components.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <ext/typeinfo>
 
#include <exception/CommonException.h>
#include <registry/AlgorithmRegistry.hpp>
 
namespace component {
 
class Value;
 
} /* namespace component */
 
namespace core {
 
template < class Derived, class ComponentType, class ComponentName >
class ElementConstraint {
public:
    static bool available ( const Derived & object, const ComponentType & element );
 
    static void valid ( const Derived & object, const ComponentType & element );
};
 
template < class Derived, class ComponentType, class ComponentCategory, class ComponentName >
class Component;
 
template < class Derived, class ComponentType, class ComponentName >
class Component < Derived, ComponentType, component::Value, ComponentName > {
    ComponentType m_data;
 
    void checkSet ( const ComponentType & element ) {
        ElementConstraint < Derived, ComponentType, ComponentName >::valid ( static_cast < const Derived & > ( * this ), element );
 
        if ( ! ElementConstraint < Derived, ComponentType, ComponentName >::available ( static_cast < const Derived & > ( * this ), element ) ) {
            std::string elementTypeName ( ext::to_string < ComponentName * > ( ) );
            elementTypeName.back ( ) = ' ';
            throw exception::CommonException ( elementTypeName + ext::to_string ( element ) + " is not available." );
        }
    }
 
protected:
    void checkState ( ) {
        checkSet ( m_data );
    }
 
public:
    Component ( ComponentType element ) : m_data ( std::move ( element ) ) {
    }
 
    bool set ( ComponentType element ) {
        checkSet ( element );
 
        if ( m_data == element ) return false;
 
        m_data = std::move ( element );
        return true;
    }
 
    ComponentType & get ( ) {
        return m_data;
    }
 
    const ComponentType & get ( ) const {
        return m_data;
    }
 
    template < class AccessedComponentName >
    requires std::is_same_v < AccessedComponentName, ComponentName >
    const Component < Derived, ComponentType, component::Value, ComponentName > & accessComponent ( ) const {
        return * this;
    }
 
    template < class AccessedComponentName >
    requires std::is_same_v < AccessedComponentName, ComponentName >
    Component < Derived, ComponentType, component::Value, ComponentName > & accessComponent ( ) {
        return * this;
    }
 
    static void registerComponent ( ) {
        std::array < std::string, 0 > emptyNames;
        std::array < std::string, 1 > elementNames = { { "element" } };
 
        ComponentType & ( Derived::* getMethod ) ( ) = & Component < Derived, ComponentType, component::Value, ComponentName >::get;
        abstraction::AlgorithmRegistry::registerMethod < ComponentName > ( getMethod, "get", emptyNames );
 
        const ComponentType & ( Derived::* constGetMethod ) ( ) const = & Component < Derived, ComponentType, component::Value, ComponentName >::get;
        abstraction::AlgorithmRegistry::registerMethod < ComponentName > ( constGetMethod, "get", emptyNames );
 
        bool ( Derived::* setMethod ) ( ComponentType ) = & Component < Derived, ComponentType, component::Value, ComponentName >::set;
        abstraction::AlgorithmRegistry::registerMethod < ComponentName > ( setMethod, "set", elementNames );
    }
 
    static void unregisterComponent ( ) {
        abstraction::AlgorithmRegistry::unregisterMethod < ComponentName, Derived & > ( "get" );
        abstraction::AlgorithmRegistry::unregisterMethod < ComponentName, const Derived & > ( "get" );
        abstraction::AlgorithmRegistry::unregisterMethod < ComponentName, Derived &, ComponentType > ( "set" );
    }
 
};
 
template < class ... Data >
class Components {
public:
    template < class T >
    requires ( ! std::is_same_v < T, T > )
    void accessComponent ( );
 
    static void registerComponent ( ) {
    }
 
    static void unregisterComponent ( ) {
    }
};
 
template < class Derived, class ComponentType, class ComponentCategory, class ComponentName, class ... Next >
class Components < Derived, ComponentType, ComponentCategory, ComponentName, Next ... > : public Component < Derived, ComponentType, ComponentCategory, ComponentName >, public Components < Derived, Next ... > {
public:
    Components ( ) = default;
 
    template < class ComponentValue, class ... NextValues >
    Components ( ComponentValue param, NextValues ... nextParams ) : Component < Derived, ComponentType, ComponentCategory, ComponentName > ( std::move ( param ) ), Components < Derived, Next ... > ( std::move ( nextParams ) ... ) {
        Component < Derived, ComponentType, ComponentCategory, ComponentName >::checkState ( );
    }
 
    using Component < Derived, ComponentType, ComponentCategory, ComponentName >::accessComponent;
 
    using Components < Derived, Next ... >::accessComponent;
 
    static void registerComponent ( ) {
        Component < Derived, ComponentType, ComponentCategory, ComponentName >::registerComponent ( );
        Components < Derived, Next ... >::registerComponent ( );
    }
 
    static void unregisterComponent ( ) {
        Component < Derived, ComponentType, ComponentCategory, ComponentName >::unregisterComponent ( );
        Components < Derived, Next ... >::unregisterComponent ( );
    }
};
 
template < class Derived, class ComponentType, class ComponentCategory, class ComponentName, class ... ComponentNames, class ... Next >
class Components < Derived, ComponentType, ComponentCategory, std::tuple < ComponentName, ComponentNames ... >, Next ... > : public Component < Derived, ComponentType, ComponentCategory, ComponentName >, public Components < Derived, ComponentType, ComponentCategory, std::tuple < ComponentNames ... >, Next ... > {
public:
    Components ( ) = default;
 
    template < class ComponentValue, class ... NextValues >
    Components ( ComponentValue param, NextValues ... nextParams ) : Component < Derived, ComponentType, ComponentCategory, ComponentName > ( std::move ( param ) ), Components < Derived, ComponentType, ComponentCategory, std::tuple < ComponentNames ... >, Next ... > ( std::move ( nextParams ) ... ) {
        Component < Derived, ComponentType, ComponentCategory, ComponentName >::checkState ( );
    }
 
    using Component < Derived, ComponentType, ComponentCategory, ComponentName >::accessComponent;
 
    using Components < Derived, ComponentType, ComponentCategory, std::tuple < ComponentNames ... >, Next ... >::accessComponent;
 
    static void registerComponent ( ) {
        Component < Derived, ComponentType, ComponentCategory, ComponentName >::registerComponent ( );
        Components < Derived, ComponentType, ComponentCategory, std::tuple < ComponentNames ... >, Next ... >::registerComponent ( );
    }
 
    static void unregisterComponent ( ) {
        Component < Derived, ComponentType, ComponentCategory, ComponentName >::unregisterComponent ( );
        Components < Derived, ComponentType, ComponentCategory, std::tuple < ComponentNames ... >, Next ... >::unregisterComponent ( );
    }
};
 
template < class Derived, class ComponentType, class ComponentCategory, class ... Next >
class Components < Derived, ComponentType, ComponentCategory, std::tuple < >, Next ... > : public Components < Derived, Next ... > {
public:
    Components ( ) = default;
 
    template < class ... NextValues >
    Components ( NextValues ... nextParams ) : Components < Derived, Next ... > ( std::move ( nextParams ) ... ) {
    }
 
    using Components < Derived, Next ... >::accessComponent;
 
    static void registerComponent ( ) {
        Components < Derived, Next ... >::registerComponent ( );
    }
 
    static void unregisterComponent ( ) {
        Components < Derived, Next ... >::unregisterComponent ( );
    }
};
 
} /* namespace core */
 
#include <core/components/setComponents.hpp>