NCBI C++ ToolKit
request_result.hpp
Go to the documentation of this file.

Go to the SVN repository for this file.

1 #ifndef GBLOADER_REQUEST_RESULT__HPP_INCLUDED
2 #define GBLOADER_REQUEST_RESULT__HPP_INCLUDED
3 
4 /* $Id: request_result.hpp 99442 2023-03-28 13:31:12Z vasilche $
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 * Class for storing results of reader's request and thread synchronization
33 *
34 * ===========================================================================
35 */
36 
37 #include <corelib/ncbiobj.hpp>
38 #include <corelib/ncbimtx.hpp>
39 #include <corelib/ncbitime.hpp>
42 #include <util/mutex_pool.hpp>
47 
48 #include <map>
49 #include <set>
50 #include <string>
51 #include <vector>
52 
55 
56 class CSeq_id;
57 class CSeq_id_Handle;
58 class CID2_Blob_Id;
60 class CBlob_id;
61 class CTSE_Info;
62 class CTSE_SetObjectInfo;
63 
64 class CGBDataLoader;
65 class CReadDispatcher;
67 class CReaderRequestConn;
69 class CWriter;
70 
73 };
74 
76 {
77 public:
78  typedef int TState;
79  typedef vector<CSeq_id_Handle> TList;
80  typedef TList::const_reference const_reference;
81  typedef TList::const_iterator const_iterator;
82 
83  enum {
84  kUnknownState = -256
85  };
86  CFixedSeq_ids(void);
87  explicit
89  explicit
90  CFixedSeq_ids(const TList& list,
91  TState state = kUnknownState);
92  CFixedSeq_ids(ENcbiOwnership ownership, TList& list,
93  TState state = kUnknownState);
94 
95  const TList& Get(void) const
96  {
97  return m_Ref->GetData();
98  }
99  operator const TList&(void) const
100  {
101  return Get();
102  }
103 
104  TState GetState(void) const
105  {
106  return m_State;
107  }
108 
109  bool IsFound(void) const
110  {
111  return !empty() &&
112  !(GetState() & CBioseq_Handle::fState_not_found);
113  }
114 
115  void SetState(TState state);
116  void SetNotFound(void);
117 
118  bool empty(void) const
119  {
120  return Get().empty();
121  }
122  size_t size(void) const
123  {
124  return Get().size();
125  }
126  const_iterator begin(void) const
127  {
128  return Get().begin();
129  }
130  const_iterator end(void) const
131  {
132  return Get().end();
133  }
134  const_reference front(void) const
135  {
136  return *begin();
137  }
138 
139  CDataLoader::SGiFound FindGi(void) const;
140  CDataLoader::SAccVerFound FindAccVer(void) const;
141  string FindLabel(void) const;
142 
143 private:
145 
148 };
149 
150 
152 {
153 public:
155  typedef vector< CConstRef<CID2S_Seq_annot_Info> > TAnnotInfo;
156 
158  {
159  return m_NamedAnnotNames;
160  }
161 
162  const TAnnotInfo& GetAnnotInfo(void) const
163  {
164  return m_AnnotInfo;
165  }
166 
167  void AddNamedAnnotName(const string& name);
168  void AddAnnotInfo(const CID2S_Seq_annot_Info& info);
169 
170  bool Matches(const SAnnotSelector* sel) const;
171 
172 private:
175 };
176 
177 
179 {
180 public:
182 
183  CBlob_Info(void);
184  CBlob_Info(CConstRef<CBlob_id> blob_id, TContentsMask contents);
185  ~CBlob_Info(void);
186 
187  const CConstRef<CBlob_id>& GetBlob_id(void) const
188  {
189  return m_Blob_id;
190  }
192 
193  const TContentsMask& GetContentsMask(void) const
194  {
195  return m_Contents;
196  }
197  bool Matches(TContentsMask mask, const SAnnotSelector* sel) const;
198 
199  bool IsSetAnnotInfo(void) const
200  {
201  return m_AnnotInfo.NotEmpty();
202  }
204  {
205  return m_AnnotInfo;
206  }
207  void SetAnnotInfo(CRef<CBlob_Annot_Info>& annot_info);
208 
209 private:
213 };
214 
215 
217 {
218 public:
219  typedef int TState;
220  typedef vector<CBlob_Info> TList;
221  typedef TList::const_reference const_reference;
222  typedef TList::const_iterator const_iterator;
223 
224  enum {
225  kUnknownState = -256
226  };
227  CFixedBlob_ids(void);
228  explicit
230  explicit
231  CFixedBlob_ids(const TList& list,
232  TState state = kUnknownState);
233  CFixedBlob_ids(ENcbiOwnership ownership, TList& list,
234  TState state = kUnknownState);
235 
236  TState GetState(void) const
237  {
238  return m_State;
239  }
240 
241  bool IsFound(void) const
242  {
243  return !empty() &&
244  !(GetState() & CBioseq_Handle::fState_not_found);
245  }
246 
247  void SetState(TState state);
248  void SetNotFound(void);
249 
250  const TList& Get(void) const
251  {
252  return m_Ref->GetData();
253  }
254  operator const TList&(void) const
255  {
256  return Get();
257  }
258 
259  bool empty(void) const
260  {
261  return Get().empty();
262  }
263  size_t size(void) const
264  {
265  return Get().size();
266  }
267  const_iterator begin(void) const
268  {
269  return Get().begin();
270  }
271  const_iterator end(void) const
272  {
273  return Get().end();
274  }
275  const_reference front(void) const
276  {
277  return *begin();
278  }
279 
280  CFixedBlob_ids Filter(const SAnnotSelector* sel) const;
281 
282 private:
284 
287 };
288 
289 
290 /////////////////////////////////////////////////////////////////////////////
291 // whole request lock
292 /////////////////////////////////////////////////////////////////////////////
293 
294 
296 
297 
298 class NCBI_XREADER_EXPORT CGBInfoManager : public GBL::CInfoManager
299 {
300 public:
301  CGBInfoManager(size_t gc_size);
302  ~CGBInfoManager(void);
303 
305  typedef GBL::CInfoCache<CSeq_id_Handle, TSequenceAcc> TCacheAcc;
306  typedef GBL::CInfoCache<CSeq_id_Handle, CFixedSeq_ids> TCacheSeqIds;
308  typedef GBL::CInfoCache<CSeq_id_Handle, TSequenceGi> TCacheGi;
309  typedef GBL::CInfoCache<CSeq_id_Handle, string> TCacheLabel;
311  typedef GBL::CInfoCache<CSeq_id_Handle, TTaxId> TCacheTaxId;
312  typedef pair<CSeq_id_Handle, string> TKeyBlobIds;
313  typedef GBL::CInfoCache<TKeyBlobIds, CFixedBlob_ids> TCacheBlobIds;
314  typedef int TBlobState;
315  typedef GBL::CInfoCache<CBlob_id, TBlobState> TCacheBlobState;
317  typedef GBL::CInfoCache<CSeq_id_Handle, TSequenceHash> TCacheHash;
319  typedef GBL::CInfoCache<CSeq_id_Handle, TSequenceLength> TCacheLength;
321  typedef GBL::CInfoCache<CSeq_id_Handle, TSequenceType> TCacheType;
322  typedef int TBlobVersion;
323  typedef GBL::CInfoCache<CBlob_id, TBlobVersion> TCacheBlobVersion;
324  typedef GBL::CInfoCache<CBlob_id, CTSE_LoadLock> TCacheBlob;
325  typedef int TChunkId;
326 
339 };
340 
341 
343  public CGBInfoManager::TCacheSeqIds::TInfoLock
344 {
345  typedef CGBInfoManager::TCacheSeqIds::TInfoLock TParent;
346 public:
348  {
349  }
353 
354  TData GetSeq_ids(void) const
355  {
356  return GetData();
357  }
359  {
360  return GetData().GetState();
361  }
362 
363  static bool IsFound(const TData& data)
364  {
365  return data.IsFound();
366  }
367  bool IsFound(void) const
368  {
369  return IsFound(GetData());
370  }
371  static GBL::EExpirationType GetExpType(const TData& data)
372  {
373  return IsFound(data)? GBL::eExpire_normal: GBL::eExpire_fast;
374  }
376  {
377  return GetExpType(GetData());
378  }
379 
380  bool SetLoadedSeq_ids(const TData& data)
381  {
382  return SetLoaded(data, GetExpType(data));
383  }
384  bool SetLoadedSeq_ids(const TData& data, TExpirationTime expiration_time)
385  {
386  return SetLoadedFor(data, expiration_time);
387  }
389  {
390  return SetLoadedFor(ids.GetSeq_ids(), ids.GetExpirationTime());
391  }
392 };
393 
394 
396  public CGBInfoManager::TCacheGi::TInfoLock
397 {
398  typedef CGBInfoManager::TCacheGi::TInfoLock TParent;
399 public:
401  {
402  }
404 
405  static TGi GetGi(const TData& data)
406  {
407  return data.gi;
408  }
409  static bool IsFound(const TData& data)
410  {
411  return data.sequence_found;
412  }
413  bool IsFound(void) const
414  {
415  return IsFound(GetData());
416  }
417  static GBL::EExpirationType GetExpType(const TData& data)
418  {
419  return IsFound(data)? GBL::eExpire_normal: GBL::eExpire_fast;
420  }
422  {
423  return GetExpType(GetData());
424  }
425 
426  bool IsLoadedGi(void) const
427  {
428  return IsLoaded();
429  }
430  TExpirationTime GetExpirationTimeGi(void) const
431  {
432  return GetExpirationTime();
433  }
434  TData GetGi(void) const
435  {
436  return GetData();
437  }
438  bool SetLoadedGi(const TData& data)
439  {
440  return SetLoaded(data, GetExpType(data));
441  }
442  bool SetLoadedGi(const TData& data, TExpirationTime expiration_time)
443  {
444  return SetLoadedFor(data, expiration_time);
445  }
446 };
447 
448 
450  public CGBInfoManager::TCacheAcc::TInfoLock
451 {
452  typedef CGBInfoManager::TCacheAcc::TInfoLock TParent;
453 public:
455  {
456  }
458 
459  static const CSeq_id_Handle& GetAcc(const TData& data)
460  {
461  return data.acc_ver;
462  }
463  static bool IsFound(const TData& data)
464  {
465  return data.sequence_found;
466  }
467  bool IsFound(void) const
468  {
469  return IsFound(GetData());
470  }
471  static GBL::EExpirationType GetExpType(const TData& data)
472  {
473  return IsFound(data)? GBL::eExpire_normal: GBL::eExpire_fast;
474  }
476  {
477  return GetExpType(GetData());
478  }
479 
480  bool IsLoadedAccVer(void) const
481  {
482  return IsLoaded();
483  }
484  TExpirationTime GetExpirationTimeAcc(void) const
485  {
486  return GetExpirationTime();
487  }
488  TData GetAccVer(void) const
489  {
490  return GetData();
491  }
492  bool SetLoadedAccVer(const TData& data)
493  {
494  return SetLoaded(data, GetExpType(data));
495  }
496  bool SetLoadedAccVer(const TData& data, TExpirationTime expiration_time)
497  {
498  return SetLoadedFor(data, expiration_time);
499  }
500 };
501 
502 
504  public CGBInfoManager::TCacheLabel::TInfoLock
505 {
506  typedef CGBInfoManager::TCacheLabel::TInfoLock TParent;
507 public:
509  {
510  }
512 
513  static bool IsFound(const TData& data)
514  {
515  return !data.empty();
516  }
517  bool IsFound(void) const
518  {
519  return IsFound(GetData());
520  }
521  static GBL::EExpirationType GetExpType(const TData& data)
522  {
523  return IsFound(data)? GBL::eExpire_normal: GBL::eExpire_fast;
524  }
526  {
527  return GetExpType(GetData());
528  }
529 
530  bool IsLoadedLabel(void) const
531  {
532  return IsLoaded();
533  }
534  TData GetLabel(void) const
535  {
536  return GetData();
537  }
538  bool SetLoadedLabel(const TData& data)
539  {
540  return SetLoaded(data, GetExpType(data));
541  }
542  bool SetLoadedLabel(const TData& data, TExpirationTime expiration_time)
543  {
544  return SetLoadedFor(data, expiration_time);
545  }
546 };
547 
548 
550  public CGBInfoManager::TCacheTaxId::TInfoLock
551 {
552  typedef CGBInfoManager::TCacheTaxId::TInfoLock TParent;
553 public:
555  {
556  }
558 
559  static bool IsFound(const TData& data)
560  {
561  return data != INVALID_TAX_ID;
562  }
563  bool IsFound(void) const
564  {
565  return IsFound(GetData());
566  }
567  static GBL::EExpirationType GetExpType(const TData& data)
568  {
569  return IsFound(data)? GBL::eExpire_normal: GBL::eExpire_fast;
570  }
572  {
573  return GetExpType(GetData());
574  }
575 
576  bool IsLoadedTaxId(void) const
577  {
578  return IsLoaded();
579  }
580  TData GetTaxId(void) const
581  {
582  return GetData();
583  }
584  bool SetLoadedTaxId(const TData& data)
585  {
586  return SetLoaded(data, GetExpType(data));
587  }
588  bool SetLoadedTaxId(const TData& data, TExpirationTime expiration_time)
589  {
590  return SetLoadedFor(data, expiration_time);
591  }
592 };
593 
594 
596  public CGBInfoManager::TCacheHash::TInfoLock
597 {
598  typedef CGBInfoManager::TCacheHash::TInfoLock TParent;
599 public:
601  {
602  }
604 
605  static int GetHash(const TData& data)
606  {
607  return data.hash;
608  }
609  static bool IsFound(const TData& data)
610  {
611  return data.sequence_found;
612  }
613  bool IsFound(void) const
614  {
615  return IsFound(GetData());
616  }
617  static GBL::EExpirationType GetExpType(const TData& data)
618  {
619  return IsFound(data)? GBL::eExpire_normal: GBL::eExpire_fast;
620  }
622  {
623  return GetExpType(GetData());
624  }
625 
626  bool IsLoadedHash(void) const
627  {
628  return IsLoaded();
629  }
630  TData GetHash(void) const
631  {
632  return GetData();
633  }
634  bool SetLoadedHash(const TData& data)
635  {
636  return SetLoaded(data, GetExpType(data));
637  }
638  bool SetLoadedHash(const TData& data, TExpirationTime expiration_time)
639  {
640  return SetLoadedFor(data, expiration_time);
641  }
642 };
643 
644 
646  public CGBInfoManager::TCacheLength::TInfoLock
647 {
648  typedef CGBInfoManager::TCacheLength::TInfoLock TParent;
649 public:
651  {
652  }
654 
655  static bool IsFound(const TData& data)
656  {
657  return data != kInvalidSeqPos;
658  }
659  bool IsFound(void) const
660  {
661  return IsFound(GetData());
662  }
663  static GBL::EExpirationType GetExpType(const TData& data)
664  {
665  return IsFound(data)? GBL::eExpire_normal: GBL::eExpire_fast;
666  }
668  {
669  return GetExpType(GetData());
670  }
671 
672  bool IsLoadedLength(void) const
673  {
674  return IsLoaded();
675  }
676  TData GetLength(void) const
677  {
678  return GetData();
679  }
680  bool SetLoadedLength(const TData& data)
681  {
682  return SetLoaded(data, GetExpType(data));
683  }
684  bool SetLoadedLength(const TData& data, TExpirationTime expiration_time)
685  {
686  return SetLoadedFor(data, expiration_time);
687  }
688 };
689 
690 
692  public CGBInfoManager::TCacheType::TInfoLock
693 {
694  typedef CGBInfoManager::TCacheType::TInfoLock TParent;
695 public:
697  {
698  }
700 
701  static CSeq_inst::TMol GetType(const TData& data)
702  {
703  return data.type;
704  }
705  static bool IsFound(const TData& data)
706  {
707  return data.sequence_found;
708  }
709  bool IsFound(void) const
710  {
711  return IsFound(GetData());
712  }
713  static GBL::EExpirationType GetExpType(const TData& data)
714  {
715  return IsFound(data)? GBL::eExpire_normal: GBL::eExpire_fast;
716  }
718  {
719  return GetExpType(GetData());
720  }
721 
722  bool IsLoadedType(void) const
723  {
724  return IsLoaded();
725  }
726  TData GetType(void) const
727  {
728  return GetData();
729  }
730  bool SetLoadedType(const TData& data)
731  {
732  return SetLoaded(data, GetExpType(data));
733  }
734  bool SetLoadedType(const TData& data, TExpirationTime expiration_time)
735  {
736  return SetLoadedFor(data, expiration_time);
737  }
738 };
739 
740 
742  public CGBInfoManager::TCacheBlobIds::TInfoLock
743 {
744  typedef CGBInfoManager::TCacheBlobIds::TInfoLock TParent;
745 public:
748  {
749  }
751  const CSeq_id_Handle& id, const SAnnotSelector* sel = 0);
753  const CSeq_id_Handle& id, const SAnnotSelector* sel,
755 
756  TData GetBlob_ids(void) const
757  {
758  return GetData();
759  }
761  {
762  return GetData().GetState();
763  }
764 
765  static bool IsFound(const TData& data)
766  {
767  return data.IsFound();
768  }
769  bool IsFound(void) const
770  {
771  return IsFound(GetData());
772  }
773  static GBL::EExpirationType GetExpType(const TData& data)
774  {
775  return IsFound(data)? GBL::eExpire_normal: GBL::eExpire_fast;
776  }
778  {
779  return GetExpType(GetData());
780  }
781 
782  bool SetLoadedBlob_ids(const TData& data, TExpirationTime expiration_time)
783  {
784  return SetLoadedFor(data, expiration_time);
785  }
786  bool SetLoadedBlob_ids(const TData& data)
787  {
788  return SetLoaded(data, GetExpType(data));
789  }
790  bool SetLoadedBlob_ids(const SAnnotSelector* sel,
791  const TData& blob_ids,
792  TExpirationTime expiration_time);
793  bool SetLoadedBlob_ids(const SAnnotSelector* sel,
794  const TData& blob_ids);
796  TExpirationTime expiration_time)
797  {
798  return SetLoadedFor(CFixedBlob_ids(state), expiration_time);
799  }
801  {
802  return SetLoadedBlob_ids(CFixedBlob_ids(state));
803  }
805  {
806  return SetLoadedBlob_ids(ids.GetBlob_ids(), ids.GetExpirationTime());
807  }
808 };
809 
810 
812  public CGBInfoManager::TCacheBlobState::TInfoLock
813 {
814  typedef CGBInfoManager::TCacheBlobState::TInfoLock TParent;
815 public:
817  {
818  }
822 
823  static bool IsFound(const TData& data)
824  {
826  }
827  bool IsFound(void) const
828  {
829  return IsFound(GetData());
830  }
831  static GBL::EExpirationType GetExpType(const TData& data)
832  {
833  return IsFound(data)? GBL::eExpire_normal: GBL::eExpire_fast;
834  }
836  {
837  return GetExpType(GetData());
838  }
839 
840  TData GetBlobState(void) const
841  {
842  return GetData();
843  }
844  bool IsLoadedBlobState(void) const
845  {
846  return IsLoaded();
847  }
848 };
849 
850 
852  public CGBInfoManager::TCacheBlobVersion::TInfoLock
853 {
854  typedef CGBInfoManager::TCacheBlobVersion::TInfoLock TParent;
855 public:
857  {
858  }
862 
863  static bool IsFound(const TData& data)
864  {
865  return data >= 0;
866  }
867  bool IsFound(void) const
868  {
869  return IsFound(GetData());
870  }
871  static GBL::EExpirationType GetExpType(const TData& data)
872  {
873  return IsFound(data)? GBL::eExpire_normal: GBL::eExpire_fast;
874  }
876  {
877  return GetExpType(GetData());
878  }
879 
880  TData GetBlobVersion(void) const
881  {
882  return GetData();
883  }
884  bool IsLoadedBlobVersion(void) const
885  {
886  return IsLoaded();
887  }
888 };
889 
890 
891 class CLoadLockBlob;
892 class CLoadLockSetter;
893 
894 // CLoadLockBlob performs pre-loading lock and check
895 // CLoadLockSetter should be used to do pass loaded data to OM
897  public CGBInfoManager::TCacheBlob::TInfoLock
898 {
899  typedef CGBInfoManager::TCacheBlob::TInfoLock TParent;
900 public:
903 
905  const CBlob_id& blob_id,
906  TChunkId chunk_id = kMain_ChunkId); // initial chunk
907  ~CLoadLockBlob(void);
908 
909  bool IsLoadedBlob(void) const // test if main blob is loaded
910  {
911  return TParent::IsLoaded();
912  }
913 
914  void SelectChunk(TChunkId chunk_id); // select current chunk
915  TChunkId GetSelectedChunkId(void) const;
916 
917  bool IsLoadedChunk(void) const; // test current chunk
918  bool IsLoadedChunk(TChunkId chunk_id) const; // test another chunk
919 
920  CTSE_LoadLock& GetTSE_LoadLock(void);
922  {
923  return *m_Chunk;
924  }
925 
926  TBlobVersion GetKnownBlobVersion(void) const;
927 
928  const CTSE_Split_Info& GetSplitInfo(void) const;
929  bool NeedsDelayedMainChunk(void) const;
930 
931 protected:
932  friend class CLoadLockSetter;
933 
935 
936 private:
937  // hide non-specific methods
938  // use either Blob or Chunk variants
939  void IsLoaded(void);
940  void SetLoaded(void);
941 
943  CTSE_LoadLock m_TSE_LoadLock; // after loading for chunk access
945 };
946 
947 
948 // CLoadLockSetter should be used to do pass loaded data to OM
950  public CGBInfoManager::TCacheBlob::TInfoLock
951 {
952  typedef CGBInfoManager::TCacheBlob::TInfoLock TParent;
953 public:
957 
958  explicit CLoadLockSetter(CLoadLockBlob& blob);
959  CLoadLockSetter(CLoadLockBlob& blob, TChunkId chunk_id);
961  const CBlob_id& blob_id,
962  TChunkId chunk_id = kMain_ChunkId);
963  ~CLoadLockSetter(void);
964 
965  bool IsLoaded(void) const;
966  void SetLoaded(void);
967 
969  {
970  return m_TSE_LoadLock;
971  }
973  {
974  return *m_Chunk;
975  }
976 
977  CTSE_Split_Info& GetSplitInfo(void);
978 
979  TBlobState GetBlobState(void) const;
980 
981  void SetSeq_entry(CSeq_entry& entry, CTSE_SetObjectInfo* set_info = 0);
982 
983  void AllowIncompleteLoading();
984 
985 protected:
986 
987  void x_SelectChunk(TChunkId chunk_id);
988  void x_Init(CLoadLockBlob& blob, TChunkId chunk_id);
989  void x_ObtainTSE_LoadLock(CReaderRequestResult& result,
990  const CBlob_id& blob_id);
991 
992 private:
997 };
998 
999 
1000 class NCBI_XREADER_EXPORT CReaderRequestResult : public GBL::CInfoRequestor
1001 {
1002 public:
1003  CReaderRequestResult(const CSeq_id_Handle& requested_id,
1004  CReadDispatcher& dispatcher, // for getting CWriter
1005  CGBInfoManager& manager);
1006  virtual ~CReaderRequestResult(void);
1007 
1009  {
1010  return static_cast<CGBInfoManager&>(CInfoRequestor::GetManager());
1011  }
1012 
1013  typedef string TKeySeq_ids;
1015  typedef pair<CSeq_id_Handle, string> TKeyBlob_ids;
1018  typedef size_t TLevel;
1021  typedef GBL::CInfo_Base::TExpirationTime TExpirationTime;
1022 
1023  //////////////////////////////////////////////////////////////////
1024  // new lock Manager support
1025 
1026  TExpirationTime GetRequestTime(void) const;
1027  TExpirationTime GetNewExpirationTime(GBL::EExpirationType type) const;
1028 
1029  typedef CGBInfoManager::TCacheSeqIds::TInfoLock TInfoLockIds;
1031  typedef CGBInfoManager::TCacheAcc::TInfoLock TInfoLockAcc;
1033  typedef CGBInfoManager::TCacheGi::TInfoLock TInfoLockGi;
1034  typedef CGBInfoManager::TCacheLabel::TInfoLock TInfoLockLabel;
1036  typedef CGBInfoManager::TCacheTaxId::TInfoLock TInfoLockTaxId;
1038  typedef CGBInfoManager::TCacheHash::TInfoLock TInfoLockHash;
1040  typedef CGBInfoManager::TCacheLength::TInfoLock TInfoLockLength;
1042  typedef CGBInfoManager::TCacheType::TInfoLock TInfoLockType;
1043  typedef CGBInfoManager::TCacheBlobIds::TInfoLock TInfoLockBlobIds;
1044  typedef CGBInfoManager::TCacheBlobState::TInfoLock TInfoLockBlobState;
1045  typedef CGBInfoManager::TCacheBlobVersion::TInfoLock TInfoLockBlobVersion;
1046  typedef CGBInfoManager::TCacheBlob::TInfoLock TInfoLockBlob;
1047 
1048  bool IsLoadedSeqIds(const CSeq_id_Handle& id);
1049  bool MarkLoadingSeqIds(const CSeq_id_Handle& id);
1050  TInfoLockIds GetLoadLockSeqIds(const CSeq_id_Handle& id);
1051  TInfoLockIds GetLoadedSeqIds(const CSeq_id_Handle& id);
1052  // returns true if information can be stored into external cache
1053  bool SetLoadedSeqIds(const CSeq_id_Handle& id,
1054  const CFixedSeq_ids& value);
1055 
1056  bool IsLoadedAcc(const CSeq_id_Handle& id);
1057  bool MarkLoadingAcc(const CSeq_id_Handle& id);
1058  TInfoLockAcc GetLoadLockAcc(const CSeq_id_Handle& id);
1059  TInfoLockAcc GetLoadedAcc(const CSeq_id_Handle& id);
1060  // returns true if information can be stored into external cache
1061  bool SetLoadedAcc(const CSeq_id_Handle& id,
1062  const TSequenceAcc& value);
1063 
1064  bool IsLoadedGi(const CSeq_id_Handle& id);
1065  bool MarkLoadingGi(const CSeq_id_Handle& id);
1066  TInfoLockGi GetLoadLockGi(const CSeq_id_Handle& id);
1067  TInfoLockGi GetLoadedGi(const CSeq_id_Handle& id);
1068  // returns true if information can be stored into external cache
1069  bool SetLoadedGi(const CSeq_id_Handle& id,
1070  const TSequenceGi& value);
1071 
1072  // set Acc.Ver info using Ids info
1073  bool UpdateAccFromSeqIds(TInfoLockAcc& acc_lock,
1074  const TInfoLockIds& ids_lock);
1075  bool SetLoadedAccFromSeqIds(const CSeq_id_Handle& id,
1076  const CLoadLockSeqIds& ids_lock);
1077 
1078  // set GI info using Ids info
1079  bool UpdateGiFromSeqIds(TInfoLockGi& gi_lock,
1080  const TInfoLockIds& ids_lock);
1081  bool SetLoadedGiFromSeqIds(const CSeq_id_Handle& id,
1082  const CLoadLockSeqIds& ids_lock);
1083 
1084  // set Ids info using other Ids info
1085  bool SetLoadedSeqIds(const CSeq_id_Handle& id,
1086  const CLoadLockSeqIds& ids);
1087  bool SetLoadedSeqIdsFromZeroGi(const CSeq_id_Handle& id,
1088  const CLoadLockGi& gi_lock);
1089  bool SetLoadedBlobIds(const CSeq_id_Handle& id,
1090  const SAnnotSelector* sel,
1091  const CLoadLockBlobIds& ids);
1092  bool SetLoadedBlobIdsFromZeroGi(const CSeq_id_Handle& id,
1093  const SAnnotSelector* sel,
1094  const CLoadLockGi& gi_lock);
1095 
1096  // set Acc.Ver info using Ids info
1097  bool UpdateLabelFromSeqIds(TInfoLockLabel& label_lock,
1098  const TInfoLockIds& ids_lock);
1099  bool SetLoadedLabelFromSeqIds(const CSeq_id_Handle& id,
1100  const CLoadLockSeqIds& ids_lock);
1101 
1102  bool IsLoadedLabel(const CSeq_id_Handle& id);
1103  bool MarkLoadingLabel(const CSeq_id_Handle& id);
1104  TInfoLockLabel GetLoadLockLabel(const CSeq_id_Handle& id);
1105  TInfoLockLabel GetLoadedLabel(const CSeq_id_Handle& id);
1106  // returns true if information can be stored into external cache
1107  bool SetLoadedLabel(const CSeq_id_Handle& id,
1108  const string& value);
1109 
1110  bool IsLoadedTaxId(const CSeq_id_Handle& id);
1111  bool MarkLoadingTaxId(const CSeq_id_Handle& id);
1112  TInfoLockTaxId GetLoadLockTaxId(const CSeq_id_Handle& id);
1113  TInfoLockTaxId GetLoadedTaxId(const CSeq_id_Handle& id);
1114  // returns true if information can be stored into external cache
1115  bool SetLoadedTaxId(const CSeq_id_Handle& id,
1116  const TTaxId& value);
1117 
1118  bool IsLoadedHash(const CSeq_id_Handle& id);
1119  bool MarkLoadingHash(const CSeq_id_Handle& id);
1120  TInfoLockHash GetLoadLockHash(const CSeq_id_Handle& id);
1121  TInfoLockHash GetLoadedHash(const CSeq_id_Handle& id);
1122  // returns true if information can be stored into external cache
1123  bool SetLoadedHash(const CSeq_id_Handle& id,
1124  const TSequenceHash& value);
1125 
1126  bool IsLoadedLength(const CSeq_id_Handle& id);
1127  bool MarkLoadingLength(const CSeq_id_Handle& id);
1128  TInfoLockLength GetLoadLockLength(const CSeq_id_Handle& id);
1129  TInfoLockLength GetLoadedLength(const CSeq_id_Handle& id);
1130  // returns true if information can be stored into external cache
1131  bool SetLoadedLength(const CSeq_id_Handle& id,
1132  const TSequenceLength& value);
1133 
1134  bool IsLoadedType(const CSeq_id_Handle& id);
1135  bool MarkLoadingType(const CSeq_id_Handle& id);
1136  TInfoLockType GetLoadLockType(const CSeq_id_Handle& id);
1137  TInfoLockType GetLoadedType(const CSeq_id_Handle& id);
1138  // returns true if information can be stored into external cache
1139  bool SetLoadedType(const CSeq_id_Handle& id,
1140  const TSequenceType& value);
1141 
1142  bool IsLoadedBlobIds(const CSeq_id_Handle& id,
1143  const SAnnotSelector* sel);
1144  bool MarkLoadingBlobIds(const CSeq_id_Handle& id,
1145  const SAnnotSelector* sel);
1146  TInfoLockBlobIds GetLoadLockBlobIds(const CSeq_id_Handle& id,
1147  const SAnnotSelector* sel);
1148  TInfoLockBlobIds GetLoadedBlobIds(const CSeq_id_Handle& id,
1149  const SAnnotSelector* sel);
1150  // returns true if information can be stored into external cache
1151  bool SetLoadedBlobIds(const CSeq_id_Handle& id,
1152  const SAnnotSelector* sel,
1153  const CFixedBlob_ids& value);
1154 
1155  bool IsLoadedBlobState(const TKeyBlob& blob_id);
1156  bool MarkLoadingBlobState(const TKeyBlob& blob_id);
1157  TInfoLockBlobState GetLoadLockBlobState(const TKeyBlob& blob_id);
1158  TInfoLockBlobState GetLoadedBlobState(const TKeyBlob& blob_id);
1159  // returns true if information can be stored into external cache
1160  bool SetLoadedBlobState(const TKeyBlob& blob_id, TBlobState state);
1161  void SetAndSaveBlobState(const TKeyBlob& blob_id, TBlobState state);
1162 
1163  bool IsLoadedBlobVersion(const TKeyBlob& blob_id);
1164  bool MarkLoadingBlobVersion(const TKeyBlob& blob_id);
1165  TInfoLockBlobVersion GetLoadLockBlobVersion(const TKeyBlob& blob_id);
1166  TInfoLockBlobVersion GetLoadedBlobVersion(const TKeyBlob& blob_id);
1167  // returns true if information can be stored into external cache
1168  bool SetLoadedBlobVersion(const TKeyBlob& blob_id, TBlobVersion version);
1169  void SetAndSaveBlobVersion(const TKeyBlob& blob_id, TBlobVersion version);
1170 
1171  /*
1172  void SetSeq_entry(const TKeyBlob& blob_id,
1173  CLoadLockBlob& blob,
1174  TChunkId chunk_id,
1175  CRef<CSeq_entry> entry,
1176  CTSE_SetObjectInfo* set_info = 0);
1177  */
1178 
1179  TInfoLockBlob GetLoadLockBlob(const TKeyBlob& blob_id);
1180  TInfoLockBlob GetLoadedBlob(const TKeyBlob& blob_id);
1181  // end of new lock manager support
1182  //////////////////////////////////////////////////////////////////
1183 
1184  virtual CGBDataLoader* GetLoaderPtr(void);
1185 
1186  static TKeyBlob_ids s_KeyBlobIds(const CSeq_id_Handle& id,
1187  const SAnnotSelector* sel);
1188 
1189  CTSE_LoadLock GetBlobLoadLock(const TKeyBlob& blob_id);
1190 
1191  virtual CTSE_LoadLock GetTSE_LoadLock(const TKeyBlob& blob_id) = 0;
1192  virtual CTSE_LoadLock GetTSE_LoadLockIfLoaded(const TKeyBlob& blob_id) = 0;
1193 
1194  typedef vector<CBlob_id> TLoadedBlob_ids;
1195  virtual void GetLoadedBlob_ids(const CSeq_id_Handle& idh,
1196  TLoadedBlob_ids& blob_ids) const;
1197 
1198  bool SetNoBlob(const TKeyBlob& blob_id, TBlobState blob_state);
1199  void ReleaseNotLoadedBlobs(void);
1200 
1203  void SaveLocksTo(TTSE_LockSet& locks);
1204 
1205  void ReleaseLocks(void);
1206 
1207  virtual operator CInitMutexPool&(void) = 0;
1208 
1209  typedef int TConn;
1210 
1211  TLevel GetLevel() const { return m_Level; }
1212  void SetLevel(TLevel level) { m_Level = level; }
1213 
1214  const CSeq_id_Handle& GetRequestedId(void) const { return m_RequestedId; }
1215  void SetRequestedId(const CSeq_id_Handle& requested_id);
1216 
1217  void ClearRetryDelay(void) { m_RetryDelay = 0; }
1218  void AddRetryDelay(double delay) { m_RetryDelay += delay; }
1219  double GetRetryDelay(void) const { return m_RetryDelay; }
1220 
1221  // expiration support
1222  TExpirationTime GetStartTime(void) const { return m_StartTime; }
1223  TExpirationTime GetNewIdExpirationTime(GBL::EExpirationType type) const;
1224  virtual TExpirationTime GetIdExpirationTimeout(GBL::EExpirationType type) const;
1225 
1226  virtual bool GetAddWGSMasterDescr(void) const;
1227 
1228  virtual EGBErrorAction GetPTISErrorAction(void) const;
1229 
1230  CWriter* GetIdWriter(void) const;
1231  CWriter* GetBlobWriter(void) const;
1232 
1233  bool IsInProcessor(void) const { return m_InProcessor > 0; }
1234 
1235 private:
1236  friend class CLoadLockBlob;
1237  friend class CLoadLockSetter;
1240 
1241  void x_AddTSE_LoadLock(const CTSE_LoadLock& lock);
1242 
1253 
1254 private: // hide methods
1255  void* operator new(size_t size);
1256  void* operator new[](size_t size);
1259 };
1260 
1261 
1263 {
1264 public:
1265  explicit
1267  bool in_processor = false);
1270  {
1271  return m_Result;
1272  }
1273  // return current recursion level
1274  int GetRecursionLevel(void) const
1275  {
1276  return m_Result.m_RecursionLevel;
1277  }
1278  // return current request processing time within recursion
1279  double GetCurrentRequestTime(void) const;
1280 private:
1282  double m_SaveTime;
1284 private: // to prevent copying
1287 };
1288 
1289 
1292 
1293 #endif//GBLOADER_REQUEST_RESULT__HPP_INCLUDED
User-defined methods of the data storage class.
ncbi::TMaskedQueryRegions mask
const TAnnotInfo & GetAnnotInfo(void) const
const TNamedAnnotNames & GetNamedAnnotNames(void) const
vector< CConstRef< CID2S_Seq_annot_Info > > TAnnotInfo
TNamedAnnotNames m_NamedAnnotNames
set< string > TNamedAnnotNames
TAnnotInfo m_AnnotInfo
const TContentsMask & GetContentsMask(void) const
const CConstRef< CBlob_Annot_Info > & GetAnnotInfo(void) const
CConstRef< CBlob_id > m_Blob_id
DECLARE_OPERATOR_BOOL_REF(m_Blob_id)
const CConstRef< CBlob_id > & GetBlob_id(void) const
TBlobContentsMask TContentsMask
bool IsSetAnnotInfo(void) const
TContentsMask m_Contents
CConstRef< CBlob_Annot_Info > m_AnnotInfo
TList::const_reference const_reference
TState GetState(void) const
size_t size(void) const
vector< CBlob_Info > TList
const_iterator end(void) const
bool empty(void) const
const_reference front(void) const
const TList & Get(void) const
const_iterator begin(void) const
bool IsFound(void) const
CObjectFor< TList > TObject
TList::const_iterator const_iterator
CConstRef< TObject > m_Ref
TState GetState(void) const
TList::const_iterator const_iterator
size_t size(void) const
bool IsFound(void) const
vector< CSeq_id_Handle > TList
const TList & Get(void) const
const_iterator begin(void) const
CObjectFor< TList > TObject
bool empty(void) const
const_reference front(void) const
TList::const_reference const_reference
CConstRef< TObject > m_Ref
const_iterator end(void) const
TCacheBlobState m_CacheBlobState
TCacheType m_CacheType
GBL::CInfoCache< CSeq_id_Handle, TSequenceAcc > TCacheAcc
GBL::CInfoCache< CBlob_id, TBlobVersion > TCacheBlobVersion
TCacheTaxId m_CacheTaxId
TCacheLength m_CacheLength
GBL::CInfoCache< CBlob_id, TBlobState > TCacheBlobState
GBL::CInfoCache< CSeq_id_Handle, TSequenceGi > TCacheGi
CDataLoader::SAccVerFound TSequenceAcc
GBL::CInfoCache< CSeq_id_Handle, string > TCacheLabel
ncbi::TTaxId TTaxId
TCacheBlobIds m_CacheBlobIds
GBL::CInfoCache< CSeq_id_Handle, TTaxId > TCacheTaxId
GBL::CInfoCache< CSeq_id_Handle, TSequenceType > TCacheType
TCacheBlob m_CacheBlob
GBL::CInfoCache< CSeq_id_Handle, TSequenceHash > TCacheHash
CDataLoader::SGiFound TSequenceGi
TCacheSeqIds m_CacheSeqIds
GBL::CInfoCache< CSeq_id_Handle, CFixedSeq_ids > TCacheSeqIds
TCacheHash m_CacheHash
CDataLoader::STypeFound TSequenceType
TCacheBlobVersion m_CacheBlobVersion
TCacheAcc m_CacheAcc
TCacheLabel m_CacheLabel
GBL::CInfoCache< TKeyBlobIds, CFixedBlob_ids > TCacheBlobIds
CDataLoader::SHashFound TSequenceHash
pair< CSeq_id_Handle, string > TKeyBlobIds
GBL::CInfoCache< CBlob_id, CTSE_LoadLock > TCacheBlob
GBL::CInfoCache< CSeq_id_Handle, TSequenceLength > TCacheLength
CID2S_Seq_annot_Info –.
CID2_Blob_Id –.
Definition: ID2_Blob_Id.hpp:66
CInfoManager & GetManager(void) const
Definition: info_cache.hpp:259
CGBInfoManager::TCacheAcc::TInfoLock TParent
static bool IsFound(const TData &data)
TData GetAccVer(void) const
TExpirationTime GetExpirationTimeAcc(void) const
static const CSeq_id_Handle & GetAcc(const TData &data)
bool SetLoadedAccVer(const TData &data, TExpirationTime expiration_time)
bool IsFound(void) const
GBL::EExpirationType GetExpType(void) const
bool IsLoadedAccVer(void) const
bool SetLoadedAccVer(const TData &data)
static GBL::EExpirationType GetExpType(const TData &data)
static GBL::EExpirationType GetExpType(const TData &data)
bool SetLoadedBlob_ids(const TData &data)
bool SetLoadedBlob_ids(const CLoadLockBlobIds &ids)
static bool IsFound(const TData &data)
bool SetNoBlob_ids(const CFixedBlob_ids::TState &state, TExpirationTime expiration_time)
bool IsFound(void) const
TData GetBlob_ids(void) const
CGBInfoManager::TCacheBlobIds::TInfoLock TParent
bool SetNoBlob_ids(const CFixedBlob_ids::TState &state)
GBL::EExpirationType GetExpType(void) const
TData::TState GetState(void) const
CSeq_id_Handle m_Seq_id
bool SetLoadedBlob_ids(const TData &data, TExpirationTime expiration_time)
bool IsFound(void) const
CGBInfoManager::TCacheBlobState::TInfoLock TParent
static bool IsFound(const TData &data)
static GBL::EExpirationType GetExpType(const TData &data)
GBL::EExpirationType GetExpType(void) const
TData GetBlobState(void) const
bool IsLoadedBlobState(void) const
bool IsFound(void) const
bool IsLoadedBlobVersion(void) const
CGBInfoManager::TCacheBlobVersion::TInfoLock TParent
TData GetBlobVersion(void) const
GBL::EExpirationType GetExpType(void) const
static GBL::EExpirationType GetExpType(const TData &data)
static bool IsFound(const TData &data)
CConstRef< CTSE_Chunk_Info > m_Chunk
void SetLoaded(void)
CGBInfoManager::TBlobVersion TBlobVersion
CGBInfoManager::TCacheBlob::TInfoLock TParent
void IsLoaded(void)
CTSE_LoadLock m_TSE_LoadLock
const CTSE_Chunk_Info & GetTSE_Chunk_Info(void)
bool IsLoadedBlob(void) const
CGBInfoManager::TChunkId TChunkId
bool SetLoadedGi(const TData &data)
bool IsLoadedGi(void) const
TData GetGi(void) const
bool IsFound(void) const
static bool IsFound(const TData &data)
TExpirationTime GetExpirationTimeGi(void) const
bool SetLoadedGi(const TData &data, TExpirationTime expiration_time)
CGBInfoManager::TCacheGi::TInfoLock TParent
static TGi GetGi(const TData &data)
GBL::EExpirationType GetExpType(void) const
static GBL::EExpirationType GetExpType(const TData &data)
bool IsFound(void) const
bool SetLoadedHash(const TData &data, TExpirationTime expiration_time)
bool SetLoadedHash(const TData &data)
static GBL::EExpirationType GetExpType(const TData &data)
bool IsLoadedHash(void) const
static int GetHash(const TData &data)
TData GetHash(void) const
CGBInfoManager::TCacheHash::TInfoLock TParent
GBL::EExpirationType GetExpType(void) const
static bool IsFound(const TData &data)
static GBL::EExpirationType GetExpType(const TData &data)
static bool IsFound(const TData &data)
CGBInfoManager::TCacheLabel::TInfoLock TParent
GBL::EExpirationType GetExpType(void) const
bool IsLoadedLabel(void) const
bool SetLoadedLabel(const TData &data, TExpirationTime expiration_time)
bool SetLoadedLabel(const TData &data)
bool IsFound(void) const
TData GetLabel(void) const
CGBInfoManager::TCacheLength::TInfoLock TParent
TData GetLength(void) const
GBL::EExpirationType GetExpType(void) const
bool IsLoadedLength(void) const
static bool IsFound(const TData &data)
bool SetLoadedLength(const TData &data, TExpirationTime expiration_time)
bool SetLoadedLength(const TData &data)
static GBL::EExpirationType GetExpType(const TData &data)
bool IsFound(void) const
CGBInfoManager::TCacheSeqIds::TInfoLock TParent
bool SetLoadedSeq_ids(const CLoadLockSeqIds &ids)
TData GetSeq_ids(void) const
static bool IsFound(const TData &data)
bool SetLoadedSeq_ids(const TData &data)
bool IsFound(void) const
static GBL::EExpirationType GetExpType(const TData &data)
TData::TState GetState(void) const
GBL::EExpirationType GetExpType(void) const
bool SetLoadedSeq_ids(const TData &data, TExpirationTime expiration_time)
void x_ObtainTSE_LoadLock(CReaderRequestResult &result, const CBlob_id &blob_id)
AutoPtr< CInitGuard > m_ChunkLoadLock
CTSE_LoadLock m_TSE_LoadLock
CTSE_Chunk_Info & GetTSE_Chunk_Info(void)
CGBInfoManager::TBlobState TBlobState
CRef< CTSE_Chunk_Info > m_Chunk
CGBInfoManager::TChunkId TChunkId
CGBInfoManager::TBlobVersion TBlobVersion
CTSE_LoadLock & GetTSE_LoadLock(void)
CGBInfoManager::TCacheBlob::TInfoLock TParent
GBL::EExpirationType GetExpType(void) const
bool IsLoadedTaxId(void) const
CGBInfoManager::TCacheTaxId::TInfoLock TParent
bool SetLoadedTaxId(const TData &data)
TData GetTaxId(void) const
bool IsFound(void) const
static GBL::EExpirationType GetExpType(const TData &data)
bool SetLoadedTaxId(const TData &data, TExpirationTime expiration_time)
static bool IsFound(const TData &data)
bool SetLoadedType(const TData &data)
TData GetType(void) const
CGBInfoManager::TCacheType::TInfoLock TParent
static bool IsFound(const TData &data)
bool IsFound(void) const
static CSeq_inst::TMol GetType(const TData &data)
bool IsLoadedType(void) const
static GBL::EExpirationType GetExpType(const TData &data)
GBL::EExpirationType GetExpType(void) const
bool SetLoadedType(const TData &data, TExpirationTime expiration_time)
CObjectFor –.
Definition: ncbiobj.hpp:2335
CObject –.
Definition: ncbiobj.hpp:180
CReaderRequestResult & m_Result
double GetCurrentRequestTime(void) const
CReaderRequestResult & GetResult(void) const
void operator=(const CReaderRequestResultRecursion &)
CReaderRequestResultRecursion(const CReaderRequestResultRecursion &)
CReaderRequestResultRecursion(CReaderRequestResult &result, bool in_processor=false)
CGBInfoManager::TSequenceAcc TSequenceAcc
CGBInfoManager::TCacheGi::TInfoLock TInfoLockGi
bool MarkLoadingBlobVersion(const TKeyBlob &blob_id)
CGBInfoManager::TCacheBlobIds::TInfoLock TInfoLockBlobIds
CSeq_id_Handle TKeySeq_ids2
bool IsInProcessor(void) const
TExpirationTime m_StartTime
CGBInfoManager::TSequenceLength TSequenceLength
CGBInfoManager::TCacheLength::TInfoLock TInfoLockLength
CReadDispatcher & m_ReadDispatcher
CGBInfoManager::TTaxId TTaxId
CGBInfoManager & GetGBInfoManager(void)
CSeq_id_Handle m_RequestedId
CGBInfoManager::TCacheBlobState::TInfoLock TInfoLockBlobState
CGBInfoManager::TBlobState TBlobState
void AddRetryDelay(double delay)
CGBInfoManager::TCacheLabel::TInfoLock TInfoLockLabel
set< TTSE_Lock > TTSE_LockSet
CReaderRequestResult(const CReaderRequestResult &)
virtual CTSE_LoadLock GetTSE_LoadLock(const TKeyBlob &blob_id)=0
CGBInfoManager::TBlobVersion TBlobVersion
CGBInfoManager::TCacheSeqIds::TInfoLock TInfoLockIds
CGBInfoManager::TCacheType::TInfoLock TInfoLockType
CReaderAllocatedConnection * m_AllocatedConnection
vector< CBlob_id > TLoadedBlob_ids
CGBInfoManager::TCacheHash::TInfoLock TInfoLockHash
CGBInfoManager::TCacheTaxId::TInfoLock TInfoLockTaxId
double GetRetryDelay(void) const
CGBInfoManager::TCacheAcc::TInfoLock TInfoLockAcc
CGBInfoManager::TCacheBlobVersion::TInfoLock TInfoLockBlobVersion
CGBInfoManager::TSequenceHash TSequenceHash
bool MarkLoadingBlobState(const TKeyBlob &blob_id)
virtual CTSE_LoadLock GetTSE_LoadLockIfLoaded(const TKeyBlob &blob_id)=0
CGBInfoManager::TCacheBlob::TInfoLock TInfoLockBlob
TExpirationTime GetStartTime(void) const
GBL::CInfo_Base::TExpirationTime TExpirationTime
pair< CSeq_id_Handle, string > TKeyBlob_ids
const CSeq_id_Handle & GetRequestedId(void) const
CGBInfoManager::TSequenceGi TSequenceGi
void SetLevel(TLevel level)
CGBInfoManager::TSequenceType TSequenceType
CReaderRequestResult & operator=(const CReaderRequestResult &)
CRef –.
Definition: ncbiobj.hpp:618
Definition: Seq_entry.hpp:56
CStopWatch –.
Definition: ncbitime.hpp:1938
char data[12]
Definition: iconv.c:80
unsigned int TSeqPos
Type for sequence locations and lengths.
Definition: ncbimisc.hpp:875
#define INVALID_TAX_ID
Definition: ncbimisc.hpp:1116
SStrictId_Tax::TId TTaxId
Taxon id type.
Definition: ncbimisc.hpp:1048
const TSeqPos kInvalidSeqPos
Define special value for invalid sequence position.
Definition: ncbimisc.hpp:878
TGi FindGi(const container &ids)
Return gi from id list if exists, return 0 otherwise.
Definition: Seq_id.hpp:1041
#define END_NCBI_SCOPE
End previously defined NCBI scope.
Definition: ncbistl.hpp:103
#define END_SCOPE(ns)
End the previously defined scope.
Definition: ncbistl.hpp:75
#define BEGIN_NCBI_SCOPE
Define ncbi namespace.
Definition: ncbistl.hpp:100
#define BEGIN_SCOPE(ns)
Define a new scope.
Definition: ncbistl.hpp:72
ENcbiOwnership
Ownership relations between objects.
Definition: ncbi_types.h:134
#define NCBI_XREADER_EXPORT
Definition: ncbi_export.h:1371
EMol
molecule class in living organism
Definition: Seq_inst_.hpp:108
EExpirationType
Definition: info_cache.hpp:78
@ eExpire_fast
Definition: info_cache.hpp:80
@ eExpire_normal
Definition: info_cache.hpp:79
static MDB_envinfo info
Definition: mdb_load.c:37
static int version
Definition: mdb_load.c:29
const TYPE & Get(const CNamedParameterList *param)
SNetStorageObjectState< SNetStorageObjectDirectState< TBase > > TState
Definition: state.hpp:107
constexpr bool empty(list< Ts... >) noexcept
const struct ncbi::grid::netcache::search::fields::SIZE size
const GenericPointer< typename T::ValueType > T2 value
Definition: pointer.h:1227
Multi-threading – mutexes; rw-locks; semaphore.
Portable reference counted smart and weak pointers using CWeakRef, CRef, CObject and CObjectEx.
Defines: CTimeFormat - storage class for time format.
void Filter(TTimeline &timeline, TServers &servers)
int TBlobContentsMask
Definition: blob_id.hpp:202
EGBErrorAction
Definition: blob_id.hpp:205
int TChunkId
Definition: blob_id.hpp:145
@ kMain_ChunkId
Definition: blob_id.hpp:147
EAlreadyLoaded
@ eAlreadyLoaded
Better replacement of GetAccVer(), this method should be defined in data loaders, GetAccVer() is left...
Better replacement of GetGi(), this method should be defined in data loaders, GetGi() is left for com...
Better replacement of GetSequenceHash(), this method should be defined in data loaders,...
Better replacement of GetSequenceType(), this method should be defined in data loaders,...
SAnnotSelector –.
Definition: type.c:6
else result
Definition: token2.c:20
Modified on Sun Apr 21 03:40:17 2024 by modify_doxy.py rev. 669887