objectiter.inl

ncbi源码

/*
 * ===========================================================================
 * PRODUCTION $Log: objectiter.inl,v $
 * PRODUCTION Revision 1000.0  2003/10/29 17:25:36  gouriano
 * PRODUCTION PRODUCTION: IMPORTED [ORIGINAL] Dev-tree R1.6
 * PRODUCTION
 * ===========================================================================
 */

#if defined(OBJECTITER__HPP)  &&  !defined(OBJECTITER__INL)
#define OBJECTITER__INL

/*  $Id: objectiter.inl,v 1000.0 2003/10/29 17:25:36 gouriano Exp $
* ===========================================================================
*
*                            PUBLIC DOMAIN NOTICE
*               National Center for Biotechnology Information
*
*  This software/database is a "United States Government Work" under the
*  terms of the United States Copyright Act.  It was written as part of
*  the author's official duties as a United States Government employee and
*  thus cannot be copyrighted.  This software/database is freely available
*  to the public for use. The National Library of Medicine and the U.S.
*  Government have not placed any restriction on its use or reproduction.
*
*  Although all reasonable efforts have been taken to ensure the accuracy
*  and reliability of the software and data, the NLM and the U.S.
*  Government do not and cannot warrant the performance or results that
*  may be obtained by using this software or data. The NLM and the U.S.
*  Government disclaim all warranties, express or implied, including
*  warranties of performance, merchantability or fitness for any particular
*  purpose.
*
*  Please cite the author in any work or product based on this material.
*
* ===========================================================================
*
* Author: Eugene Vasilchenko
*
* File Description:
*   !!! PUT YOUR DESCRIPTION HERE !!!
*/

/////////////////////////////////////////////////////////////////////////////
// iterators
/////////////////////////////////////////////////////////////////////////////

// container interface

inline
CConstObjectInfoEI::CConstObjectInfoEI(void)
{
    _DEBUG_ARG(m_LastCall = eNone);
}

inline
bool CConstObjectInfoEI::CheckValid(void) const
{
#if _DEBUG
    if ( m_LastCall != eValid)
        ReportNonValid();
#endif
    return m_Iterator.Valid();
}

inline
bool CConstObjectInfoEI::Valid(void) const
{
    _DEBUG_ARG(m_LastCall = eValid);
    return CheckValid();
}

inline
CConstObjectInfoEI::operator bool(void) const
{
    return Valid();
}

inline
bool CConstObjectInfoEI::operator!(void) const
{
    return !Valid();
}

inline
void CConstObjectInfoEI::Next(void)
{
    _ASSERT(CheckValid());
    m_Iterator.Next();
}

inline
CConstObjectInfoEI& CConstObjectInfoEI::operator++(void)
{
    Next();
    return *this;
}

inline
CConstObjectInfo CConstObjectInfoEI::GetElement(void) const
{
    _ASSERT(CheckValid());
    return m_Iterator.Get();
}

inline
CConstObjectInfo CConstObjectInfoEI::operator*(void) const
{
    _ASSERT(CheckValid());
    return m_Iterator.Get();
}

/*
inline
CConstObjectInfo CConstObjectInfoEI::operator->(void) const
{
    _ASSERT(CheckValid());
    return m_Iterator.Get();
}
*/

inline
CObjectInfoEI::CObjectInfoEI(void)
{
    _DEBUG_ARG(m_LastCall = eNone);
}

inline
bool CObjectInfoEI::CheckValid(void) const
{
#if _DEBUG
    if ( m_LastCall != eValid)
        ReportNonValid();
#endif
    return m_Iterator.Valid();
}

inline
bool CObjectInfoEI::Valid(void) const
{
    _DEBUG_ARG(m_LastCall = eValid);
    return CheckValid();
}

inline
CObjectInfoEI::operator bool(void) const
{
    return Valid();
}

inline
bool CObjectInfoEI::operator!(void) const
{
    return !Valid();
}

inline
void CObjectInfoEI::Next(void)
{
    _ASSERT(CheckValid());
    _DEBUG_ARG(m_LastCall = eNext);
    m_Iterator.Next();
}

inline
CObjectInfoEI& CObjectInfoEI::operator++(void)
{
    Next();
    return *this;
}

inline
CObjectInfo CObjectInfoEI::GetElement(void) const
{
    _ASSERT(CheckValid());
    return m_Iterator.Get();
}

