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/Exception.hpp"
#include <iosfwd>
#include <type_traits>
 
namespace Arp
{
 
 
template<class T = void>
class Enum
{
public: // typedefs
    using Value = T;
    using U = typename std::underlying_type<T>::type;
 
public: // construction
    Enum(Value val = Zero);
 
public: // static/const fields
    static const T Zero = static_cast<T>(0);
 
public: // static operations
    static bool     TryParse(const String& input, Enum& result);
 
    static bool     TryParse(const String& input, T& result);
 
    static bool     TryParse(const char* input, Enum& result);
 
    static bool     TryParse(const char* input, T& result);
 
    static Enum     Parse(const String& input);
 
    static Enum     Parse(const char* input);
 
public: // getter
    T       GetValue(void)const;
 
public: // operations
    U       ToUnderlyingType(void)const;
 
    String  ToString(bool throwIfInvalid = true)const;
 
public: // assign 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 val)
    : value(val)
{
}
 
template<class T>
inline Enum<T>& Enum<T>::operator=(Value rhs)
{
    this->value = rhs;
    return *this;
}
 
template<class T>
inline Enum<T>::operator T()const
{
    return this->GetValue();
}
 
template<class T>
inline Enum<T>& Enum<T>::operator&=(Enum rhs)
{
    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)
{
    this->value = static_cast<T>(static_cast<U>(this->value) | static_cast<U>(rhs.value));
    return *this;
}
 
template<class T>
inline T Enum<T>::GetValue()const
{
    return this->value;
}
 
template<class T>
inline typename Enum<T>::U Enum<T>::ToUnderlyingType()const
{
    return static_cast<U>(this->value);
}
 
template<class T>
inline String Enum<T>::ToString(bool throwIfInvalid)const
{
    std::ostringstream oss;
    oss << this->value;
    if (oss.fail() && throwIfInvalid)
    {
        throw Exception("Invalid value for Enum '{0}' occurs: {1}", TypeName<Enum>(), static_cast<U>(this->value));
    }
    return oss.str();
}
 
template<class T>
inline bool Enum<T>::TryParse(const String& input, T& result)
{
    return Enum::TryParse(input.CStr(), result);
}
 
template<class T>
inline bool Enum<T>::TryParse(const String& input, Enum& result)
{
    return Enum::TryParse(input.CStr(), result);
}
 
template<class T>
inline bool Enum<T>::TryParse(const char* input, T& result)
{
    T value = Zero;
    std::istringstream iss(input);
    iss >> value;
    if (iss.fail())
    {
        return false; // enum not found
    }
    // else
    result = value;
    return true;
}
 
template<class T>
inline bool Enum<T>::TryParse(const char* input, Enum& result)
{
    T value = Zero;
    if (!Enum::TryParse(input, value))
    {
        return false;
    }
    result = value;
    return true;
}
 
template<class T>
inline Enum<T> Enum<T>::Parse(const String& input)
{
    Enum<T> result;
    if (!Enum::TryParse(input, result))
    {
        throw Exception("Invalid string for Enum '{0}' occurs: {1}", TypeName<Enum>(), input);
    }
    return result;
}
 
 
template<class T>
inline Enum<T> Enum<T>::Parse(const char* input)
{
    Enum result;
    if (!Enum::TryParse(input, result))
    {
        throw Exception("Invalid string for Enum '{0}' occurs: {1}", TypeName<Enum>(), input);
    }
    return result;
}
 
// global operators of class Enum<T>
 
// stream operators of class Enum<T>
 
template<class T>
inline std::ostream& operator<<(std::ostream& os, Enum<T> value)
{
    return os << value.GetValue();
}
 
template<class T>
inline std::istream& operator>>(std::istream& is, Enum<T>& value)
{
    T enumValue = Enum<T>::Zero;
    is >> enumValue;
    if (!is.fail())
    {
        value = enumValue;
    }
    return is;
}
 
// bit operators of class Enum<T>
 
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;
}
 
// compare operators of class Enum<T>
 
template<class T>
inline bool operator==(Enum<T> lhs, Enum<T> rhs)
{
    return lhs.GetValue() == rhs.GetValue();
}
 
template<class T>
inline bool operator<(Enum<T> lhs, Enum<T> rhs)
{
    return lhs.GetValue() < rhs.GetValue();
}
 
template<class T>
inline bool operator>(Enum<T> lhs, Enum<T> rhs)
{
    return lhs.GetValue() > rhs.GetValue();
}
 
template<class T>
inline bool operator<=(Enum<T> lhs, Enum<T> rhs)
{
    return lhs.GetValue() <= rhs.GetValue();
}
 
template<class T>
inline bool operator>=(Enum<T> lhs, Enum<T> rhs)
{
    return lhs.GetValue() >= rhs.GetValue();
}
 
// compare operators of class Enum<T> and T
 
template<class T>
inline bool operator==(Enum<T> lhs, T rhs)
{
    return lhs.GetValue() == rhs;
}
 
template<class T>
inline bool operator<(Enum<T> lhs, T rhs)
{
    return lhs.GetValue() < rhs;
}
 
template<class T>
inline bool operator>(Enum<T> lhs, T rhs)
{
    return lhs.GetValue() > rhs;
}
 
template<class T>
inline bool operator<=(Enum<T> lhs, T rhs)
{
    return lhs.GetValue() <= rhs;
}
 
template<class T>
inline bool operator>=(Enum<T> lhs, T rhs)
{
    return lhs.GetValue() >= rhs;
}
 
// compare operators of T and class Enum<T>
 
template<class T>
inline bool operator==(T lhs, Enum<T> rhs)
{
    return lhs == rhs.GetValue();
}
 
template<class T>
inline bool operator<(T lhs, Enum<T> rhs)
{
    return lhs < rhs.GetValue();
}
 
template<class T>
inline bool operator>(T lhs, Enum<T> rhs)
{
    return lhs > rhs.GetValue();
}
 
template<class T>
inline bool operator<=(T lhs, Enum<T> rhs)
{
    return lhs <= rhs.GetValue();
}
 
template<class T>
inline bool operator>=(T lhs, Enum<T> rhs)
{
    return lhs >= rhs.GetValue();
}
 
 
} // end of namespace Arp