di 0.1.0
Loading...
Searching...
No Matches
di::container Namespace Reference

Namespaces

namespace  erase_ns
namespace  ring
namespace  string
namespace  vector
namespace  view

Classes

struct  InFoundResult
struct  InFunResult
struct  InInOutResult
struct  InInResult
struct  InOutOutResult
struct  InOutResult
struct  InValueResult
struct  MinMaxResult
struct  OutValueResult
struct  Allocation
struct  AllocationResult
struct  FailAllocator
struct  FallibleAllocator
struct  InfallibleAllocator
class  IntrusiveSetInterface
class  MapInterface
class  SetInterface
struct  DefaultHasher
struct  HashNode
class  HashNodeIterator
class  NodeHashMap
class  NodeHashMultiMap
class  NodeHashMultiSet
class  NodeHashSet
class  NodeHashTable
 Node based (closed addressing) hash table. More...
struct  OwningHashNodeTag
struct  OwningHashNode
class  OwningNodeHashTable
struct  BeginFunction
struct  CBeginFunction
struct  CDataFunction
struct  CEndFunction
struct  CRBeginFunction
struct  CREndFunction
struct  DataFunction
struct  EmptyFunction
struct  EnableBorrowedContainer
struct  EnableViewFunction
struct  EndFunction
struct  RBeginFunction
struct  ReconstructFunction
struct  REndFunction
struct  SizeFunction
struct  SSizeFunction
struct  IntrusiveForwardListTag
struct  DefaultIntrusiveForwardListTag
class  IntrusiveForwardList
class  IntrusiveForwardListNode
struct  IntrusiveHashSetTag
struct  DefaultIntrusiveHashSetTag
class  IntrusiveHashSet
class  IntrusiveHashMultiSet
struct  IntrusiveTagBase
struct  IntrusiveListTag
struct  DefaultIntrusiveListTag
class  IntrusiveList
class  IntrusiveListNode
struct  IntrusiveTreeSetTag
struct  DefaultIntrusiveTreeSetTag
class  IntrusiveTreeSet
class  IntrusiveTreeMultiSet
struct  AdvanceFunction
class  CommonIterator
class  ConstIteratorImpl
class  CountedIterator
struct  Dangling
struct  DefaultSentinel
struct  IteratorBase
struct  IteratorCategoryFunction
class  IteratorExtension
struct  IteratorSSizeTypeFunction
struct  IteratorValueFunction
class  MoveIterator
class  MoveSentinel
struct  NextFunction
struct  PrevFunction
class  ReverseIterator
class  SentinelBase
class  SentinelExtension
struct  UnreachableSentinel
class  LinkedList
class  PathViewImpl
class  ConstantPathInterface
class  PathImpl
class  PathIterator
class  PriorityQueue
class  Queue
class  Stack
class  ConstantRingInterface
class  MutableRingInterface
class  Ring
class  RingIterator
class  StaticRing
class  ErasedString
class  FixedString
class  ZStringImpl
struct  OwningRBTreeTag
struct  OwningRBTreeNode
class  OwningRBTree
class  RBTree
 General implementation of the Red-Black self-balancing binary tree. More...
class  RBTreeIterator
struct  RBTreeNode
class  TreeMap
class  TreeMultiMap
class  TreeMultiSet
class  TreeSet
class  ConstantVectorInterface
class  MutableVectorInterface
struct  NoCapacityError
class  StaticVector
class  Vector
class  AdjacentTransformView
class  AdjacentView
class  AsConstView
class  AsRValueView
class  CacheLastView
class  CartesianProductView
class  ChunkByView
class  ChunkView
class  ChunkView< View >
class  CommonView
class  ConcatView
class  CycleView
class  DropView
class  DropWhileView
class  ElementsView
class  EmptyView
class  EnumerateView
class  FilterView
class  IotaView
class  JoinView
class  JoinWithView
class  OwningView
class  RefView
class  RepeatView
class  ReverseView
class  SingleView
class  SlideView
class  SplitView
class  StrideView
class  TakeView
class  TakeWhileView
class  TransformView
class  View
class  ViewInterface
class  ZipTransformView
class  ZipView

Typedefs

template<typename In, typename Out>
using MoveResult = InOutResult<In, Out>
template<typename In, typename Out>
using MoveBackwardResult = InOutResult<In, Out>
template<typename In, typename Out>
using UninitializedRelocateResult = container::InOutResult<In, Out>
template<typename In, typename Out>
using UninitializedRelocateBackwardsResult = container::InOutResult<In, Out>
template<typename T>
using StdAllocator = std::allocator<T>
template<typename Tag>
using IntrusiveHashSetNode = HashNode<Tag>
template<typename Tag = DefaultIntrusiveTreeSetTag>
using IntrusiveTreeSetNode = RBTreeNode<Tag>
using Path = PathImpl<TransparentString>
using Utf8Path = PathImpl<String>
using PathView = PathViewImpl<string::TransparentEncoding>
using Utf8PathView = PathViewImpl<string::Utf8Encoding>
using String = string::StringImpl<string::Utf8Encoding>
using TransparentString = string::StringImpl<string::TransparentEncoding>
using StringView = string::StringViewImpl<string::Utf8Encoding>
using TransparentStringView = string::StringViewImpl<string::TransparentEncoding>
using ZCString = ZStringImpl<char const>
using ZCUString = ZStringImpl<unsigned char const>
using ZCWString = ZStringImpl<wchar_t const>
using ZString = ZStringImpl<char>
using ZUString = ZStringImpl<unsigned char>
using ZWString = ZStringImpl<wchar_t>
using ZC8CString = ZStringImpl<c8 const>
using ZC8String = ZStringImpl<c8>
using ZC16CString = ZStringImpl<c16 const>
using ZC16String = ZStringImpl<c16>
using ZC32CString = ZStringImpl<c32 const>
using ZC32String = ZStringImpl<c32>
template<typename Con>
using KeysView = ElementsView<Con, 0>
template<typename Con>
using ValuesView = ElementsView<Con, 1>

Functions

