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