CMake/Utilities/std/cmext/enum_set

// -*-c++-*-
// vim: set ft=cpp:

/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
   file Copyright.txt or https://cmake.org/licensing for details.  */
#pragma once

#include <bitset>
#include <cstddef>
#include <initializer_list>
#include <iterator>
#include <limits>
#include <utility>

#include <cm/type_traits>

//
// Class enum_set offers the capability to manage a set of enum values.
// Only the 'enum class' type with unsigned base type is supported. Moreover,
// all definitions must be specified without a value.
//
// The methods offered by 'enum_set' are close as possible to the 'std::set'
// container as well as the methods from 'std::bitset'.
//
// Internally, this class use 'std::bitset' container to manage the
// set of enum.
//
// The size of the bitset is deduced from the underlying type of
// the enum or can be set explicitly as template parameter:
//
// enum class Example : unsigned { A, B, C, D };
// using ExampleSet = enum_set<Example, 4>;
//
// Another possibility is to add, at the end of the list, the definition
// 'cm_count' with the value of the precedent definition:
//
//   enum class Example : unsigned { A, B, C, D, cm_count = D };
//   using ExampleSet = enum_set<Example>;
//
// To facilitate the usage of the enum_set, operators '+' and '|' can be used
// as alternate to the 'initializer_list':
//
//  auto set1 = Example::A | Example::B | Example::C;
//  auto set2 = Example::A + Example::B;
//  set2.set(Example::C | Example::D);
//

namespace cm {

namespace internals {
template <typename Enum, typename U = void>
struct enum_size
{
  static constexpr auto value =
    std::numeric_limits<typename std::underlying_type<Enum>::type>::digits;
};
template <typename Enum>
struct enum_size<Enum, cm::void_t<decltype(Enum::cm_count)>>
{
  static constexpr auto value =
    static_cast<typename std::underlying_type<Enum>::type>(Enum::cm_count) + 1;
};
}

template <typename EnumSet>
class enum_set_iterator
{
public:
  enum_set_iterator() = default;
  enum_set_iterator(enum_set_iterator const& other) = default;

  using iterator_category = std::bidirectional_iterator_tag;
  using value_type = typename EnumSet::value_type;
  using difference_type = typename EnumSet::difference_type;
  using reference = typename EnumSet::reference;
  using pointer = typename EnumSet::pointer;

  enum_set_iterator& operator++()
  {
    while (++this->Index < this->Set->max_size() &&
           !this->Set->test(this->Index))
      ;

    return *this;
  }
  enum_set_iterator operator++(int)
  {
    auto retval = *this;
    ++(*this);
    return retval;
  }

  enum_set_iterator& operator--()
  {
    if (this->Index == 0) {
      return *this;
    }

    while (!this->Set->test(--this->Index) && this->Index != 0)
      ;

    return *this;
  }
  enum_set_iterator operator--(int)
  {
    auto retval = *this;
    --(*this);
    return retval;
  }

  reference operator*() const { return static_cast<reference>(this->Index); }

  bool operator==(enum_set_iterator other) const
  {
    return (this->Set == other.Set) && (this->Index == other.Index);
  }

  bool operator!=(enum_set_iterator other) const { return !(*this == other); }

private:
  friend EnumSet;

  using size_type = typename EnumSet::size_type;

  enum_set_iterator(EnumSet* set, bool at_end = false)
    : Set(set)
  {
    if (at_end || this->Set->empty()) {
      this->Index = this->Set->max_size();
    } else {
      while (!this->Set->test(this->Index) &&
             ++this->Index < this->Set->max_size())
        ;
    }
  }
  enum_set_iterator(EnumSet* set, size_type pos)
    : Index(pos)
    , Set(set)
  {
  }

  std::size_t Index = 0;
  EnumSet* Set = nullptr;
};

template <
  typename Enum, std::size_t Size = internals::enum_size<Enum>::value,
  typename cm::enable_if_t<
    cm::is_scoped_enum<Enum>::value &&
      std::is_unsigned<typename std::underlying_type<Enum>::type>::value,
    int> = 0>
class enum_set
{
public:
  using key_type = Enum;
  using value_type = Enum;
  using size_type = typename std::underlying_type<Enum>::type;
  using difference_type = size_type;
  using reference = Enum;
  using const_reference = Enum;
  using pointer = Enum const*;
  using const_pointer = Enum const*;