template<typename Out, concepts::InputContainer Con, typename... Args>
requires (!concepts::View<Out> && concepts::Expected<meta::ContainerValue<Con>>)
constexpr auto sequence_to (Con &&container, Args &&... args)
template<template< typename... > typename Template, concepts::InputContainer Con, typename... Args, typename UnwrappedContainer = EmptyView<meta::ExpectedValue<meta::ContainerValue<Con>>>>
requires (concepts::CreateDeducible<Template, UnwrappedContainer, Args...> || concepts::CreateDeducible<Template, FromContainer, UnwrappedContainer, Args...>)
constexpr auto sequence_to (Con &&container, Args &&... args)
template<typename Out, typename... Args>
requires (!concepts::View<Out>)
constexpr auto sequence_to (Args &&... args)
template<template< typename... > typename Template, typename... Args>
constexpr auto sequence_to (Args &&... args)
template<typename Out, concepts::InputContainer Con, typename... Args>
requires (!concepts::View<Out>)
constexpr auto to (Con &&container, Args &&... args)
template<template< typename... > typename Template, concepts::InputContainer Con, typename... Args>
requires (concepts::CreateDeducible<Template, Con, Args...> || concepts::CreateDeducible<Template, FromContainer, Con, Args...>)
constexpr auto to (Con &&container, Args &&... args)
template<typename Out, typename... Args>
requires (!concepts::View<Out>)
constexpr auto to (Args &&... args)
template<template< typename... > typename Template, typename... Args>
constexpr auto to (Args &&... args)
template<concepts::InputContainer Con, concepts::TupleLike T = meta::ContainerValue<Con>>
requires (meta::TupleSize<T> == 2)
auto tag_invoke (types::Tag< util::deduce_create >, InPlaceTemplate< NodeHashMap >, Con &&) -> NodeHashMap< meta::TupleElement< T, 0 >, meta::TupleElement< T, 1 > >
template<concepts::InputContainer Con, concepts::TupleLike T = meta::ContainerValue<Con>, typename Eq>
requires (meta::TupleSize<T> == 2)
auto tag_invoke (types::Tag< util::deduce_create >, InPlaceTemplate< NodeHashMap >, Con &&, Eq) -> NodeHashMap< meta::TupleElement< T, 0 >, meta::TupleElement< T, 1 >, Eq >
template<concepts::InputContainer Con, concepts::TupleLike T = meta::ContainerValue<Con>, typename Eq, typename Hasher>
requires (meta::TupleSize<T> == 2)
auto tag_invoke (types::Tag< util::deduce_create >, InPlaceTemplate< NodeHashMap >, Con &&, Eq, Hasher) -> NodeHashMap< meta::TupleElement< T, 0 >, meta::TupleElement< T, 1 >, Eq, Hasher >
template<concepts::InputContainer Con, concepts::TupleLike T = meta::ContainerValue<Con>>
requires (meta::TupleSize<T> == 2)
auto tag_invoke (types::Tag< util::deduce_create >, InPlaceTemplate< NodeHashMultiMap >, Con &&) -> NodeHashMultiMap< meta::TupleElement< T, 0 >, meta::TupleElement< T, 1 > >
template<concepts::InputContainer Con, concepts::TupleLike T = meta::ContainerValue<Con>, typename Eq>
requires (meta::TupleSize<T> == 2)
auto tag_invoke (types::Tag< util::deduce_create >, InPlaceTemplate< NodeHashMultiMap >, Con &&, Eq) -> NodeHashMultiMap< meta::TupleElement< T, 0 >, meta::TupleElement< T, 1 >, Eq >
template<concepts::InputContainer Con, concepts::TupleLike T = meta::ContainerValue<Con>, typename Eq, typename Hasher>
requires (meta::TupleSize<T> == 2)
auto tag_invoke (types::Tag< util::deduce_create >, InPlaceTemplate< NodeHashMultiMap >, Con &&, Eq, Hasher) -> NodeHashMultiMap< meta::TupleElement< T, 0 >, meta::TupleElement< T, 1 >, Eq, Hasher >
template<concepts::InputContainer Con, typename T = meta::ContainerValue<Con>>
auto tag_invoke (types::Tag< util::deduce_create >, InPlaceTemplate< NodeHashMultiSet >, Con &&) -> NodeHashMultiSet< T >
template<concepts::InputContainer Con, typename T = meta::ContainerValue<Con>, typename Eq>
auto tag_invoke (types::Tag< util::deduce_create >, InPlaceTemplate< NodeHashMultiSet >, Con &&, Eq) -> NodeHashMultiSet< T, Eq >
template<concepts::InputContainer Con, typename T = meta::ContainerValue<Con>, typename Eq, typename Hasher>
auto tag_invoke (types::Tag< util::deduce_create >, InPlaceTemplate< NodeHashMultiSet >, Con &&, Eq, Hasher) -> NodeHashMultiSet< T, Eq, Hasher >
template<concepts::InputContainer Con, typename T = meta::ContainerValue<Con>>
auto tag_invoke (types::Tag< util::deduce_create >, InPlaceTemplate< NodeHashSet >, Con &&) -> NodeHashSet< T >
template<concepts::InputContainer Con, typename T = meta::ContainerValue<Con>, typename Eq>
auto tag_invoke (types::Tag< util::deduce_create >, InPlaceTemplate< NodeHashSet >, Con &&, Eq) -> NodeHashSet< T, Eq >
template<concepts::InputContainer Con, typename T = meta::ContainerValue<Con>, typename Eq, typename Hasher>
auto tag_invoke (types::Tag< util::deduce_create >, InPlaceTemplate< NodeHashSet >, Con &&, Eq, Hasher) -> NodeHashSet< T, Eq, Hasher >
template<typename Iter, concepts::EqualityComparableWith< Iter > U>
constexpr auto operator== (MoveIterator< Iter > const &a, MoveIterator< U > const &b) -> bool
template<typename Iter, concepts::ThreeWayComparableWith< Iter > U>
constexpr auto operator<=> (MoveIterator< Iter > const &a, MoveIterator< U > const &b)
template<typename Iter, typename U>
constexpr auto operator- (MoveIterator< Iter > const &a, MoveIterator< U > const &b) -> decltype(a.base() - b.base())
template<concepts::InputIterator Iter>
constexpr auto make_move_iterator (Iter iterator)
template<typename Iter, concepts::EqualityComparableWith< Iter > U>
constexpr auto operator== (ReverseIterator< Iter > const &a, ReverseIterator< U > const &b) -> bool
template<typename Iter, concepts::ThreeWayComparableWith< Iter > U>
constexpr auto operator<=> (ReverseIterator< Iter > const &a, ReverseIterator< U > const &b)
template<typename Iter, typename U>
constexpr auto operator- (ReverseIterator< Iter > const &a, ReverseIterator< U > const &b) -> decltype(b.base() - a.base())
template<concepts::BidirectionalIterator Iter>
constexpr auto make_reverse_iterator (Iter iter)
template<concepts::InputContainer Con, typename T = meta::ContainerValue<Con>>
auto tag_invoke (types::Tag< util::deduce_create >, InPlaceTemplate< LinkedList >, Con &&) -> LinkedList< T >
template<concepts::Container Con, typename T = meta::ContainerValue<Con>, concepts::StrictWeakOrder< T > Comp>
requires (detail::PriorityQueueCompatible<Con, T>)
 PriorityQueue (Comp, Con) -> PriorityQueue< T, Con, Comp >
template<concepts::InputContainer Con, typename T = meta::ContainerValue<Con>>
auto tag_invoke (types::Tag< util::deduce_create >, InPlaceTemplate< PriorityQueue >, Con &&) -> PriorityQueue< T >
template<concepts::InputContainer Con, typename T = meta::ContainerValue<Con>, concepts::StrictWeakOrder< T > Comp>
auto tag_invoke (types::Tag< util::deduce_create >, InPlaceTemplate< PriorityQueue >, Con &&, Comp) -> PriorityQueue< T, container::Vector< T >, Comp >
template<concepts::Container Con, typename T = meta::ContainerValue<Con>>
requires (detail::QueueCompatible<Con, T>)
 Queue (Con) -> Queue< T, Con >
template<concepts::InputContainer Con, typename T = meta::ContainerValue<Con>>
auto tag_invoke (types::Tag< util::deduce_create >, InPlaceTemplate< Queue >, Con &&) -> Queue< T >
template<concepts::Container Con, typename T = meta::ContainerValue<Con>>
requires (detail::StackCompatible<Con, T>)
 Stack (Con) -> Stack< T, Con >
template<concepts::InputContainer Con, typename T = meta::ContainerValue<Con>>
auto tag_invoke (types::Tag< util::deduce_create >, InPlaceTemplate< Stack >, Con &&) -> Stack< T >
template<concepts::InputContainer Con, typename T = meta::ContainerValue<Con>>
auto tag_invoke (types::Tag< util::deduce_create >, InPlaceTemplate< Ring >, Con &&) -> Ring< T >
template<types::size_t size>
 FixedString (char const (&)[size]) -> FixedString< size - 1 >
template<concepts::InputContainer Con, concepts::TupleLike T = meta::ContainerValue<Con>>
requires (meta::TupleSize<T> == 2)
auto tag_invoke (types::Tag< util::deduce_create >, InPlaceTemplate< TreeMap >, Con &&) -> TreeMap< meta::TupleElement< T, 0 >, meta::TupleElement< T, 1 > >
template<concepts::InputContainer Con, concepts::TupleLike T = meta::ContainerValue<Con>, concepts::StrictWeakOrder< T > Comp>
requires (meta::TupleSize<T> == 2)
auto tag_invoke (types::Tag< util::deduce_create >, InPlaceTemplate< TreeMap >, Con &&, Comp) -> TreeMap< meta::TupleElement< T, 0 >, meta::TupleElement< T, 1 >, Comp >
template<concepts::InputContainer Con, concepts::TupleLike T = meta::ContainerValue<Con>>
requires (meta::TupleSize<T> == 2)
auto tag_invoke (types::Tag< util::deduce_create >, InPlaceTemplate< TreeMultiMap >, Con &&) -> TreeMultiMap< meta::TupleElement< T, 0 >, meta::TupleElement< T, 1 > >
template<concepts::InputContainer Con, concepts::TupleLike T = meta::ContainerValue<Con>, concepts::StrictWeakOrder< T > Comp>
requires (meta::TupleSize<T> == 2)
auto tag_invoke (types::Tag< util::deduce_create >, InPlaceTemplate< TreeMultiMap >, Con &&, Comp) -> TreeMultiMap< meta::TupleElement< T, 0 >, meta::TupleElement< T, 1 >, Comp >
template<concepts::InputContainer Con, typename T = meta::ContainerValue<Con>>
auto tag_invoke (types::Tag< util::deduce_create >, InPlaceTemplate< TreeMultiSet >, Con &&) -> TreeMultiSet< T >
template<concepts::InputContainer Con, typename T = meta::ContainerValue<Con>, concepts::StrictWeakOrder< T > Comp>
auto tag_invoke (types::Tag< util::deduce_create >, InPlaceTemplate< TreeMultiSet >, Con &&, Comp) -> TreeMultiSet< T, Comp >
template<concepts::InputContainer Con, typename T = meta::ContainerValue<Con>>
auto tag_invoke (types::Tag< util::deduce_create >, InPlaceTemplate< TreeSet >, Con &&) -> TreeSet< T >
template<concepts::InputContainer Con, typename T = meta::ContainerValue<Con>, concepts::StrictWeakOrder< T > Comp>
auto tag_invoke (types::Tag< util::deduce_create >, InPlaceTemplate< TreeSet >, Con &&, Comp) -> TreeSet< T, Comp >
template<concepts::InputContainer Con, typename T = meta::ContainerValue<Con>>
auto tag_invoke (types::Tag< util::deduce_create >, InPlaceTemplate< Vector >, Con &&) -> Vector< T >
template<typename Con>
 AsConstView (Con &&) -> AsConstView< meta::AsView< Con > >
template<typename Con>
 AsRValueView (Con &&) -> AsRValueView< meta::AsView< Con > >
template<typename... Cons>
 CartesianProductView (Cons &&...) -> CartesianProductView< meta::AsView< Cons >... >
template<typename Con, typename Pred>
 ChunkByView (Con &&, Pred) -> ChunkByView< meta::AsView< Con >, Pred >
template<typename Con>
 ChunkView (Con &&, meta::ContainerSSizeType< Con >) -> ChunkView< meta::AsView< Con > >
template<typename Con>
 CommonView (Con &&) -> CommonView< meta::AsView< Con > >
