Attributes.h

#pragma once
 
#include "Name.h"
 
#include <vector>
 
namespace Cogs
{
  namespace Reflection
  {
    class Field;
    class Type;
 
    struct Attribute
    {
    public:
      TypeId getType() const { return type; }
 
      TypeId getGenericType() const { return genericType; }
 
      bool isRuntime() const { return runtime; }
 
    protected:
      Attribute(TypeId type) : Attribute(type, NoType) {}
 
      Attribute(TypeId type, TypeId genericType, bool runtime = true)
        : type(type), genericType(genericType), runtime(runtime)
      {
        std::memset(storage, 0, sizeof(storage));
      }
 
      template<typename T>
      T & get(size_t index = 0)
      {
        return reinterpret_cast<T *>(storage)[index];
      }
 
      template<typename T>
      const T & get(size_t index = 0) const
      {
        return reinterpret_cast<const T *>(storage)[index];
      }
 
      TypeId type = NoType;
      TypeId genericType = NoType;
    private:
      bool runtime;
      uint8_t storage[256 - (sizeof(TypeId) * 2) - sizeof(bool)];
    };
 
    template<typename T>
    struct RegularAttribute : public Attribute
    {
      RegularAttribute(bool runtime = true);
    };
 
    template<template<typename> class T, typename U>
    struct GenericAttribute : public Attribute
    {
      GenericAttribute(bool runtime = true);
    };
 
    struct COGSFOUNDATION_API Attributes
    {
      template<typename T>
      void add(T & attribute)
      {
        attributes.push_back(attribute);
      }
 
      template<typename T>
      Field & add(Field & field, T & attribute)
      {
        attributes.push_back(attribute);
 
        return field;
      }
 
      template<typename T>
      const T * get() const
      {
        return static_cast<const T *>(getAttribute(static_cast<T *>(nullptr)));
      }
 
    private:
      template<typename T>
      const Attribute * getAttribute(RegularAttribute<T> * a) const;
 
      template<template<typename> class T, typename U>
      const Attribute * getAttribute(GenericAttribute<T, U> * a) const;
 
      const Attribute * getAttributeByTypeId(TypeId typeId, TypeId genericTypeId = NoType) const;
 
      std::vector<Attribute> attributes;
    };
  }
}