TypeIdentifier.hpp

 
//
//  Copyright PHOENIX CONTACT Electronics GmbH
//
#pragma once
#include "Arp/System/Core/Arp.h"
#include "Arp/System/Rsc/Services/IRscSerializable.hpp"
#include "Arp/System/Rsc/Services/RscReader.hpp"
#include "Arp/System/Rsc/Services/RscString.hxx"
#include "Arp/System/Rsc/Services/RscWriter.hpp"
namespace Arp { namespace Plc { namespace Commons { namespace Meta
{
 
using namespace Arp::System::Rsc::Services;
 
// forwards
class DataTag;
 
class TypeIdentifier : public IRscSerializable
{
    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) = default;
    TypeIdentifier& operator=(const TypeIdentifier& arg) = default;
    TypeIdentifier& operator=(TypeIdentifier&& arg) = default;
    ~TypeIdentifier(void) override = 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: // IRscSerializable operations
    void Serialize(RscWriter& writer)const override;
    void Deserialize(RscReader& reader)override;
    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
 
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();
    }
};
}