template<typename... Cons>
 ConcatView (Cons &&...) -> ConcatView< meta::AsView< Cons >... >
template<typename Con>
 CycleView (Con &&) -> CycleView< meta::AsView< Con > >
template<typename Con>
 DropView (Con &&, meta::ContainerSSizeType< Con >) -> DropView< meta::AsView< Con > >
template<typename Con, typename Pred>
 DropWhileView (Con &&, Pred) -> DropWhileView< meta::AsView< Con >, Pred >
template<typename Con>
 EnumerateView (Con &&) -> EnumerateView< meta::AsView< Con > >
template<typename Con, typename Pred>
 FilterView (Con &&, Pred) -> FilterView< meta::AsView< Con >, Pred >
template<typename T, typename Bound>
requires (!concepts::Integer<T> || !concepts::Integer<Bound> || concepts::SignedInteger<T> == concepts::SignedInteger<Bound>)
 IotaView (T, Bound) -> IotaView< T, Bound >
template<typename Con>
 JoinView (Con &&) -> JoinView< meta::AsView< Con > >
template<typename Con, typename Pattern>
 JoinWithView (Con &&, Pattern &&) -> JoinWithView< meta::AsView< Con >, meta::AsView< Pattern > >
template<concepts::InputContainer Con>
 JoinWithView (Con &&, meta::ContainerValue< meta::ContainerReference< Con > >) -> JoinWithView< meta::AsView< Con >, SingleView< meta::ContainerValue< meta::ContainerReference< Con > > > >
template<typename Cont>
 RefView (Cont &) -> RefView< Cont >
template<typename T, typename Bound>
 RepeatView (T, Bound) -> RepeatView< T, Bound >
template<typename Con>
 ReverseView (Con &&) -> ReverseView< meta::AsView< Con > >
template<typename T>
 SingleView (T) -> SingleView< T >
template<typename Con>
 SlideView (Con &&, meta::ContainerSSizeType< Con >) -> SlideView< meta::AsView< Con > >
template<typename Con, typename Pattern>
 SplitView (Con &&, Pattern &&) -> SplitView< meta::AsView< Con >, meta::AsView< Pattern > >
template<concepts::InputContainer Con>
 SplitView (Con &&, meta::ContainerValue< Con >) -> SplitView< meta::AsView< Con >, SingleView< meta::ContainerValue< Con > > >
template<typename Con>
 StrideView (Con &&, meta::ContainerSSizeType< Con >) -> StrideView< meta::AsView< Con > >
template<typename Con>
 TakeView (Con &&, meta::ContainerSSizeType< Con >) -> TakeView< meta::AsView< Con > >
template<typename Con, typename Pred>
 TakeWhileView (Con &&, Pred) -> TakeWhileView< meta::AsView< Con >, Pred >
template<typename Con, typename F>
 TransformView (Con &&, F) -> TransformView< meta::AsView< Con >, F >
template<concepts::Iterator Iter, concepts::SentinelFor< Iter > Sent>
 View (Iter, Sent) -> View< Iter, Sent >
template<concepts::Iterator Iter, concepts::SentinelFor< Iter > Sent>
 View (Iter, Sent, meta::IteratorSizeType< Iter >) -> View< Iter, Sent, true >
template<concepts::BorrowedContainer Cont>
 View (Cont &&) -> View< meta::ContainerIterator< Cont >, meta::ContainerSentinel< Cont >, concepts::SizedContainer< Cont >||concepts::SizedSentinelFor< meta::ContainerSentinel< Cont >, meta::ContainerIterator< Cont > > >
template<concepts::BorrowedContainer Cont>
 View (Cont &&, meta::ContainerSizeType< Cont >) -> View< meta::ContainerIterator< Cont >, meta::ContainerSentinel< Cont >, true >
template<class F, class... Cons>
 ZipTransformView (F, Cons &&...) -> ZipTransformView< F, meta::AsView< Cons >... >
template<typename... Cons>
 ZipView (Cons &&...) -> ZipView< meta::AsView< Cons >... >

Variables

