acme
Foundational cross-platform layer of the ca2 framework
Loading...
Searching...
No Matches
aaa__papaya_array.h
1#pragma once
2
3
4template < class TYPE, class ARG_TYPE = const TYPE &, class ALLOCATOR = allocator::nodef < TYPE >, ::enum_type t_etypeContainer = e_type_element >
5inline auto & __array_object(::base_array < TYPE, ARG_TYPE, TYPED, MEMORY, t_etypeContainer > & a, ::collection::index i);
6
7
8template < typename ARRAY_TYPE, typename T >
9inline auto & __array_object(::pointer_array_process < ARRAY_TYPE, T > & a, ::collection::index i);
10
11
12namespace acme
13{
14
15
16 template < class TDST, class TSRC >
17 ::collection::count copy(pointer_array < TDST > & dsta, const pointer_array < TSRC > & srca);
18
19
20 template < class A, class T >
21 A make_array(T t1)
22 {
23
24 A a;
25 a.add(t1);
26 return a;
27
28 }
29
30
31 namespace ptra
32 {
33
34
35 template < class TDST,class TSRC >
36 ::collection::count copy(address_array < TDST > & dsta, const address_array < TSRC > & srca);
37
38 template < class TDST, class TSRC >
39 ::collection::count ptrcopy(TDST & dsta, const TSRC & srca);
40
41
42 }
43
44
45 namespace array
46 {
47
48
49 template < class TDST,class TSRC >
50 ::collection::count copy(TDST & dsta,const TSRC & srca);
51
52 template < typename CONTAINER, class TYPE >
53 bool contains_item(const CONTAINER & container, const TYPE & t);
54
55
56//#ifdef UNIVERSAL_WINDOWS
57//
58// template < typename T, typename ITEM >
59// inline ::collection::index find_first_item(::winrt::Windows::Foundation::Collections::IVectorImpact < T > ^ ivectorview, const ITEM & item)
60// {
61//
62// for (::u32 u = 0; u < ivectorview->Size; u++)
63// {
64//
65// if (ivectorview->GetAt(u) == item)
66// {
67//
68// return u;
69//
70// }
71//
72// }
73//
74// return -1;
75//
76// }
77//
78//
79// template < typename T, typename ITEM >
80// inline bool contains_item(::winrt::Windows::Foundation::Collections::IVectorImpact < T > ^ ivectorview, const ITEM & item)
81// {
82//
83// auto iFindFirst = find_first_item(ivectorview, item);
84//
85// return iFindFirst >= 0;
86//
87// }
88//
89//
90//#endif
91
92
93 template < class TINTERSECTION, class TDST, class TSRC >
94 void intersection(TINTERSECTION & intersection, const TDST & dsta, const TSRC & srca);
95
96 template < class A >
97 void randomize(A & a)
98 {
99
100 A b;
101
102 while(a.get_count() > 0)
103 {
104
105 ::collection::index i = (index) (rand() % a.get_size());
106 b.add(a.element_at(i));
107 a.erase_at(i);
108
109 }
110
111 a = b;
112
113 }
114
115
116 template < class A >
117 typename A::BASE_TYPE pick_random(A & a)
118 {
119
120 ::collection::index i = (index)(rand() % a.get_size());
121
122 return a.element_at(i);
123
124 }
125
126
127 template < class A >
128 typename A::BASE_TYPE pop_random(A & a)
129 {
130
131 ::collection::index i = (index)(rand() % a.get_size());
132
133 auto matter = a.element_at(i);
134
135 a.erase_at(i);
136
137 return matter;
138
139 }
140
141
142 template < class A, class TYPE >
143 ::collection::count populate(A & a, TYPE start, TYPE end, TYPE step, bool bIncludeStart = true, bool bIncludeEnd = true, bool bIncludeEndOnStep = true)
144 {
145
146 ::collection::count count = 0;
147
148 TYPE cur = start;
149
150 if(bIncludeStart)
151 {
152
153 if(start == end)
154 {
155
156 if(bIncludeEnd)
157 {
158
159 a.add(cur);
160
161 return 1;
162
163 }
164 else
165 {
166
167 return 0;
168
169 }
170
171 }
172 else
173 {
174
175 a.add(cur);
176
177 count++;
178
179 }
180
181 }
182
183 if(end > start)
184 {
185
186 if (step == 0)
187 {
188
189 return count;
190
191 }
192
193 if (step < 0)
194 {
195
196 step = -step;
197
198 }
199
200 while(true)
201 {
202
203 cur = cur + step;
204
205 if (cur >= end)
206 {
207
208 break;
209
210 }
211
212 a.add(cur);
213
214 count++;
215
216 }
217
218 }
219 else
220 {
221
222 if (step == 0)
223 {
224
225 return count;
226
227 }
228
229 if (step < 0)
230 {
231
232 step = -step;
233
234 }
235
236 while(true)
237 {
238
239 cur = cur - step;
240
241 if (cur <= end)
242 {
243
244 break;
245
246 }
247
248 a.add(cur);
249
250 count++;
251
252 }
253
254 }
255
256 if(bIncludeEnd)
257 {
258
259 if(bIncludeEndOnStep)
260 {
261
262 if(cur == end)
263 {
264
265 a.add(cur);
266
267 return count + 1;
268
269 }
270 else
271 {
272
273 return count;
274
275 }
276
277 }
278 else
279 {
280
281 a.add(cur);
282
283 return count + 1;
284
285 }
286
287 }
288 else
289 {
290
291 return count;
292
293 }
294
295 }
296
297
298 template < typename ARRAY >
299 ::collection::index find_first(const ARRAY & a, typename ARRAY::BASE_ARG_TYPE t,index(* pfnCompare)(typename ARRAY::BASE_ARG_TYPE,typename ARRAY::BASE_ARG_TYPE),index find = 0,index last = -1)
300 {
301
302 if (find < 0)
303 {
304
305 find += a.get_count();
306
307 }
308
309 if (last < 0)
310 {
311
312 last += a.get_count();
313
314 }
315
316 for(; find <= last; find++)
317 {
318
319 if (pfnCompare((typename ARRAY::BASE_ARG_TYPE)a.element_at(find), (typename ARRAY::BASE_ARG_TYPE)t) == 0)
320 {
321
322 return find;
323
324 }
325
326 }
327
328 return -1;
329
330 }
331
332
333 template < typename T >
334 inline bool are_all_elements_equal(const pointer_array < T > & a1, const pointer_array < T > & a2)
335 {
336
337 if (a1.get_count() != a2.get_count())
338 {
339
340 return false;
341
342 }
343
344 for (::i32 i = 0; i < a1.get_count(); i++)
345 {
346
347 if (a1.at(i) != a2.at(i))
348 {
349
350 return false;
351
352 }
353
354 }
355
356 return true;
357
358 }
359
360
361
362 namespace every
363 {
364
365 template < typename A >
366 bool ci_is(const A & a, const typename A::BASE_TYPE & t)
367 {
368
369 for (auto & i : a)
370 {
371
372 if (::case_insensitive_ansi_compare(i, t))
373 {
374
375 return false;
376
377 }
378
379 }
380
381 return true;
382
383 }
384
385 template < typename A >
386 bool is_true(A && a)
387 {
388
389 for (auto & i : a)
390 {
391
392 if ((bool) i)
393 {
394
395 return true;
396
397 }
398
399 }
400
401 return false;
402
403 }
404
405
406 }
407
408
409 } // namespace array
410
411
412
413 template < class A >
414 void array_merge(A & a, const A & a1, const A & a2)
415 {
416 a = a1 + a2;
417 }
418
419 template < class A >
420 void array_makecombination(pointer_array < A > & comb, const A & a, A blindprefixa = A(), ::collection::index idx = 0)
421 {
422 comb.add(allocateø A(blindprefixa));
423 for(::collection::index i = idx; i < a.get_count(); i++)
424 {
425 array_makecombination(comb, a, blindprefixa + make_array < A > (a[i]), i + 1);
426 }
427 }
428
429 /*
430 function array_arrange($a)
431 {
432 $comb = array_makecombination($a);
433 $ret = array();
434 $count = count($comb);
435 foreach($comb as $ai)
436 {
437 if(count($ai) > 0)
438 $ret = array_merge($ret, array_permute($ai));
439 }
440 return $ret;
441 }*/
442
443 template < class A, class A2D >
444 void array_permute(A2D & perm,const A & a);
445
446 template < class A >
447 void array_permute(pointer_array < A > & perm,const A & a);
448
449 CLASS_DECL_ACME string_array_base x1_decode_ida(const ::scoped_string & scopedstr);
450
451 CLASS_DECL_ACME string x1_encode_ida(const string_array_base & stra);
452
453
454 template < class A >
455 void x1_on_erase(const A & a, typename A::BASE_TYPE & n)
456 {
457 ::collection::count c = 0;
458 for (::collection::index i = 0; i < a.get_size(); i++)
459 {
460 if (a[i] < n)
461 {
462 c++;
463 }
464 }
465 n -= c;
466 }
467
468
469 namespace array
470 {
471
472
473 //template < typename TYPE >
474 //::stream & write_container_as_parent(::stream & stream, const pointer_array < TYPE > & a);
475
476 //template < typename TYPE >
477 //::stream & read_container_as_parent(::stream & stream, pointer_array < TYPE > & a);
478
479 //template < typename TYPE, typename INITIALIZER >
480 //::stream & exchange_container(::stream & stream, INITIALIZER * pinitializer, const pointer_array < TYPE > & a);
481
482 template < typename Type, typename RawType, ::enum_type t_etypeContainer >
483 ::collection::index add(string_base_array < Type, RawType, t_etypeContainer > & array, const Type & psz)
484 {
485
486 auto iIndex = __index(array.m_nSize);
487
488 array.set_at_grow(iIndex, psz);
489
490 return iIndex;
491
492 }
493
494
495 template < typename Type, typename RawType, ::enum_type t_etypeContainer >
496 ::collection::index add(string_base_array < Type, RawType, t_etypeContainer > & array, const ::payload & payload);
497
498
499 template < typename Type, typename RawType, ::enum_type t_etypeContainer >
500 ::collection::index unfold_add(string_base_array < Type, RawType, t_etypeContainer > & array, const ::payload & payload);
501
502 template < typename TYPE, ::enum_type t_etypeContainer = e_type_element >
503 ::collection::count ensure_sequence(::numeric_array < TYPE, t_etypeContainer > & a, TYPE start, TYPE end, TYPE increment = 1);
504
505 template < typename TYPE, ::enum_type t_etypeContainer = e_type_element >
506 ::collection::count append_sequence(::numeric_array < TYPE, t_etypeContainer > & a, TYPE iterator, TYPE end, TYPE increment = 1);
507
508 template < typename TYPE, ::enum_type t_etypeContainer = e_type_element >
509 ::collection::count set_sequence(::numeric_array < TYPE, t_etypeContainer > & a, TYPE start, TYPE end, TYPE increment = 1);
510
511 template<class ARRAY>
512 bool binary_search(ARRAY & a,typename ARRAY::BASE_ARG_TYPE t,::collection::index & iIndex,index(* fCompare) (typename ARRAY::BASE_ARG_TYPE,typename ARRAY::BASE_ARG_TYPE));
513
514 template<class ARRAY>
515 bool binary_search(ARRAY & a, typename ARRAY::BASE_ARG_TYPE t, ::collection::index & iIndex, less_predicate_base < typename ARRAY::BASE_ARG_TYPE > * pcompare, index_array & ia);
516
517 template<class ARRAY>
518 ::collection::index sort_add(ARRAY & a, typename ARRAY::BASE_ARG_TYPE t, index(*fCompare) (typename ARRAY::BASE_ARG_TYPE, typename ARRAY::BASE_ARG_TYPE), index_array & ia);
519
520 template<class ARRAY, class ARRAY2>
521 ::collection::count sort_add_array(ARRAY & a, ARRAY2 & a2, index(*fCompare) (typename ARRAY::BASE_ARG_TYPE, typename ARRAY::BASE_ARG_TYPE), index_array & ia);
522
523 template<class ARRAY>
524 inline typename ARRAY::BASE_TYPE pop(ARRAY & a, ::collection::index n = -1);
525
526 template<class ARRAY>
527 inline void pop_back(ARRAY & a, ::collection::index n = -1);
528
529 template<class ARRAY>
530 inline ::collection::index push(ARRAY & a, typename ARRAY::BASE_ARG_TYPE newElement, ::collection::index n = 0);
531
532 template<class ARRAY>
533 inline void push_back(ARRAY & a, typename ARRAY::BASE_ARG_TYPE newElement, ::collection::index n = 0);
534
535 template<class TARGET, class SOURCE> inline ::collection::index add(TARGET & target, const SOURCE & source)
536 {
537
538 return target.add(source);
539
540 }
541
542
543 template < typename ARRAY1, typename ARRAY2>
544 inline ::collection::index add_array(ARRAY1 & array1, const ARRAY2 & array2)
545 {
546
547 ::collection::index i = -1;
548
549 for (auto & item : array2)
550 {
551
552 ::collection::index iItem = array1.add_item(item);
553
554 if (i < 0)
555 {
556
557 i = iItem;
558
559 }
560
561 }
562
563 return i;
564
565 }
566
567
568 template < typename ARRAY1, typename ARRAY2>
569 inline ::collection::index unfold_array(ARRAY1 & array1, const ARRAY2 & array2)
570 {
571
572 ::collection::index i = -1;
573
574 for (auto & item : array2)
575 {
576
577 ::collection::index iItem = add(array1, item);
578
579 if (i < 0)
580 {
581
582 i = iItem;
583
584 }
585
586 }
587
588 return i;
589
590 }
591
592
593 inline ::collection::index add(string_array_base & stra, const ::scoped_string & scopedstr);
594 inline ::collection::index add(string_array_base & stra, const ::i8 & ch);
595 inline ::collection::index add(string_array_base & stra, const ansi_string & str);
596 inline ::collection::index add(string_array_base & stra, const wide_string & str);
597 inline ::collection::index add(string_array_base & stra, const ::file::path & path);
598 inline ::collection::index add(string_array_base & stra, const ::payload & payload);
599 inline ::collection::index add(string_array_base & stra, const ::property & property);
600 inline ::collection::index add(string_array_base & stra, const ::property_set & propertyset);
601
602 inline ::collection::index add(::file::path_array & patha, const ::scoped_string & scopedstr);
603
604 inline ::collection::index add(string_array_base & stra, const string_array_base & straSource);
605
606 inline ::collection::index add(::file::path_array & patha, const string_array_base & stra);
607 inline ::collection::index add(::file::path_array & patha, const ::file::path_array & pathaSrc);
608 inline ::collection::index add(::file::path_array & patha, const ::file::listing & listing);
609
610 template < typename T >
611 inline bool are_all_elements_equal(const pointer_array < T > & a1, const pointer_array < T > & a2);
612
613 // t1 candidate bigger
614 template < typename T1, typename T2>
615 inline bool contains_array(const T1 & t1, const T2 & t2);
616
617
618 template < typename T1, typename T2>
619 inline ::collection::count erase_array(T1 & t1, T2 && t2);
620
621
622 template < typename T1, typename T2>
623 inline bool equals_non_unique_unordered(const T1 & t1, const T2 & t2)
624 {
625
626 return ::papaya::array::contains_array(t1, t2) && ::papaya::array::contains_array(t2, t1);
627
628 }
629
630 template < typename A, typename PTRA >
631 void ptra(PTRA & ptra, const A & a)
632 {
633
634 for (auto & item : a)
635 {
636
637 ptra.add((typename PTRA::BASE_TYPE) item);
638
639 }
640
641 }
642
643
644 template < typename A >
645 ::array < const_char_pointer > psza(const A & a)
646 {
647
648 ::array < const_char_pointer > pa;
649
650 ptra(pa, a);
651
652 pa.add(nullptr);
653
654 return pa;
655
656 }
657
658
659 template < typename A, typename PA >
660 void copy_points(A & a, const PA * pa, ::collection::count c);
661
662
663 } // namespace array
664
665 namespace array2d
666 {
667
668 template < typename A >
669 ::collection::count predominant_column_count(A & a);
670
671 } // namespace array2d
672
673
674 template < typename TYPE, ::enum_type t_etypeContainer = e_type_element >
675 ::collection::count erase_greater_than(::numeric_array < TYPE, t_etypeContainer > & a, TYPE hi);
676
677
678 template < typename TYPE, ::enum_type t_etypeContainer = e_type_element >
679 ::collection::count erase_greater_than_or_equal(::numeric_array < TYPE, t_etypeContainer > & a, TYPE hi);
680
681
682 template < typename TYPE, ::enum_type t_etypeContainer = e_type_element >
683 ::collection::count erase_lesser_than(::numeric_array < TYPE, t_etypeContainer > & a, TYPE lo);
684
685
686 template < typename TYPE, ::enum_type t_etypeContainer = e_type_element >
687 ::collection::count erase_lesser_than_or_equal(::numeric_array < TYPE, t_etypeContainer > & a, TYPE lo);
688
689
690 template < typename TYPE, ::enum_type t_etypeContainer = e_type_element >
691 ::collection::count erase_lesser_than_or_greater_than(::numeric_array < TYPE, t_etypeContainer > & a, TYPE lo, TYPE hi);
692
693
694 template < typename TYPE, ::enum_type t_etypeContainer = e_type_element >
695 ::collection::count erase_lesser_than_or_greater_than_or_equal(::numeric_array < TYPE, t_etypeContainer > & a, TYPE lo, TYPE hi);
696
697
698 template < typename TYPE, ::enum_type t_etypeContainer = e_type_element >
699 ::collection::count erase_lesser_than_or_equal_or_greater_than(::numeric_array < TYPE, t_etypeContainer > & a, TYPE lo, TYPE hi);
700
701
702 template < typename TYPE, ::enum_type t_etypeContainer = e_type_element >
703 ::collection::count erase_lesser_than_or_equal_or_greater_than_or_equal(::numeric_array < TYPE, t_etypeContainer > & a, TYPE lo, TYPE hi);
704
705
706} // namespace acme
707
708
709
pointer_array_base::add
::collection::index add(const pointer< T > &p)
consumes a referer
Definition pointer_array.h:226
acme
include "aura/graphics/image/context.h"
Definition aaaa__defer.h:32