Field.inl

#include "TypeDatabase.h"
#include "Field.h"
 
#include "../ComponentModel/Attributes.h"
 
namespace Cogs
{
  namespace Reflection
  {
    template<typename ClassType, typename FieldType>
    Field::Field(const Name& name, FieldType ClassType::* field) :
      name(name),
      offset(memberOffset(field)),
      byteSize(sizeof(FieldType)),
      typeId(TypeDatabase::getType<FieldType>().getTypeId())
    {
      if constexpr (std::is_array<FieldType>{}) {
        fieldFlags |= FieldFlags::Array;
        arrayDimensions = std::extent<FieldType>{};
      } else if constexpr (std::is_pointer<FieldType>{}) {
        fieldFlags |= FieldFlags::Pointer;
      } else if constexpr (std::is_enum<FieldType>{}) {
        // Enum fields must be same size as int as Cogs bridge copies 4 bytes.
        static_assert(sizeof(FieldType) == sizeof(int), "Only int compatible enums supported.");
      }
    }
 
    template<typename ClassType, typename FieldType>
    FieldWrapper<Field, FieldType> Field::create(const Name& name, FieldType ClassType::* field)
    {
      return FieldWrapper<Field, FieldType>(name, field);
    }
 
    template<typename T, typename U>
    FieldWrapper<T, U> & FieldWrapper<T, U>::setDefault(U value)
    {
      Field::add(ComponentModel::DefaultValueAttribute<U>(value));
 
      return *this;
    }
 
    template<typename T, typename U>
    FieldWrapper<T, U> & FieldWrapper<T, U>::setRange(U min, U max)
    {
      Field::add(ComponentModel::RangeAttribute<U>(min, max));
 
      return *this;
    }
 
    template<typename T, typename U>
    FieldWrapper<T, U>& FieldWrapper<T, U>::setStep(U step)
    {
      Field::add(ComponentModel::StepSizeAttribute<U>(step));
 
      return *this;
    }
  }
}