constexpr auto sequence = function::curry_back(detail::SequenceFunction {}, meta::c_<2ZU>)
constexpr auto adjacent_find = detail::AdjacentFindFunction {}
constexpr auto all_of = detail::AllOfFunction {}
constexpr auto any_of = detail::AnyOfFunction {}
constexpr auto binary_search = detail::BinarySearchFunction {}
constexpr auto compare = detail::CompareFunction {}
constexpr auto contains = detail::ContainsFunction {}
constexpr auto contains_subrange = detail::ContainsSubrangeFunction {}
constexpr auto copy = detail::CopyFunction {}
constexpr auto copy_backward = detail::CopyBackwardFunction {}
constexpr auto copy_if = detail::CopyIfFunction {}
constexpr auto copy_n = detail::CopyNFunction {}
constexpr auto count = detail::CountFunction {}
constexpr auto count_if = detail::CountIfFunction {}
constexpr auto destroy = detail::DestroyFunction {}
constexpr auto destroy_n = detail::DestroyNFunction {}
constexpr auto ends_with = detail::EndsWithFunction {}
constexpr auto equal = detail::EqualFunction {}
constexpr auto equal_range = detail::EqualRangeFunction {}
constexpr auto fill = detail::FillFunction {}
constexpr auto fill_n = detail::FillNFunction {}
constexpr auto find = detail::FindFunction {}
constexpr auto find_end = detail::FindEndFunction {}
constexpr auto find_first_not_of = detail::FindFirstNotOfFunction {}
constexpr auto find_first_of = detail::FindFirstOfFunction {}
constexpr auto find_if = detail::FindIfFunction {}
constexpr auto find_if_not = detail::FindIfNotFunction {}
constexpr auto find_last = detail::FindLastFunction {}
constexpr auto find_last_if = detail::FindLastIfFunction {}
constexpr auto find_last_if_not = detail::FindLastIfNotFunction {}
constexpr auto find_last_not_of = detail::FindLastNotOfFunction {}
constexpr auto find_last_of = detail::FindLastOfFunction {}
constexpr auto fold_left = function::curry_back(detail::FoldLeftFunction {}, meta::c_<3ZU>)
constexpr auto fold_left_first = function::curry_back(detail::FoldLeftFirstFunction {}, meta::c_<2ZU>)
constexpr auto fold_left_first_with_iter = detail::FoldLeftFirstWithIterFunction {}
constexpr auto fold_left_with_iter = detail::FoldLeftWithIterFunction {}
constexpr auto fold_right = detail::FoldRightFunction {}
constexpr auto fold_right_last = detail::FoldRightLastFunction {}
constexpr auto for_each = detail::ForEachFunction {}
constexpr auto for_each_n = detail::ForEachNFunction {}
constexpr auto generate = detail::GenerateFunction {}
constexpr auto generate_n = detail::GenerateNFunction {}
constexpr auto includes = detail::IncludesFunction {}
constexpr auto iota = detail::IotaFunction {}
constexpr auto is_heap = detail::IsHeapFunction {}
constexpr auto is_heap_until = detail::IsHeapUntilFunction {}
constexpr auto is_partitioned = detail::IsPartitionedFunction {}
constexpr auto is_permutation = detail::IsPermutationFunction {}
constexpr auto is_sorted = detail::IsSortedFunction {}
constexpr auto is_sorted_until = detail::IsSortedUntilFunction {}
constexpr auto lower_bound = detail::LowerBoundFunction {}
constexpr auto make_heap = detail::MakeHeapFunction {}
constexpr auto max = detail::MaxFunction {}
constexpr auto max_element = detail::MaxElementFunction {}
constexpr auto merge = detail::MergeFunction {}
constexpr auto min = detail::MinFunction {}
constexpr auto min_element = detail::MinElementFunction {}
constexpr auto minmax = detail::MinMaxFunction {}
constexpr auto minmax_element = detail::MinMaxElementFunction {}
constexpr auto mismatch = detail::MismatchFunction {}
constexpr auto move = detail::MoveFunction {}
constexpr auto move_backward = detail::MoveBackwardFunction {}
constexpr auto next_permutation = detail::NextPermutationFunction {}
constexpr auto none_of = detail::NoneOfFunction {}
constexpr auto partition = detail::PartitionFunction {}
constexpr auto partition_copy = detail::PartitionCopyFunction {}
constexpr auto partition_point = detail::PartitionPointFunction {}
constexpr auto pop_heap = detail::PopHeapFunction {}
constexpr auto prev_permutation = detail::PrevPermutationFunction {}
constexpr auto product = detail::ProductFunction {}
constexpr auto push_heap = detail::PushHeapFunction {}
constexpr auto remove = detail::RemoveFunction {}
constexpr auto remove_copy = detail::RemoveCopyFunction {}
constexpr auto remove_copy_if = detail::RemoveCopyIfFunction {}
constexpr auto remove_if = detail::RemoveIfFunction {}
constexpr auto replace = detail::ReplaceFunction {}
constexpr auto replace_copy = detail::ReplaceCopyFunction {}
constexpr auto replace_copy_if = detail::ReplaceCopyIfFunction {}
constexpr auto replace_if = detail::ReplaceIfFunction {}
constexpr auto reverse = detail::ReverseFunction {}
constexpr auto reverse_copy = detail::ReverseCopyFunction {}
constexpr auto rotate = detail::RotateFunction {}
constexpr auto rotate_copy = detail::RotateCopyFunction {}
constexpr auto sample = detail::SampleFunction {}
constexpr auto search = detail::SearchFunction {}
constexpr auto search_n = detail::SearchNFunction {}
constexpr auto set_difference = detail::SetDifferenceFunction {}
constexpr auto set_intersection = detail::SetIntersectionFunction {}
constexpr auto set_symmetric_difference = detail::SetSymmetricDifferenceFunction {}
constexpr auto set_union = detail::SetUnionFunction {}
constexpr auto shift_left = detail::ShiftLeftFunction {}
constexpr auto shift_right = detail::ShiftRightFunction {}
constexpr auto shuffle = detail::ShuffleFunction {}
constexpr auto sort = detail::SortFunction {}
constexpr auto sort_heap = detail::SortHeapFunction {}
constexpr auto stable_partition = detail::StablePartitionFunction {}
constexpr auto starts_with = detail::StartsWithFunction {}
constexpr auto sum = detail::SumFunction {}
constexpr auto swap_ranges = detail::SwapRanges {}
constexpr auto transform = detail::TransformFunction {}
constexpr auto uninitialized_copy = detail::UninitializedCopyFunction {}
constexpr auto uninitialized_copy_n = detail::UninitializedCopyNFunction {}
constexpr auto uninitialized_default_construct = detail::UninitializedDefaultConstructFunction {}
constexpr auto uninitialized_default_construct_n = detail::UninitializedDefaultConstructNFunction {}
constexpr auto uninitialized_fill = detail::UninitializedFillFunction {}
constexpr auto uninitialized_fill_n = detail::UninitializedFillNFunction {}
constexpr auto uninitialized_move = detail::UninitializedMoveFunction {}
constexpr auto uninitialized_move_n = detail::UninitializedMoveNFunction {}
constexpr auto uninitialized_relocate = detail::UninitializedRelocateFunction {}
constexpr auto uninitialized_relocate_backwards = detail::UninitializedRelocateBackwardsFunction {}
constexpr auto uninitialized_value_construct = detail::UninitializedValueConstructFunction {}
constexpr auto uninitialized_value_construct_n = detail::UninitializedValueConstructNFunction {}
constexpr auto unique = detail::UniqueFunction {}
constexpr auto unique_copy = detail::UniqueCopyFunction {}
constexpr auto upper_bound = detail::UpperBoundFunction {}
constexpr auto allocate = detail::AllocateFunction {}
template<typename T>
constexpr auto allocate_many = detail::AllocateManyFunction<T> {}
template<typename T>
constexpr auto allocate_one = detail::AllocateOneFunction<T> {}
constexpr auto deallocate = detail::DeallocateFunction {}
template<typename T>
constexpr auto deallocate_many = detail::DeallocateManyFunction<T> {}
template<typename T>
constexpr auto deallocate_one = detail::DeallocateOneFunction<T> {}
constexpr auto fail_allocator = FailAllocator {}
constexpr auto hash = detail::HashFunction {}
constexpr auto hash_same = detail::HashSameFunction {}
constexpr auto hash_write = detail::HashWriteFunction {}
constexpr auto front = detail::FrontFunction {}
constexpr auto back = detail::BackFunction {}
constexpr auto at = di::curry_back(detail::AtFunction {}, c_<2ZU>)
constexpr auto front_unchecked = detail::FrontUncheckedFunction {}
constexpr auto back_unchecked = detail::BackUncheckedFunction {}
constexpr auto at_unchecked = di::curry_back(detail::AtUncheckedFunction {}, c_<2ZU>)
constexpr auto begin = BeginFunction {}
constexpr auto cbegin = CBeginFunction {}
constexpr auto cdata = CDataFunction {}
constexpr auto cend = CEndFunction {}
constexpr auto crbegin = CRBeginFunction {}
constexpr auto crend = CREndFunction {}
constexpr auto data = DataFunction {}
constexpr auto empty = EmptyFunction {}
constexpr struct di::container::EnableBorrowedContainer enable_borrowed_container
constexpr struct di::container::EnableViewFunction enable_view
constexpr auto end = EndFunction {}
constexpr auto erase = erase_ns::EraseFunction {}
constexpr auto erase_if = erase_ns::EraseIfFunction {}
constexpr auto rbegin = RBeginFunction {}
constexpr auto reconstruct = ReconstructFunction {}
constexpr auto rend = REndFunction {}
constexpr auto size = SizeFunction {}
constexpr auto ssize = SSizeFunction {}
constexpr auto advance = AdvanceFunction {}
constexpr auto default_sentinel = DefaultSentinel {}
constexpr auto distance = detail::DistanceFunction {}
constexpr struct di::container::IteratorCategoryFunction iterator_category
constexpr auto iterator_move = detail::IteratorMoveFunction {}
constexpr struct di::container::IteratorSSizeTypeFunction iterator_ssize_type
constexpr auto iterator_swap = detail::IteratorSwapFunction {}
constexpr struct di::container::IteratorValueFunction iterator_value
constexpr auto next = NextFunction {}
constexpr auto prev = PrevFunction {}
constexpr auto unreachable_sentinel = UnreachableSentinel {}
constexpr auto into_erased_string = detail::IntoErasedStringFunction {}
constexpr auto fixed_string_concat = detail::FixedStringConcat {}
template<FixedString literal>
constexpr auto fixed_string_to_utf8_string_view = detail::FixedStringToUtf8StringViewFunction<literal> {}

Typedef Documentation

◆ IntrusiveHashSetNode

template<typename Tag>
using di::container::IntrusiveHashSetNode = HashNode<Tag>

◆ IntrusiveTreeSetNode

template<typename Tag = DefaultIntrusiveTreeSetTag>
using di::container::IntrusiveTreeSetNode = RBTreeNode<Tag>

◆ KeysView

template<typename Con>
using di::container::KeysView = ElementsView<Con, 0>

◆ MoveBackwardResult

template<typename In, typename Out>
using di::container::MoveBackwardResult = InOutResult<In, Out>

◆ MoveResult

template<typename In, typename Out>
using di::container::MoveResult = InOutResult<In, Out>

◆ Path

using di::container::Path = PathImpl<TransparentString>

◆ PathView

using di::container::PathView = PathViewImpl<string::TransparentEncoding>

◆ StdAllocator

template<typename T>
using di::container::StdAllocator = std::allocator<T>

◆ String

using di::container::String = string::StringImpl<string::Utf8Encoding>

◆ StringView

using di::container::StringView = string::StringViewImpl<string::Utf8Encoding>

◆ TransparentString

using di::container::TransparentString = string::StringImpl<string::TransparentEncoding>

◆ TransparentStringView

using di::container::TransparentStringView = string::StringViewImpl<string::TransparentEncoding>

◆ UninitializedRelocateBackwardsResult

template<typename In, typename Out>
using di::container::UninitializedRelocateBackwardsResult = container::InOutResult<In, Out>

◆ UninitializedRelocateResult

template<typename In, typename Out>
using di::container::UninitializedRelocateResult = container::InOutResult<In, Out>

◆ Utf8Path

using di::container::Utf8Path = PathImpl<String>

◆ Utf8PathView

using di::container::Utf8PathView = PathViewImpl<string::Utf8Encoding>

◆ ValuesView

template<typename Con>
using di::container::ValuesView = ElementsView<Con, 1>

◆ ZC16CString

using di::container::ZC16CString = ZStringImpl<c16 const>

◆ ZC16String

using di::container::ZC16String = ZStringImpl<c16>

◆ ZC32CString

using di::container::ZC32CString = ZStringImpl<c32 const>

◆ ZC32String

using di::container::ZC32String = ZStringImpl<c32>

◆ ZC8CString

using di::container::ZC8CString = ZStringImpl<c8 const>

◆ ZC8String

using di::container::ZC8String = ZStringImpl<c8>

◆ ZCString

using di::container::ZCString = ZStringImpl<char const>

◆ ZCUString

using di::container::ZCUString = ZStringImpl<unsigned char const>

◆ ZCWString

using di::container::ZCWString = ZStringImpl<wchar_t const>

◆ ZString

using di::container::ZString = ZStringImpl<char>

◆ ZUString

using di::container::ZUString = ZStringImpl<unsigned char>

◆ ZWString

using di::container::ZWString = ZStringImpl<wchar_t>

Function Documentation

◆ AsConstView()

template<typename Con>
di::container::AsConstView ( Con && ) ->AsConstView< meta::AsView< Con > >

◆ AsRValueView()

template<typename Con>
di::container::AsRValueView ( Con && ) ->AsRValueView< meta::AsView< Con > >

◆ CartesianProductView()

template<typename... Cons>
di::container::CartesianProductView ( Cons && ...) ->CartesianProductView< meta::AsView< Cons >... >

◆ ChunkByView()

template<typename Con, typename Pred>
di::container::ChunkByView ( Con && ,
Pred  )->ChunkByView< meta::AsView< Con >, Pred >

◆ ChunkView()

template<typename Con>
di::container::ChunkView ( Con && ,
meta::ContainerSSizeType< Con >  )->ChunkView< meta::AsView< Con > >

◆ CommonView()

template<typename Con>
di::container::CommonView ( Con && ) ->CommonView< meta::AsView< Con > >

◆ ConcatView()

