base.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <array>
#include <cstdint>
#include <iostream>
#include <string>
#include <thread>
#include <ctime>
#include <iomanip>
#include <variant>
 
#include <fmt/format.h>
 
 
// FNDLOC must be defined BEFORE <ifw/fnd/defs/logger.hpp> is included,
// because the FND* macros in logger.hpp expand FNDLOC. FNDLOC itself
// references ifw::fnd::IsoTimeNow() and ifw::fnd::ThreadName() — we
// forward-declare them here so the macro is valid at any call site
// even though their definitions sit further down in this file.
namespace ifw::fnd {
    inline std::string IsoTimeNow(const int8_t precision);
    inline std::string ThreadName();
}
 
// TODO: Replace this with std::source_location + inline functions when C++23 used.
#define FNDLOC (ifw::fnd::IsoTimeNow(6) + ":" + std::string(__FILE__) + ":" +\
 std::to_string(__LINE__) + ":" + std::string(__FUNCTION__) + ":" + ifw::fnd::ThreadName())
 
// TODO: Temporary alias. Wider IFW ecosystem still uses IFWLOC; remove
// once every downstream module has migrated to FNDLOC.
#define IFWLOC FNDLOC
 
// Pull in the logger AFTER FNDLOC is defined, because the FND* macros
// in logger.hpp expand FNDLOC. The order matters; this is the seam
// that makes <ifw/fnd/defs/base.hpp> "the single entry point" for
// consumers who want the macros ready to use.
#include <ifw/fnd/defs/logger.hpp>
 
 
namespace ifw::fnd {

  inline double TimeSecs() {
    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) {
    FNDTRACE();
    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) {
      // 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) {
    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);
  // }
 
}
 
// FNDLOC is defined at the top of this file, before the include of
// logger.hpp, so the FND* macros can expand it correctly.
 
// 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", FNDLOC);
    }
  }
 
}