iterator.cpp
上传用户:yhdzpy8989
上传日期:2007-06-13
资源大小:13604k
文件大小:14k
源码类别:

生物技术

开发平台:

C/C++

  1. /*
  2.  * ===========================================================================
  3.  * PRODUCTION $Log: iterator.cpp,v $
  4.  * PRODUCTION Revision 1000.1  2004/06/01 19:40:24  gouriano
  5.  * PRODUCTION PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.25
  6.  * PRODUCTION
  7.  * ===========================================================================
  8.  */
  9. /*  $Id: iterator.cpp,v 1000.1 2004/06/01 19:40:24 gouriano Exp $
  10. * ===========================================================================
  11. *
  12. *                            PUBLIC DOMAIN NOTICE
  13. *               National Center for Biotechnology Information
  14. *
  15. *  This software/database is a "United States Government Work" under the
  16. *  terms of the United States Copyright Act.  It was written as part of
  17. *  the author's official duties as a United States Government employee and
  18. *  thus cannot be copyrighted.  This software/database is freely available
  19. *  to the public for use. The National Library of Medicine and the U.S.
  20. *  Government have not placed any restriction on its use or reproduction.
  21. *
  22. *  Although all reasonable efforts have been taken to ensure the accuracy
  23. *  and reliability of the software and data, the NLM and the U.S.
  24. *  Government do not and cannot warrant the performance or results that
  25. *  may be obtained by using this software or data. The NLM and the U.S.
  26. *  Government disclaim all warranties, express or implied, including
  27. *  warranties of performance, merchantability or fitness for any particular
  28. *  purpose.
  29. *
  30. *  Please cite the author in any work or product based on this material.
  31. *
  32. * ===========================================================================
  33. *
  34. * Author: Eugene Vasilchenko
  35. *
  36. * File Description:
  37. *   !!! PUT YOUR DESCRIPTION HERE !!!
  38. */
  39. #include <ncbi_pch.hpp>
  40. #include <corelib/ncbistd.hpp>
  41. #include <corelib/ncbiutil.hpp>
  42. #include <serial/exception.hpp>
  43. #include <serial/objectiter.hpp>
  44. #include <serial/iterator.hpp>
  45. BEGIN_NCBI_SCOPE
  46. struct SIteratorFunctions {
  47.     static bool s_ContainsType(const CConstObjectInfo& object,
  48.                                TTypeInfo needType);
  49. };
  50. class CTreeLevelIteratorOne : public CTreeLevelIterator
  51. {
  52. public:
  53.     CTreeLevelIteratorOne(const CObjectInfo& object)
  54.         : m_Object(object)
  55.         {
  56.         }
  57.     bool Valid(void) const
  58.         {
  59.             return m_Object;
  60.         }
  61.     void Next(void)
  62.         {
  63.             m_Object.Reset();
  64.         }
  65.     CObjectInfo Get(void) const
  66.         {
  67.             return m_Object;
  68.         }
  69. private:
  70.     CObjectInfo m_Object;
  71. };
  72. class CConstTreeLevelIteratorOne : public CConstTreeLevelIterator
  73. {
  74. public:
  75.     CConstTreeLevelIteratorOne(const CConstObjectInfo& object)
  76.         : m_Object(object)
  77.         {
  78.         }
  79.     bool Valid(void) const
  80.         {
  81.             return m_Object;
  82.         }
  83.     void Next(void)
  84.         {
  85.             m_Object.Reset();
  86.         }
  87.     CConstObjectInfo Get(void) const
  88.         {
  89.             return m_Object;
  90.         }
  91. private:
  92.     CConstObjectInfo m_Object;
  93. };
  94. template<class ChildIterator>
  95. class CTreeLevelIteratorMany : public CTreeLevelIterator
  96. {
  97. public:
  98.     CTreeLevelIteratorMany(const CObjectInfo& object)
  99.         : m_Iterator(object)
  100.         {
  101.         }
  102.     bool Valid(void) const
  103.         {
  104.             return m_Iterator;
  105.         }
  106.     void Next(void)
  107.         {
  108.             m_Iterator.Next();
  109.         }
  110.     bool CanGet(void) const
  111.         {
  112.             return m_Iterator.CanGet();
  113.         }
  114.     CObjectInfo Get(void) const
  115.         {
  116.             return *m_Iterator;
  117.         }
  118.     void Erase(void)
  119.         {
  120.             m_Iterator.Erase();
  121.         }
  122. private:
  123.     ChildIterator m_Iterator;
  124. };
  125. template<class ChildIterator>
  126. class CConstTreeLevelIteratorMany : public CConstTreeLevelIterator
  127. {
  128. public:
  129.     CConstTreeLevelIteratorMany(const CConstObjectInfo& object)
  130.         : m_Iterator(object)
  131.         {
  132.         }
  133.     bool Valid(void) const
  134.         {
  135.             return m_Iterator;
  136.         }
  137.     void Next(void)
  138.         {
  139.             m_Iterator.Next();
  140.         }
  141.     bool CanGet(void) const
  142.         {
  143.             return m_Iterator.CanGet();
  144.         }
  145.     CConstObjectInfo Get(void) const
  146.         {
  147.             return *m_Iterator;
  148.         }
  149. private:
  150.     ChildIterator m_Iterator;
  151. };
  152. CConstTreeLevelIterator::~CConstTreeLevelIterator(void)
  153. {
  154. }
  155. CConstTreeLevelIterator*
  156. CConstTreeLevelIterator::CreateOne(const CConstObjectInfo& object)
  157. {
  158.     return new CConstTreeLevelIteratorOne(object);
  159. }
  160. CConstTreeLevelIterator*
  161. CConstTreeLevelIterator::Create(const CConstObjectInfo& obj)
  162. {
  163.     switch ( obj.GetTypeFamily() ) {
  164.     case eTypeFamilyClass:
  165.         return new CConstTreeLevelIteratorMany<CConstObjectInfo::CMemberIterator>(obj);
  166.     case eTypeFamilyContainer:
  167.         return new CConstTreeLevelIteratorMany<CConstObjectInfo::CElementIterator>(obj);
  168.     case eTypeFamilyPointer:
  169.         return CreateOne(obj.GetPointedObject());
  170.     case eTypeFamilyChoice:
  171.         {
  172.             CConstObjectInfo::CChoiceVariant v(obj);
  173.             if ( v )
  174.                 return CreateOne(*v);
  175.             else
  176.                 return 0;
  177.         }
  178.     default:
  179.         return 0;
  180.     }
  181. }
  182. bool CConstTreeLevelIterator::HaveChildren(const CConstObjectInfo& object)
  183. {
  184.     if ( !object )
  185.         return false;
  186.     switch ( object.GetTypeFamily() ) {
  187.     case eTypeFamilyClass:
  188.     case eTypeFamilyChoice:
  189.     case eTypeFamilyPointer:
  190.     case eTypeFamilyContainer:
  191.         return true;
  192.     default:
  193.         return false;
  194.     }
  195. }
  196. bool SIteratorFunctions::s_ContainsType(const CConstObjectInfo& object,
  197.                                         TTypeInfo needType)
  198. {
  199.     if ( object.GetTypeInfo()->IsType(needType) )
  200.         return true;
  201.     switch ( object.GetTypeFamily() ) {
  202.     case eTypeFamilyClass:
  203.         for ( CConstObjectInfo::CMemberIterator m(object); m; ++m ) {
  204.             if ( m.GetMemberInfo()->GetTypeInfo()->MayContainType(needType) &&
  205.                  s_ContainsType(*m, needType) )
  206.                 return true;
  207.         }
  208.         return false;
  209.     case eTypeFamilyChoice:
  210.         {
  211.             CConstObjectInfo::CChoiceVariant v =
  212.                 object.GetCurrentChoiceVariant();
  213.             return v &&
  214.                 v.GetVariantInfo()->GetTypeInfo()->MayContainType(needType) &&
  215.                 s_ContainsType(*v, needType);
  216.         }
  217.     case eTypeFamilyPointer:
  218.         return s_ContainsType(object.GetPointedObject(), needType);
  219.     case eTypeFamilyContainer:
  220.         for ( CConstObjectInfo::CElementIterator e(object); e; ++e ) {
  221.             if ( s_ContainsType(*e, needType) )
  222.                 return true;
  223.         }
  224.         return false;
  225.     default:
  226.         return false;
  227.     }
  228. }
  229. CTreeLevelIterator::~CTreeLevelIterator(void)
  230. {
  231. }
  232. CTreeLevelIterator*
  233. CTreeLevelIterator::CreateOne(const CObjectInfo& object)
  234. {
  235.     return new CTreeLevelIteratorOne(object);
  236. }
  237. CTreeLevelIterator*
  238. CTreeLevelIterator::Create(const CObjectInfo& obj)
  239. {
  240.     switch ( obj.GetTypeFamily() ) {
  241.     case eTypeFamilyClass:
  242.         return new CTreeLevelIteratorMany<CObjectInfo::CMemberIterator>(obj);
  243.     case eTypeFamilyContainer:
  244.         return new CTreeLevelIteratorMany<CObjectInfo::CElementIterator>(obj);
  245.     case eTypeFamilyPointer:
  246.         return CreateOne(obj.GetPointedObject());
  247.     case eTypeFamilyChoice:
  248.         {
  249.             CObjectInfo::CChoiceVariant v(obj);
  250.             if ( v )
  251.                 return CreateOne(*v);
  252.             else
  253.                 return 0;
  254.         }
  255.     default:
  256.         return 0;
  257.     }
  258. }
  259. void CTreeLevelIterator::Erase(void)
  260. {
  261.     NCBI_THROW(CSerialException,eIllegalCall, "cannot erase");
  262. }
  263. /////////////////
  264. void CTreeIterator::Erase(void)
  265. {
  266.     _ASSERT(CheckValid());
  267.     m_CurrentObject.Reset();
  268.     _ASSERT(!m_Stack.empty());
  269.     m_Stack.top()->Erase();
  270.     Walk();
  271. }
  272. template<class Parent>
  273. bool CLeafTypeIteratorBase<Parent>::CanSelect(const CConstObjectInfo& object)
  274. {
  275.     return CParent::CanSelect(object) &&
  276.         SIteratorFunctions::s_ContainsType(object, this->GetIteratorType());
  277. }
  278. #if 0
  279. // There is an (unconfirmed) opinion that putting these two functions
  280. // into header (iterator.hpp) increases the size of an executable.
  281. // Still, keeping them here is reported as bug by
  282. // Metrowerks Codewarrior 9.0 (Mac OSX)
  283. template<class Parent>
  284. bool CTypesIteratorBase<Parent>::CanSelect(const CConstObjectInfo& object)
  285. {
  286.     if ( !CParent::CanSelect(object) )
  287.         return false;
  288.     m_MatchType = 0;
  289.     TTypeInfo type = object.GetTypeInfo();
  290.     ITERATE ( TTypeList, i, GetTypeList() ) {
  291.         if ( type->IsType(*i) ) {
  292.             m_MatchType = *i;
  293.             return true;
  294.         }
  295.     }
  296.     return false;
  297. }
  298. template<class Parent>
  299. bool CTypesIteratorBase<Parent>::CanEnter(const CConstObjectInfo& object)
  300. {
  301.     if ( !CParent::CanEnter(object) )
  302.         return false;
  303.     TTypeInfo type = object.GetTypeInfo();
  304.     ITERATE ( TTypeList, i, GetTypeList() ) {
  305.         if ( type->MayContainType(*i) )
  306.             return true;
  307.     }
  308.     return false;
  309. }
  310. #if 0 // these are obsolete
  311. template class NCBI_XSERIAL_EXPORT CTreeIteratorTmpl<CTreeLevelIterator>;
  312. template class NCBI_XSERIAL_EXPORT CTreeIteratorTmpl<CConstTreeLevelIterator>;
  313. template class NCBI_XSERIAL_EXPORT CTypeIteratorBase<CTreeIterator>;
  314. template class NCBI_XSERIAL_EXPORT CTypeIteratorBase<CTreeConstIterator>;
  315. template class NCBI_XSERIAL_EXPORT CLeafTypeIteratorBase<CTreeIterator>;
  316. template class NCBI_XSERIAL_EXPORT CLeafTypeIteratorBase<CTreeConstIterator>;
  317. #endif
  318. template class NCBI_XSERIAL_EXPORT CTypesIteratorBase<CTreeIterator>;
  319. template class NCBI_XSERIAL_EXPORT CTypesIteratorBase<CTreeConstIterator>;
  320. #endif
  321. bool CType_Base::Match(const CTypesIterator& it, TTypeInfo typeInfo)
  322. {
  323.     return it.GetMatchType() == typeInfo;
  324. }
  325. bool CType_Base::Match(const CTypesConstIterator& it, TTypeInfo typeInfo)
  326. {
  327.     return it.GetMatchType() == typeInfo;
  328. }
  329. void CType_Base::AddTo(CTypesIterator& it, TTypeInfo typeInfo)
  330. {
  331.     it.AddType(typeInfo);
  332. }
  333. void CType_Base::AddTo(CTypesConstIterator& it,  TTypeInfo typeInfo)
  334. {
  335.     it.AddType(typeInfo);
  336. }
  337. TObjectPtr CType_Base::GetObjectPtr(const CTypesIterator& it)
  338. {
  339.     return it.GetFoundPtr();
  340. }
  341. TConstObjectPtr CType_Base::GetObjectPtr(const CTypesConstIterator& it)
  342. {
  343.     return it.GetFoundPtr();
  344. }
  345. class CCObjectClassInfo : public CVoidTypeInfo
  346. {
  347.     typedef CTypeInfo CParent;
  348. public:
  349.     virtual bool IsParentClassOf(const CClassTypeInfo* classInfo) const;
  350. };
  351. TTypeInfo CObjectGetTypeInfo::GetTypeInfo(void)
  352. {
  353.     static TTypeInfo typeInfo = new CCObjectClassInfo;
  354.     return typeInfo;
  355. }
  356. bool CCObjectClassInfo::IsParentClassOf(const CClassTypeInfo* classInfo) const
  357. {
  358.     return classInfo->IsCObject();
  359. }
  360. END_NCBI_SCOPE
  361. /* ---------------------------------------------------------------------------
  362. * $Log: iterator.cpp,v $
  363. * Revision 1000.1  2004/06/01 19:40:24  gouriano
  364. * PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.25
  365. *
  366. * Revision 1.25  2004/05/17 21:03:02  gorelenk
  367. * Added include of PCH ncbi_pch.hpp
  368. *
  369. * Revision 1.24  2004/04/26 16:40:59  ucko
  370. * Tweak for GCC 3.4 compatibility.
  371. *
  372. * Revision 1.23  2003/09/30 17:11:57  gouriano
  373. * Modified TypeIterators to skip unset optional members
  374. *
  375. * Revision 1.22  2003/09/15 20:02:04  gouriano
  376. * fixed the definition of CTypesIteratorBase to eliminate compilation warnings
  377. *
  378. * Revision 1.21  2003/03/11 20:08:07  kuznets
  379. * iterate -> ITERATE
  380. *
  381. * Revision 1.20  2003/03/10 18:54:25  gouriano
  382. * use new structured exceptions (based on CException)
  383. *
  384. * Revision 1.19  2002/12/23 19:00:26  dicuccio
  385. * Moved template function bodies into header.  Log to end.
  386. *
  387. * Revision 1.18  2001/05/17 15:07:06  lavr
  388. * Typos corrected
  389. *
  390. * Revision 1.17  2000/12/26 22:24:10  vasilche
  391. * Fixed errors of compilation on Mac.
  392. *
  393. * Revision 1.16  2000/11/09 16:38:40  vasilche
  394. * Fixed error on WorkShop compiler: static functions are unusable from templates.
  395. *
  396. * Revision 1.15  2000/11/09 15:21:40  vasilche
  397. * Fixed bugs in iterators.
  398. * Added iterator constructors from CObjectInfo.
  399. * Added CLeafTypeIterator.
  400. *
  401. * Revision 1.14  2000/11/08 19:24:39  vasilche
  402. * Added CLeafTypeIterator<Type> and CLeafTypeConstIterator<Type>.
  403. *
  404. * Revision 1.13  2000/10/20 15:51:38  vasilche
  405. * Fixed data error processing.
  406. * Added interface for constructing container objects directly into output stream.
  407. * object.hpp, object.inl and object.cpp were split to
  408. * objectinfo.*, objecttype.*, objectiter.* and objectio.*.
  409. *
  410. * Revision 1.12  2000/10/03 17:22:42  vasilche
  411. * Reduced header dependency.
  412. * Reduced size of debug libraries on WorkShop by 3 times.
  413. * Fixed tag allocation for parent classes.
  414. * Fixed CObject allocation/deallocation in streams.
  415. * Moved instantiation of several templates in separate source file.
  416. *
  417. * Revision 1.11  2000/09/18 20:00:22  vasilche
  418. * Separated CVariantInfo and CMemberInfo.
  419. * Implemented copy hooks.
  420. * All hooks now are stored in CTypeInfo/CMemberInfo/CVariantInfo.
  421. * Most type specific functions now are implemented via function pointers instead of virtual functions.
  422. *
  423. * Revision 1.10  2000/09/01 13:16:15  vasilche
  424. * Implemented class/container/choice iterators.
  425. * Implemented CObjectStreamCopier for copying data without loading into memory.
  426. *
  427. * Revision 1.9  2000/07/03 18:42:43  vasilche
  428. * Added interface to typeinfo via CObjectInfo and CConstObjectInfo.
  429. * Reduced header dependency.
  430. *
  431. * Revision 1.8  2000/06/01 19:07:02  vasilche
  432. * Added parsing of XML data.
  433. *
  434. * Revision 1.7  2000/05/05 17:59:06  vasilche
  435. * Unfortunately MSVC doesn't support explicit instantiation of template methods.
  436. *
  437. * Revision 1.6  2000/05/05 16:26:56  vasilche
  438. * Simplified iterator templates.
  439. *
  440. * Revision 1.5  2000/05/05 13:08:21  vasilche
  441. * Simplified CTypesIterator interface.
  442. *
  443. * Revision 1.4  2000/05/04 16:23:12  vasilche
  444. * Updated CTypesIterator and CTypesConstInterator interface.
  445. *
  446. * Revision 1.3  2000/04/10 21:01:48  vasilche
  447. * Fixed Erase for map/set.
  448. * Added iteratorbase.hpp header for basic internal classes.
  449. *
  450. * Revision 1.2  2000/03/29 18:02:40  vasilche
  451. * Workaround of bug in MSVC: abstract member in template.
  452. *
  453. * Revision 1.1  2000/03/29 15:55:27  vasilche
  454. * Added two versions of object info - CObjectInfo and CConstObjectInfo.
  455. * Added generic iterators by class -
  456. *  CTypeIterator<class>, CTypeConstIterator<class>,
  457. *  CStdTypeIterator<type>, CStdTypeConstIterator<type>,
  458. *  CObjectsIterator and CObjectsConstIterator.
  459. *
  460. * ===========================================================================
  461. */