template<typename... Cons>
di::container::ConcatView ( Cons && ...) ->ConcatView< meta::AsView< Cons >... >

◆ CycleView()

template<typename Con>
di::container::CycleView ( Con && ) ->CycleView< meta::AsView< Con > >

◆ DropView()

template<typename Con>
di::container::DropView ( Con && ,
meta::ContainerSSizeType< Con >  )->DropView< meta::AsView< Con > >

◆ DropWhileView()

template<typename Con, typename Pred>
di::container::DropWhileView ( Con && ,
Pred  )->DropWhileView< meta::AsView< Con >, Pred >

◆ EnumerateView()

template<typename Con>
di::container::EnumerateView ( Con && ) ->EnumerateView< meta::AsView< Con > >

◆ FilterView()

template<typename Con, typename Pred>
di::container::FilterView ( Con && ,
Pred  )->FilterView< meta::AsView< Con >, Pred >

◆ FixedString()

template<types::size_t size>
di::container::FixedString ( char const(&)[size]) ->FixedString< size-1 >

◆ IotaView()

template<typename T, typename Bound>
requires (!concepts::Integer<T> || !concepts::Integer<Bound> || concepts::SignedInteger<T> == concepts::SignedInteger<Bound>)
di::container::IotaView ( T ,
Bound  )->IotaView< T, Bound >

◆ JoinView()

template<typename Con>
di::container::JoinView ( Con && ) ->JoinView< meta::AsView< Con > >
explicit

◆ JoinWithView() [1/2]

template<concepts::InputContainer Con>
di::container::JoinWithView ( Con && ,
meta::ContainerValue< meta::ContainerReference< Con > >  )->JoinWithView< meta::AsView< Con >, SingleView< meta::ContainerValue< meta::ContainerReference< Con > > > >

◆ JoinWithView() [2/2]

template<typename Con, typename Pattern>
di::container::JoinWithView ( Con && ,
Pattern &&  )->JoinWithView< meta::AsView< Con >, meta::AsView< Pattern > >

◆ make_move_iterator()

template<concepts::InputIterator Iter>
auto di::container::make_move_iterator ( Iter iterator)
constexpr

◆ make_reverse_iterator()

template<concepts::BidirectionalIterator Iter>
auto di::container::make_reverse_iterator ( Iter iter)
constexpr

◆ operator-() [1/2]

template<typename Iter, typename U>
auto di::container::operator- ( MoveIterator< Iter > const & a,
MoveIterator< U > const & b )->decltype(a.base() -b.base())
constexpr

◆ operator-() [2/2]

template<typename Iter, typename U>
auto di::container::operator- ( ReverseIterator< Iter > const & a,
ReverseIterator< U > const & b )->decltype(b.base() -a.base())
constexpr

◆ operator<=>() [1/2]

template<typename Iter, concepts::ThreeWayComparableWith< Iter > U>
auto di::container::operator<=> ( MoveIterator< Iter > const & a,
MoveIterator< U > const & b )
constexpr

◆ operator<=>() [2/2]

template<typename Iter, concepts::ThreeWayComparableWith< Iter > U>
auto di::container::operator<=> ( ReverseIterator< Iter > const & a,
ReverseIterator< U > const & b )
constexpr

◆ operator==() [1/2]

template<typename Iter, concepts::EqualityComparableWith< Iter > U>
auto di::container::operator== ( MoveIterator< Iter > const & a,
MoveIterator< U > const & b )->bool
constexpr

◆ operator==() [2/2]

template<typename Iter, concepts::EqualityComparableWith< Iter > U>
auto di::container::operator== ( ReverseIterator< Iter > const & a,
ReverseIterator< U > const & b )->bool
constexpr

◆ PriorityQueue()

template<concepts::Container Con, typename T = meta::ContainerValue<Con>, concepts::StrictWeakOrder< T > Comp>
requires (detail::PriorityQueueCompatible<Con, T>)
di::container::PriorityQueue ( Comp ,
Con  )->PriorityQueue< T, Con, Comp >

◆ Queue()

template<concepts::Container Con, typename T = meta::ContainerValue<Con>>
requires (detail::QueueCompatible<Con, T>)
di::container::Queue ( Con ) ->Queue< T, Con >

◆ RefView()

template<typename Cont>
di::container::RefView ( Cont & ) ->RefView< Cont >

◆ RepeatView()

template<typename T, typename Bound>
di::container::RepeatView ( T ,
Bound  )->RepeatView< T, Bound >

◆ ReverseView()

template<typename Con>
di::container::ReverseView ( Con && ) ->ReverseView< meta::AsView< Con > >

◆ sequence_to() [1/4]

template<template< typename... > typename Template, typename... Args>
auto di::container::sequence_to ( Args &&... args)
constexpr

◆ sequence_to() [2/4]

template<typename Out, typename... Args>
requires (!concepts::View<Out>)
auto di::container::sequence_to ( Args &&... args)
constexpr

◆ sequence_to() [3/4]

template<template< typename... > typename Template, concepts::InputContainer Con, typename... Args, typename UnwrappedContainer = EmptyView<meta::ExpectedValue<meta::ContainerValue<Con>>>>
requires (concepts::CreateDeducible<Template, UnwrappedContainer, Args...> || concepts::CreateDeducible<Template, FromContainer, UnwrappedContainer, Args...>)
auto di::container::sequence_to ( Con && container,
Args &&... args )
constexpr

◆ sequence_to() [4/4]

template<typename Out, concepts::InputContainer Con, typename... Args>
requires (!concepts::View<Out> && concepts::Expected<meta::ContainerValue<Con>>)
auto di::container::sequence_to ( Con && container,
Args &&... args )
constexpr

◆ SingleView()

template<typename T>
di::container::SingleView ( T ) ->SingleView< T >

◆ SlideView()

template<typename Con>
di::container::SlideView ( Con && ,
meta::ContainerSSizeType< Con >  )->SlideView< meta::AsView< Con > >

◆ SplitView() [1/2]

template<concepts::InputContainer Con>
di::container::SplitView ( Con && ,
meta::ContainerValue< Con >  )->SplitView< meta::AsView< Con >, SingleView< meta::ContainerValue< Con > > >

◆ SplitView() [2/2]

template<typename Con, typename Pattern>
di::container::SplitView ( Con && ,
Pattern &&  )->SplitView< meta::AsView< Con >, meta::AsView< Pattern > >

◆ Stack()

template<concepts::Container Con, typename T = meta::ContainerValue<Con>>
requires (detail::StackCompatible<Con, T>)
di::container::Stack ( Con ) ->Stack< T, Con >

◆ StrideView()

template<typename Con>
di::container::StrideView ( Con && ,
meta::ContainerSSizeType< Con >  )->StrideView< meta::AsView< Con > >

◆ tag_invoke() [1/27]

template<concepts::InputContainer Con, typename T = meta::ContainerValue<Con>>
auto di::container::tag_invoke ( types::Tag< util::deduce_create > ,
InPlaceTemplate< LinkedList > ,
Con &&  )->LinkedList< T >

◆ tag_invoke() [2/27]

template<concepts::InputContainer Con, concepts::TupleLike T = meta::ContainerValue<Con>>
requires (meta::TupleSize<T> == 2)
auto di::container::tag_invoke ( types::Tag< util::deduce_create > ,
InPlaceTemplate< NodeHashMap > ,
Con &&  )->NodeHashMap< meta::TupleElement< T, 0 >, meta::TupleElement< T, 1 > >

◆ tag_invoke() [3/27]

template<concepts::InputContainer Con, concepts::TupleLike T = meta::ContainerValue<Con>, typename Eq>
requires (meta::TupleSize<T> == 2)
auto di::container::tag_invoke ( types::Tag< util::deduce_create > ,
InPlaceTemplate< NodeHashMap > ,
Con && ,
Eq  )->NodeHashMap< meta::TupleElement< T, 0 >, meta::TupleElement< T, 1 >, Eq >

◆ tag_invoke() [4/27]

template<concepts::InputContainer Con, concepts::TupleLike T = meta::ContainerValue<Con>, typename Eq, typename Hasher>
requires (meta::TupleSize<T> == 2)
auto di::container::tag_invoke ( types::Tag< util::deduce_create > ,
InPlaceTemplate< NodeHashMap > ,
Con && ,
Eq ,
Hasher  )->NodeHashMap< meta::TupleElement< T, 0 >, meta::TupleElement< T, 1 >, Eq, Hasher >

◆ tag_invoke() [5/27]

template<concepts::InputContainer Con, concepts::TupleLike T = meta::ContainerValue<Con>>
requires (meta::TupleSize<T> == 2)
auto di::container::tag_invoke ( types::Tag< util::deduce_create > ,
InPlaceTemplate< NodeHashMultiMap > ,
Con &&  )->NodeHashMultiMap< meta::TupleElement< T, 0 >, meta::TupleElement< T, 1 > >

◆ tag_invoke() [6/27]

template<concepts::InputContainer Con, concepts::TupleLike T = meta::ContainerValue<Con>, typename Eq>
requires (meta::TupleSize<T> == 2)
auto di::container::tag_invoke ( types::Tag< util::deduce_create > ,
InPlaceTemplate< NodeHashMultiMap > ,
Con && ,
Eq  )->NodeHashMultiMap< meta::TupleElement< T, 0 >, meta::TupleElement< T, 1 >, Eq >

