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 String GetNamespace(const String& typeName, bool isCommon)
    {
        size_t pos = isCommon ? typeName.FindLastOf('.') : typeName.FindLastOf(':');
        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 = isCommon ? typeName.FindLastOf('.') : typeName.FindLastOf(':');
        if (pos == String::NPos)
        {
            return typeName;
        }
        // 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) = 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("::", "_");
    }
    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());
        }


        // strip any kind of type 'class', 'struct' or 'enum' from begin of string
        if (Value.Find("class ") == 0)
        {
            Value = Value.Substr(6);
        }
        else if (Value.Find("struct ") == 0)
        {
            Value = Value.Substr(7);
        }
        else if (Value.Find("enum ") == 0)
        {
            Value = Value.Substr(5);
        }
    }
}

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