Name.h

#pragma once
 
#include "../StringView.h"
 
#include <type_traits>
 
 
namespace Cogs::Reflection::detail {
  template<typename>
  constexpr bool always_false = false;
}
 
template<typename T>
Cogs::StringView getNameImpl(T *)
{
  static_assert(Cogs::Reflection::detail::always_false<T> && "No name specialization provided. Implement getName<Type>() or getNameImpl(Type *).");
  return Cogs::StringView();
}
 
template<typename T>
Cogs::StringView getName()
{
  return getNameImpl(static_cast<typename std::remove_extent_t<typename std::remove_pointer_t<T>>*>(nullptr));
}
 
template<> inline Cogs::StringView getName<void *>() { return "pointer"; }
 
namespace Cogs
{
  namespace Reflection
  {
    using CreateInstance = void* (*)();
 
    using ConstructInstance = void* (*)(void*);
 
    using DestroyInstance = void (*)(void*);
 
    using DestructInstance = void (*)(void *);
 
    using TypeId = uint16_t;
 
    constexpr TypeId NoType = 0xFFFF;
 
    using FieldId = uint16_t;
 
    using MethodId = uint16_t;
 
    constexpr FieldId NoField = 0xFFFF;
 
    constexpr MethodId NoMethod = 0xFFFF;
 
    struct COGSFOUNDATION_API Name
    {
      Name() = default;
 
      Name(const StringView & name) : name(name), id(Cogs::hash(name)) {}
 
      Name(const char * name) : Name(StringView(name)) {}
 
      Name(const std::string & name) : Name(StringView(name)) {}
 
      Name(const Name & other) = default;
 
      Name(Name && other) noexcept = default;
 
      Name & operator=(const Name & other) = default;
 
      Name & operator=(Name && other) noexcept = default;
 
      [[nodiscard]]
      bool operator==(const Name & other) const
      {
        return this->id == other.id;
      }
 
      [[nodiscard]]
      const std::string & getName() const { return name; }
 
      [[nodiscard]]
      const char * c_str() const { return name.c_str(); }
 
      [[nodiscard]]
      size_t getId() const { return id; }
 
    private:
      std::string name;
      size_t id = Cogs::hash();
    };
  }
}