开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数值算法/人工智能 > 生物技术 > 查看源码
seq_id_tree.hpp
资源名称：ncbi_cxx_win--Jul_08_2004.zip　[点击查看]
上传用户：yhdzpy8989
上传日期：2007-06-13
资源大小：13604k
文件大小：18k
源码类别：

生物技术

开发平台：

C/C++

seq_id_tree.hpp：源码内容
  1. /*
  2.  * ===========================================================================
  3.  * PRODUCTION $Log: seq_id_tree.hpp,v $
  4.  * PRODUCTION Revision 1000.1  2004/04/12 17:28:34  gouriano
  5.  * PRODUCTION PRODUCTION: UPGRADED [CATCHUP_003] Dev-tree R1.5
  6.  * PRODUCTION
  7.  * ===========================================================================
  8.  */
  10. #ifndef OBJECTS_OBJMGR___SEQ_ID_TREE__HPP
  11. #define OBJECTS_OBJMGR___SEQ_ID_TREE__HPP
  13. /*  $Id: seq_id_tree.hpp,v 1000.1 2004/04/12 17:28:34 gouriano Exp $
  14. * ===========================================================================
  15. *
  16. *                            PUBLIC DOMAIN NOTICE
  17. *               National Center for Biotechnology Information
  18. *
  19. *  This software/database is a "United States Government Work" under the
  20. *  terms of the United States Copyright Act.  It was written as part of
  21. *  the author's official duties as a United States Government employee and
  22. *  thus cannot be copyrighted.  This software/database is freely available
  23. *  to the public for use. The National Library of Medicine and the U.S.
  24. *  Government have not placed any restriction on its use or reproduction.
  25. *
  26. *  Although all reasonable efforts have been taken to ensure the accuracy
  27. *  and reliability of the software and data, the NLM and the U.S.
  28. *  Government do not and cannot warrant the performance or results that
  29. *  may be obtained by using this software or data. The NLM and the U.S.
  30. *  Government disclaim all warranties, express or implied, including
  31. *  warranties of performance, merchantability or fitness for any particular
  32. *  purpose.
  33. *
  34. *  Please cite the author in any work or product based on this material.
  35. *
  36. * ===========================================================================
  37. *
  38. * Author: Aleksey Grichenko, Eugene Vasilchenko
  39. *
  40. * File Description:
  41. *   Seq-id mapper for Object Manager
  42. *
  43. */
  45. #include <corelib/ncbiobj.hpp>
  46. #include <corelib/ncbimtx.hpp>
  47. #include <corelib/ncbistr.hpp>
  48. #include <corelib/ncbi_limits.hpp>
  50. #include <objects/general/Date.hpp>
  51. #include <objects/general/Dbtag.hpp>
  52. #include <objects/general/Object_id.hpp>
  54. #include <objects/biblio/Id_pat.hpp>
  56. #include <objects/seqloc/Seq_id.hpp>
  57. #include <objects/seqloc/PDB_mol_id.hpp>
  58. #include <objects/seqloc/PDB_seq_id.hpp>
  59. #include <objects/seqloc/Patent_seq_id.hpp>
  60. #include <objects/seqloc/Giimport_id.hpp>
  61. #include <objects/seqloc/Textseq_id.hpp>
  63. #include <objmgr/seq_id_handle.hpp>
  65. #include <vector>
  66. #include <set>
  67. #include <map>
  69. BEGIN_NCBI_SCOPE
  70. BEGIN_SCOPE(objects)
  73. class CSeq_id;
  74. class CSeq_id_Handle;
  75. class CSeq_id_Info;
  76. class CSeq_id_Mapper;
  77. class CSeq_id_Which_Tree;
  79. ////////////////////////////////////////////////////////////////////
  80. //
  81. //  CSeq_id_***_Tree::
  82. //
  83. //    Seq-id sub-type specific trees
  84. //
  87. // Base class for seq-id type-specific trees
  88. class NCBI_XOBJMGR_EXPORT CSeq_id_Which_Tree : public CObject
  89. {
  90. public:
  91.     // 'ctors
  92.     CSeq_id_Which_Tree(void);
  93.     virtual ~CSeq_id_Which_Tree(void);
  95.     static void Initialize(vector<CRef<CSeq_id_Which_Tree> >& v);
  97.     virtual bool Empty(void) const = 0;
  99.     // Find exaclty the same seq-id
  100.     virtual CSeq_id_Handle FindInfo(const CSeq_id& id) const = 0;
  101.     virtual CSeq_id_Handle FindOrCreate(const CSeq_id& id) = 0;
  102.     virtual CSeq_id_Handle GetGiHandle(int gi);
  104.     virtual void DropInfo(const CSeq_id_Info* info);
  106.     typedef set<CSeq_id_Handle> TSeq_id_MatchList;
  108.     // Get the list of matching seq-id.
  109.     virtual bool HaveMatch(const CSeq_id_Handle& id) const;
  110.     virtual void FindMatch(const CSeq_id_Handle& id,
  111.                            TSeq_id_MatchList& id_list) const = 0;
  112.     virtual void FindMatchStr(string sid,
  113.                               TSeq_id_MatchList& id_list) const = 0;
  115.     virtual bool IsBetterVersion(const CSeq_id_Handle& h1,
  116.                                  const CSeq_id_Handle& h2) const;
  118.     // Reverse matching
  119.     virtual bool HaveReverseMatch(const CSeq_id_Handle& id) const;
  120.     virtual void FindReverseMatch(const CSeq_id_Handle& id,
  121.                                   TSeq_id_MatchList& id_list);
  122. protected:
  123.     friend class CSeq_id_Mapper;
  125.     CSeq_id_Info* CreateInfo(void);
  126.     CSeq_id_Info* CreateInfo(const CSeq_id& id);
  128.     virtual void x_Unindex(const CSeq_id_Info* info) = 0;
  130. /*
  131.     typedef CRWLockPosix TRWLock;
  132.     typedef TRWLock::TReadLockGuard TReadLockGuard;
  133.     typedef TRWLock::TWriteLockGuard TWriteLockGuard;
  134. */
  135.     typedef CMutex TRWLock;
  136.     typedef CMutexGuard TReadLockGuard;
  137.     typedef CMutexGuard TWriteLockGuard;
  139.     mutable TRWLock m_TreeLock;
  141. private:
  142.     CSeq_id_Which_Tree(const CSeq_id_Which_Tree& tree);
  143.     const CSeq_id_Which_Tree& operator=(const CSeq_id_Which_Tree& tree);
  144. };
  148. ////////////////////////////////////////////////////////////////////
  149. // not-set tree (maximum 1 entry allowed)
  152. class CSeq_id_not_set_Tree : public CSeq_id_Which_Tree
  153. {
  154. public:
  155.     CSeq_id_not_set_Tree(void);
  156.     ~CSeq_id_not_set_Tree(void);
  158.     virtual bool Empty(void) const;
  160.     virtual CSeq_id_Handle FindInfo(const CSeq_id& id) const;
  161.     virtual CSeq_id_Handle FindOrCreate(const CSeq_id& id);
  163.     virtual void DropInfo(const CSeq_id_Info* info);
  165.     virtual bool HaveMatch(const CSeq_id_Handle& id) const;
  166.     virtual void FindMatch(const CSeq_id_Handle& id,
  167.                            TSeq_id_MatchList& id_list) const;
  168.     virtual void FindMatchStr(string sid,
  169.                               TSeq_id_MatchList& id_list) const;
  170.     virtual bool HaveReverseMatch(const CSeq_id_Handle& id) const;
  171.     virtual void FindReverseMatch(const CSeq_id_Handle& id,
  172.                                   TSeq_id_MatchList& id_list);
  174. protected:
  175.     virtual void x_Unindex(const CSeq_id_Info* info);
  176.     bool x_Check(const CSeq_id& id) const;
  177. };
  180. ////////////////////////////////////////////////////////////////////
  181. // Base class for Gi, Gibbsq & Gibbmt trees
  184. class CSeq_id_int_Tree : public CSeq_id_Which_Tree
  185. {
  186. public:
  187.     CSeq_id_int_Tree(void);
  188.     ~CSeq_id_int_Tree(void);
  190.     virtual bool Empty(void) const;
  192.     virtual CSeq_id_Handle FindInfo(const CSeq_id& id) const;
  193.     virtual CSeq_id_Handle FindOrCreate(const CSeq_id& id);
  195.     virtual bool HaveMatch(const CSeq_id_Handle& id) const;
  196.     virtual void FindMatch(const CSeq_id_Handle& id,
  197.                            TSeq_id_MatchList& id_list) const;
  198.     virtual void FindMatchStr(string sid,
  199.                               TSeq_id_MatchList& id_list) const;
  201. protected:
  202.     virtual void x_Unindex(const CSeq_id_Info* info);
  203.     virtual bool x_Check(const CSeq_id& id) const = 0;
  204.     virtual int  x_Get(const CSeq_id& id) const = 0;
  206. private:
  207.     typedef map<int, CSeq_id_Info*> TIntMap;
  208.     TIntMap m_IntMap;
  209. };
  212. ////////////////////////////////////////////////////////////////////
  213. // Gibbsq tree
  216. class CSeq_id_Gibbsq_Tree : public CSeq_id_int_Tree
  217. {
  218. protected:
  219.     virtual bool x_Check(const CSeq_id& id) const;
  220.     virtual int  x_Get(const CSeq_id& id) const;
  221. };
  224. ////////////////////////////////////////////////////////////////////
  225. // Gibbmt tree
  228. class CSeq_id_Gibbmt_Tree : public CSeq_id_int_Tree
  229. {
  230. protected:
  231.     virtual bool x_Check(const CSeq_id& id) const;
  232.     virtual int  x_Get(const CSeq_id& id) const;
  233. };
  236. ////////////////////////////////////////////////////////////////////
  237. // Gi tree
  240. class CSeq_id_Gi_Tree : public CSeq_id_Which_Tree
  241. {
  242. public:
  243.     CSeq_id_Gi_Tree(void);
  244.     ~CSeq_id_Gi_Tree(void);
  246.     virtual bool Empty(void) const;
  248.     virtual CSeq_id_Handle FindInfo(const CSeq_id& id) const;
  249.     virtual CSeq_id_Handle FindOrCreate(const CSeq_id& id);
  250.     virtual CSeq_id_Handle GetGiHandle(int gi);
  252.     virtual void DropInfo(const CSeq_id_Info* info);
  254.     virtual bool HaveMatch(const CSeq_id_Handle& id) const;
  255.     virtual void FindMatch(const CSeq_id_Handle& id,
  256.                            TSeq_id_MatchList& id_list) const;
  257.     virtual void FindMatchStr(string sid,
  258.                               TSeq_id_MatchList& id_list) const;
  260. protected:
  261.     virtual void x_Unindex(const CSeq_id_Info* info);
  262.     bool x_Check(const CSeq_id& id) const;
  263.     int  x_Get(const CSeq_id& id) const;
  265.     CConstRef<CSeq_id_Info> m_Info;
  266. };
  269. ////////////////////////////////////////////////////////////////////
  270. // Base class for e_Genbank, e_Embl, e_Pir, e_Swissprot, e_Other,
  271. // e_Ddbj, e_Prf, e_Tpg, e_Tpe, e_Tpd trees
  274. class CSeq_id_Textseq_Tree : public CSeq_id_Which_Tree
  275. {
  276. public:
  277.     CSeq_id_Textseq_Tree(void);
  278.     ~CSeq_id_Textseq_Tree(void);
  280.     virtual bool Empty(void) const;
  282.     virtual CSeq_id_Handle FindInfo(const CSeq_id& id) const;
  283.     virtual CSeq_id_Handle FindOrCreate(const CSeq_id& id);
  285.     virtual void FindMatch(const CSeq_id_Handle& id,
  286.                            TSeq_id_MatchList& id_list) const;
  287.     virtual void FindMatchStr(string sid,
  288.                               TSeq_id_MatchList& id_list) const;
  290.     virtual bool IsBetterVersion(const CSeq_id_Handle& h1,
  291.                                  const CSeq_id_Handle& h2) const;
  293.     virtual bool HaveReverseMatch(const CSeq_id_Handle& id) const;
  294.     virtual void FindReverseMatch(const CSeq_id_Handle& id,
  295.                                   TSeq_id_MatchList& id_list);
  296. protected:
  297.     virtual void x_Unindex(const CSeq_id_Info* info);
  298.     virtual bool x_Check(const CSeq_id& id) const = 0;
  299.     virtual const CTextseq_id& x_Get(const CSeq_id& id) const = 0;
  300.     CSeq_id_Info* x_FindInfo(const CTextseq_id& tid) const;
  302. private:
  303.     typedef vector<CSeq_id_Info*>   TVersions;
  304.     typedef map<string, TVersions, PNocase> TStringMap;
  306.     CSeq_id_Info* x_FindVersionEqual(const TVersions& ver_list,
  307.                                      const CTextseq_id& tid) const;
  309.     void x_FindVersionMatch(const TVersions& ver_list,
  310.                             const CTextseq_id& tid,
  311.                             TSeq_id_MatchList& id_list) const;
  313.     TStringMap m_ByAccession;
  314.     TStringMap m_ByName; // Used for searching by string
  315. };
  318. ////////////////////////////////////////////////////////////////////
  319. // Genbank, EMBL and DDBJ joint tree
  322. class CSeq_id_GB_Tree : public CSeq_id_Textseq_Tree
  323. {
  324. protected:
  325.     virtual bool x_Check(const CSeq_id& id) const;
  326.     virtual const CTextseq_id& x_Get(const CSeq_id& id) const;
  327. };
  330. ////////////////////////////////////////////////////////////////////
  331. // Pir tree
  334. class CSeq_id_Pir_Tree : public CSeq_id_Textseq_Tree
  335. {
  336. protected:
  337.     virtual bool x_Check(const CSeq_id& id) const;
  338.     virtual const CTextseq_id& x_Get(const CSeq_id& id) const;
  339. };
  342. ////////////////////////////////////////////////////////////////////
  343. // Swissprot
  346. class CSeq_id_Swissprot_Tree : public CSeq_id_Textseq_Tree
  347. {
  348. protected:
  349.     virtual bool x_Check(const CSeq_id& id) const;
  350.     virtual const CTextseq_id& x_Get(const CSeq_id& id) const;
  351. };
  354. ////////////////////////////////////////////////////////////////////
  355. // Prf tree
  358. class CSeq_id_Prf_Tree : public CSeq_id_Textseq_Tree
  359. {
  360. protected:
  361.     virtual bool x_Check(const CSeq_id& id) const;
  362.     virtual const CTextseq_id& x_Get(const CSeq_id& id) const;
  363. };
  366. ////////////////////////////////////////////////////////////////////
  367. // Tpg tree
  370. class CSeq_id_Tpg_Tree : public CSeq_id_Textseq_Tree
  371. {
  372. protected:
  373.     virtual bool x_Check(const CSeq_id& id) const;
  374.     virtual const CTextseq_id& x_Get(const CSeq_id& id) const;
  375. };
  378. ////////////////////////////////////////////////////////////////////
  379. // Tpe tree
  382. class CSeq_id_Tpe_Tree : public CSeq_id_Textseq_Tree
  383. {
  384. protected:
  385.     virtual bool x_Check(const CSeq_id& id) const;
  386.     virtual const CTextseq_id& x_Get(const CSeq_id& id) const;
  387. };
  390. ////////////////////////////////////////////////////////////////////
  391. // Tpd tree
  394. class CSeq_id_Tpd_Tree : public CSeq_id_Textseq_Tree
  395. {
  396. protected:
  397.     virtual bool x_Check(const CSeq_id& id) const;
  398.     virtual const CTextseq_id& x_Get(const CSeq_id& id) const;
  399. };
  402. ////////////////////////////////////////////////////////////////////
  403. // Other tree
  406. class CSeq_id_Other_Tree : public CSeq_id_Textseq_Tree
  407. {
  408. protected:
  409.     virtual bool x_Check(const CSeq_id& id) const;
  410.     virtual const CTextseq_id& x_Get(const CSeq_id& id) const;
  411. };
  414. ////////////////////////////////////////////////////////////////////
  415. // e_Local tree
  418. class CSeq_id_Local_Tree : public CSeq_id_Which_Tree
  419. {
  420. public:
  421.     CSeq_id_Local_Tree(void);
  422.     ~CSeq_id_Local_Tree(void);
  424.     virtual bool Empty(void) const;
  426.     virtual CSeq_id_Handle FindInfo(const CSeq_id& id) const;
  427.     virtual CSeq_id_Handle FindOrCreate(const CSeq_id& id);
  429.     virtual bool HaveMatch(const CSeq_id_Handle& id) const;
  430.     virtual void FindMatch(const CSeq_id_Handle& id,
  431.                            TSeq_id_MatchList& id_list) const;
  432.     virtual void FindMatchStr(string sid,
  433.                               TSeq_id_MatchList& id_list) const;
  435. private:
  436.     virtual void x_Unindex(const CSeq_id_Info* info);
  437.     CSeq_id_Info* x_FindInfo(const CObject_id& oid) const;
  439.     typedef map<string, CSeq_id_Info*, PNocase> TByStr;
  440.     typedef map<int, CSeq_id_Info*>    TById;
  442.     TByStr m_ByStr;
  443.     TById  m_ById;
  444. };
  447. ////////////////////////////////////////////////////////////////////
  448. // e_General tree
  451. class CSeq_id_General_Tree : public CSeq_id_Which_Tree
  452. {
  453. public:
  454.     CSeq_id_General_Tree(void);
  455.     ~CSeq_id_General_Tree(void);
  457.     virtual bool Empty(void) const;
  459.     virtual CSeq_id_Handle FindInfo(const CSeq_id& id) const;
  460.     virtual CSeq_id_Handle FindOrCreate(const CSeq_id& id);
  462.     virtual bool HaveMatch(const CSeq_id_Handle& id) const;
  463.     virtual void FindMatch(const CSeq_id_Handle& id,
  464.                            TSeq_id_MatchList& id_list) const;
  465.     virtual void FindMatchStr(string sid,
  466.                               TSeq_id_MatchList& id_list) const;
  468. private:
  469.     virtual void x_Unindex(const CSeq_id_Info* info);
  470.     CSeq_id_Info* x_FindInfo(const CDbtag& dbid) const;
  472.     struct STagMap {
  473.     public:
  474.         typedef map<string, CSeq_id_Info*, PNocase> TByStr;
  475.         typedef map<int, CSeq_id_Info*>    TById;
  477.         TByStr m_ByStr;
  478.         TById  m_ById;
  479.     };
  480.     typedef map<string, STagMap, PNocase> TDbMap;
  482.     TDbMap m_DbMap;
  483. };
  486. ////////////////////////////////////////////////////////////////////
  487. // e_Giim tree
  490. class CSeq_id_Giim_Tree : public CSeq_id_Which_Tree
  491. {
  492. public:
  493.     CSeq_id_Giim_Tree(void);
  494.     ~CSeq_id_Giim_Tree(void);
  496.     virtual bool Empty(void) const;
  498.     virtual CSeq_id_Handle FindInfo(const CSeq_id& id) const;
  499.     virtual CSeq_id_Handle FindOrCreate(const CSeq_id& id);
  501.     virtual bool HaveMatch(const CSeq_id_Handle& ) const;
  502.     virtual void FindMatch(const CSeq_id_Handle& id,
  503.                            TSeq_id_MatchList& id_list) const;
  504.     virtual void FindMatchStr(string sid,
  505.                               TSeq_id_MatchList& id_list) const;
  507. private:
  508.     virtual void x_Unindex(const CSeq_id_Info* info);
  509.     CSeq_id_Info* x_FindInfo(const CGiimport_id& gid) const;
  511.     // 2-level indexing: first by Id, second by Db+Release
  512.     typedef vector<CSeq_id_Info*> TGiimList;
  513.     typedef map<int, TGiimList>  TIdMap;
  515.     TIdMap m_IdMap;
  516. };
  519. ////////////////////////////////////////////////////////////////////
  520. // e_Patent tree
  523. class CSeq_id_Patent_Tree : public CSeq_id_Which_Tree
  524. {
  525. public:
  526.     CSeq_id_Patent_Tree(void);
  527.     ~CSeq_id_Patent_Tree(void);
  529.     virtual bool Empty(void) const;
  531.     virtual CSeq_id_Handle FindInfo(const CSeq_id& id) const;
  532.     virtual CSeq_id_Handle FindOrCreate(const CSeq_id& id);
  534.     virtual bool HaveMatch(const CSeq_id_Handle& ) const;
  535.     virtual void FindMatch(const CSeq_id_Handle& id,
  536.                            TSeq_id_MatchList& id_list) const;
  537.     virtual void FindMatchStr(string sid,
  538.                               TSeq_id_MatchList& id_list) const;
  540. private:
  541.     virtual void x_Unindex(const CSeq_id_Info* info);
  542.     CSeq_id_Info* x_FindInfo(const CPatent_seq_id& pid) const;
  544.     // 3-level indexing: country, (number|app_number), seqid.
  545.     // Ignoring patent doc-type in indexing.
  546.     struct SPat_idMap {
  547.         typedef map<int, CSeq_id_Info*> TBySeqid;
  548.         typedef map<string, TBySeqid, PNocase> TByNumber; // or by App_number
  550.         TByNumber m_ByNumber;
  551.         TByNumber m_ByApp_number;
  552.     };
  553.     typedef map<string, SPat_idMap, PNocase> TByCountry;
  555.     TByCountry m_CountryMap;
  556. };
  559. ////////////////////////////////////////////////////////////////////
  560. // e_PDB tree
  563. class CSeq_id_PDB_Tree : public CSeq_id_Which_Tree
  564. {
  565. public:
  566.     CSeq_id_PDB_Tree(void);
  567.     ~CSeq_id_PDB_Tree(void);
  569.     virtual bool Empty(void) const;
  571.     virtual CSeq_id_Handle FindInfo(const CSeq_id& id) const;
  572.     virtual CSeq_id_Handle FindOrCreate(const CSeq_id& id);
  574.     virtual void FindMatch(const CSeq_id_Handle& id,
  575.                            TSeq_id_MatchList& id_list) const;
  576.     virtual void FindMatchStr(string sid,
  577.                               TSeq_id_MatchList& id_list) const;
  579. private:
  580.     virtual void x_Unindex(const CSeq_id_Info* info);
  581.     CSeq_id_Info* x_FindInfo(const CPDB_seq_id& pid) const;
  583.     string x_IdToStrKey(const CPDB_seq_id& id) const;
  585.     // Index by mol+chain, no date - too complicated
  586.     typedef vector<CSeq_id_Info*>  TSubMolList;
  587.     typedef map<string, TSubMolList, PNocase> TMolMap;
  589.     TMolMap m_MolMap;
  590. };
  594. /////////////////////////////////////////////////////////////////////////////
  595. //
  596. // Inline methods
  597. //
  598. /////////////////////////////////////////////////////////////////////////////
  600. END_SCOPE(objects)
  601. END_NCBI_SCOPE
  603. /*
  604. * ---------------------------------------------------------------------------
  605. * $Log: seq_id_tree.hpp,v $
  606. * Revision 1000.1  2004/04/12 17:28:34  gouriano
  607. * PRODUCTION: UPGRADED [CATCHUP_003] Dev-tree R1.5
  608. *
  609. * Revision 1.5  2004/02/19 17:25:34  vasilche
  610. * Use CRef<> to safely hold pointer to CSeq_id_Info.
  611. * CSeq_id_Info holds pointer to owner CSeq_id_Which_Tree.
  612. * Reduce number of calls to CSeq_id_Handle.GetSeqId().
  613. *
  614. * Revision 1.4  2004/02/10 21:15:15  grichenk
  615. * Added reverse ID matching.
  616. *
  617. * Revision 1.3  2004/01/08 02:49:11  ucko
  618. * Make m_TreeLock a recursive mutex, as CSeq_id_Textseq_Tree can no
  619. * longer safely use a fast mutex.
  620. *
  621. * Revision 1.2  2003/09/30 16:22:01  vasilche
  622. * Updated internal object manager classes to be able to load ID2 data.
  623. * SNP blobs are loaded as ID2 split blobs - readers convert them automatically.
  624. * Scope caches results of requests for data to data loaders.
  625. * Optimized CSeq_id_Handle for gis.
  626. * Optimized bioseq lookup in scope.
  627. * Reduced object allocations in annotation iterators.
  628. * CScope is allowed to be destroyed before other objects using this scope are
  629. * deleted (feature iterators, bioseq handles etc).
  630. * Optimized lookup for matching Seq-ids in CSeq_id_Mapper.
  631. * Added 'adaptive' option to objmgr_demo application.
  632. *
  633. * Revision 1.1  2003/06/10 19:06:35  vasilche
  634. * Simplified CSeq_id_Mapper and CSeq_id_Handle.
  635. *
  636. *
  637. * ===========================================================================
  638. */
  640. #endif  /* OBJECTS_OBJMGR___SEQ_ID_TREE__HPP */