OdEnumClass.h

Go to the documentation of this file.

// Copyright (C) 2002-2024, Open Design Alliance (the "Alliance"). 
// All rights reserved. 
// 
// This software and its documentation and related materials are owned by 
// the Alliance. The software may only be incorporated into application 
// programs owned by members of the Alliance, subject to a signed 
// Membership Agreement and Supplemental Software License Agreement with the
// Alliance. The structure and organization of this software are the valuable  
// trade secrets of the Alliance and its suppliers. The software is also 
// protected by copyright law and international treaty provisions. Application  
// programs incorporating this software must include the following statement 
// with their copyright notices:
//   
//   This application incorporates Open Design Alliance software pursuant to a license 
//   agreement with Open Design Alliance.
//   Open Design Alliance Copyright (C) 2002-2024 by Open Design Alliance. 
//   All rights reserved.
//
// By use of this software, its documentation or related materials, you 
// acknowledge and accept the above terms.
 
#ifndef ODENUMCLASS_INCLUDED
#define ODENUMCLASS_INCLUDED
 
#if __cplusplus >= 201103L || (defined(_MSC_VER) && _MSC_VER >= 1900)
 
#include <type_traits>
#include <cstdarg>

template<typename TEnum,
  typename std::enable_if<std::is_enum<TEnum>::value, bool>::type = true>
typename std::underlying_type<TEnum>::type
OdEnumGetUnderlying(const TEnum value)
{
  return static_cast<typename std::underlying_type<TEnum>::type>(value);
}

template<typename TEnum>
class OdEnumClass
{
public:
  using underlying_t = typename std::underlying_type<TEnum>::type;

  template<typename... Args>
  OdEnumClass(const Args... args)
  {
    OR(args...);
  }

  OdEnumClass<TEnum>& operator=(const OdEnumClass value)
  {
    set(value.asInt());
    return *this;
  }

  OdEnumClass<TEnum>& operator=(const TEnum value)
  {
    set(value);
    return *this;
  }

  OdEnumClass<TEnum>& operator=(const underlying_t value)
  {
    set(value);
    return *this;
  }

  bool operator!=(const OdEnumClass<TEnum> value) const
  {
    return asInt() != value.asInt();
  }

  bool operator!=(const TEnum value) const
  {
    return asInt() != OdEnumGetUnderlying(value);
  }

  bool operator!=(const underlying_t value) const
  {
    return asInt() != value;
  }

  bool operator==(const OdEnumClass<TEnum> value) const
  {
    return asInt() == value.asInt();
  }

  bool operator==(const TEnum value) const
  {
    return asInt() == OdEnumGetUnderlying(value);
  }

  bool operator==(const underlying_t value) const
  {
    return asInt() == value;
  }

  OdEnumClass<TEnum> operator+(const TEnum value) const
  {
    return OdEnumClass<TEnum>(asInt() + OdEnumGetUnderlying(value));
  }
  OdEnumClass<TEnum> operator+(const underlying_t value) const
  {
    return OdEnumClass<TEnum>(asInt() + value);
  }

  OdEnumClass<TEnum> operator-(const TEnum value) const
  {
    return OdEnumClass<TEnum>(asInt() - OdEnumGetUnderlying(value));
  }

  OdEnumClass<TEnum> operator-(const underlying_t value) const
  {
    return OdEnumClass<TEnum>(asInt() - value);
  }

  OdEnumClass<TEnum> operator*(const TEnum value) const
  {
    return OdEnumClass<TEnum>(asInt() * OdEnumGetUnderlying(value));
  }

  OdEnumClass<TEnum> operator*(const underlying_t value) const
  {
    return OdEnumClass<TEnum>(asInt() * value);
  }

  OdEnumClass<TEnum> operator/(const TEnum value) const
  {
    return OdEnumClass<TEnum>(asInt() / OdEnumGetUnderlying(value));
  }

  OdEnumClass<TEnum> operator/(const underlying_t value) const
  {
    return OdEnumClass<TEnum>(asInt() / value);
  }

  OdEnumClass<TEnum> operator&(const TEnum value) const
  {
    return OdEnumClass<TEnum>(asInt() & OdEnumGetUnderlying(value));
  }

  OdEnumClass<TEnum> operator&(const underlying_t value) const
  {
    return OdEnumClass<TEnum>(asInt() & value);
  }

  OdEnumClass<TEnum> operator|(const TEnum value) const
  {
    return OdEnumClass<TEnum>(asInt() | OdEnumGetUnderlying(value));
  }

  OdEnumClass<TEnum> operator|(const underlying_t value) const
  {
    return OdEnumClass<TEnum>(asInt() | value);
  }

  OdEnumClass<TEnum> operator^(const TEnum value) const
  {
    return OdEnumClass<TEnum>(asInt() ^ OdEnumGetUnderlying(value));
  }

  OdEnumClass<TEnum> operator^(const underlying_t value) const
  {
    return OdEnumClass<TEnum>(asInt() ^ value);
  }

  OdEnumClass<TEnum> operator<<(const TEnum value) const
  {
    return OdEnumClass<TEnum>(asInt() << OdEnumGetUnderlying(value));
  }

  OdEnumClass<TEnum> operator<<(const underlying_t value) const
  {
    return OdEnumClass<TEnum>(asInt() << value);
  }

  OdEnumClass<TEnum> operator>>(const TEnum value) const
  {
    return OdEnumClass<TEnum>(asInt() >> OdEnumGetUnderlying(value));
  }

