NCBI C++ ToolKit
buf_data_loader.cpp
Go to the documentation of this file.

Go to the SVN repository for this file.

1 /* $Id: buf_data_loader.cpp 99284 2023-03-06 16:28:57Z stakhovv $
2  * ===========================================================================
3  *
4  * PUBLIC DOMAIN NOTICE
5  * National Center for Biotechnology Information
6  *
7  * This software/database is a "United States Government Work" under the
8  * terms of the United States Copyright Act. It was written as part of
9  * the author's official duties as a United States Government employee and
10  * thus cannot be copyrighted. This software/database is freely available
11  * to the public for use. The National Library of Medicine and the U.S.
12  * Government have not placed any restriction on its use or reproduction.
13  *
14  * Although all reasonable efforts have been taken to ensure the accuracy
15  * and reliability of the software and data, the NLM and the U.S.
16  * Government do not and cannot warrant the performance or results that
17  * may be obtained by using this software or data. The NLM and the U.S.
18  * Government disclaim all warranties, express or implied, including
19  * warranties of performance, merchantability or fitness for any particular
20  * purpose.
21  *
22  * Please cite the author in any work or product based on this material.
23  *
24  * ===========================================================================
25  *
26  * File Name: buf_data_loader.cpp
27  *
28  * Author: Alexey Dobronadezhdin
29  *
30  * File Description:
31  * Data loader for buffer based flat file parsing.
32  *
33  */
34 
35 #include <ncbi_pch.hpp>
36 
37 #include "ftacpp.hpp"
38 
42 #include <objmgr/scope.hpp>
44 
45 #include "index.h"
46 #include "embl.h"
47 #include "sprot.h"
48 #include "genbank.h"
52 
53 #include "utilfun.h"
54 #include "ftaerr.hpp"
55 #include "ftablock.h"
56 #include "gb_ascii.h"
57 #include "asci_blk.h"
58 #include "buf_data_loader.h"
59 
60 #ifdef THIS_FILE
61 # undef THIS_FILE
62 #endif
63 #define THIS_FILE "buf_data_loader.cpp"
64 
67 
69  m_parser(parser)
70 {
71 }
72 
74 {
75  TTSE_LockSet locks;
76 
77  switch (choice) {
78  case eBlob:
79  case eBioseq:
80  case eCore:
81  case eBioseqCore:
82  case eSequence:
83  case eAll: {
84  TBlobId blob_id = GetBlobId(idh);
85  if (blob_id) {
86  locks.insert(GetBlobById(blob_id));
87  }
88  break;
89  }
90  default:
91  break;
92  }
93 
94  return locks;
95 }
96 
98 {
99  return true;
100 }
101 
103 {
104  TBlobId blob_id = new CBlobIdSeq_id(idh);
105  return blob_id;
106 }
107 
109 {
110  CTSE_LoadLock lock = GetDataSource()->GetTSE_LoadLock(blob_id);
111  if (! lock.IsLoaded()) {
112  const CBlobIdSeq_id& id = dynamic_cast<const CBlobIdSeq_id&>(*blob_id).GetValue();
113  x_LoadData(id.GetValue(), lock);
114 
115  // Mark TSE info as loaded
116  lock.SetLoaded();
117  }
118  return lock;
119 }
120 
121 static char* get_sequence_text(ParserPtr parser, const string& accession, int version)
122 {
123  char* ret = nullptr;
124  if (parser) {
125  if (! parser->accver) {
126  if (parser->ff_get_entry)
127  ret = (*parser->ff_get_entry)(accession.c_str());
128  else if (parser->ff_get_entry_pp)
129  ret = (*parser->ff_get_entry_pp)(accession.c_str(), parser);
130  } else {
131  if (parser->ff_get_entry_v)
132  ret = (*parser->ff_get_entry_v)(accession.c_str(), version);
133  else if (parser->ff_get_entry_v_pp)
134  ret = (*parser->ff_get_entry_v_pp)(accession.c_str(), version, parser);
135  }
136  }
137 
138  return ret;
139 }
140 
141 static bool get_accession_from_id(const CSeq_id& id, string& accession, int& version)
142 {
143  bool ret = false;
144  if (id.IsGenbank() || id.IsEmbl() || id.IsPir() || id.IsSwissprot() || id.IsDdbj() ||
145  id.IsTpg() || id.IsTpe() || id.IsTpd()) {
146 
147  const CTextseq_id* text_id = id.GetTextseq_Id();
148  if (text_id && text_id->IsSetAccession()) {
149 
150  version = text_id->IsSetVersion() ? text_id->GetVersion() : 0;
151  accession = text_id->GetAccession();
152  ret = true;
153  }
154  } else if (id.IsGeneral()) {
155  if (id.GetGeneral().IsSetDb() && id.GetGeneral().GetDb() == "GSDB" && id.GetGeneral().IsSetTag() && id.GetGeneral().GetTag().IsId()) {
156  accession = NStr::IntToString(id.GetGeneral().GetTag().GetId());
157  version = 0;
158  ret = true;
159  }
160  }
161 
162  return ret;
163 }
164 
165 static int add_entry(ParserPtr pp, const char* acc, Int2 vernum, DataBlkPtr entry)
166 {
167  int i = 0;
168  for (; i < pp->indx; i++) {
169  if (StringEqu(pp->entrylist[i]->acnum, acc) &&
170  (! pp->accver || pp->entrylist[i]->vernum == vernum))
171  break;
172  }
173 
174  if (i < pp->indx)
175  return i;
176 
177  pp->entrylist.resize(pp->indx + 1, nullptr);
178 
179  IndexblkPtr cur_block = new Indexblk;
180  StringCpy(cur_block->acnum, acc);
181  cur_block->vernum = vernum;
182  cur_block->ppp = pp;
183 
184  if (pp->format == Parser::EFormat::GenBank) {
185  char* q = entry->mOffset;
186  if (q && entry->len != 0 && StringEquN(q, "LOCUS ", 6)) {
187  char* p = StringChr(q, '\n');
188  if (p)
189  *p = '\0';
190  if (StringLen(q) > 78 && q[28] == ' ' && q[63] == ' ' &&
191  q[67] == ' ') {
192  cur_block->lc.bases = ParFlat_COL_BASES_NEW;
193  cur_block->lc.bp = ParFlat_COL_BP_NEW;
194  cur_block->lc.strand = ParFlat_COL_STRAND_NEW;
195  cur_block->lc.molecule = ParFlat_COL_MOLECULE_NEW;
196  cur_block->lc.topology = ParFlat_COL_TOPOLOGY_NEW;
197  cur_block->lc.div = ParFlat_COL_DIV_NEW;
198  cur_block->lc.date = ParFlat_COL_DATE_NEW;
199  } else {
200  cur_block->lc.bases = ParFlat_COL_BASES;
201  cur_block->lc.bp = ParFlat_COL_BP;
202  cur_block->lc.strand = ParFlat_COL_STRAND;
203  cur_block->lc.molecule = ParFlat_COL_MOLECULE;
204  cur_block->lc.topology = ParFlat_COL_TOPOLOGY;
205  cur_block->lc.div = ParFlat_COL_DIV;
206  cur_block->lc.date = ParFlat_COL_DATE;
207  }
208  if (p)
209  *p = '\n';
210  }
211  }
212 
213  pp->entrylist[pp->indx] = cur_block;
214  pp->indx++;
215  return pp->indx - 1;
216 }
217 
219 {
220  char* div;
221  char* eptr;
222  char* offset;
223 
225  return;
226 
227  offset = entry->mOffset;
228  size_t len = entry->len;
229 
230  if (! offset || len == 0)
231  return;
232 
234  div = offset + ibp->lc.div;
235  StringNCpy(ibp->division, div, 3);
236  ibp->division[3] = '\0';
237 
238  div = offset + ibp->lc.bases;
239  eptr = offset + len - 1;
240  while (div < eptr && *div == ' ')
241  div++;
242  ibp->bases = atoi(div);
243  return;
244  }
245 
246  div = StringChr(offset, '\n');
247  if (div) {
248  eptr = div;
249  len = eptr - offset + 1;
250  } else
251  eptr = offset + len - 1;
252 
253  if (len > 5 && StringEquN(eptr - 3, "BP.", 3))
254  eptr -= 4;
255 
256  while (*eptr == ' ' && eptr > offset)
257  eptr--;
258  while (isdigit(*eptr) != 0 && eptr > offset)
259  eptr--;
260  ibp->bases = atoi(eptr + 1);
261  while (*eptr == ' ' && eptr > offset)
262  eptr--;
263  if (*eptr == ';')
264  eptr--;
265  while (isalpha(*eptr) != 0 && eptr > offset)
266  eptr--;
267 
268  StringNCpy(ibp->division, eptr + 1, 3);
269  ibp->division[3] = '\0';
270 }
271 
273 {
274  IndexblkPtr ibp;
275  EntryBlkPtr ebp;
276  char* ptr;
277  char* eptr;
278 
279  ibp = pp->entrylist[pp->curindx];
280  ebp = static_cast<EntryBlk*>(entry->mpData);
281  ptr = entry->mOffset;
282  eptr = ptr + entry->len;
283 
284  CRef<CBioseq> bioseq(new CBioseq);
285  CRef<CSeq_id> new_id(new CSeq_id);
286  new_id->Assign(id);
287  bioseq->SetId().push_back(new_id);
288 
289  bioseq->SetInst().SetRepr(CSeq_inst::eRepr_raw);
290  bioseq->SetInst().SetTopology(CSeq_inst::eTopology_linear);
291  bioseq->SetInst().SetStrand(CSeq_inst::eStrand_ss);
292  bioseq->SetInst().SetLength(static_cast<CSeq_inst::TLength>(ibp->bases));
293 
294  bool res = false;
295  if (pp->format == Parser::EFormat::EMBL) {
296 
297  bioseq->SetInst().SetMol(CSeq_inst::eMol_na);
298 
299  Int2 curkw = ParFlat_ID;
300  while (curkw != ParFlatEM_END) {
301  ptr = GetEmblBlock(&ebp->chain, ptr, &curkw, pp->format, eptr);
302  }
303  if (ptr < eptr) {
304 
305  if (! ibp->is_contig) {
306  auto molconv = GetDNAConv();
307  res = GetSeqData(pp, *entry, *bioseq, ParFlat_SQ, molconv.get(), eSeq_code_type_iupacna);
308  // MemFree(molconv);
309  } else {
310  pp->farseq = true;
311  res = GetEmblInstContig(*entry, *bioseq, pp);
312  pp->farseq = false;
313  }
314  }
315  } else if (pp->format == Parser::EFormat::GenBank) {
316  bioseq->SetInst().SetMol(CSeq_inst::eMol_na);
317 
318  Int2 curkw = ParFlat_LOCUS;
319  while (curkw != ParFlat_END) {
320  ptr = GetGenBankBlock(&ebp->chain, ptr, &curkw, eptr);
321  }
322  if (ptr < eptr) {
323  if (! ibp->is_contig) {
324  auto molconv = GetDNAConv();
325  res = GetSeqData(pp, *entry, *bioseq, ParFlat_ORIGIN, molconv.get(), eSeq_code_type_iupacna);
326  // MemFree(molconv);
327  } else {
328  pp->farseq = true;
329  res = GetGenBankInstContig(entry, *bioseq, pp);
330  pp->farseq = false;
331  }
332  }
333  } else if (pp->format == Parser::EFormat::SPROT) {
334  bioseq->SetInst().SetMol(CSeq_inst::eMol_aa);
335  Int2 curkw = ParFlat_ID;
336  while (curkw != ParFlatSP_END) {
337  ptr = GetEmblBlock(&ebp->chain, ptr, &curkw, pp->format, eptr);
338  }
339 
340  if (ptr < eptr) {
341  auto molconv = GetProteinConv();
342  res = GetSeqData(pp, *entry, *bioseq, ParFlat_SQ, molconv.get(), eSeq_code_type_iupacna);
343  // MemFree(molconv);
344  }
345  }
346 
347  if (! res)
348  bioseq.Reset();
349 
350  return bioseq;
351 }
352 
353 static DataBlkPtr make_entry(char* entry_str)
354 {
355  DataBlkPtr entry = new DataBlk(nullptr, ParFlat_ENTRYNODE);
356 
357  if (entry) {
358  entry->mpNext = nullptr; /* assume no segment at this time */
359  entry->mOffset = entry_str;
360  entry->len = StringLen(entry->mOffset);
361  entry->mpData = new EntryBlk;
362  }
363 
364  return entry;
365 }
366 
367 static CRef<CBioseq> parse_entry(ParserPtr pp, char* entry_str, const string& accession, int ver, const CSeq_id& id)
368 {
369  CRef<CBioseq> ret;
370  DataBlkPtr entry = make_entry(entry_str);
371 
372  if (! entry)
373  return ret;
374 
375  int ix = add_entry(pp, accession.c_str(), ver, entry),
376  old_indx = pp->curindx;
377 
378  pp->curindx = ix;
379 
380  if (pp->entrylist[ix]->bases == 0) {
381  AddToIndexBlk(entry, pp->entrylist[ix], pp->format);
382  }
383 
384  ret = get_bioseq(pp, entry, id);
385  delete entry;
386  pp->curindx = old_indx;
387 
388  return ret;
389 }
390 
392 {
393  _ASSERT(lock);
394  _ASSERT(! lock.IsLoaded());
395 
396  string accession;
397  int version = 0;
398  if (get_accession_from_id(*idh.GetSeqId(), accession, version)) {
399 
400  char* entry_str = get_sequence_text(m_parser, accession, version);
401 
402  if (entry_str) {
403 
404  CRef<CBioseq> bioseq = parse_entry(m_parser, entry_str, accession, version, *idh.GetSeqId());
405  if (bioseq.NotEmpty()) {
406 
407  GetScope().AddBioseq(*bioseq);
408 
409  CRef<CSeq_entry> entry(new CSeq_entry);
410  entry->SetSeq(*bioseq);
411  lock->SetSeq_entry(*entry);
412  }
413  }
414  }
415 }
416 
418 {
419  static const string name("FF2ASN_BUF_BASED_LOADER");
420  return name;
421 }
422 
425  Parser* params,
426  CObjectManager::EIsDefault is_default,
427  CObjectManager::TPriority priority)
428 {
429  TLoaderMaker maker(params);
430  CDataLoader::RegisterInObjectManager(om, maker, is_default, priority);
431  return maker.GetRegisterInfo();
432 }
433 
435 
436 size_t CheckOutsideEntry(ParserPtr pp, const char* acc, Int2 vernum)
437 {
438  char* entry_str = objects::get_sequence_text(pp, acc, vernum);
439  if (! entry_str)
440  return -1;
441 
442  DataBlkPtr entry = objects::make_entry(entry_str);
443  if (! entry)
444  return -1;
445 
446  int ix = objects::add_entry(pp, acc, vernum, entry),
447  old_indx = pp->curindx;
448  pp->curindx = ix;
449 
450  EntryBlkPtr ebp = static_cast<EntryBlk*>(entry->mpData);
451  char* ptr = entry->mOffset; /* points to beginning of the memory line */
452  char* eptr = ptr + entry->len;
453  Int2 curkw = ParFlat_ID;
454  while (curkw != ParFlatEM_END) {
455  /* ptr points to current keyword's memory line */
456  ptr = GetEmblBlock(&ebp->chain, ptr, &curkw, pp->format, eptr);
457  }
458 
459  if (ptr >= eptr) {
460  pp->entrylist[pp->curindx]->drop = true;
461  ErrPostEx(SEV_ERROR, ERR_FORMAT_MissingEnd, "Missing end of the entry, entry dropped.");
462  MemFree(entry->mOffset);
463  delete entry;
464  return (-1);
465  }
466 
467  if (pp->entrylist[ix]->bases == 0) {
468  objects::AddToIndexBlk(entry, pp->entrylist[ix], pp->format);
469  }
470 
471  delete entry;
472  pp->curindx = old_indx;
473  return pp->entrylist[ix]->bases;
474 }
User-defined methods of the data storage class.
unique_ptr< unsigned char[]> GetDNAConv(void)
Definition: asci_blk.cpp:1797
unique_ptr< unsigned char[]> GetProteinConv(void)
Definition: asci_blk.cpp:1825
char * GetEmblBlock(DataBlkPtr *chain, char *ptr, short *retkw, Parser::EFormat format, char *eptr)
Definition: asci_blk.cpp:545
char * GetGenBankBlock(DataBlkPtr *chain, char *ptr, Int2 *retkw, char *eptr)
Definition: asci_blk.cpp:284
bool GetSeqData(ParserPtr pp, const DataBlk &entry, CBioseq &bioseq, Int4 nodetype, unsigned char *seqconv, Uint1 seq_data_type)
Definition: asci_blk.cpp:1685
bool GetEmblInstContig(const DataBlk &entry, objects::CBioseq &bioseq, ParserPtr pp)
static void AddToIndexBlk(DataBlkPtr entry, IndexblkPtr ibp, Parser::EFormat format)
CRef< CBioseq > get_bioseq(ParserPtr pp, DataBlkPtr entry, const CSeq_id &id)
static bool get_accession_from_id(const CSeq_id &id, string &accession, int &version)
static CRef< CBioseq > parse_entry(ParserPtr pp, char *entry_str, const string &accession, int ver, const CSeq_id &id)
static char * get_sequence_text(ParserPtr parser, const string &accession, int version)
static DataBlkPtr make_entry(char *entry_str)
size_t CheckOutsideEntry(ParserPtr pp, const char *acc, Int2 vernum)
static int add_entry(ParserPtr pp, const char *acc, Int2 vernum, DataBlkPtr entry)
virtual TTSE_LockSet GetRecords(const CSeq_id_Handle &idh, EChoice choice)
Request from a datasource using handles and ranges instead of seq-loc The TSEs loaded in this call wi...
virtual TBlobId GetBlobId(const CSeq_id_Handle &idh)
static TRegisterLoaderInfo RegisterInObjectManager(CObjectManager &om, Parser *params, CObjectManager::EIsDefault is_default, CObjectManager::TPriority priority)
void x_LoadData(const CSeq_id_Handle &idh, CTSE_LoadLock &lock)
virtual TTSE_Lock GetBlobById(const TBlobId &blob_id)
static const string & GetLoaderNameFromArgs(Parser *)
virtual bool CanGetBlobById() const
CTSE_LoadLock GetTSE_LoadLock(const TBlobId &blob_id)
CObjectManager –.
Definition: Seq_entry.hpp:56
void SetSeq_entry(CSeq_entry &entry, CTSE_SetObjectInfo *set_info=0)
Definition: tse_info.cpp:351
bool IsLoaded(void) const
void SetLoaded(void)
char * mOffset
Definition: ftablock.h:334
size_t len
Definition: ftablock.h:335
CFlatFileData * mpData
Definition: ftablock.h:333
DataBlk * mpNext
Definition: ftablock.h:338
iterator_bool insert(const value_type &val)
Definition: set.hpp:149
@ ParFlat_SQ
Definition: embl.h:53
@ ParFlat_ID
Definition: embl.h:42
@ ParFlatEM_END
Definition: embl.h:58
#define ERR_FORMAT_MissingEnd
Definition: flat2err.h:39
#define ParFlat_ENTRYNODE
Definition: ftablock.h:67
bool StringEquN(const char *s1, const char *s2, size_t n)
Definition: ftacpp.hpp:115
bool StringEqu(const char *s1, const char *s2)
Definition: ftacpp.hpp:105
void StringCpy(char *d, const char *s)
Definition: ftacpp.hpp:83
void StringNCpy(char *d, const char *s, size_t n)
Definition: ftacpp.hpp:84
void MemFree(char *p)
Definition: ftacpp.hpp:55
size_t StringLen(const char *s)
Definition: ftacpp.hpp:60
int offset
Definition: replacements.h:160
bool GetGenBankInstContig(const DataBlk &entry, CBioseq &bsp, ParserPtr pp)
Definition: gb_ascii.cpp:135
@ ParFlat_LOCUS
Definition: genbank.h:41
@ ParFlat_END
Definition: genbank.h:54
@ ParFlat_ORIGIN
Definition: genbank.h:53
#define SEV_ERROR
Definition: gicache.c:91
#define StringChr
Definition: ncbistr.hpp:317
#define ErrPostEx(sev, err_code,...)
Definition: ncbierr.hpp:78
virtual void Assign(const CSerialObject &source, ESerialRecursionMode how=eRecursive)
Optimized implementation of CSerialObject::Assign, which is not so efficient.
Definition: Seq_id.cpp:318
CConstRef< CSeq_id > GetSeqId(void) const
const CSeq_id & GetId(const CSeq_loc &loc, CScope *scope)
If all CSeq_ids embedded in CSeq_loc refer to the same CBioseq, returns the first CSeq_id found,...
const value_type & GetValue(void) const
Definition: blob_id.hpp:122
CBlobIdFor< CSeq_id_Handle > CBlobIdSeq_id
Definition: blob_id.hpp:154
CBioseq_Handle AddBioseq(CBioseq &bioseq, TPriority pri=kPriority_Default, EExist action=eExist_Throw)
Add bioseq, return bioseq handle.
Definition: scope.cpp:530
CDataSource * GetDataSource(void) const
Definition: data_loader.cpp:92
EChoice
main blob is blob with sequence all other blobs are external and contain external annotations
EIsDefault
Flag defining if the data loader is included in the "default" group.
TRegisterInfo GetRegisterInfo(void)
static void RegisterInObjectManager(CObjectManager &om, CLoaderMaker_Base &loader_maker, CObjectManager::EIsDefault is_default, CObjectManager::TPriority priority)
Register the loader only if the name is not yet registered in the object manager.
Definition: data_loader.cpp:53
@ eAll
all blobs (main and external)
@ eSequence
seq data
@ eBlob
whole main
@ eCore
?only seq-entry core?
@ eBioseq
main blob with complete bioseq
@ eBioseqCore
main blob with bioseq core (no seqdata and annots)
void Reset(void)
Reset reference object.
Definition: ncbiobj.hpp:773
bool NotEmpty(void) const THROWS_NONE
Check if CRef is not empty – pointing to an object and has a non-null value.
Definition: ncbiobj.hpp:726
int16_t Int2
2-byte (16-bit) signed integer
Definition: ncbitype.h:100
#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
static string IntToString(int value, TNumToStringFlags flags=0, int base=10)
Convert int to string.
Definition: ncbistr.hpp:5084
@ eSeq_code_type_iupacna
IUPAC 1 letter nuc acid code.
bool IsSetAccession(void) const
Check if a value has been assigned to Accession data member.
TVersion GetVersion(void) const
Get the Version member data.
bool IsSetVersion(void) const
Check if a value has been assigned to Version data member.
const TAccession & GetAccession(void) const
Get the Accession member data.
TSeq & SetSeq(void)
Select the variant.
Definition: Seq_entry_.cpp:108
TId & SetId(void)
Assign a value to Id data member.
Definition: Bioseq_.hpp:296
void SetInst(TInst &value)
Assign a value to Inst data member.
Definition: Bioseq_.cpp:86
TSeqPos TLength
Definition: Seq_inst_.hpp:147
@ eRepr_raw
continuous sequence
Definition: Seq_inst_.hpp:94
@ eMol_na
just a nucleic acid
Definition: Seq_inst_.hpp:113
@ eStrand_ss
single strand
Definition: Seq_inst_.hpp:135
@ ParFlat_COL_DATE
Definition: index.h:49
@ ParFlat_COL_STRAND_NEW
Definition: index.h:54
@ ParFlat_COL_MOLECULE_NEW
Definition: index.h:55
@ ParFlat_COL_BP_NEW
Definition: index.h:53
@ ParFlat_COL_TOPOLOGY_NEW
Definition: index.h:56
@ ParFlat_COL_BP
Definition: index.h:44
@ ParFlat_COL_TOPOLOGY
Definition: index.h:47
@ ParFlat_COL_DATE_NEW
Definition: index.h:58
@ ParFlat_COL_DIV
Definition: index.h:48
@ ParFlat_COL_BASES
Definition: index.h:43
@ ParFlat_COL_DIV_NEW
Definition: index.h:57
@ ParFlat_COL_BASES_NEW
Definition: index.h:52
@ ParFlat_COL_MOLECULE
Definition: index.h:46
@ ParFlat_COL_STRAND
Definition: index.h:45
int i
int len
static int version
Definition: mdb_load.c:29
int isalpha(Uchar c)
Definition: ncbictype.hpp:61
int isdigit(Uchar c)
Definition: ncbictype.hpp:64
static Format format
Definition: njn_ioutil.cpp:53
@ ParFlatSP_END
Definition: sprot.h:55
CRef< objects::CObjectManager > om
DataBlkPtr chain
Definition: ftablock.h:346
Char acnum[200]
Definition: ftablock.h:171
Char division[4]
Definition: ftablock.h:176
Parser * ppp
Definition: ftablock.h:255
Int2 vernum
Definition: ftablock.h:172
bool is_contig
Definition: ftablock.h:202
size_t bases
Definition: ftablock.h:177
LocusCont lc
Definition: ftablock.h:217
Int4 bases
Definition: ftablock.h:105
Int4 molecule
Definition: ftablock.h:108
Int4 strand
Definition: ftablock.h:107
Int4 topology
Definition: ftablock.h:109
Int4 date
Definition: ftablock.h:111
Int4 bp
Definition: ftablock.h:106
Int4 div
Definition: ftablock.h:110
char *(* ff_get_entry_v_pp)(const char *accession, Int2 vernum, Parser *pp)
char *(* ff_get_entry)(const char *accession)
char *(* ff_get_entry_pp)(const char *accession, Parser *pp)
vector< IndexblkPtr > entrylist
char *(* ff_get_entry_v)(const char *accession, Int2 vernum)
SRegisterLoaderInfo –.
#define _ASSERT
CScope & GetScope()
#define const
Definition: zconf.h:232
Modified on Wed Apr 24 14:11:47 2024 by modify_doxy.py rev. 669887