Class ordered_set

include/tsl/ordered_set.h:81–827

          class ValueTypeContainer = std::deque<Key, Allocator>,
          class IndexType = std::uint_least32_t>
class ordered_set {
 private:
  template <typename U>
  using has_is_transparent = tsl::detail_ordered_hash::has_is_transparent<U>;

  class KeySelect {
   public:
    using key_type = Key;

    const key_type& operator()(const Key& key) const noexcept { return key; }

    key_type& operator()(Key& key) noexcept { return key; }
  };

  using ht = detail_ordered_hash::ordered_hash<Key, KeySelect, void, Hash,
                                               KeyEqual, Allocator,
                                               ValueTypeContainer, IndexType>;

 public:
  using key_type = typename ht::key_type;
  using value_type = typename ht::value_type;
  using size_type = typename ht::size_type;
  using difference_type = typename ht::difference_type;
  using hasher = typename ht::hasher;
  using key_equal = typename ht::key_equal;
  using allocator_type = typename ht::allocator_type;
  using reference = typename ht::reference;
  using const_reference = typename ht::const_reference;
  using pointer = typename ht::pointer;
  using const_pointer = typename ht::const_pointer;
  using iterator = typename ht::iterator;
  using const_iterator = typename ht::const_iterator;
  using reverse_iterator = typename ht::reverse_iterator;
  using const_reverse_iterator = typename ht::const_reverse_iterator;

  using values_container_type = typename ht::values_container_type;

  /*
   * Constructors
   */
  ordered_set() : ordered_set(ht::DEFAULT_INIT_BUCKETS_SIZE) {}

  explicit ordered_set(size_type bucket_count, const Hash& hash = Hash(),
                       const KeyEqual& equal = KeyEqual(),
                       const Allocator& alloc = Allocator())
      : m_ht(bucket_count, hash, equal, alloc, ht::DEFAULT_MAX_LOAD_FACTOR) {}

  ordered_set(size_type bucket_count, const Allocator& alloc)
      : ordered_set(bucket_count, Hash(), KeyEqual(), alloc) {}

  ordered_set(size_type bucket_count, const Hash& hash, const Allocator& alloc)
      : ordered_set(bucket_count, hash, KeyEqual(), alloc) {}

  explicit ordered_set(const Allocator& alloc)
      : ordered_set(ht::DEFAULT_INIT_BUCKETS_SIZE, alloc) {}

  template <class InputIt>
  ordered_set(InputIt first, InputIt last,