EnumFlagsDictionary.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"
#include <iomanip>
 
namespace Arp
{
 
template<class T, char Delimiter = '|'>
class EnumFlagsDictionary : public EnumDictionaryBase<T>
{
protected: // usings
    using Base = EnumDictionaryBase<T>;
    using U = typename Base::U;
    using InitializerList = typename Base::InitializerList;
 
public: // construction
    EnumFlagsDictionary(const InitializerList& fields);
 
    EnumFlagsDictionary(T flagsMask, const InitializerList& fields);
 
    EnumFlagsDictionary(T flagsMask, const char* invalidValueString, const InitializerList& fields);
 
    EnumFlagsDictionary(U flagsMask, const InitializerList& fields);
 
    EnumFlagsDictionary(U flagsMask, const char* invalidValueString, const InitializerList& fields);
 
public: // overlapping operations from base class EnumDictionary<T> (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: // flags operation
    String GetEnumString(T value)const;
 
    bool TryGetEnumString(T value, String& result)const;
 
    T GetEnumValue(const String& fieldName)const;
 
    bool TryGetEnumValue(const String& fieldName, T& value)const;
 
private: // methods
    bool IsFlag(T value)const;
    bool TryGetCombinedEnumString(T value, String& result)const;
    bool TryParseCombinedEnumValue(const String& input, T& value)const;
    bool TryFormatFlags(T value, String& result)const;
 
private: // fields
    T flagsMask = static_cast<T>(std::numeric_limits<U>::max());
    T valueMask = static_cast<T>(0);
};
 
// inline methods of class EnumFlagsDictionary<T>
template<class T, char Delimiter>
EnumFlagsDictionary<T, Delimiter>::EnumFlagsDictionary(const InitializerList& fields)
    : Base("", fields)
{
}
 
template<class T, char Delimiter>
EnumFlagsDictionary<T, Delimiter>::EnumFlagsDictionary(T flagsMask, const InitializerList& fields)
    : Base("", fields)
    , flagsMask(flagsMask)
    , valueMask(~flagsMask)
{
}
 
template<class T, char Delimiter>
EnumFlagsDictionary<T, Delimiter>::EnumFlagsDictionary(T flagsMask, const char* invalidValueString, const InitializerList& fields)
    : Base(invalidValueString, fields)
    , flagsMask(flagsMask)
    , valueMask(~flagsMask)
{
}
 
template<class T, char Delimiter>
EnumFlagsDictionary<T, Delimiter>::EnumFlagsDictionary(U flagsMask, const InitializerList& fields)
    : Base("", fields)
    , flagsMask(static_cast<T>(flagsMask))
    , valueMask(static_cast<T>(~flagsMask))
{
}
 
template<class T, char Delimiter>
EnumFlagsDictionary<T, Delimiter>::EnumFlagsDictionary(U flagsMask, const char* invalidValueString, const InitializerList& fields)
    : Base(invalidValueString, fields)
    , flagsMask(static_cast<T>(flagsMask))
    , valueMask(static_cast<T>(~flagsMask))
{
}
 
template<class T, char Delimiter>
std::ostream& EnumFlagsDictionary<T, Delimiter>::WriteEnumString(std::ostream& os, T value)const
{
    String enumString;
    if (this->TryGetEnumString(value, enumString))
    {
        os << enumString;
    }
    else
    {
        if (this->invalidValueString.IsEmpty())
        {
            os << "0x" << std::uppercase << std::hex << 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, char Delimiter>
inline std::istream& EnumFlagsDictionary<T, Delimiter>::ReadEnumValue(std::istream& is, T& value)const
{
    std::string s;
    std::getline(is, s);
    if (!this->TryParseCombinedEnumValue(s, value))
    {
        is.setstate(std::ios::failbit);
    }
    return is;
}
 
template<class T, char Delimiter>
inline String EnumFlagsDictionary<T, Delimiter>::GetEnumString(T value)const
{
    String result;
    if (!this->TryGetCombinedEnumString(value, result))
    {
        throw Exception("Could not find enum string of enum '{}' for value '{}'.", TypeName<T>().Value, static_cast<U>(value));
    }
    // else
    return result;
}
 
template<class T, char Delimiter>
bool EnumFlagsDictionary<T, Delimiter>::TryGetEnumString(T value, String& result)const
{
    return this->TryGetCombinedEnumString(value, result);
}
 
template<class T, char Delimiter>
T EnumFlagsDictionary<T, Delimiter>::GetEnumValue(const String& 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, char Delimiter>
bool EnumFlagsDictionary<T, Delimiter>::TryGetEnumValue(const String& fieldName, T& value)const
{
    return this->TryParseCombinedEnumValue(fieldName, value);
}
 
template<class T, char Delimiter>
inline bool EnumFlagsDictionary<T, Delimiter>::IsFlag(T value)const
{
    return (value & this->flagsMask) == value;
}
 
template<class T, char Delimiter>
inline bool EnumFlagsDictionary<T, Delimiter>::TryGetCombinedEnumString(T value, String& result)const
{
    const char* pResult = nullptr;
    if (Base::TryGetEnumStringInternal(value, pResult))
    {
        // it's a simple not combined value
        result = pResult;
        return true;
    }
    // else must generate a combined string
    if (TryFormatFlags(value, result))
    {
        return true;
    }
    // else format the raw value
    std::ostringstream oss;
    oss << "0x" << std::uppercase << std::hex << static_cast<U>(value);
    result = oss.str();
    return false;
}
 
template<class T, char Delimiter>
inline bool EnumFlagsDictionary<T, Delimiter>::TryFormatFlags(T value, String& result)const
{
    std::ostringstream oss;
    T resultValue = Base::zeroValue;
 
    for (const auto& item : this->fields)
    {
        if (item.first == Base::zeroValue)
        {
            continue; // ignore zero fields, otherwise it would always match
        }
        if (IsFlag(item.first)) // check if the current item is a flag but not a regular enum value
        {
            if ((value & item.first) == item.first) // does value match current flag?
            {
                if (oss.tellp() == std::streampos(0)) // first token?
                {
                    oss << item.second;
                }
                else
                {
                    oss << Delimiter << item.second;
                }
                resultValue |= item.first;
            }
        }
        else // the current item is not a flag but a regular enum value in a mixed Enum
        {
            if ((value & ~flagsMask) == item.first) // does value match current item?
            {
                if (oss.tellp() == std::streampos(0)) // first token?
                {
                    oss << item.second;
                }
                else
                {
                    oss << Delimiter << item.second;
                }
                resultValue |= item.first;
            }
        }
    }
    if (resultValue != value)
    {
        // the resulting string is incomplete, not all flags were included
        return false;
    }
    // else
    result = oss.str();
    return true;
}
 
template<class T, char Delimiter>
inline bool EnumFlagsDictionary<T, Delimiter>::TryParseCombinedEnumValue(const String& input, T& value)const
{
    static const char delimiters[] = { '|', ',', ';', Delimiter };
    static const size_t count = sizeof(delimiters) / sizeof(char);
 
    T result = Base::zeroValue;
    String::Tokens tokens = input.Split(delimiters, count);
    for (const String& token : tokens)
    {
        T flag = Base::zeroValue;
        if (!this->TryGetEnumValueInternal(token, flag))
        {
            return false;
        }
        // else combine value with flag
        result |= flag;
    }
    value = result;
    return true;
}
 
} // end of namespace Arp