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