NamedType.h

#pragma once
 
#include <type_traits>
 
namespace knowCore
{
  struct NamedTypeOptions
  {
    enum {
      None = 0,
      ExplicitConversion = 1, 
      Default = None,
    };
  };
  template<typename _T_, typename _Tag_, int _Options_ = NamedTypeOptions::Default>
  class NamedType
  {
  public:
    explicit NamedType(const _T_& _value) : m_value(_value) {}
    template<int _Options_2_ = _Options_, typename = std::enable_if_t<(_Options_2_ & NamedTypeOptions::ExplicitConversion) == 0>>
    operator _T_() const
    {
      return m_value;
    }
    _T_ value() const {
      return m_value;
    }
  private:
    _T_ m_value;
  };
}
 
#include "Formatter.h"
 
template<typename _T_, typename _Tag_, int _Options_>
struct fmt::formatter<knowCore::NamedType<_T_, _Tag_, _Options_>> : public fmt::formatter<_T_> {
  using super = fmt::formatter<_T_>;
  template <typename FormatContext>
  auto format(const knowCore::NamedType<_T_, _Tag_, _Options_>& p, FormatContext& ctx) -> decltype(ctx.out())
  {
    return super::format(p, ctx);
  }
};
 
namespace std
{
  // NamedTypes are trivial is their base type is trivial
  template<typename _T_, typename _Tag_, int _Options_>
  struct is_trivial<knowCore::NamedType<_T_, _Tag_, _Options_>>
  : public std::is_trivial<_T_>
  {
  };
}