NCBI C++ ToolKit
blast_seqsrc.h
Go to the documentation of this file.

Go to the SVN repository for this file.

1 /* $Id: blast_seqsrc.h 89539 2020-04-06 17:49:43Z fongah2 $
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  * Author: Christiam Camacho
27  *
28  */
29 
30 /** @file blast_seqsrc.h
31  * Declaration of ADT to retrieve sequences for the BLAST engine.
32  *
33  * @todo The following are pending items to be addressed in the BlastSeqSrc
34  * interface and implementations
35  * - Make "multi-sequence" BlastSeqSrc implementations MT-safe
36  * - Provide possibility of retrieving an error from BlastSeqSrc (not just
37  * initialization errors).
38  * - Constrain all use of the BlastSeqSrc to CORE BLAST
39  */
40 
41 #ifndef ALGO_BLAST_CORE__BLAST_SEQSRC__H
42 #define ALGO_BLAST_CORE__BLAST_SEQSRC__H
43 
49 
50 #ifdef __cplusplus
51 extern "C" {
52 #endif
53 
54 /** The BlastSeqSrc ADT is an opaque data type that defines an interface which
55  * is used by the core BLAST code to retrieve sequences.
56  * The interface currently provides the following services:
57  * - Retrieving number of sequences in a set
58  * - Retrieving the total length (in bases/residues) of sequences in a set.
59  * - Retrieving the length of the longest sequence in a set
60  * - Retrieving an individual sequence in a user-specified encoding by ordinal
61  * id (index into a set)
62  * - Retrieving the length of a given sequence in a set by ordinal id
63  * - Allow MT-safe iteration over sequences in a set through the
64  * BlastSeqSrcIterator abstraction, as well as resetting of any applicable
65  * implementation internal 'bookmarks' which keep track of the iteration
66  * progress, as to allow multiple passes over the set of sequences (@sa
67  * BlastSeqSrcResetChunkIterator).
68  * .
69  *
70  * Currently available client implementations of the BlastSeqSrc API include:
71  * - ReaddbBlastSeqSrcInit (C toolkit)
72  * - SeqDbBlastSeqSrcInit (C++ toolkit)
73  * - MultiSeqBlastSeqSrcInit (C/C++ toolkit)
74  * .
75  * For more details, see also @ref _impl_blast_seqsrc_howto
76  */
77 typedef struct BlastSeqSrc BlastSeqSrc;
78 
79 /** Blast Sequence Source Iterator, designed to be used in conjunction with the
80  * BlastSeqSrc to provide MT-safe iteration over the sequences in the
81  * BlastSeqSrc
82  * @todo This is still coupled to the BLAST database implementations of the
83  * BlastSeqSrc, could be made more generic if needed.
84  */
86 
87 /** Structure that contains the information needed for BlastSeqSrcNew to fully
88  * populate the BlastSeqSrc structure it returns */
90 
91 /** Allocates memory for a BlastSeqSrc structure and then invokes the
92  * constructor function defined in its first argument, passing the
93  * ctor_argument member of that same structure. If the constructor function
94  * pointer is not set or there is a memory allocation failure, NULL is
95  * returned.
96  * @note This function need not be called directly by client code as all the
97  * implementations of the BlastSeqSrc interface provide a function(s) which
98  * call this function (@ref MultiSeqBlastSeqSrcInit, @ref SeqDbBlastSeqSrcInit)
99  * @param bssn_info Structure defining constructor and its argument to be
100  * invoked from this function [in]
101  * @return a properly initialized BlastSeqSrc structure or NULL.
102  */
105 
106 /** Copy function: needed to guarantee thread safety. Copies the contents of an
107  * input BlastSeqSrc, then calls a copier function, provided by the
108  * implementation, to achieve multi-thread safety.
109  * @todo Is this function really needed?
110  * @param seq_src BlastSeqSrc to copy [in]
111  * @return An MT-safe copy of the structure passed in, NULL in case of memory
112  * allocation failure, or, if no copy function was provided by the
113  * implementation, a bitwise copy of the input.
114  */
116 BlastSeqSrc* BlastSeqSrcCopy(const BlastSeqSrc* seq_src);
117 
118 /** Frees the BlastSeqSrc structure by invoking the destructor function set by
119  * the user-defined constructor function when the structure is initialized
120  * (indirectly, by BlastSeqSrcNew). If the destructor function pointer is not
121  * set, a memory leak could occur. Note that it is the implementation's
122  * destructor responsibility to free the BlastSeqSrc structure by calling
123  * sfree.
124  * @param seq_src BlastSeqSrc to free [in]
125  * @return NULL
126  */
129 
130 /** Get the number of sequences contained in the sequence source.
131  * @param seq_src the BLAST sequence source [in]
132  */
134 Int4
135 BlastSeqSrcGetNumSeqs(const BlastSeqSrc* seq_src);
136 
137 /** Get the number of sequences used for calculation of expect values etc.
138  * @param seq_src the BLAST sequence source [in]
139  */
141 Int4
143 
144 /** Get the length of the longest sequence in the sequence source.
145  * @param seq_src the BLAST sequence source [in]
146  */
148 Int4
149 BlastSeqSrcGetMaxSeqLen(const BlastSeqSrc* seq_src);
150 
151 /** Get the length of the longest sequence in the sequence source.
152  * @param seq_src the BLAST sequence source [in]
153  */
155 Int4
156 BlastSeqSrcGetMinSeqLen(const BlastSeqSrc* seq_src);
157 
158 /** Get the average length of all sequences in the sequence source.
159  * @param seq_src the BLAST sequence source [in]
160  */
162 Int4
163 BlastSeqSrcGetAvgSeqLen(const BlastSeqSrc* seq_src);
164 
165 /** Get the total length of all sequences in the sequence source.
166  * @param seq_src the BLAST sequence source [in]
167  */
169 Int8
170 BlastSeqSrcGetTotLen(const BlastSeqSrc* seq_src);
171 
172 /** Get the total length of all sequences for calculation of expect value etc.
173  * @param seq_src the BLAST sequence source [in]
174  */
176 Int8
177 BlastSeqSrcGetTotLenStats(const BlastSeqSrc* seq_src);
178 
179 /** Get the Blast Sequence source name (e.g.: BLAST database name).
180  * Here the full name (path and file name) should be returned.
181  * If an alias file is present the return value should be the full name of
182  * the alias file.
183  * @param seq_src the BLAST sequence source [in]
184  */
186 const char*
187 BlastSeqSrcGetName(const BlastSeqSrc* seq_src);
188 
189 /** Find if the Blast Sequence Source contains protein or nucleotide sequences.
190  * @param seq_src the BLAST sequence source [in]
191  */
193 Boolean
194 BlastSeqSrcGetIsProt(const BlastSeqSrc* seq_src);
195 
196 /** Find if the Blast Sequence Source supports partial fetching
197  * @param seq_src the BLAST sequence source [in]
198  */
200 Boolean
202 
203 #define BLAST_SEQSRC_MINGAP 1024 /**< Minimal gap allowed in range list */
204 #define BLAST_SEQSRC_OVERHANG 1024 /**< Extension for each new range added */
205 #define BLAST_SEQSRC_MINLENGTH 10 /**< Default minimal sequence length */
206 
207 /** Structure used as the argument to function SetRanges */
208 typedef struct BlastSeqSrcSetRangesArg {
209  /** Oid in BLAST database, index in an array of sequences, etc [in] */
211 
212  /** initial allocation*/
214 
215  /** Number of actual ranges contained */
217 
218  /** Ranges in sorted order [in] */
221 
222 /** new setrangearg */
225 BlastSeqSrcSetRangesArgNew(Int4 num_ranges);
226 
227 /** add new range
228  * @return 0 in case of success, otherwise 1
229  */
231 Int2
233  Int4 begin, Int4 end, Int4 len);
234 
235 /** free setrangearg */
239 
240 
241 /** build BlastSeqSrcSetRangesArg from range list*/
243 void
245 
246 /** Setting the ranges for partial fetching */
248 void
249 BlastSeqSrcSetSeqRanges(const BlastSeqSrc* seq_src,
250  BlastSeqSrcSetRangesArg* setranges_arg);
251 
252 
253 /** Structure used as the second argument to functions satisfying the
254  GetSeqBlkFnPtr signature, associated with index-based
255  implementations of the BlastSeqSrc interface. Index-based implementations
256  include BLAST databases or an array/vector of sequences. */
257 typedef struct BlastSeqSrcGetSeqArg {
258  /** Oid in BLAST database, index in an array of sequences, etc [in] */
260 
261  /** Encoding of sequence, i.e.: eBlastEncodingProtein,
262  * eBlastEncodingNucleotide, etc [in] */
264 
265  /** This option allows the BLAST engine to communicate with the BlastSeqSrc
266  * that the offset ranges for a given OID should be reset and the entire
267  * sequence data should be fetched. The motivation for this option is to
268  * exploit CSeqDB's performance feature that allows to retrieve only
269  * pre-selected portions of the sequence data for the traceback stage.
270  * BlastSeqSrc implementations that do not have this feature can safely
271  * ignore this field.
272  * By default, this should be set to FALSE. [in] */
274 
275  /** Check whether an OID is excluded due to overlapping filtering.
276  * The disease is rare, and the test for it is somewhat expensive,
277  * so it is deferred to the traceback stage.
278  * TRUE to enable this test. [in] */
280 
281  /** Sequence to return, if NULL, it should allocated by GetSeqBlkFnPtr
282  * (using BlastSeqBlkNew or BlastSetUp_SeqBlkNew), else its contents are
283  * freed (using BlastSequenceBlkClean) and the structure is reused [out]*/
285 
288 
289 /* Return values from BlastSeqSrcGetSequence */
290 #define BLAST_SEQSRC_EXCLUDED -3 /**< Sequence excluded due to filtering */
291 #define BLAST_SEQSRC_ERROR -2 /**< Error while retrieving sequence */
292 #define BLAST_SEQSRC_EOF -1 /**< No more sequences available */
293 #define BLAST_SEQSRC_SUCCESS 0 /**< Successful sequence retrieval */
294 
295 /** Retrieve an individual sequence.
296  * @param seq_src the BLAST sequence source [in]
297  * @param getseq_arg arguments to aid retrieval of sequence data from the
298  * BlastSeqSrc [in|out]
299  * @return one of the BLAST_SEQSRC_* defined in blast_seqsrc.h
300  */
302 Int2
303 BlastSeqSrcGetSequence(const BlastSeqSrc* seq_src,
304  BlastSeqSrcGetSeqArg* getseq_arg);
305 
306 /** Retrieve sequence length (number of residues/bases)
307  * @param seq_src the BLAST sequence source [in]
308  * @param oid ordinal id of the sequence desired (should be Uint4) [in]
309  */
311 Int4
312 BlastSeqSrcGetSeqLen(const BlastSeqSrc* seq_src, void* oid);
313 
314 /** Deallocate individual sequence.
315  * @param seq_src the BLAST sequence source [in]
316  * @param getseq_arg contains sequence to deallocate [in|out]
317  */
319 void
321  BlastSeqSrcGetSeqArg* getseq_arg);
322 
323 /** Function to retrieve NULL terminated string containing the description
324  * of an initialization error or NULL. This function MUST ALWAYS be called
325  * after calling one of the client implementation's Init functions. If the
326  * return value is not NULL, invoking any other functionality from the
327  * BlastSeqSrc will result in undefined behavior. Caller is responsible for
328  * deallocating the return value.
329  * @param seq_src BlastSeqSrc from which to get an error [in]
330  * @return error message or NULL
331  */
333 char* BlastSeqSrcGetInitError(const BlastSeqSrc* seq_src);
334 
335 /* This is a *debugging* feature for the code that implements the various
336  * composition-based statistics types of processing, added at the request of
337  * the authors of that code */
338 #ifdef KAPPA_PRINT_DIAGNOSTICS
339 
340 /** Data structure to contain a list of gis */
341 typedef struct Blast_GiList {
342  Int4* data; /**< Gis are stored here */
343  size_t num_allocated; /**< Size of the data array */
344  size_t num_used; /**< Number of elements populated in data */
345 } Blast_GiList;
346 
347 /** Allocate a gi list with default size */
349 Blast_GiList* Blast_GiListNew(void);
350 
351 /** Allocate a gi list with the requested size
352  * @param list_size initial list size [in]
353  */
355 Blast_GiList* Blast_GiListNewEx(size_t list_size);
356 
357 /** Deallocate memory associated with the gi list
358  * @return NULL
359  */
361 Blast_GiList* Blast_GiListFree(Blast_GiList* gilist);
362 
363 /* Return values */
364 
365 /** Invalid parameter used in a function call */
367 extern const Int2 kBadParameter;
368 /** Failure due to out-of-memory condition */
370 extern const Int2 kOutOfMemory;
371 
372 /** Appends to an existing gi list, allocating memory if necessary
373  * @return 0 on success or one of the constants defined above
374  */
375 Int2 Blast_GiList_Append(Blast_GiList* gilist, Int4 gi);
376 
377 /** Retrieve a sequence's gi (if available). Caller is responsible for
378  * deallocating return value with Blast_GiListFree
379  * @param seq_src the BLAST sequence source [in]
380  * @param oid ordinal id of the sequence desired (should be Uint4) [in]
381  * @return the gis corresponding to the ordinal id requested, an empty list if
382  * there are no gis in the BlastSeqSrc implementation, or NULL in case of
383  * error
384  */
386 Blast_GiList*
387 BlastSeqSrcGetGis(const BlastSeqSrc* seq_src, void* oid);
388 
389 #endif /* KAPPA_PRINT_DIAGNOSTICS */
390 
391 /******************** BlastSeqSrcIterator API *******************************/
392 
393 /** Allocate and initialize an iterator over a BlastSeqSrc with a default chunk
394  * size for MT-safe iteration.
395  * @return pointer to initialized iterator for BlastSeqSrc
396  */
399 
400 /** How many database sequences to process in one database chunk.
401  * this value is overriden in seqdb implementation, where the number of sequences
402  * is determined by the mmaped slice size */
403 extern const unsigned int kBlastSeqSrcDefaultChunkSize;
404 
405 /** Allocate and initialize an iterator over a BlastSeqSrc.
406  * @param chunk_sz sets the chunk size of the iterator, if zero
407  * use kBlastSeqSrcDefaultChunkSize (above). [in]
408  * @return pointer to initialized iterator for BlastSeqSrc
409  */
411 BlastSeqSrcIterator* BlastSeqSrcIteratorNewEx(unsigned int chunk_sz);
412 
413 /** Frees the BlastSeqSrcIterator structure.
414  * @param itr BlastSeqSrcIterator to free [in]
415  * @return NULL
416  */
419 
420 /** Increments the BlastSeqSrcIterator.
421  * @param itr the BlastSeqSrcIterator to increment.
422  * @param seq_src the underlying BlastSeqSrc
423  * @return one of the BLAST_SEQSRC_* defined in blast_seqsrc.h
424  */
427  BlastSeqSrcIterator* itr);
428 
429 /** Reset the internal "bookmark" of the last chunk for iteration provided by
430  * this object.
431  * @param seq_src the BLAST sequence source [in]
432  */
435 
436 /** Set the number of threads for MT mode
437  * @param nthreads the number of threads [in]
438  */
440 void BlastSeqSrcSetNumberOfThreads(BlastSeqSrc* seq_src, int nthreads);
441 
442 /*****************************************************************************/
443 
444 #ifdef __cplusplus
445 }
446 #endif
447 
448 #endif /* !ALGO_BLAST_CORE__BLAST_SEQSRC__H */
Definitions used throughout BLAST.
Declarations of static arrays used to define some NCBI encodings to be used in a toolkit independent ...
Defines to provide correct exporting from BLAST DLL in Windows.
#define NCBI_XBLAST_EXPORT
NULL operations for other cases.
Definition: blast_export.h:65
Structures for BLAST messages.
Int2 BlastSeqSrcSetRangesArgAddRange(BlastSeqSrcSetRangesArg *arg, Int4 begin, Int4 end, Int4 len)
add new range
Definition: blast_seqsrc.c:467
Int4 BlastSeqSrcIteratorNext(const BlastSeqSrc *seq_src, BlastSeqSrcIterator *itr)
Increments the BlastSeqSrcIterator.
Definition: blast_seqsrc.c:425
Int8 BlastSeqSrcGetTotLenStats(const BlastSeqSrc *seq_src)
Get the total length of all sequences for calculation of expect value etc.
Definition: blast_seqsrc.c:227
BlastSeqSrcIterator * BlastSeqSrcIteratorFree(BlastSeqSrcIterator *itr)
Frees the BlastSeqSrcIterator structure.
Definition: blast_seqsrc.c:412
BlastSeqSrcIterator * BlastSeqSrcIteratorNewEx(unsigned int chunk_sz)
Allocate and initialize an iterator over a BlastSeqSrc.
Definition: blast_seqsrc.c:387
Int4 BlastSeqSrcGetSeqLen(const BlastSeqSrc *seq_src, void *oid)
Retrieve sequence length (number of residues/bases)
Definition: blast_seqsrc.c:281
Boolean BlastSeqSrcGetIsProt(const BlastSeqSrc *seq_src)
Find if the Blast Sequence Source contains protein or nucleotide sequences.
Definition: blast_seqsrc.c:243
BlastSeqSrc * BlastSeqSrcNew(const BlastSeqSrcNewInfo *bssn_info)
Allocates memory for a BlastSeqSrc structure and then invokes the constructor function defined in its...
Definition: blast_seqsrc.c:90
void BlastSeqSrcSetRangesArgBuild(BlastSeqSrcSetRangesArg *arg)
build BlastSeqSrcSetRangesArg from range list
Definition: blast_seqsrc.c:496
void BlastSeqSrcReleaseSequence(const BlastSeqSrc *seq_src, BlastSeqSrcGetSeqArg *getseq_arg)
Deallocate individual sequence.
Definition: blast_seqsrc.c:289
BlastSeqSrcIterator * BlastSeqSrcIteratorNew(void)
Allocate and initialize an iterator over a BlastSeqSrc with a default chunk size for MT-safe iteratio...
Definition: blast_seqsrc.c:380
BlastSeqSrc * BlastSeqSrcCopy(const BlastSeqSrc *seq_src)
Copy function: needed to guarantee thread safety.
Definition: blast_seqsrc.c:138
void BlastSeqSrcSetSeqRanges(const BlastSeqSrc *seq_src, BlastSeqSrcSetRangesArg *setranges_arg)
Setting the ranges for partial fetching.
Definition: blast_seqsrc.c:261
Int4 BlastSeqSrcGetAvgSeqLen(const BlastSeqSrc *seq_src)
Get the average length of all sequences in the sequence source.
Definition: blast_seqsrc.c:211
char * BlastSeqSrcGetInitError(const BlastSeqSrc *seq_src)
Function to retrieve NULL terminated string containing the description of an initialization error or ...
Definition: blast_seqsrc.c:159
Int4 BlastSeqSrcGetNumSeqs(const BlastSeqSrc *seq_src)
Get the number of sequences contained in the sequence source.
Definition: blast_seqsrc.c:177
struct BlastSeqSrcSetRangesArg BlastSeqSrcSetRangesArg
Structure used as the argument to function SetRanges.
Int8 BlastSeqSrcGetTotLen(const BlastSeqSrc *seq_src)
Get the total length of all sequences in the sequence source.
Definition: blast_seqsrc.c:219
BlastSeqSrc * BlastSeqSrcFree(BlastSeqSrc *seq_src)
Frees the BlastSeqSrc structure by invoking the destructor function set by the user-defined construct...
Definition: blast_seqsrc.c:112
Int4 BlastSeqSrcGetNumSeqsStats(const BlastSeqSrc *seq_src)
Get the number of sequences used for calculation of expect values etc.
Definition: blast_seqsrc.c:185
BlastSeqSrcSetRangesArg * BlastSeqSrcSetRangesArgNew(Int4 num_ranges)
new setrangearg
Definition: blast_seqsrc.c:444
const unsigned int kBlastSeqSrcDefaultChunkSize
How many database sequences to process in one database chunk.
Definition: blast_seqsrc.c:385
struct BlastSeqSrcGetSeqArg BlastSeqSrcGetSeqArg
Structure used as the second argument to functions satisfying the GetSeqBlkFnPtr signature,...
void BlastSeqSrcSetNumberOfThreads(BlastSeqSrc *seq_src, int nthreads)
Set the number of threads for MT mode.
Definition: blast_seqsrc.c:168
Int4 BlastSeqSrcGetMaxSeqLen(const BlastSeqSrc *seq_src)
Get the length of the longest sequence in the sequence source.
Definition: blast_seqsrc.c:193
Boolean BlastSeqSrcGetSupportsPartialFetching(const BlastSeqSrc *seq_src)
Find if the Blast Sequence Source supports partial fetching.
Definition: blast_seqsrc.c:251
const char * BlastSeqSrcGetName(const BlastSeqSrc *seq_src)
Get the Blast Sequence source name (e.g.
Definition: blast_seqsrc.c:235
Int2 BlastSeqSrcGetSequence(const BlastSeqSrc *seq_src, BlastSeqSrcGetSeqArg *getseq_arg)
Retrieve an individual sequence.
Definition: blast_seqsrc.c:271
BlastSeqSrcSetRangesArg * BlastSeqSrcSetRangesArgFree(BlastSeqSrcSetRangesArg *arg)
free setrangearg
Definition: blast_seqsrc.c:455
Int4 BlastSeqSrcGetMinSeqLen(const BlastSeqSrc *seq_src)
Get the length of the longest sequence in the sequence source.
Definition: blast_seqsrc.c:201
void BlastSeqSrcResetChunkIterator(BlastSeqSrc *seq_src)
Reset the internal "bookmark" of the last chunk for iteration provided by this object.
Definition: blast_seqsrc.c:436
char data[12]
Definition: iconv.c:80
EBlastEncoding
Different types of sequence encodings for sequence retrieval from the BLAST database.
int16_t Int2
2-byte (16-bit) signed integer
Definition: ncbitype.h:100
int32_t Int4
4-byte (32-bit) signed integer
Definition: ncbitype.h:102
int64_t Int8
8-byte (64-bit) signed integer
Definition: ncbitype.h:104
int len
Type and macro definitions from C toolkit that are not defined in C++ toolkit.
Uint1 Boolean
bool replacment for C
Definition: ncbi_std.h:94
const Int2 kOutOfMemory
Failure due to out-of-memory condition.
Definition: split_query.c:38
const Int2 kBadParameter
Invalid parameter used in a function call.
Definition: split_query.c:37
Structure to hold a sequence.
Definition: blast_def.h:242
Structure used as the second argument to functions satisfying the GetSeqBlkFnPtr signature,...
Definition: blast_seqsrc.h:257
Int4 oid
Oid in BLAST database, index in an array of sequences, etc [in].
Definition: blast_seqsrc.h:259
Boolean reset_ranges
This option allows the BLAST engine to communicate with the BlastSeqSrc that the offset ranges for a ...
Definition: blast_seqsrc.h:273
EBlastEncoding encoding
Encoding of sequence, i.e.
Definition: blast_seqsrc.h:263
Boolean check_oid_exclusion
Check whether an OID is excluded due to overlapping filtering.
Definition: blast_seqsrc.h:279
BlastSeqSrcSetRangesArg * ranges
Definition: blast_seqsrc.h:286
BLAST_SequenceBlk * seq
Sequence to return, if NULL, it should allocated by GetSeqBlkFnPtr (using BlastSeqBlkNew or BlastSetU...
Definition: blast_seqsrc.h:284
Complete type definition of Blast Sequence Source Iterator.
Complete type definition of the structure used to create a new BlastSeqSrc.
Structure used as the argument to function SetRanges.
Definition: blast_seqsrc.h:208
Int4 capacity
initial allocation
Definition: blast_seqsrc.h:213
Int4 * ranges
Ranges in sorted order [in].
Definition: blast_seqsrc.h:219
Int4 num_ranges
Number of actual ranges contained.
Definition: blast_seqsrc.h:216
Int4 oid
Oid in BLAST database, index in an array of sequences, etc [in].
Definition: blast_seqsrc.h:210
Complete type definition of Blast Sequence Source ADT.
Definition: blast_seqsrc.c:43
Modified on Tue May 28 05:51:03 2024 by modify_doxy.py rev. 669887