permutable_sequence.h

Go to the documentation of this file.

#pragma once

 
#include <pixie/sequence_options.h>
 
#include <concepts>
#include <cstddef>
#include <ranges>
#include <utility>
 
namespace pixie {
enum class ElementStorage { automatic, packed, indirect };

template <class Impl, class T, class ConstReference>
  requires(std::same_as<ConstReference, T> ||
           std::same_as<ConstReference, const T&>)
class PermutableSequenceBase {
 public:
  using value_type = T;
  using const_reference = ConstReference;
  using size_type = std::size_t;
  template <std::ranges::input_range Range>
    requires std::
        constructible_from<T, std::ranges::range_rvalue_reference_t<Range>>
      static Impl from_range(Range&& range) {
    return Impl::from_range_impl(std::forward<Range>(range));
  }

  size_type size() const noexcept { return impl().size_impl(); }
  bool empty() const noexcept { return size() == 0; }
  const_reference operator[](size_type position) const {
    return impl().value_at_impl(position);
  }

  void insert_at(size_type position, T value) {
    impl().insert_at_impl(position, std::move(value));
  }

  void rotate_left(size_type left, size_type right, size_type distance) {
    impl().rotate_left_impl(left, right, distance);
  }

  void merge(Impl& donor) { impl().merge_impl(donor); }
  size_type memory_usage_bytes() const noexcept {
    return impl().memory_usage_bytes_impl();
  }
 
 private:
  Impl& impl() noexcept { return static_cast<Impl&>(*this); }
  const Impl& impl() const noexcept { return static_cast<const Impl&>(*this); }
};
}  // namespace pixie