  using iterator = enum_set_iterator<enum_set>;
  using const_iterator = enum_set_iterator<enum_set const>;
  using reverse_iterator = std::reverse_iterator<iterator>;
  using const_reverse_iterator = std::reverse_iterator<const_iterator>;

  constexpr enum_set() noexcept = default;
  enum_set(key_type e) { this->insert(e); }
  enum_set(enum_set const& other) noexcept { this->insert(other); }
  enum_set(std::initializer_list<value_type> list) { this->insert(list); }

  enum_set& operator=(key_type e)
  {
    this->Set.reset();
    this->insert(e);
    return *this;
  }
  enum_set& operator=(enum_set const& other) noexcept
  {
    this->Set.reset();
    this->Set |= other.Set;
    return *this;
  }
  enum_set& operator=(std::initializer_list<value_type> list)
  {
    this->Set.reset();
    this->insert(list);
    return *this;
  }

  // Iterators
  iterator begin() noexcept { return iterator(this); }
  const_iterator begin() const noexcept { return const_iterator(this); }
  const_iterator cbegin() const noexcept { return const_iterator(this); }

  iterator end() noexcept { return iterator(this, true); }
  const_iterator end() const noexcept { return const_iterator(this, true); }
  const_iterator cend() const noexcept { return const_iterator(this, true); }

  reverse_iterator rbegin() noexcept { return reverse_iterator(this->end()); }
  const_reverse_iterator rbegin() const noexcept
  {
    return const_reverse_iterator(this->end());
  }
  const_reverse_iterator crbegin() const noexcept
  {
    return const_reverse_iterator(this->cend());
  }

  reverse_iterator rend() noexcept { return reverse_iterator(this->begin()); }
  const_reverse_iterator rend() const noexcept
  {
    return const_reverse_iterator(this->begin());
  }
  const_reverse_iterator crend() const noexcept
  {
    return const_reverse_iterator(this->cbegin());
  }

  // Capacity
  bool empty() const noexcept { return this->Set.none(); }

  size_type size() const noexcept { return this->Set.count(); }

  size_type max_size() const noexcept { return this->Set.size(); }

  // Modifiers

  // set all elements
  enum_set& set()
  {
    this->Set.set();
    return *this;
  }
  enum_set& set(key_type e)
  {
    this->insert(e);
    return *this;
  }
  enum_set& set(enum_set const& other) noexcept
  {
    this->insert(other);
    return *this;
  }
  enum_set& set(std::initializer_list<value_type> list)
  {
    this->insert(list);
    return *this;
  }
  // alternate syntax for bit set
  enum_set& operator+=(key_type e) { return this->set(e); }
  enum_set& operator+=(enum_set const& other) noexcept
  {
    return this->set(other);
  }
  enum_set& operator+=(std::initializer_list<value_type> list)
  {
    return this->set(list);
  }
  // alternate syntax for bit set
  enum_set& operator|=(key_type e) { return this->set(e); }
  enum_set& operator|=(enum_set const& other) noexcept
  {
    return this->set(other);
  }
  enum_set& operator|=(std::initializer_list<value_type> list)
  {
    return this->set(list);
  }

  // reset all elements
  void clear() noexcept { this->Set.reset(); }
  enum_set& reset()
  {
    this->Set.reset();
    return *this;
  }
  enum_set& reset(key_type e)
  {
    this->erase(e);
    return *this;
  }
  enum_set& reset(enum_set const& other) noexcept
  {
    this->erase(other);
    return *this;
  }
  enum_set& reset(std::initializer_list<value_type> list)
  {
    this->erase(list);
    return *this;
  }
  // alternate syntax for bit reset
  enum_set& operator-=(key_type e) { return this->reset(e); }
  enum_set& operator-=(enum_set const& other) noexcept
  {
    return this->reset(other);
  }
  enum_set& operator-=(std::initializer_list<value_type> list)
  {
    return this->reset(list);
  }

