FlagSet.hh

Go to the documentation of this file.

/*
 * MIT License
 *
 * Copyright (c) 2019 Arnaud Kapp (Xaqq), Barry Revzin, Mart Sõmermaa
 * Copyright (c) 2020 Martin Pecka
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in 
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */
#ifndef IGNITION_COMMON_FLAGSET_HH
#define IGNITION_COMMON_FLAGSET_HH

// FlagSet is a type-safe class for using enums as flags in C++14 with an
// underlying std::bitset.
// See https://github.com/mrts/flag-set-cpp
// Licence: MIT

#include <bitset>
#include <iostream>
#include <cassert>
#include <string>

namespace ignition::common
{

template<typename T, T LastElement = T::_, bool ExcludeLast = true>
class FlagSet
{
  public: FlagSet() = default;

  // cppcheck-suppress noExplicitConstructor
  public: FlagSet(const T& _val)
  {
    flags.set(static_cast<UnderlyingType>(_val));
  }

  public: explicit FlagSet(const std::initializer_list<T>& _list)
  {
    for (const auto& val : _list)
    {
      flags.set(static_cast<UnderlyingType>(val));
    }
  }

  // Binary operations.

  public: FlagSet& operator&=(const T& _val) noexcept
  {
    bool tmp = flags.test(static_cast<UnderlyingType>(_val));
    flags.reset();
    flags.set(static_cast<UnderlyingType>(_val), tmp);
    return *this;
  }

  public: FlagSet& operator&=(const FlagSet& _o) noexcept
  {
    flags &= _o.flags;
    return *this;
  }

  public: FlagSet& operator|=(const T& _val) noexcept
  {
    flags.set(static_cast<UnderlyingType>(_val));
    return *this;
  }

  public: FlagSet& operator|=(const FlagSet& _o) noexcept
  {
    flags |= _o.flags;
    return *this;
  }

  public: FlagSet operator&(const T& _val) const
  {
    FlagSet ret(*this);
    ret &= _val;

    assert(ret.flags.count() <= 1);
    return ret;
  }

  public: FlagSet operator&(const FlagSet& _val) const
  {
    FlagSet ret(*this);
    ret.flags &= _val.flags;

    return ret;
  }

  public: FlagSet operator|(const T& _val) const
  {
    FlagSet ret(*this);
    ret |= _val;

    assert(ret.flags.count() >= 1);
    return ret;
  }

  public: FlagSet operator|(const FlagSet& _val) const
  {
    FlagSet ret(*this);
    ret.flags |= _val.flags;

    return ret;
  }

  public: FlagSet operator~() const
  {
    FlagSet cp(*this);
    cp.flags.flip();

    return cp;
  }

  public: explicit operator bool() const
  {
    return flags.any();
  }

  // Methods from std::bitset.

  public: bool operator==(const FlagSet& _o) const
  {
    return flags == _o.flags;
  }

  public: bool operator!=(const FlagSet& _o) const
  {
    return !(*this == _o);
  }

  public: std::size_t Size() const
  {
    return flags.size();
  }

  public: std::size_t Count() const
  {
    return flags.count();
  }

  public: FlagSet& Set()
  {
    flags.set();
    return *this;
  }

  public: FlagSet& Reset()
  {
    flags.reset();
    return *this;
  }

  public: FlagSet& Flip()
  {
    flags.flip();
    return *this;
  }

  public: FlagSet& Set(const T& _val, bool _value = true)
  {
    flags.set(static_cast<UnderlyingType>(_val), _value);
    return *this;
  }

  public: FlagSet& Reset(const T& _val)
  {
    flags.reset(static_cast<UnderlyingType>(_val));
    return *this;
  }

  public: FlagSet& Flip(const T& _val)
  {
    flags.flip(static_cast<UnderlyingType>(_val));
    return *this;
  }

  public: bool Any() const
  {
    return flags.any();
  }

  public: bool All() const
  {
    return flags.all();
  }

  public: bool None() const
  {
    return flags.none();
  }

  public: static FlagSet AllSet()
  {
    return FlagSet().Set();
  }

  public: static FlagSet NoneSet()
  {
    return FlagSet();
  }

  public: constexpr bool operator[](const T& _val) const
  {
    return flags[static_cast<size_t>(static_cast<UnderlyingType>(_val))];
  }

  public: std::string String() const
  {
    return flags.to_string();
  }

  public: friend std::ostream& operator<<(std::ostream& _stream,
      const FlagSet& _self)
  {
    return _stream << _self.flags;
  }

  public: size_t Hash() const
  {
    return std::hash<decltype(this->flags)>{}(this->flags);
  }

  private: using UnderlyingType = std::underlying_type_t<T>;

  public: static constexpr size_t numElements = static_cast<size_t>(
    static_cast<UnderlyingType>(LastElement) +
    static_cast<UnderlyingType>(1 - ExcludeLast));

  private: std::bitset<numElements> flags;
};

template<typename T, typename = void>
struct IsEnumThatContainsSentinel : std::false_type
{
};

template<typename T>
struct IsEnumThatContainsSentinel<T, decltype(static_cast<void>(T::_))>
    : std::is_enum<T>
{
};

}

// Operator that combines two enumeration values into a FlagSet only if the
// enumeration contains the sentinel `_`.
template<typename T>
std::enable_if_t<
    ignition::common::IsEnumThatContainsSentinel<T>::value,
    ignition::common::FlagSet<T>
>
operator|(const T& _lhs, const T& _rhs)
{
  ignition::common::FlagSet<T> fs;
  fs |= _lhs;
  fs |= _rhs;

  return fs;
}

namespace std
{
template<typename T, T LastElement, bool ExcludeLast>
struct hash<ignition::common::FlagSet<T, LastElement, ExcludeLast>>
{
  std::size_t operator()(
    const ignition::common::FlagSet<T, LastElement, ExcludeLast>& _s)
    const noexcept
  {
    return _s.Hash();
  }
};
}

#endif