Set<T> is a container of T, where once an item is added, additionally adds () do nothing.
More...
|
| | Set () |
| |
| nonvirtual ElementEqualityComparerType | GetElementEqualsComparer () const |
| |
| nonvirtual bool | contains (ArgByValueType< value_type > item) const |
| |
| nonvirtual bool | ContainsAll (const Iterable< value_type > &items) const |
| |
| nonvirtual bool | ContainsAny (const Iterable< value_type > &items) const |
| |
| nonvirtual bool | IsSubsetOf (const Set &superset) const |
| |
| nonvirtual optional< value_type > | Lookup (ArgByValueType< value_type > item) const |
| |
| nonvirtual void | Add (ArgByValueType< value_type > item) |
| |
| nonvirtual bool | AddIf (ArgByValueType< value_type > item) |
| |
| template<IInputIterator< T > ITERATOR_OF_ADDABLE, sentinel_for< remove_cvref_t< ITERATOR_OF_ADDABLE > > ITERATOR_OF_ADDABLE2> |
| nonvirtual void | AddAll (ITERATOR_OF_ADDABLE &&start, ITERATOR_OF_ADDABLE2 &&end) |
| |
| nonvirtual void | Remove (ArgByValueType< value_type > item) |
| | Remove the item (given by value or iterator pointing to it) from the contain. The item MUST exist.
|
| |
| nonvirtual bool | RemoveIf (ArgByValueType< value_type > item) |
| |
| template<IInputIterator< T > ITERATOR_OF_ADDABLE> |
| nonvirtual size_t | RemoveAll (ITERATOR_OF_ADDABLE &&start, ITERATOR_OF_ADDABLE &&end) |
| | RemoveAll removes all, or all matching (predicate, iterator range, equals comparer or whatever) items.
|
| |
template<typename RESULT_CONTAINER = Set<T>, invocable< T > ELEMENT_MAPPER>
requires (convertible_to<invoke_result_t<ELEMENT_MAPPER, T>, typename RESULT_CONTAINER::value_type> or convertible_to<invoke_result_t<ELEMENT_MAPPER, T>, optional<typename RESULT_CONTAINER::value_type>>) |
| nonvirtual RESULT_CONTAINER | Map (ELEMENT_MAPPER &&elementMapper) const |
| | 'override' Iterable<>::Map () function so RESULT_CONTAINER defaults to Set, and improve that case to clone properties from this rep (such is rep type, ordering, etc).
|
| |
| template<derived_from< Iterable< T > > RESULT_CONTAINER = Set<T>, predicate< T > INCLUDE_PREDICATE> |
| nonvirtual RESULT_CONTAINER | Where (INCLUDE_PREDICATE &&includeIfTrue) const |
| |
| nonvirtual bool | operator== (const Set &rhs) const |
| |
| nonvirtual bool | Intersects (const Iterable< value_type > &rhs) const |
| | return true iff the Intersection () is non-empty
|
| |
| nonvirtual Set & | operator+= (ArgByValueType< value_type > item) |
| |
| nonvirtual Set & | operator-= (ArgByValueType< value_type > item) |
| |
| nonvirtual Set & | operator^= (const Iterable< value_type > &items) |
| |
| nonvirtual void | clear () |
| |
| nonvirtual Iterator< value_type > | find (ArgByValueType< value_type > item) const |
| |
| nonvirtual pair< const_iterator, bool > | insert (ArgByValueType< value_type > item) |
| |
| nonvirtual void | erase (ArgByValueType< value_type > item) |
| | STL-ish alias for Remove ().
|
| |
|
nonvirtual Set | CloneEmpty () const |
| | for return Set<T> { s->GetEqualsComparer(); } - except more efficient - clones settings/dynamic subtype but not data for the Set
|
| |
|
| Iterable (const Iterable &) noexcept=default |
| | Iterable are safely copyable (by value). Since Iterable uses COW, this just copies the underlying pointer and increments the reference count.
|
| |
|
| Iterable (Iterable &&) noexcept=default |
| | Iterable are safely moveable.
|
| |
template<IIterableOfTo< T > CONTAINER_OF_T>
requires (not derived_from<remove_cvref_t<CONTAINER_OF_T>, Iterable<T>>) |
| | Iterable (CONTAINER_OF_T &&from) |
| |
| | Iterable (const initializer_list< T > &from) |
| |
| nonvirtual | operator bool () const |
| |
| nonvirtual Iterator< T > | MakeIterator () const |
| | Create an iterator object which can be used to traverse the 'Iterable'.
|
| |
| nonvirtual size_t | size () const |
| | Returns the number of items contained.
|
| |
| nonvirtual bool | empty () const |
| | Returns true iff size() == 0.
|
| |
| template<Common::IPotentiallyComparer< T > EQUALS_COMPARER = equal_to<T>> |
| nonvirtual bool | Contains (ArgByValueType< T > element, EQUALS_COMPARER &&equalsComparer=EQUALS_COMPARER{}) const |
| |
| nonvirtual Iterator< T > | begin () const |
| | Support for ranged for, and STL syntax in general.
|
| |
| nonvirtual void | Apply (const function< void(ArgByValueType< T > item)> &doToElement, Execution::SequencePolicy seq=Execution::SequencePolicy::eDEFAULT) const |
| | Run the argument function (or lambda) on each element of the container.
|
| |
| template<predicate< T > THAT_FUNCTION> |
| nonvirtual Iterator< T > | Find (THAT_FUNCTION &&that, Execution::SequencePolicy seq=Execution::SequencePolicy::eDEFAULT) const |
| | Run the argument bool-returning function (or lambda) on each element of the container, and return an iterator pointing at the first element (depending on seq) found true. (or use First() to do same thing but return optional<>)
|
| |
| template<IIterableOfFrom< T > CONTAINER_OF_T, typename... CONTAINER_OF_T_CONSTRUCTOR_ARGS> |
| nonvirtual CONTAINER_OF_T | As (CONTAINER_OF_T_CONSTRUCTOR_ARGS... args) const |
| |
| nonvirtual T | Nth (ptrdiff_t n) const |
| | Find the Nth element of the Iterable<>
|
| |
| nonvirtual T | NthValue (ptrdiff_t n, ArgByValueType< T > defaultValue={}) const |
| | Find the Nth element of the Iterable<>, but allow for n to be out of range, and just return argument default-value.
|
| |
| template<derived_from< Iterable< T > > RESULT_CONTAINER = Iterable<T>, predicate< T > INCLUDE_PREDICATE> |
| nonvirtual RESULT_CONTAINER | Where (INCLUDE_PREDICATE &&includeIfTrue) const |
| | produce a subset of this iterable where argument function returns true
|
| |
| template<Common::IPotentiallyComparer< T > EQUALS_COMPARER = equal_to<T>> |
| nonvirtual Iterable< T > | Distinct (EQUALS_COMPARER &&equalsComparer=EQUALS_COMPARER{}) const |
| |
template<ranges::range RESULT_CONTAINER = Iterable<T>, invocable< T > ELEMENT_MAPPER>
requires (convertible_to<invoke_result_t<ELEMENT_MAPPER, T>, typename RESULT_CONTAINER::value_type> or convertible_to<invoke_result_t<ELEMENT_MAPPER, T>, optional<typename RESULT_CONTAINER::value_type>>) |
| nonvirtual RESULT_CONTAINER | Map (ELEMENT_MAPPER &&elementMapper) const |
| | functional API which iterates over all members of an Iterable, applies a map function to each element, and collects the results in a new Iterable
|
| |
| template<typename REDUCED_TYPE = T> |
| nonvirtual optional< REDUCED_TYPE > | Reduce (const function< REDUCED_TYPE(ArgByValueType< T >, ArgByValueType< T >)> &op) const |
| | Walk the entire list of items, and use the argument 'op' to combine (reduce) items to a resulting single item.
|
| |
| template<typename REDUCED_TYPE = T> |
| nonvirtual REDUCED_TYPE | ReduceValue (const function< REDUCED_TYPE(ArgByValueType< T >, ArgByValueType< T >)> &op, ArgByValueType< REDUCED_TYPE > defaultValue={}) const |
| |
template<typename RESULT_T = Characters::String, invocable< T > CONVERT_TO_RESULT = decltype (kDefaultToStringConverter<>), invocable< RESULT_T, RESULT_T, bool > COMBINER = decltype (Characters::kDefaultStringCombiner)>
requires (convertible_to<invoke_result_t<CONVERT_TO_RESULT, T>, RESULT_T> and convertible_to<invoke_result_t<COMBINER, RESULT_T, RESULT_T, bool>, RESULT_T>) |
| nonvirtual RESULT_T | Join (const CONVERT_TO_RESULT &convertToResult=kDefaultToStringConverter<>, const COMBINER &combiner=Characters::kDefaultStringCombiner) const |
| | ape the JavaScript/python 'join' function - take the parts of 'this' iterable and combine them into a new object (typically a string)
|
| |
| nonvirtual Iterable< T > | Skip (size_t nItems) const |
| |
| nonvirtual Iterable< T > | Take (size_t nItems) const |
| |
| nonvirtual Iterable< T > | Slice (size_t from, size_t to) const |
| |
| nonvirtual Iterable< T > | Top () const |
| | return the top/largest (possibly just top N) values from this Iterable<T>
|
| |
| template<Common::IPotentiallyComparer< T > INORDER_COMPARER_TYPE = less<T>> |
| nonvirtual Iterable< T > | OrderBy (INORDER_COMPARER_TYPE &&inorderComparer=INORDER_COMPARER_TYPE{}, Execution::SequencePolicy seq=Execution::SequencePolicy::ePar) const |
| |
| template<Common::IPotentiallyComparer< T > INORDER_COMPARER_TYPE = less<T>> |
| nonvirtual bool | IsOrderedBy (INORDER_COMPARER_TYPE &&inorderComparer=INORDER_COMPARER_TYPE{}) const |
| |
| nonvirtual optional< T > | First () const |
| | return first element in iterable, or if 'that' specified, first where 'that' is true, (or return nullopt if none)
|
| |
| nonvirtual T | FirstValue (ArgByValueType< T > defaultValue={}) const |
| | return first element in iterable provided default
|
| |
| nonvirtual optional< T > | Last () const |
| | return last element in iterable, or if 'that' specified, last where 'that' is true, (or return missing)
|
| |
| nonvirtual T | LastValue (ArgByValueType< T > defaultValue={}) const |
| |
| nonvirtual bool | All (const function< bool(ArgByValueType< T >)> &testEachElt) const |
| | return true iff argument predicate returns true for each element of the iterable
|
| |
| nonvirtual optional< T > | Min () const |
| |
| template<typename RESULT_TYPE = T> |
| nonvirtual RESULT_TYPE | MinValue (ArgByValueType< RESULT_TYPE > defaultValue={}) const |
| |
| nonvirtual optional< T > | Max () const |
| |
| template<typename RESULT_TYPE = T> |
| nonvirtual RESULT_TYPE | MaxValue (ArgByValueType< RESULT_TYPE > defaultValue={}) const |
| |
| template<typename RESULT_TYPE = T> |
| nonvirtual optional< RESULT_TYPE > | Mean () const |
| |
| template<typename RESULT_TYPE = T> |
| nonvirtual RESULT_TYPE | MeanValue (ArgByValueType< RESULT_TYPE > defaultValue={}) const |
| |
| template<typename RESULT_TYPE = T> |
| nonvirtual optional< RESULT_TYPE > | Sum () const |
| |
| template<typename RESULT_TYPE = T> |
| nonvirtual RESULT_TYPE | SumValue (ArgByValueType< RESULT_TYPE > defaultValue={}) const |
| |
| template<constructible_from< T > RESULT_TYPE = T, Common::IPotentiallyComparer< RESULT_TYPE > INORDER_COMPARE_FUNCTION = less<RESULT_TYPE>> |
| nonvirtual optional< RESULT_TYPE > | Median (const INORDER_COMPARE_FUNCTION &compare={}) const |
| |
| template<constructible_from< T > RESULT_TYPE = T> |
| nonvirtual RESULT_TYPE | MedianValue (ArgByValueType< RESULT_TYPE > defaultValue={}) const |
| |
| nonvirtual Iterable< T > | Repeat (size_t count) const |
| |
| nonvirtual bool | Any () const |
| | Any() same as not empty (); Any (includeIfTrue) returns true iff includeIfTrue returns true on any values in iterable.
|
| |
| nonvirtual size_t | Count () const |
| | with no args, same as size, with function filter arg, returns number of items that pass.
|
| |
|
nonvirtual size_t | length () const |
| | STL-ish alias for size() - really in STL only used in string, I think, but still makes sense as an alias.
|
| |
template<typename T>
class Stroika::Foundation::Containers::Set< T >
Set<T> is a container of T, where once an item is added, additionally adds () do nothing.
The Set class is based on SmallTalk-80, The Language & Its Implementation,
page 148.
The basic idea here is that you cannot have multiple copies of the same
thing into the set (like a mathematical set).
- Note
- Thread-Safety C++-Standard-Thread-Safety
vs std::set<T>: Stroika's Set<T> is like std::set<T>, except that o you can separately select different algorithms (besides red-black tree) and not change the API used (Set<T>). o You don't need to have a less<T> method defined. You just need to provide some mechanism (either operator== or argument to constructor) saying how to compare elements for equality o If you have a less<T> already defined, like std::set<T>, this will be used by default to construct a tree-based set. o Sets can also be implemented by hash-tables, etc.
Concrete Implementations: o
- See also
- Concrete::Set_Array<> o
-
Concrete::Set_LinkedList<> o
-
Concrete::SortedSet_stdset<> o
-
Concrete::SortedSet_SkipList<>
Factory:
- See also
- Set_Factory<> to see default implementations.
- Note
- See also: KeyedCollection<> - like Set<>, but for case where object has extra attributes to be preserved (Add)
-
Container Element comparisons: See about ElementInOrderComparerType, ElementThreeWayComparerType and GetElementThreeWayComparer etc
Design Note: Included <set> and have explicit CTOR for set<> so that Stroika Set can be used more interoperably with set<> - and used without an explicit CTOR. Use Explicit CTOR to avoid accidental conversions. But if you declare an API with Set<T> arguments, its important STL sources passing in set<T> work transparently.
Similarly for std::initializer_list.
- Note
- See ReadMe.md for common features of all Stroika containers (especially constructors, iterators, etc)
-
Note About Update method We intentionally omit the Update () method since update given an iterator would do the same thing as Container::Add(). We COULD enhance Add () to take an optional hint parameter in a future version of Stroika.
-
Comparisons: o static_assert (equality_comparable<Set<T>)
o ordering (<,<=> etc) not provided, because a set has no intrinsic ordering between the set elements o when comparing a Set to any Iterable<> - this is treated as 'set' equality comparison
It remains questionable whether or not we should have overloads for comparing Set<> and Iterable<>. When also done with other containers like Sequence, this could produce ambiguity. (like comparing Set with Sequence). But that's probably OK, because when we have ambiguity, we can always explicitly resolve it. So keep these overloads which are pretty convenient.
Definition at line 105 of file Set.h.
Public Types inherited from Stroika::Foundation::Traversal::Iterable< T >
1.9.8