TypeName.hxx

 
//
//  Copyright PHOENIX CONTACT Electronics GmbH
//
#pragma once
#include "Arp/System/Core/Arp.h"
#include "Arp/System/Core/Exception.hpp"
#include "Arp/System/Core/RuntimeTypeInfo.hpp"
#include <typeinfo>
 
namespace Arp
{
 
 
namespace __Internal
{
 
struct TypeNameHelper
{
    static size_t FindNamespaceEndPosition(const String& typeName, bool isCommon)
    {
        char separator = isCommon ? '.' : ':';
 
        size_t lastPos = typeName.FindFirstOf('<'); // template class?
        if (lastPos == String::NPos)
        {
            return typeName.FindLastOf(separator);
        }
        // else
        return typeName.FindLastOf(separator, lastPos);
    }
 
    static String GetNamespace(const String& typeName, bool isCommon)
    {
        size_t pos = FindNamespaceEndPosition(typeName, isCommon);
        if (pos == String::NPos)
        {
            return String::Empty;
        }
        // else
        return isCommon ? typeName.Substr(0, pos) : typeName.Substr(0, pos - 1);
    }
 
    static String GetClassName(const String& typeName, bool isCommon)
    {
        size_t pos = FindNamespaceEndPosition(typeName, isCommon);
        if (pos == String::NPos)
        {
            return typeName; // no namespace present
        }
        // else
        return typeName.Substr(pos + 1);
    }
};
} // end of namespace Internal
template<class T = void>
class TypeName
{
    friend class TypeName<void>;
 
public: // construction/destruction
    TypeName(void);
    TypeName(const TypeName& arg) = default;
    TypeName(TypeName&& arg)noexcept = default;
    TypeName& operator=(const TypeName& arg) = default;
    ~TypeName(void) = default;
 
public: // operations
    String      GetCommonName(void)const;
    String      GetSafeName(void)const;
    String      GetNamespace(void)const;
    String      GetClassName(void)const;
 
public: // operators
    operator const String& (void)const;
    operator const char*(void)const;
    bool operator==(const TypeName& other);
    bool operator!=(const TypeName& other);
 
private: // construction
    TypeName(const char* typeName, bool isCommon = false);
 
private: // methods
    void AssignTypeName(const char* typeName, bool isCommon);
 
public: // fields
    String  Value;
 
private: // fields
    bool    isCommon = false;
};
 
// inline methods of class TypeName<T>
 
template<class T>
inline TypeName<T>::TypeName()
{
    this->AssignTypeName(typeid(T).name(), false);
}
 
template<class T>
inline TypeName<T>::TypeName(const char* typeName, bool isCommonArg)
{
    this->AssignTypeName(typeName, isCommonArg);
}
 
template<class T>
inline String TypeName<T>::GetCommonName(void)const
{
    String result(this->Value);
    result.ReplaceAll("::", ".");
    return result;
}
 
template<class T>
inline String TypeName<T>::GetSafeName(void)const
{
    String result(this->Value);
 
    if (this->isCommon)
    {
        result.ReplaceAll(".", "_");
    }
    else
    {
        result.ReplaceAll("::", "_");
    }
    result.ReplaceAll("<", "$");
    result.ReplaceAll(">", "$");
 
    return result;
}
 
template<class T>
inline String TypeName<T>::GetNamespace(void)const
{
    return __Internal::TypeNameHelper::GetNamespace(this->Value, this->isCommon);
}
 
template<class T>
inline String TypeName<T>::GetClassName(void)const
{
    return __Internal::TypeNameHelper::GetClassName(this->Value, this->isCommon);
}
 
template<class T>
inline void TypeName<T>::AssignTypeName(const char* typeName, bool isCommonArg)
{
    this->isCommon = isCommonArg;
 
    if (this->isCommon)
    {
        this->Value = typeName; // name was demangled yet
    }
    else
    {
        this->Value = RuntimeTypeInfo::DemangleSymbol(typeName);
        if (this->Value.IsEmpty())
        {
            throw Exception("Demangling of type name '{0}' failed.", typeid(T).name());
        }
 
 
        // remove any kind of type 'class', 'struct' or 'enum' from begin of string
        Value.ReplaceAll("class ", String::Empty);
        Value.ReplaceAll("struct ", String::Empty);
        Value.ReplaceAll("enum ", String::Empty);
    }
}
 
template<class T>
inline TypeName<T>::operator const String& ()const
{
    return this->Value;
}
 
template<class T>
inline TypeName<T>::operator const char*()const
{
    return this->Value.CStr();
}
 
template<class T>
inline bool TypeName<T>::operator==(const TypeName& other)
{
    return this->Value == other.Value;
}
 
template<class T>
inline bool TypeName<T>::operator!=(const TypeName& other)
{
    return !(*this == other);
}
 
template<class T>
inline std::ostream& operator<<(std::ostream& os, const TypeName<T>& typeName)
{
    os << typeName.Value;
    return os;
}
 
// implementation of template specialization TypeName<void>
 
template<>
class TypeName<void>
{
private: // construction/destruction
    TypeName(void) = delete;
    TypeName(const TypeName& arg) = delete;
    TypeName& operator=(const TypeName& arg) = delete;
    ~TypeName(void) = delete;
 
public: // static factory operations
    template <class T2>
    static TypeName<T2> GetFrom(T2& instance)
    {
        return GetFrom(&instance);
    }
 
    template <class T2>
    static TypeName<T2> GetFrom(T2* pInstance)
    {
        const char* pResult = typeid(*pInstance).name();
        pInstance = nullptr;
        return TypeName<T2>(pResult);
    }
 
    static String GetNamespace(const String& typeName, bool isCommon)
    {
        return __Internal::TypeNameHelper::GetNamespace(typeName, isCommon);
    }
 
    static String GetClassName(const String& typeName, bool isCommon)
    {
        return __Internal::TypeNameHelper::GetClassName(typeName, isCommon);
    }
};
 
} // end of namespace Arp