EnumDictionaryBase.hxx

 
//
//  Copyright PHOENIX CONTACT Electronics GmbH
//
#pragma once
#include "Arp/System/Core/Arp.h"
#include <map>
 
namespace Arp
{
 
template<class T>
class EnumDictionaryBase
{
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;
 
public: // construction/destruction
    explicit EnumDictionaryBase(const InitializerList& fields);
    EnumDictionaryBase(const char* invalidValueString, const InitializerList& fields);
 
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 EnumDictionary<T>
template<class T>
EnumDictionaryBase<T>::EnumDictionaryBase(const InitializerList& fields)
    : fields(fields)
{
}
 
template<class T>
EnumDictionaryBase<T>::EnumDictionaryBase(const char* invalidValueString, const InitializerList& fields)
    : fields(fields)
    , invalidValueString(invalidValueString)
{
}
 
template<class T>
inline bool EnumDictionaryBase<T>::TryGetEnumStringInternal(T value, const char*& pResult)const
{
    pResult = nullptr;
    typename Fields::const_iterator i = this->fields.find(value);
    if (i == this->fields.end())
    {
        return false;
    }
    // else
    pResult = i->second;
    return true;
}
 
template<class T>
inline bool EnumDictionaryBase<T>::TryGetEnumValueInternal(const char* fieldName, T& value)const
{
    for (const auto& item : this->fields)
    {
        if (::strcmp(item.second, fieldName) == 0)
        {
            value = item.first;
            return true;
        }
    }
    // else not found
    return false;
}
 
} // end of namespace Arp