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

Go to the SVN repository for this file.

1 /* $Id: blast_input.hpp 93314 2021-03-31 15:26:56Z boratyng $
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: Jason Papadopoulos
27  *
28  */
29 
30 /** @file algo/blast/blastinput/blast_input.hpp
31  * Interface for converting sources of sequence data into
32  * blast sequence input
33  */
34 
35 #ifndef ALGO_BLAST_BLASTINPUT___BLAST_INPUT__HPP
36 #define ALGO_BLAST_BLASTINPUT___BLAST_INPUT__HPP
37 
38 #include <corelib/ncbistd.hpp>
41 
43 BEGIN_SCOPE(blast)
44 
45 /// Class that centralizes the configuration data for
46 /// sequences to be converted
47 ///
49 
50 public:
51 
52  /** This value and the seqlen_thresh2guess argument to this class'
53  constructor are related as follows: if the default parameter value is
54  used, then no sequence type guessing will occurs, instead the sequence
55  type specified in
56  CBlastInputSourceConfig::SDataLoader::m_IsLoadingProteins is assumed
57  correct. If an alternate value is specified, then any sequences shorter
58  than that length will be treated as described above, otherwise those
59  sequences will have their sequence type guessed (and be subject to
60  validation between what is guessed by CFastaReader and what is expected
61  by CBlastInputSource).
62 
63  By design, the default setting should be fine for command line BLAST
64  search binaries, but on the BLAST web pages we use kSeqLenThreshold2Guess
65  to validate sequences longer than that length, and to accept sequences
66  shorter than that length.
67 
68  @sa Implementation in CCustomizedFastaReader
69  @sa TestSmallDubiousSequences unit test
70  */
71  static const unsigned int kSeqLenThreshold2Guess = 25;
72 
73  /// Constructor
74  /// @param dlconfig Configuration object for the data loaders used in
75  /// CBlastScopeSource [in]
76  /// @param strand All SeqLoc types will have this strand assigned;
77  /// If set to 'other', the strand will be set to 'unknown'
78  /// for protein sequences and 'both' for nucleotide [in]
79  /// @param lowercase If true, lowercase mask locations are generated
80  /// for all input sequences [in]
81  /// @param believe_defline If true, all sequences ID's are parsed;
82  /// otherwise all sequences receive a local ID set
83  /// to a monotonically increasing count value [in]
84  /// @param retrieve_seq_data When gis/accessions are provided in the input,
85  /// should the sequence data be fetched by this library?
86  /// @param range Range restriction for all sequences (default means no
87  /// restriction). To support the specification of a single
88  /// coordinate (start or stop), use the SetRange() method,
89  /// the missing coordinate will be set the default value
90  /// (e.g.: 0 for starting coordinate, sequence length for
91  /// ending coordinate) [in]
92  /// @param seqlen_thresh2guess sequence length threshold for molecule
93  /// type guessing (see @ref kSeqLenThreshold2Guess) [in]
94  /// @param local_id_counter counter used to create the CSeqidGenerator to
95  /// create local identifiers for sequences read [in]
96  /// @param skip_seq_check When set this will avoid the sequence
97  /// validation step when using the CFastaReader. -RMH-
100  bool lowercase = false,
101  bool believe_defline = false,
103  bool retrieve_seq_data = true,
104  int local_id_counter = 1,
105  unsigned int seqlen_thresh2guess =
107  bool skip_seq_check = false /* -RMH- */ );
108 
109  /// Destructor
110  ///
112 
113  /// Set the strand to a specified value
114  /// @param strand The strand value
115  ///
116  void SetStrand(objects::ENa_strand strand) { m_Strand = strand; }
117 
118  /// Retrieve the current strand value
119  /// @return the strand
120  objects::ENa_strand GetStrand() const { return m_Strand; }
121 
122  /// Turn lowercase masking on/off
123  /// @param mask boolean to toggle lowercase masking
124  ///
125  void SetLowercaseMask(bool mask) { m_LowerCaseMask = mask; }
126 
127  /// Retrieve lowercase mask status
128  /// @return boolean to toggle lowercase masking
129  ///
130  bool GetLowercaseMask() const { return m_LowerCaseMask; }
131 
132  /// Turn parsing of sequence IDs on/off
133  /// @param believe boolean to toggle parsing of seq IDs
134  ///
135  void SetBelieveDeflines(bool believe) { m_BelieveDeflines = believe; }
136 
137  /// Retrieve current sequence ID parsing status
138  /// @return boolean to toggle parsing of seq IDs
139  ///
140  bool GetBelieveDeflines() const { return m_BelieveDeflines; }
141 
142  /// Retrieve status of sequence alphabet validation
143  /// @return boolean to toggle validation of seq data
144  /// -RMH-
145  ///
146  bool GetSkipSeqCheck() const { return m_SkipSeqCheck; }
147 
148  /// Turn validation of sequence on/off
149  /// @param skip boolean to toggle validation of sequence
150  /// -RMH-
151  ///
152  void SetSkipSeqCheck(bool skip) { m_SkipSeqCheck = skip; }
153 
154  /// Set range for all sequences
155  /// @param r range to use [in]
156  void SetRange(const TSeqRange& r) { m_Range = r; }
157  /// Set range for all sequences
158  /// @return range to modify
159  TSeqRange& SetRange(void) { return m_Range; }
160 
161  /// Get range for all sequences
162  /// @return range specified for all sequences
163  TSeqRange GetRange() const { return m_Range; }
164 
165  /// Retrieve the data loader configuration object for manipulation
166  SDataLoaderConfig& SetDataLoaderConfig() { return m_DLConfig; }
167  /// Retrieve the data loader configuration object for read-only access
168  const SDataLoaderConfig& GetDataLoaderConfig() { return m_DLConfig; }
169 
170  /// Determine if this object is for configuring reading protein sequences
171  bool IsProteinInput() const { return m_DLConfig.m_IsLoadingProteins; }
172 
173  /// True if the sequence data must be fetched
174  bool RetrieveSeqData() const { return m_RetrieveSeqData; }
175  /// Turn on or off the retrieval of sequence data
176  /// @param value true to turn on, false to turn off [in]
177  void SetRetrieveSeqData(bool value) { m_RetrieveSeqData = value; }
178 
179  /// Retrieve the local id counter initial value
180  int GetLocalIdCounterInitValue() const { return m_LocalIdCounter; }
181  /// Set the local id counter initial value
182  void SetLocalIdCounterInitValue(int val) { m_LocalIdCounter = val; }
183 
184  /// Retrieve the custom prefix string used for generating local ids
185  const string& GetLocalIdPrefix() const { return m_LocalIdPrefix; }
186  /// Set the custom prefix string used for generating local ids
187  void SetLocalIdPrefix(const string& prefix) { m_LocalIdPrefix = prefix; }
188  /// Append query-specific prefix codes to all generated local ids
189  void SetQueryLocalIdMode() {m_LocalIdPrefix = "Query_";}
190  /// Append subject-specific prefix codes to all generated local ids
191  void SetSubjectLocalIdMode() {m_LocalIdPrefix = "Subject_";}
192 
193  /// Retrieve the sequence length threshold to guess the molecule type
194  unsigned int GetSeqLenThreshold2Guess() const {
195  return m_SeqLenThreshold2Guess;
196  }
197  /// Set the sequence length threshold to guess the molecule type
198  void SetSeqLenThreshold2Guess(unsigned int val) {
199  m_SeqLenThreshold2Guess = val;
200  }
201 
202  /// Retrieve gaps to Ns converstion option value
203  bool GetConvertGapsToNs(void) const {
204  return m_GapsToNs;
205  }
206 
207  /// Turn on/off converting gaps to Ns in read FASTA sequences
208  void SetConvertGapsToNs(bool val) {
209  m_GapsToNs = val;
210  }
211 
212 private:
213  /// Strand to assign to sequences
215  /// Whether to save lowercase mask locs
217  /// Whether to parse sequence IDs
219  /// Whether to validate sequence data -RMH-
221  /// Sequence range
223  /// Configuration object for data loaders, used by CBlastInputReader
225  /// Configuration for CBlastInputReader
227  /// Initialization parameter to CSeqidGenerator
229  /// The sequence length threshold to guess molecule type
231  /// Custom prefix string passed to CSeqidGenerator
233  /// Convert gaps to Ns in FASTA sequences
235 };
236 
237 
238 
239 /// Defines user input exceptions
241 {
242 public:
243  /// Error types that reading BLAST input can generate
244  enum EErrCode {
245  eInvalidStrand, ///< Invalid strand specification
246  eSeqIdNotFound, ///< The sequence ID cannot be resolved
247  eEmptyUserInput, ///< No input was provided
248  eInvalidRange, ///< Invalid range specification
249  eSequenceMismatch, ///< Expected sequence type isn't what was expected
250  eInvalidInput ///< Invalid input data
251  };
252 
253  /// Translate from the error code value to its string representation
254  virtual const char* GetErrCodeString(void) const override {
255  switch ( GetErrCode() ) {
256  case eInvalidStrand: return "eInvalidStrand";
257  case eSeqIdNotFound: return "eSeqIdNotFound";
258  case eEmptyUserInput: return "eEmptyUserInput";
259  case eInvalidRange: return "eInvalidRange";
260  case eSequenceMismatch: return "eSequenceMismatch";
261  case eInvalidInput: return "eInvalidInput";
262  default: return CException::GetErrCodeString();
263  }
264  }
265 
266 #ifndef SKIP_DOXYGEN_PROCESSING
268 #endif /* SKIP_DOXYGEN_PROCESSING */
269 };
270 
271 
272 
273 /// Base class representing a source of biological sequences
274 ///
276 {
277 protected:
278  /// Destructor
279  ///
280  virtual ~CBlastInputSource() {}
281 
282  /// Retrieve a single sequence (in an SSeqLoc container)
283  /// @param scope CScope object to use in SSeqLoc returned [in]
284  /// @note Embedded Seq-loc returned must be of type interval or whole
285  virtual SSeqLoc GetNextSSeqLoc(CScope& scope) = 0;
286 
287  /// Retrieve a single sequence (in a CBlastSearchQuery container)
288  /// @param scope CScope object to use in CBlastSearchQuery returned [in]
289  /// @note Embedded Seq-loc returned must be of type interval or whole
291 
292  /// Signal whether there are any unread sequence left
293  /// @return true if no unread sequences remaining
294  virtual bool End() = 0;
295 
296  /// Declare CBlastInput as a friend
297  friend class CBlastInput;
298 };
299 
300 
301 /// Generalized converter from an abstract source of
302 /// biological sequence data to collections of blast input
304 {
305 public:
306 
307  /// Constructor
308  /// @param source Pointer to abstract source of sequences
309  /// @param batch_size A hint specifying how many letters should
310  /// be in a batch of converted sequences
311  ///
313  : m_Source(source), m_BatchSize(batch_size), m_NumSeqs(0), m_TotalLength(0) {}
314 
315  /// Destructor
316  ///
318 
319  /// Read and convert all the sequences from the source
320  /// @param scope CScope object to use in return value [in]
321  /// @return The converted sequences
322  ///
323  TSeqLocVector GetAllSeqLocs(CScope& scope);
324 
325  /// Read and convert all the sequences from the source
326  /// @param scope CScope object to use in return value [in]
327  /// @return The converted sequences
328  ///
329  CRef<CBlastQueryVector> GetAllSeqs(CScope& scope);
330 
331  /// Read and convert the next batch of sequences
332  /// @param scope CScope object to use in return value [in]
333  /// @return The next batch of sequence. The size of the batch is
334  /// either all remaining sequences, or the size of sufficiently
335  /// many whole sequences whose combined size exceeds m_BatchSize,
336  /// whichever is smaller
337  ///
338  TSeqLocVector GetNextSeqLocBatch(CScope& scope);
339 
340  /// Read and convert the next batch of sequences
341  /// @param scope CScope object to use in return value [in]
342  /// @return The next batch of sequence. The size of the batch is
343  /// either all remaining sequences, or the size of sufficiently
344  /// many whole sequences whose combined size exceeds m_BatchSize,
345  /// whichever is smaller
346  ///
347  CRef<CBlastQueryVector> GetNextSeqBatch(CScope& scope);
348 
349  /// Retrieve the target size of a batch of sequences
350  /// @return The current batch size
351  ///
352  TSeqPos GetBatchSize() const { return m_BatchSize; }
353 
354  /// Set the target size of a batch of sequences
355  void SetBatchSize(TSeqPos batch_size) { m_BatchSize = batch_size; }
356 
357  /// Determine if we have reached the end of the BLAST input
358  bool End() { return m_Source->End(); }
359 
360  Int8 GetNumSeqsProcessed() const { return m_NumSeqs; }
361  Int8 GetTotalLengthProcessed() const { return m_TotalLength; }
362 private:
363  CRef<CBlastInputSource> m_Source; ///< pointer to source of sequences
364  TSeqPos m_BatchSize; ///< total size of one block of sequences
365 
366  /// Prohibit copy constructor
367  CBlastInput(const CBlastInput& rhs);
368 
369  /// Prohibit assignment operator
370  CBlastInput& operator=(const CBlastInput& rhs);
371 
372  /// Perform the actual copy for assignment operator and copy constructor
373  void do_copy(const CBlastInput& input);
374 
375  // # of seqs processed
377 
378  // Total length processed
380 };
381 
382 /// Auxiliary class for creating Bioseqs given SeqIds
384 {
385 public:
386  /// Constructor
387  /// @param scope scope object to use as a source for sequence data [in]
388  ///
389  CBlastBioseqMaker(CRef<CScope> scope) : m_scope(scope) {}
390 
391  /// Creates a Bioseq given a SeqId
392  /// @param id Reference to the SeqId object identifying the sequence [in]
393  /// @param retrieve_seq_data When gis/accessions are provided in the input,
394  /// should the sequence data be fetched by this library?
395  /// @return The newly created Bioseq object
396  ///
397  CRef<CBioseq> CreateBioseqFromId(CConstRef<CSeq_id> id,
398  bool retrieve_seq_data);
399 
400  /// Checks the molecule type of the Bioseq identified by the given SeqId
401  /// @param id Reference to the SeqId object identifying the sequence [in]
402  /// @return True if the molecule type is protein
403  ///
404  bool IsProtein(CConstRef<CSeq_id> id);
405 
406  /// Checks whether the Bioseq actually contains sequence.
407  /// E.g., master WGS accessions have no sequence.
408  /// @param id Reference to the SeqId object identifying the sequence [in]
409  /// @return True if there is sequence.
410  ///
411  bool HasSequence(CConstRef<CSeq_id> id);
412 
413  /// Returns true if the Bioseq contained in the seq_entry is empty (i.e.:
414  /// it was created by this class)
415  /// @param bioseq Bioseq object to inspect [in]
416  static bool IsEmptyBioseq(const CBioseq& bioseq);
417 
418 private:
419  /// Scope object used to retrieve the bioseqs
421 };
422 
423 
425 {
426 public:
428 
429 protected:
430  /// Get one sequence (or a pair for NGS reads)
431  /// @param bioseq_set Read sequences will be appended there [in|out]
432  /// @return Number of bases read
433  virtual int GetNextSequence(CBioseq_set& bioseq_set) = 0;
434 
435  virtual bool End(void) = 0;
436 
437  friend class CBlastInputOMF;
438 };
439 
440 
442 {
443 public:
445  TSeqPos batch_size);
446 
447  void GetNextSeqBatch(CBioseq_set& bioseq_set);
448  CRef<CBioseq_set> GetNextSeqBatch(void);
449 
450  void SetBatchSize(TSeqPos num) {m_BatchSize = num;}
451  TSeqPos GetBatchSize(void) const {return m_BatchSize;}
452 
453  void SetMaxBatchNumSeqs(TSeqPos num) {m_MaxNumSequences = num;}
454  TSeqPos GetMaxBatchNumSeqs(void) const {return m_MaxNumSequences;}
455 
456  bool End(void) {return m_Source->End();}
457 
458  Int8 GetNumSeqsProcessed() const { return m_NumSeqs; }
459  Int8 GetTotalLengthProcessed() const { return m_TotalLength; }
460 
461 private:
464 
469 
470  // # of seqs processed
472 
473  // Total length processed
475 };
476 
477 END_SCOPE(blast)
479 
480 #endif /* ALGO_BLAST_BLASTINPUT___BLAST_INPUT__HPP */
Declares CBlastScopeSource class to create properly configured CScope objects to invoke the BLAST dat...
ncbi::TMaskedQueryRegions mask
Auxiliary class for creating Bioseqs given SeqIds.
CRef< CScope > m_scope
Scope object used to retrieve the bioseqs.
CBlastBioseqMaker(CRef< CScope > scope)
Constructor.
CBlastInputOMF & operator=(const CBlastInputOMF &rhs)
bool End(void)
CBlastInputOMF(const CBlastInputOMF &rhs)
TSeqPos m_MaxNumSequences
TSeqPos GetBatchSize(void) const
CBlastInputSourceOMF * m_Source
CRef< CBioseq_set > m_BioseqSet
void SetMaxBatchNumSeqs(TSeqPos num)
Int8 GetTotalLengthProcessed() const
Int8 GetNumSeqsProcessed() const
void SetBatchSize(TSeqPos num)
TSeqPos m_BatchSize
TSeqPos GetMaxBatchNumSeqs(void) const
Class that centralizes the configuration data for sequences to be converted.
Definition: blast_input.hpp:48
void SetConvertGapsToNs(bool val)
Turn on/off converting gaps to Ns in read FASTA sequences.
void SetLocalIdCounterInitValue(int val)
Set the local id counter initial value.
TSeqRange GetRange() const
Get range for all sequences.
bool GetConvertGapsToNs(void) const
Retrieve gaps to Ns converstion option value.
bool m_LowerCaseMask
Whether to save lowercase mask locs.
void SetRetrieveSeqData(bool value)
Turn on or off the retrieval of sequence data.
objects::ENa_strand m_Strand
Strand to assign to sequences.
void SetSkipSeqCheck(bool skip)
Turn validation of sequence on/off.
bool m_GapsToNs
Convert gaps to Ns in FASTA sequences.
bool m_BelieveDeflines
Whether to parse sequence IDs.
TSeqRange m_Range
Sequence range.
unsigned int m_SeqLenThreshold2Guess
The sequence length threshold to guess molecule type.
const string & GetLocalIdPrefix() const
Retrieve the custom prefix string used for generating local ids.
void SetLowercaseMask(bool mask)
Turn lowercase masking on/off.
~CBlastInputSourceConfig()
Destructor.
void SetLocalIdPrefix(const string &prefix)
Set the custom prefix string used for generating local ids.
void SetSubjectLocalIdMode()
Append subject-specific prefix codes to all generated local ids.
void SetRange(const TSeqRange &r)
Set range for all sequences.
objects::ENa_strand GetStrand() const
Retrieve the current strand value.
void SetBelieveDeflines(bool believe)
Turn parsing of sequence IDs on/off.
bool IsProteinInput() const
Determine if this object is for configuring reading protein sequences.
void SetSeqLenThreshold2Guess(unsigned int val)
Set the sequence length threshold to guess the molecule type.
void SetStrand(objects::ENa_strand strand)
Set the strand to a specified value.
bool m_SkipSeqCheck
Whether to validate sequence data -RMH-.
int m_LocalIdCounter
Initialization parameter to CSeqidGenerator.
int GetLocalIdCounterInitValue() const
Retrieve the local id counter initial value.
const SDataLoaderConfig & GetDataLoaderConfig()
Retrieve the data loader configuration object for read-only access.
bool GetBelieveDeflines() const
Retrieve current sequence ID parsing status.
bool m_RetrieveSeqData
Configuration for CBlastInputReader.
string m_LocalIdPrefix
Custom prefix string passed to CSeqidGenerator.
unsigned int GetSeqLenThreshold2Guess() const
Retrieve the sequence length threshold to guess the molecule type.
SDataLoaderConfig m_DLConfig
Configuration object for data loaders, used by CBlastInputReader.
SDataLoaderConfig & SetDataLoaderConfig()
Retrieve the data loader configuration object for manipulation.
bool GetSkipSeqCheck() const
Retrieve status of sequence alphabet validation.
bool GetLowercaseMask() const
Retrieve lowercase mask status.
bool RetrieveSeqData() const
True if the sequence data must be fetched.
TSeqRange & SetRange(void)
Set range for all sequences.
void SetQueryLocalIdMode()
Append query-specific prefix codes to all generated local ids.
virtual ~CBlastInputSourceOMF()
virtual bool End(void)=0
virtual int GetNextSequence(CBioseq_set &bioseq_set)=0
Get one sequence (or a pair for NGS reads)
Base class representing a source of biological sequences.
virtual CRef< CBlastSearchQuery > GetNextSequence(CScope &scope)=0
Retrieve a single sequence (in a CBlastSearchQuery container)
virtual bool End()=0
Signal whether there are any unread sequence left.
virtual SSeqLoc GetNextSSeqLoc(CScope &scope)=0
Retrieve a single sequence (in an SSeqLoc container)
virtual ~CBlastInputSource()
Destructor.
Generalized converter from an abstract source of biological sequence data to collections of blast inp...
~CBlastInput()
Destructor.
Int8 GetNumSeqsProcessed() const
TSeqPos GetBatchSize() const
Retrieve the target size of a batch of sequences.
CBlastInput(CBlastInputSource *source, int batch_size=kMax_Int)
Constructor.
Int8 m_TotalLength
bool End()
Determine if we have reached the end of the BLAST input.
void SetBatchSize(TSeqPos batch_size)
Set the target size of a batch of sequences.
CRef< CBlastInputSource > m_Source
pointer to source of sequences
Int8 GetTotalLengthProcessed() const
TSeqPos m_BatchSize
total size of one block of sequences
Defines user input exceptions.
NCBI_EXCEPTION_DEFAULT(CInputException, CException)
EErrCode
Error types that reading BLAST input can generate.
@ eInvalidStrand
Invalid strand specification.
@ eSequenceMismatch
Expected sequence type isn't what was expected.
@ eInvalidRange
Invalid range specification.
@ eEmptyUserInput
No input was provided.
@ eSeqIdNotFound
The sequence ID cannot be resolved.
virtual const char * GetErrCodeString(void) const override
Translate from the error code value to its string representation.
CObject –.
Definition: ncbiobj.hpp:180
CRef –.
Definition: ncbiobj.hpp:618
CScope –.
Definition: scope.hpp:92
Include a standard set of the NCBI C++ Toolkit most basic headers.
unsigned int TSeqPos
Type for sequence locations and lengths.
Definition: ncbimisc.hpp:875
CException & operator=(const CException &)
Private assignment operator to prohibit assignment.
TErrCode GetErrCode(void) const
Get error code.
Definition: ncbiexpt.cpp:453
virtual const char * GetErrCodeString(void) const
Get error code interpreted as text.
Definition: ncbiexpt.cpp:444
#define kMax_Int
Definition: ncbi_limits.h:184
int64_t Int8
8-byte (64-bit) signed integer
Definition: ncbitype.h:104
CRange< TSeqPos > TSeqRange
typedefs for sequence ranges
Definition: range.hpp:419
#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_BLASTINPUT_EXPORT
Definition: ncbi_export.h:336
ENa_strand
strand of nucleic acid
Definition: Na_strand_.hpp:64
@ eNa_strand_other
Definition: Na_strand_.hpp:70
static int input()
range(_Ty, _Ty) -> range< _Ty >
const GenericPointer< typename T::ValueType > T2 value
Definition: pointer.h:1227
const CharType(& source)[N]
Definition: pointer.h:1149
T max(T x_, T y_)
double r(size_t dimension_, const Int4 *score_, const double *prob_, double theta_)
static const char * prefix[]
Definition: pcregrep.c:405
Definition of SSeqLoc structure.
vector< SSeqLoc > TSeqLocVector
Vector of sequence locations.
Definition: sseqloc.hpp:129
Configuration structure for the CBlastScopeSource.
Structure to represent a single sequence to be fed to BLAST.
Definition: sseqloc.hpp:47
Modified on Sun Jul 21 04:14:40 2024 by modify_doxy.py rev. 669887