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