setComponents.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <ext/algorithm>
#include <ext/typeinfo>
 
#include <exception/CommonException.h>
#include <registry/AlgorithmRegistry.hpp>
 
namespace component {
 
class Set;
 
} /* namespace component */
 
namespace core {
 
template < class Derived, class ComponentType, class ComponentName >
class SetConstraint {
public:
    static bool used ( const Derived & object, const ComponentType & element );
 
    static bool available ( const Derived & object, const ComponentType & element );
 
    static void valid ( const Derived & object, const ComponentType & element );
};
 
template < class Derived, class SetComponentType, class ComponentType, class ComponentName >
class SetComponent {
    SetComponentType m_data;
 
    void checkAdd ( const ComponentType & element ) {
        SetConstraint < Derived, ComponentType, ComponentName >::valid ( static_cast < const Derived & > ( * this ), element );
 
        if ( ! SetConstraint < Derived, ComponentType, ComponentName >::available ( static_cast < const Derived & > ( * this ), element ) ) {
            std::string elementTypeName ( ext::to_string < ComponentName > ( ) );
            throw exception::CommonException ( elementTypeName + " element " + ext::to_string ( element ) + " is not available." );
        }
    }
 
    void checkRemove ( const ComponentType & element ) {
        if ( SetConstraint < Derived, ComponentType, ComponentName >::used ( static_cast < const Derived & > ( * this ), element ) ) {
            std::string elementTypeName ( ext::to_string < ComponentName > ( ) );
            throw exception::CommonException ( elementTypeName + "element " + ext::to_string ( element ) + " is used." );
        }
    }
 
protected:
    void checkState ( ) {
        for ( const ComponentType & element : m_data )
            checkAdd ( element );
    }
 
public:
    SetComponent ( SetComponentType data ) : m_data ( std::move ( data ) ) {
    }
 
    SetComponent ( ) = default;
 
    bool add ( ComponentType element ) {
        checkAdd ( element );
        return m_data.insert ( std::move ( element ) ).second;
    }
 
    Derived & add ( SetComponentType data ) {
        for ( ComponentType element : ext::make_mover ( data ) )
            add ( std::move ( element ) );
        return static_cast < Derived & > ( * this );
    }
 
    Derived & set ( SetComponentType data ) {
        auto removeCheckLambda = [ this ] ( const auto & value ) {
            this->checkRemove ( value );
        };
 
        auto addCheckLambda = [ this ] ( const auto & value ) {
            this->checkAdd ( value );
        };
 
        ext::set_symmetric_difference ( m_data.begin ( ), m_data.end ( ), data.begin ( ), data.end ( ), ext::make_callback_iterator ( removeCheckLambda ), ext::make_callback_iterator ( addCheckLambda ) );
 
        m_data = std::move ( data );
        return static_cast < Derived & > ( * this );
    }
 
    SetComponentType & get ( ) {
        return m_data;
    }
 
    const SetComponentType & get ( ) const {
        return m_data;
    }
 
    bool remove ( const ComponentType & element ) {
        checkRemove ( element );
        return m_data.erase ( element );
    }
 
    Derived & remove ( const SetComponentType & data ) {
        for ( const ComponentType & element : data )
            remove ( element );
        return static_cast < Derived & > ( * this );
    }
 
    bool empty ( ) const {
        return m_data.empty ( );
    }
 
    template < class AccessedComponentName >
    requires std::is_same_v < AccessedComponentName, ComponentName >
    const Component < Derived, SetComponentType, component::Set, ComponentName > & accessComponent ( ) const {
        return static_cast < const Component < Derived, SetComponentType, component::Set, ComponentName > & > ( * this );
    }
 
    template < class AccessedComponentName >
    requires std::is_same_v < AccessedComponentName, ComponentName >
    Component < Derived, SetComponentType, component::Set, ComponentName > & accessComponent ( ) {
        return static_cast < Component < Derived, SetComponentType, component::Set, ComponentName > & > ( * this );
    }
 
};
 
template < class Derived, class ComponentType, class ComponentName >
class Component < Derived, ComponentType, component::Set, ComponentName > : public SetComponent < Derived, ComponentType, typename ComponentType::value_type, ComponentName > {
public:
    Component ( ComponentType data ) : SetComponent < Derived, ComponentType, typename ComponentType::value_type, ComponentName > ( std::move ( data ) ) {
    }
 
