CFx SDK Documentation 2026 SP0
Loading...
Searching...
No Matches
TrVisFlagsBinTree.h
Go to the documentation of this file.
1
2// Copyright (C) 2002-2024, Open Design Alliance (the "Alliance").
3// All rights reserved.
4//
5// This software and its documentation and related materials are owned by
6// the Alliance. The software may only be incorporated into application
7// programs owned by members of the Alliance, subject to a signed
8// Membership Agreement and Supplemental Software License Agreement with the
9// Alliance. The structure and organization of this software are the valuable
10// trade secrets of the Alliance and its suppliers. The software is also
11// protected by copyright law and international treaty provisions. Application
12// programs incorporating this software must include the following statement
13// with their copyright notices:
14//
15// This application incorporates Open Design Alliance software pursuant to a license
16// agreement with Open Design Alliance.
17// Open Design Alliance Copyright (C) 2002-2024 by Open Design Alliance.
18// All rights reserved.
19//
20// By use of this software, its documentation or related materials, you
21// acknowledge and accept the above terms.
23// Optimized execution of bit flags processing using binary tree
24
25#ifndef _EXTRVISFLAGSBINTREE_INCLUDED_
26#define _EXTRVISFLAGSBINTREE_INCLUDED_
27
28#include "TD_PackPush.h"
29
30// 8-bit handlers
31
32struct OdTrVisFlagsBinTreeBase8
33{
34 inline void bit1() {}
35 inline void bit2() {}
36 inline void bit3() {}
37 inline void bit4() {}
38 inline void bit5() {}
39 inline void bit6() {}
40 inline void bit7() {}
41 inline void bit8() {}
42};
43
44struct OdTrVisFlagsBinTreeBreakBase8
45{
46 inline bool bit1() { return true; }
47 inline bool bit2() { return true; }
48 inline bool bit3() { return true; }
49 inline bool bit4() { return true; }
50 inline bool bit5() { return true; }
51 inline bool bit6() { return true; }
52 inline bool bit7() { return true; }
53 inline bool bit8() { return true; }
54};
55
56template <typename RedirBase>
57struct OdTrVisFlagsBinTreeRedir8 : public RedirBase
58{
59 inline void bit1() { RedirBase::bit(0); }
60 inline void bit2() { RedirBase::bit(1); }
61 inline void bit3() { RedirBase::bit(2); }
62 inline void bit4() { RedirBase::bit(3); }
63 inline void bit5() { RedirBase::bit(4); }
64 inline void bit6() { RedirBase::bit(5); }
65 inline void bit7() { RedirBase::bit(6); }
66 inline void bit8() { RedirBase::bit(7); }
67};
68
69template <typename RedirBase>
70struct OdTrVisFlagsBinTreeReadirBreak8 : public RedirBase
71{
72 inline bool bit1() { return RedirBase::bit(0); }
73 inline bool bit2() { return RedirBase::bit(1); }
74 inline bool bit3() { return RedirBase::bit(2); }
75 inline bool bit4() { return RedirBase::bit(3); }
76 inline bool bit5() { return RedirBase::bit(4); }
77 inline bool bit6() { return RedirBase::bit(5); }
78 inline bool bit7() { return RedirBase::bit(6); }
79 inline bool bit8() { return RedirBase::bit(7); }
80};
81
82template <typename BitDo>
83inline void odTrVisFlagsBinTree(OdUInt8 nMask, BitDo &bd)
84{
85 if (nMask)
86 {
87 if (nMask & 0x0F)
88 {
89 if (nMask & 0x03)
90 {
91 if (nMask & (1 << 0)) { bd.bit1(); }
92 if (nMask & (1 << 1)) { bd.bit2(); }
93 }
94 if (nMask & 0x0C)
95 {
96 if (nMask & (1 << 2)) { bd.bit3(); }
97 if (nMask & (1 << 3)) { bd.bit4(); }
98 }
99 }
100 if (nMask & 0xF0)
101 {
102 if (nMask & 0x30)
103 {
104 if (nMask & (1 << 4)) { bd.bit5(); }
105 if (nMask & (1 << 5)) { bd.bit6(); }
106 }
107 if (nMask & 0xC0)
108 {
109 if (nMask & (1 << 6)) { bd.bit7(); }
110 if (nMask & (1 << 7)) { bd.bit8(); }
111 }
112 }
113 }
114}
115
116template <typename BitDo>
117inline void odTrVisFlagsBinTreeRev(OdUInt8 nMask, BitDo &bd)
118{
119 if (nMask)
120 {
121 if (nMask & 0xF0)
122 {
123 if (nMask & 0xC0)
124 {
125 if (nMask & (1 << 7)) { bd.bit8(); }
126 if (nMask & (1 << 6)) { bd.bit7(); }
127 }
128 if (nMask & 0x30)
129 {
130 if (nMask & (1 << 5)) { bd.bit6(); }
131 if (nMask & (1 << 4)) { bd.bit5(); }
132 }
133 }
134 if (nMask & 0x0F)
135 {
136 if (nMask & 0x0C)
137 {
138 if (nMask & (1 << 3)) { bd.bit4(); }
139 if (nMask & (1 << 2)) { bd.bit3(); }
140 }
141 if (nMask & 0x03)
142 {
143 if (nMask & (1 << 1)) { bd.bit2(); }
144 if (nMask & (1 << 0)) { bd.bit1(); }
145 }
146 }
147 }
148}
149
150template <typename BitDo>
151inline bool odTrVisFlagsBinTreeBreak(OdUInt8 nMask, BitDo &bd)
152{
153 if (nMask)
154 {
155 if (nMask & 0x0F)
156 {
157 if (nMask & 0x03)
158 {
159 if (nMask & (1 << 0)) { if (!bd.bit1()) return false; }
160 if (nMask & (1 << 1)) { if (!bd.bit2()) return false; }
161 }
162 if (nMask & 0x0C)
163 {
164 if (nMask & (1 << 2)) { if (!bd.bit3()) return false; }
165 if (nMask & (1 << 3)) { if (!bd.bit4()) return false; }
166 }
167 }
168 if (nMask & 0xF0)
169 {
170 if (nMask & 0x30)
171 {
172 if (nMask & (1 << 4)) { if (!bd.bit5()) return false; }
173 if (nMask & (1 << 5)) { if (!bd.bit6()) return false; }
174 }
175 if (nMask & 0xC0)
176 {
177 if (nMask & (1 << 6)) { if (!bd.bit7()) return false; }
178 if (nMask & (1 << 7)) { if (!bd.bit8()) return false; }
179 }
180 }
181 }
182 return true;
183}
184
185template <typename BitDo>
186inline bool odTrVisFlagsBinTreeBreakRev(OdUInt8 nMask, BitDo &bd)
187{
188 if (nMask)
189 {
190 if (nMask & 0xF0)
191 {
192 if (nMask & 0xC0)
193 {
194 if (nMask & (1 << 7)) { if (!bd.bit8()) return false; }
195 if (nMask & (1 << 6)) { if (!bd.bit7()) return false; }
196 }
197 if (nMask & 0x30)
198 {
199 if (nMask & (1 << 5)) { if (!bd.bit6()) return false; }
200 if (nMask & (1 << 4)) { if (!bd.bit5()) return false; }
201 }
202 }
203 if (nMask & 0x0F)
204 {
205 if (nMask & 0x0C)
206 {
207 if (nMask & (1 << 3)) { if (!bd.bit4()) return false; }
208 if (nMask & (1 << 2)) { if (!bd.bit3()) return false; }
209 }
210 if (nMask & 0x03)
211 {
212 if (nMask & (1 << 1)) { if (!bd.bit2()) return false; }
213 if (nMask & (1 << 0)) { if (!bd.bit1()) return false; }
214 }
215 }
216 }
217 return true;
218}
219
220// 16-bit handlers
221
222struct OdTrVisFlagsBinTreeBase16 : public OdTrVisFlagsBinTreeBase8
223{
224 inline void bit9() {}
225 inline void bit10() {}
226 inline void bit11() {}
227 inline void bit12() {}
228 inline void bit13() {}
229 inline void bit14() {}
230 inline void bit15() {}
231 inline void bit16() {}
232};
233
234struct OdTrVisFlagsBinTreeBreakBase16 : public OdTrVisFlagsBinTreeBreakBase8
235{
236 inline bool bit9() { return true; }
237 inline bool bit10() { return true; }
238 inline bool bit11() { return true; }
239 inline bool bit12() { return true; }
240 inline bool bit13() { return true; }
241 inline bool bit14() { return true; }
242 inline bool bit15() { return true; }
243 inline bool bit16() { return true; }
244};
245
246template <typename RedirBase>
247struct OdTrVisFlagsBinTreeRedir16 : public OdTrVisFlagsBinTreeRedir8<RedirBase>
248{
249 inline void bit9() { RedirBase::bit(8); }
250 inline void bit10() { RedirBase::bit(9); }
251 inline void bit11() { RedirBase::bit(10); }
252 inline void bit12() { RedirBase::bit(11); }
253 inline void bit13() { RedirBase::bit(12); }
254 inline void bit14() { RedirBase::bit(13); }
255 inline void bit15() { RedirBase::bit(14); }
256 inline void bit16() { RedirBase::bit(15); }
257};
258
259template <typename RedirBase>
260struct OdTrVisFlagsBinTreeReadirBreak16 : public OdTrVisFlagsBinTreeReadirBreak8<RedirBase>
261{
262 inline bool bit9() { return RedirBase::bit(8); }
263 inline bool bit10() { return RedirBase::bit(9); }
264 inline bool bit11() { return RedirBase::bit(10); }
265 inline bool bit12() { return RedirBase::bit(11); }
266 inline bool bit13() { return RedirBase::bit(12); }
267 inline bool bit14() { return RedirBase::bit(13); }
268 inline bool bit15() { return RedirBase::bit(14); }
269 inline bool bit16() { return RedirBase::bit(15); }
270};
271
272template <typename BitDo>
273inline void odTrVisFlagsBinTree(OdUInt16 nMask, BitDo &bd)
274{
275 if (nMask)
276 {
277 if (nMask & 0x00FF)
278 {
279 if (nMask & 0x000F)
280 {
281 if (nMask & 0x0003)
282 {
283 if (nMask & (1 << 0)) { bd.bit1(); }
284 if (nMask & (1 << 1)) { bd.bit2(); }
285 }
286 if (nMask & 0x000C)
287 {
288 if (nMask & (1 << 2)) { bd.bit3(); }
289 if (nMask & (1 << 3)) { bd.bit4(); }
290 }
291 }
292 if (nMask & 0x00F0)
293 {
294 if (nMask & 0x0030)
295 {
296 if (nMask & (1 << 4)) { bd.bit5(); }
297 if (nMask & (1 << 5)) { bd.bit6(); }
298 }
299 if (nMask & 0x00C0)
300 {
301 if (nMask & (1 << 6)) { bd.bit7(); }
302 if (nMask & (1 << 7)) { bd.bit8(); }
303 }
304 }
305 }
306 if (nMask & 0xFF00)
307 {
308 if (nMask & 0x0F00)
309 {
310 if (nMask & 0x0300)
311 {
312 if (nMask & (1 << 8)) { bd.bit9(); }
313 if (nMask & (1 << 9)) { bd.bit10(); }
314 }
315 if (nMask & 0x0C00)
316 {
317 if (nMask & (1 << 10)) { bd.bit11(); }
318 if (nMask & (1 << 11)) { bd.bit12(); }
319 }
320 }
321 if (nMask & 0xF000)
322 {
323 if (nMask & 0x3000)
324 {
325 if (nMask & (1 << 12)) { bd.bit13(); }
326 if (nMask & (1 << 13)) { bd.bit14(); }
327 }
328 if (nMask & 0xC000)
329 {
330 if (nMask & (1 << 14)) { bd.bit15(); }
331 if (nMask & (1 << 15)) { bd.bit16(); }
332 }
333 }
334 }
335 }
336}
337
338template <typename BitDo>
339inline void odTrVisFlagsBinTreeRev(OdUInt16 nMask, BitDo &bd)
340{
341 if (nMask)
342 {
343 if (nMask & 0xFF00)
344 {
345 if (nMask & 0xF000)
346 {
347 if (nMask & 0xC000)
348 {
349 if (nMask & (1 << 15)) { bd.bit16(); }
350 if (nMask & (1 << 14)) { bd.bit15(); }
351 }
352 if (nMask & 0x3000)
353 {
354 if (nMask & (1 << 13)) { bd.bit14(); }
355 if (nMask & (1 << 12)) { bd.bit13(); }
356 }
357 }
358 if (nMask & 0x0F00)
359 {
360 if (nMask & 0x0C00)
361 {
362 if (nMask & (1 << 11)) { bd.bit12(); }
363 if (nMask & (1 << 10)) { bd.bit11(); }
364 }
365 if (nMask & 0x0300)
366 {
367 if (nMask & (1 << 9)) { bd.bit10(); }
368 if (nMask & (1 << 8)) { bd.bit9(); }
369 }
370 }
371 }
372 if (nMask & 0x00FF)
373 {
374 if (nMask & 0x00F0)
375 {
376 if (nMask & 0x00C0)
377 {
378 if (nMask & (1 << 7)) { bd.bit8(); }
379 if (nMask & (1 << 6)) { bd.bit7(); }
380 }
381 if (nMask & 0x0030)
382 {
383 if (nMask & (1 << 5)) { bd.bit6(); }
384 if (nMask & (1 << 4)) { bd.bit5(); }
385 }
386 }
387 if (nMask & 0x000F)
388 {
389 if (nMask & 0x000C)
390 {
391 if (nMask & (1 << 3)) { bd.bit4(); }
392 if (nMask & (1 << 2)) { bd.bit3(); }
393 }
394 if (nMask & 0x0003)
395 {
396 if (nMask & (1 << 1)) { bd.bit2(); }
397 if (nMask & (1 << 0)) { bd.bit1(); }
398 }
399 }
400 }
401 }
402}
403
404template <typename BitDo>
405inline bool odTrVisFlagsBinTreeBreak(OdUInt16 nMask, BitDo &bd)
406{
407 if (nMask)
408 {
409 if (nMask & 0x00FF)
410 {
411 if (nMask & 0x000F)
412 {
413 if (nMask & 0x0003)
414 {
415 if (nMask & (1 << 0)) { if (!bd.bit1()) return false; }
416 if (nMask & (1 << 1)) { if (!bd.bit2()) return false; }
417 }
418 if (nMask & 0x000C)
419 {
420 if (nMask & (1 << 2)) { if (!bd.bit3()) return false; }
421 if (nMask & (1 << 3)) { if (!bd.bit4()) return false; }
422 }
423 }
424 if (nMask & 0x00F0)
425 {
426 if (nMask & 0x0030)
427 {
428 if (nMask & (1 << 4)) { if (!bd.bit5()) return false; }
429 if (nMask & (1 << 5)) { if (!bd.bit6()) return false; }
430 }
431 if (nMask & 0x00C0)
432 {
433 if (nMask & (1 << 6)) { if (!bd.bit7()) return false; }
434 if (nMask & (1 << 7)) { if (!bd.bit8()) return false; }
435 }
436 }
437 }
438 if (nMask & 0xFF00)
439 {
440 if (nMask & 0x0F00)
441 {
442 if (nMask & 0x0300)
443 {
444 if (nMask & (1 << 8)) { if (!bd.bit9()) return false; }
445 if (nMask & (1 << 9)) { if (!bd.bit10()) return false; }
446 }
447 if (nMask & 0x0C00)
448 {
449 if (nMask & (1 << 10)) { if (!bd.bit11()) return false; }
450 if (nMask & (1 << 11)) { if (!bd.bit12()) return false; }
451 }
452 }
453 if (nMask & 0xF000)
454 {
455 if (nMask & 0x3000)
456 {
457 if (nMask & (1 << 12)) { if (!bd.bit13()) return false; }
458 if (nMask & (1 << 13)) { if (!bd.bit14()) return false; }
459 }
460 if (nMask & 0xC000)
461 {
462 if (nMask & (1 << 14)) { if (!bd.bit15()) return false; }
463 if (nMask & (1 << 15)) { if (!bd.bit16()) return false; }
464 }
465 }
466 }
467 }
468 return true;
469}
470
471template <typename BitDo>
472inline bool odTrVisFlagsBinTreeBreakRev(OdUInt16 nMask, BitDo &bd)
473{
474 if (nMask)
475 {
476 if (nMask & 0xFF00)
477 {
478 if (nMask & 0xF000)
479 {
480 if (nMask & 0xC000)
481 {
482 if (nMask & (1 << 15)) { if (!bd.bit16()) return false; }
483 if (nMask & (1 << 14)) { if (!bd.bit15()) return false; }
484 }
485 if (nMask & 0x3000)
486 {
487 if (nMask & (1 << 13)) { if (!bd.bit14()) return false; }
488 if (nMask & (1 << 12)) { if (!bd.bit13()) return false; }
489 }
490 }
491 if (nMask & 0x0F00)
492 {
493 if (nMask & 0x0C00)
494 {
495 if (nMask & (1 << 11)) { if (!bd.bit12()) return false; }
496 if (nMask & (1 << 10)) { if (!bd.bit11()) return false; }
497 }
498 if (nMask & 0x0300)
499 {
500 if (nMask & (1 << 9)) { if (!bd.bit10()) return false; }
501 if (nMask & (1 << 8)) { if (!bd.bit9()) return false; }
502 }
503 }
504 }
505 if (nMask & 0x00FF)
506 {
507 if (nMask & 0x00F0)
508 {
509 if (nMask & 0x00C0)
510 {
511 if (nMask & (1 << 7)) { if (!bd.bit8()) return false; }
512 if (nMask & (1 << 6)) { if (!bd.bit7()) return false; }
513 }
514 if (nMask & 0x0030)
515 {
516 if (nMask & (1 << 5)) { if (!bd.bit6()) return false; }
517 if (nMask & (1 << 4)) { if (!bd.bit5()) return false; }
518 }
519 }
520 if (nMask & 0x000F)
521 {
522 if (nMask & 0x000C)
523 {
524 if (nMask & (1 << 3)) { if (!bd.bit4()) return false; }
525 if (nMask & (1 << 2)) { if (!bd.bit3()) return false; }
526 }
527 if (nMask & 0x0003)
528 {
529 if (nMask & (1 << 1)) { if (!bd.bit2()) return false; }
530 if (nMask & (1 << 0)) { if (!bd.bit1()) return false; }
531 }
532 }
533 }
534 }
535 return true;
536}
537
538// 32-bit handlers
539
540struct OdTrVisFlagsBinTreeBase32 : public OdTrVisFlagsBinTreeBase16
541{
542 inline void bit17() {}
543 inline void bit18() {}
544 inline void bit19() {}
545 inline void bit20() {}
546 inline void bit21() {}
547 inline void bit22() {}
548 inline void bit23() {}
549 inline void bit24() {}
550 inline void bit25() {}
551 inline void bit26() {}
552 inline void bit27() {}
553 inline void bit28() {}
554 inline void bit29() {}
555 inline void bit30() {}
556 inline void bit31() {}
557 inline void bit32() {}
558};
559
560struct OdTrVisFlagsBinTreeBreakBase32 : public OdTrVisFlagsBinTreeBreakBase16
561{
562 inline bool bit17() { return true; }
563 inline bool bit18() { return true; }
564 inline bool bit19() { return true; }
565 inline bool bit20() { return true; }
566 inline bool bit21() { return true; }
567 inline bool bit22() { return true; }
568 inline bool bit23() { return true; }
569 inline bool bit24() { return true; }
570 inline bool bit25() { return true; }
571 inline bool bit26() { return true; }
572 inline bool bit27() { return true; }
573 inline bool bit28() { return true; }
574 inline bool bit29() { return true; }
575 inline bool bit30() { return true; }
576 inline bool bit31() { return true; }
577 inline bool bit32() { return true; }
578};
579
580template <typename RedirBase>
581struct OdTrVisFlagsBinTreeRedir32 : public OdTrVisFlagsBinTreeRedir16<RedirBase>
582{
583 inline void bit17() { RedirBase::bit(16); }
584 inline void bit18() { RedirBase::bit(17); }
585 inline void bit19() { RedirBase::bit(18); }
586 inline void bit20() { RedirBase::bit(19); }
587 inline void bit21() { RedirBase::bit(20); }
588 inline void bit22() { RedirBase::bit(21); }
589 inline void bit23() { RedirBase::bit(22); }
590 inline void bit24() { RedirBase::bit(23); }
591 inline void bit25() { RedirBase::bit(24); }
592 inline void bit26() { RedirBase::bit(25); }
593 inline void bit27() { RedirBase::bit(26); }
594 inline void bit28() { RedirBase::bit(27); }
595 inline void bit29() { RedirBase::bit(28); }
596 inline void bit30() { RedirBase::bit(29); }
597 inline void bit31() { RedirBase::bit(30); }
598 inline void bit32() { RedirBase::bit(31); }
599};
600
601template <typename RedirBase>
602struct OdTrVisFlagsBinTreeReadirBreak32 : public OdTrVisFlagsBinTreeReadirBreak16<RedirBase>
603{
604 inline bool bit17() { return RedirBase::bit(16); }
605 inline bool bit18() { return RedirBase::bit(17); }
606 inline bool bit19() { return RedirBase::bit(18); }
607 inline bool bit20() { return RedirBase::bit(19); }
608 inline bool bit21() { return RedirBase::bit(20); }
609 inline bool bit22() { return RedirBase::bit(21); }
610 inline bool bit23() { return RedirBase::bit(22); }
611 inline bool bit24() { return RedirBase::bit(23); }
612 inline bool bit25() { return RedirBase::bit(24); }
613 inline bool bit26() { return RedirBase::bit(25); }
614 inline bool bit27() { return RedirBase::bit(26); }
615 inline bool bit28() { return RedirBase::bit(27); }
616 inline bool bit29() { return RedirBase::bit(28); }
617 inline bool bit30() { return RedirBase::bit(29); }
618 inline bool bit31() { return RedirBase::bit(30); }
619 inline bool bit32() { return RedirBase::bit(31); }
620};
621
622template <typename BitDo>
623inline void odTrVisFlagsBinTree(OdUInt32 nMask, BitDo &bd)
624{
625 if (nMask)
626 {
627 if (nMask & 0x0000FFFF)
628 {
629 if (nMask & 0x000000FF)
630 {
631 if (nMask & 0x0000000F)
632 {
633 if (nMask & 0x00000003)
634 {
635 if (nMask & (1 << 0)) { bd.bit1(); }
636 if (nMask & (1 << 1)) { bd.bit2(); }
637 }
638 if (nMask & 0x0000000C)
639 {
640 if (nMask & (1 << 2)) { bd.bit3(); }
641 if (nMask & (1 << 3)) { bd.bit4(); }
642 }
643 }
644 if (nMask & 0x000000F0)
645 {
646 if (nMask & 0x00000030)
647 {
648 if (nMask & (1 << 4)) { bd.bit5(); }
649 if (nMask & (1 << 5)) { bd.bit6(); }
650 }
651 if (nMask & 0x000000C0)
652 {
653 if (nMask & (1 << 6)) { bd.bit7(); }
654 if (nMask & (1 << 7)) { bd.bit8(); }
655 }
656 }
657 }
658 if (nMask & 0x0000FF00)
659 {
660 if (nMask & 0x00000F00)
661 {
662 if (nMask & 0x00000300)
663 {
664 if (nMask & (1 << 8)) { bd.bit9(); }
665 if (nMask & (1 << 9)) { bd.bit10(); }
666 }
667 if (nMask & 0x00000C00)
668 {
669 if (nMask & (1 << 10)) { bd.bit11(); }
670 if (nMask & (1 << 11)) { bd.bit12(); }
671 }
672 }
673 if (nMask & 0x0000F000)
674 {
675 if (nMask & 0x00003000)
676 {
677 if (nMask & (1 << 12)) { bd.bit13(); }
678 if (nMask & (1 << 13)) { bd.bit14(); }
679 }
680 if (nMask & 0x0000C000)
681 {
682 if (nMask & (1 << 14)) { bd.bit15(); }
683 if (nMask & (1 << 15)) { bd.bit16(); }
684 }
685 }
686 }
687 }
688 if (nMask & 0xFFFF0000)
689 {
690 if (nMask & 0x00FF0000)
691 {
692 if (nMask & 0x000F0000)
693 {
694 if (nMask & 0x00030000)
695 {
696 if (nMask & (1 << 16)) { bd.bit17(); }
697 if (nMask & (1 << 17)) { bd.bit18(); }
698 }
699 if (nMask & 0x000C0000)
700 {
701 if (nMask & (1 << 18)) { bd.bit19(); }
702 if (nMask & (1 << 19)) { bd.bit20(); }
703 }
704 }
705 if (nMask & 0x00F00000)
706 {
707 if (nMask & 0x00300000)
708 {
709 if (nMask & (1 << 20)) { bd.bit21(); }
710 if (nMask & (1 << 21)) { bd.bit22(); }
711 }
712 if (nMask & 0x00C00000)
713 {
714 if (nMask & (1 << 22)) { bd.bit23(); }
715 if (nMask & (1 << 23)) { bd.bit24(); }
716 }
717 }
718 }
719 if (nMask & 0xFF000000)
720 {
721 if (nMask & 0x0F000000)
722 {
723 if (nMask & 0x03000000)
724 {
725 if (nMask & (1 << 24)) { bd.bit25(); }
726 if (nMask & (1 << 25)) { bd.bit26(); }
727 }
728 if (nMask & 0x0C000000)
729 {
730 if (nMask & (1 << 26)) { bd.bit27(); }
731 if (nMask & (1 << 27)) { bd.bit28(); }
732 }
733 }
734 if (nMask & 0xF0000000)
735 {
736 if (nMask & 0x30000000)
737 {
738 if (nMask & (1 << 28)) { bd.bit29(); }
739 if (nMask & (1 << 29)) { bd.bit30(); }
740 }
741 if (nMask & 0xC0000000)
742 {
743 if (nMask & (1 << 30)) { bd.bit31(); }
744 if (nMask & (1 << 31)) { bd.bit32(); }
745 }
746 }
747 }
748 }
749 }
750}
751
752template <typename BitDo>
753inline void odTrVisFlagsBinTreeRev(OdUInt32 nMask, BitDo &bd)
754{
755 if (nMask)
756 {
757 if (nMask & 0xFFFF0000)
758 {
759 if (nMask & 0xFF000000)
760 {
761 if (nMask & 0xF0000000)
762 {
763 if (nMask & 0xC0000000)
764 {
765 if (nMask & (1 << 31)) { bd.bit32(); }
766 if (nMask & (1 << 30)) { bd.bit31(); }
767 }
768 if (nMask & 0x30000000)
769 {
770 if (nMask & (1 << 29)) { bd.bit30(); }
771 if (nMask & (1 << 28)) { bd.bit29(); }
772 }
773 }
774 if (nMask & 0x0F000000)
775 {
776 if (nMask & 0x0C000000)
777 {
778 if (nMask & (1 << 27)) { bd.bit28(); }
779 if (nMask & (1 << 26)) { bd.bit27(); }
780 }
781 if (nMask & 0x03000000)
782 {
783 if (nMask & (1 << 25)) { bd.bit26(); }
784 if (nMask & (1 << 24)) { bd.bit25(); }
785 }
786 }
787 }
788 if (nMask & 0x00FF0000)
789 {
790 if (nMask & 0x00F00000)
791 {
792 if (nMask & 0x00C00000)
793 {
794 if (nMask & (1 << 23)) { bd.bit24(); }
795 if (nMask & (1 << 22)) { bd.bit23(); }
796 }
797 if (nMask & 0x00300000)
798 {
799 if (nMask & (1 << 21)) { bd.bit22(); }
800 if (nMask & (1 << 20)) { bd.bit21(); }
801 }
802 }
803 if (nMask & 0x000F0000)
804 {
805 if (nMask & 0x000C0000)
806 {
807 if (nMask & (1 << 19)) { bd.bit20(); }
808 if (nMask & (1 << 18)) { bd.bit19(); }
809 }
810 if (nMask & 0x00030000)
811 {
812 if (nMask & (1 << 17)) { bd.bit18(); }
813 if (nMask & (1 << 16)) { bd.bit17(); }
814 }
815 }
816 }
817 }
818 if (nMask & 0x0000FFFF)
819 {
820 if (nMask & 0x0000FF00)
821 {
822 if (nMask & 0x0000F000)
823 {
824 if (nMask & 0x0000C000)
825 {
826 if (nMask & (1 << 15)) { bd.bit16(); }
827 if (nMask & (1 << 14)) { bd.bit15(); }
828 }
829 if (nMask & 0x00003000)
830 {
831 if (nMask & (1 << 13)) { bd.bit14(); }
832 if (nMask & (1 << 12)) { bd.bit13(); }
833 }
834 }
835 if (nMask & 0x00000F00)
836 {
837 if (nMask & 0x00000C00)
838 {
839 if (nMask & (1 << 11)) { bd.bit12(); }
840 if (nMask & (1 << 10)) { bd.bit11(); }
841 }
842 if (nMask & 0x00000300)
843 {
844 if (nMask & (1 << 9)) { bd.bit10(); }
845 if (nMask & (1 << 8)) { bd.bit9(); }
846 }
847 }
848 }
849 if (nMask & 0x000000FF)
850 {
851 if (nMask & 0x000000F0)
852 {
853 if (nMask & 0x000000C0)
854 {
855 if (nMask & (1 << 7)) { bd.bit8(); }
856 if (nMask & (1 << 6)) { bd.bit7(); }
857 }
858 if (nMask & 0x00000030)
859 {
860 if (nMask & (1 << 5)) { bd.bit6(); }
861 if (nMask & (1 << 4)) { bd.bit5(); }
862 }
863 }
864 if (nMask & 0x0000000F)
865 {
866 if (nMask & 0x0000000C)
867 {
868 if (nMask & (1 << 3)) { bd.bit4(); }
869 if (nMask & (1 << 2)) { bd.bit3(); }
870 }
871 if (nMask & 0x00000003)
872 {
873 if (nMask & (1 << 1)) { bd.bit2(); }
874 if (nMask & (1 << 0)) { bd.bit1(); }
875 }
876 }
877 }
878 }
879 }
880}
881
882template <typename BitDo>
883inline bool odTrVisFlagsBinTreeBreak(OdUInt32 nMask, BitDo &bd)
884{
885 if (nMask)
886 {
887 if (nMask & 0x0000FFFF)
888 {
889 if (nMask & 0x000000FF)
890 {
891 if (nMask & 0x0000000F)
892 {
893 if (nMask & 0x00000003)
894 {
895 if (nMask & (1 << 0)) { if (!bd.bit1()) return false; }
896 if (nMask & (1 << 1)) { if (!bd.bit2()) return false; }
897 }
898 if (nMask & 0x0000000C)
899 {
900 if (nMask & (1 << 2)) { if (!bd.bit3()) return false; }
901 if (nMask & (1 << 3)) { if (!bd.bit4()) return false; }
902 }
903 }
904 if (nMask & 0x000000F0)
905 {
906 if (nMask & 0x00000030)
907 {
908 if (nMask & (1 << 4)) { if (!bd.bit5()) return false; }
909 if (nMask & (1 << 5)) { if (!bd.bit6()) return false; }
910 }
911 if (nMask & 0x000000C0)
912 {
913 if (nMask & (1 << 6)) { if (!bd.bit7()) return false; }
914 if (nMask & (1 << 7)) { if (!bd.bit8()) return false; }
915 }
916 }
917 }
918 if (nMask & 0x0000FF00)
919 {
920 if (nMask & 0x00000F00)
921 {
922 if (nMask & 0x00000300)
923 {
924 if (nMask & (1 << 8)) { if (!bd.bit9()) return false; }
925 if (nMask & (1 << 9)) { if (!bd.bit10()) return false; }
926 }
927 if (nMask & 0x00000C00)
928 {
929 if (nMask & (1 << 10)) { if (!bd.bit11()) return false; }
930 if (nMask & (1 << 11)) { if (!bd.bit12()) return false; }
931 }
932 }
933 if (nMask & 0x0000F000)
934 {
935 if (nMask & 0x00003000)
936 {
937 if (nMask & (1 << 12)) { if (!bd.bit13()) return false; }
938 if (nMask & (1 << 13)) { if (!bd.bit14()) return false; }
939 }
940 if (nMask & 0x0000C000)
941 {
942 if (nMask & (1 << 14)) { if (!bd.bit15()) return false; }
943 if (nMask & (1 << 15)) { if (!bd.bit16()) return false; }
944 }
945 }
946 }
947 }
948 if (nMask & 0xFFFF0000)
949 {
950 if (nMask & 0x00FF0000)
951 {
952 if (nMask & 0x000F0000)
953 {
954 if (nMask & 0x00030000)
955 {
956 if (nMask & (1 << 16)) { if (!bd.bit17()) return false; }
957 if (nMask & (1 << 17)) { if (!bd.bit18()) return false; }
958 }
959 if (nMask & 0x000C0000)
960 {
961 if (nMask & (1 << 18)) { if (!bd.bit19()) return false; }
962 if (nMask & (1 << 19)) { if (!bd.bit20()) return false; }
963 }
964 }
965 if (nMask & 0x00F00000)
966 {
967 if (nMask & 0x00300000)
968 {
969 if (nMask & (1 << 20)) { if (!bd.bit21()) return false; }
970 if (nMask & (1 << 21)) { if (!bd.bit22()) return false; }
971 }
972 if (nMask & 0x00C00000)
973 {
974 if (nMask & (1 << 22)) { if (!bd.bit23()) return false; }
975 if (nMask & (1 << 23)) { if (!bd.bit24()) return false; }
976 }
977 }
978 }
979 if (nMask & 0xFF000000)
980 {
981 if (nMask & 0x0F000000)
982 {
983 if (nMask & 0x03000000)
984 {
985 if (nMask & (1 << 24)) { if (!bd.bit25()) return false; }
986 if (nMask & (1 << 25)) { if (!bd.bit26()) return false; }
987 }
988 if (nMask & 0x0C000000)
989 {
990 if (nMask & (1 << 26)) { if (!bd.bit27()) return false; }
991 if (nMask & (1 << 27)) { if (!bd.bit28()) return false; }
992 }
993 }
994 if (nMask & 0xF0000000)
995 {
996 if (nMask & 0x30000000)
997 {
998 if (nMask & (1 << 28)) { if (!bd.bit29()) return false; }
999 if (nMask & (1 << 29)) { if (!bd.bit30()) return false; }
1000 }
1001 if (nMask & 0xC0000000)
1002 {
1003 if (nMask & (1 << 30)) { if (!bd.bit31()) return false; }
1004 if (nMask & (1 << 31)) { if (!bd.bit32()) return false; }
1005 }
1006 }
1007 }
1008 }
1009 }
1010 return true;
1011}
1012
1013template <typename BitDo>
1014inline bool odTrVisFlagsBinTreeBreakRev(OdUInt32 nMask, BitDo &bd)
1015{
1016 if (nMask)
1017 {
1018 if (nMask & 0xFFFF0000)
1019 {
1020 if (nMask & 0xFF000000)
1021 {
1022 if (nMask & 0xF0000000)
1023 {
1024 if (nMask & 0xC0000000)
1025 {
1026 if (nMask & (1 << 31)) { if (!bd.bit32()) return false; }
1027 if (nMask & (1 << 30)) { if (!bd.bit31()) return false; }
1028 }
1029 if (nMask & 0x30000000)
1030 {
1031 if (nMask & (1 << 29)) { if (!bd.bit30()) return false; }
1032 if (nMask & (1 << 28)) { if (!bd.bit29()) return false; }
1033 }
1034 }
1035 if (nMask & 0x0F000000)
1036 {
1037 if (nMask & 0x0C000000)
1038 {
1039 if (nMask & (1 << 27)) { if (!bd.bit28()) return false; }
1040 if (nMask & (1 << 26)) { if (!bd.bit27()) return false; }
1041 }
1042 if (nMask & 0x03000000)
1043 {
1044 if (nMask & (1 << 25)) { if (!bd.bit26()) return false; }
1045 if (nMask & (1 << 24)) { if (!bd.bit25()) return false; }
1046 }
1047 }
1048 }
1049 if (nMask & 0x00FF0000)
1050 {
1051 if (nMask & 0x00F00000)
1052 {
1053 if (nMask & 0x00C00000)
1054 {
1055 if (nMask & (1 << 23)) { if (!bd.bit24()) return false; }
1056 if (nMask & (1 << 22)) { if (!bd.bit23()) return false; }
1057 }
1058 if (nMask & 0x00300000)
1059 {
1060 if (nMask & (1 << 21)) { if (!bd.bit22()) return false; }
1061 if (nMask & (1 << 20)) { if (!bd.bit21()) return false; }
1062 }
1063 }
1064 if (nMask & 0x000F0000)
1065 {
1066 if (nMask & 0x000C0000)
1067 {
1068 if (nMask & (1 << 19)) { if (!bd.bit20()) return false; }
1069 if (nMask & (1 << 18)) { if (!bd.bit19()) return false; }
1070 }
1071 if (nMask & 0x00030000)
1072 {
1073 if (nMask & (1 << 17)) { if (!bd.bit18()) return false; }
1074 if (nMask & (1 << 16)) { if (!bd.bit17()) return false; }
1075 }
1076 }
1077 }
1078 }
1079 if (nMask & 0x0000FFFF)
1080 {
1081 if (nMask & 0x0000FF00)
1082 {
1083 if (nMask & 0x0000F000)
1084 {
1085 if (nMask & 0x0000C000)
1086 {
1087 if (nMask & (1 << 15)) { if (!bd.bit16()) return false; }
1088 if (nMask & (1 << 14)) { if (!bd.bit15()) return false; }
1089 }
1090 if (nMask & 0x00003000)
1091 {
1092 if (nMask & (1 << 13)) { if (!bd.bit14()) return false; }
1093 if (nMask & (1 << 12)) { if (!bd.bit13()) return false; }
1094 }
1095 }
1096 if (nMask & 0x00000F00)
1097 {
1098 if (nMask & 0x00000C00)
1099 {
1100 if (nMask & (1 << 11)) { if (!bd.bit12()) return false; }
1101 if (nMask & (1 << 10)) { if (!bd.bit11()) return false; }
1102 }
1103 if (nMask & 0x00000300)
1104 {
1105 if (nMask & (1 << 9)) { if (!bd.bit10()) return false; }
1106 if (nMask & (1 << 8)) { if (!bd.bit9()) return false; }
1107 }
1108 }
1109 }
1110 if (nMask & 0x000000FF)
1111 {
1112 if (nMask & 0x000000F0)
1113 {
1114 if (nMask & 0x000000C0)
1115 {
1116 if (nMask & (1 << 7)) { if (!bd.bit8()) return false; }
1117 if (nMask & (1 << 6)) { if (!bd.bit7()) return false; }
1118 }
1119 if (nMask & 0x00000030)
1120 {
1121 if (nMask & (1 << 5)) { if (!bd.bit6()) return false; }
1122 if (nMask & (1 << 4)) { if (!bd.bit5()) return false; }
1123 }
1124 }
1125 if (nMask & 0x0000000F)
1126 {
1127 if (nMask & 0x0000000C)
1128 {
1129 if (nMask & (1 << 3)) { if (!bd.bit4()) return false; }
1130 if (nMask & (1 << 2)) { if (!bd.bit3()) return false; }
1131 }
1132 if (nMask & 0x00000003)
1133 {
1134 if (nMask & (1 << 1)) { if (!bd.bit2()) return false; }
1135 if (nMask & (1 << 0)) { if (!bd.bit1()) return false; }
1136 }
1137 }
1138 }
1139 }
1140 }
1141 return true;
1142}
1143
1144// 64-bit handlers
1145
1146struct OdTrVisFlagsBinTreeBase64 : public OdTrVisFlagsBinTreeBase32
1147{
1148 inline void bit33() {}
1149 inline void bit34() {}
1150 inline void bit35() {}
1151 inline void bit36() {}
1152 inline void bit37() {}
1153 inline void bit38() {}
1154 inline void bit39() {}
1155 inline void bit40() {}
1156 inline void bit41() {}
1157 inline void bit42() {}
1158 inline void bit43() {}
1159 inline void bit44() {}
1160 inline void bit45() {}
1161 inline void bit46() {}
1162 inline void bit47() {}
1163 inline void bit48() {}
1164 inline void bit49() {}
1165 inline void bit50() {}
1166 inline void bit51() {}
1167 inline void bit52() {}
1168 inline void bit53() {}
1169 inline void bit54() {}
1170 inline void bit55() {}
1171 inline void bit56() {}
1172 inline void bit57() {}
1173 inline void bit58() {}
1174 inline void bit59() {}
1175 inline void bit60() {}
1176 inline void bit61() {}
1177 inline void bit62() {}
1178 inline void bit63() {}
1179 inline void bit64() {}
1180};
1181
1182struct OdTrVisFlagsBinTreeBreakBase64 : public OdTrVisFlagsBinTreeBreakBase32
1183{
1184 inline bool bit33() { return true; }
1185 inline bool bit34() { return true; }
1186 inline bool bit35() { return true; }
1187 inline bool bit36() { return true; }
1188 inline bool bit37() { return true; }
1189 inline bool bit38() { return true; }
1190 inline bool bit39() { return true; }
1191 inline bool bit40() { return true; }
1192 inline bool bit41() { return true; }
1193 inline bool bit42() { return true; }
1194 inline bool bit43() { return true; }
1195 inline bool bit44() { return true; }
1196 inline bool bit45() { return true; }
1197 inline bool bit46() { return true; }
1198 inline bool bit47() { return true; }
1199 inline bool bit48() { return true; }
1200 inline bool bit49() { return true; }
1201 inline bool bit50() { return true; }
1202 inline bool bit51() { return true; }
1203 inline bool bit52() { return true; }
1204 inline bool bit53() { return true; }
1205 inline bool bit54() { return true; }
1206 inline bool bit55() { return true; }
1207 inline bool bit56() { return true; }
1208 inline bool bit57() { return true; }
1209 inline bool bit58() { return true; }
1210 inline bool bit59() { return true; }
1211 inline bool bit60() { return true; }
1212 inline bool bit61() { return true; }
1213 inline bool bit62() { return true; }
1214 inline bool bit63() { return true; }
1215 inline bool bit64() { return true; }
1216};
1217
1218template <typename RedirBase>
1219struct OdTrVisFlagsBinTreeRedir64 : public OdTrVisFlagsBinTreeRedir32<RedirBase>
1220{
1221 inline void bit33() { RedirBase::bit(32); }
1222 inline void bit34() { RedirBase::bit(33); }
1223 inline void bit35() { RedirBase::bit(34); }
1224 inline void bit36() { RedirBase::bit(35); }
1225 inline void bit37() { RedirBase::bit(36); }
1226 inline void bit38() { RedirBase::bit(37); }
1227 inline void bit39() { RedirBase::bit(38); }
1228 inline void bit40() { RedirBase::bit(39); }
1229 inline void bit41() { RedirBase::bit(40); }
1230 inline void bit42() { RedirBase::bit(41); }
1231 inline void bit43() { RedirBase::bit(42); }
1232 inline void bit44() { RedirBase::bit(43); }
1233 inline void bit45() { RedirBase::bit(44); }
1234 inline void bit46() { RedirBase::bit(45); }
1235 inline void bit47() { RedirBase::bit(46); }
1236 inline void bit48() { RedirBase::bit(47); }
1237 inline void bit49() { RedirBase::bit(48); }
1238 inline void bit50() { RedirBase::bit(49); }
1239 inline void bit51() { RedirBase::bit(50); }
1240 inline void bit52() { RedirBase::bit(51); }
1241 inline void bit53() { RedirBase::bit(52); }
1242 inline void bit54() { RedirBase::bit(53); }
1243 inline void bit55() { RedirBase::bit(54); }
1244 inline void bit56() { RedirBase::bit(55); }
1245 inline void bit57() { RedirBase::bit(56); }
1246 inline void bit58() { RedirBase::bit(57); }
1247 inline void bit59() { RedirBase::bit(58); }
1248 inline void bit60() { RedirBase::bit(59); }
1249 inline void bit61() { RedirBase::bit(60); }
1250 inline void bit62() { RedirBase::bit(61); }
1251 inline void bit63() { RedirBase::bit(62); }
1252 inline void bit64() { RedirBase::bit(63); }
1253};
1254
1255template <typename RedirBase>
1256struct OdTrVisFlagsBinTreeReadirBreak64 : public OdTrVisFlagsBinTreeReadirBreak32<RedirBase>
1257{
1258 inline bool bit33() { return RedirBase::bit(32); }
1259 inline bool bit34() { return RedirBase::bit(33); }
1260 inline bool bit35() { return RedirBase::bit(34); }
1261 inline bool bit36() { return RedirBase::bit(35); }
1262 inline bool bit37() { return RedirBase::bit(36); }
1263 inline bool bit38() { return RedirBase::bit(37); }
1264 inline bool bit39() { return RedirBase::bit(38); }
1265 inline bool bit40() { return RedirBase::bit(39); }
1266 inline bool bit41() { return RedirBase::bit(40); }
1267 inline bool bit42() { return RedirBase::bit(41); }
1268 inline bool bit43() { return RedirBase::bit(42); }
1269 inline bool bit44() { return RedirBase::bit(43); }
1270 inline bool bit45() { return RedirBase::bit(44); }
1271 inline bool bit46() { return RedirBase::bit(45); }
1272 inline bool bit47() { return RedirBase::bit(46); }
1273 inline bool bit48() { return RedirBase::bit(47); }
1274 inline bool bit49() { return RedirBase::bit(48); }
1275 inline bool bit50() { return RedirBase::bit(49); }
1276 inline bool bit51() { return RedirBase::bit(50); }
1277 inline bool bit52() { return RedirBase::bit(51); }
1278 inline bool bit53() { return RedirBase::bit(52); }
1279 inline bool bit54() { return RedirBase::bit(53); }
1280 inline bool bit55() { return RedirBase::bit(54); }
1281 inline bool bit56() { return RedirBase::bit(55); }
1282 inline bool bit57() { return RedirBase::bit(56); }
1283 inline bool bit58() { return RedirBase::bit(57); }
1284 inline bool bit59() { return RedirBase::bit(58); }
1285 inline bool bit60() { return RedirBase::bit(59); }
1286 inline bool bit61() { return RedirBase::bit(60); }
1287 inline bool bit62() { return RedirBase::bit(61); }
1288 inline bool bit63() { return RedirBase::bit(62); }
1289 inline bool bit64() { return RedirBase::bit(63); }
1290};
1291
1292template <typename BitDo> /* internal */
1293struct OdTrVisFlagsBinTree64_UpperBitsWrap
1294{
1295 BitDo &outBits;
1296 OdTrVisFlagsBinTree64_UpperBitsWrap(BitDo &_outBits) : outBits(_outBits) { }
1297 inline void bit1() { outBits.bit33(); }
1298 inline void bit2() { outBits.bit34(); }
1299 inline void bit3() { outBits.bit35(); }
1300 inline void bit4() { outBits.bit36(); }
1301 inline void bit5() { outBits.bit37(); }
1302 inline void bit6() { outBits.bit38(); }
1303 inline void bit7() { outBits.bit39(); }
1304 inline void bit8() { outBits.bit40(); }
1305 inline void bit9() { outBits.bit41(); }
1306 inline void bit10() { outBits.bit42(); }
1307 inline void bit11() { outBits.bit43(); }
1308 inline void bit12() { outBits.bit44(); }
1309 inline void bit13() { outBits.bit45(); }
1310 inline void bit14() { outBits.bit46(); }
1311 inline void bit15() { outBits.bit47(); }
1312 inline void bit16() { outBits.bit48(); }
1313 inline void bit17() { outBits.bit49(); }
1314 inline void bit18() { outBits.bit50(); }
1315 inline void bit19() { outBits.bit51(); }
1316 inline void bit20() { outBits.bit52(); }
1317 inline void bit21() { outBits.bit53(); }
1318 inline void bit22() { outBits.bit54(); }
1319 inline void bit23() { outBits.bit55(); }
1320 inline void bit24() { outBits.bit56(); }
1321 inline void bit25() { outBits.bit57(); }
1322 inline void bit26() { outBits.bit58(); }
1323 inline void bit27() { outBits.bit59(); }
1324 inline void bit28() { outBits.bit60(); }
1325 inline void bit29() { outBits.bit61(); }
1326 inline void bit30() { outBits.bit62(); }
1327 inline void bit31() { outBits.bit63(); }
1328 inline void bit32() { outBits.bit64(); }
1329};
1330
1331template <typename BitDo> /* internal */
1332struct OdTrVisFlagsBinTreeBreak64_UpperBitsWrap
1333{
1334 BitDo &outBits;
1335 OdTrVisFlagsBinTreeBreak64_UpperBitsWrap(BitDo &_outBits) : outBits(_outBits) { }
1336 inline bool bit1() { return outBits.bit33(); }
1337 inline bool bit2() { return outBits.bit34(); }
1338 inline bool bit3() { return outBits.bit35(); }
1339 inline bool bit4() { return outBits.bit36(); }
1340 inline bool bit5() { return outBits.bit37(); }
1341 inline bool bit6() { return outBits.bit38(); }
1342 inline bool bit7() { return outBits.bit39(); }
1343 inline bool bit8() { return outBits.bit40(); }
1344 inline bool bit9() { return outBits.bit41(); }
1345 inline bool bit10() { return outBits.bit42(); }
1346 inline bool bit11() { return outBits.bit43(); }
1347 inline bool bit12() { return outBits.bit44(); }
1348 inline bool bit13() { return outBits.bit45(); }
1349 inline bool bit14() { return outBits.bit46(); }
1350 inline bool bit15() { return outBits.bit47(); }
1351 inline bool bit16() { return outBits.bit48(); }
1352 inline bool bit17() { return outBits.bit49(); }
1353 inline bool bit18() { return outBits.bit50(); }
1354 inline bool bit19() { return outBits.bit51(); }
1355 inline bool bit20() { return outBits.bit52(); }
1356 inline bool bit21() { return outBits.bit53(); }
1357 inline bool bit22() { return outBits.bit54(); }
1358 inline bool bit23() { return outBits.bit55(); }
1359 inline bool bit24() { return outBits.bit56(); }
1360 inline bool bit25() { return outBits.bit57(); }
1361 inline bool bit26() { return outBits.bit58(); }
1362 inline bool bit27() { return outBits.bit59(); }
1363 inline bool bit28() { return outBits.bit60(); }
1364 inline bool bit29() { return outBits.bit61(); }
1365 inline bool bit30() { return outBits.bit62(); }
1366 inline bool bit31() { return outBits.bit63(); }
1367 inline bool bit32() { return outBits.bit64(); }
1368};
1369
1370template <typename BitDo>
1371inline void odTrVisFlagsBinTree(OdUInt64 nMask, BitDo &bd)
1372{
1373 if (nMask)
1374 {
1375 ::odTrVisFlagsBinTree((OdUInt32)nMask, bd);
1376 OdTrVisFlagsBinTree64_UpperBitsWrap<BitDo> _upper_bits_wrap(bd);
1377 ::odTrVisFlagsBinTree((OdUInt32)(nMask >> 32), _upper_bits_wrap);
1378 }
1379}
1380
1381template <typename BitDo>
1382inline void odTrVisFlagsBinTreeRev(OdUInt64 nMask, BitDo &bd)
1383{
1384 if (nMask)
1385 {
1386 OdTrVisFlagsBinTree64_UpperBitsWrap<BitDo> _upper_bits_wrap(bd);
1387 ::odTrVisFlagsBinTreeRev((OdUInt32)(nMask >> 32), _upper_bits_wrap);
1388 ::odTrVisFlagsBinTreeRev((OdUInt32)nMask, bd);
1389 }
1390}
1391
1392template <typename BitDo>
1393inline bool odTrVisFlagsBinTreeBreak(OdUInt64 nMask, BitDo &bd)
1394{
1395 if (nMask)
1396 {
1397 if (!::odTrVisFlagsBinTreeBreak((OdUInt32)nMask, bd)) return false;
1398 OdTrVisFlagsBinTreeBreak64_UpperBitsWrap<BitDo> _upper_bits_wrap(bd);
1399 if (!::odTrVisFlagsBinTreeBreak((OdUInt32)(nMask >> 32), _upper_bits_wrap)) return false;
1400 }
1401 return true;
1402}
1403
1404template <typename BitDo>
1405inline bool odTrVisFlagsBinTreeBreakRev(OdUInt64 nMask, BitDo &bd)
1406{
1407 if (nMask)
1408 {
1409 OdTrVisFlagsBinTreeBreak64_UpperBitsWrap<BitDo> _upper_bits_wrap(bd);
1410 if (!::odTrVisFlagsBinTreeBreakRev((OdUInt32)(nMask >> 32), _upper_bits_wrap)) return false;
1411 if (!::odTrVisFlagsBinTreeBreakRev((OdUInt32)nMask, bd)) return false;
1412 }
1413 return true;
1414}
1415
1416#include "TD_PackPop.h"
1417
1418#endif // _EXTRVISFLAGSBINTREE_INCLUDED_
OdUInt32
unsigned int OdUInt32
Definition OdPlatformSettings.h:768
OdUInt16
unsigned short OdUInt16
Definition OdPlatformSettings.h:745
OdUInt8
unsigned char OdUInt8
Definition OdPlatformSettings.h:744
TD_PackPop.h
TD_PackPush.h
odTrVisFlagsBinTreeBreakRev
bool odTrVisFlagsBinTreeBreakRev(OdUInt8 nMask, BitDo &bd)
Definition TrVisFlagsBinTree.h:186
odTrVisFlagsBinTreeRev
void odTrVisFlagsBinTreeRev(OdUInt8 nMask, BitDo &bd)
Definition TrVisFlagsBinTree.h:117
odTrVisFlagsBinTree
void odTrVisFlagsBinTree(OdUInt8 nMask, BitDo &bd)
Definition TrVisFlagsBinTree.h:83
odTrVisFlagsBinTreeBreak
bool odTrVisFlagsBinTreeBreak(OdUInt8 nMask, BitDo &bd)
Definition TrVisFlagsBinTree.h:151
OdTrVisFlagsBinTree64_UpperBitsWrap
Definition TrVisFlagsBinTree.h:1294
OdTrVisFlagsBinTree64_UpperBitsWrap::bit32
void bit32()
Definition TrVisFlagsBinTree.h:1328
OdTrVisFlagsBinTree64_UpperBitsWrap::bit24
void bit24()
Definition TrVisFlagsBinTree.h:1320
OdTrVisFlagsBinTree64_UpperBitsWrap::bit6
void bit6()
Definition TrVisFlagsBinTree.h:1302
OdTrVisFlagsBinTree64_UpperBitsWrap::bit18
void bit18()
Definition TrVisFlagsBinTree.h:1314
OdTrVisFlagsBinTree64_UpperBitsWrap::bit1
void bit1()
Definition TrVisFlagsBinTree.h:1297
OdTrVisFlagsBinTree64_UpperBitsWrap::bit14
void bit14()
Definition TrVisFlagsBinTree.h:1310
OdTrVisFlagsBinTree64_UpperBitsWrap::bit27
void bit27()
Definition TrVisFlagsBinTree.h:1323
OdTrVisFlagsBinTree64_UpperBitsWrap::bit8
void bit8()
Definition TrVisFlagsBinTree.h:1304
OdTrVisFlagsBinTree64_UpperBitsWrap::bit23
void bit23()
Definition TrVisFlagsBinTree.h:1319
OdTrVisFlagsBinTree64_UpperBitsWrap::bit17
void bit17()
Definition TrVisFlagsBinTree.h:1313
OdTrVisFlagsBinTree64_UpperBitsWrap::bit26
void bit26()
Definition TrVisFlagsBinTree.h:1322
OdTrVisFlagsBinTree64_UpperBitsWrap::bit3
void bit3()
Definition TrVisFlagsBinTree.h:1299
OdTrVisFlagsBinTree64_UpperBitsWrap::bit22
void bit22()
Definition TrVisFlagsBinTree.h:1318
OdTrVisFlagsBinTree64_UpperBitsWrap::OdTrVisFlagsBinTree64_UpperBitsWrap
OdTrVisFlagsBinTree64_UpperBitsWrap(BitDo &_outBits)
Definition TrVisFlagsBinTree.h:1296
OdTrVisFlagsBinTree64_UpperBitsWrap::bit13
void bit13()
Definition TrVisFlagsBinTree.h:1309
OdTrVisFlagsBinTree64_UpperBitsWrap::bit12
void bit12()
Definition TrVisFlagsBinTree.h:1308
OdTrVisFlagsBinTree64_UpperBitsWrap::bit29
void bit29()
Definition TrVisFlagsBinTree.h:1325
OdTrVisFlagsBinTree64_UpperBitsWrap::bit30
void bit30()
Definition TrVisFlagsBinTree.h:1326
OdTrVisFlagsBinTree64_UpperBitsWrap::bit10
void bit10()
Definition TrVisFlagsBinTree.h:1306
OdTrVisFlagsBinTree64_UpperBitsWrap::bit20
void bit20()
Definition TrVisFlagsBinTree.h:1316
OdTrVisFlagsBinTree64_UpperBitsWrap::bit2
void bit2()
Definition TrVisFlagsBinTree.h:1298
OdTrVisFlagsBinTree64_UpperBitsWrap::bit5
void bit5()
Definition TrVisFlagsBinTree.h:1301
OdTrVisFlagsBinTree64_UpperBitsWrap::bit11
void bit11()
Definition TrVisFlagsBinTree.h:1307
OdTrVisFlagsBinTree64_UpperBitsWrap::bit15
void bit15()
Definition TrVisFlagsBinTree.h:1311
OdTrVisFlagsBinTree64_UpperBitsWrap::bit4
void bit4()
Definition TrVisFlagsBinTree.h:1300
OdTrVisFlagsBinTree64_UpperBitsWrap::bit25
void bit25()
Definition TrVisFlagsBinTree.h:1321
OdTrVisFlagsBinTree64_UpperBitsWrap::bit21
void bit21()
Definition TrVisFlagsBinTree.h:1317
OdTrVisFlagsBinTree64_UpperBitsWrap::bit28
void bit28()
Definition TrVisFlagsBinTree.h:1324
OdTrVisFlagsBinTree64_UpperBitsWrap::bit7
void bit7()
Definition TrVisFlagsBinTree.h:1303
OdTrVisFlagsBinTree64_UpperBitsWrap::bit9
void bit9()
Definition TrVisFlagsBinTree.h:1305
OdTrVisFlagsBinTree64_UpperBitsWrap::bit16
void bit16()
Definition TrVisFlagsBinTree.h:1312
OdTrVisFlagsBinTree64_UpperBitsWrap::bit19
void bit19()
Definition TrVisFlagsBinTree.h:1315
OdTrVisFlagsBinTree64_UpperBitsWrap::bit31
void bit31()
Definition TrVisFlagsBinTree.h:1327
OdTrVisFlagsBinTree64_UpperBitsWrap::outBits
BitDo & outBits
Definition TrVisFlagsBinTree.h:1295
OdTrVisFlagsBinTreeBreak64_UpperBitsWrap
Definition TrVisFlagsBinTree.h:1333
OdTrVisFlagsBinTreeBreak64_UpperBitsWrap::outBits
BitDo & outBits
Definition TrVisFlagsBinTree.h:1334
OdTrVisFlagsBinTreeBreak64_UpperBitsWrap::bit17
bool bit17()
Definition TrVisFlagsBinTree.h:1352
OdTrVisFlagsBinTreeBreak64_UpperBitsWrap::bit2
bool bit2()
Definition TrVisFlagsBinTree.h:1337
OdTrVisFlagsBinTreeBreak64_UpperBitsWrap::bit23
bool bit23()
Definition TrVisFlagsBinTree.h:1358
OdTrVisFlagsBinTreeBreak64_UpperBitsWrap::bit32
bool bit32()
Definition TrVisFlagsBinTree.h:1367
OdTrVisFlagsBinTreeBreak64_UpperBitsWrap::bit13
bool bit13()
Definition TrVisFlagsBinTree.h:1348
OdTrVisFlagsBinTreeBreak64_UpperBitsWrap::bit16
bool bit16()
Definition TrVisFlagsBinTree.h:1351
OdTrVisFlagsBinTreeBreak64_UpperBitsWrap::bit20
bool bit20()
Definition TrVisFlagsBinTree.h:1355
OdTrVisFlagsBinTreeBreak64_UpperBitsWrap::bit24
bool bit24()
Definition TrVisFlagsBinTree.h:1359
OdTrVisFlagsBinTreeBreak64_UpperBitsWrap::bit26
bool bit26()
Definition TrVisFlagsBinTree.h:1361
OdTrVisFlagsBinTreeBreak64_UpperBitsWrap::bit7
bool bit7()
Definition TrVisFlagsBinTree.h:1342
OdTrVisFlagsBinTreeBreak64_UpperBitsWrap::bit14
bool bit14()
Definition TrVisFlagsBinTree.h:1349
OdTrVisFlagsBinTreeBreak64_UpperBitsWrap::bit8
bool bit8()
Definition TrVisFlagsBinTree.h:1343
OdTrVisFlagsBinTreeBreak64_UpperBitsWrap::bit11
bool bit11()
Definition TrVisFlagsBinTree.h:1346
OdTrVisFlagsBinTreeBreak64_UpperBitsWrap::bit6
bool bit6()
Definition TrVisFlagsBinTree.h:1341
OdTrVisFlagsBinTreeBreak64_UpperBitsWrap::bit4
bool bit4()
Definition TrVisFlagsBinTree.h:1339
OdTrVisFlagsBinTreeBreak64_UpperBitsWrap::bit10
bool bit10()
Definition TrVisFlagsBinTree.h:1345
OdTrVisFlagsBinTreeBreak64_UpperBitsWrap::bit31
bool bit31()
Definition TrVisFlagsBinTree.h:1366
OdTrVisFlagsBinTreeBreak64_UpperBitsWrap::bit1
bool bit1()
Definition TrVisFlagsBinTree.h:1336
OdTrVisFlagsBinTreeBreak64_UpperBitsWrap::bit15
bool bit15()
Definition TrVisFlagsBinTree.h:1350
OdTrVisFlagsBinTreeBreak64_UpperBitsWrap::bit22
bool bit22()
Definition TrVisFlagsBinTree.h:1357
OdTrVisFlagsBinTreeBreak64_UpperBitsWrap::bit3
bool bit3()
Definition TrVisFlagsBinTree.h:1338
OdTrVisFlagsBinTreeBreak64_UpperBitsWrap::bit28
bool bit28()
Definition TrVisFlagsBinTree.h:1363
OdTrVisFlagsBinTreeBreak64_UpperBitsWrap::OdTrVisFlagsBinTreeBreak64_UpperBitsWrap
OdTrVisFlagsBinTreeBreak64_UpperBitsWrap(BitDo &_outBits)
Definition TrVisFlagsBinTree.h:1335
OdTrVisFlagsBinTreeBreak64_UpperBitsWrap::bit27
bool bit27()
Definition TrVisFlagsBinTree.h:1362
OdTrVisFlagsBinTreeBreak64_UpperBitsWrap::bit9
bool bit9()
Definition TrVisFlagsBinTree.h:1344
OdTrVisFlagsBinTreeBreak64_UpperBitsWrap::bit21
bool bit21()
Definition TrVisFlagsBinTree.h:1356
OdTrVisFlagsBinTreeBreak64_UpperBitsWrap::bit19
bool bit19()
Definition TrVisFlagsBinTree.h:1354
OdTrVisFlagsBinTreeBreak64_UpperBitsWrap::bit12
bool bit12()
Definition TrVisFlagsBinTree.h:1347
OdTrVisFlagsBinTreeBreak64_UpperBitsWrap::bit29
bool bit29()
Definition TrVisFlagsBinTree.h:1364
OdTrVisFlagsBinTreeBreak64_UpperBitsWrap::bit18
bool bit18()
Definition TrVisFlagsBinTree.h:1353
OdTrVisFlagsBinTreeBreak64_UpperBitsWrap::bit5
bool bit5()
Definition TrVisFlagsBinTree.h:1340
OdTrVisFlagsBinTreeBreak64_UpperBitsWrap::bit25
bool bit25()
Definition TrVisFlagsBinTree.h:1360
OdTrVisFlagsBinTreeBreak64_UpperBitsWrap::bit30
bool bit30()
Definition TrVisFlagsBinTree.h:1365
Generated on Tue Apr 15 2025 11:30:07