value.hpp

Go to the documentation of this file.

 
#ifndef CAMCOM_COMMON_VALUE_HPP
#define CAMCOM_COMMON_VALUE_HPP
 
#include <variant>
#include <string>
#include <fmt/format.h>
 
namespace camcom::common {
    using Value = std::variant<int, float, double, std::string, bool>;
 
    inline std::string_view ValueTypeString(const Value &v) noexcept {
      return std::visit([](const auto &x) -> std::string_view {
          using T = std::decay_t<decltype(x)>;
          if constexpr (std::is_same_v<T, int>)         { return "int"; }
          else if constexpr (std::is_same_v<T, float>)  { return "float"; }
          else if constexpr (std::is_same_v<T, double>) { return "double"; }
          else if constexpr (std::is_same_v<T, std::string>) { return "string"; }
          else if constexpr (std::is_same_v<T, bool>)   { return "bool"; }
          else                                          { return "unknown"; }
      }, v);
  }
 
} // namespace camcom::common
 
// ---- fmt support for camcom::common::Value ----
namespace fmt {
 
   template <>
   struct formatter<camcom::common::Value> {
      // store any specs after the colon, e.g. ".3f", ">10", etc.
      std::string specs;
 
      // parse optional format specs for the held type
      constexpr auto parse(format_parse_context& ctx) {
         auto it = ctx.begin();
         const auto end = ctx.end();
         if (it != end && *it != '}') {
               const auto start = it;
               do { ++it; } while (it != end && *it != '}');
               specs.assign(start, it);  // everything between ':' and '}'
         }
         return it; // return past-the-end of the parsed range
      }
 
      template <typename FormatContext>
      auto format(const camcom::common::Value& v, FormatContext& ctx) const
         -> typename FormatContext::iterator
      {
         return std::visit([&](const auto& x) -> typename FormatContext::iterator {
               if (specs.empty()) {
                  // no specs -> just "{}"
                  return fmt::format_to(ctx.out(), "{}", x);
               } else {
                  // build "{:<specs>}" dynamically; must use fmt::runtime
                  std::string f;
                  f.reserve(specs.size() + 3);
                  f += "{:";
                  f += specs;
                  f += '}';
                  return fmt::format_to(ctx.out(), fmt::runtime(f), x);
               }
         }, v);
      }
   };
 
} // namespace fmt
 
#endif // CAMCOM_COMMON_VALUE_HPP