  // toggle the specified enum
  enum_set& flip(key_type e)
  {
    this->Set.flip(static_cast<size_type>(e));
    return *this;
  }
  // toggle all the enums stored in the other enum_set
  enum_set& flip(enum_set const& other) noexcept
  {
    this->Set ^= other.Set;
    return *this;
  }
  // toggle all the enums specified in the list
  enum_set& flip(std::initializer_list<value_type> list)
  {
    for (auto e : list) {
      this->Set.flip(static_cast<size_type>(e));
    }
    return *this;
  }
  // alternate syntax for bit toggle
  enum_set& operator^=(key_type key) { return this->flip(key); }
  // toggle all the enums stored in the other enum_set
  enum_set& operator^=(enum_set const& other) noexcept
  {
    return this->flip(other);
  }
  // toggle all the enums specified in the list
  enum_set& operator^=(std::initializer_list<value_type> list)
  {
    return this->flip(list);
  }

  std::pair<iterator, bool> insert(key_type value)
  {
    auto exist = this->contains(value);
    if (!exist) {
      this->Set.set(static_cast<size_type>(value));
    }

    return { iterator(this, static_cast<size_type>(value)), !exist };
  }
  template <typename InputIt>
  void insert(InputIt first, InputIt last)
  {
    for (auto i = first; i != last; i++) {
      this->insert(*i);
    }
  }
  void insert(enum_set const& other) noexcept { this->Set |= other.Set; }
  void insert(std::initializer_list<value_type> list)
  {
    for (auto e : list) {
      this->Set.set(static_cast<size_type>(e));
    }
  }

  size_type erase(key_type key)
  {
    if (this->contains(key)) {
      this->Set.reset(static_cast<size_type>(key));
      return 1;
    }

    return 0;
  }
  iterator erase(iterator pos)
  {
    this->erase(*pos++);
    return pos;
  }
  iterator erase(const_iterator pos)
  {
    this->erase(*pos++);

    return pos == this->cend() ? this->end()
                               : iterator(this, static_cast<size_type>(*pos));
  }
  void erase(enum_set const& other) noexcept { this->Set &= ~other.Set; }
  void erase(std::initializer_list<value_type> list)
  {
    for (auto e : list) {
      this->Set.reset(static_cast<size_type>(e));
    }
  }

  void swap(enum_set& other) noexcept
  {
    auto tmp = this->Set;
    this->Set = other.Set;
    other.Set = tmp;
  }

  // Lookup
  size_type count(key_type e) const { return this->contains(e) ? 1 : 0; }

  iterator find(key_type e)
  {
    if (this->contains(e)) {
      return iterator(this, static_cast<size_type>(e));
    }
    return this->end();
  }
  const_iterator find(key_type e) const
  {
    if (this->contains(e)) {
      return const_iterator(this, static_cast<size_type>(e));
    }
    return this->end();
  }

  // Checks
  bool contains(key_type e) const
  {
    return this->Set.test(static_cast<size_type>(e));
  }

  bool all() const { return this->Set.all(); }
  bool any() const { return this->Set.any(); }
  bool none() const { return this->Set.none(); }
  // alternate syntax to none()
  bool operator!() const { return this->Set.none(); }

  bool all_of(enum_set const& set) const
  {
    auto result = set;
    result.Set &= this->Set;
    return result == set;
  }
  bool any_of(enum_set const& set) const
  {
    auto result = set;
    result.Set &= this->Set;
    return result.any();
  }
  bool none_of(enum_set const& set) const
  {
    auto result = set;
    result.Set &= this->Set;
    return result.none();
  }

private:
  template <typename E>
  friend inline bool operator==(enum_set<E> const& lhs,
                                enum_set<E> const& rhs) noexcept;

  template <typename E, typename Predicate>
  friend inline void erase_if(enum_set<E>& set, Predicate pred);

  friend class enum_set_iterator<enum_set>;
  friend class enum_set_iterator<enum_set const>;

