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) = default;
    CommonTypeName& operator=(const CommonTypeName& arg) = default;
    ~CommonTypeName(void) = default;

public: // operations
    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>::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