◆ tag_invoke() [7/27]

template<concepts::InputContainer Con, concepts::TupleLike T = meta::ContainerValue<Con>, typename Eq, typename Hasher>
requires (meta::TupleSize<T> == 2)
auto di::container::tag_invoke ( types::Tag< util::deduce_create > ,
InPlaceTemplate< NodeHashMultiMap > ,
Con && ,
Eq ,
Hasher  )->NodeHashMultiMap< meta::TupleElement< T, 0 >, meta::TupleElement< T, 1 >, Eq, Hasher >

◆ tag_invoke() [8/27]

template<concepts::InputContainer Con, typename T = meta::ContainerValue<Con>>
auto di::container::tag_invoke ( types::Tag< util::deduce_create > ,
InPlaceTemplate< NodeHashMultiSet > ,
Con &&  )->NodeHashMultiSet< T >

◆ tag_invoke() [9/27]

template<concepts::InputContainer Con, typename T = meta::ContainerValue<Con>, typename Eq>
auto di::container::tag_invoke ( types::Tag< util::deduce_create > ,
InPlaceTemplate< NodeHashMultiSet > ,
Con && ,
Eq  )->NodeHashMultiSet< T, Eq >

◆ tag_invoke() [10/27]

template<concepts::InputContainer Con, typename T = meta::ContainerValue<Con>, typename Eq, typename Hasher>
auto di::container::tag_invoke ( types::Tag< util::deduce_create > ,
InPlaceTemplate< NodeHashMultiSet > ,
Con && ,
Eq ,
Hasher  )->NodeHashMultiSet< T, Eq, Hasher >

◆ tag_invoke() [11/27]

template<concepts::InputContainer Con, typename T = meta::ContainerValue<Con>>
auto di::container::tag_invoke ( types::Tag< util::deduce_create > ,
InPlaceTemplate< NodeHashSet > ,
Con &&  )->NodeHashSet< T >

◆ tag_invoke() [12/27]

template<concepts::InputContainer Con, typename T = meta::ContainerValue<Con>, typename Eq>
auto di::container::tag_invoke ( types::Tag< util::deduce_create > ,
InPlaceTemplate< NodeHashSet > ,
Con && ,
Eq  )->NodeHashSet< T, Eq >

◆ tag_invoke() [13/27]

template<concepts::InputContainer Con, typename T = meta::ContainerValue<Con>, typename Eq, typename Hasher>
auto di::container::tag_invoke ( types::Tag< util::deduce_create > ,
InPlaceTemplate< NodeHashSet > ,
Con && ,
Eq ,
Hasher  )->NodeHashSet< T, Eq, Hasher >

◆ tag_invoke() [14/27]

template<concepts::InputContainer Con, typename T = meta::ContainerValue<Con>>
auto di::container::tag_invoke ( types::Tag< util::deduce_create > ,
InPlaceTemplate< PriorityQueue > ,
Con &&  )->PriorityQueue< T >

◆ tag_invoke() [15/27]

template<concepts::InputContainer Con, typename T = meta::ContainerValue<Con>, concepts::StrictWeakOrder< T > Comp>
auto di::container::tag_invoke ( types::Tag< util::deduce_create > ,
InPlaceTemplate< PriorityQueue > ,
Con && ,
Comp  )->PriorityQueue< T, container::Vector< T >, Comp >

◆ tag_invoke() [16/27]

template<concepts::InputContainer Con, typename T = meta::ContainerValue<Con>>
auto di::container::tag_invoke ( types::Tag< util::deduce_create > ,
InPlaceTemplate< Queue > ,
Con &&  )->Queue< T >

◆ tag_invoke() [17/27]

template<concepts::InputContainer Con, typename T = meta::ContainerValue<Con>>
auto di::container::tag_invoke ( types::Tag< util::deduce_create > ,
InPlaceTemplate< Ring > ,
Con &&  )->Ring< T >

◆ tag_invoke() [18/27]

template<concepts::InputContainer Con, typename T = meta::ContainerValue<Con>>
auto di::container::tag_invoke ( types::Tag< util::deduce_create > ,
InPlaceTemplate< Stack > ,
Con &&  )->Stack< T >

◆ tag_invoke() [19/27]

template<concepts::InputContainer Con, concepts::TupleLike T = meta::ContainerValue<Con>>
requires (meta::TupleSize<T> == 2)
auto di::container::tag_invoke ( types::Tag< util::deduce_create > ,
InPlaceTemplate< TreeMap > ,
Con &&  )->TreeMap< meta::TupleElement< T, 0 >, meta::TupleElement< T, 1 > >

◆ tag_invoke() [20/27]

template<concepts::InputContainer Con, concepts::TupleLike T = meta::ContainerValue<Con>, concepts::StrictWeakOrder< T > Comp>
requires (meta::TupleSize<T> == 2)
auto di::container::tag_invoke ( types::Tag< util::deduce_create > ,
InPlaceTemplate< TreeMap > ,
Con && ,
Comp  )->TreeMap< meta::TupleElement< T, 0 >, meta::TupleElement< T, 1 >, Comp >

◆ tag_invoke() [21/27]

template<concepts::InputContainer Con, concepts::TupleLike T = meta::ContainerValue<Con>>
requires (meta::TupleSize<T> == 2)
auto di::container::tag_invoke ( types::Tag< util::deduce_create > ,
InPlaceTemplate< TreeMultiMap > ,
Con &&  )->TreeMultiMap< meta::TupleElement< T, 0 >, meta::TupleElement< T, 1 > >

◆ tag_invoke() [22/27]

template<concepts::InputContainer Con, concepts::TupleLike T = meta::ContainerValue<Con>, concepts::StrictWeakOrder< T > Comp>
requires (meta::TupleSize<T> == 2)
auto di::container::tag_invoke ( types::Tag< util::deduce_create > ,
InPlaceTemplate< TreeMultiMap > ,
Con && ,
Comp  )->TreeMultiMap< meta::TupleElement< T, 0 >, meta::TupleElement< T, 1 >, Comp >

◆ tag_invoke() [23/27]

template<concepts::InputContainer Con, typename T = meta::ContainerValue<Con>>
auto di::container::tag_invoke ( types::Tag< util::deduce_create > ,
InPlaceTemplate< TreeMultiSet > ,
Con &&  )->TreeMultiSet< T >

◆ tag_invoke() [24/27]

template<concepts::InputContainer Con, typename T = meta::ContainerValue<Con>, concepts::StrictWeakOrder< T > Comp>
auto di::container::tag_invoke ( types::Tag< util::deduce_create > ,
InPlaceTemplate< TreeMultiSet > ,
Con && ,
Comp  )->TreeMultiSet< T, Comp >

◆ tag_invoke() [25/27]

template<concepts::InputContainer Con, typename T = meta::ContainerValue<Con>>
auto di::container::tag_invoke ( types::Tag< util::deduce_create > ,
InPlaceTemplate< TreeSet > ,
Con &&  )->TreeSet< T >

◆ tag_invoke() [26/27]

template<concepts::InputContainer Con, typename T = meta::ContainerValue<Con>, concepts::StrictWeakOrder< T > Comp>
auto di::container::tag_invoke ( types::Tag< util::deduce_create > ,
InPlaceTemplate< TreeSet > ,
Con && ,
Comp  )->TreeSet< T, Comp >

◆ tag_invoke() [27/27]

template<concepts::InputContainer Con, typename T = meta::ContainerValue<Con>>
auto di::container::tag_invoke ( types::Tag< util::deduce_create > ,
InPlaceTemplate< Vector > ,
Con &&  )->Vector< T >

◆ TakeView()

template<typename Con>
di::container::TakeView ( Con && ,
meta::ContainerSSizeType< Con >  )->TakeView< meta::AsView< Con > >

◆ TakeWhileView()

template<typename Con, typename Pred>
di::container::TakeWhileView ( Con && ,
Pred  )->TakeWhileView< meta::AsView< Con >, Pred >

◆ to() [1/4]

template<template< typename... > typename Template, typename... Args>
auto di::container::to ( Args &&... args)
constexpr

◆ to() [2/4]

template<typename Out, typename... Args>
requires (!concepts::View<Out>)
auto di::container::to ( Args &&... args)
constexpr

◆ to() [3/4]

template<template< typename... > typename Template, concepts::InputContainer Con, typename... Args>
requires (concepts::CreateDeducible<Template, Con, Args...> || concepts::CreateDeducible<Template, FromContainer, Con, Args...>)
auto di::container::to ( Con && container,
Args &&... args )
constexpr

◆ to() [4/4]

template<typename Out, concepts::InputContainer Con, typename... Args>
requires (!concepts::View<Out>)
auto di::container::to ( Con && container,
Args &&... args )
constexpr

◆ TransformView()

template<typename Con, typename F>
di::container::TransformView ( Con && ,
F  )->TransformView< meta::AsView< Con >, F >

◆ View() [1/4]

template<concepts::BorrowedContainer Cont>
di::container::View ( Cont && ) ->View< meta::ContainerIterator< Cont >, meta::ContainerSentinel< Cont >, concepts::SizedContainer< Cont >||concepts::SizedSentinelFor< meta::ContainerSentinel< Cont >, meta::ContainerIterator< Cont > > >

◆ View() [2/4]

