TypeIdentifierDeduction.hxx

 
//
//  Copyright PHOENIX CONTACT Electronics GmbH
//
#pragma once
#include "Arp/System/Core/Arp.h"
#include "Arp/System/Core/CommonTypeName.hxx"
#include "Arp/System/Core/TypeDeduction.hxx"
#include "Arp/Plc/Commons/DataTypeEnum.hpp"
#include "Arp/Plc/Commons/Meta/TypeIdentifier.hpp"
#include "Arp/Plc/Commons/Meta/TypeSystem/DataTypeDeduction.hxx"
#include <type_traits>
namespace Arp { namespace Plc { namespace Commons { namespace Meta { namespace TypeSystem
{
 
using namespace Arp::Plc::Commons;
 
class TypeIdentifierDeduction
{
public: // construction/destruction
    TypeIdentifierDeduction(const char* libraryNamespace);
    TypeIdentifierDeduction(const TypeIdentifierDeduction& arg) = default;
    TypeIdentifierDeduction(TypeIdentifierDeduction&& arg) = default;
    TypeIdentifierDeduction& operator=(const TypeIdentifierDeduction& arg) = default;
    TypeIdentifierDeduction& operator=(TypeIdentifierDeduction&& arg) = default;
    ~TypeIdentifierDeduction(void) = default;
 
public: // static operations
    template<class T>
    TypeIdentifier operator()(const T& value)const;
 
private: // fields
    const char* libraryNamespace;
};
 
// inline methods of class TypeIdentifierDeduction
inline TypeIdentifierDeduction::TypeIdentifierDeduction(const char* libraryNamespace)
    : libraryNamespace(libraryNamespace)
{
}
 
template<class T>
inline TypeIdentifier TypeIdentifierDeduction::operator()(const T& value)const
{
    DataTypeEnum dataType = static_cast<DataType>(DataTypeDeduction<T>());
    if (!dataType.IsComplex(true))
    {
        return TypeIdentifier::Empty;
    }
    if (dataType == DataType::Program)
    {
        return TypeIdentifier::Create(CommonTypeName<void>::GetFrom(value), this->libraryNamespace);
    }
    // else must deduce typeId
    String typeName = CommonTypeName <
                      typename std::remove_all_extents <
                      typename std::remove_pointer <
                      typename remove_shared_ptr <
                      typename std::remove_const<T>::type >::type >::type >::type > ();
 
    return TypeIdentifier::Create(typeName, this->libraryNamespace);
}
 
}}}}} // end of namespace Arp::Plc::Commons::Meta::TypeSystem