1#if defined(OBJECTITER__HPP) && !defined(OBJECTITER__INL) 2#define OBJECTITER__INL 3 4/* $Id: objectiter.inl 502193 2016-05-23 12:28:12Z gouriano $ 5* =========================================================================== 6* 7* PUBLIC DOMAIN NOTICE 8* National Center for Biotechnology Information 9* 10* This software/database is a "United States Government Work" under the 11* terms of the United States Copyright Act. It was written as part of 12* the author's official duties as a United States Government employee and 13* thus cannot be copyrighted. This software/database is freely available 14* to the public for use. The National Library of Medicine and the U.S. 15* Government have not placed any restriction on its use or reproduction. 16* 17* Although all reasonable efforts have been taken to ensure the accuracy 18* and reliability of the software and data, the NLM and the U.S. 19* Government do not and cannot warrant the performance or results that 20* may be obtained by using this software or data. The NLM and the U.S. 21* Government disclaim all warranties, express or implied, including 22* warranties of performance, merchantability or fitness for any particular 23* purpose. 24* 25* Please cite the author in any work or product based on this material. 26* 27* =========================================================================== 28* 29* Author: Eugene Vasilchenko 30* 31* File Description: 32* !!! PUT YOUR DESCRIPTION HERE !!! 33*/ 34 35///////////////////////////////////////////////////////////////////////////// 36// iterators 37///////////////////////////////////////////////////////////////////////////// 38 39// container interface 40 41inline 42CConstObjectInfoEI::CConstObjectInfoEI(void) 43{ 44} 45 46inline 47bool CConstObjectInfoEI::CheckValid(void) const 48{ 49 return m_Iterator.Valid(); 50} 51 52inline 53bool CConstObjectInfoEI::Valid(void) const 54{ 55 return CheckValid(); 56} 57 58inline 59void CConstObjectInfoEI::Next(void) 60{ 61 _ASSERT(CheckValid()); 62 m_Iterator.Next(); 63} 64 65inline 66CConstObjectInfoEI& CConstObjectInfoEI::operator++(void) 67{ 68 Next(); 69 return *this; 70} 71 72inline 73CConstObjectInfo CConstObjectInfoEI::GetElement(void) const 74{ 75 _ASSERT(CheckValid()); 76 return m_Iterator.Get(); 77} 78 79inline 80CConstObjectInfo CConstObjectInfoEI::operator*(void) const 81{ 82 _ASSERT(CheckValid()); 83 return m_Iterator.Get(); 84} 85 86/* 87inline 88CConstObjectInfo CConstObjectInfoEI::operator->(void) const 89{ 90 _ASSERT(CheckValid()); 91 return m_Iterator.Get(); 92} 93*/ 94 95inline 96CObjectInfoEI::CObjectInfoEI(void) 97{ 98} 99 100inline 101bool CObjectInfoEI::CheckValid(void) const 102{ 103 return m_Iterator.Valid(); 104} 105 106inline 107bool CObjectInfoEI::Valid(void) const 108{ 109 return CheckValid(); 110} 111 112inline 113void CObjectInfoEI::Next(void) 114{ 115 _ASSERT(CheckValid()); 116 m_Iterator.Next(); 117} 118 119inline 120CObjectInfoEI& CObjectInfoEI::operator++(void) 121{ 122 Next(); 123 return *this; 124} 125 126inline 127CObjectInfo CObjectInfoEI::GetElement(void) const 128{ 129 _ASSERT(CheckValid()); 130 return m_Iterator.Get(); 131} 132 133inline 134CObjectInfo CObjectInfoEI::operator*(void) const 135{ 136 _ASSERT(CheckValid()); 137 return m_Iterator.Get(); 138} 139 140inline 141void CObjectInfoEI::Erase(void) 142{ 143 _ASSERT(CheckValid()); 144 m_Iterator.Erase(); 145} 146 147// class interface 148 149inline 150CObjectTypeInfoII::CObjectTypeInfoII(void) 151 : m_ItemIndex(kFirstMemberIndex), 152 m_LastItemIndex(kInvalidMember) 153{ 154} 155 156inline 157void CObjectTypeInfoII::Init(const CClassTypeInfoBase* typeInfo, 158 TMemberIndex index) 159{ 160 m_OwnerType = typeInfo; 161 m_ItemIndex = index; 162 m_LastItemIndex = typeInfo->GetItems().LastIndex(); 163} 164 165inline 166void CObjectTypeInfoII::Init(const CClassTypeInfoBase* typeInfo) 167{ 168 Init(typeInfo, kFirstMemberIndex); 169} 170 171inline 172CObjectTypeInfoII::CObjectTypeInfoII(const CClassTypeInfoBase* typeInfo) 173{ 174 Init(typeInfo); 175} 176 177inline 178CObjectTypeInfoII::CObjectTypeInfoII(const CClassTypeInfoBase* typeInfo, 179 TMemberIndex index) 180{ 181 Init(typeInfo, index); 182} 183 184inline 185const CObjectTypeInfo& CObjectTypeInfoII::GetOwnerType(void) const 186{ 187 return m_OwnerType; 188} 189 190inline 191const CClassTypeInfoBase* CObjectTypeInfoII::GetClassTypeInfoBase(void) const 192{ 193 return CTypeConverter<CClassTypeInfoBase>:: 194 SafeCast(GetOwnerType().GetTypeInfo()); 195} 196 197inline 198bool CObjectTypeInfoII::CheckValid(void) const 199{ 200 return m_ItemIndex >= kFirstMemberIndex && 201 m_ItemIndex <= m_LastItemIndex; 202} 203 204inline 205TMemberIndex CObjectTypeInfoII::GetItemIndex(void) const 206{ 207 _ASSERT(CheckValid()); 208 return m_ItemIndex; 209} 210 211inline 212const CItemInfo* CObjectTypeInfoII::GetItemInfo(void) const 213{ 214 return GetClassTypeInfoBase()->GetItems().GetItemInfo(GetItemIndex()); 215} 216 217inline 218const string& CObjectTypeInfoII::GetAlias(void) const 219{ 220 return GetItemInfo()->GetId().GetName(); 221} 222 223inline 224bool CObjectTypeInfoII::Valid(void) const 225{ 226 return CheckValid(); 227} 228 229inline 230void CObjectTypeInfoII::Next(void) 231{ 232 _ASSERT(CheckValid()); 233 ++m_ItemIndex; 234} 235 236inline 237bool CObjectTypeInfoII::operator==(const CObjectTypeInfoII& iter) const 238{ 239 return GetOwnerType() == iter.GetOwnerType() && 240 GetItemIndex() == iter.GetItemIndex(); 241} 242 243inline 244bool CObjectTypeInfoII::operator!=(const CObjectTypeInfoII& iter) const 245{ 246 return GetOwnerType() != iter.GetOwnerType() || 247 GetItemIndex() == iter.GetItemIndex(); 248} 249 250// CObjectTypeInfoMI ////////////////////////////////////////////////////// 251 252inline 253CObjectTypeInfoMI::CObjectTypeInfoMI(void) 254{ 255} 256 257inline 258CObjectTypeInfoMI::CObjectTypeInfoMI(const CObjectTypeInfo& info) 259 : CParent(info.GetClassTypeInfo()) 260{ 261} 262 263inline 264CObjectTypeInfoMI::CObjectTypeInfoMI(const CObjectTypeInfo& info, 265 TMemberIndex index) 266 : CParent(info.GetClassTypeInfo(), index) 267{ 268} 269 270inline 271CObjectTypeInfoMI& CObjectTypeInfoMI::operator++(void) 272{ 273 Next(); 274 return *this; 275} 276 277inline 278void CObjectTypeInfoMI::Init(const CObjectTypeInfo& info) 279{ 280 CParent::Init(info.GetClassTypeInfo()); 281} 282 283inline 284void CObjectTypeInfoMI::Init(const CObjectTypeInfo& info, 285 TMemberIndex index) 286{ 287 CParent::Init(info.GetClassTypeInfo(), index); 288} 289 290inline 291CObjectTypeInfoMI& CObjectTypeInfoMI::operator=(const CObjectTypeInfo& info) 292{ 293 Init(info); 294 return *this; 295} 296 297inline 298const CClassTypeInfo* CObjectTypeInfoMI::GetClassTypeInfo(void) const 299{ 300 return GetOwnerType().GetClassTypeInfo(); 301} 302 303inline 304CObjectTypeInfo CObjectTypeInfoMI::GetClassType(void) const 305{ 306 return GetOwnerType(); 307} 308 309inline 310TMemberIndex CObjectTypeInfoMI::GetMemberIndex(void) const 311{ 312 return GetItemIndex(); 313} 314 315inline 316const CMemberInfo* CObjectTypeInfoMI::GetMemberInfo(void) const 317{ 318 return GetClassTypeInfo()->GetMemberInfo(GetMemberIndex()); 319} 320 321inline 322CMemberInfo* CObjectTypeInfoMI::GetNCMemberInfo(void) const 323{ 324 return const_cast<CMemberInfo*>(GetMemberInfo()); 325} 326 327inline 328CObjectTypeInfoMI::operator CObjectTypeInfo(void) const 329{ 330 return GetMemberInfo()->GetTypeInfo(); 331} 332 333inline 334CObjectTypeInfo CObjectTypeInfoMI::GetMemberType(void) const 335{ 336 return GetMemberInfo()->GetTypeInfo(); 337} 338 339inline 340CObjectTypeInfo CObjectTypeInfoMI::operator*(void) const 341{ 342 return GetMemberInfo()->GetTypeInfo(); 343} 344 345// CObjectTypeInfoVI ////////////////////////////////////////////////////// 346 347inline 348CObjectTypeInfoVI::CObjectTypeInfoVI(const CObjectTypeInfo& info) 349 : CParent(info.GetChoiceTypeInfo()) 350{ 351} 352 353inline 354CObjectTypeInfoVI::CObjectTypeInfoVI(const CObjectTypeInfo& info, 355 TMemberIndex index) 356 : CParent(info.GetChoiceTypeInfo(), index) 357{ 358} 359 360inline 361CObjectTypeInfoVI& CObjectTypeInfoVI::operator++(void) 362{ 363 Next(); 364 return *this; 365} 366 367inline 368void CObjectTypeInfoVI::Init(const CObjectTypeInfo& info) 369{ 370 CParent::Init(info.GetChoiceTypeInfo()); 371} 372 373inline 374void CObjectTypeInfoVI::Init(const CObjectTypeInfo& info, 375 TMemberIndex index) 376{ 377 CParent::Init(info.GetChoiceTypeInfo(), index); 378} 379 380inline 381CObjectTypeInfoVI& CObjectTypeInfoVI::operator=(const CObjectTypeInfo& info) 382{ 383 Init(info); 384 return *this; 385} 386 387inline 388const CChoiceTypeInfo* CObjectTypeInfoVI::GetChoiceTypeInfo(void) const 389{ 390 return GetOwnerType().GetChoiceTypeInfo(); 391} 392 393inline 394CObjectTypeInfo CObjectTypeInfoVI::GetChoiceType(void) const 395{ 396 return GetOwnerType(); 397} 398 399inline 400TMemberIndex CObjectTypeInfoVI::GetVariantIndex(void) const 401{ 402 return GetItemIndex(); 403} 404 405inline 406const CVariantInfo* CObjectTypeInfoVI::GetVariantInfo(void) const 407{ 408 return GetChoiceTypeInfo()->GetVariantInfo(GetVariantIndex()); 409} 410 411inline 412CVariantInfo* CObjectTypeInfoVI::GetNCVariantInfo(void) const 413{ 414 return const_cast<CVariantInfo*>(GetVariantInfo()); 415} 416 417inline 418CObjectTypeInfo CObjectTypeInfoVI::GetVariantType(void) const 419{ 420 return GetVariantInfo()->GetTypeInfo(); 421} 422 423inline 424CObjectTypeInfo CObjectTypeInfoVI::operator*(void) const 425{ 426 return GetVariantInfo()->GetTypeInfo(); 427} 428 429// CConstObjectInfoMI ////////////////////////////////////////////////////// 430 431inline 432CConstObjectInfoMI::CConstObjectInfoMI(void) 433{ 434} 435 436inline 437CConstObjectInfoMI::CConstObjectInfoMI(const CConstObjectInfo& object) 438 : CParent(object), m_Object(object) 439{ 440 _ASSERT(object); 441} 442 443inline 444CConstObjectInfoMI::CConstObjectInfoMI(const CConstObjectInfo& object, 445 TMemberIndex index) 446 : CParent(object, index), m_Object(object) 447{ 448 _ASSERT(object); 449} 450 451inline 452const CConstObjectInfo& 453CConstObjectInfoMI::GetClassObject(void) const 454{ 455 return m_Object; 456} 457 458inline 459CConstObjectInfoMI& 460CConstObjectInfoMI::operator=(const CConstObjectInfo& object) 461{ 462 _ASSERT(object); 463 CParent::Init(object); 464 m_Object = object; 465 return *this; 466} 467 468inline 469bool CConstObjectInfoMI::IsSet(void) const 470{ 471 return CParent::IsSet(GetClassObject()); 472} 473 474inline 475CConstObjectInfo CConstObjectInfoMI::GetMember(void) const 476{ 477 return GetMemberPair(); 478} 479 480inline 481CConstObjectInfo CConstObjectInfoMI::operator*(void) const 482{ 483 return GetMemberPair(); 484} 485 486inline 487CObjectInfoMI::CObjectInfoMI(void) 488{ 489} 490 491inline 492CObjectInfoMI::CObjectInfoMI(const CObjectInfo& object) 493 : CParent(object), m_Object(object) 494{ 495 _ASSERT(object); 496} 497 498inline 499CObjectInfoMI::CObjectInfoMI(const CObjectInfo& object, 500 TMemberIndex index) 501 : CParent(object, index), m_Object(object) 502{ 503 _ASSERT(object); 504} 505 506inline 507CObjectInfoMI& CObjectInfoMI::operator=(const CObjectInfo& object) 508{ 509 _ASSERT(object); 510 CParent::Init(object); 511 m_Object = object; 512 return *this; 513} 514 515inline 516const CObjectInfo& CObjectInfoMI::GetClassObject(void) const 517{ 518 return m_Object; 519} 520 521inline 522bool CObjectInfoMI::IsSet(void) const 523{ 524 return CParent::IsSet(GetClassObject()); 525} 526 527inline 528void CObjectInfoMI::Reset(void) 529{ 530 Erase(); 531} 532 533inline 534CObjectInfo CObjectInfoMI::GetMember(void) const 535{ 536 return GetMemberPair(); 537} 538 539inline 540CObjectInfo CObjectInfoMI::operator*(void) const 541{ 542 return GetMemberPair(); 543} 544 545// choice interface 546 547inline 548CObjectTypeInfoCV::CObjectTypeInfoCV(void) 549 : m_ChoiceTypeInfo(0), m_VariantIndex(kEmptyChoice) 550{ 551} 552 553inline 554CObjectTypeInfoCV::CObjectTypeInfoCV(const CObjectTypeInfo& info) 555 : m_ChoiceTypeInfo(info.GetChoiceTypeInfo()), m_VariantIndex(kEmptyChoice) 556{ 557} 558 559inline 560CObjectTypeInfoCV::CObjectTypeInfoCV(const CConstObjectInfo& object) 561{ 562 const CChoiceTypeInfo* choiceInfo = 563 m_ChoiceTypeInfo = object.GetChoiceTypeInfo(); 564 m_VariantIndex = choiceInfo->GetIndex(object.GetObjectPtr()); 565 _ASSERT(m_VariantIndex <= choiceInfo->GetVariants().LastIndex()); 566} 567 568inline 569CObjectTypeInfoCV::CObjectTypeInfoCV(const CObjectTypeInfo& info, 570 TMemberIndex index) 571{ 572 const CChoiceTypeInfo* choiceInfo = 573 m_ChoiceTypeInfo = info.GetChoiceTypeInfo(); 574 if ( index > choiceInfo->GetVariants().LastIndex() ) 575 index = kEmptyChoice; 576 m_VariantIndex = index; 577} 578 579inline 580const CChoiceTypeInfo* CObjectTypeInfoCV::GetChoiceTypeInfo(void) const 581{ 582 return m_ChoiceTypeInfo; 583} 584 585inline 586TMemberIndex CObjectTypeInfoCV::GetVariantIndex(void) const 587{ 588 return m_VariantIndex; 589} 590 591inline 592bool CObjectTypeInfoCV::Valid(void) const 593{ 594 return GetVariantIndex() != kEmptyChoice; 595} 596 597inline 598void CObjectTypeInfoCV::Init(const CObjectTypeInfo& info) 599{ 600 m_ChoiceTypeInfo = info.GetChoiceTypeInfo(); 601 m_VariantIndex = kEmptyChoice; 602} 603 604inline 605void CObjectTypeInfoCV::Init(const CObjectTypeInfo& info, 606 TMemberIndex index) 607{ 608 m_ChoiceTypeInfo = info.GetChoiceTypeInfo(); 609 m_VariantIndex = index; 610} 611 612inline 613CObjectTypeInfoCV& CObjectTypeInfoCV::operator=(const CObjectTypeInfo& info) 614{ 615 m_ChoiceTypeInfo = info.GetChoiceTypeInfo(); 616 m_VariantIndex = kEmptyChoice; 617 return *this; 618} 619 620inline 621bool CObjectTypeInfoCV::operator==(const CObjectTypeInfoCV& iter) const 622{ 623 _ASSERT(GetChoiceTypeInfo() == iter.GetChoiceTypeInfo()); 624 return GetVariantIndex() == iter.GetVariantIndex(); 625} 626 627inline 628bool CObjectTypeInfoCV::operator!=(const CObjectTypeInfoCV& iter) const 629{ 630 _ASSERT(GetChoiceTypeInfo() == iter.GetChoiceTypeInfo()); 631 return GetVariantIndex() != iter.GetVariantIndex(); 632} 633 634inline 635const CVariantInfo* CObjectTypeInfoCV::GetVariantInfo(void) const 636{ 637 return GetChoiceTypeInfo()->GetVariantInfo(GetVariantIndex()); 638} 639 640inline 641CVariantInfo* CObjectTypeInfoCV::GetNCVariantInfo(void) const 642{ 643 return const_cast<CVariantInfo*>(GetVariantInfo()); 644} 645 646inline 647const string& CObjectTypeInfoCV::GetAlias(void) const 648{ 649 return GetVariantInfo()->GetId().GetName(); 650} 651 652inline 653CObjectTypeInfo CObjectTypeInfoCV::GetChoiceType(void) const 654{ 655 return GetChoiceTypeInfo(); 656} 657 658inline 659CObjectTypeInfoCV::operator CObjectTypeInfo(void) const 660{ 661 return GetVariantInfo()->GetTypeInfo(); 662} 663inline 664CObjectTypeInfo CObjectTypeInfoCV::GetVariantType(void) const 665{ 666 return GetVariantInfo()->GetTypeInfo(); 667} 668 669inline 670CObjectTypeInfo CObjectTypeInfoCV::operator*(void) const 671{ 672 return GetVariantInfo()->GetTypeInfo(); 673} 674 675inline 676CConstObjectInfoCV::CConstObjectInfoCV(void) 677{ 678} 679 680inline 681CConstObjectInfoCV::CConstObjectInfoCV(const CConstObjectInfo& object) 682 : CParent(object), m_Object(object) 683{ 684} 685 686inline 687CConstObjectInfoCV::CConstObjectInfoCV(const CConstObjectInfo& object, 688 TMemberIndex index) 689 : CParent(object, index), m_Object(object) 690{ 691} 692 693inline 694const CConstObjectInfo& CConstObjectInfoCV::GetChoiceObject(void) const 695{ 696 return m_Object; 697} 698 699inline 700CConstObjectInfoCV& CConstObjectInfoCV::operator=(const CConstObjectInfo& object) 701{ 702 CParent::Init(object); 703 m_Object = object; 704 return *this; 705} 706 707inline 708CConstObjectInfo CConstObjectInfoCV::GetVariant(void) const 709{ 710 return GetVariantPair(); 711} 712 713inline 714CConstObjectInfo CConstObjectInfoCV::operator*(void) const 715{ 716 return GetVariantPair(); 717} 718 719inline 720CObjectInfoCV::CObjectInfoCV(void) 721{ 722} 723 724inline 725CObjectInfoCV::CObjectInfoCV(const CObjectInfo& object) 726 : CParent(object), m_Object(object) 727{ 728} 729 730inline 731CObjectInfoCV::CObjectInfoCV(const CObjectInfo& object, 732 TMemberIndex index) 733 : CParent(object, index), m_Object(object) 734{ 735} 736 737inline 738const CObjectInfo& CObjectInfoCV::GetChoiceObject(void) const 739{ 740 return m_Object; 741} 742 743inline 744CObjectInfoCV& CObjectInfoCV::operator=(const CObjectInfo& object) 745{ 746 CParent::Init(object); 747 m_Object = object; 748 return *this; 749} 750 751inline 752CObjectInfo CObjectInfoCV::GetVariant(void) const 753{ 754 return GetVariantPair(); 755} 756 757inline 758CObjectInfo CObjectInfoCV::operator*(void) const 759{ 760 return GetVariantPair(); 761} 762 763///////////////////////////////////////////////////////////////////////////// 764// iterator getters 765///////////////////////////////////////////////////////////////////////////// 766 767// container interface 768 769inline 770CConstObjectInfoEI CConstObjectInfo::BeginElements(void) const 771{ 772 return CElementIterator(*this); 773} 774 775inline 776CObjectInfoEI CObjectInfo::BeginElements(void) const 777{ 778 return CElementIterator(*this); 779} 780 781// class interface 782 783inline 784CObjectTypeInfoMI CObjectTypeInfo::BeginMembers(void) const 785{ 786 return CMemberIterator(*this); 787} 788 789inline 790CObjectTypeInfoMI CObjectTypeInfo::GetMemberIterator(TMemberIndex index) const 791{ 792 return CMemberIterator(*this, index); 793} 794 795inline 796CObjectTypeInfoMI CObjectTypeInfo::FindMember(const string& name) const 797{ 798 return GetMemberIterator(FindMemberIndex(name)); 799} 800 801inline 802CObjectTypeInfoMI CObjectTypeInfo::FindMemberByTag(int tag) const 803{ 804 return GetMemberIterator(FindMemberIndex(tag)); 805} 806 807inline 808CObjectTypeInfoVI CObjectTypeInfo::BeginVariants(void) const 809{ 810 return CVariantIterator(*this); 811} 812 813inline 814CObjectTypeInfoVI CObjectTypeInfo::GetVariantIterator(TMemberIndex index) const 815{ 816 return CVariantIterator(*this, index); 817} 818 819inline 820CObjectTypeInfoVI CObjectTypeInfo::FindVariant(const string& name) const 821{ 822 return GetVariantIterator(FindVariantIndex(name)); 823} 824 825inline 826CObjectTypeInfoVI CObjectTypeInfo::FindVariantByTag(int tag) const 827{ 828 return GetVariantIterator(FindVariantIndex(tag)); 829} 830 831inline 832CConstObjectInfoMI CConstObjectInfo::GetMember(CObjectTypeInfoMI member) const 833{ 834 return CMemberIterator(*this, member.GetMemberIndex()); 835} 836 837 838inline 839CConstObjectInfoMI CConstObjectInfo::BeginMembers(void) const 840{ 841 return CMemberIterator(*this); 842} 843 844inline 845CConstObjectInfoMI CConstObjectInfo::GetClassMemberIterator(TMemberIndex index) const 846{ 847 return CMemberIterator(*this, index); 848} 849 850inline 851CConstObjectInfoMI CConstObjectInfo::FindClassMember(const string& name) const 852{ 853 return GetClassMemberIterator(FindMemberIndex(name)); 854} 855 856inline 857CConstObjectInfoMI CConstObjectInfo::FindClassMemberByTag(int tag) const 858{ 859 return GetClassMemberIterator(FindMemberIndex(tag)); 860} 861 862inline 863CObjectInfoMI CObjectInfo::GetMember(CObjectTypeInfoMI member) const 864{ 865 return CMemberIterator(*this, member.GetMemberIndex()); 866} 867 868inline 869CObjectInfoMI CObjectInfo::BeginMembers(void) const 870{ 871 return CMemberIterator(*this); 872} 873 874inline 875CObjectInfoMI CObjectInfo::GetClassMemberIterator(TMemberIndex index) const 876{ 877 return CMemberIterator(*this, index); 878} 879 880inline 881CObjectInfoMI CObjectInfo::FindClassMember(const string& name) const 882{ 883 return GetClassMemberIterator(FindMemberIndex(name)); 884} 885 886inline 887CObjectInfoMI CObjectInfo::FindClassMemberByTag(int tag) const 888{ 889 return GetClassMemberIterator(FindMemberIndex(tag)); 890} 891 892// choice interface 893 894inline 895CConstObjectInfoCV CConstObjectInfo::GetCurrentChoiceVariant(void) const 896{ 897 return CChoiceVariant(*this, GetCurrentChoiceVariantIndex()); 898} 899 900inline 901CObjectInfoCV CObjectInfo::GetCurrentChoiceVariant(void) const 902{ 903 return CChoiceVariant(*this, GetCurrentChoiceVariantIndex()); 904} 905 906#endif /* def OBJECTITER__HPP && ndef OBJECTITER__INL */ 907