ObjectWithSemantic.hpp

#pragma once
 
#include <Core/RaCore.hpp>
 
#include <cstdarg>
#include <set>
 
namespace Ra {
namespace Core {
namespace Utils {
class RA_CORE_API ObjectWithSemantic
{
  public:
    using SemanticName = std::string;
 
    using SemanticNameCollection = std::set<SemanticName>;
 
    inline explicit ObjectWithSemantic( const ObjectWithSemantic& other ) :
        m_names { other.m_names } {}
 
    virtual inline ~ObjectWithSemantic() = default;
 
    inline bool hasSemantic( const SemanticName& name ) const {
        return m_names.find( name ) != m_names.end();
    }
 
    inline const SemanticNameCollection& semantics() const { return m_names; }
 
    inline ObjectWithSemantic& operator=( const ObjectWithSemantic& other ) {
        CORE_UNUSED( other );
        CORE_ASSERT( m_names == other.m_names, "Try to assign object with different semantics" );
        return *this;
    }
    inline ObjectWithSemantic& operator=( ObjectWithSemantic&& other ) {
        CORE_UNUSED( other );
        CORE_ASSERT( m_names == other.m_names, "Try to assign object with different semantics" );
        return *this;
    }
 
    inline bool shareSemantic( const ObjectWithSemantic& other ) const {
        return std::any_of( m_names.begin(), m_names.end(), [&other]( const auto& s ) {
            return other.hasSemantic( s );
        } );
    }
 
    inline bool sameSemantics( const ObjectWithSemantic& other ) const {
        return m_names == other.m_names;
    }
 
  protected:
    template <class... SemanticNames>
    inline explicit ObjectWithSemantic( SemanticNames... names ) : m_names { names... } {}
 
    inline explicit ObjectWithSemantic( const SemanticNameCollection& otherNames ) :
        m_names { otherNames } {}
 
  private:
    SemanticNameCollection m_names;
};
 
} // namespace Utils
} // namespace Core
} // namespace Ra