template<concepts::BorrowedContainer Cont>
di::container::View ( Cont && ,
meta::ContainerSizeType< Cont >  )->View< meta::ContainerIterator< Cont >, meta::ContainerSentinel< Cont >, true >

◆ View() [3/4]

template<concepts::Iterator Iter, concepts::SentinelFor< Iter > Sent>
di::container::View ( Iter ,
Sent  )->View< Iter, Sent >

◆ View() [4/4]

template<concepts::Iterator Iter, concepts::SentinelFor< Iter > Sent>
di::container::View ( Iter ,
Sent ,
meta::IteratorSizeType< Iter >  )->View< Iter, Sent, true >

◆ ZipTransformView()

template<class F, class... Cons>
di::container::ZipTransformView ( F ,
Cons && ... )->ZipTransformView< F, meta::AsView< Cons >... >

◆ ZipView()

template<typename... Cons>
di::container::ZipView ( Cons && ...) ->ZipView< meta::AsView< Cons >... >

Variable Documentation

◆ adjacent_find

auto di::container::adjacent_find = detail::AdjacentFindFunction {}
inlineconstexpr

◆ advance

auto di::container::advance = AdvanceFunction {}
inlineconstexpr

◆ all_of

auto di::container::all_of = detail::AllOfFunction {}
inlineconstexpr

◆ allocate

auto di::container::allocate = detail::AllocateFunction {}
inlineconstexpr

◆ allocate_many

template<typename T>
auto di::container::allocate_many = detail::AllocateManyFunction<T> {}
inlineconstexpr

◆ allocate_one

template<typename T>
auto di::container::allocate_one = detail::AllocateOneFunction<T> {}
inlineconstexpr

◆ any_of

auto di::container::any_of = detail::AnyOfFunction {}
inlineconstexpr

◆ at

auto di::container::at = di::curry_back(detail::AtFunction {}, c_<2ZU>)
inlineconstexpr

◆ at_unchecked

auto di::container::at_unchecked = di::curry_back(detail::AtUncheckedFunction {}, c_<2ZU>)
inlineconstexpr

◆ back

auto di::container::back = detail::BackFunction {}
inlineconstexpr

◆ back_unchecked

auto di::container::back_unchecked = detail::BackUncheckedFunction {}
inlineconstexpr

◆ begin

auto di::container::begin = BeginFunction {}
inlineconstexpr

◆ binary_search

auto di::container::binary_search = detail::BinarySearchFunction {}
inlineconstexpr

◆ cbegin

auto di::container::cbegin = CBeginFunction {}
inlineconstexpr

◆ cdata

auto di::container::cdata = CDataFunction {}
inlineconstexpr

◆ cend

auto di::container::cend = CEndFunction {}
inlineconstexpr

◆ compare

auto di::container::compare = detail::CompareFunction {}
inlineconstexpr

◆ contains

auto di::container::contains = detail::ContainsFunction {}
inlineconstexpr

◆ contains_subrange

auto di::container::contains_subrange = detail::ContainsSubrangeFunction {}
inlineconstexpr

◆ copy

auto di::container::copy = detail::CopyFunction {}
inlineconstexpr

◆ copy_backward

auto di::container::copy_backward = detail::CopyBackwardFunction {}
inlineconstexpr

◆ copy_if

auto di::container::copy_if = detail::CopyIfFunction {}
inlineconstexpr

◆ copy_n

auto di::container::copy_n = detail::CopyNFunction {}
inlineconstexpr

◆ count

auto di::container::count = detail::CountFunction {}
inlineconstexpr

◆ count_if

auto di::container::count_if = detail::CountIfFunction {}
inlineconstexpr

◆ crbegin

auto di::container::crbegin = CRBeginFunction {}
inlineconstexpr

◆ crend

auto di::container::crend = CREndFunction {}
inlineconstexpr

◆ data

auto di::container::data = DataFunction {}
inlineconstexpr

◆ deallocate

auto di::container::deallocate = detail::DeallocateFunction {}
inlineconstexpr

◆ deallocate_many

template<typename T>
auto di::container::deallocate_many = detail::DeallocateManyFunction<T> {}
inlineconstexpr

◆ deallocate_one

template<typename T>
auto di::container::deallocate_one = detail::DeallocateOneFunction<T> {}
inlineconstexpr

◆ default_sentinel

auto di::container::default_sentinel = DefaultSentinel {}
inlineconstexpr

◆ destroy

auto di::container::destroy = detail::DestroyFunction {}
inlineconstexpr

◆ destroy_n

auto di::container::destroy_n = detail::DestroyNFunction {}
inlineconstexpr

◆ distance

auto di::container::distance = detail::DistanceFunction {}
inlineconstexpr

◆ empty

auto di::container::empty = EmptyFunction {}
inlineconstexpr

◆ enable_borrowed_container

struct di::container::EnableBorrowedContainer di::container::enable_borrowed_container

◆ enable_view

struct di::container::EnableViewFunction di::container::enable_view

◆ end

auto di::container::end = EndFunction {}
inlineconstexpr

◆ ends_with

auto di::container::ends_with = detail::EndsWithFunction {}
inlineconstexpr

◆ equal

auto di::container::equal = detail::EqualFunction {}
inlineconstexpr

◆ equal_range

auto di::container::equal_range = detail::EqualRangeFunction {}
inlineconstexpr

◆ erase

auto di::container::erase = erase_ns::EraseFunction {}
inlineconstexpr

◆ erase_if

auto di::container::erase_if = erase_ns::EraseIfFunction {}
inlineconstexpr

◆ fail_allocator

auto di::container::fail_allocator = FailAllocator {}
inlineconstexpr

◆ fill

auto di::container::fill = detail::FillFunction {}
inlineconstexpr

◆ fill_n

auto di::container::fill_n = detail::FillNFunction {}
inlineconstexpr

◆ find

auto di::container::find = detail::FindFunction {}
inlineconstexpr

◆ find_end

auto di::container::find_end = detail::FindEndFunction {}
inlineconstexpr

◆ find_first_not_of

auto di::container::find_first_not_of = detail::FindFirstNotOfFunction {}
inlineconstexpr

◆ find_first_of

auto di::container::find_first_of = detail::FindFirstOfFunction {}
inlineconstexpr

◆ find_if

auto di::container::find_if = detail::FindIfFunction {}
inlineconstexpr

◆ find_if_not

auto di::container::find_if_not = detail::FindIfNotFunction {}
inlineconstexpr

◆ find_last

auto di::container::find_last = detail::FindLastFunction {}
inlineconstexpr

◆ find_last_if

auto di::container::find_last_if = detail::FindLastIfFunction {}
inlineconstexpr

◆ find_last_if_not

auto di::container::find_last_if_not = detail::FindLastIfNotFunction {}
inlineconstexpr

◆ find_last_not_of

auto di::container::find_last_not_of = detail::FindLastNotOfFunction {}
inlineconstexpr

◆ find_last_of

auto di::container::find_last_of = detail::FindLastOfFunction {}
inlineconstexpr

◆ fixed_string_concat

auto di::container::fixed_string_concat = detail::FixedStringConcat {}
inlineconstexpr

◆ fixed_string_to_utf8_string_view

template<FixedString literal>
auto di::container::fixed_string_to_utf8_string_view = detail::FixedStringToUtf8StringViewFunction<literal> {}
inlineconstexpr

◆ fold_left

auto di::container::fold_left = function::curry_back(detail::FoldLeftFunction {}, meta::c_<3ZU>)
inlineconstexpr

◆ fold_left_first

auto di::container::fold_left_first = function::curry_back(detail::FoldLeftFirstFunction {}, meta::c_<2ZU>)
inlineconstexpr

◆ fold_left_first_with_iter

auto di::container::fold_left_first_with_iter = detail::FoldLeftFirstWithIterFunction {}
inlineconstexpr

◆ fold_left_with_iter

auto di::container::fold_left_with_iter = detail::FoldLeftWithIterFunction {}
inlineconstexpr

◆ fold_right

auto di::container::fold_right = detail::FoldRightFunction {}
inlineconstexpr

◆ fold_right_last

auto di::container::fold_right_last = detail::FoldRightLastFunction {}
inlineconstexpr

◆ for_each

auto di::container::for_each = detail::ForEachFunction {}
inlineconstexpr

◆ for_each_n

auto di::container::for_each_n = detail::ForEachNFunction {}
inlineconstexpr

◆ front

auto di::container::front = detail::FrontFunction {}
inlineconstexpr

◆ front_unchecked

auto di::container::front_unchecked = detail::FrontUncheckedFunction {}
inlineconstexpr

◆ generate

auto di::container::generate = detail::GenerateFunction {}
inlineconstexpr

◆ generate_n

auto di::container::generate_n = detail::GenerateNFunction {}
inlineconstexpr

◆ hash

auto di::container::hash = detail::HashFunction {}
inlineconstexpr

◆ hash_same

auto di::container::hash_same = detail::HashSameFunction {}
inlineconstexpr

◆ hash_write

auto di::container::hash_write = detail::HashWriteFunction {}
inlineconstexpr

◆ includes

auto di::container::includes = detail::IncludesFunction {}
inlineconstexpr

◆ into_erased_string

auto di::container::into_erased_string = detail::IntoErasedStringFunction {}
inlineconstexpr

◆ iota

auto di::container::iota = detail::IotaFunction {}
inlineconstexpr

◆ is_heap

