EnumDictionaryBase.hxx

 
//
//  Copyright Phoenix Contact GmbH & Co. KG
//
#pragma once
#include "Arp/Base/Core/Arp.hpp"
#include <map>
 
namespace Arp { namespace Base { namespace Core
{
 
template<class T>
class EnumDictionaryBase
{
    static_assert(std::is_enum_v<T>);
    static_assert(std::is_integral_v<std::underlying_type_t<T>>);
 
protected: // usings
    using Fields = std::map<T, const char*>; 
    using InitializerList = std::initializer_list<typename Fields::value_type>; 
    using U = typename std::underlying_type<T>::type; 
 
protected: // construction/destruction
    explicit EnumDictionaryBase(const InitializerList& fields);
    EnumDictionaryBase(const char* invalidValueString, const InitializerList& fields);
    EnumDictionaryBase(const EnumDictionaryBase& arg);
    EnumDictionaryBase(EnumDictionaryBase&& arg)noexcept;
    EnumDictionaryBase& operator=(const EnumDictionaryBase& arg);
    EnumDictionaryBase& operator=(EnumDictionaryBase&& arg)noexcept;
    ~EnumDictionaryBase(void);
 
protected: // string conversion operations
    bool TryGetEnumStringInternal(T value, const char*& pResult)const;
    bool TryGetEnumValueInternal(const char* fieldName, T& value)const;
 
protected: // fields
    Fields fields;
    String invalidValueString;
 
protected: // static/const fields
    static const T zeroValue = static_cast<T>(0);
};
 
// inline methods of class EnumDictionaryBase<T>
 
template<class T>
inline EnumDictionaryBase<T>::EnumDictionaryBase(const InitializerList& fields)
    : fields(fields)
{
}
 
template<class T>
inline EnumDictionaryBase<T>::EnumDictionaryBase(const char* invalidValueString, const InitializerList& fields)
    : fields(fields)
    , invalidValueString(invalidValueString)
{
}
 
template<class T>
inline EnumDictionaryBase<T>::EnumDictionaryBase(const EnumDictionaryBase& arg) = default;
 
template<class T>
inline EnumDictionaryBase<T>::EnumDictionaryBase(EnumDictionaryBase&& arg)noexcept = default;
 
template<class T>
inline EnumDictionaryBase<T>& EnumDictionaryBase<T>::operator=(const EnumDictionaryBase& arg) = default;
 
template<class T>
inline EnumDictionaryBase<T>& EnumDictionaryBase<T>::operator=(EnumDictionaryBase&& arg)noexcept = default;
 
template<class T>
inline EnumDictionaryBase<T>::~EnumDictionaryBase() = default;
 
template<class T>
inline bool EnumDictionaryBase<T>::TryGetEnumStringInternal(T value, const char*& pResult)const
{
    auto it = this->fields.find(value);
    if (it == this->fields.end())
    {
        pResult = nullptr;
        return false;
    }
    // else
    pResult = it->second;
    return true;
}
 
template<class T>
inline bool EnumDictionaryBase<T>::TryGetEnumValueInternal(const char* fieldName, T& value)const
{
    auto it = std::find_if(this->fields.begin(), this->fields.end(), [fieldName](const auto & each)
    {
        return ::strcmp(each.second, fieldName) == 0;
    });
    if (it == this->fields.end())
    {
        value = T{};
        return false;
    }
    // else
    value = it->first;
    return true;
}
 
}}} // end of namespace Arp::Base::Core
 
namespace Arp {
using Arp::Base::Core::EnumDictionaryBase;
}