Field.h

#pragma once
 
#include "Attributes.h"
 
namespace Cogs
{
  namespace Reflection
  {
    class Type;
 
    template<typename T, typename U>
    struct FieldWrapper : public T
    {
      template<typename ClassType, typename FieldType>
      FieldWrapper(const Name& name, FieldType ClassType::* field) : T(name, field) {}
 
      FieldWrapper & setDefault(U value);
 
      FieldWrapper & setRange(U min, U max);
 
      FieldWrapper& setStep(U step);
    };
 
    enum struct FieldFlags : uint16_t
    {
      Default = 0,
      Pointer = 0x1,
      Array = 0x2,
      NoSerialize = 0x4,
    };
 
    [[nodiscard]]
    inline FieldFlags operator|(FieldFlags lhs, FieldFlags rhs) { return static_cast<FieldFlags>(static_cast<uint16_t>(lhs) | static_cast<uint16_t>(rhs)); }
 
    [[nodiscard]]
    inline FieldFlags operator&(FieldFlags lhs, FieldFlags rhs) { return static_cast<FieldFlags>(static_cast<uint16_t>(lhs) & static_cast<uint16_t>(rhs)); }
 
    inline FieldFlags & operator|=(FieldFlags & lhs, FieldFlags rhs) { lhs = static_cast<FieldFlags>(static_cast<uint16_t>(lhs) | static_cast<uint16_t>(rhs)); return lhs; }
 
    class COGSFOUNDATION_API Field
    {
    public:
      template<typename ClassType, typename FieldType>
      Field(const Name& name, FieldType ClassType::* field);
 
      template<typename ClassType, typename FieldType>
      static FieldWrapper<Field, FieldType> create(const Name& name, FieldType ClassType::* field);
 
      Field(const Field & other) = default;
 
      Field(Field && other) noexcept = default;
 
      Field & operator=(const Field & other) = default;
 
      Field & operator=(Field && other) noexcept = default;
 
      template<typename FieldValueType>
      [[nodiscard]]
      FieldValueType * getPtr(void * container) const
      {
        if constexpr (!std::is_array<FieldValueType>()) {
          assert(sizeof(FieldValueType) <= byteSize && "Pointer overflows field size.");
        }
 
        return static_cast<FieldValueType*>(static_cast<void*>(static_cast<char*>(container) + offset));
      }
 
      template<typename FieldValueType>
      [[nodiscard]]
      const FieldValueType * getPtr(const void * container) const
      {
        return static_cast<const FieldValueType*>(static_cast<const void*>(static_cast<const char*>(container) + offset));
      }
 
      [[nodiscard]]
      const Name & getName() const { return name; }
 
      [[nodiscard]]
      TypeId getTypeId() const { return typeId; }
 
      [[nodiscard]]
      size_t getOffset() const { return offset; }
 
      [[nodiscard]]
      FieldFlags getFlags() const { return fieldFlags; }
 
      [[nodiscard]]
      bool isSet(FieldFlags flag) const { return (fieldFlags & flag) == flag; }
 
      [[nodiscard]]
      size_t getDimensions() const { return arrayDimensions; }
 
      Field& setSerialize(bool serialize)
      {
        if (serialize) {
          unsetFlag(FieldFlags::NoSerialize);
        }
        else {
          fieldFlags |= FieldFlags::NoSerialize;
        }
 
        return *this;
      }
 
      template<typename T>
      Field & add(T attribute)
      {
#if defined( EMSCRIPTEN )
        // Only add runtime attributes for Cogs.js, skip code-gen attributes.
        if (!attribute.isRuntime())
          return *this;
#endif
        return attributes.add(*this, attribute);
      }
 
      template<typename T>
      [[nodiscard]]
      const T * get() const
      {
        return attributes.get<T>();
      }
 
    private:
      void unsetFlag(FieldFlags flag) { this->fieldFlags = this->fieldFlags & static_cast<FieldFlags>(~uint32_t(flag)); }
 
      Attributes attributes;
 
      FieldFlags fieldFlags = FieldFlags::Default;
 
      Name name;
 
      size_t offset;
 
      size_t byteSize;
 
      size_t arrayDimensions = 0;
 
      TypeId typeId;
 
    };
  }
}
 
#include "Field.inl"