auto di::container::is_heap = detail::IsHeapFunction {}
inlineconstexpr

◆ is_heap_until

auto di::container::is_heap_until = detail::IsHeapUntilFunction {}
inlineconstexpr

◆ is_partitioned

auto di::container::is_partitioned = detail::IsPartitionedFunction {}
inlineconstexpr

◆ is_permutation

auto di::container::is_permutation = detail::IsPermutationFunction {}
inlineconstexpr

◆ is_sorted

auto di::container::is_sorted = detail::IsSortedFunction {}
inlineconstexpr

◆ is_sorted_until

auto di::container::is_sorted_until = detail::IsSortedUntilFunction {}
inlineconstexpr

◆ iterator_category

struct di::container::IteratorCategoryFunction di::container::iterator_category

◆ iterator_move

auto di::container::iterator_move = detail::IteratorMoveFunction {}
inlineconstexpr

◆ iterator_ssize_type

struct di::container::IteratorSSizeTypeFunction di::container::iterator_ssize_type

◆ iterator_swap

auto di::container::iterator_swap = detail::IteratorSwapFunction {}
inlineconstexpr

◆ iterator_value

struct di::container::IteratorValueFunction di::container::iterator_value

◆ lower_bound

auto di::container::lower_bound = detail::LowerBoundFunction {}
inlineconstexpr

◆ make_heap

auto di::container::make_heap = detail::MakeHeapFunction {}
inlineconstexpr

◆ max

auto di::container::max = detail::MaxFunction {}
inlineconstexpr

◆ max_element

auto di::container::max_element = detail::MaxElementFunction {}
inlineconstexpr

◆ merge

auto di::container::merge = detail::MergeFunction {}
inlineconstexpr

◆ min

auto di::container::min = detail::MinFunction {}
inlineconstexpr

◆ min_element

auto di::container::min_element = detail::MinElementFunction {}
inlineconstexpr

◆ minmax

auto di::container::minmax = detail::MinMaxFunction {}
inlineconstexpr

◆ minmax_element

auto di::container::minmax_element = detail::MinMaxElementFunction {}
inlineconstexpr

◆ mismatch

auto di::container::mismatch = detail::MismatchFunction {}
inlineconstexpr

◆ move

auto di::container::move = detail::MoveFunction {}
inlineconstexpr

◆ move_backward

auto di::container::move_backward = detail::MoveBackwardFunction {}
inlineconstexpr

◆ next

auto di::container::next = NextFunction {}
inlineconstexpr

◆ next_permutation

auto di::container::next_permutation = detail::NextPermutationFunction {}
inlineconstexpr

◆ none_of

auto di::container::none_of = detail::NoneOfFunction {}
inlineconstexpr

◆ partition

auto di::container::partition = detail::PartitionFunction {}
inlineconstexpr

◆ partition_copy

auto di::container::partition_copy = detail::PartitionCopyFunction {}
inlineconstexpr

◆ partition_point

auto di::container::partition_point = detail::PartitionPointFunction {}
inlineconstexpr

◆ pop_heap

auto di::container::pop_heap = detail::PopHeapFunction {}
inlineconstexpr

◆ prev

auto di::container::prev = PrevFunction {}
inlineconstexpr

◆ prev_permutation

auto di::container::prev_permutation = detail::PrevPermutationFunction {}
inlineconstexpr

◆ product

auto di::container::product = detail::ProductFunction {}
inlineconstexpr

◆ push_heap

auto di::container::push_heap = detail::PushHeapFunction {}
inlineconstexpr

◆ rbegin

auto di::container::rbegin = RBeginFunction {}
inlineconstexpr

◆ reconstruct

auto di::container::reconstruct = ReconstructFunction {}
inlineconstexpr

◆ remove

auto di::container::remove = detail::RemoveFunction {}
inlineconstexpr

◆ remove_copy

auto di::container::remove_copy = detail::RemoveCopyFunction {}
inlineconstexpr

◆ remove_copy_if

auto di::container::remove_copy_if = detail::RemoveCopyIfFunction {}
inlineconstexpr

◆ remove_if

auto di::container::remove_if = detail::RemoveIfFunction {}
inlineconstexpr

◆ rend

auto di::container::rend = REndFunction {}
inlineconstexpr

◆ replace

auto di::container::replace = detail::ReplaceFunction {}
inlineconstexpr

◆ replace_copy

auto di::container::replace_copy = detail::ReplaceCopyFunction {}
inlineconstexpr

◆ replace_copy_if

auto di::container::replace_copy_if = detail::ReplaceCopyIfFunction {}
inlineconstexpr

◆ replace_if

auto di::container::replace_if = detail::ReplaceIfFunction {}
inlineconstexpr

◆ reverse

auto di::container::reverse = detail::ReverseFunction {}
inlineconstexpr

◆ reverse_copy

auto di::container::reverse_copy = detail::ReverseCopyFunction {}
inlineconstexpr

◆ rotate

auto di::container::rotate = detail::RotateFunction {}
inlineconstexpr

◆ rotate_copy

auto di::container::rotate_copy = detail::RotateCopyFunction {}
inlineconstexpr

◆ sample

auto di::container::sample = detail::SampleFunction {}
inlineconstexpr

◆ search

auto di::container::search = detail::SearchFunction {}
inlineconstexpr

◆ search_n

auto di::container::search_n = detail::SearchNFunction {}
inlineconstexpr

◆ sequence

auto di::container::sequence = function::curry_back(detail::SequenceFunction {}, meta::c_<2ZU>)
inlineconstexpr

◆ set_difference

auto di::container::set_difference = detail::SetDifferenceFunction {}
inlineconstexpr

◆ set_intersection

auto di::container::set_intersection = detail::SetIntersectionFunction {}
inlineconstexpr

◆ set_symmetric_difference

auto di::container::set_symmetric_difference = detail::SetSymmetricDifferenceFunction {}
inlineconstexpr

◆ set_union

auto di::container::set_union = detail::SetUnionFunction {}
inlineconstexpr

◆ shift_left

auto di::container::shift_left = detail::ShiftLeftFunction {}
inlineconstexpr

◆ shift_right

auto di::container::shift_right = detail::ShiftRightFunction {}
inlineconstexpr

◆ shuffle

auto di::container::shuffle = detail::ShuffleFunction {}
inlineconstexpr

◆ size

auto di::container::size = SizeFunction {}
inlineconstexpr

◆ sort

auto di::container::sort = detail::SortFunction {}
inlineconstexpr

◆ sort_heap

auto di::container::sort_heap = detail::SortHeapFunction {}
inlineconstexpr

◆ ssize

auto di::container::ssize = SSizeFunction {}
inlineconstexpr

◆ stable_partition

auto di::container::stable_partition = detail::StablePartitionFunction {}
inlineconstexpr

◆ starts_with

auto di::container::starts_with = detail::StartsWithFunction {}
inlineconstexpr

◆ sum

auto di::container::sum = detail::SumFunction {}
inlineconstexpr

◆ swap_ranges

auto di::container::swap_ranges = detail::SwapRanges {}
inlineconstexpr

◆ transform

auto di::container::transform = detail::TransformFunction {}
inlineconstexpr

◆ uninitialized_copy

auto di::container::uninitialized_copy = detail::UninitializedCopyFunction {}
inlineconstexpr

◆ uninitialized_copy_n

auto di::container::uninitialized_copy_n = detail::UninitializedCopyNFunction {}
inlineconstexpr

◆ uninitialized_default_construct

auto di::container::uninitialized_default_construct = detail::UninitializedDefaultConstructFunction {}
inlineconstexpr

◆ uninitialized_default_construct_n

auto di::container::uninitialized_default_construct_n = detail::UninitializedDefaultConstructNFunction {}
inlineconstexpr

◆ uninitialized_fill

auto di::container::uninitialized_fill = detail::UninitializedFillFunction {}
inlineconstexpr

◆ uninitialized_fill_n

auto di::container::uninitialized_fill_n = detail::UninitializedFillNFunction {}
inlineconstexpr

◆ uninitialized_move

auto di::container::uninitialized_move = detail::UninitializedMoveFunction {}
inlineconstexpr

◆ uninitialized_move_n

auto di::container::uninitialized_move_n = detail::UninitializedMoveNFunction {}
inlineconstexpr

◆ uninitialized_relocate

auto di::container::uninitialized_relocate = detail::UninitializedRelocateFunction {}
inlineconstexpr

◆ uninitialized_relocate_backwards

auto di::container::uninitialized_relocate_backwards = detail::UninitializedRelocateBackwardsFunction {}
inlineconstexpr

◆ uninitialized_value_construct

auto di::container::uninitialized_value_construct = detail::UninitializedValueConstructFunction {}
inlineconstexpr

◆ uninitialized_value_construct_n

auto di::container::uninitialized_value_construct_n = detail::UninitializedValueConstructNFunction {}
inlineconstexpr

◆ unique

auto di::container::unique = detail::UniqueFunction {}
inlineconstexpr

◆ unique_copy

auto di::container::unique_copy = detail::UniqueCopyFunction {}
inlineconstexpr

◆ unreachable_sentinel

auto di::container::unreachable_sentinel = UnreachableSentinel {}
inlineconstexpr

◆ upper_bound

auto di::container::upper_bound = detail::UpperBoundFunction {}
inlineconstexpr