base.hpp

Go to the documentation of this file.

 
#ifndef IFW_FND_DEFS_BASE_HPP_H_
#define IFW_FND_DEFS_BASE_HPP_H_
 
#include <array>
#include <iostream>
#include <thread>
#include <ctime>
#include <iomanip>
#include <variant>
 
#include <fmt/format.h>
 
 
#include <ifw/fnd/defs/logger.hpp>
 
 
namespace ifw::fnd {
 
  inline double TimeSecs() {
    LOG4CPLUS_TRACE_METHOD(Logger(), __PRETTY_FUNCTION__);
    return (std::chrono::duration_cast<std::chrono::nanoseconds>(
      std::chrono::system_clock::now().time_since_epoch()).count() / 1e9);
  }
 
  inline void SleepSecs(const float sleep_time_in_seconds) {
    LOG4CPLUS_TRACE_METHOD(Logger(), __PRETTY_FUNCTION__);
    std::chrono::duration<double> chrono_sleep_time(sleep_time_in_seconds);
    std::this_thread::sleep_for(chrono_sleep_time);
  }
 
   inline std::string IsoTime(const double time_since_epoch, const uint8_t precision) {
      LOG4CPLUS_TRACE_METHOD(Logger(), __PRETTY_FUNCTION__);
 
      // Split the time into whole seconds and fractional part
      std::time_t whole_seconds = static_cast<std::time_t>(time_since_epoch);
      double fractional_seconds = time_since_epoch - whole_seconds;
 
      // Get the base time structure (only whole seconds)
      std::tm* gmt_time = std::gmtime(&whole_seconds);
      std::ostringstream oss;
 
      // Format the date and time up to the seconds part
      oss << std::put_time(gmt_time, "%Y-%m-%dT%H:%M:");
 
      // Ensure the seconds part is always two digits
      oss << std::setw(2) << std::setfill('0') << gmt_time->tm_sec;
 
      // If no precision is required, return the base ISO time
      if (precision == 0) {
          return oss.str();
      }
 
      // Format the fractional seconds with the specified precision
      std::string fractional_str = fmt::format("{:.{}}", fractional_seconds, precision);
 
      // Skip the "0." part from the fractional part and append the rest
      oss << fractional_str.substr(1);
 
      return oss.str();
  }
 
  inline std::string IsoTimeNow(const int8_t precision) {
    LOG4CPLUS_TRACE_METHOD(Logger(), __PRETTY_FUNCTION__);
    return IsoTime(TimeSecs(), precision);
  }
 
  inline std::string ThreadName() {
      std::array<char, 32> thread_name{};
      pthread_getname_np(pthread_self(), thread_name.data(), 32);
      return std::string(thread_name.data());
  }   
 
  // template <typename... Ts>
  // std::string VariantToString(const std::variant<Ts...>& var) {
  //     return std::visit([](const auto& v) { return fmt::format("{}", v); }, var);
  // }
 
}
 
// TODO: Replace this with std::source_location + inline functions when C++23 used.
#define IFWLOC (ifw::fnd::IsoTimeNow(6) + ":" + std::string(__FILE__) + ":" +\
 std::to_string(__LINE__) + ":" + std::string(__FUNCTION__) + ":" + ifw::fnd::ThreadName())
 
// TODO: Future implementation from C++20 (or C++23):
// #include <source_location>
 
// inline std::string IfwLoc(const std::source_location& location =
//                           std::source_location::current()) {
//     auto thr_name = ifw::fnd::ThreadName();
//     if (thr_name != "") {
//       return std::string(location.file_name()) + ":" +
//              std::to_string(location.line()) + ":" +
//              std::string(location.function_name()) + ":" +
//              thr_name;
//     } else {
//             return std::string(location.file_name()) + ":" +
//              std::to_string(location.line()) + ":" +
//              std::string(location.function_name());
//     }
// }
 
namespace ifw::fnd {
 
  // template <typename... Ts>
  // std::string VariantToString(const std::variant<Ts...>& var) {
  //     return std::visit([](const auto& v) { return fmt::format("{}", v); }, var);
  // }
 
  template <typename... Ts>
  std::string VariantToString(const std::variant<Ts...>& var) {
    try {
        return std::visit([](const auto& v) { return fmt::format("{}", v); }, var);
    } catch (...) {
        return fmt::format("{}: Invalid value", IFWLOC);
    }
  }
 
}
 
#endif