TypeIdentifier.hpp

 
//
//  Copyright Phoenix Contact GmbH & Co. KG
//
#pragma once
#include "Arp/Base/Core/Arp.hpp"
#include "Arp/Base/Rsc/Commons/Rsc.hpp"
#include "Arp/Base/Rsc/Commons/RscSerializable.hpp"
#include "Arp/Base/Rsc/Commons/RscString.hxx"
 
namespace Arp { namespace Plc { namespace Commons { namespace Meta
{
 
using namespace Arp::Base::Rsc::Commons;
using namespace Arp::Base::Rsc::Commons::Services;
 
// forwards
class DataTag;
 
class TypeIdentifier : public RscSerializable
{
    friend class DataTag;
 
public: // typedefs
 
public: // construction/destruction
    TypeIdentifier(void) = default;
    TypeIdentifier(const String& name, const char* namespace_, const void* typeTag = nullptr);
    TypeIdentifier(const String& name, const char* namespace_, const void* typeTag, const void* namespaceTag);
    TypeIdentifier(const TypeIdentifier& arg) = default;
    TypeIdentifier(TypeIdentifier&& arg) noexcept = default;
    TypeIdentifier& operator=(const TypeIdentifier& arg) = default;
    TypeIdentifier& operator=(TypeIdentifier&& arg) noexcept = default;
    ~TypeIdentifier(void) noexcept = default;
 
public: // static properties
    static const TypeIdentifier Empty;
 
public: // static operations
    static TypeIdentifier Create(const String& commonTypeName, const char* libraryNamespace, void* typeTag = nullptr);
    static TypeIdentifier Create(const String& commonTypeName, const char* libraryNamespace, void* typeTag, const void* namespaceTag);
 
    static size_t GetMaxTypenameLength();
    static size_t GetMaxNamespaceLength();
 
public: // operators
    bool operator==(const TypeIdentifier& rhs)const;
    bool operator<(const TypeIdentifier& rhs)const;
 
public: // setter/getter operations
    bool            IsEmpty(void)const;
    const String&   GetName(void)const;
    const String&   GetNamespace(void)const;
    String          GetFullName(void)const;
    const byte*     GetTypeTag(void)const;
    ARP_DEPRECATED("CounterpartTypeTag is not used any more. It will be removed.")
    const byte*     GetChangeCounterpartTypeTag(void)const;
    size_t          GetHashValue(void)const;
    size_t          GetCacheSize()const;
 
public: // operations
    String          ToString(void)const;
    void            SwapDomain(void);
    TypeIdentifier CreateUniqueComponentTypeIdentifier() const;
    bool AreFullNamesEqual(const TypeIdentifier& other) const;
 
public: // RscSerializable operations
    void Serialize(RscWriter& writer)const;
    void Deserialize(RscReader& reader);
    static size_t GetFieldCount(void);
 
private: // methods
    ARP_DEPRECATED("CounterpartTypeTag is not used any more. It will be removed.")
    void    SetChangeCounterpartTypeTag(const byte* value);
 
private: // fields
    String      name;
    String      namespace_;
    const byte* typeTag = nullptr;
    const byte* namespaceTag = nullptr;
 
private: // static fields
    static const char namespaceSeparator = '/';
};
 
std::ostream& operator<<(std::ostream& os, const TypeIdentifier& typeId);
 
}}}} // end of namespace Arp::Plc::Meta
 
// template specialization of TypeIdentifier formatter
template<> struct fmt::formatter<Arp::Plc::Commons::Meta::TypeIdentifier> : public fmt::ostream_formatter {};
 
namespace std
{
 
// hash functor for TypeIdentifier
template<>
struct hash<Arp::Plc::Commons::Meta::TypeIdentifier>
{
private: // usings
    using TypeIdentifier = Arp::Plc::Commons::Meta::TypeIdentifier;
 
public:
    using argument_type =  TypeIdentifier;
    using result_type = size_t;
 
public:
    result_type operator()(const argument_type& key) const
    {
        return key.GetHashValue();
    }
};
}