  bool test(size_type pos) const { return this->Set.test(pos); }

  std::bitset<Size> Set;
};

// non-member functions for enum_set
template <typename Enum>
inline enum_set<Enum> operator+(enum_set<Enum> const& lhs, Enum rhs)
{
  return enum_set<Enum>{ lhs } += rhs;
}
template <typename Enum>
inline enum_set<Enum> operator+(enum_set<Enum> const& lhs,
                                enum_set<Enum> const& rhs) noexcept
{
  return enum_set<Enum>{ lhs } += rhs;
}
template <typename Enum>
inline enum_set<Enum> operator+(enum_set<Enum> const& lhs,
                                std::initializer_list<Enum> const rhs)
{
  return enum_set<Enum>{ lhs } += rhs;
}

template <typename Enum>
inline cm::enum_set<Enum> operator|(cm::enum_set<Enum> const& lhs, Enum rhs)
{
  return enum_set<Enum>{ lhs } |= rhs;
}
template <typename Enum>
inline cm::enum_set<Enum> operator|(Enum lhs, cm::enum_set<Enum> const& rhs)
{
  return enum_set<Enum>{ lhs } |= rhs;
}
template <typename Enum>
inline cm::enum_set<Enum> operator|(cm::enum_set<Enum> const& lhs,
                                    cm::enum_set<Enum> const& rhs)
{
  return enum_set<Enum>{ lhs } |= rhs;
}

template <typename Enum>
inline enum_set<Enum> operator-(enum_set<Enum> const& lhs, Enum rhs)
{
  return enum_set<Enum>{ lhs } -= rhs;
}
template <typename Enum>
inline enum_set<Enum> operator-(enum_set<Enum> const& lhs,
                                enum_set<Enum> const& rhs) noexcept
{
  return enum_set<Enum>{ lhs } -= rhs;
}
template <typename Enum>
inline enum_set<Enum> operator-(enum_set<Enum> const& lhs,
                                std::initializer_list<Enum> const rhs)
{
  return enum_set<Enum>{ lhs } -= rhs;
}

template <typename Enum>
inline enum_set<Enum> operator^(enum_set<Enum> const& lhs, Enum rhs)
{
  return enum_set<Enum>{ lhs } ^= rhs;
}
template <typename Enum>
inline enum_set<Enum> operator^(enum_set<Enum> const& lhs,
                                enum_set<Enum> const& rhs) noexcept
{
  return enum_set<Enum>{ lhs } ^= rhs;
}
template <typename Enum>
inline enum_set<Enum> operator^(enum_set<Enum> const& lhs,
                                std::initializer_list<Enum> const rhs)
{
  return enum_set<Enum>{ lhs } ^= rhs;
}

template <typename Enum>
inline bool operator==(enum_set<Enum> const& lhs,
                       enum_set<Enum> const& rhs) noexcept
{
  return lhs.Set == rhs.Set;
}

template <typename Enum>
inline bool operator!=(enum_set<Enum> const& lhs,
                       enum_set<Enum> const& rhs) noexcept
{
  return !(lhs == rhs);
}

template <typename Enum>
inline void erase(enum_set<Enum>& set, Enum value)
{
  set.erase(value);
}

template <typename Enum, typename Predicate>
inline void erase_if(enum_set<Enum>& set, Predicate pred)
{
  for (std::size_t index = 0; index < set.Set.size(); ++index) {
    if (set.Set.test(index) && pred(static_cast<Enum>(index))) {
      set.Set.reset(index);
    }
  }
}
} // namespace cm

template <typename Enum,
          typename cm::enable_if_t<cm::is_scoped_enum<Enum>::value, int> = 0>
inline cm::enum_set<Enum> operator+(Enum lhs, Enum rhs)
{
  return cm::enum_set<Enum>{ lhs, rhs };
}
// Alternate syntax
template <typename Enum,
          typename cm::enable_if_t<cm::is_scoped_enum<Enum>::value, int> = 0>
inline cm::enum_set<Enum> operator|(Enum lhs, Enum rhs)
{
  return cm::enum_set<Enum>{ lhs, rhs };
}