inline
CObjectInfo CObjectInfoEI::operator*(void) const
{
    _ASSERT(CheckValid());
    return m_Iterator.Get();
}

inline
void CObjectInfoEI::Erase(void)
{
    _ASSERT(CheckValid());
    _DEBUG_ARG(m_LastCall = eErase);
    m_Iterator.Erase();
}

// class interface

inline
CObjectTypeInfoII::CObjectTypeInfoII(void)
    : m_ItemIndex(kFirstMemberIndex),
      m_LastItemIndex(kInvalidMember)
{
    _DEBUG_ARG(m_LastCall = eNone);
}

inline
void CObjectTypeInfoII::Init(const CClassTypeInfoBase* typeInfo,
                             TMemberIndex index)
{
    m_OwnerType = typeInfo;
    m_ItemIndex = index;
    m_LastItemIndex = typeInfo->GetItems().LastIndex();
    _DEBUG_ARG(m_LastCall = (index == kInvalidMember? eNone: eValid));
}

inline
void CObjectTypeInfoII::Init(const CClassTypeInfoBase* typeInfo)
{
    Init(typeInfo, kFirstMemberIndex);
}

inline
CObjectTypeInfoII::CObjectTypeInfoII(const CClassTypeInfoBase* typeInfo)
{
    Init(typeInfo);
}

inline
CObjectTypeInfoII::CObjectTypeInfoII(const CClassTypeInfoBase* typeInfo,
                                     TMemberIndex index)
{
    Init(typeInfo, index);
}

inline
const CObjectTypeInfo& CObjectTypeInfoII::GetOwnerType(void) const
{
    return m_OwnerType;
}

inline
const CClassTypeInfoBase* CObjectTypeInfoII::GetClassTypeInfoBase(void) const
{
    return CTypeConverter<CClassTypeInfoBase>::
        SafeCast(GetOwnerType().GetTypeInfo());
}

inline
bool CObjectTypeInfoII::CheckValid(void) const
{
#if _DEBUG
    if ( m_LastCall != eValid)
        ReportNonValid();
#endif
    return m_ItemIndex >= kFirstMemberIndex &&
        m_ItemIndex <= m_LastItemIndex;
}

inline
TMemberIndex CObjectTypeInfoII::GetItemIndex(void) const
{
    _ASSERT(CheckValid());
    return m_ItemIndex;
}

inline
const CItemInfo* CObjectTypeInfoII::GetItemInfo(void) const
{
    return GetClassTypeInfoBase()->GetItems().GetItemInfo(GetItemIndex());
}

inline
const string& CObjectTypeInfoII::GetAlias(void) const
{
    return GetItemInfo()->GetId().GetName();
}

inline
bool CObjectTypeInfoII::Valid(void) const
{
    _DEBUG_ARG(m_LastCall = eValid);
    return CheckValid();
}

inline
CObjectTypeInfoII::operator bool(void) const
{
    return Valid();
}

inline
bool CObjectTypeInfoII::operator!(void) const
{
    return !Valid();
}

inline
void CObjectTypeInfoII::Next(void)
{
    _ASSERT(CheckValid());
    _DEBUG_ARG(m_LastCall = eNext);
    ++m_ItemIndex;
}

inline
bool CObjectTypeInfoII::operator==(const CObjectTypeInfoII& iter) const
{
    return GetOwnerType() == iter.GetOwnerType() &&
        GetItemIndex() == iter.GetItemIndex();
}

inline
bool CObjectTypeInfoII::operator!=(const CObjectTypeInfoII& iter) const
{
    return GetOwnerType() != iter.GetOwnerType() ||
        GetItemIndex() == iter.GetItemIndex();
}

// CObjectTypeInfoMI //////////////////////////////////////////////////////

inline
CObjectTypeInfoMI::CObjectTypeInfoMI(void)
{
}

inline
CObjectTypeInfoMI::CObjectTypeInfoMI(const CObjectTypeInfo& info)
    : CParent(info.GetClassTypeInfo())
{
}

inline
CObjectTypeInfoMI::CObjectTypeInfoMI(const CObjectTypeInfo& info,
                                     TMemberIndex index)
    : CParent(info.GetClassTypeInfo(), index)
{
}

inline
CObjectTypeInfoMI& CObjectTypeInfoMI::operator++(void)
{
    Next();
    return *this;
}

