ALib C++ Library
Library Version: 2510 R0
Documentation generated by doxygen
Loading...
Searching...
No Matches
boxstrap.cpp
1// #################################################################################################
2// ALib C++ Library
3//
4// Copyright 2013-2025 A-Worx GmbH, Germany
5// Published under 'Boost Software License' (a free software license, see LICENSE.txt)
6// #################################################################################################
7#include "alib_precompile.hpp"
8#if !defined(ALIB_C20_MODULES) || ((ALIB_C20_MODULES != 0) && (ALIB_C20_MODULES != 1))
9# error "Symbol ALIB_C20_MODULES has to be given to the compiler as either 0 or 1"
10#endif
11#if ALIB_C20_MODULES
12 module;
13#endif
14// ====================================== Global Fragment ======================================
15#include <cmath>
16#include <functional>
17#include <cstring>
18#include <typeindex>
19#include <span>
20
21# include "ALib.Lang.H"
22# include "ALib.Characters.Functions.H"
23# include "ALib.Time.H"
24# include "ALib.Threads.H"
25# include "ALib.Monomem.H"
26# include "ALib.Strings.H"
27# include "ALib.Strings.Token.H"
28# include "ALib.Singletons.H"
29# include "ALib.Boxing.H"
30# include "ALib.EnumRecords.Bootstrap.H"
31# include "ALib.ThreadModel.H"
32# include "ALib.Exceptions.H"
33# include "ALib.System.H"
34# include "ALib.Format.H"
35# include "ALib.Format.StdImplementation.H"
36# include "ALib.Format.FormatterPythonStyle.H"
37# include "ALib.Format.FormatterJavaStyle.H"
38# include "ALib.Variables.H"
39# include "ALib.Variables.IniFile.H"
40# include "ALib.BitBuffer.H"
41# include "ALib.Camp.H"
42# include "ALib.Camp.Base.H"
43# include "ALib.Bootstrap.H"
44# include "ALib.CLI.H"
45# include "ALib.Expressions.H"
46# include "ALib.ALox.Impl.H"
47# include "ALib.Files.H"
48
49#if ALIB_DEBUG && !DOXYGEN
50namespace alib::boxing::debug {
51 // This is used by boxing::Bootstrap to do a runtime-check for compatibility of boxing
52 // and long double values.
53 // It was put here to prevent the compiler to optimize and remove the code.
54 extern long double LONGDOUBLE_WRITE_TEST_MEM[2];
55 extern void LongDoubleTrueLengthSet();
56 extern bool LongDoubleTrueLengthTest();
57}
58#endif
59
60// =========================================== Module ==========================================
61#if ALIB_C20_MODULES
62 module ALib.Boxing;
63#endif
64// ====================================== Implementation =======================================
65
66// #################################################################################################
67// Anonymous methods needed for Bootstrap()
68// #################################################################################################
69#if !DOXYGEN
70
71namespace alib::boxing {
72namespace {
73
74bool FIsNotNull_Default( const Box& box )
75{
76 return !( (box.IsArray() && box.UnboxLength() == 0 )
77 || (box.IsPointer() && box.Data().PointerPair.P1 == nullptr )
78 );
79}
80
81std::size_t FHashcode_Default( const Box& self )
82{
83 if( self.IsPointer() )
84 {
85 return size_t(0xa814e72cUL)
86 + size_t( self.TypeID().hash_code() )
87 + self.Data().Integrals.UArray[0] * 89047023;
88 }
89
90 if( self.IsEnum() )
91 {
92 return size_t(0x49a024efUL)
93 + size_t( self.TypeID().hash_code() )
94 + self.Data().Integrals.UArray[0] * 79204799;
95 }
96
97 if( self.IsArray() )
98 {
99 std::size_t result= 0xa925eb91L
100 + std::size_t( self.ElementTypeID().hash_code() );
101
102 // do different loops depending on array element size
103 auto size = self.ArrayElementSize();
104 auto length= self.UnboxLength();
105 if( size == 2 || size == 6 )
106 {
107 if (size == 6)
108 length*= 3;
109
110 std::span<uint16_t> array= {self.Data().GetPointer<uint16_t>(), size_t(length) };
111 for( uint16_t v : array )
112 result = 67 * result + v;
113
114 return size_t( result );
115 }
116
117 if( size == 4 )
118 {
119 std::span<uint32_t> array= {self.Data().GetPointer<uint32_t>(), size_t(length) };
120 for( uint32_t v : array )
121 result = 67*result + v;
122
123 return size_t( result );
124 }
125
126 if( size == 8 )
127 {
128 std::span<uint64_t> array= {self.Data().GetPointer<uint64_t>(), size_t(length) };
129 for( uint64_t v : array )
130 result = std::size_t( 67 * result + v );
131
132 return std::size_t( result );
133 }
134
135 // any other size
136 {
137 length*= size;
138 std::span<unsigned char> array= {self.Data().GetPointer<unsigned char>(), size_t(length) };
139 for( unsigned char v : array )
140 result = 67 * result + v;
141
142 return size_t( result );
143 }
144 }
145
146 //--- default (value types) ---
147 size_t result= size_t(0xcf670957UL)
148 + size_t( self.TypeID().hash_code() );
149
150 unsigned int usedLen= self.GetPlaceholderUsageLength();
151
152 constexpr uinteger Bit1= 1;
153
154 // smaller than first "word"
155 if( usedLen < sizeof( uinteger ) )
156 return size_t( ( self.Data().Integrals.UArray[0]
157 & ((Bit1 << (usedLen * 8) )- 1) ) * 32194735 )
158 + result;
159
160 // add first word
161 result+= self.Data().Integrals.UArray[0] * 32194735;
162
163 if( usedLen == sizeof(uinteger) )
164 return result;
165
166 // tests if smaller than second "word"
167 if( usedLen - sizeof( uinteger ) < sizeof( uinteger ) )
168 {
169 return size_t( ( self.Data().Integrals.UArray[1]
170 & ((Bit1 << ((usedLen - sizeof(uinteger)) * 8) )- 1) ) * 321947 )
171 + result;
172 }
173
174 return result + self.Data().Integrals.UArray[1] * 321947;
175
176
177}
178
179bool FEquals_Default( const Box& self, const Box& rhs )
180{
181 if( !self.IsSameType( rhs ) )
182 return false;
183
184 // array types?
185 if( self.IsArray() )
186 {
187 // different in type, length or nulled?
188 if( self.UnboxLength() != rhs.UnboxLength()
189 || ( ( self.Data().GetPointer<char>() == nullptr)
190 != ( rhs .Data().GetPointer<char>() == nullptr ) ) )
191 return false;
192
193 return self.Data().GetPointer<char>() == nullptr
194 || self.UnboxLength() == 0
195 || self.Data().GetPointer<char>() == rhs.Data().GetPointer<char>()
196 || memcmp( self.Data().GetPointer<char>(),
197 rhs .Data().GetPointer<char>(),
198 static_cast <size_t>( self.UnboxLength() ) * self.ArrayElementSize()
199 ) == 0;
200 }
201
202 // non-array types
203 unsigned int usedLen= self.GetPlaceholderUsageLength();
204
205 constexpr uinteger Bit1= uinteger( 1 );
206 // tests if smaller than first "word"
207 if( usedLen < sizeof( uinteger ) )
208 {
209 uinteger mask= (Bit1 << (usedLen * 8) )- 1;
210 return ( self.Data().Integrals.UArray[0] & mask )
211 == ( rhs .Data().Integrals.UArray[0] & mask );
212 }
213
214 // test first word
215 if( self.Data().Integrals.UArray[0] != rhs.Data().Integrals.UArray[0] )
216 return false;
217
218 if( usedLen == sizeof( uinteger ) )
219 return true;
220
221 // tests if smaller than second "word"
222 if( usedLen - sizeof( uinteger ) < sizeof( uinteger ) )
223 {
224 uinteger mask= (Bit1 << (usedLen - sizeof(uinteger)) * 8 )- 1;
225 return ( self.Data().Integrals.UArray[1] & mask )
226 == ( rhs .Data().Integrals.UArray[1] & mask );
227 }
228
229 return self.Data().Integrals.UArray[1] == rhs.Data().Integrals.UArray[1];
230}
231
232
233bool FEquals_double( const Box& self, const Box& rhsBox )
234{
235 double lhs= self.UnboxFloatingPoint();
236 double rhs;
237 if( rhsBox.IsFloatingPoint () ) rhs= rhsBox.UnboxFloatingPoint () ;
238 else if( rhsBox.IsSignedIntegral () ) rhs= double( rhsBox.UnboxSignedIntegral () );
239 else if( rhsBox.IsUnsignedIntegral() ) rhs= double( rhsBox.UnboxUnsignedIntegral() );
240 else return false;
241
242 // we can ignore this warning, because we fixed it with the second test
243 #if defined(__clang__)
244 #pragma clang diagnostic push
245 #pragma clang diagnostic ignored "-Wfloat-equal"
246 #endif
247
248 return lhs == rhs
249 // take rounding errors into account.
250 // We use the "float-epsilon" and double it to be even a little weaker!
251 || std::fabs( lhs - rhs ) <= double( 2.0f * std::numeric_limits<float>::epsilon() );
252
253 #if defined(__clang__)
254 #pragma clang diagnostic pop
255 #endif
256}
257
258bool FEquals_integer( const Box& self, const Box& rhsBox )
259{
260 if( rhsBox.IsFloatingPoint() )
261 return FEquals_double( rhsBox, self );
262
263 integer rhs;
264 if( rhsBox.IsSignedIntegral () ) rhs= rhsBox.UnboxSignedIntegral () ;
265 else if( rhsBox.IsUnsignedIntegral() ) rhs= static_cast< integer>( rhsBox.UnboxUnsignedIntegral() );
266 else return false;
267
268 return self.UnboxSignedIntegral() == rhs;
269}
270
271bool FEquals_uinteger( const Box& self, const Box& rhsBox )
272{
273 if( rhsBox.IsFloatingPoint() )
274 return FEquals_double( rhsBox, self );
275
276 uinteger rhs;
277 if( rhsBox.IsSignedIntegral () ) rhs= uinteger( rhsBox.UnboxSignedIntegral () );
278 else if( rhsBox.IsUnsignedIntegral() ) rhs= rhsBox.UnboxUnsignedIntegral() ;
279 else return false;
280
281 return self.UnboxUnsignedIntegral() == rhs;
282}
283
284bool FEquals_char( const Box& self, const Box& rhs )
285{
286 if( !rhs.IsCharacter() )
287 return false;
288 return self.UnboxCharacter() == rhs.UnboxCharacter();
289}
290
291
292template<typename TChar>
293bool FEquals_TChar_Arr( const Box& lhs, const Box& rhs )
294{
295 if ( !rhs.IsArrayOf<TChar>() )
296 return false;
297
298 const TChar* compBuf= rhs.Data().GetPointer<TChar>();
299 const TChar* boxBuf= lhs.Data().GetPointer<TChar>();
300 if ( (boxBuf == nullptr) != (compBuf == nullptr) )
301 return false;
302
303 integer compLen= rhs.UnboxLength();
304 integer boxLen= lhs.UnboxLength();
305 if ( boxLen != compLen )
306 return false;
307
308 return 0 == characters::Compare <TChar>( boxBuf, compBuf, boxLen );
309}
310
311bool FIsLess_Default( const Box& box, const Box& comp )
312{
313 return std::type_index( box.TypeID() ) < std::type_index(comp.TypeID() )
314 || ( box.TypeID() == comp.TypeID()
315 &&box.Data().Integrals.UArray[0] < comp.Data().Integrals.UArray[0] );
316
317}
318
319#if !ALIB_FEAT_BOXING_BIJECTIVE_INTEGRALS
320bool FIsLess_integer( const Box& self, const Box& rhs )
321{
322 auto lhs= self.Data().Integrals.Array[0];
323 if( rhs.IsSameType( self ) ) return lhs < rhs.Unbox<integer > ();
324 if( rhs.IsType<uinteger>() ) return lhs < integer(rhs.Unbox<uinteger> ());
325 if( rhs.IsFloatingPoint() ) return double( lhs ) < rhs.UnboxFloatingPoint();
326
327 return std::type_index( self.TypeID() ) < std::type_index( rhs.TypeID() );
328}
329
330bool FIsLess_uinteger( const Box& self, const Box& rhs )
331{
332 auto lhs= self.Data().Integrals.UArray[0];
333 if( rhs.IsSameType( self ) ) return lhs < rhs.Data().Integrals.UArray[0] ;
334 if( rhs.IsType<integer> () ) return integer( lhs ) < rhs.Unbox<integer>();
335 if( rhs.IsFloatingPoint() ) return double ( lhs ) < rhs.UnboxFloatingPoint();
336
337 return std::type_index( self.TypeID() ) < std::type_index( rhs.TypeID() );
338}
339
340#else
341
342bool helperBijectiveLessS( integer selfVal, const Box& selfType, const Box& rhs )
343{
344 if( rhs.IsSignedIntegral () ) return selfVal < rhs.UnboxSignedIntegral () ;
345 if( rhs.IsUnsignedIntegral() ) return selfVal < integer(rhs.UnboxUnsignedIntegral());
346 if( rhs.IsFloatingPoint () ) return double( selfVal ) < rhs.UnboxFloatingPoint () ;
347
348 // no number?
349 return std::type_index( selfType.TypeID() ) < std::type_index( rhs.TypeID() );
350}
351
352bool helperBijectiveLessU( uinteger selfVal, const Box& selfType, const Box& rhs )
353{
354 if( rhs.IsSignedIntegral () ) return selfVal < uinteger(rhs.UnboxSignedIntegral ());
355 if( rhs.IsUnsignedIntegral() ) return selfVal < rhs.UnboxUnsignedIntegral() ;
356 if( rhs.IsFloatingPoint () ) return double(selfVal) < rhs.UnboxFloatingPoint () ;
357
358 // no number?
359 return std::type_index( selfType.TypeID() ) < std::type_index( rhs.TypeID() );
360}
361
362bool FIsLess_int8_t ( const Box& self, const Box& rhs ) { return helperBijectiveLessS( integer( self.Unbox< int8_t >() ), self, rhs ); }
363bool FIsLess_int16_t ( const Box& self, const Box& rhs ) { return helperBijectiveLessS( integer( self.Unbox< int16_t >() ), self, rhs ); }
364bool FIsLess_int32_t ( const Box& self, const Box& rhs ) { return helperBijectiveLessS( integer( self.Unbox< int32_t >() ), self, rhs ); }
365bool FIsLess_int64_t ( const Box& self, const Box& rhs ) { return helperBijectiveLessS( integer( self.Unbox< int64_t >() ), self, rhs ); }
366bool FIsLess_intGap_t ( const Box& self, const Box& rhs ) { return helperBijectiveLessS( integer( self.Unbox< intGap_t>() ), self, rhs ); }
367
368bool FIsLess_uint8_t ( const Box& self, const Box& rhs ) { return helperBijectiveLessU( uinteger( self.Unbox<uint8_t >() ), self, rhs ); }
369bool FIsLess_uint16_t ( const Box& self, const Box& rhs ) { return helperBijectiveLessU( uinteger( self.Unbox<uint16_t >() ), self, rhs ); }
370bool FIsLess_uint32_t ( const Box& self, const Box& rhs ) { return helperBijectiveLessU( uinteger( self.Unbox<uint32_t >() ), self, rhs ); }
371bool FIsLess_uint64_t ( const Box& self, const Box& rhs ) { return helperBijectiveLessU( uinteger( self.Unbox<uint64_t >() ), self, rhs ); }
372bool FIsLess_uintGap_t( const Box& self, const Box& rhs ) { return helperBijectiveLessU( uinteger( self.Unbox<uintGap_t>() ), self, rhs ); }
373
374#endif
375
376bool FIsLess_char( const Box& self, const Box& rhs )
377{
378 if( rhs.IsCharacter () )
379 return self.UnboxCharacter() < rhs.UnboxCharacter () ;
380
381 return std::type_index( self.TypeID() ) < std::type_index( rhs.TypeID() );
382}
383
384
385
386bool FIsLess_double( const Box& self, const Box& rhs )
387{
388 double lhs= self.Unbox<double>();
389 if( rhs.IsFloatingPoint () ) return lhs < rhs.UnboxFloatingPoint () ;
390 if( rhs.IsSignedIntegral () ) return lhs < double( rhs.UnboxSignedIntegral () );
391 if( rhs.IsUnsignedIntegral() ) return lhs < double( rhs.UnboxUnsignedIntegral() );
392
393 return std::type_index( self.TypeID() ) < std::type_index( rhs.TypeID() );
394}
395
396#if ALIB_FEAT_BOXING_BIJECTIVE_FLOATS
397 bool FIsLess_float( const Box& self, const Box& rhs )
398 {
399 float lhs= self.Unbox<float>();
400 if( rhs.IsType<float >() ) return lhs < rhs.Unbox<float >() ;
401 if( rhs.IsType<double >() ) return lhs < float( rhs.Unbox<double>() );
402 if( rhs.IsSignedIntegral () ) return lhs < float( rhs.UnboxSignedIntegral () );
403 if( rhs.IsUnsignedIntegral() ) return lhs < float( rhs.UnboxUnsignedIntegral() );
404
405 return std::type_index( self.TypeID() ) < std::type_index( rhs.TypeID() );
406 }
407#endif
408
409
410
411#if ALIB_MONOMEM
412
413void FClone_Default( Box& self, MonoAllocator& memory)
414{
415 if ( !self.IsArray() || self.UnboxLength() == 0)
416 return;
417
418 Placeholder& placeHolder= self.Data();
419 auto* src= placeHolder.GetPointer<char>();
420 if( src== nullptr || placeHolder.Integrals.Array[1] < 0 )
421 return;
422
423 size_t alignment= self.ArrayElementSize();
424 if( alignment > sizeof(std::ptrdiff_t) )
425 alignment= sizeof(std::ptrdiff_t);
426
427
428 placeHolder.SetPointer( memory().Alloc( self.ArrayElementSize() * placeHolder.Integrals.UArray[1],
429 alignment ) );
430 memcpy( placeHolder.GetPointer<char>(), src, self.ArrayElementSize() * placeHolder.Integrals.UArray[1] );
431}
432#endif
433
434// #################################################################################################
435bool FIsTrue_Default( const Box& self )
436{
437 if( self.IsArray() )
438 return self.UnboxLength() != 0;
439
440 // non-array types
441 unsigned int usedLen= self.GetPlaceholderUsageLength();
442
443 constexpr uinteger Bit1= uinteger( 1 );
444 // tests if smaller than first "word"
445 if( usedLen < sizeof( uinteger ) )
446 return ( self.Data().Integrals.UArray[0]
447 & ((Bit1 << (usedLen * 8) )- 1) ) != 0;
448
449 // test first word
450 if( self.Data().Integrals.UArray[0] != 0 )
451 return true;
452
453 if( usedLen == sizeof( uinteger ) )
454 return false;
455
456 // tests if smaller than second "word"
457 if( usedLen - sizeof( uinteger ) < sizeof( uinteger ) )
458 {
459 return ( self.Data().Integrals.UArray[1]
460 & ((Bit1 << (usedLen - sizeof(uinteger)) * 8 )- 1) ) != 0;
461 }
462
463 return self.Data().Integrals.UArray[1] != 0;
464}
465
466
467#if ALIB_STRINGS
468template<typename TChar>
469bool FIsLess_TChar_arr( const Box& lhs, const Box& rhs )
470{
471 if( rhs.IsArrayOf<TChar>() )
472 return lhs.Unbox<strings::TString<TChar>>() < rhs.Unbox<strings::TString<TChar>>();
473
474 return std::type_index( lhs.TypeID() ) < std::type_index(rhs.TypeID() );
475}
476
477
478template<typename TChar, typename TAllocator>
479void FAppend_Default( const Box& self, strings::TAString<TChar,TAllocator>& target)
480{
481 if( self.IsPointer() )
482 {
483 target << ALIB_REL_DBG( "PointerType", self.TypeID() )
484 << '(' << strings::TNumberFormat<TChar>::Computational.HexLiteralPrefix
485 << strings::THex<TChar>( self.Data().Integrals.UArray[0] )
486 << ')';
487 return;
488 }
489
490 if( self.IsEnum() )
491 {
492 target << ALIB_REL_DBG( "EnumType", self.TypeID() ) << '(' << self.Data().Integrals.Array[0] << ')';
493 return;
494 }
495
496 if( self.IsArray() )
497 {
498 target << ALIB_REL_DBG( "ArrayType", self.ElementTypeID() ) << '[' << self.UnboxLength() << ']';
499 return;
500 }
501
502 // value type
503 target << ALIB_REL_DBG( "ValueType", self.TypeID() ) << "(Size: " << self.GetPlaceholderUsageLength() << " bytes)";
504}
505
506
507template<typename TCharSrc, typename TChar, typename TAllocator>
508void FAppend_TcharArr( const Box& box, strings::TAString<TChar,TAllocator>& target )
509{
510 target.template Append<NC>( box.UnboxArray<TCharSrc>(), box.UnboxLength() );
511}
512
513#endif
514
515} // anonymous namespace
516} // namespace [alib::boxing]
517#endif //!DOXYGEN
518
519// #################################################################################################
520// Bootstrap()
521// #################################################################################################
522# include "ALib.Lang.CIFunctions.H"
523
524namespace alib::boxing{
525#if ALIB_DEBUG && !DOXYGEN
526namespace{ unsigned int initFlag= 0; }
527#endif // !DOXYGEN
528
529void shutdown() {
530 ALIB_ASSERT_ERROR( initFlag == 0x92A3EF61, "BOXING", "Not initialized when calling shutdown." )
531 ALIB_DBG(initFlag= 1);
532 detail::FunctionTable::Shutdown();
533 detail::FunctionTable::Shutdown();
534}
535
536void bootstrap()
537{
538 ALIB_ASSERT_ERROR( initFlag == 0, "BOXING", "This method must not be invoked twice." )
539 ALIB_DBG(initFlag= 0x92A3EF61);
540
541 //############### Debug-compilation checks ################
542 #if ALIB_DEBUG
543 // check size of long double
544 {
545 debug::LongDoubleTrueLengthSet();
546 debug::LONGDOUBLE_WRITE_TEST_MEM[0]= 0.0L;
547 ALIB_ASSERT_ERROR( debug::LongDoubleTrueLengthTest(), "BOXING",
548 "Platform not supported. SizeTraits<long double> contains wrong size" )
549 }
550 #endif
551
552 //############################# BootstrapRegister Static VTables #################################
553 ALIB_BOXING_BOOTSTRAP_VTABLE_DBG_REGISTER( vt_voidP )
554 ALIB_BOXING_BOOTSTRAP_VTABLE_DBG_REGISTER( vt_boxes )
555#if ALIB_MONOMEM
556 ALIB_BOXING_BOOTSTRAP_VTABLE_DBG_REGISTER( vt_boxesma )
557#endif
558 ALIB_BOXING_BOOTSTRAP_VTABLE_DBG_REGISTER( vt_boxarray )
559
560DOX_MARKER([DOX_BOXING_OPTIMIZE_REGISTER_1])
561ALIB_BOXING_BOOTSTRAP_VTABLE_DBG_REGISTER( vt_bool )
562DOX_MARKER([DOX_BOXING_OPTIMIZE_REGISTER_1])
563
564 #if !ALIB_FEAT_BOXING_BIJECTIVE_INTEGRALS
565 ALIB_BOXING_BOOTSTRAP_VTABLE_DBG_REGISTER( vt_integer )
566 ALIB_BOXING_BOOTSTRAP_VTABLE_DBG_REGISTER( vt_uinteger )
567 #else
568 ALIB_BOXING_BOOTSTRAP_VTABLE_DBG_REGISTER( vt_int8_t )
569 ALIB_BOXING_BOOTSTRAP_VTABLE_DBG_REGISTER( vt_uint8_t )
570 ALIB_BOXING_BOOTSTRAP_VTABLE_DBG_REGISTER( vt_int16_t )
571 ALIB_BOXING_BOOTSTRAP_VTABLE_DBG_REGISTER( vt_uint16_t )
572 ALIB_BOXING_BOOTSTRAP_VTABLE_DBG_REGISTER( vt_int32_t )
573 ALIB_BOXING_BOOTSTRAP_VTABLE_DBG_REGISTER( vt_uint32_t )
574 ALIB_BOXING_BOOTSTRAP_VTABLE_DBG_REGISTER( vt_intGap_t )
575 ALIB_BOXING_BOOTSTRAP_VTABLE_DBG_REGISTER( vt_uintGap_t )
576 #if ALIB_SIZEOF_INTEGER == 8
577 ALIB_BOXING_BOOTSTRAP_VTABLE_DBG_REGISTER( vt_int64_t )
578 ALIB_BOXING_BOOTSTRAP_VTABLE_DBG_REGISTER( vt_uint64_t )
579 #endif
580 #endif // !ALIB_FEAT_BOXING_BIJECTIVE_INTEGRALS
581
582 ALIB_BOXING_BOOTSTRAP_VTABLE_DBG_REGISTER( vt_double )
583 #if ALIB_SIZEOF_LONGDOUBLE_REPORTED <= 2 * ALIB_SIZEOF_INTEGER
584 ALIB_BOXING_BOOTSTRAP_VTABLE_DBG_REGISTER( vt_long_double )
585 #endif
586 #if ALIB_FEAT_BOXING_BIJECTIVE_FLOATS
587 ALIB_BOXING_BOOTSTRAP_VTABLE_DBG_REGISTER( vt_float )
588 #endif
589
590
591 #if !ALIB_FEAT_BOXING_BIJECTIVE_CHARACTERS
592 ALIB_BOXING_BOOTSTRAP_VTABLE_DBG_REGISTER( vt_wchar )
593 #else
594 ALIB_BOXING_BOOTSTRAP_VTABLE_DBG_REGISTER( vt_char )
595 ALIB_BOXING_BOOTSTRAP_VTABLE_DBG_REGISTER( vt_wchar_t )
596 ALIB_BOXING_BOOTSTRAP_VTABLE_DBG_REGISTER( vt_char8_t )
597 ALIB_BOXING_BOOTSTRAP_VTABLE_DBG_REGISTER( vt_char16_t )
598 ALIB_BOXING_BOOTSTRAP_VTABLE_DBG_REGISTER( vt_char32_t )
599 #endif
600
601DOX_MARKER([DOX_BOXING_OPTIMIZE_REGISTER_2])
602ALIB_BOXING_BOOTSTRAP_VTABLE_DBG_REGISTER( vt_arr_char )
603DOX_MARKER([DOX_BOXING_OPTIMIZE_REGISTER_2])
604
605 ALIB_BOXING_BOOTSTRAP_VTABLE_DBG_REGISTER( vt_arr_wchar_t )
606 ALIB_BOXING_BOOTSTRAP_VTABLE_DBG_REGISTER( vt_arr_char8_t )
607 ALIB_BOXING_BOOTSTRAP_VTABLE_DBG_REGISTER( vt_arr_char16_t )
608 ALIB_BOXING_BOOTSTRAP_VTABLE_DBG_REGISTER( vt_arr_char32_t )
609
610 // Static VTables for standard types
611 ALIB_BOXING_BOOTSTRAP_VTABLE_DBG_REGISTER( vt_std_type_info )
612
613 // CodeMarker_CommonEnums
614 // Static VTables for low-level ALib types
615 ALIB_BOXING_BOOTSTRAP_VTABLE_DBG_REGISTER( vt_alib_Alignment )
616 ALIB_BOXING_BOOTSTRAP_VTABLE_DBG_REGISTER( vt_alib_Bool )
617 ALIB_BOXING_BOOTSTRAP_VTABLE_DBG_REGISTER( vt_alib_Caching )
618 ALIB_BOXING_BOOTSTRAP_VTABLE_DBG_REGISTER( vt_alib_Case )
619 ALIB_BOXING_BOOTSTRAP_VTABLE_DBG_REGISTER( vt_alib_ContainerOp )
620 ALIB_BOXING_BOOTSTRAP_VTABLE_DBG_REGISTER( vt_alib_CreateDefaults )
621 ALIB_BOXING_BOOTSTRAP_VTABLE_DBG_REGISTER( vt_alib_CreateIfNotExists )
622 ALIB_BOXING_BOOTSTRAP_VTABLE_DBG_REGISTER( vt_alib_CurrentData )
623 ALIB_BOXING_BOOTSTRAP_VTABLE_DBG_REGISTER( vt_alib_Inclusion )
624 ALIB_BOXING_BOOTSTRAP_VTABLE_DBG_REGISTER( vt_alib_Initialization )
625 ALIB_BOXING_BOOTSTRAP_VTABLE_DBG_REGISTER( vt_alib_Phase )
626 ALIB_BOXING_BOOTSTRAP_VTABLE_DBG_REGISTER( vt_alib_Propagation )
627 ALIB_BOXING_BOOTSTRAP_VTABLE_DBG_REGISTER( vt_alib_Reach )
628 ALIB_BOXING_BOOTSTRAP_VTABLE_DBG_REGISTER( vt_alib_Responsibility )
629 ALIB_BOXING_BOOTSTRAP_VTABLE_DBG_REGISTER( vt_alib_Safeness )
630 ALIB_BOXING_BOOTSTRAP_VTABLE_DBG_REGISTER( vt_alib_Side )
631 ALIB_BOXING_BOOTSTRAP_VTABLE_DBG_REGISTER( vt_alib_SortOrder )
632 ALIB_BOXING_BOOTSTRAP_VTABLE_DBG_REGISTER( vt_alib_SourceData )
633 ALIB_BOXING_BOOTSTRAP_VTABLE_DBG_REGISTER( vt_alib_Switch )
634 ALIB_BOXING_BOOTSTRAP_VTABLE_DBG_REGISTER( vt_alib_Timezone )
635 ALIB_BOXING_BOOTSTRAP_VTABLE_DBG_REGISTER( vt_alib_Timing )
636 ALIB_BOXING_BOOTSTRAP_VTABLE_DBG_REGISTER( vt_alib_ValueReference )
637 ALIB_BOXING_BOOTSTRAP_VTABLE_DBG_REGISTER( vt_alib_Whitespaces )
638
639 ALIB_BOXING_BOOTSTRAP_VTABLE_DBG_REGISTER( vt_lang_callerinfo )
640 #if !ALIB_SINGLE_THREADED
641 ALIB_BOXING_BOOTSTRAP_VTABLE_DBG_REGISTER( vt_threads_tp )
642 #endif
643 ALIB_BOXING_BOOTSTRAP_VTABLE_DBG_REGISTER( vt_time_ticks )
644 ALIB_BOXING_BOOTSTRAP_VTABLE_DBG_REGISTER( vt_time_ticks_duration )
645 ALIB_BOXING_BOOTSTRAP_VTABLE_DBG_REGISTER( vt_time_datetime )
646 ALIB_BOXING_BOOTSTRAP_VTABLE_DBG_REGISTER( vt_time_datetime_duration )
647
648
649 #if ALIB_STRINGS
650 ALIB_BOXING_BOOTSTRAP_VTABLE_DBG_REGISTER( vt_alib_wrapped_tanstring )
651 ALIB_BOXING_BOOTSTRAP_VTABLE_DBG_REGISTER( vt_alib_wrapped_tawstring )
652 ALIB_BOXING_BOOTSTRAP_VTABLE_DBG_REGISTER( vt_alib_wrapped_taxstring )
653 ALIB_BOXING_BOOTSTRAP_VTABLE_DBG_REGISTER( vt_alib_strings_token )
654 #endif
655
656 #if ALIB_SYSTEM
657 ALIB_BOXING_BOOTSTRAP_VTABLE_DBG_REGISTER( vt_system_systemerrors )
658 ALIB_BOXING_BOOTSTRAP_VTABLE_DBG_REGISTER( vt_system_path )
659 #endif
660 #if ALIB_EXCEPTIONS
661 ALIB_BOXING_BOOTSTRAP_VTABLE_DBG_REGISTER( vt_alib_exception )
662 #endif
663 #if ALIB_VARIABLES
664 ALIB_BOXING_BOOTSTRAP_VTABLE_DBG_REGISTER( vt_config_priorities )
665 ALIB_BOXING_BOOTSTRAP_VTABLE_DBG_REGISTER( vt_config_exceptions )
666 ALIB_BOXING_BOOTSTRAP_VTABLE_DBG_REGISTER( vt_config_variable )
667 ALIB_BOXING_BOOTSTRAP_VTABLE_DBG_REGISTER( vt_config_constcursor )
668 #endif
669 #if ALIB_FORMAT
670 ALIB_BOXING_BOOTSTRAP_VTABLE_DBG_REGISTER( vt_system_fmtexceptions)
671 ALIB_BOXING_BOOTSTRAP_VTABLE_DBG_REGISTER( vt_lang_format_bytesize_iec )
672 ALIB_BOXING_BOOTSTRAP_VTABLE_DBG_REGISTER( vt_lang_format_bytesize_si )
673 ALIB_BOXING_BOOTSTRAP_VTABLE_DBG_REGISTER( vt_lang_format_bytesize_units )
674 #endif
675
676 #if ALIB_CLI
677 ALIB_BOXING_BOOTSTRAP_VTABLE_DBG_REGISTER( vt_cli_exceptions )
678 #endif
679
680 #if ALIB_ALOX
681 ALIB_BOXING_BOOTSTRAP_VTABLE_DBG_REGISTER( vt_lox_verbosity )
682 ALIB_BOXING_BOOTSTRAP_VTABLE_DBG_REGISTER( vt_lox_scope )
683 ALIB_BOXING_BOOTSTRAP_VTABLE_DBG_REGISTER( vt_lox_logger )
684 ALIB_BOXING_BOOTSTRAP_VTABLE_DBG_REGISTER( vt_lox_pair_verby_prio )
685 #endif
686
687 #if ALIB_EXPRESSIONS
688 ALIB_BOXING_BOOTSTRAP_VTABLE_DBG_REGISTER( vt_expressions_exceptions )
689 #endif
690
691 #if ALIB_FILES
692 ALIB_BOXING_BOOTSTRAP_VTABLE_DBG_REGISTER( vt_files_cursor )
693 ALIB_BOXING_BOOTSTRAP_VTABLE_DBG_REGISTER( vt_files_perms )
694 ALIB_BOXING_BOOTSTRAP_VTABLE_DBG_REGISTER( vt_files_type )
695 ALIB_BOXING_BOOTSTRAP_VTABLE_DBG_REGISTER( vt_files_type1 )
696 ALIB_BOXING_BOOTSTRAP_VTABLE_DBG_REGISTER( vt_files_type2 )
697 ALIB_BOXING_BOOTSTRAP_VTABLE_DBG_REGISTER( vt_files_type3 )
698 ALIB_BOXING_BOOTSTRAP_VTABLE_DBG_REGISTER( vt_files_qual )
699 ALIB_BOXING_BOOTSTRAP_VTABLE_DBG_REGISTER( vt_files_qual3 )
700 #endif
701
702 //######################## Register default implementations #######################
703 BootstrapRegisterDefault<FIsTrue >( FIsTrue_Default );
704 BootstrapRegisterDefault<FIsNotNull >( FIsNotNull_Default );
705 BootstrapRegisterDefault<FIsLess >( FIsLess_Default );
706 BootstrapRegisterDefault<FHashcode >( FHashcode_Default );
707 BootstrapRegisterDefault<FEquals >( FEquals_Default );
708IF_ALIB_MONOMEM(
709 BootstrapRegisterDefault<FClone >( FClone_Default ); )
710
711 // ################################ IsNotNull ##########################################
712 BootstrapRegister<FIsNotNull, bool >( FIsNotNull::ConstantTrue );
713 #if !ALIB_FEAT_BOXING_BIJECTIVE_INTEGRALS
714 BootstrapRegister<FIsNotNull, integer >( FIsNotNull::ConstantTrue );
715 BootstrapRegister<FIsNotNull, uinteger >( FIsNotNull::ConstantTrue );
716 #else
717 BootstrapRegister<FIsNotNull, int8_t >( FIsNotNull::ConstantTrue );
718 BootstrapRegister<FIsNotNull, uint8_t >( FIsNotNull::ConstantTrue );
719 BootstrapRegister<FIsNotNull, int16_t >( FIsNotNull::ConstantTrue );
720 BootstrapRegister<FIsNotNull, uint16_t >( FIsNotNull::ConstantTrue );
721 BootstrapRegister<FIsNotNull, int32_t >( FIsNotNull::ConstantTrue );
722 BootstrapRegister<FIsNotNull, uint32_t >( FIsNotNull::ConstantTrue );
723 BootstrapRegister<FIsNotNull, int64_t >( FIsNotNull::ConstantTrue );
724 BootstrapRegister<FIsNotNull, uint64_t >( FIsNotNull::ConstantTrue );
725 BootstrapRegister<FIsNotNull, intGap_t >( FIsNotNull::ConstantTrue );
726 BootstrapRegister<FIsNotNull, uintGap_t >( FIsNotNull::ConstantTrue );
727 #endif
728
729 #if !ALIB_FEAT_BOXING_BIJECTIVE_CHARACTERS
730 BootstrapRegister<FIsNotNull, wchar >( FIsNotNull::ConstantTrue );
731 #else
732 BootstrapRegister<FIsNotNull, char >( FIsNotNull::ConstantTrue );
733 BootstrapRegister<FIsNotNull, wchar_t >( FIsNotNull::ConstantTrue );
734 BootstrapRegister<FIsNotNull, char8_t >( FIsNotNull::ConstantTrue );
735 BootstrapRegister<FIsNotNull, char16_t >( FIsNotNull::ConstantTrue );
736 BootstrapRegister<FIsNotNull, char32_t >( FIsNotNull::ConstantTrue );
737 #endif
738
739
740 #if ALIB_FEAT_BOXING_BIJECTIVE_FLOATS
741 BootstrapRegister<FIsNotNull, float >( FIsNotNull::ConstantTrue );
742 #endif
743 BootstrapRegister<FIsNotNull, double >( FIsNotNull::ConstantTrue );
744
745 // ################################ Hashcode ##########################################
746 BootstrapRegister<FHashcode, bool >( FHashcode::UsePlaceholderBytes<sizeof(bool )> );
747 #if !ALIB_FEAT_BOXING_BIJECTIVE_INTEGRALS
748 BootstrapRegister<FHashcode, integer >( FHashcode::UsePlaceholderBytes<sizeof( integer )> );
749 BootstrapRegister<FHashcode, uinteger >( FHashcode::UsePlaceholderBytes<sizeof(uinteger )> );
750 #else
751 BootstrapRegister<FHashcode, int8_t >( FHashcode::UsePlaceholderBytes<sizeof( int8_t )> );
752 BootstrapRegister<FHashcode, uint8_t >( FHashcode::UsePlaceholderBytes<sizeof(uint8_t )> );
753 BootstrapRegister<FHashcode, int16_t >( FHashcode::UsePlaceholderBytes<sizeof( int16_t )> );
754 BootstrapRegister<FHashcode, uint16_t >( FHashcode::UsePlaceholderBytes<sizeof(uint16_t )> );
755 BootstrapRegister<FHashcode, int32_t >( FHashcode::UsePlaceholderBytes<sizeof( int32_t )> );
756 BootstrapRegister<FHashcode, uint32_t >( FHashcode::UsePlaceholderBytes<sizeof(uint32_t )> );
757 BootstrapRegister<FHashcode, int64_t >( FHashcode::UsePlaceholderBytes<sizeof( int64_t )> );
758 BootstrapRegister<FHashcode, uint64_t >( FHashcode::UsePlaceholderBytes<sizeof(uint64_t )> );
759 BootstrapRegister<FHashcode, intGap_t >( FHashcode::UsePlaceholderBytes<sizeof( intGap_t)> );
760 BootstrapRegister<FHashcode, uintGap_t >( FHashcode::UsePlaceholderBytes<sizeof(uintGap_t)> );
761 #endif
762
763 #if !ALIB_FEAT_BOXING_BIJECTIVE_CHARACTERS
764 BootstrapRegister<FHashcode, wchar >( FHashcode::UsePlaceholderBytes<sizeof(wchar )> );
765 #else
766 BootstrapRegister<FHashcode, char >( FHashcode::UsePlaceholderBytes<sizeof(char )> );
767 BootstrapRegister<FHashcode, wchar_t >( FHashcode::UsePlaceholderBytes<sizeof(wchar_t )> );
768 BootstrapRegister<FHashcode, char8_t >( FHashcode::UsePlaceholderBytes<sizeof(char16_t )> );
769 BootstrapRegister<FHashcode, char16_t >( FHashcode::UsePlaceholderBytes<sizeof(char16_t )> );
770 BootstrapRegister<FHashcode, char32_t >( FHashcode::UsePlaceholderBytes<sizeof(char32_t )> );
771 #endif
772
773
774 #if ALIB_FEAT_BOXING_BIJECTIVE_FLOATS
775 BootstrapRegister<FHashcode, float >( FHashcode::UsePlaceholderBytes<sizeof(float )> );
776 #endif
777 BootstrapRegister<FHashcode, double >( FHashcode::UsePlaceholderBytes<sizeof(double )> );
778 BootstrapRegister<FHashcode, long double>( FHashcode::UsePlaceholderBytes<SizeTraits<long double>> );
779
780
781 // ################################ Equals ###########################################
782 BootstrapRegister<FEquals , bool >( FEquals::ComparableTypes<bool> );
783
784 #if !ALIB_FEAT_BOXING_BIJECTIVE_INTEGRALS
785 BootstrapRegister<FEquals , integer >( FEquals_integer );
786 BootstrapRegister<FEquals , uinteger >( FEquals_uinteger );
787 #else
788 BootstrapRegister<FEquals , int8_t >( FEquals_integer );
789 BootstrapRegister<FEquals , uint8_t >( FEquals_uinteger );
790 BootstrapRegister<FEquals , int16_t >( FEquals_integer );
791 BootstrapRegister<FEquals , uint16_t >( FEquals_uinteger );
792 BootstrapRegister<FEquals , int32_t >( FEquals_integer );
793 BootstrapRegister<FEquals , uint32_t >( FEquals_uinteger );
794 BootstrapRegister<FEquals , int64_t >( FEquals_integer );
795 BootstrapRegister<FEquals , uint64_t >( FEquals_uinteger );
796 BootstrapRegister<FEquals , intGap_t >( FEquals_integer );
797 BootstrapRegister<FEquals , uintGap_t >( FEquals_uinteger );
798 #endif
799
800 #if ALIB_FEAT_BOXING_BIJECTIVE_FLOATS
801 BootstrapRegister<FEquals , float >( FEquals_double );
802 #endif
803 BootstrapRegister<FEquals , double >( FEquals_double );
804 BootstrapRegister<FEquals , long double>( FEquals_double );
805
806
807 #if !ALIB_FEAT_BOXING_BIJECTIVE_CHARACTERS
808 BootstrapRegister<FEquals , wchar >( FEquals_char );
809 #else
810 BootstrapRegister<FEquals , char >( FEquals_char );
811 BootstrapRegister<FEquals , wchar_t >( FEquals_char );
812 BootstrapRegister<FEquals , char8_t >( FEquals_char );
813 BootstrapRegister<FEquals , char16_t >( FEquals_char );
814 BootstrapRegister<FEquals , char32_t >( FEquals_char );
815 #endif
816
817 BootstrapRegister<FEquals , nchar,true >( FEquals_TChar_Arr<nchar>);
818 BootstrapRegister<FEquals , wchar,true >( FEquals_TChar_Arr<wchar>);
819 BootstrapRegister<FEquals , xchar,true >( FEquals_TChar_Arr<xchar>);
820
821 // ################################ IsLess ###########################################
822 #if !ALIB_FEAT_BOXING_BIJECTIVE_INTEGRALS
823 BootstrapRegister<FIsLess , integer >( FIsLess_integer );
824 BootstrapRegister<FIsLess , uinteger >( FIsLess_uinteger);
825 #else
826 BootstrapRegister<FIsLess , int8_t >( FIsLess_int8_t );
827 BootstrapRegister<FIsLess , uint8_t >( FIsLess_uint8_t );
828 BootstrapRegister<FIsLess , int16_t >( FIsLess_int16_t );
829 BootstrapRegister<FIsLess , uint16_t >( FIsLess_uint16_t );
830 BootstrapRegister<FIsLess , int32_t >( FIsLess_int32_t );
831 BootstrapRegister<FIsLess , uint32_t >( FIsLess_uint32_t );
832 BootstrapRegister<FIsLess , int64_t >( FIsLess_int64_t );
833 BootstrapRegister<FIsLess , uint64_t >( FIsLess_uint64_t );
834 BootstrapRegister<FIsLess , intGap_t >( FIsLess_intGap_t );
835 BootstrapRegister<FIsLess , uintGap_t >( FIsLess_uintGap_t);
836 #endif
837
838 #if ALIB_FEAT_BOXING_BIJECTIVE_FLOATS
839 BootstrapRegister<FIsLess , float >( FIsLess_float );
840 #endif
841 BootstrapRegister<FIsLess , double >( FIsLess_double );
842 BootstrapRegister<FIsLess , long double>( FIsLess_double );
843
844 #if !ALIB_FEAT_BOXING_BIJECTIVE_CHARACTERS
845 BootstrapRegister<FIsLess , wchar >( FIsLess_char );
846 #else
847 BootstrapRegister<FIsLess , char >( FIsLess_char );
848 BootstrapRegister<FIsLess , wchar_t >( FIsLess_char );
849 BootstrapRegister<FIsLess , char8_t >( FIsLess_char );
850 BootstrapRegister<FIsLess , char16_t >( FIsLess_char );
851 BootstrapRegister<FIsLess , char32_t >( FIsLess_char );
852 #endif
853
854
855 // #############################################################################################
856 // ########################## Strings And Boxing ###################################
857 // #############################################################################################
858#if ALIB_STRINGS
859 // register functions interface implementations
860 BootstrapRegister<FIsLess, nchar,true >( FIsLess_TChar_arr<nchar> );
861 BootstrapRegister<FIsLess, wchar,true >( FIsLess_TChar_arr<wchar> );
862 BootstrapRegister<FIsLess, xchar,true >( FIsLess_TChar_arr<xchar> );
863
864 // register functions of type FAppend
865 BootstrapRegisterDefault<FAppend<character , lang::HeapAllocator>>( FAppend_Default<character , lang::HeapAllocator> );
866 BootstrapRegisterDefault<FAppend<complementChar, lang::HeapAllocator>>( FAppend_Default<complementChar, lang::HeapAllocator> );
867 BootstrapRegisterDefault<FAppend<strangeChar , lang::HeapAllocator>>( FAppend_Default<strangeChar , lang::HeapAllocator> );
868
869 BootstrapRegister<FAppend<nchar, lang::HeapAllocator>, bool >(FAppend<nchar, lang::HeapAllocator>::Appendable< bool >);
870 BootstrapRegister<FAppend<wchar, lang::HeapAllocator>, bool >(FAppend<wchar, lang::HeapAllocator>::Appendable< bool >);
871
872 #if !ALIB_FEAT_BOXING_BIJECTIVE_CHARACTERS
873 BootstrapRegister<FAppend<nchar, lang::HeapAllocator>, wchar >(FAppend<nchar, lang::HeapAllocator>::Appendable< wchar >);
874 BootstrapRegister<FAppend<wchar, lang::HeapAllocator>, wchar >(FAppend<wchar, lang::HeapAllocator>::Appendable< wchar >);
875 #else
876 BootstrapRegister<FAppend<nchar, lang::HeapAllocator>, nchar >(FAppend<nchar, lang::HeapAllocator>::Appendable< nchar >);
877 BootstrapRegister<FAppend<wchar, lang::HeapAllocator>, nchar >(FAppend<wchar, lang::HeapAllocator>::Appendable< nchar >);
878 BootstrapRegister<FAppend<nchar, lang::HeapAllocator>, wchar >(FAppend<nchar, lang::HeapAllocator>::Appendable< wchar >);
879 BootstrapRegister<FAppend<wchar, lang::HeapAllocator>, wchar >(FAppend<wchar, lang::HeapAllocator>::Appendable< wchar >);
880 BootstrapRegister<FAppend<nchar, lang::HeapAllocator>, xchar >(FAppend<nchar, lang::HeapAllocator>::Appendable< xchar >);
881 BootstrapRegister<FAppend<wchar, lang::HeapAllocator>, xchar >(FAppend<wchar, lang::HeapAllocator>::Appendable< xchar >);
882 #endif
883
884 #if !ALIB_FEAT_BOXING_BIJECTIVE_INTEGRALS
885 BootstrapRegister<FAppend<nchar, lang::HeapAllocator>, integer >(FAppend<nchar, lang::HeapAllocator>::Appendable<integer >);
886 BootstrapRegister<FAppend<wchar, lang::HeapAllocator>, integer >(FAppend<wchar, lang::HeapAllocator>::Appendable<integer >);
887 BootstrapRegister<FAppend<nchar, lang::HeapAllocator>, uinteger >(FAppend<nchar, lang::HeapAllocator>::Appendable<uinteger >);
888 BootstrapRegister<FAppend<wchar, lang::HeapAllocator>, uinteger >(FAppend<wchar, lang::HeapAllocator>::Appendable<uinteger >);
889 #else
890 BootstrapRegister<FAppend<nchar, lang::HeapAllocator>, int8_t >(FAppend<nchar, lang::HeapAllocator>::Appendable< int8_t >);
891 BootstrapRegister<FAppend<wchar, lang::HeapAllocator>, int8_t >(FAppend<wchar, lang::HeapAllocator>::Appendable< int8_t >);
892 BootstrapRegister<FAppend<nchar, lang::HeapAllocator>, int16_t >(FAppend<nchar, lang::HeapAllocator>::Appendable< int16_t >);
893 BootstrapRegister<FAppend<wchar, lang::HeapAllocator>, int16_t >(FAppend<wchar, lang::HeapAllocator>::Appendable< int16_t >);
894 BootstrapRegister<FAppend<nchar, lang::HeapAllocator>, int32_t >(FAppend<nchar, lang::HeapAllocator>::Appendable< int32_t >);
895 BootstrapRegister<FAppend<wchar, lang::HeapAllocator>, int32_t >(FAppend<wchar, lang::HeapAllocator>::Appendable< int32_t >);
896 BootstrapRegister<FAppend<nchar, lang::HeapAllocator>, int64_t >(FAppend<nchar, lang::HeapAllocator>::Appendable< int64_t >);
897 BootstrapRegister<FAppend<wchar, lang::HeapAllocator>, int64_t >(FAppend<wchar, lang::HeapAllocator>::Appendable< int64_t >);
898 BootstrapRegister<FAppend<nchar, lang::HeapAllocator>, intGap_t>(FAppend<nchar, lang::HeapAllocator>::Appendable< intGap_t>);
899 BootstrapRegister<FAppend<wchar, lang::HeapAllocator>, intGap_t>(FAppend<wchar, lang::HeapAllocator>::Appendable< intGap_t>);
900 BootstrapRegister<FAppend<nchar, lang::HeapAllocator>, uint8_t >(FAppend<nchar, lang::HeapAllocator>::Appendable<uint8_t >);
901 BootstrapRegister<FAppend<wchar, lang::HeapAllocator>, uint8_t >(FAppend<wchar, lang::HeapAllocator>::Appendable<uint8_t >);
902 BootstrapRegister<FAppend<nchar, lang::HeapAllocator>, uint16_t >(FAppend<nchar, lang::HeapAllocator>::Appendable<uint16_t >);
903 BootstrapRegister<FAppend<wchar, lang::HeapAllocator>, uint16_t >(FAppend<wchar, lang::HeapAllocator>::Appendable<uint16_t >);
904 BootstrapRegister<FAppend<nchar, lang::HeapAllocator>, uint32_t >(FAppend<nchar, lang::HeapAllocator>::Appendable<uint32_t >);
905 BootstrapRegister<FAppend<wchar, lang::HeapAllocator>, uint32_t >(FAppend<wchar, lang::HeapAllocator>::Appendable<uint32_t >);
906 BootstrapRegister<FAppend<nchar, lang::HeapAllocator>, uint64_t >(FAppend<nchar, lang::HeapAllocator>::Appendable<uint64_t >);
907 BootstrapRegister<FAppend<wchar, lang::HeapAllocator>, uint64_t >(FAppend<wchar, lang::HeapAllocator>::Appendable<uint64_t >);
908 BootstrapRegister<FAppend<nchar, lang::HeapAllocator>, uintGap_t>(FAppend<nchar, lang::HeapAllocator>::Appendable<uintGap_t>);
909 BootstrapRegister<FAppend<wchar, lang::HeapAllocator>, uintGap_t>(FAppend<wchar, lang::HeapAllocator>::Appendable<uintGap_t>);
910 #endif
911
912 BootstrapRegister<FAppend<nchar, lang::HeapAllocator>, double>(FAppend<nchar, lang::HeapAllocator>::Appendable<double>);
913 BootstrapRegister<FAppend<wchar, lang::HeapAllocator>, double>(FAppend<wchar, lang::HeapAllocator>::Appendable<double>);
914 #if ALIB_FEAT_BOXING_BIJECTIVE_FLOATS
915 BootstrapRegister<FAppend<nchar, lang::HeapAllocator>, float >(FAppend<nchar, lang::HeapAllocator>::Appendable<float >);
916 BootstrapRegister<FAppend<wchar, lang::HeapAllocator>, float >(FAppend<wchar, lang::HeapAllocator>::Appendable<float >);
917 #endif
918 if constexpr (sizeof(long double) <= sizeof(Placeholder) )
919 {
920 BootstrapRegister<FAppend<nchar, lang::HeapAllocator>, long double>(FAppend<nchar, lang::HeapAllocator>::Appendable<long double>);
921 BootstrapRegister<FAppend<wchar, lang::HeapAllocator>, long double>(FAppend<wchar, lang::HeapAllocator>::Appendable<long double>);
922 }
923 BootstrapRegister<FAppend<nchar, lang::HeapAllocator>, nchar ,true>(FAppend_TcharArr<nchar, nchar, lang::HeapAllocator>);
924 BootstrapRegister<FAppend<nchar, lang::HeapAllocator>, wchar ,true>(FAppend_TcharArr<wchar, nchar, lang::HeapAllocator>);
925 BootstrapRegister<FAppend<nchar, lang::HeapAllocator>, xchar ,true>(FAppend_TcharArr<xchar, nchar, lang::HeapAllocator>);
926 BootstrapRegister<FAppend<wchar, lang::HeapAllocator>, nchar ,true>(FAppend_TcharArr<nchar, wchar, lang::HeapAllocator>);
927 BootstrapRegister<FAppend<wchar, lang::HeapAllocator>, wchar ,true>(FAppend_TcharArr<wchar, wchar, lang::HeapAllocator>);
928 BootstrapRegister<FAppend<wchar, lang::HeapAllocator>, xchar ,true>(FAppend_TcharArr<xchar, wchar, lang::HeapAllocator>);
929 BootstrapRegister<FAppend<xchar, lang::HeapAllocator>, nchar ,true>(FAppend_TcharArr<nchar, xchar, lang::HeapAllocator>);
930 BootstrapRegister<FAppend<xchar, lang::HeapAllocator>, wchar ,true>(FAppend_TcharArr<wchar, xchar, lang::HeapAllocator>);
931 BootstrapRegister<FAppend<xchar, lang::HeapAllocator>, xchar ,true>(FAppend_TcharArr<xchar, xchar, lang::HeapAllocator>);
932
933 BootstrapRegister<FAppend<nchar, lang::HeapAllocator>, std::reference_wrapper<NAString>>(FAppend<nchar, lang::HeapAllocator>::WrappedAppendable<NAString>);
934 BootstrapRegister<FAppend<nchar, lang::HeapAllocator>, std::reference_wrapper<WAString>>(FAppend<nchar, lang::HeapAllocator>::WrappedAppendable<WAString>);
935 BootstrapRegister<FAppend<nchar, lang::HeapAllocator>, std::reference_wrapper<XAString>>(FAppend<nchar, lang::HeapAllocator>::WrappedAppendable<XAString>);
936 BootstrapRegister<FAppend<wchar, lang::HeapAllocator>, std::reference_wrapper<NAString>>(FAppend<wchar, lang::HeapAllocator>::WrappedAppendable<NAString>);
937 BootstrapRegister<FAppend<wchar, lang::HeapAllocator>, std::reference_wrapper<WAString>>(FAppend<wchar, lang::HeapAllocator>::WrappedAppendable<WAString>);
938 BootstrapRegister<FAppend<wchar, lang::HeapAllocator>, std::reference_wrapper<XAString>>(FAppend<wchar, lang::HeapAllocator>::WrappedAppendable<XAString>);
939 BootstrapRegister<FAppend<xchar, lang::HeapAllocator>, std::reference_wrapper<NAString>>(FAppend<xchar, lang::HeapAllocator>::WrappedAppendable<NAString>);
940 BootstrapRegister<FAppend<xchar, lang::HeapAllocator>, std::reference_wrapper<WAString>>(FAppend<xchar, lang::HeapAllocator>::WrappedAppendable<WAString>);
941 BootstrapRegister<FAppend<xchar, lang::HeapAllocator>, std::reference_wrapper<XAString>>(FAppend<xchar, lang::HeapAllocator>::WrappedAppendable<XAString>);
942
943 ALIB_BOXING_BOOTSTRAP_REGISTER_FAPPEND_FOR_APPENDABLE_TYPE_N( time::DateTime::Duration )
944 ALIB_BOXING_BOOTSTRAP_REGISTER_FAPPEND_FOR_APPENDABLE_TYPE_W( time::DateTime::Duration )
945 ALIB_BOXING_BOOTSTRAP_REGISTER_FAPPEND_FOR_APPENDABLE_TYPE_X( time::DateTime::Duration )
946 ALIB_BOXING_BOOTSTRAP_REGISTER_FAPPEND_FOR_APPENDABLE_TYPE_N( time::Ticks ::Duration )
947 ALIB_BOXING_BOOTSTRAP_REGISTER_FAPPEND_FOR_APPENDABLE_TYPE_W( time::Ticks ::Duration )
948 ALIB_BOXING_BOOTSTRAP_REGISTER_FAPPEND_FOR_APPENDABLE_TYPE_X( time::Ticks ::Duration )
949
950 // CodeMarker_CommonEnums
951 #if ALIB_ENUMRECORDS
952 ALIB_BOXING_BOOTSTRAP_REGISTER_FAPPEND_FOR_APPENDABLE_TYPE( lang::Alignment )
953 ALIB_BOXING_BOOTSTRAP_REGISTER_FAPPEND_FOR_APPENDABLE_TYPE( lang::Bool )
954 ALIB_BOXING_BOOTSTRAP_REGISTER_FAPPEND_FOR_APPENDABLE_TYPE( lang::Caching )
955 ALIB_BOXING_BOOTSTRAP_REGISTER_FAPPEND_FOR_APPENDABLE_TYPE( lang::Case )
956 ALIB_BOXING_BOOTSTRAP_REGISTER_FAPPEND_FOR_APPENDABLE_TYPE( lang::ContainerOp )
957 ALIB_BOXING_BOOTSTRAP_REGISTER_FAPPEND_FOR_APPENDABLE_TYPE( lang::CreateDefaults )
958 ALIB_BOXING_BOOTSTRAP_REGISTER_FAPPEND_FOR_APPENDABLE_TYPE( lang::CreateIfNotExists)
959 ALIB_BOXING_BOOTSTRAP_REGISTER_FAPPEND_FOR_APPENDABLE_TYPE( lang::CurrentData )
960 ALIB_BOXING_BOOTSTRAP_REGISTER_FAPPEND_FOR_APPENDABLE_TYPE( lang::Inclusion )
961 ALIB_BOXING_BOOTSTRAP_REGISTER_FAPPEND_FOR_APPENDABLE_TYPE( lang::Initialization )
962 ALIB_BOXING_BOOTSTRAP_REGISTER_FAPPEND_FOR_APPENDABLE_TYPE( lang::Phase )
963 ALIB_BOXING_BOOTSTRAP_REGISTER_FAPPEND_FOR_APPENDABLE_TYPE( lang::Propagation )
964 ALIB_BOXING_BOOTSTRAP_REGISTER_FAPPEND_FOR_APPENDABLE_TYPE( lang::Reach )
965 ALIB_BOXING_BOOTSTRAP_REGISTER_FAPPEND_FOR_APPENDABLE_TYPE( lang::Recursive )
966 ALIB_BOXING_BOOTSTRAP_REGISTER_FAPPEND_FOR_APPENDABLE_TYPE( lang::Responsibility )
967 ALIB_BOXING_BOOTSTRAP_REGISTER_FAPPEND_FOR_APPENDABLE_TYPE( lang::Safeness )
968 ALIB_BOXING_BOOTSTRAP_REGISTER_FAPPEND_FOR_APPENDABLE_TYPE( lang::Side )
969 ALIB_BOXING_BOOTSTRAP_REGISTER_FAPPEND_FOR_APPENDABLE_TYPE( lang::SortOrder )
970 ALIB_BOXING_BOOTSTRAP_REGISTER_FAPPEND_FOR_APPENDABLE_TYPE( lang::SourceData )
971 ALIB_BOXING_BOOTSTRAP_REGISTER_FAPPEND_FOR_APPENDABLE_TYPE( lang::Switch )
972 ALIB_BOXING_BOOTSTRAP_REGISTER_FAPPEND_FOR_APPENDABLE_TYPE( lang::Timezone )
973 ALIB_BOXING_BOOTSTRAP_REGISTER_FAPPEND_FOR_APPENDABLE_TYPE( lang::Timing )
974 ALIB_BOXING_BOOTSTRAP_REGISTER_FAPPEND_FOR_APPENDABLE_TYPE( lang::ValueReference )
975 ALIB_BOXING_BOOTSTRAP_REGISTER_FAPPEND_FOR_APPENDABLE_TYPE( lang::Whitespaces )
976 #endif
977
978 ALIB_BOXING_BOOTSTRAP_REGISTER_FAPPEND_FOR_APPENDABLE_TYPE( strings::util::Token* )
979
980 #if ALIB_VARIABLES
981 # if ALIB_CAMP
982 ALIB_BOXING_BOOTSTRAP_REGISTER_FAPPEND_FOR_APPENDABLE_TYPE( variables::Exceptions )
983 # endif
984 ALIB_BOXING_BOOTSTRAP_REGISTER_FAPPEND_FOR_APPENDABLE_TYPE( alib::variables::Priority )
985 ALIB_BOXING_BOOTSTRAP_REGISTER_FAPPEND_FOR_APPENDABLE_TYPE( alib::variables::Variable )
986 #endif
987
988 #if ALIB_DEBUG
989 ALIB_BOXING_BOOTSTRAP_REGISTER_FAPPEND_FOR_APPENDABLE_TYPE( std::type_info* )
990 #if ALIB_EXT_LIB_THREADS_AVAILABLE
991 ALIB_BOXING_BOOTSTRAP_REGISTER_FAPPEND_FOR_APPENDABLE_TYPE( std::thread::id )
992 #endif
993 ALIB_BOXING_BOOTSTRAP_REGISTER_FAPPEND_FOR_APPENDABLE_TYPE( lang::CallerInfo* )
994 #endif
995
996 #if ALIB_FORMAT
997 boxing::BootstrapRegister< format::FFormat, time::DateTime >(format::FFormat_DateTime);
998 boxing::BootstrapRegister< format::FFormat, lang::CallerInfo*>(format::FFormat_CallerInfo);
999 ALIB_BOXING_BOOTSTRAP_REGISTER_FAPPEND_FOR_APPENDABLE_TYPE( format::FormatterStdImpl::PHTypes )
1000 ALIB_BOXING_BOOTSTRAP_REGISTER_FAPPEND_FOR_APPENDABLE_TYPE( format::FMTExceptions )
1001 ALIB_BOXING_BOOTSTRAP_REGISTER_FAPPEND_FOR_APPENDABLE_TYPE( format::ByteSizeSI )
1002 ALIB_BOXING_BOOTSTRAP_REGISTER_FAPPEND_FOR_APPENDABLE_TYPE( format::ByteSizeIEC )
1003 ALIB_BOXING_BOOTSTRAP_REGISTER_FAPPEND_FOR_APPENDABLE_TYPE_N( format::ByteSizeUnits )
1004 ALIB_BOXING_BOOTSTRAP_REGISTER_FAPPEND_FOR_APPENDABLE_TYPE_W( format::ByteSizeUnits )
1005 ALIB_BOXING_BOOTSTRAP_REGISTER_FAPPEND_FOR_APPENDABLE_TYPE_X( format::ByteSizeUnits )
1006 #endif
1007
1008 #if ALIB_SYSTEM && ALIB_EXCEPTIONS
1009 ALIB_BOXING_BOOTSTRAP_REGISTER_FAPPEND_FOR_APPENDABLE_TYPE( system::SystemErrors )
1010 ALIB_BOXING_BOOTSTRAP_REGISTER_FAPPEND_FOR_APPENDABLE_TYPE( system::Path* )
1011 #endif
1012
1013 #if ALIB_ALOX
1014 ALIB_BOXING_BOOTSTRAP_REGISTER_FAPPEND_FOR_APPENDABLE_TYPE_N(alib::lox::Verbosity)
1015 ALIB_BOXING_BOOTSTRAP_REGISTER_FAPPEND_FOR_APPENDABLE_TYPE_N(alib::lox::Scope)
1016 ALIB_BOXING_BOOTSTRAP_REGISTER_FAPPEND_FOR_APPENDABLE_TYPE_N(alib::lox::detail::Logger*)
1017 ALIB_BOXING_BOOTSTRAP_REGISTER_FAPPEND_FOR_APPENDABLE_TYPE_N(alib::Pair<Verbosity ALIB_COMMA Priority>)
1018 #endif
1019
1020 #if ALIB_CLI
1021 ALIB_BOXING_BOOTSTRAP_REGISTER_FAPPEND_FOR_APPENDABLE_TYPE( cli::Exceptions )
1022 #endif
1023 #if ALIB_EXPRESSIONS
1024 ALIB_BOXING_BOOTSTRAP_REGISTER_FAPPEND_FOR_APPENDABLE_TYPE( alib::expressions::Exceptions )
1025 #endif
1026
1027 #if ALIB_FILES
1028 ALIB_BOXING_BOOTSTRAP_REGISTER_FAPPEND_FOR_APPENDABLE_TYPE( alib::files::File )
1029 alib::boxing::BootstrapRegister<alib::format::FFormat, files::File >( files::FFormat_File );
1030 ALIB_BOXING_BOOTSTRAP_REGISTER_FAPPEND_FOR_APPENDABLE_TYPE( FInfo::Types )
1031 ALIB_BOXING_BOOTSTRAP_REGISTER_FAPPEND_FOR_APPENDABLE_TYPE( FInfo::TypeNames1Letter )
1032 ALIB_BOXING_BOOTSTRAP_REGISTER_FAPPEND_FOR_APPENDABLE_TYPE( FInfo::TypeNames2Letters )
1033 ALIB_BOXING_BOOTSTRAP_REGISTER_FAPPEND_FOR_APPENDABLE_TYPE( FInfo::TypeNames3Letters )
1034 ALIB_BOXING_BOOTSTRAP_REGISTER_FAPPEND_FOR_APPENDABLE_TYPE( FInfo::Qualities )
1035 ALIB_BOXING_BOOTSTRAP_REGISTER_FAPPEND_FOR_APPENDABLE_TYPE( FInfo::Qualities3Letters )
1036 #endif
1037
1038
1039 #if !ALIB_SINGLE_THREADED
1040 alib::boxing::BootstrapRegister<FAppend<character, alib::HeapAllocator>,
1041 alib::threads::Thread* >(alib::boxing::FAppend_thread);
1042 #if ALIB_ENUMRECORDS
1043 ALIB_BOXING_BOOTSTRAP_REGISTER_FAPPEND_FOR_APPENDABLE_TYPE( alib::threads::Thread::State )
1044 #endif
1045 #endif
1046 #if ALIB_BITBUFFER
1047 ALIB_BOXING_BOOTSTRAP_REGISTER_FAPPEND_FOR_APPENDABLE_TYPE( alib::bitbuffer::ac_v1::ArrayCompressor::Algorithm )
1048 #endif
1049
1050#endif // ALIB_STRINGS
1051}
1052
1053// Box::dbgCheckRegistration
1054// Note: this method has to go here, to be able to check if boxing was bootstrapped already.
1055// If not, no check is performed.
1056#if ALIB_DEBUG_BOXING
1057
1058void debug::DbgCheckIsInitialized()
1059{
1060 // ERROR: A global or static instance of class Box is created and initialized to a
1061 // mapped type that uses a dynamic vtable. This is forbidden.
1062 // See chapter "12.4 Global And Static Box Instances" of the Programmer's Manual
1063 // of module ALib Boxing, for more information.
1064 assert( initFlag == 0x92A3EF61 ); // magic number
1065}
1066
1067void debug::DbgCheckRegistration( detail::VTable* vtable, bool increaseUsageCounter )
1068{
1069 if( vtable==nullptr)
1070 return;
1071
1072 if( increaseUsageCounter )
1073 ++vtable->DbgCntUsage;
1074
1075 if( initFlag== 0 || vtable->DbgProduction != detail::VTable::DbgFactoryType::Unregistered )
1076 return;
1077
1078 if( !vtable->IsArray() )
1079 ALIB_ERROR( "BOXING", "Static VTable of mapped type <{}> not registered.\n"
1080 "Use Macro ALIB_BOXING_BOOTSTRAP_VTABLE_DBG_REGISTER with bootstrapping.",
1081 &vtable->Type )
1082 else
1083 ALIB_ERROR( "BOXING", "Static VTable of mapped type <{}[]> not registered.\n"
1084 "Use Macro ALIB_BOXING_REGISTER_MAPPED_ARRAY_TYPE with bootstrapping.",
1085 &vtable->ElementType)
1086}
1087#endif
1088
1089
1090} // namespace [alib::boxing]
1091
alib_precompile.hpp
alib::bitbuffer::ac_v1::ArrayCompressor::Algorithm
Algorithm
Definition ac.inl:245
alib::files::FInfo::Qualities
Qualities
Per-entry information about how a node was scanned.
Definition finfo.inl:123
alib::format::FormatterStdImpl::PHTypes
PHTypes
Denotes the type of placeholders (respectively the values they represent).
Definition formatterstdimpl.inl:130
ALIB_BOXING_BOOTSTRAP_REGISTER_FAPPEND_FOR_APPENDABLE_TYPE_X
#define ALIB_BOXING_BOOTSTRAP_REGISTER_FAPPEND_FOR_APPENDABLE_TYPE_X(TAppendable)
Definition boxing.prepro.hpp:167
ALIB_ERROR
#define ALIB_ERROR(domain,...)
Definition alib.inl:1045
ALIB_BOXING_BOOTSTRAP_REGISTER_FAPPEND_FOR_APPENDABLE_TYPE
#define ALIB_BOXING_BOOTSTRAP_REGISTER_FAPPEND_FOR_APPENDABLE_TYPE(TAppendable)
Definition boxing.prepro.hpp:155
ALIB_BOXING_BOOTSTRAP_VTABLE_DBG_REGISTER
#define ALIB_BOXING_BOOTSTRAP_VTABLE_DBG_REGISTER(Identifier)
Definition boxing.prepro.hpp:142
ALIB_BOXING_BOOTSTRAP_REGISTER_FAPPEND_FOR_APPENDABLE_TYPE_N
#define ALIB_BOXING_BOOTSTRAP_REGISTER_FAPPEND_FOR_APPENDABLE_TYPE_N(TAppendable)
Definition boxing.prepro.hpp:159
ALIB_DBG
#define ALIB_DBG(...)
Definition alib.inl:836
IF_ALIB_MONOMEM
#define IF_ALIB_MONOMEM(...)
Definition alib.inl:361
ALIB_ASSERT_ERROR
#define ALIB_ASSERT_ERROR(cond, domain,...)
Definition alib.inl:1049
ALIB_BOXING_BOOTSTRAP_REGISTER_FAPPEND_FOR_APPENDABLE_TYPE_W
#define ALIB_BOXING_BOOTSTRAP_REGISTER_FAPPEND_FOR_APPENDABLE_TYPE_W(TAppendable)
Definition boxing.prepro.hpp:163
ALIB_REL_DBG
#define ALIB_REL_DBG(releaseCode,...)
Definition alib.inl:838
ALib.Boxing
alib::assert
This namespace exposes entities of module ALib Assert.
Definition assert.cpp:105
alib::boxing::debug::DbgCheckIsInitialized
ALIB_DLL void DbgCheckIsInitialized()
Definition boxstrap.cpp:1058
alib::boxing::debug::DbgCheckRegistration
ALIB_DLL void DbgCheckRegistration(detail::VTable *vtable, bool increaseUsageCounter)
Definition boxstrap.cpp:1067
alib::boxing::BootstrapRegisterDefault
void BootstrapRegisterDefault(typename TFDecl::Signature function)
Definition box.inl:1292
alib::boxing::shutdown
void shutdown()
Definition boxstrap.cpp:529
alib::boxing::SizeTraits
constexpr unsigned int SizeTraits
Definition boxingtraits.inl:267
alib::boxing::BootstrapRegister
void BootstrapRegister(typename TFDecl::Signature function)
Definition box.inl:1254
alib::boxing::bootstrap
void bootstrap()
Definition boxstrap.cpp:536
alib::characters::Compare
int Compare(const TChar *lhs, const TChar *rhs, integer cmpLength)
Definition functions.inl:348
alib::files::FFormat_File
void FFormat_File(const alib::Box &box, const alib::String &formatSpec, alib::NumberFormat &nf, alib::AString &target)
Definition file.cpp:424
alib::format::FFormat_CallerInfo
ALIB_DLL void FFormat_CallerInfo(const Box &self, const String &formatSpec, NumberFormat &nf, AString &target)
alib::format::FFormat_DateTime
ALIB_DLL void FFormat_DateTime(const Box &self, const String &formatSpec, NumberFormat &nf, AString &target)
alib::lang::SortOrder
SortOrder
Denotes sort order.
Definition commonenumdefs.inl:192
alib::lang::Side
Side
Denotes if something is left or right.
Definition commonenumdefs.inl:183
alib::lang::SourceData
SourceData
Denotes if the source data should be moved or copied.
Definition commonenumdefs.inl:201
alib::lang::Reach
Reach
Denotes the reach of something.
Definition commonenumdefs.inl:145
alib::lang::Recursive
Recursive
Denotes whether recursion is performed/allowed or not.
Definition commonenumdefs.inl:154
alib::lang::Timing
Timing
Denotes if asynchronous tasks become synchronized.
Definition commonenumdefs.inl:228
alib::lang::Alignment
Alignment
Denotes Alignments.
Definition commonenumdefs.inl:16
alib::lang::ContainerOp
ContainerOp
Denotes standard container operations.
Definition commonenumdefs.inl:65
alib::lang::Switch
Switch
Denotes if sth. is switched on or off.
Definition commonenumdefs.inl:210
alib::lang::Phase
Phase
Denotes a phase, e.g.,of a transaction.
Definition commonenumdefs.inl:127
alib::lang::CreateIfNotExists
CreateIfNotExists
Denotes whether something should be created if it does not exist.
Definition commonenumdefs.inl:86
alib::lang::Case
Case
Denotes upper and lower case character treatment.
Definition commonenumdefs.inl:53
alib::lang::CreateDefaults
CreateDefaults
Denotes whether default entities should be created or not.
Definition commonenumdefs.inl:77
alib::lang::Whitespaces
Whitespaces
Denotes whether a string is trimmed or not.
Definition commonenumdefs.inl:249
alib::lang::Caching
Caching
Denotes if a cache mechanism is enabled or disabled.
Definition commonenumdefs.inl:42
alib::lang::Propagation
Propagation
Denotes whether a e.g a setting should be propagated.
Definition commonenumdefs.inl:136
alib::lang::ValueReference
ValueReference
Denotes if a value is interpreted as an absolute or relative number.
Definition commonenumdefs.inl:240
alib::lang::Safeness
Safeness
Denotes whether something should be performed in a safe or unsafe fashion.
Definition commonenumdefs.inl:174
alib::lang::Initialization
Initialization
Used for example with constructors that allow to suppress initialization of members.
Definition commonenumdefs.inl:114
alib::lang::Inclusion
Inclusion
Denotes how members of a set something should be taken into account.
Definition commonenumdefs.inl:105
alib::lang::Timezone
Timezone
Denotes whether a time value represents local time or UTC.
Definition commonenumdefs.inl:219
alib::WAString
strings::TAString< wchar, lang::HeapAllocator > WAString
Type alias in namespace alib.
Definition tastring.inl:2175
alib::intGap_t
lang::intGap_t intGap_t
Type alias in namespace alib.
Definition integers.inl:155
alib::wchar
characters::wchar wchar
Type alias in namespace alib.
Definition chartypes.inl:138
alib::integer
lang::integer integer
Type alias in namespace alib.
Definition integers.inl:149
alib::NAString
strings::TAString< nchar, lang::HeapAllocator > NAString
Type alias in namespace alib.
Definition tastring.inl:2172
alib::MonoAllocator
monomem::TMonoAllocator< lang::HeapAllocator > MonoAllocator
Definition monoallocator.inl:1003
alib::uintGap_t
lang::uintGap_t uintGap_t
Type alias in namespace alib.
Definition integers.inl:158
alib::Pair
boxing::Pair< T, U > Pair
Type alias in namespace alib.
Definition boxing/placeholder.inl:780
alib::nchar
characters::nchar nchar
Type alias in namespace alib.
Definition chartypes.inl:135
alib::xchar
characters::xchar xchar
Type alias in namespace alib.
Definition chartypes.inl:141
alib::XAString
strings::TAString< xchar, lang::HeapAllocator > XAString
Type alias in namespace alib.
Definition tastring.inl:2178
alib::uinteger
lang::uinteger uinteger
Type alias in namespace alib.
Definition integers.inl:152
alib::boxing::FAppend::Appendable
static void Appendable(const Box &self, strings::TAString< TChar, TAllocator > &target)
alib::boxing::FAppend::WrappedAppendable
static void WrappedAppendable(const Box &self, strings::TAString< TChar, TAllocator > &target)
alib::boxing::FEquals::ComparableTypes
static bool ComparableTypes(const Box &self, const Box &rhs)
alib::boxing::FHashcode::UsePlaceholderBytes
static size_t UsePlaceholderBytes(const Box &self)
alib::boxing::FIsNotNull::ConstantTrue
static ALIB_DLL bool ConstantTrue(const Box &)
Definition box.cpp:175
alib::boxing::detail::FunctionTable::Shutdown
static ALIB_DLL void Shutdown()
Needs to be called only in debug versions to shut down internal hashtables cleanly.
Definition vtable.cpp:99
alib::boxing::detail::VTable
The custom function hash.
Definition vtable.inl:227
alib::boxing::detail::VTable::ElementType
const std::type_info & ElementType
Definition vtable.inl:245
alib::boxing::detail::VTable::DbgProduction
DbgFactoryType DbgProduction
Debug information.
Definition vtable.inl:274
alib::boxing::detail::VTable::Type
const std::type_info & Type
Definition vtable.inl:241
alib::strings::TNumberFormat::Computational
static TNumberFormat Computational
Definition numberformat.inl:212
alib::strings::TNumberFormat::HexLiteralPrefix
TCString< TChar > HexLiteralPrefix
Definition numberformat.inl:251