acme
Foundational cross-platform layer of the ca2 framework
Loading...
Searching...
No Matches
_impl_string_base_allocation.h
1// Created by camilo on 2025-04-21 19:55 <3ThomasBorregaardSørensen!!
2#pragma once
3
4
5//template < typename ITERATOR_TYPE >
6//inline void string_base < ITERATOR_TYPE >::construct_from_string(const ITERATOR_TYPE p, character_count length)
7//{
8//
9// if (::is_null(p) || length <= 0)
10// {
11//
12// default_construct();
13//
14// return;
15//
16// }
17//
18// fork_string<false, false>(length);
19//
20// memory_copy((void*)this->m_begin, p, length * sizeof(CHARACTER));
21//
22// *(CHARACTER*)this->m_end = (CHARACTER)0;
23//
24//}
25
26
27//template < typename ITERATOR_TYPE >
28//template < other_primitive_character < typename string_base < ITERATOR_TYPE >::CHARACTER > OTHER_CHARACTER >
29//inline void string_base < ITERATOR_TYPE >::construct5(const OTHER_CHARACTER* p, character_count len)
30//{
31//
32// if (::is_null(p) || len <= 0)
33// {
34//
35// default_construct();
36//
37// return;
38//
39// }
40//
41// auto dstlen = utf_to_utf_length(this->begin(), p, len);
42//
43// create_string(dstlen);
44//
45// utf_to_utf((CHARACTER*)this->m_begin, p, len);
46//
47// *(CHARACTER*)this->m_end = (CHARACTER)0;
48//
49//}
50
51
52template < typename ITERATOR_TYPE >
53//template < other_primitive_character < typename ::string_base < ITERATOR_TYPE >::CHARACTER > OTHER_CHARACTER >
54template < typename OTHER_CHARACTER >
55inline void string_base < ITERATOR_TYPE >::construct20(const OTHER_CHARACTER * psz, character_count srclen, enum_range erange)
56 requires (other_primitive_character < OTHER_CHARACTER, CHARACTER >)
57{
58
59 auto lengthSrc = srclen;
60
61 auto lengthNew = utf_to_utf_length2(this->m_begin, psz, lengthSrc);
62
63 auto pbasedata = this->create_string_data2(lengthNew, erange);
64
65 auto pdata = pbasedata->data();
66
67 this->m_begin = pdata;
68
69 utf_to_utf(pdata, psz, lengthSrc);
70
71 this->_set_length(lengthNew);
72
73}
74
75
76template < typename ITERATOR_TYPE >
77inline string_base < ITERATOR_TYPE >::string_base(CHARACTER chSrc, character_count repeat) :
78 ::const_string_range < ITERATOR_TYPE >(no_initialize_t{})
79{
80
81 if (repeat <= 0)
82 {
83
84 default_construct();
85
86 return;
87
88 }
89
90 auto lengthNew = repeat;
91
92 auto pbasedata = this->create_string_data2(lengthNew, e_range_none);
93
94 auto pdata = pbasedata->data();
95
96 this->m_begin = pdata;
97
98 auto p = pdata;
99
100 while (repeat > 0)
101 {
102
103 *p++ = chSrc;
104
105 repeat--;
106
107 }
108
109 this->_set_length(lengthNew);
110
111}
112
113
114template < typename ITERATOR_TYPE >
115template < typename OTHER_CHARACTER >
116inline string_base < ITERATOR_TYPE >::string_base(OTHER_CHARACTER chSrc, character_count repeat)
117requires other_primitive_character < OTHER_CHARACTER, CHARACTER > :
118::const_string_range < ITERATOR_TYPE >(no_initialize_t{})
119{
120
121 if (repeat <= 0)
122 {
123
124 default_construct();
125
126 return;
127
128 }
129
130 auto lenUnit = utf_to_utf_length1(this->begin(), &chSrc, 1);
131
132 auto lengthNew = lenUnit * repeat;
133
134 auto pbasedata = this->create_string_data2(lengthNew, e_range_none);
135
136 auto pdata = pbasedata->data();
137
138 this->m_begin = pdata;
139
140 CHARACTER sz[8];
141
142 utf_to_utf(sz, &chSrc, 1);
143
144 auto p = pdata;
145
146 while (repeat > 0)
147 {
148
149 auto pSource = sz;
150
151 auto j = lenUnit;
152
153 while(j > 0)
154 {
155
156 *p++ = *pSource++;
157
158 j--;
159
160 }
161
162 repeat--;
163
164 }
165
166 this->_set_length(lengthNew);
167
168}
169
170
171
172
173
174//template < typename ITERATOR_TYPE >
175//template < other_primitive_character < typename string_base < ITERATOR_TYPE >::CHARACTER > OTHER_CHARACTER, ::i32 t_size >
176//inline string_base < ITERATOR_TYPE >::string_base(const const_string_range_static_array < const OTHER_CHARACTER*, t_size >& a) :
177// ::const_string_range < ITERATOR_TYPE >(no_initialize_t{})
178//{
179//
180// character_count iaLen[t_size];
181//
182// character_count* plen = iaLen;
183//
184// auto len = a.__utf_length(this->begin(), plen);
185//
186// auto p = construct_string(len);
187//
188// plen = iaLen;
189//
190// a.__utf_concatenate_to(p, plen);
191//
192// *p = {};
193//
194//}
195
196
197template < typename ITERATOR_TYPE >
198template < prototype_character CHARACTER2 >
199string_base < ITERATOR_TYPE > & string_base < ITERATOR_TYPE > ::assign(const CHARACTER2 * start, const CHARACTER2 * end)
200{
201
202 return assign(start, end - start);
203
204}
205
206
207template < typename ITERATOR_TYPE >
208template < prototype_character CHARACTER2 >
209inline ::string_base < ITERATOR_TYPE > & string_base < ITERATOR_TYPE >::assign(const CHARACTER2 * start, character_count len)
210{
211
212 _assign(start, len);
213
214 return *this;
215
216}
217
218
219template < typename ITERATOR_TYPE >
220template < prototype_character SAME_SIZE_CHARACTER >
221inline string_base < ITERATOR_TYPE > & string_base < ITERATOR_TYPE >::_assign(const SAME_SIZE_CHARACTER * pszSource, character_count length)
222requires (sizeof(SAME_SIZE_CHARACTER) == sizeof(CHARACTER))
223{
224
225 // auto dstlen = utf_to_utf_length(this->begin(), pszSource, len);
226 //
227 // if (dstlen <= 0)
228 // {
229 //
230 // this->empty();
231 //
232 // }
233 // else
234 // {
235 //
236 // auto pszTarget = this->get_buffer(dstlen);
237 //
238 // utf_to_utf(pszTarget, pszSource, len);
239 //
240 // this->release_buffer(dstlen);
241 //
242 // }
243 //
244 // return *this;
245
246 // if ((::range<const CHARACTER *> *)(this) == (::range<const CHARACTER *> *)(&range))
247 // {
248 //
249 // return *this;
250 //
251 // }
252
253 auto lengthNew = string_safe_length2(pszSource, length);
254
255 auto pdataThis = this->m_pbasedata;
256
257 // if(this->m_erange & e_range_string)
258 // {
259 //
260 // pdataThis = BASE_DATA::base_data_from_data(this->m_begin);
261 //
262 // }
263 // else
264 // {
265 //
266 // pdataThis = nullptr;
267 //
268 // }
269
270 if (::is_null(pszSource) || lengthNew <= 0)
271 {
272
273 this->default_construct();
274
275 }
276 else
277 {
278
279 if (::is_set(pdataThis) &&
280 !pdataThis->base_data_is_shared() &&
281 lengthNew <= pdataThis->storage_character_count()
282 )
283 {
284
285 pdataThis = nullptr;
286
287 }
288 else
289 {
290
291 auto pbasedata = this->create_string_data2(lengthNew, this->m_erange);
292
293 this->m_begin = pbasedata->data();
294
295 }
296
297 ::memory_transfer((void*) this->m_begin, pszSource, lengthNew * sizeof(CHARACTER));
298
299 this->_set_length(lengthNew);
300
301 }
302
303 if (pdataThis)
304 {
305
306 ::base_data_defer_release(pdataThis);
307
308 }
309
310 return *this;
311
312}
313
314
315
316template < typename ITERATOR_TYPE >
317template < prototype_character OTHER_SIZE_CHARACTER >
318inline string_base < ITERATOR_TYPE > & string_base < ITERATOR_TYPE >::_assign(const OTHER_SIZE_CHARACTER * pszSource, character_count srclen)
319requires (sizeof(OTHER_SIZE_CHARACTER) != sizeof(CHARACTER))
320{
321
322 ASSERT((void * )(pszSource + srclen) < (void*)this->m_begin
323 || (void * )pszSource > (void*)(this->m_end))
324
325 // auto dstlen = utf_to_utf_length(this->begin(), pszSource, len);
326 //
327 // if (dstlen <= 0)
328 // {
329 //
330 // this->empty();
331 //
332 // }
333 // else
334 // {
335 //
336 // auto pszTarget = this->get_buffer(dstlen);
337 //
338 // utf_to_utf(pszTarget, pszSource, len);
339 //
340 // this->release_buffer(dstlen);
341 //
342 // }
343 //
344 // return *this;
345
346 // if ((::range<const CHARACTER *> *)(this) == (::range<const CHARACTER *> *)(&range))
347 // {
348 //
349 // return *this;
350 //
351 // }
352
353 auto pdataThis = this->m_pbasedata;
354
355 if (::is_null(pszSource) || srclen <= 0)
356 {
357
358 this->default_construct();
359
360 }
361 else
362 {
363
364 auto lengthSrc = srclen;
365
366 auto lengthNew = utf_to_utf_length2(this->begin(), pszSource, lengthSrc);
367
368 if (lengthNew <= 0)
369 {
370
371 this->default_construct();
372
373 }
374 else
375 {
376
377 if ((::is_set(pdataThis) && !pdataThis->base_data_is_shared() &&
378 lengthNew <= pdataThis->storage_character_count()))
379 {
380
381 pdataThis = nullptr;
382
383 }
384 else
385 {
386
387 auto pbasedata = this->create_string_data2(lengthNew, this->m_erange);
388
389 this->m_begin = pbasedata->data();
390 }
391
392 utf_to_utf((CHARACTER *)this->m_begin, pszSource, lengthSrc);
393
394 this->_set_length(lengthNew);
395
396 }
397
398 }
399
400 if (pdataThis)
401 {
402
403 ::base_data_defer_release(pdataThis);
404
405 }
406
407 return *this;
408
409}
410
411
412template < typename ITERATOR_TYPE >
413template < prototype_character CHARACTER2 >
414inline string_base < ITERATOR_TYPE > & string_base < ITERATOR_TYPE >::assign(CHARACTER2 chSrc, character_count repeat)
415{
416
417 if (repeat > 0)
418 {
419
420 auto lenUnit = utf_to_utf_length1(this->begin(), &chSrc, 1);
421
422 auto len = lenUnit * repeat;
423
424 auto psz = get_buffer(len);
425
426 CHARACTER sz[8];
427
428 utf_to_utf(sz, &chSrc, 1);
429
430 auto pTarget = psz;
431
432 while (repeat > 0)
433 {
434
435 auto pSource = sz;
436
437 for (::collection::index j = 0; j < lenUnit; j++)
438 {
439
440 *pTarget++ = *pSource;
441
442 }
443
444 repeat--;
445
446 }
447
448 release_buffer(len);
449
450 }
451 else
452 {
453
454 this->empty();
455
456 }
457
458 return *this;
459
460}
461
462
463
464
465template < typename ITERATOR_TYPE >
466inline string_base < ITERATOR_TYPE > & string_base < ITERATOR_TYPE >::_append(const CHARACTER * pszSrc, character_count srclen)
467{
468
469 if (this->is_empty())
470 {
471
472 return _assign(pszSrc, srclen);
473
474 }
475
476 auto old_len = this->length();
477
478 if (old_len < 0)
479 {
480
481 old_len = 0;
482
483 }
484
485 auto lengthSrc = srclen;
486
487 auto add_len = utf_to_utf_length2(this->m_begin, pszSrc, lengthSrc);
488
489 auto new_len = old_len + add_len;
490
491 auto p = get_buffer<true>(new_len);
492
493 utf_to_utf(p + old_len, pszSrc, lengthSrc);
494
495 this->_set_length(new_len);
496
497 return *this;
498
499}
500
501
502template < typename ITERATOR_TYPE >
503template < typename OTHER_CHARACTER >
504inline string_base < ITERATOR_TYPE > & string_base < ITERATOR_TYPE >::_append(const OTHER_CHARACTER * pszSrc, character_count count)
505requires other_primitive_character < OTHER_CHARACTER, CHARACTER >
506{
507
508 auto old_len = this->length();
509
510 if (old_len < 0)
511 {
512
513 old_len = 0;
514
515 }
516
517 auto lengthSrcAppend = count;
518
519 auto add_len = utf_to_utf_length2(this->m_begin, pszSrc, lengthSrcAppend);
520
521 auto new_len = old_len + add_len;
522
523 auto p = get_buffer<true>(new_len);
524
525 p += old_len;
526
527 utf_to_utf(p, pszSrc, lengthSrcAppend);
528
529 this->_set_length(new_len);
530
531 return *this;
532
533}
534
535
536
537template < typename ITERATOR_TYPE >
538inline string_base < ITERATOR_TYPE > & string_base < ITERATOR_TYPE >::append_character(::ansi_character ch)
539{
540
541 return append(&ch, 1);
542
543}
544
545
546template < typename ITERATOR_TYPE >
547inline string_base < ITERATOR_TYPE > & string_base < ITERATOR_TYPE >::append_character(::wd16_character wch)
548{
549
550 return append(&wch, 1);
551
552}
553
554
555template < typename ITERATOR_TYPE >
556inline string_base < ITERATOR_TYPE > & string_base < ITERATOR_TYPE >::append_character(::wd32_character wch)
557{
558
559 return append(&wch, 1);
560
561}
562
563
564template < typename ITERATOR_TYPE >
565inline string_base < ITERATOR_TYPE > & string_base < ITERATOR_TYPE >::append(character_count len, CHARACTER ch)
566{
567
568 if (len > 0)
569 {
570
571 character_count nOldLength = this->size();
572
573 character_count nNewLength = nOldLength + len;
574
575 auto p = this->get_buffer<true>(nNewLength);
576
577 auto padd = p + len - 1;
578
579 while (padd >= p)
580 {
581
582 *padd = ch;
583
584 padd--;
585
586 }
587
588 this->release_buffer(nNewLength);
589
590 }
591
592 return *this;
593
594}
595
596
597template < typename ITERATOR_TYPE >
598void string_base< ITERATOR_TYPE >::construct_from_string(const string_base& str)
599{
600
601 this->m_begin = str.m_begin;
602
603 this->m_end = str.m_end;
604
605 this->m_erange = str.m_erange;
606
607 this->m_pbasedata = str.m_pbasedata;
608
609 if (this->m_pbasedata)
610 {
611
612 this->m_pbasedata->base_data_increment_reference_count();
613
614 }
615
616}
617
618
619template < typename ITERATOR_TYPE >
620inline void string_base< ITERATOR_TYPE >::construct_from_range(ITERATOR_TYPE pSrc, character_count length)
621{
622
623 auto lengthNew = string_safe_length2(pSrc, length);
624
625 if (::is_null(pSrc) || lengthNew <= 0)
626 {
627
628 default_construct();
629
630 return;
631
632 }
633
634 auto pbasedata = this->create_string_data2(lengthNew, e_range_none);
635
636 auto pdata = pbasedata->data();
637
638 this->m_begin = pdata;
639
640 string_count_copy(pdata, pSrc, lengthNew);
641
642 this->_set_length(lengthNew);
643
644}
645
646
647template < typename ITERATOR_TYPE >
648template < typename OTHER_CHARACTER_POINTER >
649inline void string_base< ITERATOR_TYPE >::construct_from_range(OTHER_CHARACTER_POINTER pSrc, character_count srclen)
650requires other_character_pointer < OTHER_CHARACTER_POINTER, ITERATOR_TYPE >
651{
652
653 auto lengthSrc = srclen;
654
655 auto lengthNew = utf_to_utf_length2(this->begin(), pSrc, lengthSrc);
656
657 if (::is_null(pSrc) || lengthNew <= 0)
658 {
659
660 default_construct();
661
662 return;
663
664 }
665
666 auto pbasedata = this->create_string_data2(lengthNew, e_range_none);
667
668 auto pdata = pbasedata->data();
669
670 this->m_begin = pdata;
671
672 utf_to_utf(pdata, pSrc, lengthSrc);
673
674 this->_set_length(lengthNew);
675
676}
677
678
679template < typename ITERATOR_TYPE >
680template < character_pointer CHARACTER_POINTER >
681string_base< ITERATOR_TYPE >::string_base(CHARACTER_POINTER s1, CHARACTER_POINTER e1, CHARACTER_POINTER s2, CHARACTER_POINTER e2) :
682 string_base(::range < ITERATOR_TYPE >(s1, e1) + ::range < ITERATOR_TYPE >(s2, e2))
683{
684
685
686}
687
688
689template < typename ITERATOR_TYPE >
690template < typename RANGE1, typename RANGE2 >
691void string_base< ITERATOR_TYPE >::construct_from_two_ranges_concatenation(const RANGE1& range1, const RANGE2& range2)
692{
693
694 if (range1.is_empty())
695 {
696
697 if (range2.is_empty())
698 {
699
700 default_construct();
701
702 }
703 else
704 {
705
706 construct_from_a_range(range2);
707
708 }
709
710 return;
711
712 }
713 else if (range2.is_empty())
714 {
715
716 construct_from_a_range(range1);
717
718 return;
719
720 }
721
722 auto len1 = range1.size();
723
724 auto lenNew1 = string_safe_length2(range1.m_begin, len1);
725
726 auto len2 = range2.size();
727
728 auto lenNew2 = string_safe_length2(range2.m_begin, len2);
729
730 auto lengthNew = lenNew1 + lenNew2;
731
732 auto pbasedata = this->create_string_data2(lengthNew, e_range_none);
733
734 auto pdata = pbasedata->data();
735
736 this->m_begin = pdata;
737
738 auto p = pdata;
739
740 string_count_copy(p, range1.m_begin, lenNew1);
741
742 string_count_copy(p + lenNew1, range2.m_begin, lenNew2);
743
744 this->_set_length(lengthNew);
745
746}
747
748
749// template < typename ITERATOR_TYPE >
750// inline ITERATOR_TYPE character_range_defer_increment_reference_count(ITERATOR_TYPE piterator, enum_range erange)
751// {
752//
753// if (erange & e_range_string)
754// {
755//
756// string_base_increment_reference_count(piterator);
757//
758// }
759//
760// return piterator;
761//
762// }
763
764//
765// template < typename RANGE >
766// inline RANGE & character_range_defer_increment_reference_count(RANGE & range)
767// {
768//
769// character_range_defer_increment_reference_count(range.m_begin, range.m_erange);
770//
771// return range;
772//
773// }
774
775//
776// template < typename RANGE >
777// inline RANGE & character_range_defer_release(RANGE & range)
778// {
779//
780// if (range.m_erange & e_range_string)
781// {
782//
783// string_base_release(range.m_begin);
784//
785// }
786//
787// return range;
788//
789// }
790//
791//
792
793//
794// template < typename ITERATOR_TYPE >
795// inline void string_base_increment_reference_count(ITERATOR_TYPE piterator)
796// {
797//
798// ::string_base< ITERATOR_TYPE >::string_data_increment_reference_count(piterator);
799//
800// }
801//
802//
803// template < typename ITERATOR_TYPE >
804// inline void string_base_release(ITERATOR_TYPE piterator)
805// {
806//
807// ::string_base< ITERATOR_TYPE >::string_data_release(piterator);
808//
809// }
810//
811//
812
CHARACTER
range
Definition range.h:223
string_base
Definition string_base.h:90
no_initialize_t
Definition _tags.h:5