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

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

生物技术

开发平台：

C/C++

blob_splitter_maker.cpp：源码内容
  1. /*
  2.  * ===========================================================================
  3.  * PRODUCTION $Log: blob_splitter_maker.cpp,v $
  4.  * PRODUCTION Revision 1000.2  2004/06/01 19:24:50  gouriano
  5.  * PRODUCTION PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.10
  6.  * PRODUCTION
  7.  * ===========================================================================
  8.  */
  10. /*  $Id: blob_splitter_maker.cpp,v 1000.2 2004/06/01 19:24:50 gouriano Exp $
  11. * ===========================================================================
  12. *
  13. *                            PUBLIC DOMAIN NOTICE
  14. *               National Center for Biotechnology Information
  15. *
  16. *  This software/database is a "United States Government Work" under the
  17. *  terms of the United States Copyright Act.  It was written as part of
  18. *  the author's official duties as a United States Government employee and
  19. *  thus cannot be copyrighted.  This software/database is freely available
  20. *  to the public for use. The National Library of Medicine and the U.S.
  21. *  Government have not placed any restriction on its use or reproduction.
  22. *
  23. *  Although all reasonable efforts have been taken to ensure the accuracy
  24. *  and reliability of the software and data, the NLM and the U.S.
  25. *  Government do not and cannot warrant the performance or results that
  26. *  may be obtained by using this software or data. The NLM and the U.S.
  27. *  Government disclaim all warranties, express or implied, including
  28. *  warranties of performance, merchantability or fitness for any particular
  29. *  purpose.
  30. *
  31. *  Please cite the author in any work or product based on this material.
  32. *
  33. * ===========================================================================
  34. *
  35. * Author:  Eugene Vasilchenko
  36. *
  37. * File Description:
  38. *   Application for splitting blobs withing ID1 cache
  39. *
  40. * ===========================================================================
  41. */
  43. #include <ncbi_pch.hpp>
  44. #include <objmgr/split/blob_splitter_impl.hpp>
  46. #include <serial/objostr.hpp>
  47. #include <serial/serial.hpp>
  48. #include <serial/iterator.hpp>
  50. #include <objects/general/Object_id.hpp>
  52. #include <objects/seqloc/Seq_id.hpp>
  53. #include <objects/seqloc/Seq_loc.hpp>
  55. #include <objects/seqset/Seq_entry.hpp>
  56. #include <objects/seqset/Bioseq_set.hpp>
  58. #include <objects/seq/Bioseq.hpp>
  59. #include <objects/seq/Seq_annot.hpp>
  60. #include <objects/seq/Annot_id.hpp>
  61. #include <objects/seq/Annot_descr.hpp>
  62. #include <objects/seq/Annotdesc.hpp>
  64. #include <objects/seqalign/Seq_align.hpp>
  65. #include <objects/seqfeat/Seq_feat.hpp>
  66. #include <objects/seqres/Seq_graph.hpp>
  68. #include <objects/seqsplit/ID2S_Split_Info.hpp>
  69. #include <objects/seqsplit/ID2S_Chunk_Id.hpp>
  70. #include <objects/seqsplit/ID2S_Chunk.hpp>
  71. #include <objects/seqsplit/ID2S_Chunk_Data.hpp>
  72. #include <objects/seqsplit/ID2S_Chunk_Info.hpp>
  73. #include <objects/seqsplit/ID2S_Chunk_Content.hpp>
  74. #include <objects/seqsplit/ID2S_Seq_annot_Info.hpp>
  75. #include <objects/seqsplit/ID2S_Feat_type_Info.hpp>
  76. #include <objects/seqsplit/ID2_Seq_loc.hpp>
  77. #include <objects/seqsplit/ID2_Id_Range.hpp>
  78. #include <objects/seqsplit/ID2_Seq_range.hpp>
  79. #include <objects/seqsplit/ID2_Interval.hpp>
  80. #include <objects/seqsplit/ID2_Packed_Seq_ints.hpp>
  82. #include <objmgr/split/blob_splitter.hpp>
  83. #include <objmgr/split/object_splitinfo.hpp>
  84. #include <objmgr/split/annot_piece.hpp>
  85. #include <objmgr/split/asn_sizer.hpp>
  86. #include <objmgr/split/chunk_info.hpp>
  88. BEGIN_NCBI_SCOPE
  89. BEGIN_SCOPE(objects)
  91. template<class C>
  92. inline
  93. C& NonConst(const C& c)
  94. {
  95.     return const_cast<C&>(c);
  96. }
  99. /////////////////////////////////////////////////////////////////////////////
  100. // CBlobSplitterImpl
  101. /////////////////////////////////////////////////////////////////////////////
  104. CBlobSplitterImpl::CBlobSplitterImpl(const SSplitterParams& params)
  105.     : m_Params(params)
  106. {
  107. }
  110. CBlobSplitterImpl::~CBlobSplitterImpl(void)
  111. {
  112. }
  115. void CBlobSplitterImpl::Reset(void)
  116. {
  117.     m_SplitBlob.Reset();
  118.     m_Skeleton.Reset(new CSeq_entry);
  119.     m_NextBioseq_set_Id = 1;
  120.     m_Bioseqs.clear();
  121.     m_Pieces.reset();
  122.     m_Chunks.clear();
  123. }
  126. void CBlobSplitterImpl::MakeID2SObjects(void)
  127. {
  128.     m_Split_Info.Reset(new CID2S_Split_Info);
  129.     ITERATE ( TChunks, it, m_Chunks ) {
  130.         if ( it->first == 0 ) {
  131.             AttachToSkeleton(it->second);
  132.         }
  133.         else {
  134.             MakeID2Chunk(it->first, it->second);
  135.         }
  136.     }
  137.     m_SplitBlob.Reset(*m_Skeleton, *m_Split_Info);
  138.     ITERATE ( TID2Chunks, it, m_ID2_Chunks ) {
  139.         m_SplitBlob.AddChunk(it->first, *it->second);
  140.     }
  141. }
  144. struct SOneSeqAnnots
  145. {
  146.     typedef set<SAnnotTypeSelector> TTypeSet;
  147.     typedef COneSeqRange TTotalLocation;
  149.     void Add(const SAnnotTypeSelector& type, const COneSeqRange& loc)
  150.         {
  151.             m_TotalType.insert(type);
  152.             m_TotalLocation.Add(loc);
  153.         }
  155.     TTypeSet m_TotalType;
  156.     TTotalLocation m_TotalLocation;
  157. };
  160. struct SSplitAnnotInfo
  161. {
  162.     typedef vector<SAnnotTypeSelector> TTypeSet;
  163.     typedef CSeqsRange TLocation;
  165.     TTypeSet m_TypeSet;
  166.     TLocation m_Location;
  167. };
  170. struct SAllAnnots
  171. {
  172.     typedef map<CSeq_id_Handle, SOneSeqAnnots> TAllAnnots;
  173.     typedef vector<SAnnotTypeSelector> TTypeSet;
  174.     typedef map<TTypeSet, CSeqsRange> TSplitAnnots;
  176.     void Add(const CSeq_annot& annot)
  177.         {
  178.             switch ( annot.GetData().Which() ) {
  179.             case CSeq_annot::C_Data::e_Ftable:
  180.                 Add(annot.GetData().GetFtable());
  181.                 break;
  182.             case CSeq_annot::C_Data::e_Align:
  183.                 Add(annot.GetData().GetAlign());
  184.                 break;
  185.             case CSeq_annot::C_Data::e_Graph:
  186.                 Add(annot.GetData().GetGraph());
  187.                 break;
  188.             }
  189.         }
  192.     void Add(const CSeq_annot::C_Data::TGraph& objs)
  193.         {
  194.             SAnnotTypeSelector type(CSeq_annot::C_Data::e_Graph);
  195.             ITERATE ( CSeq_annot::C_Data::TGraph, it, objs ) {
  196.                 CSeqsRange loc;
  197.                 loc.Add(**it);
  198.                 Add(type, loc);
  199.             }
  200.         }
  201.     void Add(const CSeq_annot::C_Data::TAlign& objs)
  202.         {
  203.             SAnnotTypeSelector type(CSeq_annot::C_Data::e_Align);
  204.             ITERATE ( CSeq_annot::C_Data::TAlign, it, objs ) {
  205.                 CSeqsRange loc;
  206.                 loc.Add(**it);
  207.                 Add(type, loc);
  208.             }
  209.         }
  210.     void Add(const CSeq_annot::C_Data::TFtable& objs)
  211.         {
  212.             ITERATE ( CSeq_annot::C_Data::TFtable, it, objs ) {
  213.                 SAnnotTypeSelector type((*it)->GetData().GetSubtype());
  214.                 CSeqsRange loc;
  215.                 loc.Add(**it);
  216.                 Add(type, loc);
  217.             }
  218.         }
  220.     void Add(const SAnnotTypeSelector& sel, const CSeqsRange& loc)
  221.         {
  222.             ITERATE ( CSeqsRange, it, loc ) {
  223.                 m_AllAnnots[it->first].Add(sel, it->second);
  224.             }
  225.         }
  227.     void SplitInfo(void)
  228.         {
  229.             ITERATE ( TAllAnnots, it, m_AllAnnots ) {
  230.                 TTypeSet type_set;
  231.                 ITERATE(SOneSeqAnnots::TTypeSet, tit, it->second.m_TotalType) {
  232.                     type_set.push_back(*tit);
  233.                 }
  234.                 m_SplitAnnots[type_set].Add(it->first,
  235.                                             it->second.m_TotalLocation);
  236.             }
  237.         }
  239.     TAllAnnots m_AllAnnots;
  240.     TSplitAnnots m_SplitAnnots;
  241. };
  244. typedef set<int> TWhole_set;
  245. TWhole_set seq_gis;
  246. typedef set<CSeqsRange::TRange> TGiInt_set;
  247. typedef map<int, TGiInt_set> TInt_set;
  248. TGiInt_set seq_ints;
  251. CRef<CID2_Seq_loc> MakeLoc(int gi, const TGiInt_set& int_set)
  252. {
  253.     CRef<CID2_Seq_loc> loc(new CID2_Seq_loc);
  254.     if ( int_set.size() == 1 ) {
  255.         CID2_Interval& interval = loc->SetInterval();
  256.         interval.SetGi(gi);
  257.         const CSeqsRange::TRange& range = *int_set.begin();
  258.         interval.SetStart(range.GetFrom());
  259.         interval.SetLength(range.GetLength());
  260.     }
  261.     else {
  262.         CID2_Packed_Seq_ints& seq_ints = loc->SetPacked_ints();
  263.         seq_ints.SetGi(gi);
  264.         ITERATE ( TGiInt_set, it, int_set ) {
  265.             CRef<CID2_Seq_range> add(new CID2_Seq_range);
  266.             const CSeqsRange::TRange& range = *it;
  267.             add->SetStart(range.GetFrom());
  268.             add->SetLength(range.GetLength());
  269.             seq_ints.SetIntervals().push_back(add);
  270.         }
  271.     }
  272.     return loc;
  273. }
  276. void AddLoc(CRef<CID2_Seq_loc>& loc, const CRef<CID2_Seq_loc>& add)
  277. {
  278.     if ( !loc ) {
  279.         loc = add;
  280.     }
  281.     else {
  282.         if ( !loc->IsLoc_set() ) {
  283.             CRef<CID2_Seq_loc> loc_set(new CID2_Seq_loc);
  284.             loc_set->SetLoc_set().push_back(loc);
  285.             loc = loc_set;
  286.         }
  287.         loc->SetLoc_set().push_back(add);
  288.     }
  289. }
  292. void AddLoc(CRef<CID2_Seq_loc>& loc, const TInt_set& int_set)
  293. {
  294.     ITERATE ( TInt_set, it, int_set ) {
  295.         AddLoc(loc, MakeLoc(it->first, it->second));
  296.     }
  297. }
  300. void AddLoc(CRef<CID2_Seq_loc>& loc, int gi_start, int gi_count)
  301. {
  302.     if ( gi_count < 4 ) {
  303.         for ( int i = 0; i < gi_count; ++i ) {
  304.             CRef<CID2_Seq_loc> add(new CID2_Seq_loc);
  305.             add->SetGi_whole(gi_start + i);
  306.             AddLoc(loc, add);
  307.         }
  308.     }
  309.     else {
  310.         CRef<CID2_Seq_loc> add(new CID2_Seq_loc);
  311.         add->SetGi_whole_range().SetStart(gi_start);
  312.         add->SetGi_whole_range().SetCount(gi_count);
  313.         AddLoc(loc, add);
  314.     }
  315. }
  317. void AddLoc(CRef<CID2_Seq_loc>& loc, const TWhole_set& whole_set)
  318. {
  319.     int gi_start = 0, gi_count = 0;
  320.     ITERATE ( TWhole_set, it, whole_set ) {
  321.         if ( gi_count == 0 || *it != gi_start + gi_count ) {
  322.             AddLoc(loc, gi_start, gi_count);
  323.             gi_start = *it;
  324.             gi_count = 0;
  325.         }
  326.         ++gi_count;
  327.     }
  328.     AddLoc(loc, gi_start, gi_count);
  329. }
  332. CRef<CID2_Seq_loc> MakeLoc(const CSeqsRange& range)
  333. {
  334.     TWhole_set whole_set;
  335.     TInt_set int_set;
  337.     ITERATE ( CSeqsRange, it, range ) {
  338.         int gi = it->first.GetGi();
  339.         CSeqsRange::TRange range = it->second.GetTotalRange();
  340.         if ( range == range.GetWhole() ) {
  341.             whole_set.insert(gi);
  342.             _ASSERT(int_set.count(gi) == 0);
  343.         }
  344.         else {
  345.             int_set[gi].insert(range);
  346.             _ASSERT(whole_set.count(gi) == 0);
  347.         }
  348.     }
  350.     CRef<CID2_Seq_loc> loc;
  351.     AddLoc(loc, int_set);
  352.     AddLoc(loc, whole_set);
  353.     _ASSERT(loc);
  354.     return loc;
  355. }
  358. void CBlobSplitterImpl::MakeID2Chunk(int id, const SChunkInfo& info)
  359. {
  360.     CRef<CID2S_Chunk> chunk(new CID2S_Chunk);
  361.     CRef<CID2S_Chunk_Info> chunk_info(new CID2S_Chunk_Info);
  362.     chunk_info->SetId(CID2S_Chunk_Id(id));
  364.     typedef map<CAnnotName, SAllAnnots> TAllAnnots;
  365.     TAllAnnots all_annots;
  367.     ITERATE ( SChunkInfo::TChunkAnnots, it, info.m_Annots ) {
  368.         CRef<CID2S_Chunk_Data> data(new CID2S_Chunk_Data);
  369.         chunk->SetData().push_back(data);
  370.         CID2S_Chunk_Data::TId& id = data->SetId();
  371.         if ( it->first > 0 ) {
  372.             id.SetGi(it->first);
  373.         }
  374.         else {
  375.             id.SetBioseq_set(-it->first);
  376.         }
  377.         ITERATE ( SChunkInfo::TIdAnnots, annot_it, it->second ) {
  378.             CRef<CSeq_annot> annot = MakeSeq_annot(*annot_it->first,
  379.                                                    annot_it->second);
  380.             data->SetAnnots().push_back(annot);
  382.             // collect locations
  383.             CAnnotName name = CSeq_annot_SplitInfo::GetName(*annot_it->first);
  384.             all_annots[name].Add(*annot);
  385.         }
  386.     }
  388.     NON_CONST_ITERATE ( TAllAnnots, nit, all_annots ) {
  389.         nit->second.SplitInfo();
  390.         const CAnnotName& annot_name = nit->first;
  391.         ITERATE ( SAllAnnots::TSplitAnnots, it, nit->second.m_SplitAnnots ) {
  392.             const SAllAnnots::TTypeSet& type_set = it->first;
  393.             const CSeqsRange& location = it->second;
  394.             CRef<CID2S_Chunk_Content> content(new CID2S_Chunk_Content);
  395.             CID2S_Seq_annot_Info& annot_info = content->SetSeq_annot();
  396.             if ( annot_name.IsNamed() ) {
  397.                 annot_info.SetName(annot_name.GetName());
  398.             }
  399.             typedef CSeqFeatData::ESubtype TSubtype;
  400.             typedef CSeqFeatData::E_Choice TFeatType;
  401.             typedef set<TSubtype> TSubtypes;
  402.             typedef map<TFeatType, TSubtypes> TFeatTypes;
  403.             TFeatTypes feat_types;
  404.             ITERATE ( SAllAnnots::TTypeSet, tit, type_set ) {
  405.                 const SAnnotTypeSelector& t = *tit;
  406.                 switch ( t.GetAnnotType() ) {
  407.                 case CSeq_annot::C_Data::e_Align:
  408.                     annot_info.SetAlign();
  409.                     break;
  410.                 case CSeq_annot::C_Data::e_Graph:
  411.                     annot_info.SetGraph();
  412.                     break;
  413.                 case CSeq_annot::C_Data::e_Ftable:
  414.                     feat_types[t.GetFeatType()].insert(t.GetFeatSubtype());
  415.                     break;
  416.                 }
  417.             }
  418.             ITERATE ( TFeatTypes, tit, feat_types ) {
  419.                 TFeatType t = tit->first;
  420.                 const TSubtypes& subtypes = tit->second;
  421.                 bool all_subtypes =
  422.                     subtypes.find(CSeqFeatData::eSubtype_any) !=
  423.                     subtypes.end();
  424.                 if ( !all_subtypes ) {
  425.                     all_subtypes = true;
  426.                     for ( TSubtype st = CSeqFeatData::eSubtype_bad;
  427.                           st <= CSeqFeatData::eSubtype_max;
  428.                           st = TSubtype(st+1) ) {
  429.                         if ( CSeqFeatData::GetTypeFromSubtype(st) == t &&
  430.                              subtypes.find(st) == subtypes.end() ) {
  431.                             all_subtypes = false;
  432.                             break;
  433.                         }
  434.                     }
  435.                 }
  436.                 CRef<CID2S_Feat_type_Info> type_info(new CID2S_Feat_type_Info);
  437.                 type_info->SetType(t);
  438.                 if ( !all_subtypes ) {
  439.                     ITERATE ( TSubtypes, stit, subtypes ) {
  440.                         type_info->SetSubtypes().push_back(*stit);
  441.                     }
  442.                 }
  443.                 annot_info.SetFeat().push_back(type_info);
  444.             }
  445.             annot_info.SetSeq_loc(*MakeLoc(location));
  446.             chunk_info->SetContent().push_back(content);
  447.         }
  448.     }
  450. #if 0
  451.     NcbiCout << "Objects: in SChunkInfo: " << info.CountAnnotObjects() <<
  452.         " in CID2S_Chunk: " << CountAnnotObjects(*chunk) << 'n';
  453. #endif
  455.     m_ID2_Chunks[CID2S_Chunk_Id(id)] = chunk;
  456.     m_Split_Info->SetChunks().push_back(chunk_info);
  457. }
  460. void CBlobSplitterImpl::AttachToSkeleton(const SChunkInfo& info)
  461. {
  462.     ITERATE ( SChunkInfo::TChunkAnnots, it, info.m_Annots ) {
  463.         TBioseqs::iterator seq_it = m_Bioseqs.find(it->first);
  464.         _ASSERT(seq_it != m_Bioseqs.end());
  465.         _ASSERT(bool(seq_it->second.m_Bioseq) || bool(seq_it->second.m_Bioseq_set));
  466.         ITERATE ( SChunkInfo::TIdAnnots, annot_it, it->second ) {
  467.             CRef<CSeq_annot> annot = MakeSeq_annot(*annot_it->first,
  468.                                                    annot_it->second);
  469.             if ( seq_it->second.m_Bioseq ) {
  470.                 seq_it->second.m_Bioseq->SetAnnot().push_back(annot);
  471.             }
  472.             else {
  473.                 seq_it->second.m_Bioseq_set->SetAnnot().push_back(annot);
  474.             }
  475.         }
  476.     }
  477. }
  480. CRef<CSeq_annot>
  481. CBlobSplitterImpl::MakeSeq_annot(const CSeq_annot& src,
  482.                                  const TAnnotObjects& objs)
  483. {
  484.     CRef<CSeq_annot> annot(new CSeq_annot);
  485.     if ( src.IsSetId() ) {
  486.         CSeq_annot::TId& id = annot->SetId();
  487.         ITERATE ( CSeq_annot::TId, it, src.GetId() ) {
  488.             id.push_back(Ref(&NonConst(**it)));
  489.         }
  490.     }
  491.     if ( src.IsSetDb() ) {
  492.         annot->SetDb(src.GetDb());
  493.     }
  494.     if ( src.IsSetName() ) {
  495.         annot->SetName(src.GetName());
  496.     }
  497.     if ( src.IsSetDesc() ) {
  498.         annot->SetDesc(NonConst(src.GetDesc()));
  499.     }
  500.     switch ( src.GetData().Which() ) {
  501.     case CSeq_annot::C_Data::e_Ftable:
  502.         ITERATE ( CLocObjects_SplitInfo, it, objs ) {
  503.             CObject& obj = NonConst(*it->m_Object);
  504.             annot->SetData().SetFtable()
  505.                 .push_back(Ref(&dynamic_cast<CSeq_feat&>(obj)));
  506.         }
  507.         break;
  508.     case CSeq_annot::C_Data::e_Align:
  509.         ITERATE ( CLocObjects_SplitInfo, it, objs ) {
  510.             CObject& obj = NonConst(*it->m_Object);
  511.             annot->SetData().SetAlign()
  512.                 .push_back(Ref(&dynamic_cast<CSeq_align&>(obj)));
  513.         }
  514.         break;
  515.     case CSeq_annot::C_Data::e_Graph:
  516.         ITERATE ( CLocObjects_SplitInfo, it, objs ) {
  517.             CObject& obj = NonConst(*it->m_Object);
  518.             annot->SetData().SetGraph()
  519.                 .push_back(Ref(&dynamic_cast<CSeq_graph&>(obj)));
  520.         }
  521.         break;
  522.     }
  523.     return annot;
  524. }
  527. size_t CBlobSplitterImpl::CountAnnotObjects(const TID2Chunks& chunks)
  528. {
  529.     size_t count = 0;
  530.     ITERATE ( TID2Chunks, it, chunks ) {
  531.         count += CountAnnotObjects(*it->second);
  532.     }
  533.     return count;
  534. }
  537. size_t CBlobSplitterImpl::CountAnnotObjects(const CID2S_Chunk& chunk)
  538. {
  539.     size_t count = 0;
  540.     for ( CTypeConstIterator<CSeq_annot> it(ConstBegin(chunk)); it; ++it ) {
  541.         count += CSeq_annot_SplitInfo::CountAnnotObjects(*it);
  542.     }
  543.     return count;
  544. }
  547. END_SCOPE(objects)
  548. END_NCBI_SCOPE
  550. /*
  551. * ---------------------------------------------------------------------------
  552. * $Log: blob_splitter_maker.cpp,v $
  553. * Revision 1000.2  2004/06/01 19:24:50  gouriano
  554. * PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.10
  555. *
  556. * Revision 1.10  2004/05/21 21:42:13  gorelenk
  557. * Added PCH ncbi_pch.hpp
  558. *
  559. * Revision 1.9  2004/02/04 18:05:40  grichenk
  560. * Added annotation filtering by set of types/subtypes.
  561. * Renamed *Choice to *Type in SAnnotSelector.
  562. *
  563. * Revision 1.8  2004/01/22 20:10:42  vasilche
  564. * 1. Splitted ID2 specs to two parts.
  565. * ID2 now specifies only protocol.
  566. * Specification of ID2 split data is moved to seqsplit ASN module.
  567. * For now they are still reside in one resulting library as before - libid2.
  568. * As the result split specific headers are now in objects/seqsplit.
  569. * 2. Moved ID2 and ID1 specific code out of object manager.
  570. * Protocol is processed by corresponding readers.
  571. * ID2 split parsing is processed by ncbi_xreader library - used by all readers.
  572. * 3. Updated OBJMGR_LIBS correspondingly.
  573. *
  574. * Revision 1.7  2004/01/07 17:36:24  vasilche
  575. * Moved id2_split headers to include/objmgr/split.
  576. * Fixed include path to genbank.
  577. *
  578. * Revision 1.6  2003/12/03 19:30:45  kuznets
  579. * Misprint fixed
  580. *
  581. * Revision 1.5  2003/12/02 19:12:24  vasilche
  582. * Fixed compilation on MSVC.
  583. *
  584. * Revision 1.4  2003/12/01 18:37:10  vasilche
  585. * Separate different annotation types in split info to reduce memory usage.
  586. *
  587. * Revision 1.3  2003/11/26 23:04:58  vasilche
  588. * Removed extra semicolons after BEGIN_SCOPE and END_SCOPE.
  589. *
  590. * Revision 1.2  2003/11/26 17:56:02  vasilche
  591. * Implemented ID2 split in ID1 cache.
  592. * Fixed loading of splitted annotations.
  593. *
  594. * Revision 1.1  2003/11/12 16:18:28  vasilche
  595. * First implementation of ID2 blob splitter withing cache.
  596. *
  597. * ===========================================================================
  598. */