  OdEnumClass<TEnum> operator>>(const underlying_t value) const
  {
    return OdEnumClass<TEnum>(asInt() >> value);
  }

  OdEnumClass<TEnum>& operator+=(const TEnum value)
  {
    m_value += OdEnumGetUnderlying(value);
    return *this;
  }
  OdEnumClass<TEnum>& operator+=(const underlying_t value)
  {
    m_value += value;
    return *this;
  }

  OdEnumClass<TEnum>& operator-=(const TEnum value)
  {
    m_value -= OdEnumGetUnderlying(value);
    return *this;
  }

  OdEnumClass<TEnum>& operator-=(const underlying_t value)
  {
    m_value -= value;
    return *this;
  }

  OdEnumClass<TEnum>& operator*=(const TEnum value)
  {
    m_value *= OdEnumGetUnderlying(value);
    return *this;
  }

  OdEnumClass<TEnum>& operator*=(const underlying_t value)
  {
    m_value *= value;
    return *this;
  }

  OdEnumClass<TEnum>& operator/=(const TEnum value)
  {
    m_value /= OdEnumGetUnderlying(value);
    return *this;
  }

  OdEnumClass<TEnum>& operator/=(const underlying_t value)
  {
    m_value /= value;
    return *this;
  }

  OdEnumClass<TEnum>& operator&=(const TEnum value)
  {
    m_value &= OdEnumGetUnderlying(value);
    return *this;
  }

  OdEnumClass<TEnum>& operator&=(const underlying_t value)
  {
    m_value &= value;
    return *this;
  }

  OdEnumClass<TEnum>& operator|=(const TEnum value)
  {
    m_value |= OdEnumGetUnderlying(value);
    return *this;
  }

  OdEnumClass<TEnum>& operator|=(const underlying_t value)
  {
    m_value |= value;
    return *this;
  }

  OdEnumClass<TEnum>& operator^=(const TEnum value)
  {
    m_value ^= OdEnumGetUnderlying(value);
    return *this;
  }

  OdEnumClass<TEnum>& operator^=(const underlying_t value)
  {
    m_value ^= value;
    return *this;
  }

  OdEnumClass<TEnum>& operator<<=(const TEnum value)
  {
    m_value <<= OdEnumGetUnderlying(value);
    return *this;
  }

  OdEnumClass<TEnum>& operator<<=(const underlying_t value)
  {
    m_value <<= value;
    return *this;
  }

  OdEnumClass<TEnum>& operator>>=(const TEnum value)
  {
    m_value >>= OdEnumGetUnderlying(value);
    return *this;
  }

  OdEnumClass<TEnum>& operator>>=(const underlying_t value)
  {
    m_value >>= value;
    return *this;
  }

  void set(const TEnum value)
  {
    m_value = OdEnumGetUnderlying(value);
  }

  void set(const underlying_t value)
  {
    m_value = value;
  }

  void setBit(const int bit, const bool value = true)
  {
    if (value)
      m_value |= (1 << bit);
    else
      unsetBit(bit);
  }

  void unsetBit(const int bit)
  {
    m_value &= ~(1 << bit);
  }

  void clear()
  {
    m_value = 0;
  }

  void OR(const OdEnumClass<TEnum> value)
  {
    m_value |= value.asInt();
  }

  void OR(const TEnum value)
  {
    m_value |= OdEnumGetUnderlying(value);
  }

  void OR(const underlying_t value)
  {
    m_value |= value;
  }

  template<typename T, typename... Args>
  void OR(const T value, const Args... args)
  {
    static_assert(
      std::is_convertible<T, TEnum>::value || std::is_convertible<T, underlying_t>::value,
      "This type is not allowed");
    OR(value);
    OR(args...);
  }

  void AND(const OdEnumClass<TEnum> value)
  {
    m_value &= value.asInt();
  }

  void AND(const TEnum value)
  {
    m_value &= OdEnumGetUnderlying(value);
  }

  void AND(const underlying_t value)
  {
    m_value &= value;
  }

  template<typename T, typename... Args>
  void AND(const T value, const Args... args)
  {
    static_assert(
      std::is_convertible<T, TEnum>::value || std::is_convertible<T, underlying_t>::value,
      "This type is not allowed");
    AND(value);
    AND(args...);
  }

  void XOR(const OdEnumClass<TEnum> value)
  {
    m_value ^= value.asInt();
  }

  void XOR(const TEnum value)
  {
    m_value ^= OdEnumGetUnderlying(value);
  }

  void XOR(const underlying_t value)
  {
    m_value ^= value;
  }

  template<typename T, typename... Args>
  void XOR(const T value, const Args... args)
  {
    static_assert(
      std::is_convertible<T, TEnum>::value || std::is_convertible<T, underlying_t>::value,
      "This type is not allowed");
    XOR(value);
    XOR(args...);
  }

  bool all() const
  {
    for (std::size_t i = 0; i < sizeof (underlying_t) * CHAR_BIT; ++i)
    {
      if ((m_value & (1 << i)) == 0)
        return false;
    }
    return true;
  }

  bool any() const
  {
    return asBool();
  }

  bool none() const
  {
    return !any();
  }

  TEnum asEnum() const
  {
    return static_cast<TEnum>(m_value);
  }

  underlying_t asInt() const
  {
    return m_value;
  }

  bool asBool() const
  {
    return (m_value ? true : false);
  }

  operator TEnum() const { return asEnum(); }
 
private:
  underlying_t m_value{};
};
 
#endif //#if __cplusplus >= 201103L
 
#endif //#ifndef ODENUMCLASS_INCLUDED