inline
void CObjectTypeInfoMI::Init(const CObjectTypeInfo& info)
{
    CParent::Init(info.GetClassTypeInfo());
}

inline
void CObjectTypeInfoMI::Init(const CObjectTypeInfo& info,
                             TMemberIndex index)
{
    CParent::Init(info.GetClassTypeInfo(), index);
}

inline
CObjectTypeInfoMI& CObjectTypeInfoMI::operator=(const CObjectTypeInfo& info)
{
    Init(info);
    return *this;
}

inline
const CClassTypeInfo* CObjectTypeInfoMI::GetClassTypeInfo(void) const
{
    return GetOwnerType().GetClassTypeInfo();
}

inline
CObjectTypeInfo CObjectTypeInfoMI::GetClassType(void) const
{
    return GetOwnerType();
}

inline
TMemberIndex CObjectTypeInfoMI::GetMemberIndex(void) const
{
    return GetItemIndex();
}

inline
const CMemberInfo* CObjectTypeInfoMI::GetMemberInfo(void) const
{
    return GetClassTypeInfo()->GetMemberInfo(GetMemberIndex());
}

inline
CMemberInfo* CObjectTypeInfoMI::GetNCMemberInfo(void) const
{
    return const_cast<CMemberInfo*>(GetMemberInfo());
}

inline
CObjectTypeInfoMI::operator CObjectTypeInfo(void) const
{
    return GetMemberInfo()->GetTypeInfo();
}

inline
CObjectTypeInfo CObjectTypeInfoMI::GetMemberType(void) const
{
    return GetMemberInfo()->GetTypeInfo();
}

inline
CObjectTypeInfo CObjectTypeInfoMI::operator*(void) const
{
    return GetMemberInfo()->GetTypeInfo();
}

// CObjectTypeInfoVI //////////////////////////////////////////////////////

inline
CObjectTypeInfoVI::CObjectTypeInfoVI(const CObjectTypeInfo& info)
    : CParent(info.GetChoiceTypeInfo())
{
}

inline
CObjectTypeInfoVI::CObjectTypeInfoVI(const CObjectTypeInfo& info,
                                     TMemberIndex index)
    : CParent(info.GetChoiceTypeInfo(), index)
{
}

inline
CObjectTypeInfoVI& CObjectTypeInfoVI::operator++(void)
{
    Next();
    return *this;
}

inline
void CObjectTypeInfoVI::Init(const CObjectTypeInfo& info)
{
    CParent::Init(info.GetChoiceTypeInfo());
}

inline
void CObjectTypeInfoVI::Init(const CObjectTypeInfo& info,
                             TMemberIndex index)
{
    CParent::Init(info.GetChoiceTypeInfo(), index);
}

inline
CObjectTypeInfoVI& CObjectTypeInfoVI::operator=(const CObjectTypeInfo& info)
{
    Init(info);
    return *this;
}

inline
const CChoiceTypeInfo* CObjectTypeInfoVI::GetChoiceTypeInfo(void) const
{
    return GetOwnerType().GetChoiceTypeInfo();
}

inline
CObjectTypeInfo CObjectTypeInfoVI::GetChoiceType(void) const
{
    return GetOwnerType();
}

inline
TMemberIndex CObjectTypeInfoVI::GetVariantIndex(void) const
{
    return GetItemIndex();
}

inline
const CVariantInfo* CObjectTypeInfoVI::GetVariantInfo(void) const
{
    return GetChoiceTypeInfo()->GetVariantInfo(GetVariantIndex());
}

inline
CVariantInfo* CObjectTypeInfoVI::GetNCVariantInfo(void) const
{
    return const_cast<CVariantInfo*>(GetVariantInfo());
}

inline
CObjectTypeInfo CObjectTypeInfoVI::GetVariantType(void) const
{
    return GetVariantInfo()->GetTypeInfo();
}

inline
CObjectTypeInfo CObjectTypeInfoVI::operator*(void) const
{
    return GetVariantInfo()->GetTypeInfo();
}

// CConstObjectInfoMI //////////////////////////////////////////////////////

inline
CConstObjectInfoMI::CConstObjectInfoMI(void)
{
}

inline
CConstObjectInfoMI::CConstObjectInfoMI(const CConstObjectInfo& object)
    : CParent(object), m_Object(object)
{
    _ASSERT(object);