DataTagDeduction.hxx

 
//
//  Copyright Phoenix Contact GmbH & Co. KG
//
#pragma once
#include "Arp/System/Core/Arp.h"
#include "Arp/Plc/Commons/Meta/DataTag.hpp"
#include "Arp/Plc/Commons/Meta/TypeSystem/DataTypeDeduction.hxx"
#include "Arp/Plc/Commons/Meta/TypeSystem/TypeIdentifierDeduction.hxx"
 
namespace Arp { namespace Plc { namespace Commons { namespace Meta { namespace TypeSystem
{
 
class DataTagDeduction
{
public: // construction/destruction
    DataTagDeduction(const char* libraryNamespace = nullptr);
    DataTagDeduction(const DataTagDeduction& arg) = default;
    DataTagDeduction(DataTagDeduction&& arg) = default;
    DataTagDeduction& operator=(const DataTagDeduction& arg) = default;
    DataTagDeduction& operator=(DataTagDeduction&& arg) = default;
    ~DataTagDeduction(void) = default;
 
public: // static operations
    template<class T>
    DataTag operator()(const char* name, T& value)const;
 
private: // fields
    const char* libraryNamespace;
 
private: // nested class GetAdressBase
    struct GetAdressBase
    {
    protected: // typedefs/usings
        using Base = GetAdressBase;
        using ValueType = byte*;
 
    protected: // construction
        GetAdressBase(ValueType value) : Value(value) {}
        GetAdressBase(const GetAdressBase& arg) = default;
        GetAdressBase(GetAdressBase&& arg) = default;
        GetAdressBase& operator=(const GetAdressBase& arg) = default;
        GetAdressBase& operator=(GetAdressBase&& arg) = default;
        ~GetAdressBase(void) = default;
 
    public: // operators
        operator ValueType(void)const
        {
            return this->Value;
        }
 
    public: // fields
        ValueType Value = nullptr;
    };
 
private: // nested template class GetAdress
    template<class T>
    struct GetAdress : public GetAdressBase
    {
        GetAdress(T& value): Base(const_cast<ValueType>(reinterpret_cast<const byte*>(&value))) {}
    };
 
    template<class T>
    struct GetAdress<std::shared_ptr<T>> : public GetAdressBase
    {
        GetAdress(std::shared_ptr<T>& value) : Base(const_cast<ValueType>(reinterpret_cast<const byte*>(value.get()))) {}
    };
 
    template<class T>
    struct GetAdress<const std::shared_ptr<T>> : public GetAdressBase
    {
        GetAdress(const std::shared_ptr<T>& value) : Base(const_cast<ValueType>(reinterpret_cast<const byte*>(value.get()))) {}
    };
};
 
// inline methods of class DataInfoDeduction
 
template<class T>
inline DataTag DataTagDeduction::operator()(const char* name, T& value)const
{
    DataType dataType = DataTypeDeduction<T>();
    TypeIdentifierDeduction getTypeId(this->libraryNamespace);
    TypeIdentifier typeId = getTypeId(value);
 
    return DataTag(name, GetAdress<T>(value), dataType, typeId);
}
 
}}}}} // end of namespace Arp::Plc::Commons::Meta::TypeSystem