EnumDictionary.hxx

 
//
//  Copyright PHOENIX CONTACT Electronics GmbH
//
#pragma once
#include "Arp/System/Core/Arp.h"
#include "Arp/System/Core/EnumDictionaryBase.hxx"
#include "Arp/System/Core/TypeName.hxx"
 
namespace Arp
{
 
template<class T>
class EnumDictionary : public EnumDictionaryBase<T>
{
protected: // usings
    using Base = EnumDictionaryBase<T>;
    using U = typename Base::U;
    using InitializerList = typename Base::InitializerList;
 
public: // construction/destruction
    EnumDictionary(const InitializerList& fields);
    EnumDictionary(const char* invalidValueString, const InitializerList& fields);
 
public: // operations used by stream operators of enums
    std::ostream& WriteEnumString(std::ostream& os, T value)const;
 
    std::istream& ReadEnumValue(std::istream& is, T& value)const;
 
public: // string conversion operations
    const char* GetEnumString(T value)const;
 
    bool TryGetEnumString(T value, const char*& pResult)const;
 
    T GetEnumValue(const char* fieldName)const;
 
    bool TryGetEnumValue(const char* fieldName, T& value)const;
};
 
// inline methods of class EnumDictionary<T>
template<class T>
EnumDictionary<T>::EnumDictionary(const InitializerList& fields)
    : Base("", fields)
{
}
 
template<class T>
EnumDictionary<T>::EnumDictionary(const char* invalidValueString, const InitializerList& fields)
    : Base(invalidValueString, fields)
{
}
 
template<class T>
std::ostream& EnumDictionary<T>::WriteEnumString(std::ostream& os, T value)const
{
    const char* pString = nullptr;
    if (this->TryGetEnumString(value, pString))
    {
        os << pString;
    }
    else
    {
        if (this->invalidValueString.IsEmpty())
        {
            os << static_cast<U>(value);
        }
        else
        {
            os << this->invalidValueString;
        }
        os.setstate(std::ios::failbit); // inform caller that entry was not found
    }
    return os;
}
 
template<class T>
inline std::istream& EnumDictionary<T>::ReadEnumValue(std::istream& is, T& value)const
{
    String token;
    is >> token;
    if (!TryGetEnumValue(token, value))
    {
        is.setstate(std::ios::failbit);
    }
    return is;
}
 
template<class T>
inline const char* EnumDictionary<T>::GetEnumString(T value)const
{
    const char* pResult = nullptr;
    if(!this->TryGetEnumString(value, pResult))
    {
        throw Exception("Could not find enum string of enum '{}' for value '{}'.", TypeName<T>().Value, static_cast<U>(value));
    }
    return pResult;
}
 
template<class T>
inline bool EnumDictionary<T>::TryGetEnumString(T value, const char*& pResult)const
{
    return this->TryGetEnumStringInternal(value, pResult); // from base class
}
 
template<class T>
inline T EnumDictionary<T>::GetEnumValue(const char* fieldName)const
{
    T result;
    if (!this->TryGetEnumValue(fieldName, result))
    {
        throw Exception("Could not find enum value of enum '{}' for string '{}'.", TypeName<T>().Value, fieldName);
    }
    return result;
}
 
template<class T>
inline bool EnumDictionary<T>::TryGetEnumValue(const char* fieldName, T& value)const
{
    return this->TryGetEnumValueInternal(fieldName, value); // from base class
}
 
} // end of namespace Arp