acme
Foundational cross-platform layer of the ca2 framework
Loading...
Searching...
No Matches
range.h
1// Refactored around 2022-09-12 by camilo <3ThomasBorregaardSorensen!!
2#pragma once
3
4//template < typename SAME_AS, typename COMPARE >
5//concept same_as = ::std::is_same_v< SAME_AS, COMPARE >;
6
7#include "acme/prototype/comparison/compare.h"
8
9
10enum enum_range : ::i32
11{
12
13 e_range_none = 0,
14 //e_range_null_terminated = 1,
15 //e_range_string = 2,
22 e_range_string_literal = 4,
29
41 //e_range_scoped_ownership = 32768,
42 e_range_buffer = 65536,
43 //e_range_read_only = 4,
44 //e_range_read_only_and_null_terminated = 5,
45 //e_range_scoped_string_allocation = 2,
46 //e_range_array_allocate = 128,
47 e_range_array_carriage_return = 256,
48 e_range_array_clear_on_allocate = 512,
49
50 //e_range_node_malloc = 1024,
51
52
53};
54
55//
56//template < prototype_character CHARACTER, character_count n >
57//constexpr ::range < const CHARACTER* > as_string_literal(const CHARACTER* s)
58//{
59//
60// if constexpr (n >= 1)
61// {
62//
63// if (s[n - 1] == CHARACTER{})
64// {
65//
66// return { s, s + n - 1, e_range_null_terminated };
67//
68// }
69//
70// }
71//
72// return { s, s + n, e_range_none };
73//
74//}
75
76
77
78template < typename TYPE >
79auto & get(TYPE * p)
80{
81
82 return *p;
83
84}
85
86template < typename TYPE >
87auto & get(const TYPE * p)
88{
89
90 return *p;
91
92}
93
94
95DECLARE_C_FLAG(e_range, enum_range);
96
97
98template < prototype_range RANGE >
99constexpr RANGE _start_end_range(const RANGE & range, memsize start, typename RANGE::const_iterator end)
100{
101
102 return {
103 ::clipped_add(range.begin(), start, range.begin(), range.end()),
104 ::clipped_add(range.begin(), end - range.begin(), range.begin(), range.end())
105 };
106
107}
108
109
110template < prototype_range RANGE >
111constexpr RANGE _start_count_range(const RANGE & range, memsize start, memsize count)
112{
113
114 return {
115 ::clipped_add(range.begin(), start, range.begin(), range.end()),
116 ((count >= 0) ? ::clipped_add(range.begin(), start + count, range.begin(), range.end()) :
117 ::clipped_add(range.end(), count + 1, range.begin(), range.end())) };
118
119}
120
121
122template<typename ITERATOR_TYPE>
123struct get_iterator_item_struct
124{
125
126 using ITEM = typename ITERATOR_TYPE::ITEM;
127
128};
129
130
131template<typename ITEM_TYPE>
132struct get_iterator_item_struct<ITEM_TYPE *>
133{
134
135 using ITEM = ITEM_TYPE;
136
137};
138
139
140template<typename ITEM_TYPE>
141using get_iterator_item = typename get_iterator_item_struct < ITEM_TYPE >::ITEM;
142
143
144template<typename TYPE>
145struct get_type_item_pointer_struct
146{
147
148 using type = typename TYPE::ITEM_POINTER;
149
150};
151
152
153template<typename TYPE>
154struct get_type_item_pointer_struct<TYPE *>
155{
156
157 using type = non_const<TYPE> *;
158
159};
160
161
162template<typename TYPE>
163struct get_type_item_pointer_struct<const TYPE *>
164{
165
166 using type = TYPE *;
167
168};
169
170
171template<typename TYPE>
172using get_type_item_pointer = typename get_type_item_pointer_struct < TYPE >::type;
173
174
175
176template<typename iterator>
177struct get_iterator_struct
178{
179
180 using type = typename iterator::iterator;
181
182};
183
184
185template<typename TYPE>
186struct get_iterator_struct<TYPE *>
187{
188
189 using type = non_const<TYPE> *;
190
191};
192
193template<typename TYPE >
194using get_iterator = typename get_iterator_struct < TYPE >::type;
195
196
197
198template<typename iterator>
199struct get_const_iterator_struct
200{
201
202 using type = typename iterator::const_iterator;
203
204};
205
206
207template<typename TYPE>
208struct get_const_iterator_struct<TYPE *>
209{
210
211 using type = const non_const<TYPE> *;
212
213};
214
215
216template<typename TYPE >
217using get_const_iterator = typename get_const_iterator_struct < TYPE >::type;
218
219
220
221template<typename ITERATOR_TYPE>
222class range
223{
224public:
225
226
227 using this_iterator = ITERATOR_TYPE;
228 using iterator = get_iterator<ITERATOR_TYPE>;
229 using const_iterator = get_const_iterator<iterator>;
230
231
232 using THIS_RAW_RANGE = ::range<ITERATOR_TYPE>;
233 using RAW_RANGE = ::range<iterator>;
234 using CONST_RAW_RANGE = ::range<const_iterator>;
235
236
237 using THIS_RANGE = ::range<ITERATOR_TYPE>;
238 using RANGE = ::range<iterator>;
239 using CONST_RANGE = ::range<const_iterator>;
240
241
242 using ITEM_POINTER = get_type_item_pointer<iterator>;
243
244
245 using THIS_ITEM = get_iterator_item<this_iterator>;
246 using ITEM = non_const<THIS_ITEM>;
247 using CONST_ITEM = add_const<THIS_ITEM>;
248 using ARG_ITEM = argument_of < ITEM >;
249
250
251 this_iterator m_begin;
252 this_iterator m_end;
253 enum_range m_erange;
254
255
256 constexpr range(no_initialize_t)
257 {
258 }
259
260 constexpr range(nullptr_t) :
261 range(nullptr, nullptr, e_range_none)
262 {
263
264 };
265
266 constexpr range() :
267 range(nullptr, nullptr, e_range_none)
268 {
269 }
270
271
272 template<::collection::count count>
273 constexpr range(const ITEM(&array)[count], enum_range erange = e_range_none)
274 requires
275 (!prototype_character < ITEM >)
276 : range(array, count, erange)
277 {
278 }
279
280 //template < typename CHARACTER, character_count n >
281 //constexpr range(const CHARACTER(& s)[n]) requires
282 // prototype_character < CHARACTER > &&
283 // ::std::is_same_v<non_const<non_pointer<CHARACTER>>, non_const<non_pointer<ITEM>>>
284 //{
285
286 // if constexpr (n >= 1)
287 // {
288
289 // if (s[n - 1] == CHARACTER{})
290 // {
291
292 // this->m_begin = s;
293 // this->m_end = s + n - 1;
294 // this->m_erange = e_range_null_terminated;
295
296 // return;
297
298 // }
299
300 // }
301
302 // this->m_begin = s;
303 // this->m_end = s + n;
304 // this->m_erange = e_range_none;
305
306 //}
307
308
309 template<typed_range<iterator> TYPED_RANGE>
310 constexpr range(const TYPED_RANGE& range)
311 requires(!::std::is_same_v < TYPED_RANGE, THIS_RANGE >) :
312 m_begin((this_iterator)range.begin()),
313 m_end((this_iterator)range.end()),
314 m_erange(range.m_erange)
315 {
316
317
318 }
319
320
321 constexpr range(const range & range) :
322 m_begin(range.m_begin),
323 m_end(range.m_end),
324 m_erange(range.m_erange)
325 {
326
327 }
328
329
330 constexpr range(range && range) :
331 m_begin(range.m_begin),
332 m_end(range.m_end),
333 m_erange(range.m_erange)
334 {
335
336 range.m_begin = nullptr;
337 range.m_end = nullptr;
338 range.m_erange = e_range_none;
339
340 }
341
342
343 template<typename TYPE>
344 constexpr range(TYPE *& p) :
345 m_begin((this_iterator)p),
346 m_end((this_iterator)find_first_null_character(p)),
347 //m_erange(e_range_null_terminated)
348 m_erange(e_range_none)
349 {
350
351 }
352
353
354 template<prototype_integral INTEGRAL>
355 constexpr range(this_iterator begin, INTEGRAL count, enum_range erange = e_range_none) :
356 m_begin(begin), m_end(begin + count), m_erange(erange)
357 {
358 }
359
360 constexpr range(this_iterator begin, this_iterator end, enum_range erange = e_range_none) :
361 m_begin(begin), m_end(end), m_erange(erange)
362 {
363 }
364
365 template<::comparison::equality<ITEM> EQUALITY>
366 constexpr range(this_iterator begin, EQUALITY equality) :
367 m_begin(begin),
368 m_end((this_iterator)find_first_null_character(begin, equality)),
369 //m_erange(e_range_null_terminated)
370 m_erange(e_range_none)
371 {
372 }
373
374
375
376
377
378 range & operator =(const range & range)
379 {
380
381 m_begin = range.m_begin;
382 m_end = range.m_end;
383 m_erange = range.m_erange;
384
385 return *this;
386
387 }
388
389
390 range & operator=(range && range)
391 {
392
393 m_begin = range.m_begin;
394 m_end = range.m_end;
395 m_erange = range.m_erange;
396 range.m_begin = nullptr;
397 range.m_end = nullptr;
398 range.m_erange = e_range_none;
399
400 return *this;
401
402 }
403
404
405 void add_initializer_list(const ::std::initializer_list<ITEM> & initializer_list)
406 {
407
408 // not implementable for ranges without allocation
409
410 }
411
412
413 void set_null()
414 {
415
416 this->m_begin = nullptr;
417
418 this->m_end = nullptr;
419
420 this->m_erange = e_range_none;
421
422 }
423
424
425
426 //constexpr bool is_string() const { return m_erange & e_range_string; }
427 //constexpr void set_string_flag() { m_erange = (enum_range)(m_erange | e_range_string); }
428 //constexpr void clear_string_flag() { m_erange = (enum_range) (m_erange & ~e_range_string); }
429
430
431 template < prototype_integral START >
432 constexpr THIS_RAW_RANGE operator()(START start) const
433 {
434
435 return { m_begin + start, m_end };
436
437 }
438
439
440 template < prototype_integral START, prototype_integral COUNT >
441 constexpr THIS_RAW_RANGE operator()(START start, COUNT count) const
442 {
443
444 return { m_begin + start, (count < 0) ? m_end + count + 1 : m_begin + start + count };
445
446 }
447
448 //
449 // template < prototype_character CHARACTER >
450 // character_count __utf_length(CHARACTER * ptrigger, character_count *& plen) const;
451 //
452 //
453 // template < prototype_character CHARACTER >
454 // void __utf_concatenate_to(CHARACTER *& p, character_count *& plen) const;
455 //
456
457 ::collection::count array_get_count() const { return this->m_end - this->m_begin; }
458
459 template < same_as < ITEM > A_ITEM >
460 void block_concatenate_to(A_ITEM * & p)
461 {
462
463 auto s = size();
464
465 if (s < 32)
466 {
467
468 auto psrc = this->m_begin;
469
470 while (s > 0)
471 {
472
473 *p++ = *psrc++;
474
475 s--;
476
477 }
478
479 }
480 else
481 {
482
483 ::memory_copy(p, this->m_begin, s*sizeof(ITEM));
484
485 p += s;
486
487 }
488
489 }
490
491 template < prototype_integral START >
492 constexpr THIS_RAW_RANGE operator()(START start)
493 {
494
495 return { m_begin + start, m_end };
496
497 }
498
499
500 template < prototype_integral START, prototype_integral COUNT >
501 THIS_RAW_RANGE operator()(START start, COUNT count)
502 {
503
504 return { m_begin + start, (count < 0) ? m_end + count + 1 : m_begin + start + count };
505
506 }
507
508
509 constexpr auto index_of(const_iterator p) const
510 {
511
512 return p - (const_iterator)this->begin();
513
514 }
515
516
517 this_iterator & begin()
518 {
519 return m_begin;
520 }
521
522 this_iterator & end()
523 {
524 return m_end;
525 }
526
527 const_iterator begin() const
528 {
529 return (const_iterator) m_begin;
530 }
531
532 const_iterator end() const
533 {
534 return (const_iterator) m_end;
535 }
536
537 this_iterator & begin(this_iterator begin)
538 {
539 return m_begin = begin;
540 }
541
542 this_iterator & end(this_iterator end)
543 {
544 return m_end = end;
545 }
546
547 auto & first();
548 auto & first() const;
549
550 constexpr this_iterator data()
551 {
552 return m_begin;
553 }
554
555
556 constexpr const this_iterator data() const
557 {
558 return m_begin;
559 }
560
561
562 static constexpr memsize item_size()
563 {
564 return sizeof(ITEM);
565 }
566
567 constexpr ::collection::count size() const
568 {
569 return this->m_end - this->m_begin;
570 }
571
572 constexpr memsize size_in_bytes() const
573 {
574 return this->size() * this->item_size();
575 }
576
577
578 constexpr bool is_empty() const
579 {
580 return size() <= 0;
581 }
582
583 constexpr bool is_set() const
584 {
585 return !is_empty();
586 }
587
588
589 inline bool operator!() const
590 {
591 return is_empty();
592 }
593
594
595 constexpr bool is_before_begin(const_iterator iterator) const
596 {
597
598 return ::iterator_is_before_begin(iterator, m_begin);
599
600 }
601
602
603 constexpr bool is_end(const_iterator iterator) const
604 {
605
606 return ::iterator_is_end(iterator, m_end);
607
608 }
609
610
611 constexpr bool is_iterator_ok(const_iterator iterator) const
612 {
613
614 return !this->is_end(iterator);
615
616
617 }
618
619
620 constexpr bool is_this_range(const range& range) const
621 {
622
623 return this->m_begin == range.m_begin && this->m_end == range.m_end;
624
625 }
626
627
628
629
630
631 //constexpr bool iterator_ok(const_iterator iterator) const
632 //{
633
634 // return ::iterator_is_ok(iterator, m_begin, m_end);
635
636 //}
637
638 //constexpr bool is_end() const
639 //{
640
641 // return ::range_is_empty(m_begin, m_end);
642
643 //}
644
645
646 //constexpr bool is_ok(iterator iterator) const
647 //{
648
649 // return ::range_is_ok(iterator, m_end);
650
651 //}
652
653 //constexpr bool is_ok() const
654 //{
655
656 // return ::range_is_ok(m_begin, m_end);
657
658 //}
659
660
661 constexpr THIS_RAW_RANGE _start_range(memsize start) const
662 {
663
664 return { (ITERATOR_TYPE) (this->begin() + start), (ITERATOR_TYPE)this->end() };
665
666 }
667
668
669 constexpr THIS_RAW_RANGE _end_range(const_iterator end) const
670 {
671
672 return { (ITERATOR_TYPE) this->begin(), (ITERATOR_TYPE)end };
673
674 }
675
676
677 constexpr THIS_RAW_RANGE _start_count_range(memsize start, memsize count) const
678 {
679
680 return {
681 (ITERATOR_TYPE) (this->begin() + start),
682 (ITERATOR_TYPE) (((count >= 0) ? ::clipped_add(this->begin(), start + count, this->begin(), this->end()) : ::clipped_add(
683 this->end(), count + 1, this->begin(), this->end()))) };
684
685 }
686
687
688 static constexpr bool _initialize_equals(bool & b, const THIS_RAW_RANGE & range, const THIS_RAW_RANGE & rangeBlock)
689 {
690
691
692
693 return false;
694
695 }
696
697
698 template<::comparison::equality<ITEM> EQUALITY>
699 static constexpr bool _static_equals(THIS_RAW_RANGE range, THIS_RAW_RANGE rangeBlock, EQUALITY equality)
700 {
701
702 while (range.begin() < range.end())
703 {
704
705 if (!equality.equals(*range.begin(), *rangeBlock.begin()))
706 {
707
708 return false;
709
710 }
711
712 range.begin()++;
713
714 rangeBlock.begin()++;
715
716 }
717
718 return true;
719
720 }
721
722
723 template<::comparison::equality<ITEM> EQUALITY>
724 static constexpr bool static_equals(const THIS_RAW_RANGE & range, const THIS_RAW_RANGE & rangeBlock, EQUALITY equality)
725 {
726
727 auto sizeRange = range.size();
728
729 return sizeRange != rangeBlock.size() ? false :
730 (sizeRange <= 0 ?
731 true:
732 _static_equals(range, rangeBlock, equality)
733 );
734
735 }
736
737
738 template<::comparison::equality<ITEM> EQUALITY>
739 constexpr bool _equals(const THIS_RAW_RANGE & rangeBlock, EQUALITY equality) const
740 {
741
742 return _static_equals(*this, rangeBlock, equality);
743
744 }
745
746
747 template<::comparison::equality<ITEM> EQUALITY>
748 constexpr bool equals(const THIS_RAW_RANGE & rangeBlock, EQUALITY equality) const
749 {
750
751 return static_equals(*this, rangeBlock, equality);
752
753 }
754
755
756
757
758
759 // template<::comparison::equality<ITEM> EQUALITY>
760 // constexpr bool _equals_start(const THIS_RAW_RANGE &rangeBlock, memsize start, EQUALITY equality) const
761 // {
762 //
763 // return _static_equals(_start_range(start), rangeBlock, equality);
764 //
765 // }
766 //
767 //
768 // template<::comparison::equality<ITEM> EQUALITY>
769 // constexpr bool equals_start(const THIS_RAW_RANGE &rangeBlock, memsize start, EQUALITY equality) const
770 // {
771 //
772 // return static_equals(_start_range(start), rangeBlock, equality);
773 //
774 // }
775 //
776 //
777 // template<::comparison::equality<ITEM> EQUALITY>
778 // constexpr bool
779 // _equals_start_count(const THIS_RAW_RANGE &rangeBlock, memsize start, memsize count, EQUALITY equality) const
780 // {
781 //
782 // return _static_equals(_start_count_range(start, count), rangeBlock, equality);
783 //
784 // }
785 //
786 //
787 // template<::comparison::equality<ITEM> EQUALITY>
788 // constexpr bool
789 // equals_start_count(const THIS_RAW_RANGE &rangeBlock, memsize start, memsize count, EQUALITY equality) const
790 // {
791 //
792 // return static_equals(_start_count_range(start, count), rangeBlock, equality);
793 //
794 // }
795
796
797 //static constexpr bool
798 // _initialize_order(::std::strong_ordering & order, const THIS_RAW_RANGE & range, const THIS_RAW_RANGE & rangeBlock)
799 //{
800
801 // if (range.is_empty())
802 // {
803
804 // if (rangeBlock.is_empty())
805 // {
806
807 // order = ::std::strong_ordering::equal;
808
809 // return true;
810
811 // }
812 // else
813 // {
814
815 // order = ::std::strong_ordering::greater;
816
817 // return true;
818
819 // }
820
821 // }
822 // else if (rangeBlock.is_empty())
823 // {
824
825 // order = ::std::strong_ordering::less;
826
827 // return true;
828
829 // }
830
831 // return false;
832
833 //}
834
835
836 /*static constexpr bool
837 _initialize_partial_order(::std::partial_ordering& partialorder, const THIS_RAW_RANGE& range, const THIS_RAW_RANGE& rangeBlock)
838 {
839
840 if (range.is_empty())
841 {
842
843 if (rangeBlock.is_empty())
844 {
845
846 partialorder = ::std::partial_ordering::equivalent;
847
848 return true;
849
850 }
851 else
852 {
853
854 partialorder = ::std::partial_ordering::greater;
855
856 return true;
857
858 }
859
860 }
861 else if (rangeBlock.is_empty())
862 {
863
864 partialorder = ::std::partial_ordering::less;
865
866 return true;
867
868 }
869
870 return false;
871
872 }*/
873
874
875 template<::comparison::ordering<ITEM> ORDERING>
876 static constexpr auto _static_order(THIS_RAW_RANGE range, THIS_RAW_RANGE rangeBlock, ORDERING ordering)
877 {
878
879 using TORDERING = decltype(ordering.order(*range.begin(), *rangeBlock.begin()));
880
881 do
882 {
883
884 auto order = ordering.order(*range.begin(), *rangeBlock.begin());
885
886 if (order != 0)
887 {
888
889 return order;
890
891 }
892
893 range.begin()++;
894
895 rangeBlock.begin()++;
896
897 } while (!range.is_end(range.begin()) && !rangeBlock.is_end(rangeBlock.begin()));
898
899 return ::as< TORDERING, ::std::strong_ordering >(range.size() <=> rangeBlock.size());
900
901 }
902
903
904
905
906 template<::comparison::ordering<ITEM> ORDERING>
907 static constexpr auto
908 static_order(const THIS_RAW_RANGE & range, const THIS_RAW_RANGE & rangeBlock, ORDERING ordering)
909 {
910
911
912 return _static_order(range, rangeBlock, ordering);
913
914 }
915
916
917 //template<::comparison::partial_ordering<ITEM> PARTIAL_ORDERING>
918 //static constexpr ::std::partial_ordering
919 // static_partial_order(const THIS_RAW_RANGE& range, const THIS_RAW_RANGE& rangeBlock, PARTIAL_ORDERING partialordering)
920 //{
921
922 // std::partial_ordering order(::std::partial_ordering::less);
923
924 // if (_initialize_partial_order(order, range, rangeBlock))
925 // {
926
927 // return order;
928
929 // }
930
931 // return _static_partial_order(range, rangeBlock, partialordering);
932
933 //}
934
935
936 template<::comparison::ordering<ITEM> ORDERING>
937 constexpr auto _order(const THIS_RAW_RANGE & rangeBlock, ORDERING ordering) const
938 {
939
940 return _static_order(*this, rangeBlock, ordering);
941
942 }
943
944
945 template<::comparison::ordering<ITEM> ORDERING>
946 constexpr auto order(const THIS_RAW_RANGE & rangeBlock, ORDERING ordering) const
947 {
948
949 return static_order(*this, rangeBlock, ordering);
950
951 }
952
953 //template<::comparison::partial_ordering<ITEM> PARTIAL_ORDERING>
954 //constexpr ::std::partial_ordering partial_order(const THIS_RAW_RANGE& rangeBlock, PARTIAL_ORDERING partialordering) const
955 //{
956
957 // return static_partial_order(*this, rangeBlock, partialordering);
958
959 //}
960
961 // template<::comparison::ordering<ITEM> ORDERING>
962 // constexpr ::std::strong_ordering
963 // _order_start(const THIS_RAW_RANGE &rangeBlock, memsize start, ORDERING ordering) const
964 // {
965 //
966 // return _static_order(_start_range(start), rangeBlock, ordering);
967 //
968 // }
969 //
970 //
971 // template<::comparison::ordering<ITEM> ORDERING>
972 // constexpr ::std::strong_ordering
973 // order_start(const THIS_RAW_RANGE &rangeBlock, memsize start, ORDERING ordering) const
974 // {
975 //
976 // return static_order(_start_range(start), rangeBlock, ordering);
977 //
978 // }
979 //
980 //
981 // template<::comparison::ordering<ITEM> ORDERING>
982 // constexpr ::std::strong_ordering
983 // _order_start_count(const THIS_RAW_RANGE &rangeBlock, memsize start, memsize count, ORDERING ordering) const
984 // {
985 //
986 // return _static_order(_start_count_range(start, count), rangeBlock, ordering);
987 //
988 // }
989 //
990 //
991 // template<::comparison::ordering<ITEM> ORDERING>
992 // constexpr ::std::strong_ordering
993 // order_start_count(const THIS_RAW_RANGE &rangeBlock, memsize start, memsize count, ORDERING ordering) const
994 // {
995 //
996 // return static_order(_start_count_range(start, count), rangeBlock, ordering);
997 //
998 // }
999
1000
1001 static bool _initialize_find(const_iterator & p, const THIS_RAW_RANGE & range, const THIS_RAW_RANGE & rangeBlock)
1002 {
1003
1004 if (range.is_empty())
1005 {
1006
1007 p = nullptr;
1008
1009 return true;
1010
1011 }
1012
1013 return false;
1014
1015 }
1016
1017
1018 template<::comparison::equality<ITEM> EQUALITY>
1019 static const_iterator _static_find(THIS_RAW_RANGE range, const THIS_RAW_RANGE & rangeBlock, EQUALITY equality)
1020 {
1021
1022 auto pEnd = range.end() - rangeBlock.size();
1023
1024 do
1025 {
1026
1027 auto p = range.begin();
1028
1029 auto pBlock = rangeBlock.begin();
1030
1031 while (true)
1032 {
1033
1034 if (!equality.equals(*p, *pBlock))
1035 {
1036
1037 break;
1038
1039 }
1040
1041 pBlock++;
1042
1043 if (rangeBlock.is_end(pBlock))
1044 {
1045
1046 return range.begin();
1047
1048 }
1049
1050 p++;
1051
1052 }
1053
1054 range.begin()++;
1055
1056 } while (range.begin() <= pEnd);
1057
1058 return nullptr;
1059
1060 }
1061
1062
1063 template<::comparison::equality<ITEM> EQUALITY>
1064 static const_iterator static_find(const THIS_RAW_RANGE & range, const THIS_RAW_RANGE & rangeBlock, EQUALITY equality)
1065 {
1066
1067 const_iterator p;
1068
1069 if (_initialize_find(p, range, rangeBlock))
1070 {
1071
1072 return p;
1073
1074 }
1075
1076 return _static_find(range, rangeBlock, equality);
1077
1078 }
1079
1080
1081 template<::comparison::equality<ITEM> EQUALITY>
1082 constexpr const_iterator _find(const THIS_RAW_RANGE & rangeBlock, EQUALITY equality) const
1083 {
1084
1085 return _static_find(*this, rangeBlock, equality);
1086
1087 }
1088
1089
1090 template<::comparison::equality<ITEM> EQUALITY>
1091 constexpr const_iterator find(const THIS_RAW_RANGE & rangeBlock, EQUALITY equality) const
1092 {
1093
1094 return static_find(*this, rangeBlock, equality);
1095
1096 }
1097
1098
1099 // template<::comparison::equality<ITEM> EQUALITY>
1100 // constexpr const_iterator _find_start(const THIS_RAW_RANGE &rangeBlock, memsize start, EQUALITY equality) const
1101 // {
1102 //
1103 // return _static_find(_start_range(start), rangeBlock, equality);
1104 //
1105 // }
1106 //
1107 //
1108 // template<::comparison::equality<ITEM> EQUALITY>
1109 // constexpr const_iterator find_start(const THIS_RAW_RANGE &rangeBlock, memsize start, EQUALITY equality) const
1110 // {
1111 //
1112 // return static_find(_start_range(start), rangeBlock, equality);
1113 //
1114 // }
1115 //
1116 //
1117 // template<::comparison::equality<ITEM> EQUALITY>
1118 // constexpr const_iterator
1119 // _find_start_count(const THIS_RAW_RANGE &rangeBlock, memsize start, memsize count, EQUALITY equality) const
1120 // {
1121 //
1122 // return _static_find(_start_count_range(start, count), rangeBlock, equality);
1123 //
1124 // }
1125
1126
1127 static bool _initialize_rear_find(const_iterator & p, const THIS_RAW_RANGE & range, const THIS_RAW_RANGE & rangeBlock)
1128 {
1129
1130 if (rangeBlock.is_empty())
1131 {
1132
1133 p = range.end();
1134
1135 return true;
1136
1137 }
1138
1139 if (range.is_empty())
1140 {
1141
1142 p = nullptr;
1143
1144 return true;
1145
1146 }
1147
1148 return false;
1149
1150 }
1151
1152
1153 template<::comparison::equality<ITEM> EQUALITY>
1154 static const_iterator _static_rear_find(THIS_RAW_RANGE range, const THIS_RAW_RANGE & rangeBlock, EQUALITY equality)
1155 {
1156
1157 do
1158 {
1159
1160 auto p = range.end();
1161
1162 auto pBlock = rangeBlock.end() - 1;
1163
1164 while (true)
1165 {
1166
1167 if (!equality.equals(*p, *pBlock))
1168 {
1169
1170 break;
1171
1172 }
1173
1174 p--;
1175
1176 pBlock--;
1177
1178 if (rangeBlock.is_before_begin(pBlock))
1179 {
1180
1181 return p + 1;
1182
1183 }
1184
1185 }
1186
1187 range.end()--;
1188
1189 } while (!range.is_before_begin(range.end()));
1190
1191 return nullptr;
1192
1193 }
1194
1195
1196 template<::comparison::equality<ITEM> EQUALITY>
1197 static const_iterator
1198 static_rear_find(const THIS_RAW_RANGE & range, const THIS_RAW_RANGE & rangeBlock, EQUALITY equality)
1199 {
1200
1201 const_iterator p;
1202
1203 if (_initialize_rear_find(p, range, rangeBlock))
1204 {
1205
1206 return p;
1207
1208 }
1209
1210 return _static_rear_find(range, rangeBlock, equality);
1211
1212 }
1213
1214
1215 template<::comparison::equality<ITEM> EQUALITY>
1216 constexpr const_iterator _rear_find(const THIS_RAW_RANGE & rangeBlock, EQUALITY equality) const
1217 {
1218
1219 return _static_rear_find(*this, rangeBlock, equality);
1220
1221 }
1222
1223
1224 template<::comparison::equality<ITEM> EQUALITY>
1225 constexpr const_iterator rear_find(const THIS_RAW_RANGE & rangeBlock, EQUALITY equality) const
1226 {
1227
1228 return static_rear_find(*this, rangeBlock, equality);
1229
1230 }
1231
1232
1233 // template<::comparison::equality<ITEM> EQUALITY>
1234 // constexpr const_iterator _rear_find_start(const THIS_RAW_RANGE &rangeBlock, memsize start, EQUALITY equality) const
1235 // {
1236 //
1237 // return _static_rear_find(_start_range(start), rangeBlock, equality);
1238 //
1239 // }
1240 //
1241 //
1242 // template<::comparison::equality<ITEM> EQUALITY>
1243 // constexpr const_iterator rear_find_start(const THIS_RAW_RANGE &rangeBlock, memsize start, EQUALITY equality) const
1244 // {
1245 //
1246 // return static_rear_find(_start_range(start), rangeBlock, equality);
1247 //
1248 // }
1249 //
1250 //
1251 // template<::comparison::equality<ITEM> EQUALITY>
1252 // constexpr const_iterator
1253 // _rear_find_start_count(const THIS_RAW_RANGE &rangeBlock, memsize start, memsize count, EQUALITY equality) const
1254 // {
1255 //
1256 // return _static_rear_find(_start_count_range(start, count), rangeBlock, equality);
1257 //
1258 // }
1259 //
1260 //
1261 // template<::comparison::equality<ITEM> EQUALITY>
1262 // constexpr const_iterator
1263 // rear_find_start_count(const THIS_RAW_RANGE &rangeBlock, memsize start, memsize count, EQUALITY equality) const
1264 // {
1265 //
1266 // return static_rear_find(_start_count_range(start, count), rangeBlock, equality);
1267 //
1268 // }
1269 //
1270 //
1271 // template<::comparison::equality<ITEM> EQUALITY>
1272 // constexpr const_iterator
1273 // find_start_count(const THIS_RAW_RANGE &rangeBlock, memsize start, memsize count, EQUALITY equality) const
1274 // {
1275 //
1276 // return static_find(_start_count_range(start, count), rangeBlock, equality);
1277 //
1278 // }
1279
1280
1281
1282 // template<::comparison::equality<ITEM> EQUALITY>
1283 // constexpr const_iterator _skip_any_character_in_start(const THIS_RAW_RANGE &rangeBlock, memsize start, EQUALITY equality) const
1284 // {
1285 //
1286 // return _static_skip_any_character_in(_start_range(start), rangeBlock, equality);
1287 //
1288 // }
1289 //
1290 //
1291 // template<::comparison::equality<ITEM> EQUALITY>
1292 // constexpr const_iterator skip_any_character_in_start(const THIS_RAW_RANGE &rangeBlock, memsize start, EQUALITY equality) const
1293 // {
1294 //
1295 // return static_skip_any_character_in(_start_range(start), rangeBlock, equality);
1296 //
1297 // }
1298 //
1299 //
1300 // template<::comparison::equality<ITEM> EQUALITY>
1301 // constexpr const_iterator
1302 // _skip_any_character_in_start_count(const THIS_RAW_RANGE &rangeBlock, memsize start, memsize count, EQUALITY equality) const
1303 // {
1304 //
1305 // return _static_skip_any_character_in(_start_count_range(start, count), rangeBlock, equality);
1306 //
1307 // }
1308 //
1309 //
1310 // template<::comparison::equality<ITEM> EQUALITY>
1311 // constexpr const_iterator
1312 // skip_any_character_in_start_count(const THIS_RAW_RANGE &rangeBlock, memsize start, memsize count, EQUALITY equality) const
1313 // {
1314 //
1315 // return static_skip_any_character_in(_start_count_range(start, count), rangeBlock, equality);
1316 //
1317 // }
1318
1319
1320 template < typename ITEM2 >
1321 static constexpr bool
1322 _initialize_find_first_character(const_iterator & p, const THIS_RAW_RANGE & range, ITEM2 item) noexcept
1323 {
1324
1325 if (range.is_empty())
1326 {
1327
1328 p = nullptr;
1329
1330 return true;
1331
1332 }
1333
1334 if (item == 0)
1335 {
1336
1337 p = range.begin();
1338
1339 return true;
1340
1341 }
1342
1343 return false;
1344
1345 }
1346
1347
1348 template<::comparison::equality<ITEM> EQUALITY>
1349 static constexpr const_iterator
1350 _static_find_first_character(THIS_RAW_RANGE range, ITEM item, EQUALITY equality) noexcept
1351 {
1352
1353 do
1354 {
1355
1356 if (equality.equals(*range.begin(), item))
1357 {
1358
1359 // found a matching item...
1360 // stop find_first_character_inning and return address of the matching item
1361
1362 return range.begin();
1363
1364 }
1365
1366 // Didn't found matching item...
1367 // continue find_first_character...
1368
1369 range.begin()++;
1370
1371 } while (!range.is_end(range.begin()));
1372
1373 // reached end of the find_first_character_inning range...
1374 // and didn't find any matching items...
1375 // return address immediately after end of find_first_character_inning range....
1376
1377 return nullptr;
1378
1379 }
1380
1381 template<::comparison::equality<ITEM> EQUALITY>
1382 static constexpr const_iterator
1383 static_find_first_character(const THIS_RAW_RANGE & range, ITEM item, EQUALITY equality) noexcept
1384 {
1385
1386 const_iterator p;
1387
1388 if (_initialize_find_first_character(p, range, item))
1389 {
1390
1391 return p;
1392
1393 }
1394
1395 return _static_find_first_character(range, item, equality);
1396
1397 }
1398
1399
1400 template<::comparison::equality<ITEM> EQUALITY>
1401 constexpr const_iterator _find_first_character(ITEM item, EQUALITY equality) const
1402 {
1403
1404 return _static_find_first_character(*this, item, equality);
1405
1406 }
1407
1408
1409 template<::comparison::equality<ITEM> EQUALITY>
1410 constexpr const_iterator find_first_character(ITEM item, EQUALITY equality) const
1411 {
1412
1413 return static_find_first_character(*this, item, equality);
1414
1415 }
1416
1417
1418
1419 static constexpr bool
1420 _initialize_find_first_character_in(const_iterator & p, const THIS_RAW_RANGE & range, const THIS_RAW_RANGE & rangeBlock) noexcept
1421 {
1422
1423 if (range.is_empty())
1424 {
1425
1426 p = nullptr;
1427
1428 return true;
1429
1430 }
1431
1432 if (rangeBlock.is_empty())
1433 {
1434
1435 p = range.begin();
1436
1437 return true;
1438
1439 }
1440
1441 return false;
1442
1443 }
1444
1445
1446 template<::comparison::equality<ITEM> EQUALITY>
1447 static constexpr const_iterator
1448 _static_find_first_character_in(THIS_RAW_RANGE range, const THIS_RAW_RANGE & rangeBlock, EQUALITY equality) noexcept
1449 {
1450
1451 do
1452 {
1453
1454 auto pBlockScan = rangeBlock.begin();
1455
1456 do
1457 {
1458
1459 if (equality.equals(*range.begin(), *pBlockScan))
1460 {
1461
1462 // found a matching item...
1463 // stop find_first_character_inning and return address of the matching item
1464
1465 return range.begin();
1466
1467 }
1468
1469 pBlockScan++;
1470
1471 } while (!rangeBlock.is_end(pBlockScan));
1472
1473 // Didn't found matching item...
1474 // continue find_first_character_inning...
1475
1476 range.begin()++;
1477
1478 } while (!range.is_end(range.begin()));
1479
1480 // reached end of the find_first_character_inning range...
1481 // and didn't find any matching items...
1482 // return address immediately after end of find_first_character_inning range....
1483
1484 return nullptr;
1485
1486 }
1487
1488 template<::comparison::equality<ITEM> EQUALITY>
1489 static constexpr const_iterator
1490 static_find_first_character_in(const THIS_RAW_RANGE & range, const THIS_RAW_RANGE & rangeBlock, EQUALITY equality) noexcept
1491 {
1492
1493 const_iterator p;
1494
1495 if (_initialize_find_first_character_in(p, range, rangeBlock))
1496 {
1497
1498 return p;
1499
1500 }
1501
1502 return _static_find_first_character_in(range, rangeBlock, equality);
1503
1504 }
1505
1506
1507 template<::comparison::equality<ITEM> EQUALITY>
1508 constexpr const_iterator _find_first_character_in(const THIS_RAW_RANGE & rangeBlock, EQUALITY equality) const
1509 {
1510
1511 return _static_find_first_character_in(*this, rangeBlock, equality);
1512
1513 }
1514
1515
1516 template<::comparison::equality<ITEM> EQUALITY>
1517 constexpr const_iterator find_first_character_in(const THIS_RAW_RANGE & rangeBlock, EQUALITY equality) const
1518 {
1519
1520 return static_find_first_character_in(*this, rangeBlock, equality);
1521
1522 }
1523
1524
1525 // template<::comparison::equality<ITEM> EQUALITY>
1526 // constexpr const_iterator _find_first_character_in_start(const THIS_RAW_RANGE &rangeBlock, memsize start, EQUALITY equality) const
1527 // {
1528 //
1529 // return _static_find_first_character_in(_start_range(start), rangeBlock, equality);
1530 //
1531 // }
1532 //
1533 //
1534 // template<::comparison::equality<ITEM> EQUALITY>
1535 // constexpr const_iterator find_first_character_in_start(const THIS_RAW_RANGE &rangeBlock, memsize start, EQUALITY equality) const
1536 // {
1537 //
1538 // return static_find_first_character_in(_start_range(start), rangeBlock, equality);
1539 //
1540 // }
1541 //
1542 //
1543 // template<::comparison::equality<ITEM> EQUALITY>
1544 // constexpr const_iterator
1545 // _find_first_character_in_start_count(const THIS_RAW_RANGE &rangeBlock, memsize start, memsize count, EQUALITY equality) const
1546 // {
1547 //
1548 // return _static_find_first_character_in(_start_count_range(start, count), rangeBlock, equality);
1549 //
1550 // }
1551 //
1552 //
1553 // template<::comparison::equality<ITEM> EQUALITY>
1554 // constexpr const_iterator
1555 // find_first_character_in_start_count(const THIS_RAW_RANGE &rangeBlock, memsize start, memsize count, EQUALITY equality) const
1556 // {
1557 //
1558 // return static_find_first_character_in(_start_count_range(start, count), rangeBlock, equality);
1559 //
1560 // }
1561
1562
1563 static constexpr bool
1564 _initialize_rear_find_first_character_in(const_iterator & p, const THIS_RAW_RANGE & range, const THIS_RAW_RANGE & rangeBlock) noexcept
1565 {
1566
1567 if (range.is_empty())
1568 {
1569
1570 p = nullptr;
1571
1572 return true;
1573
1574 }
1575
1576 if (rangeBlock.is_empty())
1577 {
1578
1579 p = range.end();
1580
1581 return true;
1582
1583 }
1584
1585 return false;
1586
1587 }
1588
1589
1590 template<::comparison::equality<ITEM> EQUALITY>
1591 static constexpr const_iterator
1592 _static_rear_find_first_character_in(THIS_RAW_RANGE range, const THIS_RAW_RANGE & rangeBlock, EQUALITY equality) noexcept
1593 {
1594
1595 do
1596 {
1597
1598 auto pBlockScan = rangeBlock.begin();
1599
1600 do
1601 {
1602
1603 if (equality.equals(*range.end(), *pBlockScan))
1604 {
1605
1606 // found a matching item...
1607 // stop find_first_character_inning and return address of the matching item
1608
1609 return range.end();
1610
1611 }
1612
1613 pBlockScan++;
1614
1615 } while (!rangeBlock.is_end(pBlockScan));
1616
1617 range.end()--;
1618
1619 } while (!range.is_before_begin(range.end()));
1620
1621 return nullptr;
1622
1623 }
1624
1625
1626 template<::comparison::equality<ITEM> EQUALITY>
1627 static constexpr const_iterator
1628 static_rear_find_first_character_in(THIS_RAW_RANGE range, const THIS_RAW_RANGE & rangeBlock, EQUALITY equality) noexcept
1629 {
1630
1631 const_iterator p;
1632
1633 if (_initialize_rear_find_first_character_in(p, range, rangeBlock))
1634 {
1635
1636 return p;
1637
1638 }
1639
1640 range.end()--;
1641
1642 return _static_rear_find_first_character_in(range, rangeBlock, equality);
1643
1644 }
1645
1646
1647 template<::comparison::equality<ITEM> EQUALITY>
1648 constexpr const_iterator _rear_find_first_character_in(const THIS_RAW_RANGE & rangeBlock, EQUALITY equality) const
1649 {
1650
1651 return _static_rear_find_first_character_in(*this, rangeBlock, equality);
1652
1653 }
1654
1655
1656 template<::comparison::equality<ITEM> EQUALITY>
1657 constexpr const_iterator rear_find_first_character_in(const THIS_RAW_RANGE & rangeBlock, EQUALITY equality) const
1658 {
1659
1660 return static_rear_find_first_character_in(*this, rangeBlock, equality);
1661
1662 }
1663
1664
1665 // template<::comparison::equality<ITEM> EQUALITY>
1666 // constexpr const_iterator _rear_find_first_character_in_start(const THIS_RAW_RANGE & rangeBlock, memsize start, EQUALITY equality) const
1667 // {
1668 //
1669 // return _static_rear_find_first_character_in(_start_range(start), rangeBlock, equality);
1670 //
1671 // }
1672 //
1673 //
1674 // template<::comparison::equality<ITEM> EQUALITY>
1675 // constexpr const_iterator rear_find_first_character_in_start(const THIS_RAW_RANGE & rangeBlock, memsize start, EQUALITY equality) const
1676 // {
1677 //
1678 // return static_rear_find_first_character_in(_start_range(start), rangeBlock, equality);
1679 //
1680 // }
1681 //
1682 //
1683 // template<::comparison::equality<ITEM> EQUALITY>
1684 // constexpr const_iterator
1685 // _rear_find_first_character_in_start_count(const THIS_RAW_RANGE & rangeBlock, memsize start, memsize count, EQUALITY equality) const
1686 // {
1687 //
1688 // return _static_rear_find_first_character_in(_start_count_range(start, count), rangeBlock, equality);
1689 //
1690 // }
1691 //
1692 //
1693 // template<::comparison::equality<ITEM> EQUALITY>
1694 // constexpr const_iterator
1695 // rear_find_first_character_in_start_count(const THIS_RAW_RANGE & rangeBlock, memsize start, memsize count, EQUALITY equality) const
1696 // {
1697 //
1698 // return static_rear_find_first_character_in(_start_count_range(start, count), rangeBlock, equality);
1699 //
1700 // }
1701
1702
1703 static constexpr bool _initialize_skip(const_iterator & p, const THIS_RAW_RANGE & range) noexcept
1704 {
1705
1706 if (range.is_empty())
1707 {
1708
1709 p = range.end();
1710
1711 return true;
1712
1713 }
1714
1715 return false;
1716
1717 }
1718
1719
1720 template<::comparison::equality<ITEM> EQUALITY>
1721 static constexpr const_iterator _static_skip(THIS_RAW_RANGE range, ARG_ITEM item, EQUALITY equality) noexcept
1722 {
1723
1724 do
1725 {
1726
1727 if (!equality.equals(*range.begin(), item))
1728 {
1729
1730 return range.begin();
1731
1732 }
1733
1734 range.begin()++;
1735
1736 } while (!range.is_end(range.begin()));
1737
1738 return range.begin();
1739
1740 }
1741
1742
1743 template<::comparison::equality<ITEM> EQUALITY>
1744 static constexpr const_iterator
1745 static_skip(const THIS_RAW_RANGE & range, ARG_ITEM item, EQUALITY equality) noexcept
1746 {
1747
1748 const_iterator p;
1749
1750 if (_initialize_skip(p, range))
1751 {
1752
1753 return p;
1754
1755 }
1756
1757 return _static_skip(range, item, equality);
1758
1759 }
1760
1761
1762 template<::comparison::equality<ITEM> EQUALITY>
1763 constexpr const_iterator _skip(ARG_ITEM item, EQUALITY equality) const
1764 {
1765
1766 return _static_skip(*this, item, equality);
1767
1768 }
1769
1770
1771 template<::comparison::equality<ITEM> EQUALITY>
1772 constexpr const_iterator skip(ARG_ITEM item, EQUALITY equality) const
1773 {
1774
1775 return static_skip(*this, item, equality);
1776
1777 }
1778
1779
1780 static constexpr bool _initialize_rear_skip(const_iterator & p, const THIS_RAW_RANGE & range) noexcept
1781 {
1782
1783 if (range.is_empty())
1784 {
1785
1786 p = nullptr;
1787
1788 return true;
1789
1790 }
1791
1792 return false;
1793
1794 }
1795
1796
1797 template<::comparison::equality<ITEM> EQUALITY>
1798 static constexpr const_iterator _static_rear_skip(THIS_RAW_RANGE range, ARG_ITEM item, EQUALITY equality) noexcept
1799 {
1800
1801 while (true)
1802 {
1803
1804 range.end()--;
1805
1806 if (range.is_before_begin(range.end()))
1807 {
1808
1809 return nullptr;
1810
1811 }
1812
1813 if (!equality.equals(*range.end(), item))
1814 {
1815
1816 return range.begin();
1817
1818 }
1819
1820 }
1821
1822 return nullptr;
1823
1824 }
1825
1826
1827 template<::comparison::equality<ITEM> EQUALITY>
1828 static constexpr const_iterator
1829 static_rear_skip(const THIS_RAW_RANGE & range, ARG_ITEM item, EQUALITY equality) noexcept
1830 {
1831
1832 const_iterator p;
1833
1834 if (_initialize_rear_skip(p, range))
1835 {
1836
1837 return p;
1838
1839 }
1840
1841 return _static_rear_skip(range, item, equality);
1842
1843 }
1844
1845
1846 template<::comparison::equality<ITEM> EQUALITY>
1847 constexpr const_iterator _rear_skip(ARG_ITEM item, EQUALITY equality) const
1848 {
1849
1850 return _static_rear_skip(*this, item, equality);
1851
1852 }
1853
1854
1855 template<::comparison::equality<ITEM> EQUALITY>
1856 constexpr const_iterator rear_skip(ARG_ITEM item, EQUALITY equality) const
1857 {
1858
1859 return static_rear_skip(*this, item, equality);
1860
1861 }
1862
1863
1864 // template<::comparison::equality<ITEM> EQUALITY>
1865 // constexpr const_iterator _skip_start(ARG_ITEM item, memsize start, EQUALITY equality) const
1866 // {
1867 //
1868 // return _static_skip(_start_range(start), item, equality);
1869 //
1870 // }
1871 //
1872 //
1873 // template<::comparison::equality<ITEM> EQUALITY>
1874 // constexpr const_iterator skip_start(ARG_ITEM item, memsize start, EQUALITY equality) const
1875 // {
1876 //
1877 // return static_skip(_start_range(start), item, equality);
1878 //
1879 // }
1880 //
1881 //
1882 // template<::comparison::equality<ITEM> EQUALITY>
1883 // constexpr const_iterator _skip_start_count(ARG_ITEM item, memsize start, memsize count, EQUALITY equality) const
1884 // {
1885 //
1886 // return _static_skip(_start_count_range(start, count), item, equality);
1887 //
1888 // }
1889 //
1890 //
1891 // template<::comparison::equality<ITEM> EQUALITY>
1892 // constexpr const_iterator skip_start_count(ARG_ITEM item, memsize start, memsize count, EQUALITY equality) const
1893 // {
1894 //
1895 // return static_skip(_start_count_range(start, count), item, equality);
1896 //
1897 // }
1898
1899
1900 static constexpr bool _initialize_find_item(const_iterator & p, const THIS_RAW_RANGE & range) noexcept
1901 {
1902
1903 if (range.is_empty())
1904 {
1905
1906 p = nullptr;
1907
1908 return true;
1909
1910 }
1911
1912 return false;
1913
1914 }
1915
1916
1917 // template<::comparison::equality<ITEM> EQUALITY>
1918 //static constexpr const_iterator
1919 //static_skip(const THIS_RAW_RANGE &range, ARG_ITEM item, EQUALITY equality) noexcept
1920 //{
1921
1922 // const_iterator p;
1923
1924 // if (_initialize_skip(p, range))
1925 // {
1926
1927 // return p;
1928
1929 // }
1930
1931 // return _static_skip(range, item, equality);
1932
1933 //}
1934
1935
1936 //template<::comparison::equality<ITEM> EQUALITY>
1937 //constexpr const_iterator _skip(ARG_ITEM item, EQUALITY equality) const
1938 //{
1939
1940 // return _static_skip(*this, item, equality);
1941
1942 //}
1943
1944
1945 //template<::comparison::equality<ITEM> EQUALITY>
1946 //constexpr const_iterator skip(ARG_ITEM item, EQUALITY equality) const
1947 //{
1948
1949 // return static_skip(*this, item, equality);
1950
1951 //}
1952
1953
1954 static constexpr bool _initialize_rear_find(const_iterator & p, const THIS_RAW_RANGE & range) noexcept
1955 {
1956
1957 if (range.is_empty())
1958 {
1959
1960 p = nullptr;
1961
1962 return true;
1963
1964 }
1965
1966 return false;
1967
1968 }
1969
1970
1971 template<::comparison::equality<ITEM> EQUALITY>
1972 static constexpr const_iterator
1973 _static_rear_find(THIS_RAW_RANGE range, ARG_ITEM item, EQUALITY equality) noexcept
1974 {
1975
1976 while (true)
1977 {
1978
1979 range.end()--;
1980
1981 if (range.is_before_begin(range.end()))
1982 {
1983
1984 return nullptr;
1985
1986 }
1987
1988 if (equality.equals(*range.end(), item))
1989 {
1990
1991 return range.end();
1992
1993 }
1994
1995 }
1996
1997 return nullptr;
1998
1999 }
2000
2001
2002
2003 template<::comparison::equality<ITEM> EQUALITY>
2004 static constexpr const_iterator
2005 static_rear_find(THIS_RAW_RANGE range, ARG_ITEM item, EQUALITY equality) noexcept
2006 {
2007
2008 const_iterator p;
2009
2010 if (_initialize_find_item(p, range))
2011 {
2012
2013 return p;
2014
2015 }
2016
2017 range.end()--;
2018
2019 return _static_rear_find(range, item, equality);
2020
2021 }
2022
2023
2024 template<::comparison::equality<ITEM> EQUALITY>
2025 constexpr const_iterator _rear_find(ARG_ITEM item, EQUALITY equality) const
2026 {
2027
2028 return _static_rear_find(*this, item, equality);
2029
2030 }
2031
2032
2033 template<::comparison::equality<ITEM> EQUALITY>
2034 constexpr const_iterator rear_find(ARG_ITEM item, EQUALITY equality) const
2035 {
2036
2037 return static_rear_find(*this, item, equality);
2038
2039 }
2040
2041
2042 // template<::comparison::equality<ITEM> EQUALITY>
2043 //static constexpr const_iterator
2044 //static_skip(const THIS_RAW_RANGE &range, ARG_ITEM item, EQUALITY equality) noexcept
2045 //{
2046
2047 // const_iterator p;
2048
2049 // if (_initialize_skip(p, range))
2050 // {
2051
2052 // return p;
2053
2054 // }
2055
2056 // return _static_skip(range, item, equality);
2057
2058 //}
2059
2060
2061 //template<::comparison::equality<ITEM> EQUALITY>
2062 //constexpr const_iterator _skip(ARG_ITEM item, EQUALITY equality) const
2063 //{
2064
2065 // return _static_skip(*this, item, equality);
2066
2067 //}
2068
2069
2070 //template<::comparison::equality<ITEM> EQUALITY>
2071 //constexpr const_iterator skip(ARG_ITEM item, EQUALITY equality) const
2072 //{
2073
2074 // return static_skip(*this, item, equality);
2075
2076 //}
2077
2078// template<::comparison::equality<ITEM> EQUALITY>
2079// constexpr const_iterator _rear_find_item_start(ARG_ITEM item, memsize start, EQUALITY equality) const
2080// {
2081//
2082// return _static_rear_find_item(_start_range(start), item, equality);
2083//
2084// }
2085//
2086//
2087// template<::comparison::equality<ITEM> EQUALITY>
2088// constexpr const_iterator rear_find_item_start(ARG_ITEM item, memsize start, EQUALITY equality) const
2089// {
2090//
2091// return static_rear_find_item(_start_range(start), item, equality);
2092//
2093// }
2094//
2095//
2096// template<::comparison::equality<ITEM> EQUALITY>
2097// constexpr const_iterator
2098// _rear_find_item_start_count(ARG_ITEM item, memsize start, memsize count, EQUALITY equality) const
2099// {
2100//
2101// return _static_rear_find_item(_start_count_range(start, count), item, equality);
2102//
2103// }
2104//
2105//
2106// template<::comparison::equality<ITEM> EQUALITY>
2107// constexpr const_iterator
2108// rear_find_item_start_count(ARG_ITEM item, memsize start, memsize count, EQUALITY equality) const
2109// {
2110//
2111// return static_rear_find_item(_start_count_range(start, count), item, equality);
2112//
2113// }
2114
2115
2116
2117 // template<::comparison::equality<ITEM> EQUALITY>
2118 // constexpr const_iterator _rear_skip_any_character_in_start(const THIS_RAW_RANGE &rangeBlock, const_iterator end, EQUALITY equality) const
2119 // {
2120 //
2121 // return _static_rear_skip_any_character_in(_end_range(end), rangeBlock, equality);
2122 //
2123 // }
2124 //
2125 //
2126 // template<::comparison::equality<ITEM> EQUALITY>
2127 // constexpr const_iterator rear_skip_any_character_in_start(const THIS_RAW_RANGE &rangeBlock, memsize start, EQUALITY equality) const
2128 // {
2129 //
2130 // return static_rear_skip_any_character_in(_start_range(start), rangeBlock, equality);
2131 //
2132 // }
2133 //
2134 //
2135 // template<::comparison::equality<ITEM> EQUALITY>
2136 // constexpr const_iterator
2137 // _rear_skip_any_character_in_start_count(const THIS_RAW_RANGE &rangeBlock, memsize start, memsize count, EQUALITY equality) const
2138 // {
2139 //
2140 // return _static_rear_skip_any_character_in(_start_count_range(start, count), rangeBlock, equality);
2141 //
2142 // }
2143 //
2144 //
2145 // template<::comparison::equality<ITEM> EQUALITY>
2146 // constexpr const_iterator
2147 // rear_skip_any_character_in_start_count(const THIS_RAW_RANGE &rangeBlock, memsize start, memsize count, EQUALITY equality) const
2148 // {
2149 //
2150 // return static_rear_skip_any_character_in(_start_count_range(start, count), rangeBlock, equality);
2151 //
2152 // }
2153
2154
2155 static constexpr bool
2156 _initialize_contains(bool & b, const THIS_RAW_RANGE & range, const THIS_RAW_RANGE & rangeBlock) noexcept
2157 {
2158
2159 if (rangeBlock.is_empty())
2160 {
2161
2162 b = true;
2163
2164 return true;
2165
2166 }
2167
2168 if (range.is_empty())
2169 {
2170
2171 b = false;
2172
2173 return true;
2174
2175 }
2176
2177 return false;
2178
2179 }
2180
2181
2182 template<::comparison::equality<ITEM> EQUALITY>
2183 static constexpr bool _static_begins(THIS_RAW_RANGE range, THIS_RAW_RANGE rangeBlock, EQUALITY equality) noexcept
2184 {
2185
2186 do
2187 {
2188
2189 if (!equality.equals(*range.begin(), *rangeBlock.begin()))
2190 {
2191
2192 return false;
2193
2194 }
2195
2196 range.begin()++;
2197
2198 rangeBlock.begin()++;
2199
2200 } while (!range.is_end(range.begin()) && !rangeBlock.is_end(rangeBlock.begin()));
2201
2202 return rangeBlock.is_end(rangeBlock.begin());
2203
2204 }
2205
2206
2207 template<::comparison::equality<ITEM> EQUALITY>
2208 static constexpr bool
2209 static_begins(const THIS_RAW_RANGE & range, const THIS_RAW_RANGE & rangeBlock, EQUALITY equality) noexcept
2210 {
2211
2212 bool b;
2213
2214 if (_initialize_contains(b, range, rangeBlock))
2215 {
2216
2217 return b;
2218
2219 }
2220
2221 return _static_begins(range, rangeBlock, equality);
2222
2223 }
2224
2225
2226 template<::comparison::equality<ITEM> EQUALITY>
2227 constexpr bool _begins(const THIS_RAW_RANGE & rangeBlock, EQUALITY equality) const
2228 {
2229
2230 return _static_begins(*this, rangeBlock, equality);
2231
2232 }
2233
2234
2235 template<::comparison::equality<ITEM> EQUALITY>
2236 constexpr bool begins(const THIS_RAW_RANGE & rangeBlock, EQUALITY equality) const
2237 {
2238
2239 return static_begins(*this, rangeBlock, equality);
2240
2241 }
2242
2243
2244 // template<::comparison::equality<ITEM> EQUALITY>
2245 // constexpr bool _begins_start(const THIS_RAW_RANGE &rangeBlock, memsize start, EQUALITY equality) const
2246 // {
2247 //
2248 // return _static_begins(_start_range(start), rangeBlock, equality);
2249 //
2250 // }
2251 //
2252 //
2253 // template<::comparison::equality<ITEM> EQUALITY>
2254 // constexpr bool begins_start(const THIS_RAW_RANGE &rangeBlock, memsize start, EQUALITY equality) const
2255 // {
2256 //
2257 // return static_begins(_start_range(start), rangeBlock, equality);
2258 //
2259 // }
2260 //
2261 //
2262 // template<::comparison::equality<ITEM> EQUALITY>
2263 // constexpr bool
2264 // _begins_start_count(const THIS_RAW_RANGE &rangeBlock, memsize start, memsize count, EQUALITY equality) const
2265 // {
2266 //
2267 // return _static_begins(_start_count_range(start, count), rangeBlock, equality);
2268 //
2269 // }
2270 //
2271 //
2272 // template<::comparison::equality<ITEM> EQUALITY>
2273 // constexpr bool
2274 // begins_start_count(const THIS_RAW_RANGE &rangeBlock, memsize start, memsize count, EQUALITY equality) const
2275 // {
2276 //
2277 // return static_begins(_start_count_range(start, count), rangeBlock, equality);
2278 //
2279 // }
2280
2281
2282 template<::comparison::equality<ITEM> EQUALITY>
2283 static constexpr bool _static_ends(THIS_RAW_RANGE range, THIS_RAW_RANGE rangeBlock, EQUALITY equality) noexcept
2284 {
2285
2286 range.end()--;
2287
2288 rangeBlock.end()--;
2289
2290 do
2291 {
2292
2293 if (!equality.equals(*range.end(), *rangeBlock.end()))
2294 {
2295
2296 return false;
2297
2298 }
2299
2300 range.end()--;
2301
2302 rangeBlock.end()--;
2303
2304 if (rangeBlock.is_before_begin(rangeBlock.end()))
2305 {
2306
2307 return true;
2308
2309 }
2310
2311 } while (!range.is_before_begin(range.end()));
2312
2313 return false;
2314
2315 }
2316
2317
2318 template<::comparison::equality<ITEM> EQUALITY>
2319 static constexpr bool
2320 static_ends(const THIS_RAW_RANGE & range, const THIS_RAW_RANGE & rangeBlock, EQUALITY equality) noexcept
2321 {
2322
2323 bool b;
2324
2325 if (_initialize_contains(b, range, rangeBlock))
2326 {
2327
2328 return b;
2329
2330 }
2331
2332 return _static_ends(range, rangeBlock, equality);
2333
2334 }
2335
2336
2337 template<::comparison::equality<ITEM> EQUALITY>
2338 constexpr bool _ends(const THIS_RAW_RANGE & rangeBlock, EQUALITY equality) const
2339 {
2340
2341 return _static_ends(*this, rangeBlock, equality);
2342
2343 }
2344
2345
2346 template<::comparison::equality<ITEM> EQUALITY>
2347 constexpr bool ends(const THIS_RAW_RANGE & rangeBlock, EQUALITY equality) const
2348 {
2349
2350 return static_ends(*this, rangeBlock, equality);
2351
2352 }
2353
2354
2355 // template<::comparison::equality<ITEM> EQUALITY>
2356 // constexpr bool _ends_start(const THIS_RAW_RANGE &rangeBlock, memsize start, EQUALITY equality) const
2357 // {
2358 //
2359 // return _static_ends(_start_range(start), rangeBlock, equality);
2360 //
2361 // }
2362 //
2363 //
2364 // template<::comparison::equality<ITEM> EQUALITY>
2365 // constexpr bool ends_start(const THIS_RAW_RANGE &rangeBlock, memsize start, EQUALITY equality) const
2366 // {
2367 //
2368 // return static_ends(_start_range(start), rangeBlock, equality);
2369 //
2370 // }
2371 //
2372 //
2373 // template<::comparison::equality<ITEM> EQUALITY>
2374 // constexpr bool
2375 // _ends_start_count(const THIS_RAW_RANGE &rangeBlock, memsize start, memsize count, EQUALITY equality) const
2376 // {
2377 //
2378 // return _static_ends(_start_count_range(start, count), rangeBlock, equality);
2379 //
2380 // }
2381 //
2382 //
2383 // template<::comparison::equality<ITEM> EQUALITY>
2384 // constexpr bool
2385 // ends_start_count(const THIS_RAW_RANGE &rangeBlock, memsize start, memsize count, EQUALITY equality) const
2386 // {
2387 //
2388 // return static_ends(_start_count_range(start, count), rangeBlock, equality);
2389 //
2390 // }
2391
2392
2393
2394 //constexpr bool _equals_prefix(bool & b, const THIS_RAW_RANGE & range) const
2395 //{
2396
2397 // return BASE_ARRAY::_equals_prefix(b, range);
2398
2399 //}
2400
2401
2402 //using BASE_ARRAY::_equals_prefix;
2403
2404 //template < ::comparison::equality < ITEM > EQUALITY >
2405 //constexpr auto _equals(const THIS_RAW_RANGE & range, EQUALITY equality) const
2406 //{
2407
2408 // return BASE_ARRAY::_equals(range, equality);
2409
2410 //}
2411
2412 //constexpr bool _equals(const THIS_RAW_RANGE & range) const
2413 //{
2414
2415 // return this->_equals(range, ::equals_const_reference < ITEM >);
2416
2417 //}
2418
2419
2420 //template < ::comparison::equality < ITEM > EQUALITY >
2421 //constexpr bool equals(const THIS_RAW_RANGE & range, EQUALITY equality) const
2422 //{
2423
2424 // return BASE_ARRAY::equals(range, equality);
2425
2426 //}
2427
2428 //constexpr bool _initialize_order(::std::strong_ordering & ordering, const THIS_RAW_RANGE & range) const
2429 //{
2430
2431 // return BASE_ARRAY::_initialize_order(range, equality);
2432
2433 //}
2434
2435
2436 //template < typename COMPARE >
2437 //constexpr auto _order(const THIS_RAW_RANGE & range, COMPARE compare) const
2438 //{
2439
2440 // return BASE_ARRAY::_order(range, equality);
2441
2442 //}
2443
2444 //template < typename COMPARE >
2445 //constexpr ::std::strong_ordering compare(const THIS_RAW_RANGE & range, COMPARE compare) const
2446 //{
2447
2448 // return BASE_ARRAY::compare(range, compare);
2449
2450 //}
2451
2452
2453 //constexpr ::std::strong_ordering operator<=>(const THIS_RAW_RANGE & range) const
2454 //{
2455
2456 // return compare(range, ::compare_const_reference < ITEM >);
2457
2458 //}
2459
2460
2461 //static bool _find_prefix(const_iterator & p, const ::scoped_string & scopedstr, const ::scoped_string & scopedstrScope)
2462 //{
2463
2464 // return BASE_ARRAY::_equals(range, equality);
2465
2466 //}
2467
2468
2469 //template < ::comparison::equality < ITEM > EQUALITY >
2470 //static this_iterator _find(RANGE search)
2471 //{
2472
2473 // return BASE_ARRAY::_find(search, equality);
2474
2475 //}
2476
2477
2478 //template < ::comparison::equality < ITEM > EQUALITY >
2479 //const_iterator find(const ::scoped_string & scopedstr, EQUALITY equality) const
2480 //{
2481
2482 // return BASE_ARRAY::find(range, equality);
2483
2484 //}
2485
2486
2487 //constexpr bool _skip_any_character_in_prefix(this_iterator & p, const THIS_RAW_RANGE & range) const noexcept
2488 //{
2489
2490 // return BASE_ARRAY::_skip_any_character_in_prefix(range, equality);
2491
2492 //}
2493
2494
2495 //template < ::comparison::equality < ITEM > EQUALITY >
2496 //constexpr this_iterator _skip_any_character_in(const THIS_RAW_RANGE & range, EQUALITY equality) noexcept
2497 //{
2498
2499 // return BASE_ARRAY::_skip_any_character_in(range, equality);
2500
2501 //}
2502
2503
2504 //constexpr this_iterator _skip_any_character_in(const THIS_RAW_RANGE & range) noexcept
2505 //{
2506
2507 // return _skip_any_character_in(range, ::equals_const_reference < ITEM >);
2508
2509 //}
2510
2511
2512 //template < ::comparison::equality < ITEM > EQUALITY >
2513 //constexpr this_iterator skip_any_character_in(const THIS_RAW_RANGE & range, EQUALITY equality) noexcept
2514 //{
2515
2516 // return BASE_ARRAY::skip_any_character_in(range, equality);
2517
2518 //}
2519
2520
2521 //constexpr this_iterator skip_any_character_in(const THIS_RAW_RANGE & range) noexcept
2522 //{
2523
2524 // return skip_any_character_in(range, ::equals_const_reference < ITEM >);
2525
2526 //}
2527
2528
2529 //constexpr bool _find_first_character_in_prefix(this_iterator & p, const THIS_RAW_RANGE & range) noexcept
2530 //{
2531
2532 // return BASE_ARRAY::_find_first_character_in_prefix(range, equality);
2533
2534 //}
2535
2536
2537 //template < ::comparison::equality < ITEM > EQUALITY >
2538 //constexpr this_iterator _find_first_character_in(const THIS_RAW_RANGE & range, EQUALITY equality) noexcept
2539 //{
2540
2541 // return BASE_ARRAY::_find_first_character_in(range, equality);
2542
2543 //}
2544
2545
2546 //constexpr this_iterator _find_first_character_in(const THIS_RAW_RANGE & range) noexcept
2547 //{
2548
2549 // return _find_first_character_in(range, ::equals_const_reference < ITEM >);
2550
2551 //}
2552
2553
2554 //template < ::comparison::equality < ITEM > EQUALITY >
2555 //constexpr this_iterator find_first_character_in(const THIS_RAW_RANGE & range, EQUALITY equality) noexcept
2556 //{
2557
2558 // return BASE_ARRAY::find_first_character_in(range, equality);
2559
2560 //}
2561
2562
2563 //constexpr this_iterator find_first_character_in(const THIS_RAW_RANGE & range) noexcept
2564 //{
2565
2566 // return find_first_character_in(range, ::equals_const_reference < ITEM >);
2567
2568 //}
2569
2570
2571 //template < ::comparison::equality < ITEM > EQUALITY >
2572 //constexpr this_iterator _skip(ARG_ITEM item, EQUALITY equality) noexcept
2573 //{
2574
2575 // return BASE_ARRAY::_skip(range, equality);
2576
2577 //}
2578
2579
2580 //constexpr this_iterator _skip(ARG_ITEM item) noexcept
2581 //{
2582
2583 // return _skip(item, ::equals_const_reference < ITEM >);
2584
2585 //}
2586
2587
2588 //template < ::comparison::equality < ITEM > EQUALITY >
2589 //constexpr this_iterator skip(ARG_ITEM item, EQUALITY equality) noexcept
2590 //{
2591
2592 // return BASE_ARRAY::skip(item, equality);
2593
2594 //}
2595
2596
2597 //constexpr this_iterator skip(ARG_ITEM item) noexcept
2598 //{
2599
2600 // return skip(item, ::equals_const_reference < ITEM >);
2601
2602 //}
2603
2604
2605 //template < ::comparison::equality < ITEM > EQUALITY >
2606 //constexpr this_iterator _rear_find_item(ITEM item, EQUALITY equality) noexcept
2607 //{
2608
2609 // return BASE_ARRAY::_rear_find_item(item, equality);
2610
2611 //}
2612
2613
2614 //constexpr this_iterator _rear_find_item(ITEM item) noexcept
2615 //{
2616
2617 // return _rear_find_item(item, ::equals_const_reference < ITEM >);
2618
2619 //}
2620
2621
2622 //template < ::comparison::equality < ITEM > EQUALITY >
2623 //constexpr this_iterator rear_find_item(ITEM item, EQUALITY equality) noexcept
2624 //{
2625
2626 // return BASE_ARRAY::rear_find_item(item, equality);
2627
2628 //}
2629
2630
2631 //constexpr this_iterator rear_find_item(ITEM item) noexcept
2632 //{
2633
2634 // return rear_find_item(item, ::equals_const_reference < ITEM >);
2635
2636 //}
2637
2638
2639 //constexpr bool _rear_skip_any_character_in_prefix(this_iterator & p, const THIS_RAW_RANGE & range) noexcept
2640 //{
2641
2642 // return BASE_ARRAY::_rear_skip_any_character_in_prefix(p, range);
2643
2644 //}
2645
2646
2647 //template < ::comparison::equality < ITEM > EQUALITY >
2648 //constexpr this_iterator _rear_skip_any_character_in(const THIS_RAW_RANGE & range, EQUALITY equality) noexcept
2649 //{
2650
2651 // return BASE_ARRAY::_rear_skip_any_character_in(range, equality);
2652
2653 //}
2654
2655
2656 //constexpr this_iterator _rear_skip_any_character_in(const THIS_RAW_RANGE & range) noexcept
2657 //{
2658
2659 // return _rear_skip_any_character_in(range, ::equals_const_reference < ITEM >);
2660
2661 //}
2662
2663
2664 //template < ::comparison::equality < ITEM > EQUALITY >
2665 //constexpr this_iterator rear_skip_any_character_in(const THIS_RAW_RANGE & range, EQUALITY equality) noexcept
2666 //{
2667
2668 // return BASE_ARRAY::rear_skip_any_character_in(range, equality);
2669
2670 //}
2671
2672
2673
2674};
2675
2676
2677template<typename ITERATOR_TYPE>
2678auto begin(::range<ITERATOR_TYPE> & t)
2679{
2680
2681 return t.begin();
2682
2683}
2684
2685template<typename ITERATOR_TYPE>
2686auto end(::range<ITERATOR_TYPE> & t)
2687{
2688
2689 return t.begin();
2690
2691}
2692
2693template<prototype_range RANGE>
2694void end_skip_any_character_in_null(RANGE & range)
2695{
2696
2697 while (range.is_set(range.end()++));
2698
2699}
2700
2701
2702template<typename ITEM, ::comparison::equality<ITEM> EQUALITY>
2703constexpr bool _initialize_range_contains_null_terminated(bool & b, ::range<const ITEM *> range, const ITEM * pzPrefix,
2704 EQUALITY equality)
2705{
2706
2707 if (::is_empty(pzPrefix, equality))
2708 {
2709
2710 b = true;
2711
2712 return true;
2713
2714 }
2715
2716 if (range.is_empty())
2717 {
2718
2719 b = false;
2720
2721 return true;
2722
2723 }
2724
2725
2726 return false;
2727
2728}
2729
2730template<typename ITEM, ::comparison::equality<ITEM> EQUALITY>
2731constexpr bool _range_begins_null_terminated(::range<const ITEM *> range, const ITEM * pzPrefix, EQUALITY equality)
2732{
2733
2734 do
2735 {
2736
2737 if (!equality(*range.begin(), *pzPrefix))
2738 {
2739
2740 return false;
2741
2742 }
2743
2744 range.begins()++;
2745
2746 pzPrefix++;
2747
2748 } while (range.is_set() && equality(*pzPrefix, 0));
2749
2750 return true;
2751
2752}
2753
2754template<typename ITEM, ::comparison::equality<ITEM> EQUALITY>
2755constexpr bool range_begins_null_terminated(::range<const ITEM *> range, const ITEM * pzPrefix, EQUALITY equality)
2756{
2757
2758 bool b;
2759
2760 if (_initialize_range_begins_null_terminated(b, range, pzPrefix, equality))
2761 {
2762
2763 return b;
2764
2765 }
2766
2767 return _range_begin_null_terminated(range, pzPrefix, equality);
2768
2769}
2770
2771
2772template<typename ITEM, ::comparison::equality<ITEM> EQUALITY>
2773constexpr bool null_terminated_ends(const ITEM * pz, const ITEM * pzSuffix, EQUALITY equality)
2774{
2775
2776 return ::range<const ITEM *>(pz, equality).ends({ pzSuffix, find_first_null_character(pzSuffix) }, equality);
2777
2778}
2779
2780
2781//template < prototype_character CHARACTER, character_count n >
2782//constexpr class ::range < const CHARACTER* > as_string_range(const CHARACTER(&s)[n])
2783//{
2784//
2785// return s;
2786//
2787//}
2788
2789
2790template < prototype_character CHARACTER, character_count n >
2791constexpr class ::character_range < const CHARACTER* > as_string_literal(const CHARACTER* s)
2792{
2793
2794 if constexpr (n >= 1)
2795 {
2796
2797 if (s[n - 1] == CHARACTER{})
2798 {
2799
2800 return { s, s + n - 1 };
2801
2802 }
2803
2804 }
2805
2806 return { s, s + n };
2807
2808}
2809
2810struct block;
2811
2812template<typename ITERATOR_TYPE>
2813class block_range :
2814 public ::range <ITERATOR_TYPE >
2815{
2816public:
2817
2818
2819
2820 using this_iterator = ITERATOR_TYPE;
2821 using iterator = get_iterator<ITERATOR_TYPE>;
2822 using const_iterator = get_const_iterator<iterator>;
2823
2824
2825 using THIS_RAW_RANGE = ::range<ITERATOR_TYPE>;
2826 using RAW_RANGE = ::range<iterator>;
2827 using CONST_RAW_RANGE = ::range<const_iterator>;
2828 using _BASE_RAW_RANGE = ::range<ITERATOR_TYPE>;
2829
2830 using THIS_RANGE = ::block_range<ITERATOR_TYPE>;
2831 using RANGE = ::block_range<iterator>;
2832 using CONST_RANGE = ::block_range<const_iterator>;
2833
2834
2835 using ITEM_POINTER = get_type_item_pointer<iterator>;
2836
2837
2838 using THIS_ITEM = get_iterator_item<this_iterator>;
2839 using ITEM = non_const<THIS_ITEM>;
2840 using CONST_ITEM = add_const<THIS_ITEM>;
2841 using ARG_ITEM = argument_of < ITEM >;
2842
2843
2844 //this_iterator m_begin;
2845 //this_iterator m_end;
2846 //enum_range m_erange;
2847
2848
2849 constexpr block_range(no_initialize_t noinitialize) :
2850 _BASE_RAW_RANGE(noinitialize)
2851 {
2852 }
2853
2854 constexpr block_range(nullptr_t) :
2855 _BASE_RAW_RANGE(nullptr)
2856 {
2857
2858 };
2859
2860 constexpr block_range() :
2861 _BASE_RAW_RANGE()
2862 {
2863 }
2864
2865
2866 template<::collection::count count>
2867 constexpr block_range(const ITEM(&array)[count], enum_range erange = e_range_none)
2868 requires
2869 (!prototype_character < ITEM >)
2870 : _BASE_RAW_RANGE(array, count, erange)
2871 {
2872 }
2873
2874 //template < typename CHARACTER, character_count n >
2875 //constexpr range(const CHARACTER(& s)[n]) requires
2876 // prototype_character < CHARACTER > &&
2877 // ::std::is_same_v<non_const<non_pointer<CHARACTER>>, non_const<non_pointer<ITEM>>>
2878 //{
2879
2880 // if constexpr (n >= 1)
2881 // {
2882
2883 // if (s[n - 1] == CHARACTER{})
2884 // {
2885
2886 // this->m_begin = s;
2887 // this->m_end = s + n - 1;
2888 // this->m_erange = e_range_null_terminated;
2889
2890 // return;
2891
2892 // }
2893
2894 // }
2895
2896 // this->m_begin = s;
2897 // this->m_end = s + n;
2898 // this->m_erange = e_range_none;
2899
2900 //}
2901
2902
2903 template<typed_range<iterator> TYPED_RANGE>
2904 constexpr block_range(const TYPED_RANGE& range)
2905 requires(!::std::is_same_v < TYPED_RANGE, THIS_RANGE >) :
2906 _BASE_RAW_RANGE((this_iterator)range.begin(),(this_iterator)range.end(),range.m_erange)
2907 {
2908
2909
2910 }
2911
2912
2913 constexpr block_range(const block_range & range) :
2914 _BASE_RAW_RANGE(range)
2915 {
2916
2917 }
2918
2919
2920 constexpr block_range(block_range && range) :
2921 _BASE_RAW_RANGE(::transfer(range))
2922 {
2923
2924
2925 }
2926
2927
2928 template<typename TYPE>
2929 constexpr block_range(TYPE *& p) :
2930 _BASE_RAW_RANGE((this_iterator)p,(this_iterator)find_first_null_character(p), e_range_none)
2931 {
2932
2933 }
2934
2935
2936 template<prototype_integral INTEGRAL>
2937 constexpr block_range(this_iterator begin, INTEGRAL count, enum_range erange = e_range_none) :
2938 _BASE_RAW_RANGE(begin, begin + count,erange)
2939 {
2940 }
2941
2942 constexpr block_range(this_iterator begin, this_iterator end, enum_range erange = e_range_none) :
2943 _BASE_RAW_RANGE(begin, end, erange)
2944 {
2945 }
2946
2947 template<::comparison::equality<ITEM> EQUALITY>
2948 constexpr block_range(this_iterator begin, EQUALITY equality) :
2949 _BASE_RAW_RANGE(begin, (this_iterator)find_first_null_character(begin, equality), e_range_none)
2950 {
2951 }
2952
2953
2954
2955
2956
2957 block_range & operator =(const block_range & range)
2958 {
2959
2960 _BASE_RAW_RANGE::operator =(range);
2961
2962 return *this;
2963
2964 }
2965
2966
2967 block_range & operator=(block_range && range)
2968 {
2969
2970 _BASE_RAW_RANGE::operator =(::transfer(range));
2971
2972 return *this;
2973
2974 }
2975
2976
2977 const ::block block() const;
2978 ::block block();
2979
2980
2981};
ITEM
item
Definition item.h:93
range
Definition range.h:223
add_const
Definition cmp.h:6
block
Definition block.h:46
get_const_iterator_struct
Definition range.h:200
get_iterator_item_struct
Definition range.h:124
get_iterator_struct
Definition range.h:178
get_type_item_pointer_struct
Definition range.h:146
no_initialize_t
Definition _tags.h:5