Enum.hxx

 
//
//  Copyright Phoenix Contact GmbH & Co. KG
//
#pragma once
#include "Arp/Base/Core/Arp.hpp"
#include <iosfwd>
#include <type_traits>
 
namespace Arp { namespace Base { namespace Core
{
 
 
template<class T>
class Enum
{
public: // usings
    using Value = T;                                    
    using U = typename std::underlying_type<T>::type;   
 
public: // construction
    Enum(Value initialValue = Zero);
 
public: // static/const fields
    static constexpr 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: // conversion operators
    operator T(void)const;
 
public: // (logical) assign operators
    Enum& operator=(Value arg);
    Enum& operator&=(Enum rhs);
    Enum& operator|=(Enum rhs);
 
public: // getter
    T GetValue(void)const;
 
public: // operations
    bool    HasFlag(Value flag);
    bool    HasAnyFlag(Value flags);
    bool    HasAllFlags(Value flags);
    U       ToUnderlyingType(void)const;
    String  ToString(bool throwIfInvalid = true)const;
 
private: // fields
    Value value;
 
public: // global (friend) operators (shall be defined implicit inline due to EXPORT on Windows)
 
    // stream operators of class Enum<T>
 
    friend std::ostream& operator<<(std::ostream& os, Enum arg)
    {
        return os << arg.value;
    }
 
    friend std::istream& operator>>(std::istream& is, Enum& arg)
    {
        T enumValue = Enum<T>::Zero;
        is >> enumValue;
        if (!is.fail())
        {
            arg = enumValue;
        }
        return is;
    }
 
    // global bit operators of class Enum<T>
 
    friend Enum operator|(Enum lhs, Enum rhs)
    {
        Enum result = lhs;
        result |= rhs;
        return result;
    }
 
    friend Enum operator&(Enum lhs, Enum rhs)
    {
        Enum result = lhs;
        result &= rhs;
        return result;
    }
 
    // global compare operators of class Enum<T>
    friend bool operator==(Enum lhs, Enum rhs)
    {
        return lhs.value == rhs.value;
    }
 
    friend bool operator<(Enum lhs, Enum rhs)
    {
        return lhs.value < rhs.value;
    }
 
    friend bool operator>(Enum lhs, Enum rhs)
    {
        return lhs.value > rhs.value;
    }
 
    friend bool operator<=(Enum lhs, Enum rhs)
    {
        return lhs.value <= rhs.value;
    }
 
    friend bool operator>=(Enum lhs, Enum rhs)
    {
        return lhs.value >= rhs.value;
    }
 
    // global compare operators of class Enum<T> and T
 
    friend bool operator==(Enum lhs, T rhs)
    {
        return lhs.value == rhs;
    }
 
    friend bool operator<(Enum lhs, T rhs)
    {
        return lhs.value < rhs;
    }
 
    friend bool operator>(Enum lhs, T rhs)
    {
        return lhs.value > rhs;
    }
 
    friend bool operator<=(Enum lhs, T rhs)
    {
        return lhs.value <= rhs;
    }
 
    friend bool operator>=(Enum lhs, T rhs)
    {
        return lhs.value >= rhs;
    }
 
    // compare operators of T and class Enum<T>
 
    friend bool operator==(T lhs, Enum rhs)
    {
        return lhs == rhs.value;
    }
 
    friend bool operator<(T lhs, Enum rhs)
    {
        return lhs < rhs.value;
    }
 
    friend bool operator>(T lhs, Enum rhs)
    {
        return lhs > rhs.value;
    }
 
    friend bool operator<=(T lhs, Enum rhs)
    {
        return lhs <= rhs.value;
    }
 
    friend bool operator>=(T lhs, Enum rhs)
    {
        return lhs >= rhs.value;
    }
};
 
template<class T>
Enum<T> make_enum(T value);
 
 
}}} // end of namespace Arp::Base::Core
 
namespace Arp {
using Arp::Base::Core::Enum;
using Arp::Base::Core::make_enum;
}
template<class T> struct fmt::formatter<Arp::Base::Core::Enum<T>> : public fmt::ostream_formatter {};
 
#include "Arp/Base/Core/Detail/Enum.ipp"