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

Go to the SVN repository for this file.

1 #ifndef SEQ_ENTRY_HANDLE__HPP
2 #define SEQ_ENTRY_HANDLE__HPP
3 
4 /* $Id: seq_entry_handle.hpp 87148 2019-07-30 16:13:15Z 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: Aleksey Grichenko, Eugene Vasilchenko
30 *
31 * File Description:
32 * Handle to Seq-entry object
33 *
34 */
35 
36 #include <corelib/ncbiobj.hpp>
37 
40 
41 #include <objmgr/tse_handle.hpp>
42 
45 
46 
47 /** @addtogroup ObjectManagerHandles
48  *
49  * @{
50  */
51 
52 
53 class CScope;
54 
55 class CSeq_entry_Handle;
56 class CBioseq_set_Handle;
57 class CBioseq_Handle;
58 class CSeq_annot_Handle;
61 class CBioseq_EditHandle;
63 
64 class CSeq_entry_Info;
65 class CSeq_annot_Info;
66 class CBioseq_set_Info;
67 class CBioseq_Info;
68 
69 class CTSE_Info;
70 
71 class CSeqdesc;
72 class CBioObjectId;
73 class CSeq_submit;
74 class CSubmit_block;
75 
76 
78 {
79 public:
81 
83  : CScopeInfo_Base(tse, reinterpret_cast<const CTSE_Info_Object&>(info))
84  {
85  }
86 
87  const TObjectInfo& GetObjectInfo(void) const
88  {
89  return reinterpret_cast<const TObjectInfo&>(GetObjectInfo_Base());
90  }
92  {
93  return const_cast<TObjectInfo&>(GetObjectInfo());
94  }
95 };
96 
97 
98 
99 /////////////////////////////////////////////////////////////////////////////
100 ///
101 /// CSeq_entry_Handle --
102 ///
103 /// Proxy to access seq-entry objects
104 ///
105 
107 {
108 public:
109  // default constructor
110  CSeq_entry_Handle(void);
111  CSeq_entry_Handle(const CTSE_Handle& tse);
112 
113  /// Get scope this handle belongs to
114  CScope& GetScope(void) const;
115 
116  /// Get unique object id
117  const CBioObjectId& GetBioObjectId(void) const;
118 
119  // Navigate object tree
120  /// Check if current seq-entry has a parent
121  bool HasParentEntry(void) const;
122 
123  /// Get parent bioseq-set handle
124  CBioseq_set_Handle GetParentBioseq_set(void) const;
125 
126  /// Get parent Seq-entry handle
127  CSeq_entry_Handle GetParentEntry(void) const;
128 
129  /// Get handle of the sub seq-entry
130  /// If current seq-entry is not seq-set or
131  /// has more than one subentry exception is thrown
132  CSeq_entry_Handle GetSingleSubEntry(void) const;
133 
134  /// Check if this handle is top-level entry
135  bool IsTopLevelEntry(void) const;
136 
137  /// Get top level Seq-entry handle
138  CSeq_entry_Handle GetTopLevelEntry(void) const;
139 
140  /// Seq-submit access functions
141  bool IsTopLevelSeq_submit(void) const;
142  const CSeq_submit& GetTopLevelSeq_submit(void) const;
143  const CSubmit_block& GetTopLevelSubmit_block(void) const;
144 
145  /// Get Bioseq handle from the TSE of this Seq-entry
146  CBioseq_Handle GetBioseqHandle(const CSeq_id& id) const;
147  CBioseq_Handle GetBioseqHandle(const CSeq_id_Handle& id) const;
148 
149  /// Get 'edit' version of handle
150  CSeq_entry_EditHandle GetEditHandle(void) const;
151 
152  /// Complete and get const reference to the seq-entry
153  CConstRef<CSeq_entry> GetCompleteSeq_entry(void) const;
154 
155  /// Get const reference to the seq-entry
156  CConstRef<CSeq_entry> GetSeq_entryCore(void) const;
157 
158  /// Unified interface for templates
160  CConstRef<TObject> GetCompleteObject(void) const;
161  CConstRef<TObject> GetObjectCore(void) const;
162 
163  // Seq-entry accessors
165  E_Choice Which(void) const;
166 
167  // Bioseq access
168  bool IsSeq(void) const;
170  TSeq GetSeq(void) const;
171 
172  // Bioseq_set access
173  bool IsSet(void) const;
175  TSet GetSet(void) const;
176 
177  // descr field is in both Bioseq and Bioseq-set
178  bool IsSetDescr(void) const;
180  const TDescr& GetDescr(void) const;
181 
183 
185  typedef int TBlobVersion;
186  TBlobId GetBlobId(void) const;
187  TBlobVersion GetBlobVersion(void) const;
188 
189  // Utility methods/operators
190 
191  DECLARE_OPERATOR_BOOL(m_Info.IsValid());
192 
193  bool IsRemoved(void) const;
194 
195 
196  // Get CTSE_Handle of containing TSE
197  const CTSE_Handle& GetTSE_Handle(void) const;
198 
199 
200  /// Reset handle and make it not to point to any seq-entry
201  void Reset(void);
202 
203  /// Reset handle and make it not to point to any seq-entry
204  void Swap(CSeq_entry_Handle& h);
205 
206  /// Check if handles point to the same seq-entry
207  ///
208  /// @sa
209  /// operator!=()
210  bool operator ==(const CSeq_entry_Handle& handle) const;
211 
212  // Check if handles point to different seq-entry
213  ///
214  /// @sa
215  /// operator==()
216  bool operator !=(const CSeq_entry_Handle& handle) const;
217 
218  /// For usage in containers
219  bool operator <(const CSeq_entry_Handle& handle) const;
220 
221 protected:
222  friend class CScope_Impl;
223  friend class CBioseq_Handle;
224  friend class CBioseq_set_Handle;
225  friend class CSeq_annot_Handle;
226  friend class CTSE_Handle;
227  friend class CSeqMap_CI;
228  friend class CSeq_entry_CI;
229 
232 
234 
235  CScope_Impl& x_GetScopeImpl(void) const;
236 
238 
239 public: // non-public section
240 
241  const TScopeInfo& x_GetScopeInfo(void) const;
242  const CSeq_entry_Info& x_GetInfo(void) const;
243 };
244 
245 
246 /////////////////////////////////////////////////////////////////////////////
247 ///
248 /// CSeq_entry_Handle --
249 ///
250 /// Proxy to access seq-entry objects
251 ///
252 
254 {
255 public:
256  // Default constructor
257  CSeq_entry_EditHandle(void);
258  /// create edit interface class to the object which already allows editing
259  /// throw an exception if the argument is not in editing mode
260  explicit CSeq_entry_EditHandle(const CSeq_entry_Handle& h);
261 
262  // Navigate object tree
263 
264  /// Get parent bioseq-set edit handle
265  CBioseq_set_EditHandle GetParentBioseq_set(void) const;
266 
267  /// Get parent seq-entry edit handle
268  CSeq_entry_EditHandle GetParentEntry(void) const;
269 
270  /// Seq-submit support
271  CSubmit_block& SetTopLevelSubmit_block(void) const;
272  void SetTopLevelSubmit_block(CSubmit_block& sub) const;
273 
274  /// Get edit handle of the sub seq-entry
275  /// If current seq-entry is not seq-set or
276  /// has more than one subentry exception is thrown
277  CSeq_entry_EditHandle GetSingleSubEntry(void) const;
278 
279  // Change descriptions
280  void SetDescr(TDescr& v) const;
281  TDescr& SetDescr(void) const;
282  void ResetDescr(void) const;
283  bool AddSeqdesc(CSeqdesc& v) const;
284  CRef<CSeqdesc> RemoveSeqdesc(const CSeqdesc& v) const;
285  CRef<CSeqdesc> ReplaceSeqdesc(const CSeqdesc& old_desc, CSeqdesc& new_desc) const;
286 
287  void AddDescr(TDescr& v) const;
288 
291 
292  TSet SetSet(void) const;
293  TSeq SetSeq(void) const;
294 
295  /// Make this Seq-entry to be empty.
296  /// Old contents of the entry will be deleted.
297  void SelectNone(void) const;
298 
299  /// Convert the empty Seq-entry to Bioseq-set.
300  /// Returns new Bioseq-set handle.
301  TSet SelectSet(TClass set_class = CBioseq_set::eClass_not_set) const;
302 
303  /// Make the empty Seq-entry be in set state with given Bioseq-set object.
304  /// Returns new Bioseq-set handle.
305  TSet SelectSet(CBioseq_set& seqset) const;
306  TSet SelectSet(CRef<CBioseq_set_Info>) const;
307 
308  /// Make the empty Seq-entry be in set state with given Bioseq-set object.
309  /// Returns new Bioseq-set handle.
310  TSet CopySet(const CBioseq_set_Handle& seqset) const;
311 
312  /// Make the empty Seq-entry be in set state with moving Bioseq-set object
313  /// from the argument seqset.
314  /// Returns new Bioseq-set handle which could be different
315  /// from the argument is the argument is from another scope.
316  TSet TakeSet(const TSet& seqset) const;
317 
318  /// Make the empty Seq-entry be in set state with Bioseq-set object
319  /// from the argument seqset.
320  /// The seqset argument must point to removed Bioseq-set.
321  /// Returns new Bioseq-set handle which could be different
322  /// from the argument is the argument is from another scope.
323  TSet SelectSet(const TSet& seqset) const;
324 
325  /// Make the empty Seq-entry be in seq state with specified Bioseq object.
326  /// Returns new Bioseq handle.
327  TSeq SelectSeq(CBioseq& seq) const;
328  TSeq SelectSeq(CRef<CBioseq_Info> seq) const;
329 
330  /// Make the empty Seq-entry be in seq state with specified Bioseq object.
331  /// Returns new Bioseq handle.
332  TSeq CopySeq(const CBioseq_Handle& seq) const;
333 
334  /// Make the empty Seq-entry be in seq state with moving bioseq object
335  /// from the argument seq.
336  /// Returns Bioseq handle which could be different from the argument
337  /// is the argument is from another scope.
338  TSeq TakeSeq(const TSeq& seq) const;
339 
340  /// Make the empty Seq-entry be in seq state with Bioseq object
341  /// from the argument seqset.
342  /// The seq argument must point to removed Bioseq.
343  /// Returns Bioseq handle which could be different
344  /// from the argument is the argument is from another scope.
345  TSeq SelectSeq(const TSeq& seq) const;
346 
347  /// Convert the entry from Bioseq to Bioseq-set.
348  /// Old Bioseq will become the only entry of new Bioseq-set.
349  /// New Bioseq-set will have the specified class.
350  /// If the set_class argument is omitted,
351  /// or equals to CBioseq_set::eClass_not_set,
352  /// the class field of new Bioseq-set object will not be initialized.
353  /// Returns new Bioseq-set handle.
354  TSet ConvertSeqToSet(TClass set_class = CBioseq_set::eClass_not_set) const;
355 
356  /// Collapse one level of Bioseq-set.
357  /// The Bioseq-set should originally contain only one sub-entry.
358  /// Current Seq-entry will become the same type as sub-entry.
359  /// All Seq-annot and Seq-descr objects from old Bioseq-set
360  /// will be moved to new contents (sub-entry).
361  void CollapseSet(void) const;
362 
363  /// Do the same as CollapseSet() when sub-entry is of type bioseq.
364  /// Throws an exception in other cases.
365  /// Returns resulting Bioseq handle.
366  TSeq ConvertSetToSeq(void) const;
367 
368  // Attach new Seq-annot to Bioseq or Bioseq-set
369 
370  /// Attach an annotation
371  ///
372  /// @param annot
373  /// Reference to this annotation will be attached
374  ///
375  /// @return
376  /// Edit handle to the attached annotation
377  ///
378  /// @sa
379  /// CopyAnnot()
380  /// TakeAnnot()
381  CSeq_annot_EditHandle AttachAnnot(CSeq_annot& annot) const;
382  CSeq_annot_EditHandle AttachAnnot(CRef<CSeq_annot_Info> annot) const;
383 
384  /// Attach a copy of the annotation
385  ///
386  /// @param annot
387  /// Copy of the annotation pointed by this handle will be attached
388  ///
389  /// @return
390  /// Edit handle to the attached annotation
391  ///
392  /// @sa
393  /// AttachAnnot()
394  /// TakeAnnot()
395  CSeq_annot_EditHandle CopyAnnot(const CSeq_annot_Handle& annot) const;
396 
397  /// Remove the annotation from its location and attach to current one
398  ///
399  /// @param annot
400  /// An annotation pointed by this handle will be removed and attached.
401  ///
402  /// @return
403  /// Edit handle to the attached annotation
404  ///
405  /// @sa
406  /// AttachAnnot()
407  /// CopyAnnot()
408  /// TakeAllAnnots()
409  CSeq_annot_EditHandle TakeAnnot(const CSeq_annot_EditHandle& annot) const;
410 
411  /// Attach an annotation
412  ///
413  /// @param annot
414  /// Reference to this annotation will be attached,
415  /// the annot must be removed.
416  ///
417  /// @return
418  /// Edit handle to the attached annotation
419  ///
420  /// @sa
421  /// CopyAnnot()
422  /// TakeAnnot()
423  CSeq_annot_EditHandle AttachAnnot(const CSeq_annot_EditHandle& annot) const;
424 
425  /// Remove all the annotation from seq-entry and attach to current one
426  ///
427  /// @param src_entry
428  /// A seq-entry hanlde where annotations will be taken
429  ///
430  /// @sa
431  /// TakeAnnot()
432  void TakeAllAnnots(const CSeq_entry_EditHandle& src_entry) const;
433 
434  /// Remove all the descritions from seq-entry and attach to current one
435  ///
436  /// @param src_entry
437  /// A seq-entry hanlde where annotations will be taken
438  ///
439  void TakeAllDescr(const CSeq_entry_EditHandle& src_entry) const;
440 
441  // Attach new sub objects to Bioseq-set
442  // index < 0 or index >= current number of entries
443  // means to add at the end.
444 
445  /// Attach an existing bioseq
446  ///
447  /// @param seq
448  /// Reference to this bioseq will be attached
449  /// @param index
450  /// Start index is 0 and -1 means end
451  ///
452  /// @return
453  /// Edit handle to the attached bioseq
454  ///
455  /// @sa
456  /// CopyBioseq()
457  /// TakeBioseq()
458  CBioseq_EditHandle AttachBioseq(CBioseq& seq,
459  int index = -1) const;
460 
461  /// Attach a copy of the existing bioseq
462  ///
463  /// @param seq
464  /// Copy of this bioseq will be attached
465  /// @param index
466  /// Start index is 0 and -1 means end
467  ///
468  /// @return
469  /// Edit handle to the attached bioseq
470  ///
471  /// @sa
472  /// AttachBioseq()
473  /// TakeBioseq()
474  CBioseq_EditHandle CopyBioseq(const CBioseq_Handle& seq,
475  int index = -1) const;
476 
477  /// Remove bioseq from its location and attach to current one
478  ///
479  /// @param seq
480  /// bioseq pointed by this handle will be removed and attached
481  /// @param index
482  /// Start index is 0 and -1 means end
483  ///
484  /// @return
485  /// Edit handle to the attached bioseq
486  ///
487  /// @sa
488  /// AttachBioseq()
489  /// CopyBioseq()
490  CBioseq_EditHandle TakeBioseq(const CBioseq_EditHandle& seq,
491  int index = -1) const;
492 
493  /// Attach an existing seq-entry
494  ///
495  /// @param entry
496  /// Reference to this seq-entry will be attached
497  /// @param index
498  /// Start index is 0 and -1 means end
499  ///
500  /// @return
501  /// Edit handle to the attached seq-entry
502  ///
503  /// @sa
504  /// AddNewEntry()
505  /// CopyEntry()
506  /// TakeEntry()
507  CSeq_entry_EditHandle AttachEntry(CSeq_entry& entry,
508  int index = -1) const;
509 
510  /// Attach a copy of the existing seq-entry
511  ///
512  /// @param entry
513  /// Copy of this seq-entry will be attached
514  /// @param index
515  /// Start index is 0 and -1 means end
516  ///
517  /// @return
518  /// Edit handle to the attached seq-entry
519  ///
520  /// @sa
521  /// AddNewEntry()
522  /// AttachEntry()
523  /// TakeEntry()
524  CSeq_entry_EditHandle CopyEntry(const CSeq_entry_Handle& entry,
525  int index = -1) const;
526 
527  /// Remove seq-entry from its location and attach to current one
528  ///
529  /// @param entry
530  /// seq-entry pointed by this handle will be removed and attached
531  /// @param index
532  /// Start index is 0 and -1 means end
533  ///
534  /// @return
535  /// Edit handle to the attached seq-entry
536  ///
537  /// @sa
538  /// AddNewEntry()
539  /// AttachEntry()
540  /// CopyEntry()
541  CSeq_entry_EditHandle TakeEntry(const CSeq_entry_EditHandle& entry,
542  int index = -1) const;
543 
544  /// Add removed seq-entry
545  ///
546  /// @param entry
547  /// seq-entry pointed by this handle will be removed and attached
548  /// @param index
549  /// Start index is 0 and -1 means end
550  ///
551  /// @return
552  /// Edit handle to the attached seq-entry
553  ///
554  /// @sa
555  /// AddNewEntry()
556  /// AttachEntry()
557  /// CopyEntry()
558  CSeq_entry_EditHandle AttachEntry(const CSeq_entry_EditHandle& entry,
559  int index = -1) const;
560 
561  /// Remove this Seq-entry from parent,
562  /// or scope if it's top level Seq-entry.
563  void Remove(void) const;
564 
565  /// Update annotation index after manual modification of the object
566  void UpdateAnnotations(void) const;
567 
568 protected:
569  friend class CScope_Impl;
570  friend class CBioseq_EditHandle;
572  friend class CSeq_annot_EditHandle;
573  friend class CSeq_entry_I;
574 
576 
577 public: // non-public section
578  TScopeInfo& x_GetScopeInfo(void) const;
579  CSeq_entry_Info& x_GetInfo(void) const;
580 
581 public:
582  void x_RealSetDescr(TDescr& v) const;
583  void x_RealResetDescr(void) const;
584  bool x_RealAddSeqdesc(CSeqdesc& v) const;
585  CRef<CSeqdesc> x_RealRemoveSeqdesc(const CSeqdesc& v) const;
586  CRef<CSeqdesc> x_RealReplaceSeqdesc(const CSeqdesc& old_desc, CSeqdesc& new_desc) const;
587  void x_RealAddSeq_descr(TDescr& v) const;
588 
589 };
590 
591 
592 /////////////////////////////////////////////////////////////////////////////
593 // CSeq_entry_Handle inline methods
594 /////////////////////////////////////////////////////////////////////////////
595 
596 
597 inline
599 {
600 }
601 
602 
603 inline
605 {
606  return m_Info->GetTSE_Handle();
607 }
608 
609 
610 inline
612 {
613  return GetTSE_Handle().GetScope();
614 }
615 
616 
617 inline
619 {
620  return GetTSE_Handle().x_GetScopeImpl();
621 }
622 
623 
624 inline
626 {
627  return *m_Info;
628 }
629 
630 
631 inline
633 {
634  return GetCompleteSeq_entry();
635 }
636 
637 
638 inline
640 {
641  return GetSeq_entryCore();
642 }
643 
644 
645 inline
647 {
648  return m_Info.IsRemoved();
649 }
650 
651 
652 inline
654 {
655  return m_Info == handle.m_Info;
656 }
657 
658 
659 inline
661 {
662  return m_Info != handle.m_Info;
663 }
664 
665 
666 inline
668 {
669  return m_Info < handle.m_Info;
670 }
671 
672 
673 inline
674 bool CSeq_entry_Handle::IsSeq(void) const
675 {
676  return Which() == CSeq_entry::e_Seq;
677 }
678 
679 
680 inline
681 bool CSeq_entry_Handle::IsSet(void) const
682 {
683  return Which() == CSeq_entry::e_Set;
684 }
685 
686 
687 /////////////////////////////////////////////////////////////////////////////
688 // CSeq_entry_EditHandle
689 /////////////////////////////////////////////////////////////////////////////
690 
691 
692 inline
694 {
695 }
696 
697 
698 inline
700 {
701  return m_Info.GetNCObject();
702 }
703 
704 
705 /* @} */
706 
707 
710 
711 #endif //SEQ_ENTRY_HANDLE__HPP
bool operator!=(const _Ht_iterator< _Val, _Nonconst_traits< _Val >, _Key, _HF, _ExK, _EqK, _All > &__x, const _Ht_iterator< _Val, _Const_traits< _Val >, _Key, _HF, _ExK, _EqK, _All > &__y)
Definition: _hashtable.h:173
CBioseq_EditHandle –.
CBioseq_Handle –.
CBioseq_set_EditHandle –.
CBioseq_set_Handle –.
const CTSE_Handle & GetTSE_Handle(void) const
Definition: tse_handle.hpp:445
const CTSE_Info_Object & GetObjectInfo_Base(void) const
Definition: tse_handle.hpp:452
bool IsRemoved(void) const
Definition: tse_handle.hpp:633
TScopeInfo & GetNCObject(void) const
Definition: tse_handle.hpp:671
CScope –.
Definition: scope.hpp:92
Iterator over CSeqMap.
Definition: seq_map_ci.hpp:252
CSeq_annot_Handle –.
@Seq_descr.hpp User-defined methods of the data storage class.
Definition: Seq_descr.hpp:55
CSeq_entry_CI –.
CSeq_entry_Handle –.
CSeq_entry_Handle –.
CSeq_entry_I –.
Definition: Seq_entry.hpp:56
CSubmit_block –.
CScope_Impl & x_GetScopeImpl(void) const
Definition: tse_handle.hpp:332
CScope & GetScope(void) const
Returns scope.
Definition: tse_handle.hpp:325
bool operator<(const CEquivRange &A, const CEquivRange &B)
bool operator==(const CEquivRange &A, const CEquivRange &B)
bool operator<(const CSeq_entry_Handle &handle) const
For usage in containers.
TObjectInfo & GetNCObjectInfo(void)
CSeq_entry_Info TObjectInfo
TScopeInfo & x_GetScopeInfo(void) const
CBioseq_EditHandle TSeq
const TObjectInfo & GetObjectInfo(void) const
CSeq_entry TObject
Unified interface for templates.
CSeq_entry_ScopeInfo TScopeInfo
CBioseq_set::TClass TClass
E_Choice Which(void) const
bool operator==(const CSeq_entry_Handle &handle) const
Check if handles point to the same seq-entry.
bool IsRemoved(void) const
const CTSE_Handle & GetTSE_Handle(void) const
DECLARE_OPERATOR_BOOL(m_Info.IsValid())
CBioseq_set_Handle TSet
CScopeInfo_Ref< TScopeInfo > TLock
bool operator!=(const CSeq_entry_Handle &handle) const
CBioseq_set_EditHandle TSet
CSeq_entry_ScopeInfo(const CTSE_Handle &tse, const TObjectInfo &info)
CConstRef< CSeq_entry > GetCompleteSeq_entry(void) const
Complete and get const reference to the seq-entry.
CScope & GetScope(void) const
Get scope this handle belongs to.
const TScopeInfo & x_GetScopeInfo(void) const
bool IsSet(void) const
CSeq_entry::E_Choice E_Choice
CConstRef< TObject > GetObjectCore(void) const
CConstRef< TObject > GetCompleteObject(void) const
TSet SelectSet(const TSet &seqset) const
Make the empty Seq-entry be in set state with Bioseq-set object from the argument seqset.
CScope_Impl & x_GetScopeImpl(void) const
TSeq SelectSeq(const TSeq &seq) const
Make the empty Seq-entry be in seq state with Bioseq object from the argument seqset.
CConstRef< CSeq_entry > GetSeq_entryCore(void) const
Get const reference to the seq-entry.
bool IsSeq(void) const
#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
#define NCBI_XOBJMGR_EXPORT
Definition: ncbi_export.h:1307
E_Choice
Choice variants.
Definition: Seq_entry_.hpp:87
static MDB_envinfo info
Definition: mdb_load.c:37
void Swap(T &a, T &b) RAPIDJSON_NOEXCEPT
Custom swap() to avoid dependency on C++ <algorithm> header.
Definition: swap.h:33
Portable reference counted smart and weak pointers using CWeakRef, CRef, CObject and CObjectEx.
CScope & GetScope()
#define const
Definition: zconf.h:232
Modified on Wed Jun 19 17:02:09 2024 by modify_doxy.py rev. 669887