ORIGINAL
Loading...
Searching...
No Matches
algorithms.h
1#ifndef ALGORITHMS_H
2#define ALGORITHMS_H
3
4#include "filter.h"
5#include "iterator.h"
6#include "types.h"
7
8namespace original
9{
10 class algorithms
11 {
12 public:
13 template<typename TYPE>
14 static int64_t distance(const iterator<TYPE>& end, const iterator<TYPE>& begin);
15
16 template<typename TYPE>
17 static iterator<TYPE>* frontOf(const iterator<TYPE>& it, int64_t steps);
18
19 template<typename TYPE>
20 static iterator<TYPE>* backOf(const iterator<TYPE>& it, int64_t steps);
21
22 template<typename TYPE, typename Callback>
23 requires Condition<Callback, TYPE>
24 static bool allOf(const iterator<TYPE>& begin, const iterator<TYPE>& end, const Callback& condition);
25
26 template<typename TYPE, typename Callback>
27 requires Condition<Callback, TYPE>
28 static bool anyOf(const iterator<TYPE>& begin, const iterator<TYPE>& end, const Callback& condition);
29
30 template<typename TYPE, typename Callback>
31 requires Condition<Callback, TYPE>
32 static bool noneOf(const iterator<TYPE>& begin, const iterator<TYPE>& end, const Callback& condition);
33
34 template<typename TYPE>
35 static iterator<TYPE>* find(const iterator<TYPE> &begin, const iterator<TYPE> &end, const TYPE &target);
36
37 template<typename TYPE>
38 static iterator<TYPE>* find(const iterator<TYPE> &begin, uint32_t n, const TYPE &target);
39
40 template<typename TYPE, typename Callback>
41 requires Condition<Callback, TYPE>
42 static iterator<TYPE>* find(const iterator<TYPE> &begin,
43 const iterator<TYPE> &end, const Callback& condition);
44
45 template<typename TYPE, typename Callback>
46 requires Condition<Callback, TYPE>
47 static iterator<TYPE>* find(const iterator<TYPE> &begin, uint32_t n, const Callback& condition);
48
49 template<typename TYPE>
50 static uint32_t count(const iterator<TYPE>& begin, const iterator<TYPE>& end, const TYPE& target);
51
52 template<typename TYPE, typename Callback>
53 requires Condition<Callback, TYPE>
54 static uint32_t count(const iterator<TYPE>& begin, const iterator<TYPE>& end, const Callback& condition);
55
56 template<typename TYPE>
57 static bool equal(const iterator<TYPE>& begin1, const iterator<TYPE>& end1,
58 const iterator<TYPE>& begin2, const iterator<TYPE>& end2);
59
60 template<typename TYPE, typename Callback>
61 requires Operation<Callback, TYPE>
62 static void forEach(const iterator<TYPE>& begin,
63 const iterator<TYPE>& end, Callback operation);
64
65 template<typename TYPE, typename Callback>
66 requires Operation<Callback, TYPE>
67 static iterator<TYPE>* forEach(const iterator<TYPE> &begin, uint32_t n, Callback operation);
68
69 template<typename TYPE, typename Callback_O, typename Callback_C>
70 requires Operation<Callback_O, TYPE> && Condition<Callback_C, TYPE>
71 static void forEach(const iterator<TYPE>& begin, const iterator<TYPE>& end, Callback_O operation, const Callback_C& condition);
72
73 template<typename TYPE, typename Callback_O, typename Callback_C>
74 requires Operation<Callback_O, TYPE> && Condition<Callback_C, TYPE>
75 static iterator<TYPE>* forEach(const iterator<TYPE> &begin, uint32_t n, Callback_O operation, const Callback_C& condition);
76
77 template<typename TYPE>
78 static void fill(const iterator<TYPE>& begin,
79 const iterator<TYPE>& end, const TYPE& value = TYPE{});
80
81 template<typename TYPE>
82 static iterator<TYPE>* fill(const iterator<TYPE> &begin, uint32_t n, const TYPE &value = TYPE{});
83
84 template<typename TYPE>
85 static void swap(const iterator<TYPE>& it1, const iterator<TYPE>& it2) noexcept;
86
87 template<typename TYPE>
88 static iterator<TYPE>* copy(const iterator<TYPE> &begin_src, const iterator<TYPE> &end_src,
89 const iterator<TYPE> &begin_tar);
90
91 template<typename TYPE, typename Callback>
92 requires Condition<Callback, TYPE>
93 static iterator<TYPE>* copy(const iterator<TYPE> &begin_src, const iterator<TYPE> &end_src,
94 const iterator<TYPE> &begin_tar, Callback condition = filter<TYPE>{});
95
96 template<typename TYPE>
97 static iterator<TYPE>* reverse(const iterator<TYPE> &begin, const iterator<TYPE> &end);
98
99 template<typename TYPE, typename Callback>
100 requires Compare<Callback, TYPE>
101 static bool compare(const iterator<TYPE>& it1, const iterator<TYPE>& it2, const Callback& compares);
102
103 template<typename TYPE, typename Callback>
104 requires Compare<Callback, TYPE>
105 static void heapAdjustDown(const iterator<TYPE>& begin, const iterator<TYPE>& range,
106 const iterator<TYPE>& current, const Callback& compares);
107
108 template<typename TYPE, typename Callback>
109 requires Compare<Callback, TYPE>
110 static void heapAdjustUp(const iterator<TYPE>& begin, const iterator<TYPE>& current,
111 const Callback& compares);
112
113 template<typename TYPE, typename Callback>
114 requires Compare<Callback, TYPE>
115 static void heapInit(const iterator<TYPE> &begin, const iterator<TYPE> &end,
116 const Callback& compares);
117
118 protected:
119 template<typename TYPE, typename Callback>
120 requires Compare<Callback, TYPE>
121 static iterator<TYPE>* heapGetPrior(const iterator<TYPE>& begin, const iterator<TYPE>& range,
122 const iterator<TYPE>& parent, const Callback& compares);
123
124
128
129 public:
130 template <typename TYPE>
131 static auto distance(const iterator<TYPE>* end, const iterator<TYPE>* begin) -> int64_t
132 {
133 return distance(*end, *begin);
134 }
135
136 template<typename TYPE>
137 static auto frontOf(const iterator<TYPE> *it, int64_t steps) -> iterator<TYPE> * {
138 return frontOf(*it, steps);
139 }
140
141 template<typename TYPE>
142 static auto backOf(const iterator<TYPE> *it, int64_t steps) -> iterator<TYPE> * {
143 return backOf(*it, steps);
144 }
145
146 template<typename TYPE, typename Callback>
147 requires original::Condition<Callback, TYPE>
148 static auto allOf(const iterator<TYPE> *begin, const iterator<TYPE> *end,
149 const Callback &condition) -> bool {
150 return allOf(*begin, *end, condition);
151 }
152
153 template<typename TYPE, typename Callback>
154 requires original::Condition<Callback, TYPE>
155 static auto anyOf(const iterator<TYPE> *begin, const iterator<TYPE> *end,
156 const Callback &condition) -> bool {
157 return anyOf(*begin, *end, condition);
158 }
159
160 template<typename TYPE, typename Callback>
161 requires original::Condition<Callback, TYPE>
162 static auto noneOf(const iterator<TYPE> *begin, const iterator<TYPE> *end,
163 const Callback &condition) -> bool {
164 return noneOf(*begin, *end, condition);
165 }
166
167 template <typename TYPE>
168 static auto find(const iterator<TYPE>* begin, const iterator<TYPE>* end,
169 const TYPE& target) -> iterator<TYPE>* {
170 return find(*begin, *end, target);
171 }
172
173 template <typename TYPE>
174 static auto find(const iterator<TYPE>* begin, uint32_t n,
175 const TYPE& target) -> iterator<TYPE>* {
176 return find(*begin, n, target);
177 }
178
179 template<typename TYPE, typename Callback>
180 requires original::Condition<Callback, TYPE>
181 static auto find(const iterator<TYPE>* begin, const iterator<TYPE>* end,
182 const Callback& condition) -> iterator<TYPE>* {
183 return find(*begin, *end, condition);
184 }
185
186 template <typename TYPE, typename Callback>
187 requires original::Condition<Callback, TYPE>
188 static auto find(const iterator<TYPE>* begin, uint32_t n, const Callback& condition) -> iterator<TYPE>* {
189 return find(*begin, n, condition);
190 }
191
192 template <typename TYPE>
193 static auto count(const iterator<TYPE>* begin, const iterator<TYPE>* end,
194 const TYPE& target) -> uint32_t {
195 return count(*begin, *end, target);
196 }
197
198 template <typename TYPE, typename Callback>
199 requires original::Condition<Callback, TYPE>
200 static auto count(const iterator<TYPE>* begin, const iterator<TYPE>* end,
201 const Callback& condition) -> uint32_t {
202 return count(*begin, *end, condition);
203 }
204
205 template <typename TYPE>
206 static auto equal(const iterator<TYPE>* begin1, const iterator<TYPE>* end1,
207 const iterator<TYPE>* begin2, const iterator<TYPE>* end2) -> bool {
208 return equal(*begin1, *end1, *begin2, *end2);
209 }
210
211 template <typename TYPE, typename Callback>
212 requires original::Operation<Callback, TYPE>
213 static auto forEach(const iterator<TYPE>* begin, const iterator<TYPE>* end,
214 Callback operation) -> void {
215 forEach(*begin, *end, operation);
216 }
217
218 template <typename TYPE, typename Callback>
219 requires original::Operation<Callback, TYPE>
220 static auto forEach(const iterator<TYPE>* begin, uint32_t n, Callback operation) -> iterator<TYPE>* {
221 return forEach(*begin, n, operation);
222 }
223
224 template<typename TYPE>
225 static auto fill(const iterator<TYPE>* begin, const iterator<TYPE>* end,
226 const TYPE& value) -> void {
227 fill(*begin, *end, value);
228 }
229
230 template<typename TYPE>
231 static auto fill(const iterator<TYPE>* begin, uint32_t n, const TYPE& value) -> iterator<TYPE>* {
232 return fill(*begin, n, value);
233 }
234
235 template <typename TYPE>
236 static auto swap(const iterator<TYPE>* it1, const iterator<TYPE>* it2) noexcept -> void {
237 swap(*it1, *it2);
238 }
239
240 template <typename TYPE>
241 static auto copy(const iterator<TYPE>* begin_src, const iterator<TYPE>* end_src,
242 const iterator<TYPE>* begin_tar) -> iterator<TYPE>* {
243 return copy(*begin_src, *end_src, *begin_tar);
244 }
245
246 template<typename TYPE, typename Callback>
247 requires original::Condition<Callback, TYPE>
248 static auto copy(const iterator<TYPE>* begin_src, const iterator<TYPE>* end_src,
249 const iterator<TYPE>* begin_tar, Callback condition) -> iterator<TYPE>* {
250 return copy(*begin_src, *end_src, *begin_tar, condition);
251 }
252
253 template<typename TYPE>
254 static auto reverse(const iterator<TYPE>* begin, const iterator<TYPE>* end) -> iterator<TYPE>* {
255 return reverse(*begin, *end);
256 }
257
258 template <typename TYPE, typename Callback>
259 requires original::Compare<Callback, TYPE>
260 static auto compare(const iterator<TYPE>* it1, const iterator<TYPE>* it2,
261 const Callback& compares) -> bool {
262 return compare(*it1, *it2, compares);
263 }
264
265 template<typename TYPE, typename Callback>
266 requires original::Compare<Callback, TYPE>
267 static auto heapAdjustDown(const iterator<TYPE>* begin, const iterator<TYPE>* range,
268 const iterator<TYPE>* current, const Callback& compares) -> void {
269 heapAdjustDown(*begin, *range, *current, compares);
270 }
271
272 template<typename TYPE, typename Callback>
273 requires original::Compare<Callback, TYPE>
274 static auto heapAdjustUp(const iterator<TYPE>* begin, const iterator<TYPE>* current,
275 const Callback& compares) -> void {
276 heapAdjustUp(*begin, *current, compares);
277 }
278
279 template<typename TYPE, typename Callback>
280 requires original::Compare<Callback, TYPE>
281 static auto heapInit(const iterator<TYPE>* begin, const iterator<TYPE>* end,
282 const Callback& compares) -> void {
283 heapInit(*begin, *end, compares);
284 }
285
286 template<typename TYPE, typename Callback>
287 requires original::Compare<Callback, TYPE>
288 static auto heapGetPrior(const iterator<TYPE>* begin, const iterator<TYPE>* range,
289 const iterator<TYPE>* parent, const Callback& compares) -> iterator<TYPE>* {
290 return heapGetPrior(*begin, *range, *parent, compares);
291 }
292 };
293}
294
295 template <typename TYPE>
296 auto original::algorithms::distance(const iterator<TYPE>& end, const iterator<TYPE>& begin) -> int64_t
297 {
298 auto* it1 = end.clone();
299 auto* it2 = begin.clone();
300 auto dis = it1->operator-(*it2);
301 delete it1;
302 delete it2;
303 return dis;
304 }
305
306 template<typename TYPE>
307 original::iterator<TYPE> *original::algorithms::frontOf(const iterator<TYPE> &it, int64_t steps) {
308 return it + steps;
309 }
310
311 template<typename TYPE>
312 original::iterator<TYPE> *original::algorithms::backOf(const iterator<TYPE> &it, int64_t steps) {
313 return it - steps;
314 }
315
316 template<typename TYPE, typename Callback>
317 requires original::Condition<Callback, TYPE>
318 bool original::algorithms::allOf(const iterator<TYPE> &begin, const iterator<TYPE> &end,
319 const Callback& condition) {
320 auto* it = begin.clone();
321 for (; distance(*it, end) <= 0; it->next()){
322 if (!condition(it->get())){
323 delete it;
324 return false;
325 }
326 }
327 delete it;
328 return true;
329 }
330
331 template<typename TYPE, typename Callback>
332 requires original::Condition<Callback, TYPE>
333 bool original::algorithms::anyOf(const iterator<TYPE> &begin, const iterator<TYPE> &end,
334 const Callback& condition) {
335 auto* it = begin.clone();
336 for (; distance(*it, end) <= 0; it->next()){
337 if (condition(it->get())){
338 delete it;
339 return true;
340 }
341 }
342 delete it;
343 return false;
344 }
345
346 template<typename TYPE, typename Callback>
347 requires original::Condition<Callback, TYPE>
348 bool original::algorithms::noneOf(const iterator<TYPE> &begin, const iterator<TYPE> &end,
349 const Callback& condition) {
350 auto* it = begin.clone();
351 for (; distance(*it, end) <= 0; it->next()){
352 if (condition(it->get())){
353 delete it;
354 return false;
355 }
356 }
357 delete it;
358 return true;
359 }
360
361 template <typename TYPE>
362 auto original::algorithms::find(const iterator<TYPE>& begin, const iterator<TYPE>& end,
363 const TYPE& target) -> iterator<TYPE>* {
364 auto it = begin.clone();
365 while (it->isValid() && !it->equal(end)) {
366 if (it->get() == target) {
367 return it;
368 }
369 it->next();
370 }
371 delete it;
372 return end.clone();
373 }
374
375 template <typename TYPE>
376 auto original::algorithms::find(const iterator<TYPE>& begin, const uint32_t n, const TYPE& target) -> iterator<TYPE>* {
377 auto it = begin.clone();
378 for (uint32_t i = 0; i < n; i += 1, it->next())
379 {
380 if (it->get() == target) return it;
381 }
382 return it;
383 }
384
385 template<typename TYPE, typename Callback>
386 requires original::Condition<Callback, TYPE>
387 auto original::algorithms::find(const iterator<TYPE> &begin, const iterator<TYPE> &end,
388 const Callback& condition) -> iterator<TYPE>* {
389 auto it = begin.clone();
390 while (it->isValid() && !it->equal(end)) {
391 if (condition(it->get())) {
392 return it;
393 }
394 it->next();
395 }
396 delete it;
397 return end.clone();
398 }
399
400 template <typename TYPE, typename Callback>
401 requires original::Condition<Callback, TYPE>
402 auto original::algorithms::find(const iterator<TYPE>& begin, const uint32_t n, const Callback& condition) -> iterator<TYPE>* {
403 auto it = begin.clone();
404 for (uint32_t i = 0; i < n; i += 1, it->next())
405 {
406 if (condition(it->get())) return it;
407 }
408 return it;
409 }
410
411 template <typename TYPE>
412 auto original::algorithms::count(const iterator<TYPE>& begin, const iterator<TYPE>& end,
413 const TYPE& target) -> uint32_t
414 {
415 uint32_t cnt = 0;
416 auto it = begin.clone();
417 while (it->isValid() && !end.atPrev(it)) {
418 if (it->get() == target) {
419 cnt += 1;
420 }
421 it->next();
422 }
423 delete it;
424 return cnt;
425 }
426
427 template <typename TYPE, typename Callback>
428 requires original::Condition<Callback, TYPE>
429 auto original::algorithms::count(const iterator<TYPE>& begin, const iterator<TYPE>& end,
430 const Callback& condition) -> uint32_t
431 {
432 uint32_t cnt = 0;
433 auto it = begin.clone();
434 while (it->isValid() && !end.atPrev(it)) {
435 if (condition(it->get())) {
436 cnt += 1;
437 }
438 it->next();
439 }
440 delete it;
441 return cnt;
442 }
443
444 template <typename TYPE>
445 auto original::algorithms::equal(const iterator<TYPE>& begin1, const iterator<TYPE>& end1,
446 const iterator<TYPE>& begin2, const iterator<TYPE>& end2) -> bool
447 {
448 auto it1 = begin1.clone();
449 auto it2 = begin2.clone();
450
451 while (it1->isValid() && it2->isValid() && !it1->equal(end1) && !it2->equal(end2)) {
452 it1->next();
453 it2->next();
454 }
455 const bool res = it1->equal(end1) && it2->equal(end2) && it1->get() == it2->get();
456 delete it1;
457 delete it2;
458 return res;
459 }
460
461 template <typename TYPE, typename Callback>
462 requires original::Operation<Callback, TYPE>
463 auto original::algorithms::forEach(const iterator<TYPE>& begin, const iterator<TYPE>& end,
464 Callback operation) -> void
465 {
466 auto it = begin.clone();
467 for (; !it->equal(end); it->next()) {
468 operation(it->get());
469 }
470 operation(it->get());
471 delete it;
472 }
473
474 template <typename TYPE, typename Callback>
475 requires original::Operation<Callback, TYPE>
476 auto original::algorithms::forEach(const iterator<TYPE>& begin, const uint32_t n,
477 Callback operation) -> iterator<TYPE>* {
478 auto it = begin.clone();
479 for (uint32_t i = 0; i < n; i += 1, it->next())
480 {
481 operation(it->get());
482 }
483 return it;
484 }
485
486 template<typename TYPE, typename Callback_O, typename Callback_C>
487 requires original::Operation<Callback_O, TYPE> && original::Condition<Callback_C, TYPE>
488 auto original::algorithms::forEach(const iterator<TYPE> &begin, const iterator<TYPE> &end, Callback_O operation,
489 const Callback_C &condition) -> void {
490 auto it = begin.clone();
491 for (; !it->equal(end); it->next()) {
492 if (condition(it->get()))
493 operation(it->get());
494 }
495 operation(it->get());
496 delete it;
497 }
498
499 template<typename TYPE, typename Callback_O, typename Callback_C>
500 requires original::Operation<Callback_O, TYPE> && original::Condition<Callback_C, TYPE>
501 auto original::algorithms::forEach(const iterator<TYPE> &begin, const uint32_t n, Callback_O operation,
502 const Callback_C &condition) -> iterator<TYPE>* {
503 auto it = begin.clone();
504 for (uint32_t i = 0; i < n; i += 1, it->next())
505 {
506 if (condition(it->get()))
507 operation(it->get());
508 }
509 return it;
510 }
511
512 template<typename TYPE>
513 auto original::algorithms::fill(const iterator<TYPE>& begin,
514 const iterator<TYPE>& end, const TYPE& value) -> void
515 {
516 auto it = begin.clone();
517 while (!it->equal(end)){
518 it->set(value);
519 it->next();
520 }
521 it->set(value);
522 delete it;
523 }
524
525 template<typename TYPE>
526 auto original::algorithms::fill(const iterator<TYPE>& begin,
527 const uint32_t n, const TYPE& value) -> iterator<TYPE>* {
528 auto it = begin.clone();
529 for (uint32_t i = 0; i < n; ++i) {
530 it->set(value);
531 it->next();
532 }
533 return it;
534 }
535
536 template <typename TYPE>
537 auto original::algorithms::swap(const iterator<TYPE>& it1, const iterator<TYPE>& it2) noexcept -> void
538 {
539 auto it_1 = it1.clone();
540 auto it_2 = it2.clone();
541 TYPE tmp = it_2->get();
542 it_2->set(it_1->get());
543 it_1->set(tmp);
544 delete it_1;
545 delete it_2;
546 }
547
548 template <typename TYPE>
549 auto original::algorithms::copy(const iterator<TYPE>& begin_src, const iterator<TYPE>& end_src,
550 const iterator<TYPE>& begin_tar) -> iterator<TYPE>* {
551 auto it_src = begin_src.clone();
552 auto it_tar = begin_tar.clone();
553 while (!it_src->equal(end_src)){
554 it_tar->set(it_src->get());
555 it_src->next();
556 it_tar->next();
557 }
558 it_tar->set(it_src->get());
559 it_tar->next();
560 delete it_src;
561 return it_tar;
562 }
563
564 template<typename TYPE, typename Callback>
565 requires original::Condition<Callback, TYPE>
566 auto original::algorithms::copy(const iterator<TYPE>& begin_src, const iterator<TYPE>& end_src,
567 const iterator<TYPE>& begin_tar, Callback condition) -> iterator<TYPE>* {
568 auto it_src = begin_src.clone();
569 auto it_tar = begin_tar.clone();
570 while (!it_src->equal(end_src)){
571 if (condition(it_src->get())){
572 it_tar->set(it_src->get());
573 }
574 it_src->next();
575 it_tar->next();
576 }
577 if (condition(it_src->get())){
578 it_tar->set(it_src->get());
579 }
580 it_tar->next();
581 delete it_src;
582 return it_tar;
583 }
584
585 template<typename TYPE>
586 auto original::algorithms::reverse(const iterator<TYPE>& begin,
587 const iterator<TYPE>& end) -> iterator<TYPE>* {
588 auto left = begin.clone();
589 auto right = end.clone();
590 while (!left->equal(right) && !left->atNext(right)){
591 swap(left, right);
592 left->next();
593 right->prev();
594 }
595 delete right;
596 return left;
597 }
598
599 template <typename TYPE, typename Callback>
600 requires original::Compare<Callback, TYPE>
601 auto original::algorithms::compare(const iterator<TYPE>& it1, const iterator<TYPE>& it2,
602 const Callback& compares) -> bool
603 {
604 return compares(it1.get(), it2.get());
605 }
606
607 template <typename TYPE, typename Callback>
608 requires original::Compare<Callback, TYPE>
609 auto original::algorithms::heapAdjustDown(const iterator<TYPE>& begin, const iterator<TYPE>& range,
610 const iterator<TYPE>& current, const Callback& compares) -> void
611 {
612 if (distance(current, begin) < 0)
613 return;
614
615 auto* it = current.clone();
616 while (distance(*it, begin) * 2 + 1 <= distance(range, begin))
617 {
618 auto* child = heapGetPrior(begin, range, *it, compares);
619 if (compare(it, child, compares))
620 {
621 delete child;
622 break;
623 }
624 swap(it, child);
625 delete it;
626 it = child->clone();
627 delete child;
628 }
629 delete it;
630 }
631
632 template <typename TYPE, typename Callback>
633 requires original::Compare<Callback, TYPE>
634 auto original::algorithms::heapAdjustUp(const iterator<TYPE>& begin, const iterator<TYPE>& current,
635 const Callback& compares) -> void
636 {
637 auto* it = current.clone();
638 while (distance(*it, begin) > 0)
639 {
640 auto* parent = frontOf(begin, (distance(*it, begin) - 1) / 2);
641 if (compare(it, parent, compares))
642 {
643 swap(it, parent);
644 }else
645 {
646 delete parent;
647 break;
648 }
649 delete parent;
650 }
651 delete it;
652 }
653
654 template <typename TYPE, typename Callback>
655 requires original::Compare<Callback, TYPE>
656 auto original::algorithms::heapInit(const iterator<TYPE>& begin, const iterator<TYPE>& end,
657 const Callback& compares) -> void
658 {
659 auto* it = frontOf(begin, (distance(end, begin) + 1) / 2 - 1);
660 for (; distance(*it, begin) >= 0; it->prev())
661 {
662 heapAdjustDown(begin, end, *it, compares);
663 }
664 delete it;
665 }
666
667 template <typename TYPE, typename Callback>
668 requires original::Compare<Callback, TYPE>
669 auto original::algorithms::heapGetPrior(const iterator<TYPE>& begin, const iterator<TYPE>& range,
670 const iterator<TYPE>& parent, const Callback& compares) -> iterator<TYPE>*
671 {
672 if (distance(parent, begin) * 2 + 2 <= distance(range, begin))
673 {
674 auto* left = frontOf(begin, distance(parent, begin) * 2 + 1);
675 auto* right = frontOf(begin, distance(parent, begin) * 2 + 2);
676 if (compare(left, right, compares))
677 {
678 delete right;
679 return left;
680 }
681 delete left;
682 return right;
683 }
684 return frontOf(begin, distance(parent, begin) * 2 + 1);
685 }
686
687#endif // ALGORITHMS_H
original::algorithms
Definition algorithms.h:11
original::algorithms::distance
static auto distance(const iterator< TYPE > *end, const iterator< TYPE > *begin) -> int64_t
Definition algorithms.h:131
original::filter
Definition filter.h:8
original::iterator
Definition iterator.h:11
original::Compare
Definition types.h:24
original::Condition
Definition types.h:28
original::Operation
Definition types.h:31
Generated by doxygen 1.13.2