Enum.hxx

//
//  Copyright PHOENIX CONTACT Electronics GmbH
//
#pragma once
#include "Arp/System/Core/Arp.h"
#include "Arp/System/Core/TypeName.hxx"
#include "Arp/System/Core/EnumStrings.hxx"
#include "Arp/System/Core/Exception.hpp"
#include <iostream>
#include <utility>

namespace Arp
{


template<class T = void>
class Enum
{
public: // typedefs
    typedef T   Value;

public: // construction
    Enum(Value value = Value(0));

public: // static operations
    static bool     TryParse(const char* input, Enum& result);

    static bool     TryParse(const String& input, Enum& result);

    static Enum     Parse(const char* input);

    static Enum     Parse(const String& input);

public: // operations
    T       ToValue(void)const;

    String  ToString(void)const;

public: // operators
    Enum&   operator=(const Enum& rhs) = default;

    Enum&   operator=(Value rhs);

    Enum&   operator&=(Enum rhs);

    Enum&   operator|=(Enum rhs);

public: // conversion operators
    operator T(void)const;

private: // fields
    Value value;
};

// global function related to class Enum<T>
// define global make_ function as usual for C++
template<class T>
Enum<T> make_enum(T value)
{
    return Enum<T>(value);
}

// inline methods of class Enum<T>
template<class T>
inline Enum<T>::Enum(Value valueArg)
    : value(valueArg)
{
}

template<class T>
inline Enum<T>& Enum<T>::operator=(Value arg)
{
    this->value = arg;
    return *this;
}

template<class T>
inline Enum<T>::operator T()const
{
    return this->ToValue();
}

template<class T>
inline Enum<T>& Enum<T>::operator&=(Enum rhs)
{
    using U = typename std::underlying_type<T>::type;
    this->value = static_cast<T>(static_cast<U>(this->value) & static_cast<U>(rhs.value));
    return *this;
}

template<class T>
inline Enum<T>& Enum<T>::operator|=(Enum rhs)
{
    using U = typename std::underlying_type<T>::type;
    this->value = static_cast<T>(static_cast<U>(this->value) | static_cast<U>(rhs.value));
    return *this;
}

template<class T>
inline T Enum<T>::ToValue()const
{
    return value;
}

template<class T>
inline String Enum<T>::ToString()const
{
    return EnumStrings<T>::GetEntry(this->value);
}

template<class T>
inline bool Enum<T>::TryParse(const String& input, Enum& result)
{
    T resultValue = (T)0;
    if (EnumStrings<T>::TryGetEntryValue(input, resultValue))
    {
        result = Enum(resultValue);
        return true;
    }
    // else not found
    return false;
}

template<class T>
inline Enum<T> Enum<T>::Parse(const String& input)
{
    Enum<T> result;
    if (!TryParse(input, result))
    {
        throw Exception("Unknown string of Enum '{0}' occurs: {1}", TypeName<Enum>().Value, input);
    }
    return result;
}

template<class T>
inline bool Enum<T>::TryParse(const char* input, Enum& result)
{
    return Enum::TryParse(String(input), result);
}

template<class T>
inline Enum<T> Enum<T>::Parse(const char* input)
{
    Enum result;
    if (!TryParse(input, result))
    {
        throw Exception("Unknown string of Enum '{0}' occurs: {1}", TypeName<Enum>().Value, input);
    }
    return result;
}

// global operators of class Enum<T>

template<class T>
inline std::ostream& operator<<(std::ostream& os, Enum<T> value)
{
    return os << Enum<T>(value).ToString();
}

template<class T>
inline bool operator==(Enum<T> lhs, Enum<T> rhs)
{
    return lhs.ToValue() == rhs.ToValue();
}

template<class T>
inline bool operator<(Enum<T> lhs, Enum<T> rhs)
{
    return lhs.ToValue() < rhs.ToValue();
}

template<class T>
inline Enum<T> operator&(Enum<T> lhs, Enum<T> rhs)
{
    Enum<T> result = lhs;
    result &= rhs;
    return result;
}

template<class T>
inline Enum<T> operator|(Enum<T> lhs, Enum<T> rhs)
{
    Enum<T> result = lhs;
    result |= rhs;
    return result;
}


} // end of namespace Arp