Stroika Library 3.0d16
 
Loading...
Searching...
No Matches
KeyedCollection_Array.inl
1/*
2 * Copyright(c) Sophist Solutions, Inc. 1990-2025. All rights reserved
3 */
4#include "Stroika/Foundation/Containers/DataStructures/Array.h"
5#include "Stroika/Foundation/Containers/Private/IteratorImplHelper.h"
6#include "Stroika/Foundation/Debug/Cast.h"
7#include "Stroika/Foundation/Memory/BlockAllocated.h"
8
9namespace Stroika::Foundation::Containers::Concrete {
10
11 /*
12 */
13 template <typename T, typename KEY_TYPE, typename TRAITS>
14 template <qCompilerAndStdLib_ConstraintDiffersInTemplateRedeclaration_BWA (IEqualsComparer<KEY_TYPE>) KEY_EQUALS_COMPARER>
15 class KeyedCollection_Array<T, KEY_TYPE, TRAITS>::Rep_ : public Private::ArrayBasedContainerRepImpl<Rep_<KEY_EQUALS_COMPARER>, IImplRepBase_>,
16 public Memory::UseBlockAllocationIfAppropriate<Rep_<KEY_EQUALS_COMPARER>> {
17 private:
18 using inherited = Private::ArrayBasedContainerRepImpl<Rep_<KEY_EQUALS_COMPARER>, IImplRepBase_>;
19
20 private:
21 [[no_unique_address]] const KeyExtractorType fKeyExtractor_;
22 [[no_unique_address]] const KEY_EQUALS_COMPARER fKeyComparer_;
23
24 public:
25 Rep_ (const KeyExtractorType& keyExtractor, const KEY_EQUALS_COMPARER& keyComparer)
26 : fKeyExtractor_{keyExtractor}
27 , fKeyComparer_{keyComparer}
28 {
29 }
30 Rep_ (const Rep_& from) = default;
31
32 public:
33 nonvirtual Rep_& operator= (const Rep_&) = delete;
34
35 // Iterable<T>::_IRep overrides
36 public:
37 virtual shared_ptr<typename Iterable<T>::_IRep> Clone () const override
38 {
39 Debug::AssertExternallySynchronizedMutex::ReadContext declareContext{fData_};
40 return Memory::MakeSharedPtr<Rep_> (*this);
41 }
42 virtual Iterator<value_type> MakeIterator () const override
43 {
44 Debug::AssertExternallySynchronizedMutex::ReadContext declareContext{fData_};
45 return Iterator<value_type>{make_unique<IteratorRep_> (&fData_, &fChangeCounts_)};
46 }
47 virtual size_t size () const override
48 {
49 Debug::AssertExternallySynchronizedMutex::ReadContext declareContext{fData_};
50 return fData_.size ();
51 }
52 virtual bool empty () const override
53 {
54 Debug::AssertExternallySynchronizedMutex::ReadContext declareContext{fData_};
55 return fData_.empty ();
56 }
57 virtual void Apply (const function<void (ArgByValueType<value_type> item)>& doToElement, [[maybe_unused]] Execution::SequencePolicy seq) const override
58 {
59 Debug::AssertExternallySynchronizedMutex::ReadContext declareContext{fData_};
60 fData_.Apply (doToElement);
61 }
62 virtual Iterator<value_type> Find (const function<bool (ArgByValueType<value_type> item)>& that,
63 [[maybe_unused]] Execution::SequencePolicy seq) const override
64 {
65 Debug::AssertExternallySynchronizedMutex::ReadContext declareContext{fData_};
66 if (auto i = fData_.Find (that)) {
67 return Iterator<value_type>{make_unique<IteratorRep_> (&fChangeCounts_, i)};
68 }
69 return nullptr;
70 }
71
72 // KeyedCollection<T, KEY_TYPE, TRAITS>::_IRep overrides
73 public:
74 virtual KeyExtractorType GetKeyExtractor () const override
75 {
76 Debug::AssertExternallySynchronizedMutex::ReadContext declareContext{fData_};
77 return fKeyExtractor_;
78 }
79 virtual KeyEqualityComparerType GetKeyEqualityComparer () const override
80 {
81 Debug::AssertExternallySynchronizedMutex::ReadContext declareContext{fData_};
82 return fKeyComparer_;
83 }
84 virtual shared_ptr<typename KeyedCollection<T, KEY_TYPE, TRAITS>::_IRep> CloneEmpty () const override
85 {
86 Debug::AssertExternallySynchronizedMutex::ReadContext declareContext{fData_};
87 return Memory::MakeSharedPtr<Rep_> (this->fKeyExtractor_, this->fKeyComparer_); // lose data but keep compare functions
88 }
89 virtual shared_ptr<typename KeyedCollection<T, KEY_TYPE, TRAITS>::_IRep> CloneAndPatchIterator (Iterator<value_type>* i) const override
90 {
91 RequireNotNull (i);
92 Debug::AssertExternallySynchronizedMutex::ReadContext declareContext{fData_};
93 auto result = Memory::MakeSharedPtr<Rep_> (*this);
94 auto& mir = Debug::UncheckedDynamicCast<const IteratorRep_&> (i->ConstGetRep ());
95 result->fData_.MoveIteratorHereAfterClone (&mir.fIterator, &fData_);
96 i->Refresh (); // reflect updated rep
97 return result;
98 }
99 virtual bool Lookup (ArgByValueType<KeyType> key, optional<value_type>* item) const override
100 {
101 Debug::AssertExternallySynchronizedMutex::ReadContext declareContext{fData_};
102 if (auto i = this->Find ([this, &key] (ArgByValueType<T> item) { return fKeyComparer_ (fKeyExtractor_ (item), key); },
103 Execution::SequencePolicy::eDEFAULT)) {
104 if (item != nullptr) {
105 *item = *i;
106 }
107 return true;
108 }
109 return false;
110 }
111 virtual bool Add (ArgByValueType<value_type> item) override
112 {
113 Debug::AssertExternallySynchronizedMutex::WriteContext declareContext{fData_};
114 KEY_TYPE key{fKeyExtractor_ (item)};
115 if (auto i = this->Find ([this, &key] (ArgByValueType<T> item) { return fKeyComparer_ (fKeyExtractor_ (item), key); },
116 Execution::SequencePolicy::eDEFAULT)) {
117 auto& mir = Debug::UncheckedDynamicCast<const IteratorRep_&> (i.ConstGetRep ());
118 fData_.SetAt (mir.fIterator, item);
119 fChangeCounts_.PerformedChange ();
120 return false;
121 }
122 else {
123 fData_.push_back (item); // order meaningless for collection, and append cheaper on array
124 fChangeCounts_.PerformedChange ();
125 return true;
126 }
127 }
128 virtual void Remove (const Iterator<value_type>& i, Iterator<value_type>* nextI) override
129 {
130 Debug::AssertExternallySynchronizedMutex::WriteContext declareContext{fData_};
131 auto& mir = Debug::UncheckedDynamicCast<const IteratorRep_&> (i.ConstGetRep ());
132 if (nextI == nullptr) {
133 fData_.Remove (mir.fIterator);
134 fChangeCounts_.PerformedChange ();
135 }
136 else {
137 auto retI = fData_.erase (mir.fIterator);
138 fChangeCounts_.PerformedChange ();
139 *nextI = Iterator<value_type>{make_unique<IteratorRep_> (&fChangeCounts_, retI)};
140 }
141 }
142 virtual bool RemoveIf (ArgByValueType<KEY_TYPE> key) override
143 {
144 Debug::AssertExternallySynchronizedMutex::WriteContext declareContext{fData_};
145 if (auto i = this->Find ([this, &key] (ArgByValueType<T> item) { return fKeyComparer_ (fKeyExtractor_ (item), key); },
146 Execution::SequencePolicy::eDEFAULT)) {
147 Remove (i, nullptr);
148 return true;
149 }
150 return false;
151 }
152
153 private:
154 using DataStructureImplType_ = DataStructures::Array<value_type>;
155 using IteratorRep_ = typename Private::IteratorImplHelper_<value_type, DataStructureImplType_>;
156
157 private:
158 DataStructureImplType_ fData_;
159 [[no_unique_address]] Private::ContainerDebugChangeCounts_ fChangeCounts_;
160
161 private:
162 friend inherited;
163 };
164
165 /*
166 ********************************************************************************
167 ***************************** KeyedCollection_Array<T> *************************
168 ********************************************************************************
169 */
170 template <typename T, typename KEY_TYPE, typename TRAITS>
171 template <IEqualsComparer<KEY_TYPE> KEY_EQUALS_COMPARER>
172 inline KeyedCollection_Array<T, KEY_TYPE, TRAITS>::KeyedCollection_Array (KEY_EQUALS_COMPARER&& keyComparer)
173 requires (IKeyedCollection_ExtractorCanBeDefaulted<T, KEY_TYPE, TRAITS>)
174 : KeyedCollection_Array{KeyExtractorType{}, forward<KEY_EQUALS_COMPARER> (keyComparer)}
175 {
176 AssertRepValidType_ ();
177 }
178 template <typename T, typename KEY_TYPE, typename TRAITS>
179 template <IEqualsComparer<KEY_TYPE> KEY_EQUALS_COMPARER>
180 inline KeyedCollection_Array<T, KEY_TYPE, TRAITS>::KeyedCollection_Array (const KeyExtractorType& keyExtractor, KEY_EQUALS_COMPARER&& keyComparer)
181 : inherited{Memory::MakeSharedPtr<Rep_<KEY_EQUALS_COMPARER>> (keyExtractor, forward<KEY_EQUALS_COMPARER> (keyComparer))}
182 {
183 AssertRepValidType_ ();
184 }
185#if !qCompilerAndStdLib_RequiresNotMatchInlineOutOfLineForTemplateClassBeingDefined_Buggy
186 template <typename T, typename KEY_TYPE, typename TRAITS>
187 template <IIterableOfTo<T> ITERABLE_OF_ADDABLE, IEqualsComparer<KEY_TYPE> KEY_EQUALS_COMPARER>
188 requires (IKeyedCollection_ExtractorCanBeDefaulted<T, KEY_TYPE, TRAITS> and
189 not derived_from<remove_cvref_t<ITERABLE_OF_ADDABLE>, KeyedCollection_Array<T, KEY_TYPE, TRAITS>>)
190 inline KeyedCollection_Array<T, KEY_TYPE, TRAITS>::KeyedCollection_Array (ITERABLE_OF_ADDABLE&& src)
191 : KeyedCollection_Array{KeyExtractorType{}, equal_to<KEY_TYPE>{}}
192 {
193 this->AddAll (src);
194 AssertRepValidType_ ();
195 }
196#endif
197 template <typename T, typename KEY_TYPE, typename TRAITS>
198 template <IIterableOfTo<T> ITERABLE_OF_ADDABLE, IEqualsComparer<KEY_TYPE> KEY_EQUALS_COMPARER>
199 inline KeyedCollection_Array<T, KEY_TYPE, TRAITS>::KeyedCollection_Array (KEY_EQUALS_COMPARER&& keyComparer, ITERABLE_OF_ADDABLE&& src)
200 requires (IKeyedCollection_ExtractorCanBeDefaulted<T, KEY_TYPE, TRAITS>)
201 : KeyedCollection_Array{KeyExtractorType{}, forward<KEY_EQUALS_COMPARER> (keyComparer)}
202 {
203 this->AddAll (src);
204 AssertRepValidType_ ();
205 }
206 template <typename T, typename KEY_TYPE, typename TRAITS>
207 template <IEqualsComparer<KEY_TYPE> KEY_EQUALS_COMPARER, IIterableOfTo<T> ITERABLE_OF_ADDABLE>
208 inline KeyedCollection_Array<T, KEY_TYPE, TRAITS>::KeyedCollection_Array (const KeyExtractorType& keyExtractor,
209 KEY_EQUALS_COMPARER&& keyComparer, ITERABLE_OF_ADDABLE&& src)
210 : KeyedCollection_Array{keyExtractor, forward<KEY_EQUALS_COMPARER> (keyComparer)}
211 {
212 this->AddAll (src);
213 AssertRepValidType_ ();
214 }
215 template <typename T, typename KEY_TYPE, typename TRAITS>
216 template <IInputIterator<T> ITERATOR_OF_ADDABLE, IEqualsComparer<KEY_TYPE> KEY_EQUALS_COMPARER>
217 KeyedCollection_Array<T, KEY_TYPE, TRAITS>::KeyedCollection_Array (ITERATOR_OF_ADDABLE&& start, ITERATOR_OF_ADDABLE&& end)
218 requires (IKeyedCollection_ExtractorCanBeDefaulted<T, KEY_TYPE, TRAITS>)
219 : KeyedCollection_Array{KeyExtractorType{}, KEY_EQUALS_COMPARER{}}
220 {
221 this->AddAll (forward<ITERATOR_OF_ADDABLE> (start), forward<ITERATOR_OF_ADDABLE> (end));
222 AssertRepValidType_ ();
223 }
224 template <typename T, typename KEY_TYPE, typename TRAITS>
225 template <IInputIterator<T> ITERATOR_OF_ADDABLE, IEqualsComparer<KEY_TYPE> KEY_EQUALS_COMPARER>
226 KeyedCollection_Array<T, KEY_TYPE, TRAITS>::KeyedCollection_Array (KEY_EQUALS_COMPARER&& keyComparer, ITERATOR_OF_ADDABLE&& start,
227 ITERATOR_OF_ADDABLE&& end)
228 requires (IKeyedCollection_ExtractorCanBeDefaulted<T, KEY_TYPE, TRAITS>)
229 : KeyedCollection_Array{KeyExtractorType{}, forward<KEY_EQUALS_COMPARER> (keyComparer)}
230 {
231 this->AddAll (forward<ITERATOR_OF_ADDABLE> (start), forward<ITERATOR_OF_ADDABLE> (end));
232 AssertRepValidType_ ();
233 }
234 template <typename T, typename KEY_TYPE, typename TRAITS>
235 template <IEqualsComparer<KEY_TYPE> KEY_EQUALS_COMPARER, IInputIterator<T> ITERATOR_OF_ADDABLE>
236 KeyedCollection_Array<T, KEY_TYPE, TRAITS>::KeyedCollection_Array (const KeyExtractorType& keyExtractor, KEY_EQUALS_COMPARER&& keyComparer,
237 ITERATOR_OF_ADDABLE&& start, ITERATOR_OF_ADDABLE&& end)
238 : KeyedCollection_Array{keyExtractor, forward<KEY_EQUALS_COMPARER> (keyComparer)}
239 {
240 this->AddAll (forward<ITERATOR_OF_ADDABLE> (start), forward<ITERATOR_OF_ADDABLE> (end));
241 AssertRepValidType_ ();
242 }
243 template <typename T, typename KEY_TYPE, typename TRAITS>
244 inline void KeyedCollection_Array<T, KEY_TYPE, TRAITS>::AssertRepValidType_ () const
245 {
246 if constexpr (qStroika_Foundation_Debug_AssertionsChecked) {
247 typename inherited::template _SafeReadRepAccessor<IImplRepBase_> tmp{this}; // for side-effect of AssertMemeber
248 }
249 }
250
251}
qStroika_Foundation_Debug_AssertionsChecked
#define qStroika_Foundation_Debug_AssertionsChecked
The qStroika_Foundation_Debug_AssertionsChecked flag determines if assertions are checked and validat...
Definition Assertions.h:48
RequireNotNull
#define RequireNotNull(p)
Definition Assertions.h:347
Stroika::Foundation::Containers::Concrete::KeyedCollection_Array
KeyedCollection_Array<T> is an Array-based concrete implementation of the KeyedCollection<T> containe...
Definition KeyedCollection_Array.h:44
Stroika::Foundation::Containers::Concrete::KeyedCollection_Array::KeyedCollection_Array
KeyedCollection_Array(KEY_EQUALS_COMPARER &&keyComparer=KEY_EQUALS_COMPARER{})
Definition KeyedCollection_Array.inl:172
Stroika::Foundation::Debug::AssertExternallySynchronizedMutex::ReadContext
shared_lock< const AssertExternallySynchronizedMutex > ReadContext
Instantiate AssertExternallySynchronizedMutex::ReadContext to designate an area of code where protect...
Definition AssertExternallySynchronizedMutex.h:288
Stroika::Foundation::Debug::AssertExternallySynchronizedMutex::WriteContext
unique_lock< AssertExternallySynchronizedMutex > WriteContext
Instantiate AssertExternallySynchronizedMutex::WriteContext to designate an area of code where protec...
Definition AssertExternallySynchronizedMutex.h:309
Stroika::Foundation::Containers::IKeyedCollection_ExtractorCanBeDefaulted
Definition KeyedCollection.h:83
Stroika::Foundation::Execution::SequencePolicy
SequencePolicy
equivalent which of 4 types being used std::execution::sequenced_policy, parallel_policy,...
Definition Foundation/Execution/Common.h:21