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

Go to the SVN repository for this file.

1 /* $Id: blast_aux.hpp 91349 2020-10-15 17:50:28Z camacho $
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_aux.hpp
31 /// Contains C++ wrapper classes to structures in algo/blast/core as well as
32 /// some auxiliary functions to convert CSeq_loc to/from BlastMask structures.
33 
34 #ifndef ALGO_BLAST_API___BLAST_AUX__HPP
35 #define ALGO_BLAST_API___BLAST_AUX__HPP
36 
37 #include <corelib/ncbistd.hpp>
38 #include <corelib/ddumpable.hpp>
39 #include <corelib/ncbifile.hpp>
40 #include <corelib/metareg.hpp>
44 #include <util/range.hpp> // For TSeqRange
47 #include <objmgr/scope.hpp>
48 
49 // BLAST includes
55 #include <algo/blast/core/blast_filter.h> // Needed for BlastMaskLoc & BlastSeqLoc
61 
62 
64 
66  class CSeq_loc;
67  class CPacked_seqint;
69 
70 template <>
72 {
73  static void Delete(BlastHSPStream* p)
74  { BlastHSPStreamFree(p); }
75 };
76 
77 /** @addtogroup AlgoBlast
78  *
79  * @{
80  */
81 
82 BEGIN_SCOPE(blast)
83 
84 /* Convenience typedef's for common types used in BLAST to implement the RAII
85  * idiom.
86  */
87 
88 /// Uses C Deleter (free) - used in functions that deal with CORE BLAST
89 #define TYPEDEF_AUTOPTR_CDELETER(type) \
90 typedef AutoPtr<type, CDeleter<type> > TAuto ## type ## Ptr
91 
92 /// Uses delete [] operator - for C++ arrays
93 #define TYPEDEF_AUTOPTR_ARRAYDELETER(type) \
94 typedef AutoPtr<type, ArrayDeleter<type> > TAuto ## type ## ArrayPtr
95 
96 #ifndef SKIP_DOXYGEN_PROCESSING
97 /// Declares TAutoUint1Ptr (for Uint1 arrays allocated with malloc/calloc)
99 /// Declares TAutoCharPtr (for Char arrays allocated with malloc/calloc)
101 /// Declares TAutoUint1ArrayPtr (for Uint1 arrays allocated with new[])
103 #endif
104 
105 /// Returns a string program name, given a blast::EBlastProgramType enumeration.
106 /// @param program Enumerated program value [in]
107 /// @return String program name.
110 
111 /** Converts a CSeq_loc into a BlastSeqLoc structure used in NewBlast
112  * @param slp CSeq_loc to convert [in]
113  * @return Linked list of BlastSeqLoc structures
114  */
117 CSeqLoc2BlastSeqLoc(const objects::CSeq_loc* slp);
118 
119 /** Retrieves the requested genetic code in Ncbistdaa format.
120  * @param genetic_code numeric identifier for genetic code requested [in]
121  * @return NULL if genetic_code is invalid or in case of memory allocation
122  * failure, otherwise genetic code string.
123  * @note the returned string has length GENCODE_STRLEN
124  */
127 FindGeneticCode(int genetic_code);
128 
129 /** Function object to assist in finding all CSeqLocInfo objects which
130  * corresponds to a given frame.
131  */
133 {
134 public:
135  /// Convenience typedef
138  typedef bool result_type;
139 
140  /// ctor
141  /// @param frame the translation frame [in]
143 
144  /// Returns true if its argument's frame corresponds to the one used to
145  /// create this object
146  /// @param seqlocinfo the object to examine [in]
147  result_type operator() (argument_type& seqlocinfo) const {
148  if (seqlocinfo.Empty()) {
149  NCBI_THROW(CBlastException, eInvalidArgument,
150  "Empty CRef<CSeqLocInfo>!");
151  }
152  return (seqlocinfo->GetFrame() == m_Frame) ? true : false;
153  }
154 private:
155  ETranslationFrame m_Frame; ///< Frame to look for
156 };
157 
158 /// Returns true if the CSeq_id is a local id
159 /// @param seqid Sequence identifier to examine [in]
160 /// @return if seqid is NULL or if it is NOT a local id, it returns false
162 bool IsLocalId(const objects::CSeq_id* seqid);
163 
164 /// Auxiliary function to convert a Seq-loc describing masked query regions to a
165 /// TMaskedQueryRegions object
166 /// @param sloc Seq-loc to use as source (must be Packed-int or Seq-int) [in]
167 /// @param program BLAST program type [in]
168 /// @param assume_both_strands ignores the strand of sloc_in and adds masking
169 /// locations to both strands in return value. This is irrelevant for protein
170 /// queries
171 /// @return List of masked query regions.
172 /// @throws CBlastException if Seq-loc type cannot be converted to Packed-int
176  EBlastProgramType program,
177  bool assume_both_strands = false);
178 
179 /// Interface to build a CSeq-loc from a TMaskedQueryRegion; note that
180 /// conversion conversion in this direction can be lossy.
181 /// It might be better to convert the calling code to use a CBlastQueryVector.
185 
187 {
188  bool operator() (const CConstRef<objects::CSeq_id>& a, const CConstRef<objects::CSeq_id>& b) const {
189  if (a.Empty() && b.NotEmpty()) {
190  return true;
191  } else if (a.NotEmpty() && b.Empty()) {
192  return false;
193  } else if (a.Empty() && b.Empty()) {
194  return true;
195  } else {
196  _ASSERT(a.NotEmpty() && b.NotEmpty());
197  return *a < *b;
198  }
199  }
200 };
201 
202 /// This method retrieve sequence data in bulk to scope
203 /// @ids seq id list [in]
204 /// @ranges seq range list [in]
205 /// @scope sconfigured with data loader for retrieving seqs [in] | retrieved bioseqs [out]
207 void
208 LoadSequencesToScope(objects::CScope::TIds& ids, vector<TSeqRange>& ranges, CRef<objects::CScope> & scope);
209 
210 /// Converts a BlastMaskLoc internal structure into an object returned by the
211 /// C++ API.
212 /// @param program Type of BLAST program [in]
213 /// @param queries Container of query ids and start/stop locations [in]
214 /// @param mask All masking locations [in]
215 /// @param mask_v Vector of per-query lists of mask locations in CSeqLocInfo
216 /// form. [out]
218 void
220  const objects::CPacked_seqint& queries,
221  const BlastMaskLoc* mask,
222  TSeqLocInfoVector& mask_v);
223 
224 /** Initializes and uninitializes the genetic code singleton as if it was an
225  * automatic variable (to facilitate use in our unit tests and in the
226  * CBlastOptions object). It also provides MT-safety. */
228 public:
229  /// Default constructor
230  /// @param genetic_code Integer representing the genetic code, if 0 is
231  /// passed the default BLAST_GENETIC_CODE will be used [in]
232  /// @sa BLAST_GENETIC_CODE
233  CAutomaticGenCodeSingleton(int genetic_code = 0);
234  /// Add the genetic code to the genetic code singleton
235  /// @param genetic_code Integer representing the genetic code [in]
236  void AddGeneticCode(int genetic_code);
237  /// destructor
239 private:
240 
241  /// Reference counter for this object so that the genetic code singleton is
242  //not deleted prematurely
245 };
246 
247 /// Class to capture message from diag handler
249 {
250 public:
251  /// Constructor
252  CBlastAppDiagHandler():m_handler(GetDiagHandler(true)), m_save (true) {}
253  /// Destructor
255  /// Save and post diag message
256  virtual void Post (const SDiagMessage & mess);
257  /// Reset messgae buffer, erase all saved message
258  void ResetMessages(void);
259  /// Call to turn off saving diag message, discard all saved message
260  void DoNotSaveMessages(void);
261  /// Return list of saved diag messages
262  list<CRef<objects::CBlast4_error> > & GetMessages(void) { return m_messages;}
263 private :
265  list<CRef<objects::CBlast4_error> > m_messages;
266  bool m_save;
267 };
268 
269 
270 /** Declares class to handle deallocating of the structure using the appropriate
271  * function
272  */
273 
274 #define DECLARE_AUTO_CLASS_WRAPPER(struct_name, free_func) \
275 /** Wrapper class for struct_name. */ \
276  \
277 class NCBI_XBLAST_EXPORT C##struct_name : public CObject \
278 { \
279 public: \
280  C##struct_name() : m_Ptr(NULL) {} \
281  C##struct_name(struct_name* p) : m_Ptr(p) {} \
282  virtual ~C##struct_name() { Reset(); } \
283  void Reset(struct_name* p = NULL) { \
284  if (m_Ptr) { \
285  free_func(m_Ptr); \
286  } \
287  m_Ptr = p; \
288  } \
289  struct_name* Release() { \
290  struct_name* retval = m_Ptr; \
291  m_Ptr = NULL; \
292  return retval; \
293  } \
294  struct_name* Get() const { return m_Ptr; } \
295  operator struct_name *() { return m_Ptr; } \
296  operator struct_name *() const { return m_Ptr; } \
297  struct_name* operator->() { return m_Ptr; } \
298  struct_name* operator->() const { return m_Ptr; } \
299  struct_name** operator&() { return &m_Ptr; } \
300  virtual void DebugDump(CDebugDumpContext ddc, unsigned int depth) const;\
301 private: \
302  struct_name* m_Ptr; \
303 }
304 
305 #ifndef SKIP_DOXYGEN_PROCESSING
306 
307 /* Don't forget to define DebugDump for each of these in blast_aux.cpp! */
308 
310 
313 
316 
321 
325 
329 
332 
336 
341 
344 
349 
353 
356 
358 
359 #endif /* SKIP_DOXYGEN_PROCESSING */
360 
361 END_SCOPE(blast)
363 
364 /* @} */
365 
366 #endif /* ALGO_BLAST_API___BLAST_AUX__HPP */
User-defined methods of the data storage class.
SBlastProgress * SBlastProgressFree(SBlastProgress *progress_info)
Deallocates a SBlastProgress structure.
Definition: blast_util.c:1397
Declares the BLAST exception class.
#define NCBI_XBLAST_EXPORT
NULL operations for other cases.
Definition: blast_export.h:65
Ungapped extension structures that are common to nucleotide and protein extension routines.
Blast_ExtendWord * BlastExtendWordFree(Blast_ExtendWord *ewp)
Deallocate memory for the word extension structure.
Definition: blast_extend.c:203
BLAST filtering functions.
BlastMaskLoc * BlastMaskLocFree(BlastMaskLoc *mask_loc)
Deallocate memory for a BlastMaskLoc structure as well as the BlastSeqLoc's pointed to.
Definition: blast_filter.c:789
BlastSeqLoc * BlastSeqLocFree(BlastSeqLoc *loc)
Deallocate all BlastSeqLoc objects in a chain.
Definition: blast_filter.c:737
Structures and functions prototypes used for BLAST gapped extension.
BlastGapAlignStruct * BLAST_GapAlignStructFree(BlastGapAlignStruct *gap_align)
Deallocates memory in the BlastGapAlignStruct structure.
Structures and API used for saving BLAST hits.
BlastHSPResults * Blast_HSPResultsFree(BlastHSPResults *results)
Deallocate memory for BLAST results.
Definition: blast_hits.c:3358
Declaration of ADT to save and retrieve lists of HSPs in the BLAST engine.
BlastHSPStream * BlastHSPStreamFree(BlastHSPStream *hsp_stream)
Frees the BlastHSPStream structure by invoking the destructor function set by the user-defined constr...
Blast_Message * Blast_MessageFree(Blast_Message *blast_msg)
Deallocates message memory.
Definition: blast_message.c:80
The structures and functions in blast_options.
PSIBlastOptions * PSIBlastOptionsFree(PSIBlastOptions *psi_options)
Deallocate PSI BLAST options.
BlastHitSavingOptions * BlastHitSavingOptionsFree(BlastHitSavingOptions *options)
Deallocate memory for BlastHitSavingOptions.
BlastInitialWordOptions * BlastInitialWordOptionsFree(BlastInitialWordOptions *options)
Deallocate memory for BlastInitialWordOptions.
BlastEffectiveLengthsOptions * BlastEffectiveLengthsOptionsFree(BlastEffectiveLengthsOptions *options)
Deallocate memory for BlastEffectiveLengthsOptions*.
BlastExtensionOptions * BlastExtensionOptionsFree(BlastExtensionOptions *options)
Deallocate memory for BlastExtensionOptions.
BlastDatabaseOptions * BlastDatabaseOptionsFree(BlastDatabaseOptions *db_options)
Deallocate database options.
BlastScoringOptions * BlastScoringOptionsFree(BlastScoringOptions *options)
Deallocate memory for BlastScoringOptions.
LookupTableOptions * LookupTableOptionsFree(LookupTableOptions *options)
Deallocates memory for LookupTableOptions*.
QuerySetUpOptions * BlastQuerySetUpOptionsFree(QuerySetUpOptions *options)
Deallocate memory for QuerySetUpOptions.
BlastHitSavingParameters * BlastHitSavingParametersFree(BlastHitSavingParameters *parameters)
Deallocate memory for BlastHitSavingOptions*.
BlastEffectiveLengthsParameters * BlastEffectiveLengthsParametersFree(BlastEffectiveLengthsParameters *parameters)
Deallocate memory for BlastEffectiveLengthsParameters*.
BlastInitialWordParameters * BlastInitialWordParametersFree(BlastInitialWordParameters *parameters)
Deallocate memory for BlastInitialWordParameters.
BlastExtensionParameters * BlastExtensionParametersFree(BlastExtensionParameters *parameters)
Deallocate memory for BlastExtensionParameters.
BlastScoringParameters * BlastScoringParametersFree(BlastScoringParameters *parameters)
Deallocate memory for BlastScoringParameters.
EBlastProgramType
Defines the engine's notion of the different applications of the BLAST algorithm.
Definition: blast_program.h:72
High level definitions and declarations for the PSSM engine of PSI-BLAST.
PSIDiagnosticsResponse * PSIDiagnosticsResponseFree(PSIDiagnosticsResponse *diags)
Deallocates the PSIDiagnosticsResponse structure passed in.
Definition: blast_psi.c:717
PSIMatrix * PSIMatrixFree(PSIMatrix *matrix)
Deallocates the PSIMatrix structure passed in.
Definition: blast_psi.c:569
PSIMsa * PSIMsaFree(PSIMsa *msa)
Deallocates the PSIMsa structure.
Definition: blast_psi.c:513
PSIDiagnosticsRequest * PSIDiagnosticsRequestFree(PSIDiagnosticsRequest *diags_request)
Deallocates the PSIDiagnosticsRequest structure passed in.
Definition: blast_psi.c:611
Definitions and functions associated with the BlastQueryInfo structure.
BlastQueryInfo * BlastQueryInfoFree(BlastQueryInfo *query_info)
Deallocate memory for query information structure.
BlastSeqSrcIterator * BlastSeqSrcIteratorFree(BlastSeqSrcIterator *itr)
Frees the BlastSeqSrcIterator structure.
Definition: blast_seqsrc.c:412
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
BlastScoreBlk * BlastScoreBlkFree(BlastScoreBlk *sbp)
Deallocates BlastScoreBlk as well as all associated structures.
Definition: blast_stat.c:965
Definitions of special type used in BLAST.
Various auxiliary BLAST utility functions.
BLAST_SequenceBlk * BlastSequenceBlkFree(BLAST_SequenceBlk *seq_blk)
Deallocate memory for a sequence block.
Definition: blast_util.c:245
ncbi::TMaskedQueryRegions mask
Initializes and uninitializes the genetic code singleton as if it was an automatic variable (to facil...
Definition: blast_aux.hpp:227
Class to capture message from diag handler.
Definition: blast_aux.hpp:249
Defines BLAST error codes (user errors included)
Function object to assist in finding all CSeqLocInfo objects which corresponds to a given frame.
Definition: blast_aux.hpp:133
int GetFrame() const
Definition: seqlocinfo.hpp:79
Collection of masked regions for a single query sequence.
Definition: seqlocinfo.hpp:113
Include a standard set of the NCBI C++ Toolkit most basic headers.
#define true
Definition: bool.h:35
void Blast_GetSeqLocInfoVector(EBlastProgramType program, const objects::CPacked_seqint &queries, const BlastMaskLoc *mask, TSeqLocInfoVector &mask_v)
Converts a BlastMaskLoc internal structure into an object returned by the C++ API.
Definition: blast_aux.cpp:904
CBlastAppDiagHandler()
Constructor.
Definition: blast_aux.hpp:252
BlastSeqLoc * CSeqLoc2BlastSeqLoc(const objects::CSeq_loc *slp)
Converts a CSeq_loc into a BlastSeqLoc structure used in NewBlast.
Definition: blast_aux.cpp:539
TMaskedQueryRegions PackedSeqLocToMaskedQueryRegions(CConstRef< objects::CSeq_loc > sloc, EBlastProgramType program, bool assume_both_strands=false)
Auxiliary function to convert a Seq-loc describing masked query regions to a TMaskedQueryRegions obje...
#define DECLARE_AUTO_CLASS_WRAPPER(struct_name, free_func)
Declares class to handle deallocating of the structure using the appropriate function.
Definition: blast_aux.hpp:274
result_type operator()(argument_type &seqlocinfo) const
Returns true if its argument's frame corresponds to the one used to create this object.
Definition: blast_aux.hpp:147
TAutoUint1ArrayPtr FindGeneticCode(int genetic_code)
Retrieves the requested genetic code in Ncbistdaa format.
Definition: blast_aux.cpp:588
const CRef< CSeqLocInfo > argument_type
Definition: blast_aux.hpp:137
ETranslationFrame m_Frame
Frame to look for.
Definition: blast_aux.hpp:155
#define TYPEDEF_AUTOPTR_ARRAYDELETER(type)
Uses delete [] operator - for C++ arrays.
Definition: blast_aux.hpp:93
bool IsLocalId(const objects::CSeq_id *seqid)
Returns true if the CSeq_id is a local id.
Definition: blast_aux.cpp:1094
#define TYPEDEF_AUTOPTR_CDELETER(type)
Uses C Deleter (free) - used in functions that deal with CORE BLAST.
Definition: blast_aux.hpp:89
bool result_type
Definition: blast_aux.hpp:138
CFrameFinder(ETranslationFrame frame)
ctor
Definition: blast_aux.hpp:142
CRef< objects::CSeq_loc > MaskedQueryRegionsToPackedSeqLoc(const TMaskedQueryRegions &sloc)
Interface to build a CSeq-loc from a TMaskedQueryRegion; note that conversion conversion in this dire...
CSeqLocInfo::ETranslationFrame ETranslationFrame
Convenience typedef.
Definition: blast_aux.hpp:136
DECLARE_CLASS_STATIC_FAST_MUTEX(sm_Mutex)
Reference counter for this object so that the genetic code singleton is.
string Blast_ProgramNameFromType(EBlastProgramType program)
Returns a string program name, given a blast::EBlastProgramType enumeration.
Definition: blast_aux.cpp:813
void LoadSequencesToScope(objects::CScope::TIds &ids, vector< TSeqRange > &ranges, CRef< objects::CScope > &scope)
This method retrieve sequence data in bulk to scope @ids seq id list [in] @ranges seq range list [in]...
CDiagHandler * m_handler
Definition: blast_aux.hpp:264
list< CRef< objects::CBlast4_error > > m_messages
Definition: blast_aux.hpp:265
static void Delete(BlastHSPStream *p)
Definition: blast_aux.hpp:73
list< CRef< objects::CBlast4_error > > & GetMessages(void)
Return list of saved diag messages.
Definition: blast_aux.hpp:262
CDiagHandler * GetDiagHandler(bool take_ownership=false, bool *current_ownership=0)
Get the currently set diagnostic handler class.
Definition: ncbidiag.cpp:6329
#define NCBI_THROW(exception_class, err_code, message)
Generic macro to throw an exception, given the exception class, error code and message string.
Definition: ncbiexpt.hpp:704
bool Empty(void) const THROWS_NONE
Check if CRef is empty – not pointing to any object, which means having a null value.
Definition: ncbiobj.hpp:719
uint8_t Uint1
1-byte (8-bit) unsigned integer
Definition: ncbitype.h:99
char Char
Alias for char.
Definition: ncbitype.h:93
uint32_t Uint4
4-byte (32-bit) unsigned integer
Definition: ncbitype.h:103
#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
LookupTableWrap * LookupTableWrapFree(LookupTableWrap *lookup)
Deallocate memory for the lookup table.
Definition: lookup_wrap.c:197
CMetaRegistry: Singleton class for loading CRegistry data from files; keeps track of what it loaded f...
unsigned int a
Definition: ncbi_localip.c:102
Defines classes: CDirEntry, CFile, CDir, CSymLink, CMemoryFile, CFileUtil, CFileLock,...
vector< TMaskedQueryRegions > TSeqLocInfoVector
Collection of masked regions for all queries in a BLAST search.
Definition: seqlocinfo.hpp:139
Structure to hold a sequence.
Definition: blast_def.h:242
Options used to create the ReadDBFILE structure Include database name and various information for res...
Options for setting up effective lengths and search spaces.
Parameters for setting up effective lengths and search spaces.
Options used for gapped extension These include: a.
Computed values used as parameters for gapped alignments.
Structure supporting the gapped alignment.
The structure to contain all BLAST results, for multiple queries.
Definition: blast_hits.h:183
Default implementation of BlastHSPStream.
Options used when evaluating and saving hits These include: a.
Parameter block that contains a pointer to BlastHitSavingOptions and the values derived from it.
Options needed for initial word finding and processing.
Parameter block that contains a pointer to BlastInitialWordOptions and the values derived from it.
Structure for keeping the query masking information.
Definition: blast_def.h:210
The query related information.
Structure used for scoring calculations.
Definition: blast_stat.h:177
Scoring options block Used to produce the BlastScoreBlk structure This structure may be needed for lo...
Scoring parameters block Contains scoring-related information that is actually used for the blast sea...
Used to hold a set of positions, mostly used for filtering.
Definition: blast_def.h:204
Complete type definition of Blast Sequence Source Iterator.
Complete type definition of Blast Sequence Source ADT.
Definition: blast_seqsrc.c:43
Structure for keeping initial word extension information.
Definition: blast_extend.h:109
Structure to hold the a message from the core of the BLAST engine.
Definition: blast_message.h:70
Functor template for deleting object.
Definition: ncbimisc.hpp:349
Options needed to construct a lookup table Also needed: query sequence and query length.
Wrapper structure for different types of BLAST lookup tables.
Definition: lookup_wrap.h:50
Options used in protein BLAST only (PSI, PHI, RPS and translated BLAST) Some of these possibly should...
Structure to allow requesting various diagnostics data to be collected by PSSM engine.
Definition: blast_psi.h:181
This structure contains the diagnostics information requested using the PSIDiagnosticsRequest structu...
Definition: blast_psi.h:201
This is the main return value from the PSSM engine.
Definition: blast_psi.h:150
Multiple sequence alignment (msa) data structure containing the raw data needed by the PSSM engine to...
Definition: blast_psi.h:75
Options required for setting up the query sequence.
Progress monitoring structure.
Definition: blast_def.h:341
SDiagMessage –.
Definition: ncbidiag.hpp:1599
#define _ASSERT
void AddGeneticCode(CSeq_feat &cds, CGenetic_code::C_E::TId code_id)
Modified on Sun Apr 21 03:43:33 2024 by modify_doxy.py rev. 669887