CommonTypeName.hxx

 
//
//  Copyright PHOENIX CONTACT Electronics GmbH
//
#pragma once
#include "Arp/System/Core/Arp.h"
#include "Arp/System/Core/TypeName.hxx"
 
namespace Arp
{
 
template<class T = void>
class CommonTypeName
{
    friend class CommonTypeName<void>;
 
public: // construction/destruction
    CommonTypeName(void);
    CommonTypeName(const CommonTypeName& arg) = default;
    CommonTypeName(CommonTypeName&& arg)noexcept = default;
    CommonTypeName& operator=(const CommonTypeName& arg) = default;
    ~CommonTypeName(void) = default;
 
public: // operations
    String  GetFullName(void)const;
    String      GetNamespace(void)const;
    String      GetClassName(void)const;
 
public: // fields
    String  Value;
 
public: // operators
    operator const String& (void)const;
    operator const char*(void)const;
 
private: // construction
    CommonTypeName(const char* typeName);
};
 
// inline methods of class CommonTypeName
template<class T>
inline CommonTypeName<T>::CommonTypeName()
    : Value(TypeName<T>().GetCommonName())
{
}
 
template<class T>
inline CommonTypeName<T>::CommonTypeName(const char* typeName)
    : Value(typeName)
{
}
 
template<class T>
inline CommonTypeName<T>::operator const String& ()const
{
    return this->Value;
}
 
template<class T>
inline CommonTypeName<T>::operator const char*()const
{
    return this->Value.CStr();
}
 
template<class T>
inline String CommonTypeName<T>::GetFullName(void)const
{
    return this->Value;
}
 
template<class T>
inline String CommonTypeName<T>::GetNamespace(void)const
{
    return __Internal::TypeNameHelper::GetNamespace(this->Value, true);
}
 
template<class T>
inline String CommonTypeName<T>::GetClassName(void)const
{
    return __Internal::TypeNameHelper::GetClassName(this->Value, true);
}
 
// implementation of template specialization CommonTypeName<void>
template<>
class CommonTypeName<void>
{
private: // construction/destruction
    CommonTypeName(void) = delete;
    CommonTypeName(const CommonTypeName& arg) = delete;
    CommonTypeName& operator=(const CommonTypeName& arg) = delete;
    ~CommonTypeName(void) = delete;
 
public: // static factory operations
    template <class T2>
    static CommonTypeName<T2> GetFrom(T2& instance)
    {
        return GetFrom(&instance);
    }
 
    template <class T2>
    static CommonTypeName<T2> GetFrom(T2* pInstance)
    {
        CommonTypeName<T2> result;
        result.Value = TypeName<void>::GetFrom(pInstance).GetCommonName();
        return result;
    }
};
 
} // end of namespace Arp