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& typeName, const char* namespace_, const void* typeTag = nullptr);
    TypeIdentifier(const TypeIdentifier& arg) = default;
    TypeIdentifier(TypeIdentifier&& arg) = default;
    TypeIdentifier& operator=(const TypeIdentifier& arg) = default;
    TypeIdentifier& operator=(TypeIdentifier&& arg) = default;
    ~TypeIdentifier(void) = default;

public: // static properties
    static const TypeIdentifier Empty;

public: // static operations
    static TypeIdentifier Create(const String& commonTypeName, const char* libraryNamespace, void* typeTag = nullptr);

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;

    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;

public: // IRscSerializable operations
    void Serialize(RscWriter& writer)const override;
    void Deserialize(RscReader& reader)override;
    static size_t GetFieldCount(void);

private: // methods
    void    SetChangeCounterpartTypeTag(const byte* value);

private: // fields
    String      name;
    String      namespace_;
    const byte* typeTag = nullptr;
    const byte* changeCounterpartTypeTag = nullptr;

private: // static fields
    static const char namespaceSeparator = '/';
};

// inline methods of class TypeIdentifier
inline TypeIdentifier::TypeIdentifier(const String& name, const char* namespace_, const void* typeTag)
    : name(name)
      , namespace_(namespace_)
    , typeTag(reinterpret_cast<const byte*>(typeTag))
{
}

inline bool TypeIdentifier::IsEmpty()const
{
    return this->name.IsEmpty() && this->namespace_.IsEmpty();
}
inline const String& TypeIdentifier::GetName()const
{
    return this->name;
}

inline const String& TypeIdentifier::GetNamespace()const
{
    return this->namespace_;
}
inline String TypeIdentifier::GetFullName()const
{
    return this->namespace_ + namespaceSeparator + this->name;
}
inline const byte* TypeIdentifier::GetTypeTag()const
{
    return this->typeTag;
}

inline const byte* TypeIdentifier::GetChangeCounterpartTypeTag()const
{
    return this->changeCounterpartTypeTag;
}

inline size_t TypeIdentifier::GetHashValue()const
{
    // if (this->typeTag != nullptr) return reinterpret_cast<const size_t>(this->typeTag);
    // else
    std::hash<String> gethash;
    return gethash(this->namespace_) ^ gethash(this->name);
}

inline void TypeIdentifier::SwapDomain()
{
    std::swap(this->typeTag, this->changeCounterpartTypeTag);
}

inline size_t TypeIdentifier::GetFieldCount()
{
    return 4;
}

inline void TypeIdentifier::SetChangeCounterpartTypeTag(const byte* value)
{
    this->changeCounterpartTypeTag = value;
}

inline size_t TypeIdentifier::GetCacheSize()const
{
    size_t cacheSize = 0;
    cacheSize += this->name.Capacity();
    cacheSize += this->namespace_.Capacity();
    cacheSize += sizeof(this->typeTag);
    cacheSize += sizeof(this->changeCounterpartTypeTag);
    cacheSize += sizeof(this->namespaceSeparator);

    return cacheSize;
}

inline bool TypeIdentifier::operator==(const TypeIdentifier& rhs)const
{
    //if (this->typeTag != nullptr)
    //{
    //    return this->typeTag == rhs.typeTag;
    //}
    // else
    return this->name == rhs.name && this->namespace_ == rhs.namespace_;
}

inline bool TypeIdentifier::operator<(const TypeIdentifier& rhs)const
{
    // just sort using names w/o typeTag
    return (this->namespace_ == rhs.namespace_) ? (this->name < rhs.name) : (this->namespace_ < rhs.namespace_);
}

inline std::ostream& operator<<(std::ostream& os, const TypeIdentifier& typeId)
{
    os << typeId.ToString();
    return os;
}

}}}} // 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:
    typedef TypeIdentifier  argument_type;
    typedef size_t          result_type;

public:
    result_type operator()(const argument_type& key) const
    {
        return key.GetHashValue();
    }
};
}