    Component ( ) = default;
 
    static void registerComponent ( ) {
        std::array < std::string, 0 > emptyNames;
        std::array < std::string, 1 > elementNames = { { "element" } };
        std::array < std::string, 1 > dataNames = { { "data" } };
 
        ComponentType & ( Derived::* getMethod ) ( ) = & SetComponent < Derived, ComponentType, typename ComponentType::value_type, ComponentName >::get;
        abstraction::AlgorithmRegistry::registerMethod < ComponentName > ( getMethod, "get", emptyNames );
 
        const ComponentType & ( Derived::* constGetMethod ) ( ) const = & SetComponent < Derived, ComponentType, typename ComponentType::value_type, ComponentName >::get;
        abstraction::AlgorithmRegistry::registerMethod < ComponentName > ( constGetMethod, "get", emptyNames );
 
        Derived & ( Derived::* setMethod ) ( ComponentType ) = & SetComponent < Derived, ComponentType, typename ComponentType::value_type, ComponentName >::set;
        abstraction::AlgorithmRegistry::registerMethod < ComponentName > ( setMethod, "set", dataNames );
 
        bool ( Derived::* addElement ) ( typename ComponentType::value_type ) = & SetComponent < Derived, ComponentType, typename ComponentType::value_type, ComponentName >::add;
        abstraction::AlgorithmRegistry::registerMethod < ComponentName > ( addElement, "add", elementNames );
 
        Derived & ( Derived::* addSet ) ( ComponentType ) = & SetComponent < Derived, ComponentType, typename ComponentType::value_type, ComponentName >::add;
        abstraction::AlgorithmRegistry::registerMethod < ComponentName > ( addSet, "add", dataNames );
 
        bool ( Derived::* removeElement ) ( const typename ComponentType::value_type & ) = & SetComponent < Derived, ComponentType, typename ComponentType::value_type, ComponentName >::remove;
        abstraction::AlgorithmRegistry::registerMethod < ComponentName > ( removeElement, "remove", elementNames );
 
        Derived & ( Derived::* removeSet ) ( const ComponentType & ) = & SetComponent < Derived, ComponentType, typename ComponentType::value_type, ComponentName >::remove;
        abstraction::AlgorithmRegistry::registerMethod < ComponentName > ( removeSet, "remove", dataNames );
 
        bool ( Derived::* emptyMethod ) ( ) const = & SetComponent < Derived, ComponentType, typename ComponentType::value_type, ComponentName >::empty;
        abstraction::AlgorithmRegistry::registerMethod < ComponentName > ( emptyMethod, "empty", emptyNames );
    }
 
    static void unregisterComponent ( ) {
        abstraction::AlgorithmRegistry::unregisterMethod < ComponentName, Derived & > ( "get" );
        abstraction::AlgorithmRegistry::unregisterMethod < ComponentName, const Derived & > ( "get" );
        abstraction::AlgorithmRegistry::unregisterMethod < ComponentName, Derived &, ComponentType > ( "set" );
        abstraction::AlgorithmRegistry::unregisterMethod < ComponentName, Derived, typename ComponentType::value_type > ( "add" );
        abstraction::AlgorithmRegistry::unregisterMethod < ComponentName, Derived, ComponentType > ( "add" );
        abstraction::AlgorithmRegistry::unregisterMethod < ComponentName, Derived, const typename ComponentType::value_type & > ( "remove" );
        abstraction::AlgorithmRegistry::unregisterMethod < ComponentName, Derived, const ComponentType & > ( "remove" );
        abstraction::AlgorithmRegistry::unregisterMethod < ComponentName, const Derived & > ( "empty" );
    }
};
 
} /* namespace core */