| __Enter__ | |
| _Alloc_traits< _Tp, _Allocator > | |
| CObjectList::_CColumn | |
| _character_set_alias | |
| _Const_traits< _Tp > | |
| bm::_copyright< T > | Internal structure |
| _Cor_Def | |
| _cs_blkdesc | |
| _cs_clientmsg | |
| _cs_command | |
| _cs_command_list | |
| _cs_config | |
| _cs_connection | |
| _cs_context | |
| _cs_datafmt | |
| _cs_daterec | |
| _cs_datetime | |
| _cs_datetime4 | |
| _cs_dynamic | |
| _cs_iodesc | |
| _cs_locale | |
| _cs_money | |
| _cs_money4 | |
| _cs_numeric | |
| _cs_objdata | |
| _cs_objname | |
| _cs_param | |
| _cs_servermsg | |
| _cs_varbinary | |
| _cs_varchar | |
| _csremote_proc | |
| _ct_colinfo | |
| _Cur_Aln | |
| _Cur_Loc | |
| _Cxl_Als | |
| _Cxl_Los | |
| _dblib_error_message | |
| _DBREMOTE_PROC | |
| _DBREMOTE_PROC_PARAM | |
| _dheader | |
| _drecord | |
| _Fld_Mtf | |
| _Gib_Scd | |
| _Hashtable_iterator< _Val, _Key, _HF, _ExK, _EqK, _All > | |
| _Hashtable_node< _Val > | |
| _hcattr | |
| _hchk | |
| _hdbc | |
| _hdesc | |
| _heattr | |
| _henv | |
| _hsattr | |
| _hstmt | |
| _Ht_iterator< _Val, _Traits, _Key, _HF, _ExK, _EqK, _All > | |
| _InputPeak | Struct for holding a single peak |
| _M_node_allocator_type | |
| _MassMask | |
| _MassPeak | |
| _MODULEINFO | |
| _Nonconst_traits< _Tp > | |
| _pbcb | |
| _PSIAlignedBlock | This structure keeps track of the regions aligned between the query sequence and those that were not purged |
| _PSIAlignmentTraits | Auxiliary structure to maintain information about two aligned regions between the query and a subject sequence |
| _PSIInternalPssmData | Internal representation of a PSSM in various stages of its creation and its dimensions |
| _PSIMsa | Internal multiple alignment data structure used by the PSSM engine |
| _PSIMsaCell | Internal data structure to represent a position in the multiple sequence alignment data structure |
| _PSIPackedMsa | Compact version of PSIMsa structure |
| _PSIPackedMsaCell | Compact version of the PSIMsaCell structure |
| _PSISequenceWeights | Internal data structure to keep computed sequence weights |
| _Qry_Seq | |
| _Rcx_Ptl | |
| pcrecpp::_RE_MatchObject< T > | |
| _Rnd_Smp | |
| _Seg_Cmp | |
| _Seg_Gsm | |
| _Seg_Nsm | |
| _Seg_Ord | |
| _Seq_Mtf | |
| _sql_error | |
| _sql_errors | |
| _Stl_prime< _Tp > | |
| _STLP_alloc_proxy< _Value, _Tp, _MaybeReboundAlloc > | |
| _tds_bcpcoldata | |
| _tds_compiletime_settings | A structure to hold all the compile-time settings |
| _tds_cursor | |
| _tds_cursor_status | |
| _tds_encoding | Information relevant to libiconv |
| _tds_errno_message_flags | |
| _Thd_Cxe | |
| _Thd_Gsm | |
| _Thd_Tbl | |
| _Thd_Tst | |
| AaLookupBackboneCell | Structure defining one cell of the compacted lookup table |
| AaLookupSmallboneCell | Structure defining one cell of the small (i.e., use short) lookup table |
| AalookupTestFixture | A general lookup table for the test |
| AascanTestFixture | The test fixture to use for all test cases in this file |
| AbstractLexer | |
| AbstractParser | |
| AbstractToken | |
| CBinsGlyph::accum_study | |
| CGwasGlyph::accum_study | |
| AddRemoveIdEditAction< add > | |
| AddRemoveIdEditAction< false > | |
| AdvancedProteinOptionsHandleFixture | |
| xml::impl::ait_impl | Class that does all the work behind xml::attributes::iterator and xml::attributes::const_iterator |
| ALICORD | |
| IBISAnnotateDialog::AlignAnnotInfo | |
| AlignedDM | |
| AlignmentCollection | |
| AlignmentDisplay | |
| AlignmentFeature | |
| AlignmentManager | |
| AlignmentSet | |
| AlignmentUtility | |
| AlignSeqOrder | |
| bm::all_set< T > | Structure carries pointer on bit block with all bits 1 |
| bm::all_set< T >::all_set_block | |
| AllCutoffScores | |
| CVecscreen::AlnInfo | Match info |
| alp | |
| alp_data | |
| alp_reg | |
| alp_sim | |
| Alpha | Information about the alphabet used by seg |
| AMatrix | |
| AMatrix_base | |
| ambchar | |
| AnimationControls | |
| AnnotateDialog | |
| AnnotationEditorDialog | |
| AnnotDataResolver< CSeq_align_Handle > | |
| AnnotDataResolver< CSeq_feat_EditHandle > | |
| AnnotDataResolver< CSeq_graph_Handle > | |
| AnnotObjTrait< CSeq_align > | |
| AnnotObjTrait< CSeq_feat > | |
| AnnotObjTrait< CSeq_graph > | |
| AnyType | |
| oligofar::AOutputFormatter | |
| AppResources | |
| pcrecpp::Arg | |
| array< T > | |
| array_map< K, V, Cmp, kCapacityIncrement > | |
| array_positive< T > | |
| array_set< T, Cmp > | |
| ArrayDeleter< X > | Functor template for deleting array of objects |
| oligofar::AScoreWithParam | |
| ASNDataManager | |
| ASNInputContainerStream< ASNContainerClass, ASNElementClass > | |
| ASNIOTestApp | |
| ASNLexer | |
| AsnMemoryRead | |
| AsnMemoryWrite | |
| ASNParser | |
| AtomCoord | |
| Residue::AtomInfo | |
| AtomPntr | |
| AtomSet | |
| AtomStyle | |
| xml::attributes::attr | The xml::attributes::attr class is used to hold information about one attribute |
| xml::impl::attr_instance | |
| xml::attributes | The xml::attributes class is used to access all the attributes of one xml::node |
| CPhyloTreeCalculator::AttrKey | Structure allows us to more efficiently store and look up seq-id keys in m_AttrTable |
| auto_ptr< X > | Auto_ptr -- |
| auto_ptr< X >::auto_ptr_ref< Y > | |
| AutoArray< X, Del > | AutoArray -- |
| AutoPtr< X, Del > | AutoPtr -- |
| StyleSettings::BackboneStyle | |
| BadECNumberChar | |
| BaseTagMapper | |
| BCP_HOSTCOLINFO | |
| BCP_HOSTFILEINFO | |
| binary_function | |
| binary_functor< Type > | TEMPLATE binary functor base struct |
| BioseqInfo | |
| BioTreeBaseNode< TNodeData, TNodeFeatures > | Basic data contained in every bio-tree node |
| bm::bit_AND< W > | Bit AND functor |
| bm::bit_ASSIGN< W > | Bit ASSIGN functor |
| bm::bit_block_guard< BlocksManager > | Bit block buffer guard |
| bm::bit_COUNT< W > | Bit COUNT functor |
| bm::bit_COUNT_A< W > | Bit COUNT A functor |
| bm::bit_COUNT_AND< W > | Bit COUNT AND functor |
| bm::bit_COUNT_B< W > | Bit COUNT B functor |
| bm::bit_COUNT_OR< W > | Bit COUNT OR functor |
| bm::bit_COUNT_SUB_AB< W > | Bit COUNT SUB AB functor |
| bm::bit_COUNT_SUB_BA< W > | Bit SUB BA functor |
| bm::bit_count_table< T > | Structure to aid in counting bits table contains count of bits in 0-255 diapason of numbers |
| bm::bit_COUNT_XOR< W > | Bit COUNT XOR functor |
| bm::bit_grabber< T, BPC > | |
| bm::bit_grabber< unsigned char, 8 > | |
| bm::bit_grabber< unsigned short, 16 > | |
| bm::bit_grabber< unsigned, 32 > | |
| bm::bit_in< TDecoder > | Byte based reader for un-aligned bit streaming |
| bm::bit_OR< W > | Bit OR functor |
| bm::bit_out< TEncoder > | Byte based writer for un-aligned bit streaming |
| bm::bit_SUB< W > | Bit SUB functor |
| bm::bit_trans_grabber< T, BPC, BPS > | |
| bm::bit_XOR< W > | Bit XOR functor |
| bm::bvector< Alloc >::iterator_base::bitblock_descr | Information about current bitblock |
| bm::bitblock_get_adapter | Bit-block get adapter, takes bitblock and represents it as a get_32() accessor function /internal |
| bm::bitblock_store_adapter | Bit-block store adapter, takes bitblock and saves results into it /internal |
| bm::bitblock_sum_adapter | Bit-block sum adapter, takes values and sums it /internal |
| BitmapCharRec | |
| BitmapFontRec | |
| BitStream | |
| Blast_AminoAcidComposition | Represents the composition of an amino-acid sequence, in the ncbistdaa alphabet |
| Blast_CompositionWorkspace | Work arrays used to perform composition-based matrix adjustment |
| BLAST_DiagHash | Track initial word matches using hashing with chaining |
| BLAST_DiagTable | Structure containing parameters needed for initial word extension |
| Blast_ExtendWord | Structure for keeping initial word extension information |
| Blast_ForbiddenRanges | An instance of Blast_ForbiddenRanges is used by the Smith-Waterman algorithm to represent ranges in the database that are not to be aligned |
| Blast_GumbelBlk | Structure to hold the Gumbel parameters (for FSC) |
| Blast_KarlinBlk | Structure to hold the Karlin-Altschul parameters |
| BLAST_LetterProb | Records probability of letter appearing in sequence |
| BLAST_Matrix | |
| Blast_MatrixInfo | Information about a amino-acid substitution matrix |
| Blast_Message | Structure to hold the a message from the core of the BLAST engine |
| Blast_RedoAlignCallbacks | Callbacks used by Blast_RedoOneMatch and Blast_RedoOneMatchSmithWaterman routines |
| Blast_RedoAlignParams | A parameter block for the Blast_RedoOneMatch and Blast_RedoOneMatchSmithWaterman routines |
| Blast_ResComp | Intermediate structure to store the composition of a sequence |
| Blast_ResFreq | Stores the letter frequency of a sequence or database |
| Blast_ScoreFreq | Holds score frequencies used in calculation of Karlin-Altschul parameters for an ungapped search |
| BLAST_SequenceBlk | Structure to hold a sequence |
| BlastAaLookupTable | The basic lookup table structure for blastp searches |
| BlastCompo_Alignment | Within the composition adjustment module, an object of type BlastCompo_Alignment represents a distinct alignment of the query sequence to the current subject sequence |
| BlastCompo_GappingParams | Parameters used to compute gapped alignments |
| BlastCompo_Heap | A BlastCompo_Heap represents a collection of alignments between one query sequence and several matching subject sequences |
| BlastCompo_HeapRecord | The struct BlastCompo_HeapRecord data type is used below to define the internal structure of a BlastCompo_Heap (see below) |
| BlastCompo_MatchingSequence | A BlastCompo_MatchingSequence represents a subject sequence to be aligned with the query |
| BlastCompo_QueryInfo | Collected information about a query |
| BlastCompo_SequenceData | BlastCompo_SequenceData - represents a string of amino acids or nucleotides |
| BlastCompo_SequenceRange | BlastCompo_SequenceRange - a struct whose instances represent a range of data in a sequence |
| BlastCompressedAaLookupTable | The lookup table structure for protein searches using a compressed alphabet |
| BlastContextInfo | The context related information |
| BlastCoreAuxStruct | Structure to be passed to s_BlastSearchEngineCore, containing pointers to various preallocated structures and arrays |
| BlastDatabaseOptions | Options used to create the ReadDBFILE structure Include database name and various information for restricting the database to a subset |
| BlastdbCopyApplication | |
| BlastDiagnostics | Return statistics from the BLAST search |
| BlastEffectiveLengthsOptions | Options for setting up effective lengths and search spaces |
| BlastEffectiveLengthsParameters | Parameters for setting up effective lengths and search spaces |
| BlastEngineTestFixture | |
| BLASTer | |
| BlastExtensionOptions | Options used for gapped extension These include: a |
| BlastExtensionParameters | Computed values used as parameters for gapped alignments |
| BlastGapAlignStruct | Structure supporting the gapped alignment |
| BlastGapDP | Auxiliary structure for dynamic programming gapped extension |
| BlastGappedCutoffs | All the gapped cutoff values that can change from context to context |
| BlastGappedStats | Structure containing hit counts from the gapped stage of a BLAST search |
| BlastGapSW | Auxiliary structures for Smith-Waterman alignment with traceback |
| BlastHitList | The structure to contain all BLAST results for one query sequence |
| BlastHitSavingOptions | Options used when evaluating and saving hits These include: a |
| BlastHitSavingParameters | Parameter block that contains a pointer to BlastHitSavingOptions and the values derived from it |
| BlastHSP | Structure holding all information about an HSP |
| BlastHSPBestHitData | |
| BlastHSPBestHitOptions | Options for the Best Hit HSP collection algorithm |
| BlastHSPBestHitParams | Keeps parameters used in best hit algorithm |
| BlastHSPCollectorData | Data structure used by the writer |
| BlastHSPCollectorParams | Keeps prelim_hitlist_size and HitSavingOptions together |
| BlastHSPCullingData | The following are implementations for BlastHSPWriter ADT |
| BlastHSPCullingOptions | Options for the HSP culling algorithm |
| BlastHSPCullingParams | Keeps parameters used in best hit algorithm |
| BlastHSPFilteringOptions | Structure containing the HSP filtering/writing options |
| BlastHSPLink | The following structure is used in "link_hsps" to decide between two different "gapping" models |
| BlastHSPList | The structure to hold all HSPs for a given sequence after the gapped alignment |
| BlastHSPPipe | ADT definition of BlastHSPPipe |
| BlastHSPPipeInfo | A wrap of data structure used to create a pipe |
| BlastHSPResults | The structure to contain all BLAST results, for multiple queries |
| BlastHSPStream | Default implementation of BlastHSPStream |
| BlastHSPStreamResultBatch | Structure used to hold a collection of hits retrieved from the HSPStream |
| BlastHSPWriter | ADT definition of BlastHSPWriter |
| BlastHSPWriterInfo | A wrap of data structure used to create a writer |
| BlastInitHitList | Structure to hold all initial HSPs for a given subject sequence |
| BlastInitHSP | Structure to hold the initial HSP information |
| BlastInitialWordOptions | Options needed for initial word finding and processing |
| BlastInitialWordParameters | Parameter block that contains a pointer to BlastInitialWordOptions and the values derived from it |
| BlastIntervalTree | Main structure describing an interval tree |
| BlastKappa_GappingParamsContext | Data and data-structures needed to perform a gapped alignment |
| BlastKappa_SavedParameters | A BlastKappa_SavedParameters holds the value of certain search parameters on entry to RedoAlignmentCore |
| BlastKappa_SequenceInfo | BLAST-specific information that is associated with a BlastCompo_MatchingSequence |
| BlastLinkedHSPSet | Simple doubly linked list of HSPs, used for calculating sum statistics |
| BlastLinkHSPParameters | Parameter block for linking HSPs with sum statistics |
| BlastMaskLoc | Structure for keeping the query masking information |
| BlastMBLookupTable | The lookup table structure used for Mega BLAST |
| BlastNaLookupTable | The basic lookup table structure for blastn searches |
| BlastNuclOptionsHandleFixture | |
| BlastOffsetPair | This symbol enables the verbose option in makeblastdb and other BLAST+ search command line applications, as well as the option to submit searches to the test server in NCBI for remote BLAST searches #define _BLAST_DEBUG 1 |
| BlastQueryInfo | The query related information |
| BlastRawCutoffs | Structure holding raw cutoff and gap-x-drop values |
| BlastRPSAuxInfo | Information derived from RPS blast '.aux' file |
| BlastRPSInfo | The RPS engine uses this structure to access all of the RPS blast related data (assumed to be collected in an implementation-specific manner) |
| BlastRPSLookupFileHeader | Header of RPS blast '.loo' file |
| BlastRPSLookupTable | The basic lookup table structure for RPS blast searches |
| BlastRPSProfileHeader | Header of RPS blast '.rps' file |
| BlastScoreBlk | Structure used for scoring calculations |
| BlastScoringOptions | Scoring options block Used to produce the BlastScoreBlk structure This structure may be needed for lookup table construction (proteins only), and for evaluating alignments |
| BlastScoringParameters | Scoring parameters block Contains scoring-related information that is actually used for the blast search |
| BlastSeg | One sequence segment within an HSP |
| BlastSeqLoc | Used to hold a set of positions, mostly used for filtering |
| BlastSeqSrc | Complete type definition of Blast Sequence Source ADT |
| BlastSeqSrcGetSeqArg | Structure used as the second argument to functions satisfying the GetSeqBlkFnPtr signature, associated with index-based implementations of the BlastSeqSrc interface |
| BlastSeqSrcIterator | Complete type definition of Blast Sequence Source Iterator |
| BlastSeqSrcNewInfo | Complete type definition of the structure used to create a new BlastSeqSrc |
| BlastSeqSrcSetRangesArg | Structure used as the argument to function SetRanges |
| BlastSmallNaLookupTable | Lookup table structure for blastn searches with small queries |
| blastStr | |
| BlastUngappedCutoffs | All the ungapped cutoff values that can change from context to context |
| BlastUngappedData | Structure to hold ungapped alignment information |
| BlastUngappedStats | Structure containing hit counts from the ungapped stage of a BLAST search |
| Block | |
| bm::block_allocator | Default malloc based bitblock allocator class |
| bm::blocks_manager< Alloc >::block_any_func | Functor detects if any bit set |
| bm::blocks_manager< Alloc >::block_copy_func | Block copy functor |
| bm::blocks_manager< Alloc >::block_count_arr_func | Bitcounting functor filling the block counts array |
| bm::blocks_manager< Alloc >::block_count_base | Base class for bitcounting functors |
| bm::blocks_manager< Alloc >::block_count_change_func | Bit value change counting functor |
| bm::blocks_manager< Alloc >::block_count_func | Bitcounting functor |
| bm::bvector< Alloc >::iterator_base::block_descr | |
| bm::blocks_manager< Alloc >::block_free_func | Block deallocation functor |
| bm::blocks_manager< Alloc >::block_invert_func | Bitblock invert functor |
| bm::blocks_manager< Alloc >::block_one_func | Fill block with all-one bits functor |
| bm::blocks_manager< Alloc >::block_opt_func | |
| bm::block_set_table< T > | Structure keeps all-left/right ON bits masks |
| bm::blocks_manager< Alloc >::block_zero_func | Set block zero functor |
| BlockAligner | |
| BlockAligner::BlockAlignerOptions | |
| BlockAlignerOptionsDialog | |
| BlockBoundaryAlgorithm | |
| BlockEditingParams | |
| BlockExtender | |
| CBlockedAlignmentEditor::BlockExtensionBound | |
| BlockFormater | |
| BlockMultipleAlignment::BlockInfo | |
| BlockIntersector | |
| BlockModel | |
| BlockModelPair | |
| BlockMultipleAlignment | |
| bm::blocks_manager< Alloc > | Bitvector blocks manager Embedded class managing bit-blocks on very low level. Includes number of functor classes used in different bitset algorithms |
| bm::blocks_manager< Alloc >::bm_func_base | Base functor class (block visitor) |
| bm::blocks_manager< Alloc >::bm_func_base_const | Base functor class connected for "constant" functors |
| BMARefinerInterface | |
| BMARefinerOptions | |
| BMARefinerOptionsDialog | |
| BMAUtils | |
| bm::globals< T >::bo | |
| Bond | |
| BondStyle | |
| BoundaryShapeEllipse | BoundaryShapeEllipse -- |
| branch_chain | |
| BUF_tag | |
| bm::bv_statistics | Structure with statistical information about bitset's memory allocation details |
| bm::bvector< Alloc > | Bitvector with runtime compression of bits |
| bm::bvector_mini< A > | Bitvector class with very limited functionality |
| bm::bvmini< N > | Mini bitvector used in bvector template to keep block type flags |
| SSubString::ByLength | |
| SSubString::ByOrder | |
| CObjectIStream::ByteBlock | |
| CObjectOStream::ByteBlock | |
| bz_stream | |
| bzFile | |
| C2DLayoutEngine | Class C2DLayoutEngine defines the interface for a standard 2D layout engine |
| C2naCmp | |
| C2naExpandToIupacna | |
| C2naRevCmp | |
| C2naReverse | |
| C2naTo2naExpand | |
| C2naTo4na | |
| C2naTo8na | |
| C2naToIupacna | |
| CTreeIterator::C4Each | |
| C4naCmp | |
| C4naRevCmp | |
| C4naReverse | |
| C4naTo2na | |
| C4naTo2naExpand | |
| C4naTo8na | |
| C4naToIupacna | |
| C8naCmp | |
| C8naTo2na | |
| C8naToIupacna | |
| CCode_break_Base::C_Aa | Amino acid |
| CTrna_ext_Base::C_Aa | Aa this carries |
| CDataHandleAction_Base::C_Action | C_Action -- |
| CSeqEdit_Cmd_ReplaceAnnot_Base::C_Data::C_Align | C_Align -- |
| CPC_AssaySubmit_Base::C_Assay | Assay Description or pre-existing Identifier |
| oligofar::CPermutator8b::C_Atom | |
| CAssay_Base::C_Attlist | C_Attlist -- |
| CAssay_Base::C_Method::C_EMethod::C_Attlist | C_Attlist -- |
| CAssay_Base::C_Taxonomy::C_Attlist | C_Attlist -- |
| CAssembly_Base::C_Attlist | C_Attlist -- |
| CAssembly_Base::C_SnpStat::C_Attlist | C_Attlist -- |
| CBaseURL_Base::C_Attlist | C_Attlist -- |
| CComponent_Base::C_Attlist | C_Attlist -- |
| CExchangeSet_Base::C_Attlist | C_Attlist -- |
| CExchangeSet_Base::C_SourceDatabase::C_Attlist | C_Attlist -- |
| CExchangeSet_Base::C_Query::C_Attlist | C_Attlist -- |
| CFxnSet_Base::C_Attlist | C_Attlist -- |
| CMapLoc_Base::C_Attlist | C_Attlist -- |
| CPrimarySequence_Base::C_Attlist | C_Attlist -- |
| CRs_Base::C_Attlist | C_Attlist -- |
| CRs_Base::C_Het::C_Attlist | C_Attlist -- |
| CExchangeSet_Base::C_Summary::C_Attlist | C_Attlist -- |
| CRs_Base::C_Validation::C_Attlist | C_Attlist -- |
| CRs_Base::C_Create::C_Attlist | C_Attlist -- |
| CRs_Base::C_Update::C_Attlist | C_Attlist -- |
| CRs_Base::C_Sequence::C_Attlist | C_Attlist -- |
| CRs_Base::C_E_MergeHistory::C_Attlist | C_Attlist -- |
| CRs_Base::C_E_AlleleOrigin::C_Attlist | C_Attlist -- |
| CRs_Base::C_E_Frequency::C_Attlist | C_Attlist -- |
| CRsLinkout_Base::C_Attlist | C_Attlist -- |
| CRsStruct_Base::C_Attlist | C_Attlist -- |
| CSs_Base::C_Attlist | C_Attlist -- |
| CFFile_Base::C_Attlist | C_Attlist -- |
| CFileConfiguration_Base::C_Attlist | C_Attlist -- |
| CConfiguration_Base::C_Attlist | C_Attlist -- |
| CFilter_Base::C_Attlist | C_Attlist -- |
| CImportGroup_Base::C_Attlist | C_Attlist -- |
| CItemDefinitionGroup_Base::C_Attlist | C_Attlist -- |
| CItemGroup_Base::C_Attlist | C_Attlist -- |
| CProject_Base::C_Attlist | C_Attlist -- |
| CPropertyGroup_Base::C_Attlist | C_Attlist -- |
| CTarget_Base::C_Attlist | C_Attlist -- |
| CUsingTask_Base::C_Attlist | C_Attlist -- |
| CAffected_channel_Base::C_Attlist | C_Attlist -- |
| CAlternative_protein_Base::C_Attlist | C_Attlist -- |
| CPlatform_Base::C_Attlist | C_Attlist -- |
| CAminoacid_modification_Base::C_Attlist | C_Attlist -- |
| CAnalysis_result_Base::C_Attlist | C_Attlist -- |
| CTool_Base::C_Attlist | C_Attlist -- |
| CVisualStudioProject_Base::C_Attlist | C_Attlist -- |
| CAnalysis_summary_Base::C_Attlist | C_Attlist -- |
| CAnalysis_timestamp_Base::C_Attlist | C_Attlist -- |
| CAsapratio_contribution_Base::C_Attlist | C_Attlist -- |
| CAsapratio_lc_heavypeak_Base::C_Attlist | C_Attlist -- |
| CAsapratio_lc_lightpeak_Base::C_Attlist | C_Attlist -- |
| CAsapratio_peptide_data_Base::C_Attlist | C_Attlist -- |
| CAsapratio_result_Base::C_Attlist | C_Attlist -- |
| CAsapratio_summary_Base::C_Attlist | C_Attlist -- |
| CAsapratio_timestamp_Base::C_Attlist | C_Attlist -- |
| CData_filter_Base::C_Attlist | C_Attlist -- |
| CDataset_derivation_Base::C_Attlist | C_Attlist -- |
| CDistribution_point_Base::C_Attlist | C_Attlist -- |
| CContributing_channel_Base::C_Attlist | C_Attlist -- |
| CDatabase_refresh_timestamp_Base::C_Attlist | C_Attlist -- |
| CEnzymatic_search_constraint_Base::C_Attlist | C_Attlist -- |
| CFragment_masses_Base::C_Attlist | C_Attlist -- |
| CError_point_Base::C_Attlist | C_Attlist -- |
| CInputfile_Base::C_Attlist | C_Attlist -- |
| CIntensity_Base::C_Attlist | C_Attlist -- |
| CInteract_summary_Base::C_Attlist | C_Attlist -- |
| CLibra_result_Base::C_Attlist | C_Attlist -- |
| CLibra_summary_Base::C_Attlist | C_Attlist -- |
| CMixture_model_Base::C_Attlist | C_Attlist -- |
| CMixturemodel_distribution_Base::C_Attlist | C_Attlist -- |
| CMod_aminoacid_mass_Base::C_Attlist | C_Attlist -- |
| CModification_info_Base::C_Attlist | C_Attlist -- |
| CMsms_pipeline_analysis_Base::C_Attlist | C_Attlist -- |
| CMsms_run_summary_Base::C_Attlist | C_Attlist -- |
| CNegmodel_distribution_Base::C_Attlist | C_Attlist -- |
| CParameter_Base::C_Attlist | C_Attlist -- |
| CPeptideprophet_result_Base::C_Attlist | C_Attlist -- |
| CPeptideprophet_summary_Base::C_Attlist | C_Attlist -- |
| CPosmodel_distribution_Base::C_Attlist | C_Attlist -- |
| CRoc_data_point_Base::C_Attlist | C_Attlist -- |
| CSample_enzyme_Base::C_Attlist | C_Attlist -- |
| CSearch_database_Base::C_Attlist | C_Attlist -- |
| CSearch_hit_Base::C_Attlist | C_Attlist -- |
| CSearch_result_Base::C_Attlist | C_Attlist -- |
| CSearch_score_Base::C_Attlist | C_Attlist -- |
| CSequence_search_constraint_Base::C_Attlist | C_Attlist -- |
| CSearch_summary_Base::C_Attlist | C_Attlist -- |
| CSpecificity_Base::C_Attlist | C_Attlist -- |
| CSpectrum_query_Base::C_Attlist | C_Attlist -- |
| CTerminal_modification_Base::C_Attlist | C_Attlist -- |
| CXpressratio_result_Base::C_Attlist | C_Attlist -- |
| CXpressratio_summary_Base::C_Attlist | C_Attlist -- |
| CXpressratio_timestamp_Base::C_Attlist | C_Attlist -- |
| CItem_Base::C_Attlist | C_Attlist -- |
| CApad_Base::C_Attlist | C_Attlist -- |
| CObjectUrl_Base::C_Attlist | C_Attlist -- |
| CPad_Base::C_Attlist | C_Attlist -- |
| CStrip_Base::C_Attlist | C_Attlist -- |
| CSubs_Base::C_Attlist | C_Attlist -- |
| COperand_Base::C_Attlist | C_Attlist -- |
| CData_set_id_type_Base::C_Attlist | C_Attlist -- |
| CData_set_id_Base::C_Data_set_id_type::C_Attlist | C_Attlist -- |
| CObjectUrl_Base::C_Data::C_BaseData | C_BaseData -- |
| CID2_Request_Get_Blob_Info_Base::C_Blob_id | Id can be supplied by inner request |
| CSeqTree_node_Base::C_Children | C_Children -- |
| CVariation_ref_Base::C_E_Somatic_origin::C_Condition | Condition related to this origin's type |
| CVariation_Base::C_E_Somatic_origin::C_Condition | Condition related to this origin's type |
| CPC_ResultType_Base::C_Constraints | Allowed Values, used for validating incoming data If type is "float" |
| CESearchResult_Base::C_Data::C_Info::C_Content | C_Content -- |
| CModel_coordinate_set_Base::C_Coordinates | C_Coordinates -- |
| CRs_Base::C_Create | Date the refsnp cluster was instantiated date the refsnp cluster was instantiated |
| CUser_field_Base::C_Data | Field contents |
| CEntrez_general_Base::C_Data | C_Data -- |
| CPluginArg_Base::C_Data | C_Data -- |
| CViewDescriptor_Base::C_Data | |
| CSeq_annot_Base::C_Data | C_Data -- |
| CSeqEdit_Cmd_AddAnnot_Base::C_Data | Annotaion object to add |
| CSeqEdit_Cmd_ChangeSeqAttr_Base::C_Data | C_Data -- |
| CSeqEdit_Cmd_ChangeSetAttr_Base::C_Data | C_Data -- |
| CSeqEdit_Cmd_RemoveAnnot_Base::C_Data | Object for deletion |
| CSeqEdit_Cmd_ReplaceAnnot_Base::C_Data | C_Data -- |
| CVariation_ref_Base::C_Data | C_Data -- |
| CSeq_submit_Base::C_Data | C_Data -- |
| CVariation_Base::C_Data | C_Data -- |
| CIdUrlSet_Base::C_Data | C_Data -- |
| CLinkSet_Base::C_Data | C_Data -- |
| CLinkSetDb_Base::C_Data | C_Data -- |
| CESearchResult_Base::C_Data | C_Data -- |
| CTranslationStack_Base::C_Data | C_Data -- |
| CESummaryResult_Base::C_Data | C_Data -- |
| CNormalize_Base::C_Data | C_Data -- |
| CObjectList_Base::C_Data | All Entrez databases may be configured to include LinkOut |
| CObjectUrl_Base::C_Data | C_Data -- |
| CRule_Base::C_Data | C_Data -- |
| CTolower_Base::C_Data | C_Data -- |
| CToupper_Base::C_Data | C_Data -- |
| CData_set_id_Base::C_Data_set_id_type | C_Data_set_id_type -- |
| CData_set_id_Base::C_Data_set_id_uids | C_Data_set_id_uids -- |
| CSeq_hist_Base::C_Deleted | C_Deleted -- |
| CSoapFault_Base::C_Detail | |
| C_DriverMgr | |
| CTitle_Base::C_E | C_E -- |
| CGenetic_code_Base::C_E | C_E -- |
| CID2S_Bioseq_Ids_Base::C_E | C_E -- |
| CRs_Base::C_E_AlleleOrigin | C_E_AlleleOrigin -- |
| CApad_Base::C_E_Apad | C_E_Apad -- |
| CRs_Base::C_E_BioSource | C_E_BioSource -- |
| CVariation_ref_Base::C_E_Consequence | C_E_Consequence -- |
| CVariation_Base::C_E_Consequence | C_E_Consequence -- |
| CData_set_id_Base::C_Data_set_id_uids::C_E_EData_set_id_uids | C_E_EData_set_id_uids -- |
| CLinkSet_Base::C_Data::C_IE::C_EL_2::C_EL::C_E_EL | C_E_EL -- |
| CFilter_Base::C_FF::C_E_FF | C_E_FF -- |
| CRs_Base::C_E_Frequency | C_E_Frequency -- |
| CIdCheckList_Base::C_II::C_E_II | Cmd=ncheck & lcheck & acheck |
| CImportGroup_Base::C_E_ImportGroup | ======================================================================================= Groups import definitions |
| CItem_Base::C_E_Item | |
| CItemDefinitionGroup_Base::C_E_ItemDefinitionGroup | ======================================================================================= |
| CItemGroup_Base::C_E_ItemGroup | ======================================================================================= Groups item list definitions |
| CRs_Base::C_E_MergeHistory | C_E_MergeHistory -- |
| CPad_Base::C_E_Pad | C_E_Pad -- |
| CRs_Base::C_E_Phenotype | C_E_Phenotype -- |
| CMarkov_chain_params_Base::C_E_Probabilities | C_E_Probabilities -- |
| CProject_Base::C_ProjectLevelTagExceptTargetOrImportType::C_E_ProjectLevelTagExceptTargetOrImportType | C_E_ProjectLevelTagExceptTargetOrImportType -- |
| CProject_Base::C_ProjectLevelTagType::C_E_ProjectLevelTagType | C_E_ProjectLevelTagType -- |
| CPropertyGroup_Base::C_E_PropertyGroup | ======================================================================================= Groups property definitions |
| CVariation_ref_Base::C_E_Somatic_origin | C_E_Somatic_origin -- |
| CVariation_Base::C_E_Somatic_origin | C_E_Somatic_origin -- |
| CStrip_Base::C_E_Strip | C_E_Strip -- |
| CSubs_Base::C_E_Subs | C_E_Subs -- |
| CSeq_code_table_Base::C_E_Table | C_E_Table -- |
| CLinkSet_Base::C_Data::C_IE::C_EL_2::C_EL | C_EL -- |
| CLinkSet_Base::C_Data::C_IE::C_EL_2 | C_EL_2 -- |
| CAssay_Base::C_Method::C_EMethod | C_EMethod -- |
| oligofar::CPermutator8b::C_Entry | |
| CRNA_ref_Base::C_Ext | C_Ext -- |
| C_FA_Storage | |
| CSeqEdit_Cmd_ReplaceAnnot_Base::C_Data::C_Feat | C_Feat -- |
| CFilter_Base::C_FF | C_FF -- |
| CViewDataLink_Base::C_Fingerprint | |
| CSeqTree_node_Base::C_Children::C_Footprint | C_Footprint -- |
| CVariation_ref_Base::C_E_Consequence::C_Frameshift | See http://www.hgvs.org/mutnomen/recs-prot.html |
| CVariation_Base::C_Frameshift | Frameshift-related info |
| CCit_art_Base::C_From | Journal or book |
| CGnomon_param_Base::C_Gc_content_range | Percents |
| CSeqEdit_Cmd_ReplaceAnnot_Base::C_Data::C_Graph | C_Graph -- |
| CSeq_graph_Base::C_Graph | C_Graph -- |
| CRs_Base::C_Het | C_Het -- |
| CEPostResult_Base::C_History | C_History -- |
| CId_pat_Base::C_Id | C_Id -- |
| CPC_CompoundType_Base::C_Id | Compound Namespace and ID (absent for "deposited" type compounds) |
| CID2S_Chunk_Data_Base::C_Id | Place of data to insert |
| CLinkSet_Base::C_Data::C_IE | C_IE -- |
| CIdCheckList_Base::C_II | Cmd=ncheck & lcheck & acheck |
| CESearchResult_Base::C_Data::C_Info | Response tags |
| CProjectItem_Base::C_Item | Item we represent |
| oligofar::CQueryHash::C_ListInserter | |
| CBiostruc_feature_Base::C_Location | C_Location -- |
| oligofar::CSeqScanner::C_LoopImpl_ColorspAmbiguities | |
| oligofar::CSeqScanner::C_LoopImpl_ColorspNoAmbiguities | |
| oligofar::CSeqScanner::C_LoopImpl_Ncbi8naAmbiguities | |
| oligofar::CSeqScanner::C_LoopImpl_Ncbi8naNoAmbiguities | |
| CVariation_ref_Base::C_E_Consequence::C_Loss_of_heterozygosity | C_Loss_of_heterozygosity -- |
| CVariation_Base::C_E_Consequence::C_Loss_of_heterozygosity | C_Loss_of_heterozygosity -- |
| CLinkSet_Base::C_Data::C_IE::C_EL_2::C_LW | C_LW -- |
| CAssay_Base::C_Method | C_Method -- |
| CMaps_Base::C_Method | C_Method -- |
| COrgName_Base::C_Name | C_Name -- |
| CAuth_list_Base::C_Names | C_Names -- |
| oligofar::CHit::C_NextCtl | |
| CSeqEdit_Cmd_AddAnnot_Base::C_Search_param::C_Obj | Use an annotaion descriptor, |
| CGnomon_param_Base::C_Param | C_Param -- |
| CProject_Base::C_ProjectLevelTagExceptTargetOrImportType | C_ProjectLevelTagExceptTargetOrImportType -- |
| CProject_Base::C_ProjectLevelTagType | C_ProjectLevelTagType -- |
| CBiostruc_feature_Base::C_Property | C_Property -- |
| CExchangeSet_Base::C_Query | C_Query -- |
| C_RA_Storage | |
| CInt_fuzz_Base::C_Range | Max to min |
| CLength_distribution_params_Base::C_Range | C_Range -- |
| CRegion_pntrs_Base::C_Region | C_Region -- |
| CID2_Reply_Base::C_Reply | Reply data moved at the end to make it easier to construct the reply data manually from precalculated data |
| CID2_Request_Base::C_Request | C_Request -- |
| CID2_Request_Get_Blob_Info_Base::C_Blob_id::C_Resolve | Generate blob-ids from request |
| oligofar::CTrSequence< bitst, bitsc >::C_ReverseIterator< Item > | |
| CObjectUrl_Base::C_Data::C_BaseData::C_Rule | End of SubObjectSelector group |
| CObjectUrl_Base::C_Data::C_Rule | C_Rule -- |
| C_SA_Storage | |
| oligofar::CQueryHash::C_ScanCallback< Callback > | |
| oligofar::CSeqScanner::C_ScanImpl_Base | |
| CSeqEdit_Cmd_AddAnnot_Base::C_Search_param | A search creteria |
| CSeq_align_Base::C_Segs | Alignment data |
| CLink_Base::C_Selector | C_Selector -- |
| CDelta_item_Base::C_Seq | C_Seq -- |
| CBiostruc_seqs_aligns_cdd_Base::C_Seq_align_data | C_Seq_align_data -- |
| CRs_Base::C_Sequence | C_Sequence -- |
| CSs_Base::C_Sequence | C_Sequence -- |
| CGC_Replicon_Base::C_Sequence | Sequence(s) representing this molecule in the case of 2L and 2R - the molecule is represented by several sequences, and there is no seq-id of "chr 2" as a whole |
| CVariation_ref_Base::C_Data::C_Set | Set of related Variations |
| CVariation_Base::C_Data::C_Set | Set of related Variations |
| CAssembly_Base::C_SnpStat | C_SnpStat -- |
| CSeqTestResults_Base::C_Source | C_Source -- |
| CExchangeSet_Base::C_SourceDatabase | C_SourceDatabase -- |
| CAffil_Base::C_Std | Std representation |
| CExchangeSet_Base::C_Summary | C_Summary -- |
| CSurface_coordinates_Base::C_Surface | C_Surface -- |
| CProject_Base::C_TargetOrImportType | Must be at least one Target or Import tag |
| CAssay_Base::C_Taxonomy | C_Taxonomy -- |
| CTarget_Base::C_TPI | C_TPI -- |
| CRs_Base::C_Update | Most recent date the cluster was updated (member added or deleted) most recent date the cluster was updated (member added or deleted) |
| CRs_Base::C_Validation | C_Validation -- |
| CPC_AssayData_Base::C_Value | Assay Result, must be the same type as defined for TID |
| CPC_InfoData_Base::C_Value | Data Value |
| CScore_Base::C_Value | C_Value -- |
| CT3StatusFlags_Base::C_Value | C_Value -- |
| CBiostruc_source_Base::C_Version_of_database | C_Version_of_database -- |
| C_xDriverMgr | |
| CAA | |
| CAbsTimeout | CAbsTimeout |
| CAbstractProjectItem | .hpp User-defined methods of the data storage class |
| CAbstractProjectItem_Base | CAbstractProjectItem_Base -- |
| CAccelTable | CAccelTable - Accelerator Table |
| CAcceptRequest | |
| CAccessionItem | |
| CAccPatternCounter | Accession naming patterns; find ranges for consequtive digits |
| CAce2AsnApp | |
| CBDB_Cache::CacheKey | Cache accession for internal in-memory storage |
| CAction_choice | CAction_choice -- |
| CAction_choice_Base | CAction_choice_Base -- |
| CActiveObject | |
| CAdd_descriptor_list_action | CAdd_descriptor_list_action -- |
| CAdd_descriptor_list_action_Base | CAdd_descriptor_list_action_Base -- |
| CAdd_file_action | CAdd_file_action -- |
| CAdd_file_action_Base | CAdd_file_action_Base -- |
| CAddBioseqChecker | |
| CAddDescr_EditCommand< TEditHandle > | |
| CAddFeatChecker | |
| CAddIdChecker | |
| CAddToNodeSetCallback | |
| CAdvancedFileInput | CAdvancedFileInput |
| CAECR_action | CAECR_action -- |
| CAECR_action_Base | CAECR_action_Base -- |
| CAECRParse_action | CAECRParse_action -- |
| CAECRParse_action_Base | CAECRParse_action_Base -- |
| CAffected_channel | CAffected_channel -- |
| CAffected_channel_Base | ============================================ This section is mapped from module "pepXML" ================================================= channel recipient |
| CAffil | .hpp User-defined methods of the data storage class |
| CAffil_Base | CAffil_Base -- |
| CAgpCompSpanSplitter | |
| CAgpconvertApplication | |
| CAgpErr | |
| CAgpErrEx | Correctly print multiple errors and warnings on consequitive lines; suppress undesired or higly repetitive messages; calculate total counts for each type of error |
| CAgpExporter | |
| CAgpExporterFactory | |
| CAgpExportJob | CAgpExportJob |
| CAgpExportPage | |
| CAgpExportParams | |
| CAgpFastaComparator | |
| CAgpLoader | CAgpLoader |
| CAgpLoadJob | CAgpLoadJob |
| CAgpLoadPage | |
| CAgpLoadParams | |
| CAgpReader | Detects scaffolds, object boundaries, errors that involve 2 consequitive lines |
| CAgpRenumber | |
| CAgpRow | A container for both the original string column values (Get*() methods) and the values converted to int, char, bool types (member variables) |
| CAgpValidateApplication | |
| CAgpValidateReader | |
| CAgpWriteComponentIdMapper | |
| CAgpwriteProcess | |
| CAgressiveResizeStrategy | |
| CAlgoAlignException | |
| CAlgoAlignUtilException | |
| CAlgoPlugin_CreateTrackCreatorDialog | |
| CAlgorithm_type | CAlgorithm_type -- |
| CAlgorithm_type_Base | CAlgorithm_type_Base -- |
| CAlgoToolManagerBase | CAlgoToolManagerBase This is base class for simple algorithmic tool managers |
| CAlgoToolManagerParamsPanel | CAlgoToolManagerParamsPanel |
| CAli | |
| CAliasBase< TPrim > | Alias wrapper templates |
| CAliasRefTypeStrings | |
| CAliasTest | |
| CAliasTypeInfo | |
| CAliasTypeInfoFunctions | |
| CAliasTypeStrings | |
| CAliCreator | |
| CAlign_annot | CAlign_annot -- |
| CAlign_annot_Base | CAlign_annot_Base -- |
| CAlign_annot_set | CAlign_annot_set -- |
| CAlign_annot_set_Base | CAlign_annot_set_Base -- |
| CAlign_CI | CAlign_CI -- |
| CAlign_def | CAlign_def -- |
| CAlign_def_Base | CAlign_def_Base -- |
| CAlign_stats | CAlign_stats -- |
| CAlign_stats_Base | CAlign_stats_Base -- |
| CAlignCleanup | Class CAlignCleanup implements an alignment cleanup utility based on the C++ alignment manager |
| CAlignCompare | |
| CAlignDataSource | |
| CAlignDataSourceException | |
| CAlignedFeatureGraph | CFeatureGraph |
| CAlignedGis | Class to contain the gis of the aligned sequences |
| oligofar::CAligner | |
| oligofar::CAligner_fast | |
| oligofar::CAligner_HSP | |
| oligofar::CAligner_SW | |
| oligofar::CAligner_SW_Base | |
| oligofar::CAlignerBase | |
| CAlignFilter | CAlignFilter exposes a query language for inspecting properties and scores placed on Seq-align objects |
| CAlignFindContext | |
| CAlignFormatUtil | This class contains misc functions for displaying BLAST results |
| CAlignGlyph | |
| CAlignGroup | |
| CAlignInfo | |
| CAlignMap | |
| CAlignMarkHandler | CAlignMarkHandler manages handling and editing of marks on alignments |
| CAlignmentBasedRowSelector | |
| CAlignmentConfig | File Description: |
| CAlignmentItem | |
| CAlignmentRefiner | |
| CAlignmentSmear | |
| CAlignmentTrack | CAlignmentTrack -- |
| CAlignmentTrackFactory | CAlignmentTrackFactory |
| CAlignModel | |
| CAlignMultipleDemoApp | Derive our application class from CwxNCBIApp and use it together with standard CNCBIwxApplication |
| CAlignMultipleDemoDlg | |
| CAlignNeedlemanWunschPanel | |
| CAlignPackage | Declare the Package Object |
| CAlignParam | |
| CAlignRange< Position > | CAlignRange Represents an element of pairwise alignment of two sequences |
| CAlignRangeCollection< TAlnRange > | Class CAlignRangeCollection<TAlignRange> represent a sorted collection of TAlignRange |
| CAlignRangeCollException | |
| CAlignRangeCollExtender< TColl > | CAlignRangeCollExtender this is an adapter for a collection that perfroms some of the operations faster due to an additional index built on top of the collection |
| CAlignResultsSet | |
| CAlignRow | |
| CAlignRowGraphCont | CAlignRowGraphCont |
| CAlignSeqTableModel | CAlignSeqTableModel |
| CAlignShadow | |
| CAlignSmearGlyph | |
| CAlignSort | |
| CAlignSpanView | CAlignSpanView |
| CAlignSpanViewFactory | CAlignSpanViewFactory |
| oligofar::CAlignTest | |
| CAliPiece | |
| CAliToSeq_align | |
| CAsyncCall::Call | |
| CAllOtherFeaturesTrack | File Description: |
| CAllOtherFeaturesTrackFactory | CAllOtherFeaturesTrackFactory |
| CAlnAsnReader | Helper class for reading seq-align objects from a CObjectIStream |
| CAlnBuildApp | |
| CAlnMap::CAlnChunk | |
| CAlnChunkSegment | CAlnChunkSegment - IAlnSegment implementation for CAlnMap::CAlnChunk |
| CAlnMap::CAlnChunkVec | |
| CAlnContainer | CSeq_align container |
| CAlnContentEvtHandler | |
| CAlnError | |
| CAlnException | |
| CAlnGraphic | |
| CAlnIdMap< _TAlnVec, TAlnSeqIdExtract > | Container mapping seq-aligns to vectors of participating seq-ids |
| CAlnMap | |
| CAlnMapPrinter | |
| CAlnMix | |
| CAlnMixMatch | |
| CAlnMixMatches | |
| CAlnMixMerger | |
| CAlnMixSegment | |
| CAlnMixSegments | |
| CAlnMixSeq | |
| CAlnMixSequences | |
| CAlnMixStarts | |
| CAlnMrgApp | |
| CAlnMrgTaskProgressCallback | |
| CAlnMultiCGIApplication | |
| CAlnMultiCGIException | Number of gradient colors in alignment |
| CAlnMultiDSBuilder | |
| CAlnMultiHeader | CAlnMultiHeader |
| CAlnMultiHeaderHandler | CAlnMultiHeaderHandler |
| CAlnMultiModel | Class CAlnMultiModel - represents a visual model of an alignment |
| CAlnMultiModelFactory | CAlnMultiModelFactory - a factory to separate creation of the model from widget |
| CAlnMultiPane | Class CAlnMultiPane |
| CAlnMultiRenderer | Class CAlnMultiRenderer - renders multiple alignment represented by IAlnMultiRendererContext (the Model) |
| CAlnMultiWidget | Class CAlnMultiWidget |
| CAlnPos_CI | |
| CAlnPropertiesDlg | CwxAlnPropertiesDlg |
| CAlnReader | Class CAlnReader supports importing a large variety of text-based alignment formats into standard data structures |
| CAlnRowState | CAlnRowState - implements state management for Align Row |
| CAlnScoringMethodSelector | |
| CAlnSeqId | Default IAlnSeqId implementation based on CSeq_id_Handle |
| CAlnSeqIdConverter< TAlnSeqId > | Default seq-id converter |
| CAlnSeqIdsExtract< TAlnSeqId, TIdConverter > | IAlnSeqId extracting functor |
| CAlnSpanSettingsDlg | |
| CAlnSpanVertModel | |
| CAlnSpanWidget | |
| CAlnStatConfig | |
| CAlnStatGlyph | |
| CContigAssembly::CAlnStats | |
| CAlnStats< _TAlnIdVec > | Helper class which collects seq-align statistics: seq-ids participating in alignments and rows, potential anchors etc |
| CTableDataAlnSummary::CAlnSummary | |
| CAlnSummaryViewFactory | CAlnSummaryViewFactory |
| CAlnTableDS | |
| CAlnTableWidget | |
| CAlnTestApp | Types we use here: |
| CAlnUserOptions | Options for different alignment manager operations |
| CAlnVec | |
| CAlnVecGraphicDataSource | CAlnVecGraphicDataSource - implementation of CAlnGraphicDataSource for CAlnVec-based alignments |
| CAlnVecIterator | CAlnVecIterator - IAlnSegmentIterator implementation for CAlnMap::CAlnChunkVec |
| CAlnVecMultiDataSource | CAlnVecMultiDataSource - implementation of IAlnMultiDataSource for CAlnVec-based alignments |
| CAlnVecPrinter | |
| CAlnVecRow | Class CAlnVecRow - implementation of IAlignRow for CAlnVec-based alignments |
| CAlnVecRowHandle | CAlnVecRowHandle is inherited from IAlignRowHandle and represents a row of CAlnVec-based alignment |
| CAlnVwrApp | |
| CAlternate_conformation_id | CAlternate_conformation_id -- |
| CAlternate_conformation_id_Base | CAlternate_conformation_id_Base -- |
| CAlternate_conformation_ids | CAlternate_conformation_ids -- |
| CAlternate_conformation_ids_Base | An alternate conformation id is optionally associated with each coordinate |
| CAlternative_protein | CAlternative_protein -- |
| CAlternative_protein_Base | Other protein in search database that contains peptide |
| CAltSplice | |
| CAltValidator | |
| CAlwaysFailMockBlastSeqSrc | Mock BlastSeqSrc implementation which always fails |
| CAmbigDataBuilder | Encode ambiguities in blast database format |
| CAmbiguiousTypes | |
| CAmbiguityContext | |
| CAmbiguousRegion | Ambiguous portion of a sequence |
| CAminoacid_modification | CAminoacid_modification -- |
| CAminoacid_modification_Base | Modified aminoacid, static or variable |
| CAminoAcidCharToSymbol | |
| CAnalysis_result | CAnalysis_result -- |
| CAnalysis_result_Base | CAnalysis_result_Base -- |
| CAnalysis_summary | CAnalysis_summary -- |
| CAnalysis_summary_Base | Summary of analysis subjected to run(s) |
| CAnalysis_timestamp | CAnalysis_timestamp -- |
| CAnalysis_timestamp_Base | Reference for analysis applied to current run (time corresponds with analysis_summary/, id corresponds with analysis_result/) |
| CAnalysisFile | |
| CAnalysisFileLoader | |
| CAnchoredAln | Query-anchored alignment can be 2 or multi-dimentional |
| CAnisotropic_temperature_factors | CAnisotropic_temperature_factors -- |
| CAnisotropic_temperature_factors_Base | CAnisotropic_temperature_factors_Base -- |
| CAnnot_CI | CAnnot_CI -- |
| CAnnot_Collector | |
| CAnnot_descr | CAnnot_descr -- |
| CAnnot_descr_Base | CAnnot_descr_Base -- |
| CAnnot_id | CAnnot_id -- |
| CAnnot_id_Base | CAnnot_id_Base -- |
| CAnnotationASN1 | |
| CAnnotCompare | |
| CAnnotCompare_AlignDS | CAnnotCompare_AlignDS |
| CAnnotCompare_LocationDS | CAnnotCompare_LocationDS |
| CAnnotCompareDS | CAnnotCompareDS |
| CAnnotCompareView | CAnnotCompareView |
| CAnnotCompareViewFactory | CAnnotCompareViewFactory |
| CAnnotCompareWidget | CAnnotCompareWidget |
| CAnnotWriteConfig::CAnnotConfigSettings | |
| CAnnotConfigUtils | |
| CAnnotdesc | CAnnotdesc -- |
| CAnnotdesc_Base | CAnnotdesc_Base -- |
| CAnnotException | Annotation iterators exceptions |
| CAnnotMapperException | Seq-loc and seq-align mapper exceptions |
| CAnnotMapping_Info | |
| CAnnotMappingCollector | |
| CAnnotMetaData | |
| CAnnotMetaDataJob | CAnnotMetaDataJob |
| CAnnotMetaDataJobResult | CAnnotMetaDataJobResult |
| CAnnotName | |
| CAnnotObject_Info | |
| CAnnotObject_Less | |
| CAnnotObject_LessReverse | |
| CAnnotObject_Ref | |
| CAnnotObject_SplitInfo | |
| CAnnotObjectType_Less | |
| CAnnotPieces | |
| CAnnotReadConfig | |
| CAnnotType_Index | |
| CAnnotTypes_CI | |
| CAnnotWriteConfig | |
| CAnnotWriterApp | |
| CAntigenic | |
| CAnyContentDataType | |
| CAnyContentFunctions | |
| CAnyContentObject | Serializable object that stores any combination of parsable data |
| CAnyContentTypeStrings | |
| CAnyIntron | |
| CAnyTypeChoice | |
| CAnyTypeClassInfo | |
| CAnyTypeSource | |
| CApad | CApad -- |
| CApad_Base | CApad_Base -- |
| oligofar::CApp | |
| CApp | |
| CAppException | CAppException -- |
| CAppExplorerCmdHandler | CAppExplorerCmdHandler - handles wxWidget commands and translates them into calls to CAppExplorerService IExplorerItemSelectionSource provides selection for the commands |
| CAppExplorerData | CAppExplorerData - data descriptor for use with CAppExplorerDataObject |
| CAppExplorerDataObject | CAppExplorerDataObject - wxDataObject for use with CAppExplorerService |
| CAppExplorerItemCmdContributor | CAppExplorerItemCmdContributor - an extension contributing App Explorer Service commands |
| CAppExplorerService | CAppExplorerService - TODO comments |
| CAppHitFilter | |
| CAppHitFilterException | |
| CAppInfo | Class CAppInfo defines an interface for application registration information |
| CAppJob | CAppJob - default implementation of IAppJob that could be used as a base class |
| CAppJobDispatcher | CAppJobDispatcher |
| CAppJobError | CAppJobError Default implementation for IAppJobError - encapsulates a text error message |
| CAppJobEventTranslator | CAppJobEventTranslator Standard Listener that generates notification events |
| CAppJobException | IAppJobListener Interface for components that need to be notified about changes in Jobs |
| CAppJobNotification | CAppJobNotification Notification send by CAppJobEventTranslator |
| CAppJobProgress | CAppJobProgress Default implementation for IAppJobProgress - the class encapsulates a text message and a numeric value indicating the progress of the task normalized in [0.0, 1.0] range (0.0 - just started, 1.0 - 100% done) |
| CAppJobTask | CAppJobTask CAppJobTask is an adapter that allows for running IAppJobs as Tasks in App Task Service |
| CAppJobTestApplication | CAppJobTestApplication |
| CAppJobTextResult | CAppJobTextResult Default implementation for result object - encapsulates a text error message |
| CApply_action | CApply_action -- |
| CApply_action_Base | CApply_action_Base -- |
| CApply_feature_action | CApply_feature_action -- |
| CApply_feature_action_Base | CApply_feature_action_Base -- |
| CApply_table_action | CApply_table_action -- |
| CApply_table_action_Base | CApply_table_action_Base -- |
| CApply_table_extra_data | CApply_table_extra_data -- |
| CApply_table_extra_data_Base | CApply_table_extra_data_Base -- |
| CAppNWA | |
| CAppNWAException | |
| CAppOptionsDlg | |
| CAppPackagesDlg | |
| CAppPopup | Class CAppPopup allows applications to be launched based on standard registered types |
| CAppRegistry | Class CAppRegistry defines the registry of application information for automated application link-outs |
| CAppTask | CAppTask - default implementation of IAppTask, use it as a base class for custom tasks |
| CAppTaskService | CAppTaskService - Application Task Service |
| CAppTaskServiceEvent | CAppTaskServiceEvent |
| CAppTaskServiceException | CAppTaskServiceException |
| CArg_Boolean | |
| CArg_Dir | |
| CArg_Double | |
| CArg_ExcludedValue | |
| CArg_Flag | |
| CArg_InputFile | |
| CArg_Int8 | |
| CArg_Integer | |
| CArg_IOFile | |
| CArg_Ios | |
| CArg_NoValue | |
| CArg_OutputFile | |
| CArg_String | |
| CArgAllow | CArgAllow -- |
| CArgAllow_Doubles | CArgAllow_Doubles -- |
| CArgAllow_Int8s | CArgAllow_Int8s -- |
| CArgAllow_Integers | CArgAllow_Integers -- |
| CArgAllow_Regexp | CArgAllow_Regexp -- |
| CArgAllow_String | CArgAllow_String -- |
| CArgAllow_Strings | CArgAllow_Strings -- |
| CArgAllow_Symbols | CArgAllow_Symbols -- |
| CArgAllowIntegerSet | |
| CArgAllowStringSet | |
| CArgAllowValuesBetween | Class to constrain the values of an argument to those in between the values specified in the constructor |
| CArgAllowValuesGreaterThanOrEqual | Class to constrain the values of an argument to those greater than or equal to the value specified in the constructor |
| CArgAllowValuesLessThanOrEqual | Class to constrain the values of an argument to those less than or equal to the value specified in the constructor |
| CArgArray | |
| CArgC | |
| CArgDesc | CArgDesc -- |
| CArgDesc_agp_validate | |
| CArgDesc_Alias | |
| CArgDesc_Flag | |
| CArgDesc_Key | |
| CArgDesc_KeyDef | |
| CArgDesc_KeyOpt | |
| CArgDesc_NameOnly | |
| CArgDesc_Opening | |
| CArgDesc_Pos | |
| CArgDesc_PosDef | |
| CArgDesc_PosOpt | |
| CArgDescDefault | |
| CArgDescMandatory | |
| CArgDescOptional | |
| CArgDescriptions | CArgDescriptions -- |
| CArgDescSynopsis | |
| CArgErrorHandler | CArgErrorHandler -- |
| CArgException | CArgException -- |
| CArgHelpException | CArgHelpException -- |
| CArgs | CArgs -- |
| CArgumentsException | CArgumentsException -- |
| CArgValue | CArgValue -- |
| pythonpp::CArithmeticError | |
| CArrayHolder | Helper class for holding and correct destruction of static array copy |
| CArrayString< STR_SIZE > | Fixed-buffer string type |
| CArticleId | CArticleId -- |
| CArticleId_Base | Article Ids can be many ids for an article |
| CArticleIdSet | CArticleIdSet -- |
| CArticleIdSet_Base | CArticleIdSet_Base -- |
| CAsapratio_contribution | CAsapratio_contribution -- |
| CAsapratio_contribution_Base | CAsapratio_contribution_Base -- |
| CAsapratio_lc_heavypeak | CAsapratio_lc_heavypeak -- |
| CAsapratio_lc_heavypeak_Base | CAsapratio_lc_heavypeak_Base -- |
| CAsapratio_lc_lightpeak | CAsapratio_lc_lightpeak -- |
| CAsapratio_lc_lightpeak_Base | CAsapratio_lc_lightpeak_Base -- |
| CAsapratio_peptide_data | CAsapratio_peptide_data -- |
| CAsapratio_peptide_data_Base | CAsapratio_peptide_data_Base -- |
| CAsapratio_result | CAsapratio_result -- |
| CAsapratio_result_Base | ASAPRatio quantitation results for search hit |
| CAsapratio_summary | CAsapratio_summary -- |
| CAsapratio_summary_Base | Quantitation |
| CAsapratio_timestamp | CAsapratio_timestamp -- |
| CAsapratio_timestamp_Base | CAsapratio_timestamp_Base -- |
| CAsBodyDiagFactory | |
| CAscii85 | |
| CAsn2Asn | |
| CAsn2AsnThread | |
| CAsn2FastaApp | |
| CAsn2FlatApp | |
| CAsn2GffApp | |
| CAsnBinaryDefs | |
| CAsnBlockEndItem | |
| CAsnConverter< TCpp, TC > | |
| CAsnElementBlockCollapsed | |
| CAsnElementBlockStart | |
| CAsnElementItem | |
| CAsnElementPrimitive | |
| CAsnExporter | |
| CAsnExporterFactory | |
| CAsnExportJob | CAsnExportJob |
| CAsnExportPage | |
| CAsnExportParams | |
| CASNFormatLoadManager | CASNFormatLoadManager |
| CAsnHeaderItem | |
| CAsnHeaderPrimitive | |
| CAsnLoadJob | CAsnLoadJob |
| CAsnOctetStringBlock | |
| CAsnRetrieveJob | |
| CAsnSizer | |
| CAsnStyles | |
| CAsnvalApp | |
| CAsnViewContext | |
| CAsnWriteNode | |
| CAspN | Asp-N, Nterm of D |
| CAspNDE | EMSEnzymes_aspn_de Asp-N that cuts at D and E |
| CAssay | CAssay -- |
| CAssay_Base | CAssay_Base -- |
| CAssembly | CAssembly -- |
| CAssembly_Base | A collection of genome sequence records (curated gene regions (NG's), contigs (NWNT's) and chromosomes (NC/AC's) produced by a genome sequence project |
| CAssemblyInfo | |
| CAssemblyListPanel | |
| CAssemblyQueryPanel | |
| pythonpp::CAssertionError | |
| CBioTree< TBioNode >::CAssignTreeFunc | Functor to reset tree pointer in all nodes |
| CBDB_MergeBlobWalkerAsync< BF >::CAsync | IAsync implementation |
| CBDB_MergeStoreAsync< BStore >::CAsync | IAsync implementation |
| CAsyncCall | Class for GUI asyncronous execition |
| CAsyncCallDlg | |
| CAsyncDiagHandler | |
| CAsyncDiagThread | |
| CAsyncMemberCall | |
| CAsyncObjConvert | |
| CAsyncObjConvert2 | |
| CAtom | CAtom -- |
| CAtom_Base | Atoms in residue graphs are defined by elemental symbols and names |
| CAtom_id | CAtom_id -- |
| CAtom_id_Base | CAtom_id_Base -- |
| CAtom_pntr | CAtom_pntr -- |
| CAtom_pntr_Base | Atoms, residues and molecules within the current biostruc are referenced by hierarchical pointers |
| CAtom_pntr_set | CAtom_pntr_set -- |
| CAtom_pntr_set_Base | CAtom_pntr_set_Base -- |
| CAtom_pntrs | CAtom_pntrs -- |
| CAtom_pntrs_Base | CAtom_pntrs_Base -- |
| CAtomic_coordinates | CAtomic_coordinates -- |
| CAtomic_coordinates_Base | Literal atomic coordinate values give location, occupancy and order parameters, and a pointer to a specific atom defined in the biostruc graph |
| CAtomic_occupancies | CAtomic_occupancies -- |
| CAtomic_occupancies_Base | CAtomic_occupancies_Base -- |
| CAtomic_temperature_factors | CAtomic_temperature_factors -- |
| CAtomic_temperature_factors_Base | CAtomic_temperature_factors_Base -- |
| CAtomicCounter | CAtomicCounter -- |
| CAtomicCounter_WithAutoInit | CAtomicCounter_WithAutoInit -- |
| CAttachAnnot_EditCommand< Annot > | |
| CAttachEntry_EditCommand< Entry > | |
| CAttribFloatMenuItem | Class CAttribFloatMenuItem |
| CAttribIntMenuItem | Class CAttribIntMenuItem |
| CAttribMenu | Class CAttribMenuItem |
| CAttribMenuInstance | Simple singleton class to allow multiple classes to share the same menu |
| CAttribMenuItem | Class CAttribMenuItem |
| CAttribStringsMenuItem | Class CAttribStringsMenuItem |
| pythonpp::CAttributeError | |
| CAttrListParser | |
| CAttrRangeCollection< Attr, Position > | |
| CAuth_list | .hpp User-defined methods of the data storage class |
| CAuth_list_Base | Authorship Group |
| CAuthor | |
| CAuthor_Base | CAuthor_Base -- |
| CAuthor_fix_action | CAuthor_fix_action -- |
| CAuthor_fix_action_Base | CAuthor_fix_action_Base -- |
| CAuthorAffiliationPanel | |
| CAuthorNamesPanel | |
| CAutoCompleteCombo | CAutoCompleteComboBox |
| CAutoDef | |
| CAutodef_action | CAutodef_action -- |
| CAutodef_action_Base | CAutodef_action_Base -- |
| CAutoDefAvailableModifier | |
| CAutoDefDemo | |
| CAutoDefExonListClause | |
| CAutoDefFakePromoterClause | |
| CAutoDefFeatureClause | |
| CAutoDefFeatureClause_Base | |
| CAutoDefGeneClusterClause | |
| CAutoDefIntergenicSpacerClause | |
| CAutodefJob | CAutodefJob |
| CAutoDefMiscCommentClause | |
| CAutoDefModifierCombo | |
| CAutoDefNcRNAClause | |
| CAutodefParamsPanel | |
| CAutoDefParsedClause | |
| CAutoDefParsedIntergenicSpacerClause | |
| CAutoDefParsedRegionClause | |
| CAutoDefParsedtRNAClause | |
| CAutoDefPromoterClause | |
| CAutoDefSatelliteClause | |
| CAutoDefSourceDescription | |
| CAutoDefSourceGroup | |
| CAutoDefSourceModifierInfo | |
| CAutodefToolManager | CAutodefToolManager |
| CAutoDefTransposonClause | |
| CAutoDefUnknownGeneList | |
| CAutoEnvironmentVariable | CAutoEnvironmentVariable -- |
| CAutofix_action | CAutofix_action -- |
| CAutofix_action_Base | CAutofix_action_Base -- |
| CAutogeneratedCleanup | This file was generated by application DATATOOL |
| CAutogeneratedExtendedCleanup | This file was generated by application DATATOOL |
| CAutoInitializeStaticFastMutex | CAutoInitializeStaticFastMutex -- |
| CAutoInitializeStaticMutex | CAutoInitializeStaticMutex -- |
| CAutoInitPtr< T > | CAutoInitPtr<>:: |
| CAutoInitPtr_Base | CAutoInitPtr_Base:: |
| CAutoInitRef< T > | CAutoInitRef<>:: |
| CAutomaticGenCodeSingleton | Initializes and uninitializes the genetic code singleton as if it was an automatic variable (to facilitate use in our unit tests and in the CBlastOptions object) |
| CAutomationException | |
| CAutomationObject | |
| CAutomationProc | |
| CAutoNcbiConfigFile | Auxiliary class to write temporary NCBI configuration files in the local directory for the purpose of testing the CBlastScopeSource configuration class via this file (and override any other installed NCBI configuration files) |
| CAutoOutputFileReset | Auxiliary class to store the name of an output file, which is reset every time its GetStream method is invoked |
| CAutoPointerTypeInfo | |
| CAutoPtrTypeInfo< Data > | |
| CAutoRegistrar | Auxiliary class to register the BLAST database data loader of choice (information provided in the constructor) and deactivate it on object destruction |
| CAutoTrans | |
| CThreadInPool< TRequest >::CAutoUnregGuard | |
| CThreadInPool_ForServer::CAutoUnregGuard | |
| CAuxiliaryManagedWrapperGeneratorToolDummyImpl | |
| CAVApp | |
| CAxisArea | Class CAxisArea |
| CAxisRenderer | Class CAxisRenderer |
| CBackgroundHost | |
| CNWAligner::CBacktraceMatrix4 | |
| CSeqportUtil::CBadIndex | |
| CSourceModParser::CBadModError | |
| CBadResiduesException | |
| CSeqportUtil::CBadSymbol | |
| CSeqportUtil::CBadType | |
| CBamCoverageGraphPanel | |
| CBamDSEvtHandler | CBamDSEvtHandler - wxEvtHandler-derived adapter for Bam data source |
| CBamIndexingPanel | |
| CBamLoadingJob | CBamLoadingJob |
| CBamLoadOptionPanel | CBamLoadOptionPanel |
| CBamUIDataSource | CBamUIDataSource |
| CBamUIDataSourceType | CBamUIDataSourceType |
| CBamUILoadManager | |
| CBandAligner | |
| pythonpp::bind::CBase | |
| CBase64BinaryDataType | |
| CBaseAddress | CBaseAddress -- |
| CBaseClusterer | |
| impl::CBaseCmd | |
| CBaseCountItem | |
| CBaseNRCriteria | |
| CBaseTextOStream | |
| CBaseURL | CBaseURL -- |
| CBaseURL_Base | URL value from dbSNP_main.BaseURL links table |
| CBasicFastaWrapper | Concrete implementations of the CFastaIOWrapper virtual class |
| CBasicRelation | |
| oligofar::CBatch | |
| CBatchFeatJob | CBatchFeatJob: a job class for loading annotated features from a given a set of sequences within the corresponding visible ranges |
| CBatchJobResult | CBatchJobResult -- the data structure holding the seqgraphic job results for a batch job processing |
| CBatchSubmitAttrParser | |
| CBBox< N > | |
| CBDB_BLobDemo1 | BLob Demo application |
| CBDB_BlobDeMux | Volume split BLOB demultiplexer |
| CBDB_BlobDeMux_RoundRobin | BLOB demultiplexer implements round-robin volume rotation |
| CBDB_BlobDeMuxPersistent | Split demux which can save and load state into a file Stateful (persistent) class |
| CBDB_BlobDeMuxSplit | Base class for page-split demultiplexers |
| CBDB_BlobDictionary< Key > | Templatized candidate for dictionaries This template defines the basic interface that must be supported by all dictionaries |
| CBDB_BlobDictionary< Int4 > | |
| CBDB_BlobDictionary< Uint4 > | Pass-through for Uint4 key types |
| CBDB_BlobDictStore< Key, Dictionary, Store > | |
| CBDB_BLobFile | Berkeley DB BLOB File class |
| CBDB_BlobMetaContainer | Container of BLOB attributes Encapsulates: BLOB maps of several BLOBs (offsets there point in super BLOB) Super BLOB location table (offsets and sizes in external file) |
| CBDB_BlobReaderWriter | Stream style BDB BLOB reader |
| CBDB_BlobSplitStore< TBV, TObjDeMux, TL > | BLOB storage based on single unsigned integer key Supports BLOB volumes and different base page size files in the volume to guarantee the best fit |
| CBDB_BlobStoreDict< TBV > | Persistent storage for demux information |
| CBDB_BLobStream | Berkeley DB BLOB File stream |
| CBDB_BufferManager | BDB Data Field Buffer manager class |
| CBDB_BvPropertyStore< PropKey, PropValue, Dictionary, BvStore, BV > | |
| CBDB_BvSplitDictStore< Key, Dictionary, BvStore, BV > | |
| CBDB_BvStore< TBV > | Basic template class for bitvector storage |
| CBDB_Cache | BDB cache implementation |
| CBDB_CacheHolder | Class container for BDB cache objects |
| CBDB_CacheIReader | |
| CBDB_CacheIWriter | |
| CBDB_CacheReaderCF | Class factory for BDB implementation of ICache |
| CBDB_CacheVerifyApp | BDB cache verify application |
| CBDB_CheckPointThread | Transaction checkpoint / memptrickle thread |
| CBDB_ConditionHandle | File cursor condition handle |
| CBDB_ConfigStructureParser | |
| CBDB_CursorGuard | BDB Cursor guard |
| CBDB_DumpScanner | Query scanner |
| CBDB_Env | BDB environment object a collection including support for some or all of caching, locking, logging and transaction subsystems |
| CBDB_ErrnoException | BDB errno exception class |
| CBDB_Exception | Base BDB exception class |
| CBDB_ExtBlobMap | BLOB map, encapsulates collection of BLOB ids and BLOB locations |
| CBDB_ExtBlobStore< TBV > | External BLOB store |
| CBDB_FC_Condition | Internal class used by CBDB_FileCursor to represent search condition criteries |
| CBDB_Field | Base class for constructing BDB fields |
| CBDB_FieldChar | |
| CBDB_FieldDouble | Double precision floating point field type |
| CBDB_FieldFactory | Class factory for BDB field types |
| CBDB_FieldFixedByteString | Fixed length bytestring |
| CBDB_FieldFloat | Float field type |
| CBDB_FieldInt1 | Int1 field type |
| CBDB_FieldInt2 | Int2 field type |
| CBDB_FieldInt4 | Int4 field type |
| CBDB_FieldInt8 | Int8 field type |
| CBDB_FieldInterfaces | Interface definition class for field construction |
| CBDB_FieldLString | Length prefised string field type |
| CBDB_FieldSimple< T > | Template class for building simple scalar data fields |
| CBDB_FieldSimpleFloat< T > | Template class for building simple scalar floating point compatible fields |
| CBDB_FieldSimpleInt< T > | Template class for building simple scalar integer compatible data fields |
| CBDB_FieldString | String field type designed to work with C-strings (ASCIIZ) |
| CBDB_FieldStringBase | String field type |
| CBDB_FieldStringCase | Case-insensitive (but case preserving) string field type |
| CBDB_FieldUChar | Char field type |
| CBDB_FieldUint1 | Uint1 field type |
| CBDB_FieldUint2 | Uint2 field type |
| CBDB_FieldUint4 | Uint4 field type |
| CBDB_FieldUint8 | Uint8 field type |
| CBDB_File | Berkeley DB file class |
| CBDB_FileCursor | Berkeley DB file cursor class |
| CBDB_FileDumper | Utility class to convert DBD files into text files |
| CBDB_FileDumperApp | BDB file dumper application |
| CBDB_FileScanner | Scans the BDB file, searches the matching records |
| CBDB_IdBlobFile | Variant of BLOB storage for integer key database |
| CBDB_IdFile | Berkeley DB file class optimized to work with tables having int as the primary key |
| CBDB_LibException | BDB library exception |
| CBDB_LobFile | Berkeley DB Large Object File class |
| CBDB_MatrixBvStore< TBV, TM > | Matrix BV store |
| CBDB_MergeBlobWalker< BF > | Generic iterator to traverse any CBDB_BLobFile for volume merge BF - any CBDB_BLobFile derived class |
| CBDB_MergeBlobWalkerAsync< BF > | Generic iterator to traverse any CBDB_BLobFile for volume merge BF - any CBDB_BLobFile derived class This implementation supports asyncronous processing |
| CBDB_MergeStore< BStore > | Merge store saves result to BLOB store |
| CBDB_MergeStoreAsync< BStore > | Merge store saves result to BLOB store |
| CBDB_MergeTest | |
| CBDB_MultiRowBuffer | Multirow buffer for reading many rows in one call |
| CBDB_PersistentSplitStore< BV, TL > | |
| CBDB_PhoneBookDemo1 | |
| CBDB_PhoneBookDemo2 | |
| CBDB_PhoneBookDemo3 | |
| CBDB_PropertyDictionary< PropKey, PropValue > | |
| CBDB_Query | Query class incapsulates query tree (query clause) and implements set of utility methods to construct query trees |
| CBDB_QueryNode | Query node class |
| CBDB_QueryParserEnvironment | Class passed to Lex/Bison (yylex/yyparse) functions |
| CBDB_RangeMap< TBV > | Range map class, stores unsigned integer range mappings like 10 to 15 maps into 100 to 115 |
| CBDB_RawFile | Raw file class wraps up basic Berkeley DB operations |
| CBDB_SplitCursor< BDB_SplitStore, BDB_Vol > | |
| CBDB_SplitTest | |
| CBDB_StrErrAdapt | Auxiliary exception class to wrap up Berkeley DB strerror function |
| CBDB_Transaction | BDB transaction object |
| CBDB_TypeMapper< T > | Internal template used for compiler based type mapping (C++ templates specialization emplyed here) |
| CBDB_TypeMapper< int > | |
| CBDB_TypeMapper< string > | |
| CBDB_Volumes | Volumes management |
| CBDB_VolumesException | Exceptions specific to volumes management |
| CBDB_VolumesTransaction | Transaction class for volumes management |
| CBDBEnvKeeperApp | |
| CBDBEnvKeeperConnectionFactory | |
| CBDBEnvKeeperConnectionHandler | Actual event (command) responder (session state machine) |
| CBDBEnvKeeperServer | Main server class |
| CBedFeatureRecord | Encapsulation of the BED feature record |
| CBedLoadJob | CBedLoadJob |
| CBedLoadManager | CBedLoadManager |
| CBedLoadParams | |
| CBedParamsPanel | |
| CBedTrackRecord | Encapsulation of a track line in the BED file format |
| CBedWriter | CWriterBase implementation that will render given Genbank objects in the BED file format (http://http://genome.ucsc.edu/FAQ/FAQformat#format1) |
| CBeginDragOutsideEvent | |
| CBeginInfo | Class holding information about root of non-modifiable object hierarchy Do not use it directly |
| CBestChoiceTracker< T, F > | Tracks the best score (lowest value) |
| CBestFeatFinder | |
| CBestI | |
| CBestIntron | |
| xml::impl::cbfo_node_compare | |
| CBigIntDataType | |
| CBigIntEnumDataType | |
| python::CBinary | |
| CBinaryKmerCounts | K-mer counts implemented as bit vectors |
| CBinaryListBuilder | Binary GI or TI List Builder |
| CBinomialOrgName | CBinomialOrgName -- |
| CBinomialOrgName_Base | CBinomialOrgName_Base -- |
| CBinsDS | |
| CBinsDSType | |
| CBinsGlyph | |
| CBinsJob | CBinsJob |
| CBinsTrack | |
| CBinsTrackFactory | |
| CBiomol_descr | CBiomol_descr -- |
| CBiomol_descr_Base | A biomolecule description refers to the chemical structure of a molecule or component substructures |
| CBioTree< TBioNode >::CBioNode | |
| CPhyTreeFormatter::CBioNodeFinder | Tree visitor, finds BioTreeDynamic node by id |
| CBioObjectId | |
| CBioseq | |
| CBioseq_Base | Sequence ******************************** |
| CBioseq_Base_Info | |
| CBioseq_CI | CBioseq_CI -- |
| CBioseq_EditHandle | CBioseq_EditHandle -- |
| CBioseq_Handle | CBioseq_Handle -- |
| CBioseq_Info | |
| CBioseq_ScopeInfo | |
| CBioseq_set | |
| CBioseq_set_Base | Sequence Collections ******************************** |
| CBioseq_set_EditHandle | CBioseq_set_EditHandle -- |
| CBioseq_set_Handle | CBioseq_set_Handle -- |
| CBioseq_set_Info | |
| CBioseq_set_ScopeInfo | |
| CBioseq_setHandler | |
| CBioseq_SplitInfo | |
| CBioseqContext | |
| CBioseqHandler | |
| CBioseqSeqInfoSrc | Implementation of the IBlastSeqInfoSrc interface to encapsulate retrieval of sequence identifiers and lengths from a CBioseq/CBioseq_set object |
| CBioSource | |
| CBioSource_Base | BioSource gives the source of the biological material for sequences |
| CBiostruc | |
| CBiostruc_align | CBiostruc_align -- |
| CBiostruc_align_Base | CBiostruc_align_Base -- |
| CBiostruc_align_seq | CBiostruc_align_seq -- |
| CBiostruc_align_seq_Base | Display seq structure align only |
| CBiostruc_annot_set | CBiostruc_annot_set -- |
| CBiostruc_annot_set_Base | A biostruc annotation set is a means to collect ASN.1 data for biostruc features into one file |
| CBiostruc_Base | A structure report or "biostruc" describes the components of a biomolecular assembly in terms of their names and descriptions, and a chemical graph giving atomic formula, connectivity and chirality |
| CBiostruc_descr | CBiostruc_descr -- |
| CBiostruc_descr_Base | The description of a biostruc refers to both the reported chemical and spatial structure of a biomolecular assembly |
| CBiostruc_feature | CBiostruc_feature -- |
| CBiostruc_feature_Base | An explicitly specified type in Biostruc-feature allows for efficient extraction and indexing of feature sets of a specific type |
| CBiostruc_feature_id | CBiostruc_feature_id -- |
| CBiostruc_feature_id_Base | CBiostruc_feature_id_Base -- |
| CBiostruc_feature_set | CBiostruc_feature_set -- |
| CBiostruc_feature_set_Base | Named model features refer to sets of residues or atoms, or a region in the model space |
| CBiostruc_feature_set_descr | CBiostruc_feature_set_descr -- |
| CBiostruc_feature_set_descr_Base | CBiostruc_feature_set_descr_Base -- |
| CBiostruc_feature_set_id | CBiostruc_feature_set_id -- |
| CBiostruc_feature_set_id_Base | CBiostruc_feature_set_id_Base -- |
| CBiostruc_graph | CBiostruc_graph -- |
| CBiostruc_graph_Base | A biostruc graph contains the complete chemical graph of the biomolecular assembly |
| CBiostruc_graph_pntr | CBiostruc_graph_pntr -- |
| CBiostruc_graph_pntr_Base | CBiostruc_graph_pntr_Base -- |
| CBiostruc_history | CBiostruc_history -- |
| CBiostruc_history_Base | The history of a biostruc indicates it's origin and it's update history within MMDB, the NCBI-maintained molecular structure database |
| CBiostruc_id | CBiostruc_id -- |
| CBiostruc_id_Base | A Biostruc-id is a collection identifiers for the molecular assembly |
| CBiostruc_model | CBiostruc_model -- |
| CBiostruc_model_Base | A structural model maps chemical components into a measured three- dimensional space |
| CBiostruc_molecule_pntr | CBiostruc_molecule_pntr -- |
| CBiostruc_molecule_pntr_Base | Atom, residue or molecule motifs describe a substructure defined by a set of nodes from the chemical graph |
| CBiostruc_replace | CBiostruc_replace -- |
| CBiostruc_replace_Base | CBiostruc_replace_Base -- |
| CBiostruc_residue_graph_set | CBiostruc_residue_graph_set -- |
| CBiostruc_residue_graph_set_Base | A biostruc residue graph set is a collection of residue graphs |
| CBiostruc_residue_graph_set_pntr | CBiostruc_residue_graph_set_pntr -- |
| CBiostruc_residue_graph_set_pntr_Base | CBiostruc_residue_graph_set_pntr_Base -- |
| CBiostruc_script | CBiostruc_script -- |
| CBiostruc_script_Base | When a Biostruc-Feature with a Biostruc-script is initiated, it should play the specified steps one at a time, setting the feature-do list as the active display |
| CBiostruc_script_step | CBiostruc_script_step -- |
| CBiostruc_script_step_Base | CBiostruc_script_step_Base -- |
| CBiostruc_seq | CBiostruc_seq -- |
| CBiostruc_seq_Base | Display structure seq added by yanli |
| CBiostruc_seqs | CBiostruc_seqs -- |
| CBiostruc_seqs_aligns_cdd | CBiostruc_seqs_aligns_cdd -- |
| CBiostruc_seqs_aligns_cdd_Base | CBiostruc_seqs_aligns_cdd_Base -- |
| CBiostruc_seqs_Base | Display blast alignment along with neighbor's structure added by yanli |
| CBiostruc_set | CBiostruc_set -- |
| CBiostruc_set_Base | A biostruc set is a means to collect ASN.1 data for many biostrucs in one file, as convenient for application programs |
| CBiostruc_source | CBiostruc_source -- |
| CBiostruc_source_Base | The origin of a biostruc is a reference to another database |
| CBioTree< TBioNode > | Basic tree structure for biological applications |
| CBioTreeAttrReader | Parser-reader for BKBTA - biotree attributes format |
| CBioTreeContainer | |
| CBioTreeContainer_Base | CBioTreeContainer_Base -- |
| CBioTreeContainerHandler | ******************************************************************* Moved from plugins/algo/init |
| CBioTreeConvert2ContainerFunc< TBioTreeContainer, TDynamicTree > | Visitor functor to convert dynamic tree nodes to ASN.1 BioTree container |
| CBioTreeEmptyNodeData | Basic node data structure used by BioTreeBaseNode |
| CBioTreeFeatureDictionary | Feature dictionary |
| CBioTreeFeatureList | Features storage for the bio tree node |
| CBioTreeFeaturePair | Tree node feature pair (id to string) |
| CBioTreeForest< BioTree > | Set of BioTree objects managed as a single forest |
| oligofar::CBitHacks | |
| oligofar::CBitmaskAccess | |
| oligofar::CBitmaskBase | |
| oligofar::CBitmaskBuilder | |
| CBitStringDataType | |
| CBitStringDataValue | |
| CBitStringFunctions | |
| CBitStringTypeStrings | |
| CBl2Seq | Runs the BLAST algorithm between 2 sequences |
| CBlast4_alignments_for_query | CBlast4_alignments_for_query -- |
| CBlast4_alignments_for_query_Base | Alignments for one query, compiled from the raw SeqAlign results |
| CBlast4_archive | CBlast4_archive -- |
| CBlast4_archive_Base | An archive format for results |
| CBlast4_common_options | CBlast4_common_options -- |
| CBlast4_common_options_Base | CBlast4_common_options_Base -- |
| CBlast4_common_options_db_restriction | CBlast4_common_options_db_restriction -- |
| CBlast4_common_options_db_restriction_Base | CBlast4_common_options_db_restriction_Base -- |
| CBlast4_common_options_db_restriction_by_organism | CBlast4_common_options_db_restriction_by_organism -- |
| CBlast4_common_options_db_restriction_by_organism_Base | Data types to be used in BLAST4 "Lite" |
| CBlast4_common_options_discontiguous_megablast | CBlast4_common_options_discontiguous_megablast -- |
| CBlast4_common_options_discontiguous_megablast_Base | CBlast4_common_options_discontiguous_megablast_Base -- |
| CBlast4_common_options_nucleotide_query | CBlast4_common_options_nucleotide_query -- |
| CBlast4_common_options_nucleotide_query_Base | CBlast4_common_options_nucleotide_query_Base -- |
| CBlast4_common_options_query_filtering | CBlast4_common_options_query_filtering -- |
| CBlast4_common_options_query_filtering_Base | CBlast4_common_options_query_filtering_Base -- |
| CBlast4_common_options_repeats_filtering | CBlast4_common_options_repeats_filtering -- |
| CBlast4_common_options_repeats_filtering_Base | CBlast4_common_options_repeats_filtering_Base -- |
| CBlast4_common_options_scoring | CBlast4_common_options_scoring -- |
| CBlast4_common_options_scoring_Base | CBlast4_common_options_scoring_Base -- |
| CBlast4_cutoff | CBlast4_cutoff -- |
| CBlast4_cutoff_Base | Other types in alphabetical order |
| CBlast4_database | |
| CBlast4_database_Base | CBlast4_database_Base -- |
| CBlast4_database_info | CBlast4_database_info -- |
| CBlast4_database_info_Base | CBlast4_database_info_Base -- |
| CBlast4_error | CBlast4_error -- |
| CBlast4_error_Base | Errors |
| CBlast4_finish_params_reply | CBlast4_finish_params_reply -- |
| CBlast4_finish_params_reply_Base | CBlast4_finish_params_reply_Base -- |
| CBlast4_finish_params_request | CBlast4_finish_params_request -- |
| CBlast4_finish_params_request_Base | CBlast4_finish_params_request_Base -- |
| CBlast4_get_databases_reply | CBlast4_get_databases_reply -- |
| CBlast4_get_databases_reply_Base | CBlast4_get_databases_reply_Base -- |
| CBlast4_get_matrices_reply | CBlast4_get_matrices_reply -- |
| CBlast4_get_matrices_reply_Base | CBlast4_get_matrices_reply_Base -- |
| CBlast4_get_parameters_reply | CBlast4_get_parameters_reply -- |
| CBlast4_get_parameters_reply_Base | CBlast4_get_parameters_reply_Base -- |
| CBlast4_get_paramsets_reply | CBlast4_get_paramsets_reply -- |
| CBlast4_get_paramsets_reply_Base | Note: Paramsets and tasks represent the same concept: a human readable description that represents a set of parameters with specific values to accomplish a given task |
| CBlast4_get_programs_reply | CBlast4_get_programs_reply -- |
| CBlast4_get_programs_reply_Base | CBlast4_get_programs_reply_Base -- |
| CBlast4_get_protocol_info_reply | CBlast4_get_protocol_info_reply -- |
| CBlast4_get_protocol_info_reply_Base | CBlast4_get_protocol_info_reply_Base -- |
| CBlast4_get_protocol_info_request | CBlast4_get_protocol_info_request -- |
| CBlast4_get_protocol_info_request_Base | Support for version and checking availability of methods |
| CBlast4_get_queries_reply | CBlast4_get_queries_reply -- |
| CBlast4_get_queries_reply_Base | CBlast4_get_queries_reply_Base -- |
| CBlast4_get_request_info_reply | CBlast4_get_request_info_reply -- |
| CBlast4_get_request_info_reply_Base | CBlast4_get_request_info_reply_Base -- |
| CBlast4_get_request_info_request | CBlast4_get_request_info_request -- |
| CBlast4_get_request_info_request_Base | Fetch information about the search request |
| CBlast4_get_search_info_reply | CBlast4_get_search_info_reply -- |
| CBlast4_get_search_info_reply_Base | CBlast4_get_search_info_reply_Base -- |
| CBlast4_get_search_info_request | CBlast4_get_search_info_request -- |
| CBlast4_get_search_info_request_Base | Variose search information |
| CBlast4_get_search_results_reply | CBlast4_get_search_results_reply -- |
| CBlast4_get_search_results_reply_Base | CBlast4_get_search_results_reply_Base -- |
| CBlast4_get_search_results_request | CBlast4_get_search_results_request -- |
| CBlast4_get_search_results_request_Base | CBlast4_get_search_results_request_Base -- |
| CBlast4_get_search_status_reply | CBlast4_get_search_status_reply -- |
| CBlast4_get_search_status_reply_Base | Reply to retrieve the status of a given search |
| CBlast4_get_search_status_request | CBlast4_get_search_status_request -- |
| CBlast4_get_search_status_request_Base | Request to retrieve the status of a given search |
| CBlast4_get_search_strategy_reply | CBlast4_get_search_strategy_reply -- |
| CBlast4_get_search_strategy_reply_Base | Return the search strategy (i.e |
| CBlast4_get_search_strategy_request | CBlast4_get_search_strategy_request -- |
| CBlast4_get_search_strategy_request_Base | Fetch the search strategy (i.e |
| CBlast4_get_seq_parts_reply | CBlast4_get_seq_parts_reply -- |
| CBlast4_get_seq_parts_reply_Base | CBlast4_get_seq_parts_reply_Base -- |
| CBlast4_get_seq_parts_request | CBlast4_get_seq_parts_request -- |
| CBlast4_get_seq_parts_request_Base | Fetch parts of sequences from a BLAST database |
| CBlast4_get_sequences_reply | CBlast4_get_sequences_reply -- |
| CBlast4_get_sequences_reply_Base | CBlast4_get_sequences_reply_Base -- |
| CBlast4_get_sequences_request | CBlast4_get_sequences_request -- |
| CBlast4_get_sequences_request_Base | Fetch sequence data from a BLAST database |
| CBlast4_get_windowmasked_taxids_reply | CBlast4_get_windowmasked_taxids_reply -- |
| CBlast4_get_windowmasked_taxids_reply_Base | CBlast4_get_windowmasked_taxids_reply_Base -- |
| CBlast4_ka_block | CBlast4_ka_block -- |
| CBlast4_ka_block_Base | CBlast4_ka_block_Base -- |
| CBlast4_mask | CBlast4_mask -- |
| CBlast4_mask_Base | Masking locations for a query's frame |
| CBlast4_matrix_id | CBlast4_matrix_id -- |
| CBlast4_matrix_id_Base | CBlast4_matrix_id_Base -- |
| CBlast4_options_lite | CBlast4_options_lite -- |
| CBlast4_options_lite_Base | CBlast4_options_lite_Base -- |
| CBlast4_parameter | CBlast4_parameter -- |
| CBlast4_parameter_Base | CBlast4_parameter_Base -- |
| CBlast4_parameter_info | CBlast4_parameter_info -- |
| CBlast4_parameter_info_Base | CBlast4_parameter_info_Base -- |
| CBlast4_parameters | |
| CBlast4_parameters_Base | CBlast4_parameters_Base -- |
| CBlast4_phi_alignments | CBlast4_phi_alignments -- |
| CBlast4_phi_alignments_Base | CBlast4_phi_alignments_Base -- |
| CBlast4_program_info | CBlast4_program_info -- |
| CBlast4_program_info_Base | CBlast4_program_info_Base -- |
| CBlast4_queries | |
| CBlast4_queries_Base | If a PSSM is used (ie |
| CBlast4_queue_search_reply | CBlast4_queue_search_reply -- |
| CBlast4_queue_search_reply_Base | CBlast4_queue_search_reply_Base -- |
| CBlast4_queue_search_request | CBlast4_queue_search_request -- |
| CBlast4_queue_search_request_Base | Options have been broken down into three groups as part of the BLAST API work |
| CBlast4_queue_search_request_lite | CBlast4_queue_search_request_lite -- |
| CBlast4_queue_search_request_lite_Base | Simplified search submission structure |
| CBlast4_range | |
| CBlast4_range_Base | Range on a sequence - zero offset |
| CBlast4_reply | CBlast4_reply -- |
| CBlast4_reply_Base | Replies |
| CBlast4_reply_body | CBlast4_reply_body -- |
| CBlast4_reply_body_Base | CBlast4_reply_body_Base -- |
| CBlast4_request | CBlast4_request -- |
| CBlast4_request_Base | Requests |
| CBlast4_request_body | CBlast4_request_body -- |
| CBlast4_request_body_Base | CBlast4_request_body_Base -- |
| CBlast4_seq_part_data | CBlast4_seq_part_data -- |
| CBlast4_seq_part_data_Base | Bundles Seq-ids and sequence data to fulfill requests of type Blast4-get-seq-parts-request |
| CBlast4_simple_alignment | CBlast4_simple_alignment -- |
| CBlast4_simple_alignment_Base | A single alignment |
| CBlast4_simple_results | CBlast4_simple_results -- |
| CBlast4_simple_results_Base | Complete set of simple Blast results |
| CBlast4_subject | CBlast4_subject -- |
| CBlast4_subject_Base | CBlast4_subject_Base -- |
| CBlast4_task_info | CBlast4_task_info -- |
| CBlast4_task_info_Base | Self documenting task structure |
| CBlast4_value | CBlast4_value -- |
| CBlast4_value_Base | CBlast4_value_Base -- |
| CBlast4Client | CBlast4Client -- |
| CBlast4Client_Base | CBlast4Client_Base -- |
| CBlast4Field | Field properties for options in a Blast4 parameter list |
| CBLAST_DB_Dialog | CBLAST_DB_Dialog |
| CBlast_db_mask_info | CBlast_db_mask_info -- |
| CBlast_db_mask_info_Base | Defines the masking information for a set of sequences |
| CBlast_def_line | CBlast_def_line -- |
| CBlast_def_line_Base | CBlast_def_line_Base -- |
| CBlast_def_line_set | |
| CBlast_def_line_set_Base | All deflines for an entry |
| CBLAST_Dlg_Item | |
| CBlast_ExtendWord | Wrapper class for Blast_ExtendWord |
| CBlast_mask_list | CBlast_mask_list -- |
| CBlast_mask_list_Base | CBlast_mask_list_Base -- |
| CBlast_Message | Wrapper class for Blast_Message |
| CBLAST_SequenceBlk | Wrapper class for BLAST_SequenceBlk |
| CBlastAdvancedProteinOptionsHandle | Handle to the Advanced BLASTP options |
| CBlastAligner | |
| CBlastAncillaryData | Class used to return ancillary data from a blast search, i.e |
| CBlastAppArgs | Base command line argument class for a generic BLAST command line binary |
| CBlastArgs | |
| CBlastBioseqMaker | Auxiliary class for creating Bioseqs given SeqIds |
| CBlastDatabaseArgs | Argument class to collect database/subject arguments |
| CBlastDatabaseOptions | Wrapper class for BlastDatabaseOptions |
| CBlastDb_DataLoaderCF | Data Loader Factory for BlastDbDataLoader |
| CBlastDBAliasApp | The main application class |
| CBlastDbBioseqSource | |
| CBlastDbBlob | `Blob' Class for SeqDB (and WriteDB) |
| CBlastDbCheckApplication | CBlastDbCheckApplication: the main application class |
| CBlastDbCheckLog | |
| CBlastDBCmdApp | The application class |
| CBlastDbDataLoader | |
| CBlastDBExtractor | Class to extract data from a BLAST database given an identifier |
| CBlastDbFinder | Functor class for FindFilesInDir |
| CBlastDbFormatter | Customizable BLAST DB information formatter interface |
| CBlastDbMetadata | Proxy class for retrieving meta data from a BLAST DB |
| CBlastDBSeqId | Encapsulates identifier to retrieve data from a BLAST database |
| CBlastDbSet | |
| CBlastDemoApplication | |
| CBLASTDlgItemData | CExplorerItemData - tree item attachment pointing back to CExplorerItem |
| CBlastEffectiveLengthsOptions | Wrapper class for BlastEffectiveLengthsOptions |
| CBlastEffectiveLengthsParameters | Wrapper class for BlastEffectiveLengthsParameters |
| CBlastException | Defines BLAST error codes (user errors included) |
| CBlastExtendTestFixture | |
| CBlastExtensionOptions | Wrapper class for BlastExtensionOptions |
| CBlastExtensionParameters | Wrapper class for BlastExtensionParameters |
| CBlastFastaInputSource | Class representing a text file containing sequences in fasta format |
| CBlastFilterTest | |
| CBlastFormat | This class formats the BLAST results for command line applications |
| CBlastFormatterApp | The application class |
| CBlastFormattingMatrix | 256x256 matrix used for calculating positives etc |
| CBlastFormatUtil | Setting up scope |
| CBlastGapAlignStruct | Wrapper class for BlastGapAlignStruct |
| CBlastHitMatrix | This class displays the image of the hitmatrix view for blast 2 seq results |
| CBlastHitMatrixCGIApplication | CBlastHitMatrixCGIApplication This CGI loads an accession from GenBank, extract a Seq-annot from the sequence and renders a pairwise alignment between the first two Seq-id in the alignment |
| CBlastHitMatrixCGIException | |
| CBlastHitSavingOptions | Wrapper class for BlastHitSavingOptions |
| CBlastHitSavingParameters | Wrapper class for BlastHitSavingParameters |
| CBlastHSPListQueueData | Data structure for the queue implementation of BlastHSPStream |
| CBlastHSPResults | Wrapper class for BlastHSPResults |
| CBlastInitialWordOptions | Wrapper class for BlastInitialWordOptions |
| CBlastInitialWordParameters | Wrapper class for BlastInitialWordParameters |
| CBlastInput | Generalized converter from an abstract source of biological sequence data to collections of blast input |
| CBlastInputDemoApplication | |
| CBlastInputReader | Class to read non-FASTA sequence input to BLAST programs using the various data loaders configured in CBlastScopeSource objects |
| CBlastInputSource | Base class representing a source of biological sequences |
| CBlastInputSourceConfig | Class that centralizes the configuration data for sequences to be converted |
| CBlastMaskLoc | Wrapper class for BlastMaskLoc |
| CBlastnApp | |
| CBlastnAppArgs | Handles command line arguments for blastn binary |
| CBlastNucleotideOptionsHandle | Handle to the nucleotide-nucleotide options to the BLAST algorithm |
| TestUtil::CBlastOM | Class which registers the BLAST database and Genbank data loaders as a non-default data loaders with the object manager upon construction |
| CBlastOptions | Encapsulates ALL the BLAST algorithm's options |
| CBlastOptionsBuilder | Class to build CBlastOptionsHandle from blast4 ASN objects |
| CBlastOptionsFactory | Creates BlastOptionsHandle objects with default values for the programs/tasks requested |
| CBlastOptionsHandle | Handle to the options to the BLAST algorithm |
| CBlastOptionsLocal | Encapsulates all blast input parameters |
| CBlastOptionsMemento | Class that allows the transfer of data structures from the CBlastOptionsLocal class to either the BLAST preliminary or traceback search classes |
| CBlastOptionsRemote | Encapsulates all blast input parameters |
| CBlastOutput | CBlastOutput -- |
| CBlastOutput_Base | CBlastOutput_Base -- |
| CBlastpApp | |
| CBlastpAppArgs | Handles command line arguments for blastp binary |
| CBLASTParams | CBLASTParams - save user-specified parameters and preferences |
| CBlastPrelimSearch | Search class to perform the preliminary stage of the BLAST search |
| CBlastProteinOptionsHandle | Handle to the protein-protein options to the BLAST algorithm |
| CBlastQueryFilteredFrames | Collection of BlastSeqLoc lists for filtering processing |
| CBlastQueryInfo | Wrapper class for BlastQueryInfo |
| CBlastQuerySourceBioseqSet | Implements the IBlastQuerySource interface using a CBioseq_set as data source |
| CBlastQuerySourceOM | Implements the object manager dependant version of the IBlastQuerySource |
| CBlastQueryVector | Query Vector |
| CBlastRPSAuxInfo | Wrapper class to manage the BlastRPSAuxInfo structure, as currently there aren't any allocation or deallocation functions for this structure in the CORE of BLAST |
| CBlastRPSInfo | Wrapper class to manage the BlastRPSInfo structure, as currently there aren't any allocation or deallocation functions for this structure in the CORE of BLAST |
| CBlastRPSOptionsHandle | Handle to the rpsblast options to the BLAST algorithm |
| CBlastSampleApplication | |
| CBlastScopeSource | Class whose purpose is to create CScope objects which have data loaders added with different priorities, so that the BLAST database data loader is used first, then the Genbank data loader |
| CBlastScopeSourceWrapper | RAII class for the CBlastScopeSource |
| CBlastScoreBlk | Wrapper class for BlastScoreBlk |
| CBlastScorer | |
| CBlastScoringOptions | Wrapper class for BlastScoringOptions |
| CBlastScoringParameters | Wrapper class for BlastScoringParameters |
| CBLASTSearchOptionsPanel | |
| CBLASTSearchParamsPanel | |
| CBlastSearchQuery | Search Query |
| CBlastSearchTask | TODO |
| CBLASTSearchToolManager | CBLASTSearchToolManager |
| CBlastSeqLoc | Wrapper class for BlastSeqLoc |
| CBlastSeqLocWrap | Wrapper for BlastSeqLoc structure |
| CBlastSeqSrc | Wrapper class for BlastSeqSrc |
| CBlastSeqSrcIterator | Wrapper class for BlastSeqSrcIterator |
| CBLASTSeqToolJob | CBLASTSeqToolJob |
| CBLASTSeqToolManager | CBLASTSeqToolManager |
| CBlastSequenceSource | |
| CBlastSeqVectorFromCSeq_data | Implementation of the IBlastSeqVector interface which obtains data from a CSeq_data object |
| CBlastSeqVectorOM | Implementation of the IBlastSeqVector interface which obtains data from a CSeq_loc and a CScope relying on the CSeqVector class |
| CBlastServices | API for Remote Blast Services |
| CBlastServicesException | RemoteServicesException |
| CBlastSetupTestFixture | |
| CBlastSystemException | Defines system exceptions occurred while running BLAST |
| CBlastTabular | |
| CBlastTabularInfo | Class containing information needed for tabular formatting of BLAST results |
| CBLASTToolManagerBase | CBLASTToolManagerBase |
| CBlastTracebackSearch | |
| CBlastVersion | Keeps track of the version of the BLAST engine in the NCBI C++ toolkit |
| CBlastxApp | |
| CBlastxAppArgs | Handles command line arguments for blastx binary |
| CBlastxOptionsHandle | Handle to the translated nucleotide-protein options to the BLAST algorithm |
| CBlob_id | |
| CBlob_Info | |
| CBlobBookmark | Object used to store bookmarks to blobs to be changed later |
| CBlobBookmarkImpl | |
| CBlobId | |
| CBlobIdFor< Value, Converter > | |
| CBlobIdKey | |
| CBlobIStream | |
| CBlobLoader | |
| CBlobMetaDB | Dictionary file, storing references on external BLOB file (super BLOB structure) |
| CBlobOStream | |
| CBlobReader | |
| CBlobRetriever | |
| CBlobSplitter | |
| CBlobSplitterImpl | |
| CBlobStateException | Blob state exceptions, used by GenBank loader |
| CBlobStorage_NetCache | CBlobStorage_NetCache -- NetCache-based implementation of IBlobStorage |
| CBlobStorage_Null | An Empty implementation of Blob Storage Interface |
| CBlobStorageException | Blob Storage Exception |
| CBlobStorageFactory | Blob Storage Factory interface |
| CBlobStorageFactory_Null | Blob Storage Factory interface |
| CBlobStorageNetCacheCF | |
| CBlobStoreBase | |
| CBlobStoreDynamic | |
| CBlobStoreStatic | |
| CWriter::CBlobStream | |
| CBlobStreamHelper | |
| CBlobWriter | |
| CBlockDataValue | |
| CBlockedAlignmentEditor | |
| CBV_PoolBlockAlloc< BA, Lock >::CBlockFactory | |
| CBlockingQueue< TRequest > | CBlockingQueue<> -- queue of requests, with efficiently blocking Get() |
| CBlockingQueue_ForServer | |
| CBlockingQueueException | |
| CBlockProperty | CBlockProperty -- |
| CBlockProperty_Base | Rudimentary block/core-model, to be used with block-based alignment routines and threading |
| CBMARefinerBlockEditPhase | |
| CBMARefinerCycle | |
| CBMARefinerEngine | |
| CBMARefinerLOOPhase | |
| CBMARefinerPhase | |
| CBMARefinerTrial | |
| CBMode | |
| CBondList | |
| CBookChapterPanel | |
| CBookmark | Class CBookmark defines the data stored in an individual sequence-based bookmark |
| CBookmarkManager | Class CBookmarkManager manages a set of bookmarks, complete with hooks for serialization and efficient retrieval of bookmarks for a given seq-id |
| CBookmarksHandler | Class CBookmarksHandler represents in GUI a bookmarks on a sequence bar |
| CBookPanel | |
| pythonpp::CBool | |
| CBoolDataType | |
| CBoolGuard | |
| CElementaryMatching::CBoolVector | |
| CBoundaryParams | IBoundaryParams |
| CBoundaryParms | CBoundaryParms |
| CBoundaryPoints | CBoundaryPoints -- |
| CBoundaryShapeRect | CBoundaryShapeRect -- |
| CBoundaryShapeRectBase | CBoundaryShapeRectBase -- |
| CBoundaryShapeRoundedRect | CBoundaryShapeRoundedRect -- |
| CBoundaryShapeTri | CBoundaryShapeTri -- |
| CBoyerMooreMatcher | This implemetation uses the Boyer-Moore alg |
| CBrick | CBrick -- |
| CBrick_Base | A brick is defined by the coordinates of eight corners |
| CBroadcastDialog | |
| CBroadcastVRChangeDialog | |
| CBrowserUtils | |
| CBssInfoApp | |
| CBucketPool< Value, Lock, RPool > | Bucket of resourse pools |
| pythonpp::CBuffer | |
| CBufferedLineReader | Implementation of ILineReader for IReader |
| CBufferedSockReaderWriter | Object reading/writing from socket and automatically buffering data |
| CBufferWriter< TBuffer > | |
| CBufferWriterStream< Buffer > | |
| CBuildAlnVecJob | CBuildAlnVecJob |
| CBuildAlnVecResult | CBuildAlnVecResult |
| CBuildDatabase | Build BlastDB format databases from various data sources |
| CBuildOptionsDlg | CwxBuildOptionsDlg |
| CBuildSparseAlnJob | CBuildSparseAlnJob |
| CBuildSparseAlnResult | CBuildAlnVecResult |
| CBuildType | Utility class for distinguish between static and dll builds |
| CBulkInsert | Object used to perform bulk-inserting operations to database |
| CBulkInsertImpl | |
| CBundle_seqs_aligns | CBundle_seqs_aligns -- |
| CBundle_seqs_aligns_Base | Generic bundle of sequence and alignment info |
| CButtonList | |
| CBV_PoolBlockAlloc< BA, Lock > | Thread-safe pool block allocator for NCBI bitsets |
| CBvGapFactory< TBV > | Bit-vector factory |
| CBVResourcePool< BV, Lock > | Resource pool for bit-vectors Bit-vector creation-destruction can be expensive, use pool to recycle used objects |
| CByte_graph | CByte_graph -- |
| CByte_graph_Base | Integer from 0-255 |
| CByteSource | |
| CByteSourceReader | |
| CByteStreamBuf | |
| CByteSwap | CByteSwap -- |
| CBZip2Compression | CBZip2Compression -- |
| CBZip2CompressionFile | CBZip2CompressionFile class -- |
| CBZip2Compressor | CBZip2Compressor -- bzip2 based compressor |
| CBZip2Decompressor | CBZip2Decompressor -- bzip2 based decompressor |
| CBZip2StreamCompressor | CBZip2StreamCompressor -- bzip2 based compression stream processor |
| CBZip2StreamDecompressor | CLZOStreamDecompressor -- bzip2 based decompression stream processor |
| CCache< TKey, TValue, THandler, TLock, TSize > | Cache template |
| CCacheBlobStream | |
| CCacheBufferResizeStrategy | Buffer resize strategy, to balance memory reallocs and heap consumption |
| CCacheCleanerThread | Thread class, peridically calls ICache::Purge to remove obsolete elements |
| CCachedDictionary | Class CCachedDictionary provides an internalized mechanism for caching the alternates returned by SuggestAlternates() |
| CCacheDemoApp | |
| python::CCachedResultSet | |
| impl::CCachedRowInfo | |
| CCachedSeqDataForRemote | This class defines a "bundle" of elements to cache which are then returned by CRemoteBlastDbAdapter |
| CCachedSequence | Manages a TSE and its subordinate chunks for all implementations of the IBlastDbAdapter interface |
| CCachedTipHandle | |
| CCacheElement_Handler< TKey, TValue > | Default (NOP) element handler |
| CCacheElement_Less< TCacheElementPtr > | Compare cache elements by weight/order |
| CCacheException | Exception thrown by CCache |
| CCacheHashedContent | Hashed content cache |
| CCacheHolder | |
| CCacheReader | |
| CCacheReaderCF | |
| CCacheWriter | |
| CCacheWriterCF | Class factory for Cache writer |
| pythonpp::CCalable | |
| CCalcCaretPosOStream | |
| CCalcCharsOStream | |
| CCalcDataPosOStream | |
| CCalcNBPosOStream | |
| CCalcSizeCache | |
| CCalcSizeOStream | |
| CCalcTextPosOStream | |
| CCallableStatement | |
| python::CCallableStmtHelper | |
| pythonpp::CCallIterator | |
| CCamera | CCamera -- |
| CCamera_Base | The camera is a position relative to the world coordinates of the structure referred to by a location |
| CCancelRequestException | |
| CCategory | CCategory -- |
| CCategory_Base | CCategory_Base -- |
| CCategoryConfig | Data structure holding configuration for a track |
| CCdAnnotationInfo | |
| CCdCore | |
| CCdd | |
| CCdd_Base | Cdd is the basic ASN.1 object storing an annotated and curated set of alignments (formulated as a set of pairwise master-slave alignments) |
| CCdd_book_ref | CCdd_book_ref -- |
| CCdd_book_ref_Base | Record a link to Entrez Books |
| CCdd_DataLoaderCF | |
| CCdd_descr | CCdd_descr -- |
| CCdd_descr_Base | The description of CDD's refers to the specific set of aligned sequences, the region that is being aligned and the information contained in the alignment |
| CCdd_descr_set | CCdd_descr_set -- |
| CCdd_descr_set_Base | CCdd_descr_set_Base -- |
| CCdd_id | CCdd_id -- |
| CCdd_id_Base | CCdd_id_Base -- |
| CCdd_id_set | CCdd_id_set -- |
| CCdd_id_set_Base | CCdd_id_set_Base -- |
| CCdd_org_ref | CCdd_org_ref -- |
| CCdd_org_ref_Base | Dealing with lists of preferred tax-nodes |
| CCdd_org_ref_set | CCdd_org_ref_set -- |
| CCdd_org_ref_set_Base | CCdd_org_ref_set_Base -- |
| CCdd_pref_node_descr | CCdd_pref_node_descr -- |
| CCdd_pref_node_descr_Base | CCdd_pref_node_descr_Base -- |
| CCdd_pref_node_descr_set | CCdd_pref_node_descr_set -- |
| CCdd_pref_node_descr_set_Base | CCdd_pref_node_descr_set_Base -- |
| CCdd_pref_nodes | CCdd_pref_nodes -- |
| CCdd_pref_nodes_Base | CCdd_pref_nodes_Base -- |
| CCdd_Project | CCdd_Project -- |
| CCdd_Project_Base | Cd colors are as: 0000FF for red, 00FF00 for green, FF0000 for blue |
| CCdd_repeat | CCdd_repeat -- |
| CCdd_repeat_Base | Record whether the CD contains repeated sequence/structure motifs |
| CCdd_Script | CCdd_Script -- |
| CCdd_Script_Base | CCdd_Script_Base -- |
| CCdd_set | CCdd_set -- |
| CCdd_set_Base | CCdd_set_Base -- |
| CCdd_tree | CCdd_tree -- |
| CCdd_tree_Base | Cdd-tree stores the hierarchy of CDDs |
| CCdd_tree_set | CCdd_tree_set -- |
| CCdd_tree_set_Base | CCdd_tree_set_Base -- |
| CCdd_Viewer | CCdd_Viewer -- |
| CCdd_Viewer_Base | CCdd_Viewer_Base -- |
| CCdd_Viewer_Rect | CCdd_Viewer_Rect -- |
| CCdd_Viewer_Rect_Base | Cdd projects store a set of CDs, typically related to each other relationships would be specified using the ancestors fields in the individual CD objects |
| CCdDbPriority | |
| CCddDataLoader | |
| CCddInputData | Strategy for pre-processing RPS-BLAST matches for PSSM computation |
| CCdFromFasta | |
| CCdregion | CCdregion -- |
| CCdregion_Base | CdRegion *********************************************** |
| CCdregion_translate | Public interface for coding region translation function Uses CTrans_table in <objects/seqfeat/Genetic_code_table.hpp> for rapid translation from a given genetic code, allowing all of the iupac nucleotide ambiguity characters |
| variation::CVariationUtil::CCdregionIndex | Cache seq-data in the CDS regions and the cds features by location |
| CCdsConfig | |
| CCDSExceptionPanel | |
| CCdsForMrnaPlugin | |
| CCDSGeneProt_constraint_field | CCDSGeneProt_constraint_field -- |
| CCDSGeneProt_constraint_field_Base | CCDSGeneProt_constraint_field_Base -- |
| CCDSGeneProt_field_pair | CCDSGeneProt_field_pair -- |
| CCDSGeneProt_field_pair_Base | CCDSGeneProt_field_pair_Base -- |
| CCDSGeneProt_pseudo_constraint | CCDSGeneProt_pseudo_constraint -- |
| CCDSGeneProt_pseudo_constraint_Base | CCDSGeneProt_pseudo_constraint_Base -- |
| CCDSGeneProt_qual_constraint | CCDSGeneProt_qual_constraint -- |
| CCDSGeneProt_qual_constraint_Base | CCDSGeneProt_qual_constraint_Base -- |
| CCdsGlyph | |
| CCDSInfo | |
| CCDSProductPanel | |
| CCDSProteinPanel | |
| CCDSTranslationPanel | |
| oligofar::CAligner::CCell | |
| pythonpp::CCell | |
| CCgi2RCgiApp | |
| CCgiApplication | |
| CCgiApplicationCached | |
| CCgiContext | |
| CCgiCookie | CCgiCookie:: |
| CCgiCookieException | CCgiCookieException -- |
| CCgiCookies | CCgiCookies:: |
| CCgiEntries_Parser | |
| CCgiEntry | |
| CCgiEntryReader | |
| CCgiEntryReaderContext | |
| CCgiEnvHolder | |
| CCgiErrnoException | CCgiErrnoException -- |
| CCgiException | |
| CCgiFontTestApp | |
| CCgiIbuffer | |
| CCgiObuffer | |
| CCgiParseException | CCgiParseException -- |
| CCgiRedirectApplication | CCgiRedirectApplication -- |
| CCgiRequest | CCgiRequest:: |
| CCgiRequestException | CCgiRequestException -- |
| CCgiResponse | |
| CCgiResponseException | CCgiResponseException -- |
| CCgiSampleApplication | |
| CCgiServerContext | |
| CCgiSession | CCgiSession -- |
| CCgiSession_NetCache | |
| CCgiSessionException | CCgiSessionException -- |
| CCgiSessionParameters | |
| CCgiSessionSampleApplication | |
| CCgiStatistics | |
| CCGIStreamReader | |
| CCGIStreamWriter | |
| CCgiTunnel2Grid | |
| CCgiUserAgent | CCgiUserAgent -- |
| CCgiWorkerNodeJob | |
| CCgiWorkerNodeJobFactory | |
| CChain | |
| CChainer | |
| CChainerArgUtil | |
| CChainer::CChainerImpl | |
| CChainMembers | |
| CChangePhyloTreeCommand | |
| CChangeSeqFeatCommand | |
| CChangeUnindexedObjectCommand< T > | |
| pythonpp::CChar | |
| CCharacterSet | CCharacterSet -- |
| CCharInSet | |
| CCharPtrFunctions< T > | |
| CChartElem | |
| CCharVectorFunctions< Char > | |
| CCharVectorFunctionsBase | |
| CCharVectorTypeInfo< Char > | |
| CCheckBox | CCheckBox -- |
| CCheckBox_Base | CCheckBox_Base -- |
| CChecksum | CChecksum -- Checksum calculator |
| CChecksumStreamWriter | CChecksumStreamWriter -- |
| CChem_graph_alignment | CChem_graph_alignment -- |
| CChem_graph_alignment_Base | A biostruc alignment establishes an equivalence of nodes in the chemical graphs of two or more biostrucs |
| CChem_graph_interaction | CChem_graph_interaction -- |
| CChem_graph_interaction_Base | CChem_graph_interaction_Base -- |
| CChem_graph_pntrs | CChem_graph_pntrs -- |
| CChem_graph_pntrs_Base | CChem_graph_pntrs_Base -- |
| CChiral_center | CChiral_center -- |
| CChiral_center_Base | Chiral centers are atoms with tetrahedral geometry |
| CChoice | CChoice -- |
| CQueryMacro::CChoice | CHOICE descriptor (list of options to choose from |
| CChoice_Base | CChoice_Base -- |
| CChoiceDataType | |
| CChoiceItem | CChoiceItem -- |
| CChoiceItem_Base | CChoiceItem_Base -- |
| CChoicePointerTypeInfo | |
| CChoicePtrRefTypeStrings | |
| CChoicePtrTypeStrings | |
| CChoiceRefTypeStrings | |
| CChoiceTypeInfo | |
| CChoiceTypeInfoFunctions | |
| CChoiceTypeStrings | |
| CChymoP | EMSEnzymes_chymotrypsin_p chymotrypsin without proline rule |
| CChymotrypsin | |
| CCIGAR_Formatter | The base class for alignment formatters which use CIGAR format |
| CCit_art | |
| CCit_art_Base | Citation Types article in journal or book |
| CCit_book | |
| CCit_book_Base | Book citation |
| CCit_gen | |
| CCit_gen_Base | NOT from ANSI, this is a catchall |
| CCit_jour | |
| CCit_jour_Base | Journal citation |
| CCit_let | |
| CCit_let_Base | Letter, thesis, or manuscript |
| CCit_pat | |
| CCit_pat_Base | Patent number and date-issue were made optional in 1997 to support patent applications being issued from the USPTO Semantically a Cit-pat must have either a patent number or an application number (or both) to be valid patent citation |
| CCit_proc | |
| CCit_proc_Base | Meeting proceedings |
| CCit_sub | |
| CCit_sub_Base | NOTE: this is just to cite a direct data submission, see NCBI-Submit for the form of a sequence submission citation for a direct submission |
| CCitationsPanel | |
| CCitRetract | CCitRetract -- |
| CCitRetract_Base | CCitRetract_Base -- |
| CCitSubPanel | |
| CCL | CCL -- |
| pythonpp::CExtObject< T >::CClass< N > | |
| pythonpp::CExtModule< T >::CClass< N > | |
| CClassCode | |
| CClassContext | |
| CClassInfoHelper< C > | |
| CClassInfoHelperBase | |
| CClassPrePostReadWrite< Class > | |
| CClassRefTypeStrings | |
| CClassTypeInfo | |
| CClassTypeInfoBase | |
| CClassTypeStrings | |
| CClCompile | CClCompile -- |
| CCleanup | |
| CCleanupAlignmentsJob | CCleanupAlignmentsJob |
| CCleanupAlignmentsParamsPanel | |
| CCleanupAlignmentsToolManager | CCleanupAlignmentsToolManager |
| CCleanupApp | |
| CCleanupChange | All the changes made during cleanup |
| CCleanupJob | CCleanupJob |
| CCleanupPanel | |
| CCleanupParams | |
| CCleanupProcess | |
| CCleanupTool | CCleanupTool |
| CCleave | |
| CCleaveFactory | Factory to return back object for enzyme |
| CClientPseudoDataType | |
| CClientPseudoTypeStrings | |
| CClInclude | CClInclude -- |
| CClipboard | |
| CClippedScorer | |
| CClockPanelWMClient | CClockPanelWMClient |
| CClockView | CClockView |
| CClockViewFactory | CClockViewFactory |
| CClone_ref | CClone_ref -- |
| CClone_ref_Base | Clone-ref *********************************************** |
| CClone_seq | CClone_seq -- |
| CClone_seq_Base | CClone_seq_Base -- |
| CClone_seq_set | CClone_seq_set -- |
| CClone_seq_set_Base | CClone_seq_set_Base -- |
| CClonePlacementGlyph | CClonePlacementGlyph is similar to CFeatureGlyph, but with different rendering style and settings |
| CClonePlacementParams | CClonePlacementParams: |
| CCLRSupport | CCLRSupport -- |
| CClustalwTool | CClustalwTool |
| CClustalwToolJob | CClustalwToolJob |
| CClustalwToolPanel | |
| CClustalwToolParams | |
| CClusterer | Interface for CClusterer class used for clustering any type of data based on distance matrix |
| CClustererApplication | |
| CClustererException | Exceptions for CClusterer class |
| impl::CCmdBase | |
| CCmdLineArgList | |
| CCmdLineBlastXMLReportData | Strategy class to gather the data for generating BLAST XML output |
| CCn3d_backbone_label_style | CCn3d_backbone_label_style -- |
| CCn3d_backbone_label_style_Base | Style blob for backbone labels |
| CCn3d_backbone_style | CCn3d_backbone_style -- |
| CCn3d_backbone_style_Base | Style blob for backbones only |
| CCn3d_color | CCn3d_color -- |
| CCn3d_color_Base | RGB triplet, interpreted (after division by the scale-factor) as floating point values which should range from [0..1] |
| CCn3d_general_style | CCn3d_general_style -- |
| CCn3d_general_style_Base | Style blob for other objects |
| CCn3d_GL_matrix | CCn3d_GL_matrix -- |
| CCn3d_GL_matrix_Base | GL-ordered transformation matrix |
| CCn3d_molecule_location | CCn3d_molecule_location -- |
| CCn3d_molecule_location_Base | Set of locations on a particular chain |
| CCn3d_object_location | CCn3d_object_location -- |
| CCn3d_object_location_Base | Set of locations on a particular structure object (e.g., a PDB/MMDB structure), which may include multiple ranges of residues each on multiple chains |
| CCn3d_residue_range | CCn3d_residue_range -- |
| CCn3d_residue_range_Base | Range of residues in a chain, identified by MMDB residue-id (e.g., numbered from 1) |
| CCn3d_style_dictionary | CCn3d_style_dictionary -- |
| CCn3d_style_dictionary_Base | Global settings, and a lookup table of styles for user annotations |
| CCn3d_style_settings | CCn3d_style_settings -- |
| CCn3d_style_settings_Base | Rendering settings for Cn3D (mirrors StyleSettings class) |
| CCn3d_style_settings_set | CCn3d_style_settings_set -- |
| CCn3d_style_settings_set_Base | CCn3d_style_settings_set_Base -- |
| CCn3d_style_table_id | CCn3d_style_table_id -- |
| CCn3d_style_table_id_Base | CCn3d_style_table_id_Base -- |
| CCn3d_style_table_item | CCn3d_style_table_item -- |
| CCn3d_style_table_item_Base | CCn3d_style_table_item_Base -- |
| CCn3d_user_annotation | CCn3d_user_annotation -- |
| CCn3d_user_annotation_Base | Information for an individual user annotation |
| CCn3d_user_annotations | CCn3d_user_annotations -- |
| CCn3d_user_annotations_Base | The list of annotations for a given CDD/mime |
| CCn3d_vector | CCn3d_vector -- |
| CCn3d_vector_Base | Floating point 3d vector |
| CCn3d_view_settings | CCn3d_view_settings -- |
| CCn3d_view_settings_Base | Parameters used to set up the camera in Cn3D |
| CCNBr | |
| pythonpp::CCObject | |
| CCObjectClassInfo | |
| CCode_break | CCode_break -- |
| CCode_break_Base | Specific codon exceptions NCBIstdaa code |
| CCodeBreakCompare | |
| CCodeBreakEqual | |
| CCodeGenerator | |
| CCodingPropensity | |
| CCodingRegion | |
| CCoiledCoil | |
| oligofar::CColFileReader | |
| CCollisionGrid2D< ElemType > | Class CCollisionHash2D |
| CColor_prop | CColor_prop -- |
| CColor_prop_Base | CColor_prop_Base -- |
| CColorPanel | |
| CColorPickerValidator | |
| CColorTableMethod | CColorTableMethod |
| CColorTableScoringPanel | CColorTableScoringPanel - Properties Panel for CColorTableMethod |
| oligofar::CColorTwoBase | |
| CColumnLayout | CColumnLayout is for creating layout by sorting glyphs into 'columns' |
| CColumnScoringMethod | CColumnScoringMethod |
| CColumnScoringPanel | CColumnScoringPanel |
| CCombinatorCall | |
| CComboChart | Class CComboChart |
| CComboChartDataSource | Class CComboChartDataSource |
| impl::CCommand | |
| CCommandArgDescriptions | CCommandArgDescriptions -- |
| CCommandLineParser | |
| CCommandProcessor | |
| CCommandToFocusHandler | |
| CComment | CComment -- |
| AbstractLexer::CComment | |
| CComment_Base | CComment_Base -- |
| CComment_rule | |
| CComment_rule_Base | CComment_rule_Base -- |
| CComment_set | |
| CComment_set_Base | CComment_set_Base -- |
| CCommentConfig | CCommentConfig -- help config class for holding a set of settings for a comment glyph |
| CCommentDiagFactory | |
| CCommentDiagHandler | |
| CCommentGlyph | CCommentGlyph -- utility class for having comments in graphical glyphs |
| CCommentItem | |
| CCommentPanel | |
| CComments | |
| CCommonBytes_table | CCommonBytes_table -- |
| CCommonBytes_table_Base | CCommonBytes_table_Base -- |
| CCommonComponentScorer | |
| CCommonString_table | CCommonString_table -- |
| CCommonString_table_Base | CCommonString_table_Base -- |
| CCommonTaxTreeTool | CCommonTaxTreeTool |
| CCompactLayout | CCompactLayout is amed to generate more compact 2D layout policy than layered layout for glyphs with non-uniform height |
| CCompareCRefUserCall | |
| CCompareFeats | CCompareFeats represens a result of comparison of two features |
| CCompareSeq_locs | CCompareSeq_locs is used for comparing locations of two features on the same coordinate system It is agnostic to what type of feature it is and only compares the internal structure of the locs |
| CCompareSeqRegions | Compare multiple feature annotations on the specified seq_locs |
| CCompartApp | |
| CCompartApp::CCompartment | |
| CCompartmentFinder< THit >::CCompartment | Individual compartment representation |
| CCompartmentAccessor< THit > | |
| CCompartmentFinder< THit > | |
| CCompartOptions | |
| CCompatDiagHandler | |
| CCompatStreamDiagHandler | |
| CCompile | CCompile -- |
| CCompilerToolImpl | CCompilerToolImpl -- |
| CBlockingQueue< TRequest >::CCompletingHandle | It may be desirable to store handles obtained from GetHandle() in instances of CCompletingHandle to ensure that they are marked as complete when all is said and done, even in the face of exceptions |
| CBlockingQueue_ForServer::CCompletingHandle | It may be desirable to store handles obtained from GetHandle() in instances of CCompletingHandle to ensure that they are marked as complete when all is said and done, even in the face of exceptions |
| pythonpp::CComplex | |
| oligofar::CComplexityMeasure | |
| CComplexRelation | |
| CComponent | CComponent -- |
| CComponent_Base | CComponent_Base -- |
| CComponentSearchForm | |
| CComponentSearchJob | CComponentSearchJob |
| CComponentSearchQuery | CComponentSearchTool |
| CComponentSearchTool | CComponentSearchTool |
| CComponentVersionInfo | |
| CCompositeAppTask | CCompositeAppTask - an application task that consists of subtasks |
| CCompositeTextItem | |
| CCompositionBasedStatsArgs | Argument class for collecting composition based statistics options |
| CCompoundRegistry | CCompoundRegistry -- |
| CCompoundRWRegistry | CCompoundRWRegistry -- |
| CCompression | |
| CCompressionException | |
| CCompressionFile | |
| CCompressionIOStream | |
| CCompressionIStream | |
| CCompressionOStream | |
| CCompressionProcessor | |
| CCompressionStream | |
| CCompressionStreambuf | |
| CCompressionStreamProcessor | |
| CCompressionUtil | |
| CCompressIStream | CCompressIStream -- |
| CCompressOStream | CCompressOStream -- |
| CCompressStream | CCompressStream -- |
| CCompSpans | |
| CCompVal | |
| CCOMReference | CCOMReference -- |
| CConcurrentMap< Key, Value, Comparator, Allocator, CntChildsInNode, MaxTreeHeight, DeletionDelay, DelStoreCapacity > | |
| CConditionVariableException | CConditionVariable -- |
| CCone | CCone -- |
| CCone_Base | CCone_Base -- |
| CConfig | |
| CConfigException | CConfigException -- |
| CConfigMediator | |
| CConfiguration | CConfiguration -- |
| CConfiguration_Base | CConfiguration_Base -- |
| CConfigurationImpl< ConfTrait > | CConfigurationImpl -- |
| CConfigurations | CConfigurations -- |
| CConfigurations_Base | CConfigurations_Base -- |
| CConfigurationType | CConfigurationType -- |
| CConformation_ensemble | CConformation_ensemble -- |
| CConformation_ensemble_Base | Correlated disorder ensemble is defined by a set of alternate conformation id's which identify coordinates relevant to that ensemble |
| CConn_FileStream | |
| CConn_FTPDownloadStream | CConn_FtpStream specialization (ctor) for download |
| CConn_FtpStream | CConn_FtpStream is an elaborate FTP client, can be used for both data downloading and/or uploading to and from an FTP server |
| CConn_FTPUploadStream | CConn_FtpStream specialization (ctor) for upload |
| CConn_HttpStream | This stream exchanges data with an HTTP server located at the URL: http://host[:port]/path[?args] |
| CConn_IOStream | Base class, inherited from "std::iostream", does both input and output, using the specified CONNECTOR |
| CConn_IOStreamSetReadTimeout | |
| CConn_IOStreamSetTimeout | |
| CConn_IOStreamSetWriteTimeout | |
| CConn_MemoryStream | In-memory stream (a la strstream or stringstream) |
| CConn_NamedPipeStream | CConn_NamedPipeStream for inter-process communication |
| CConn_PipeStream | CConn_PipeStream for command piping |
| CConn_ServiceStream | This stream exchanges data with a named service, in a constraint that the service is implemented as one of the specified server "types" (details: <connect/ncbi_server_info.h>) |
| CConn_SocketStream | This stream exchanges data in a TCP channel, using socket interface |
| CConn_Streambuf | |
| impl::CConnection | CConnection:: |
| CConnection | |
| python::CConnection | |
| CConnectPolicyApp | |
| CConnException | |
| CConnHolder | |
| CConnIniter | Helper hook-up class that installs default logging/registry/locking (but only if they have not yet been installed explicitly by user) |
| CConnTest | |
| CConnTestJob | |
| CConnTestResult | |
| CConnTestThread | |
| CConnValidatorCoR | CConnValidatorCoR |
| CConsortiumPanel | |
| CConstBeginInfo | Class holding information about root of non-modifiable object hierarchy Do not use it directly |
| CConstContainerElementIterator | |
| CConstIRef< Interface, Locker > | |
| CStringListCtrl::CConstIterator | |
| CSeqTable_sparse_index::CConstIterator | |
| CContainerTypeInfo::CConstIterator | |
| CConstObjectInfo | CConstObjectInfo -- |
| CConstObjectInfoCV | CConstObjectInfoCV -- |
| CConstObjectInfoEI | CConstObjectInfoEI -- |
| CConstObjectInfoMI | CConstObjectInfoMI -- |
| CConstraint_choice | CConstraint_choice -- |
| CConstraint_choice_Base | CConstraint_choice_Base -- |
| CConstraint_choice_set | CConstraint_choice_set -- |
| CConstraint_choice_set_Base | CConstraint_choice_set_Base -- |
| CConstRef< C, Locker > | CConstRef -- |
| CConstRefCSeqId_LessThan | |
| CConstRefTypeInfo< Data > | |
| CConstResizingIterator< TSeq, TOut > | |
| CConstSageData | |
| CConstTreeLevelIterator | Class describing stack level of traversal do not use it directly |
| CConstTreeLevelIteratorMany< ChildIterator > | |
| CConstTreeLevelIteratorOne | |
| CContact_info | CContact_info -- |
| CContact_info_Base | Who to contact to discuss the submission |
| CContainerElementIterator | |
| CContainerTypeInfo | |
| CContainerTypeInfoFunctions | |
| CContElemConverter< TElem > | Template<typename TElem> CContElemConverter |
| CContElemConverter< CCgiEntry > | Template<> CContElemConverter<CCgiEntry> |
| CContElemConverter< objects::CSeq_id_Handle > | |
| CContElemConverter< string > | Template<> CContElemConverter<string> |
| CContent | CContent -- |
| CContentCheckDialog | |
| variation_ref::CHgvsParser::CContext | |
| variation::CHgvsParser::CContext | |
| CContextTranslator | Auxiliary class to provide convenient and efficient access to conversions between contexts local to query split chunks and the absolute (full, unsplit) query |
| oligofar::CContig | |
| CContigAssembly | This class provides alignment-related functions intended for finding overlaps for contig assembly |
| CContigItem | |
| CContributing_channel | CContributing_channel -- |
| CContributing_channel_Base | Channel donor |
| CConversionApp | |
| CConversionRef_Less | |
| CConversionResultPanel | |
| CConvert2BlastMaskApplication | |
| CConvert_action | CConvert_action -- |
| CConvert_action_Base | CConvert_action_Base -- |
| CConvert_feature_action | CConvert_feature_action -- |
| CConvert_feature_action_Base | CConvert_feature_action_Base -- |
| CConvert_feature_dst_options | CConvert_feature_dst_options -- |
| CConvert_feature_dst_options_Base | CConvert_feature_dst_options_Base -- |
| CConvert_feature_src_options | CConvert_feature_src_options -- |
| CConvert_feature_src_options_Base | CConvert_feature_src_options_Base -- |
| CConvert_from_CDS_options | CConvert_from_CDS_options -- |
| CConvert_from_CDS_options_Base | For convert features |
| CConvertCache | |
| value_slice::CConvertTO< CP, TO > | |
| value_slice::CConvertTO< CP, deque< T > > | |
| value_slice::CConvertTO< CP, map< K, V > > | |
| value_slice::CConvertTO< CP, set< T > > | |
| value_slice::CConvertTO< CP, stack< T > > | |
| value_slice::CConvertTO< CP, vector< T > > | |
| CConvGraph | |
| CConvImageApp | |
| value_slice::CConvPolicy< SRunTimeCP, bool > | |
| value_slice::CConvPolicy< SRunTimeCP, CTime > | |
| value_slice::CConvPolicy< SRunTimeCP, double > | |
| value_slice::CConvPolicy< SRunTimeCP, float > | |
| value_slice::CConvPolicy< SRunTimeCP, Int1 > | |
| value_slice::CConvPolicy< SRunTimeCP, Int2 > | |
| value_slice::CConvPolicy< SRunTimeCP, Int4 > | |
| value_slice::CConvPolicy< SRunTimeCP, Int8 > | |
| value_slice::CConvPolicy< SRunTimeCP, long > | |
| value_slice::CConvPolicy< SRunTimeCP, long double > | |
| value_slice::CConvPolicy< SRunTimeCP, string > | |
| value_slice::CConvPolicy< SRunTimeCP, Uint1 > | |
| value_slice::CConvPolicy< SRunTimeCP, Uint2 > | |
| value_slice::CConvPolicy< SRunTimeCP, Uint4 > | |
| value_slice::CConvPolicy< SRunTimeCP, Uint8 > | |
| value_slice::CConvPolicy< SSafeCP, bool > | |
| value_slice::CConvPolicy< SSafeCP, CTime > | |
| value_slice::CConvPolicy< SSafeCP, double > | |
| value_slice::CConvPolicy< SSafeCP, float > | |
| value_slice::CConvPolicy< SSafeCP, Int1 > | |
| value_slice::CConvPolicy< SSafeCP, Int2 > | |
| value_slice::CConvPolicy< SSafeCP, Int4 > | |
| value_slice::CConvPolicy< SSafeCP, Int8 > | |
| value_slice::CConvPolicy< SSafeCP, string > | |
| value_slice::CConvPolicy< SSafeCP, Uint1 > | |
| value_slice::CConvPolicy< SSafeCP, Uint2 > | |
| value_slice::CConvPolicy< SSafeCP, Uint4 > | |
| value_slice::CConvPolicy< SSafeCP, Uint8 > | |
| CCookieAffinity | |
| CGlDrawScale::CCoordConverter | |
| CCoordinates | CCoordinates -- |
| CCoordinates_Base | Literal coordinates map chemical components into the model space |
| CCoordMapper_SeqLocMapper | CCoordMapper_SeqLocMapper coordinate mapper based on CSeq_Loc_Mapper |
| CCopy_action | CCopy_action -- |
| CCopy_action_Base | CCopy_action_Base -- |
| CCopyChoiceVariantHook | Copy hook for a choice variant (CHOICE) |
| CCopyClassMemberHook | Copy hook for data member of a containing object (eg, SEQUENCE) |
| CCopyObjectHook | Copy hook for a standalone object |
| CCoreBlock | CCoreBlock -- |
| CCoreBlock_Base | CCoreBlock_Base -- |
| CCoreDef | CCoreDef -- |
| CCoreDef_Base | CCoreDef_Base -- |
| CCoreException | CCoreException -- |
| CCounter | |
| CCounterManager | |
| CCountries | |
| CCountryExtreme | |
| CCountryLine | |
| CCpGDemoApp | |
| CCpGIslands | |
| CCpgSearchForm | |
| CCpgSearchJob | CCpgSearchJob |
| CCpgSearchQuery | CCpgSearchTool |
| CCpgSearchTool | CCpgSearchTool |
| CCPPClean | CCPPClean -- |
| CCPPToolkitConnParams | |
| CCreate_TSA_ids_action | CCreate_TSA_ids_action -- |
| CCreate_TSA_ids_action_Base | CCreate_TSA_ids_action_Base -- |
| CCreate_TSA_ids_src | CCreate_TSA_ids_src -- |
| CCreate_TSA_ids_src_Base | CCreate_TSA_ids_src_Base -- |
| CCreateDataSource_local | |
| CCreatedFeat_Ref | |
| CCreateFeat | |
| CCreateGeneModelJob | CCreateGeneModelJob |
| CCreateGeneModelParamsPanel | |
| CCreateGeneModelToolManager | CCreateGeneModelToolManager |
| CCreateNeedlemanWunschJob | CCreateNeedlemanWunschJob |
| CCreateNeedlemanWunschToolManager | CCreateNeedlemanWunschToolManager |
| CTraversalNode::CCRefUserCallLessThan | |
| CCrossAlignView | CCrossAlignView |
| CCrossAlignViewFactory | CCrossAlignViewFactory |
| CCrossAlnDemoApp | Derive our application class from CwxNCBIApp and use it together with standard CNCBIwxApplication |
| CCrossAlnDemoDlg | |
| CCrossAlnPane | |
| CCrossAlnRenderer | |
| CCrossAlnWidget | |
| CCrossPanelIR | |
| CCtrlItem | |
| CCtxMsg | |
| CCtxMsgString | |
| CCursor | |
| python::CCursor | |
| python::CCursorIter | |
| CCurveBezier | |
| CCurveCubic | |
| CCustomBuild | CCustomBuild -- |
| CCustomBuildStep | CCustomBuildStep -- |
| CCustomBuildToolDummyImpl | |
| CCustomErrorHandler | |
| CCustomFeatureColor | File Description: configuration class for everything needed to render a single feature |
| CCustomizedFastaReader | CFastaReader-derived class which contains customizations for processing BLAST sequence input |
| oligofar::CCvtQryNcbi8naBisulfite< mask, Shift > | |
| oligofar::CCvtQryNcbi8naEquiv | |
| oligofar::CCvtQryNcbipnaBisulfite< from, to > | |
| oligofar::CCvtQryNcbipnaEquiv | |
| oligofar::CCvtSubjNcbi8naFwd | |
| oligofar::CCvtSubjNcbi8naRev | |
| CCyclicDepends | CCyclicDepends -- |
| CCylinder | CCylinder -- |
| CCylinder_Base | CCylinder_Base -- |
| COffsetList::CData | |
| xml::node::cdata | Helper struct for creating a xml::node of type_cdata |
| CData_filter | CData_filter -- |
| CData_filter_Base | CData_filter_Base -- |
| CData_set_id | CData_set_id -- |
| CData_set_id_Base | CData_set_id_Base -- |
| CData_set_id_type | CData_set_id_type -- |
| CData_set_id_type_Base | CData_set_id_type_Base -- |
| CData_set_id_uids | CData_set_id_uids -- |
| CData_set_id_uids_Base | CData_set_id_uids_Base -- |
| CDatabase | Database connection object |
| CDatabase_refresh_timestamp | CDatabase_refresh_timestamp -- |
| CDatabase_refresh_timestamp_Base | CDatabase_refresh_timestamp_Base -- |
| python::CDatabaseError | |
| CDatabaseError | |
| CDatabaseImpl | |
| CDataChangeNotifier | Data notification relay class, sends data change notifications to the subscribed listener |
| CDataContainerType | |
| python::CDataError | |
| CDatagramSocket | CDatagramSocket:: |
| CDataHandle | |
| CDataHandle_Base | CDataHandle_Base -- |
| CDataHandleAction | |
| CDataHandleAction_Base | CDataHandleAction_Base -- |
| CDataHandleSelector | |
| CDataHandleSelector_Base | CDataHandleSelector_Base -- |
| CDataHandleTransformer | |
| CDataHandleTransformer_Base | CDataHandleTransformer_Base -- |
| CDataHandleViewer | |
| CDataHandleViewer_Base | CDataHandleViewer_Base -- |
| CDataItemValidator | |
| COffsetList::CData::CDataIterator | |
| CDataLoader | |
| CDataLoaderFactory | |
| CDataLoaderPatcher | |
| CDataLoadingJob | CDataLoadingJob - a base class for Jobs loading data into projects |
| CDataLoadingOptions | CDataLoadingOptions - describes how new Project Items shall be added to a workspace |
| CDataLoadingTask | CDataLoadingTask - a task that executes CDataLoadingJob |
| CDataMember | |
| CDataMemberContainerType | |
| CDataMiningPanel | CDataMiningPanel |
| CDataMiningService | CDataMiningService |
| CDataMiningView | CDataMiningView |
| CDataMiningViewFactory | CDataMiningViewFactory |
| COffsetList::CDataPool | |
| CRCache::CDataPool | |
| CDataSequenceType | |
| CDataset_derivation | CDataset_derivation -- |
| CDataset_derivation_Base | Source and filtering criteria used to generate dataset |
| CDataSetType | |
| CDataSource | |
| CDataSource_ScopeInfo | |
| CDataSourceInitializer | |
| CDataSourcesOptionsDlgExtension | |
| CDataSourcesPage | |
| CDataStore | |
| CDataTool | |
| CDatatoolException | |
| CDataToolGeneratedSrc | |
| CDataTrack | File Description: |
| CDataType | |
| CDataTypeModule | |
| CDataValue | |
| CDataValueTmpl< Type > | |
| CDate | |
| pythonpp::CDate | |
| CDate_Base | StringStore is really a VisibleString |
| CDate_std | |
| CDate_std_Base | NOTE: this is NOT a unix tm struct |
| CDateItem | |
| pythonpp::CDateTime | |
| python::CDateTimeType | |
| CDB_BCPInCmd | |
| CDB_BigInt | |
| CDB_Binary | |
| CDB_Bit | |
| CDB_Char | |
| CDB_ClientEx | |
| CDB_Connection | |
| CDB_CursorCmd | |
| CDB_DateTime | |
| CDB_DBLB_Delegate | |
| CDB_DeadlockEx | |
| CDB_Double | |
| CDB_DSEx | |
| CDB_Exception | CDB_Exception -- |
| CDB_Float | |
| CDB_guard | Auto-pointer style guard class for DB structure |
| CDB_Image | |
| CDB_Int | |
| CDB_ITDescriptor | |
| CDB_LangCmd | |
| CDB_LongBinary | |
| CDB_LongChar | |
| CDB_MultiEx | |
| CDB_Numeric | |
| CDB_Object | |
| CDB_ODBC_ConnParams | |
| impl::CDB_Params | |
| CDB_Result | |
| CDB_Result_Reader | |
| CDB_ResultProcessor | |
| CDB_RPCCmd | |
| CDB_RPCEx | |
| CDB_SendDataCmd | |
| CDB_SmallDateTime | |
| CDB_SmallInt | |
| CDB_SQLEx | |
| CDB_Stream | |
| CDB_String | |
| CDB_Text | |
| CDB_TimeoutEx | |
| CDB_TinyInt | |
| CDB_TruncateEx | |
| CDB_UserHandler | |
| CDB_UserHandler_Diag | |
| CDB_UserHandler_Exception | |
| CDB_UserHandler_Exception_ODBC | |
| CDB_UserHandler_Stream | |
| CDB_UserHandler_Wrapper | |
| CDB_VarBinary | |
| CDB_VarChar | |
| CDBAPI_BlobCacheCF | Class factory for DBAPI BLOB cache |
| CDBAPI_Cache | DBAPI cache implementation |
| CDBAPI_CacheAdmin | DBAPI cache administration tool |
| CDBAPI_CacheIReader | |
| CDBAPI_CacheIWriter | |
| CDBAPI_CursorGuard | Guard class, closes cursor on destruction |
| CDBAPI_ICacheException | DBAPI ICache exception |
| CDBAPI_TransGuard | Transaction Guard class |
| CDbapiAuxDeletedEvent | |
| CDbapiBcpApp | |
| CDBAPIBulkInsert | Class has deliberately obscure name to not mix it with CBulkInsert in SDBAPI and to avoid direct usages |
| CDbapiClosedEvent | |
| CDbapiConnMgr | CDbapiConnMgr |
| CDbapiCtlibCF_Sybase | |
| CDbapiCtlibCFBase | |
| CDbapiCursorApp | |
| CDbapiDblibCF2 | |
| CDbapiDeletedEvent | |
| CDbapiDriverSampleApp | |
| CDbapiEvent | |
| CDbapiException | |
| CDbapiFetchCompletedEvent | |
| python::CDBAPIModule | |
| CDbapiMySqlCF2 | |
| CDbapiNewResultEvent | |
| CDbapiOdbcCF | |
| CDbapiOdbcCFBase | |
| CDbapiQueryApp | |
| CDbapiSampleApp | |
| CDbapiSampleErrHandler | |
| CDbapiSendDataApp | |
| CDbapiSimpleApp | |
| CDbapiTest | |
| CDbapiTestSpeedApp | |
| impl::CDBBindedParams | |
| CDBConnectionFactory | |
| CDBConnParams | CDBConnParams:: |
| CDBConnParamsBase | CDBConnParamsBase:: |
| impl::CDBConnParamsBase | Impl::CDBConnParamsBase:: |
| CDBConnParamsDelegate | |
| CDbCopyApp | |
| CDBDefaultConnParams | CDBDefaultConnParams:: |
| CDBDefaultServiceMapper | CDBDefaultServiceMapper |
| CDBEnvConnParams | |
| CDbEquals | |
| impl::CDBExceptionStorage | |
| CDBGiveUpFactory | CDBGiveUpFactory |
| impl::CDBHandlerStack | |
| CDbIndex | Base class providing high level interface to index objects |
| CDbIndex_Exception | Types of exception the indexing library can throw |
| CDbIndex_Factory | Index factory implementation |
| CDbIndex_Impl< LEGACY > | Implementation of the BLAST database index |
| CDbIndex_Traits< LEGACY > | Some computed type definitions |
| CDbInfo | CDbInfo -- |
| CDbInfo_Base | CDbInfo_Base -- |
| CDBInterfacesFileConnParams | |
| CDBL_BCPInCmd | CDBL_BCPInCmd:: |
| CDBL_BlobResult | CDBL_BlobResult:: |
| CDBL_Cmd | CDBL_Cmd:: |
| CDBL_ComputeResult | CDBL_ComputeResult:: |
| CDBL_Connection | CDBL_Connection:: |
| CDBL_CursorCmd | CDBL_CursorCmd:: |
| CDBL_CursorResult | CDBL_CursorResult:: |
| CDBL_ITDescriptor | |
| CDBL_LangCmd | CDBL_LangCmd:: |
| CDBL_ParamResult | CDBL_ParamResult:: |
| CDBL_Result | CDBL_Result |
| CDBL_ResultBase | CDBL_ResultBase:: |
| CDBL_RowResult | CDBL_RowResult:: |
| CDBL_RPCCmd | CTL_RPCCmd:: |
| CDBL_SendDataCmd | CDBL_SendDataCmd:: |
| CDBL_StatusResult | CDBL_StatusResult:: |
| CdBlaster | |
| CDBLibContext | |
| CDblibContextRegistry | |
| CDBLink_field_pair | CDBLink_field_pair -- |
| CDBLink_field_pair_Base | CDBLink_field_pair_Base -- |
| CDbList | CDbList -- |
| CDBParams | CDBParams |
| CDBParamVariant | |
| CDBRedispatchFactory | CDBRedispatchFactory |
| CDBServer | IDBServiceMapper |
| CDBServiceMapperCoR | CDBServiceMapperCoR |
| CDBServiceMapperTraits< T > | DBServiceMapperTraits IDBServiceMapper traits |
| CDBServiceMapperTraits< CDBDefaultServiceMapper > | |
| CDBServiceMapperTraits< CDBServiceMapperCoR > | |
| CDBServiceMapperTraits< CDBUDPriorityMapper > | |
| CDBServiceMapperTraits< CDBUDRandomMapper > | |
| CDBServiceMapperTraits< CDBUniversalMapper > | |
| CDBSourceItem | |
| CDbtag | |
| CDbtag_Base | Dbtag is generalized for tagging eg |
| CDbTest | |
| CDBUDPriorityMapper | CDBUDPriorityMapper |
| CDBUDRandomMapper | CDBUDRandomMapper |
| CDBUniversalMapper | |
| CDBUriConnParams | |
| CDbxrefPanel | |
| CDDAnnotateDialog | |
| CDDBookRefDialog | |
| CDDEvidenceDialog | |
| CDDRefDialog | |
| CDDSplashDialog | |
| CDDTypedAnnotDialog | |
| CDDV_DDX_Exception | CDDV_DDX_Exception |
| CDockManager::CDeadFrameDescr | |
| CDebugArgs | Argument class to collect debugging options |
| CDebugDumpable | |
| CDebugDumpContext | |
| CDebugDumpFormatter | |
| CDebugDumpFormatterText | |
| CDebugDumpViewer | |
| CId2ReaderBase::CDebugPrinter | |
| CDebugSymbols | CDebugSymbols -- |
| CDebugType | CDebugType -- |
| CDecompressIStream | CDecompressIStream -- |
| CDecompressOStream | CDecompressOStream -- |
| CDefault_Mapper_Sequence_Info | |
| CDefaultConnectPolicy | |
| CDefaultDriverVersion< TInterface > | |
| CDefaultIdler | Default idler |
| CDefaultLengthGetter | |
| CDefaultNodeKeyGetter< TValue > | Bi-directionaly linked N way tree |
| CDefaultSynonymMapper | |
| CDefaultUrlEncoder | Default encoder, uses the selected encoding for argument names/values and eUrlEncode_Path for document path |
| CDefaultWorkerNodeInitContext | Default implementation of a worker node initialization interface |
| CDeflineGenerator | Class for computing sequences' titles ("definitions") |
| CDeflineItem | |
| CDeflineProcess | |
| CDelayBuffer | CDelayBuffer |
| CDelayedOfstream | |
| CDeleteParams | |
| CDeleteQueue< Key, Value > | |
| CDeleter< X > | Functor template for the C language deallocation function, free() |
| CDeleteSeqFeatCommand | |
| CDeleteSeqFeatCommandFactory | |
| CDelta_ext | |
| CDelta_ext_Base | CDelta_ext_Base -- |
| CDelta_ext_PackTarget | |
| CDelta_item | CDelta_item -- |
| CDelta_item_Base | CDelta_item_Base -- |
| CDelta_seq | CDelta_seq -- |
| CDelta_seq_Base | CDelta_seq_Base -- |
| CDeltaBlast | A simple realization of the DELTA-BLAST algorithm: seacrch domain database, compute PSSM, search sequence database |
| CDeltaBlastApp | |
| CDeltaBlastAppArgs | Handle command line arguments for deltablast binary |
| CDeltaBlastArgs | Argument class to collect options specific to DELTA-BLAST |
| CDeltaBlastOptionsHandle | Handle to the protein-protein options to the BLAST algorithm |
| CDeltaBlastTestFixture | |
| CDemoAlignScorePropsApp | Derive our application class from CwxNCBIApp and use it together with standard CNCBIwxApplication |
| CDemoAlignTableApp | /////////////////////////////////////////////////////////////////////////// Derive our application class from CwxNCBIApp and use it together with standard CNCBIwxApplication |
| CDemoApp | Derive our application class from CwxNCBIApp and use it together with standard CNCBIwxApplication |
| CDemoApplication | |
| CDemoContigAssemblyApp | |
| CDemoeApp | |
| CDemoFeatTableApp | /////////////////////////////////////////////////////////////////////////// Derive our application class from CwxNCBIApp and use it together with standard CNCBIwxApplication |
| CDemoHandler_EmptyOnOverflow | |
| CDemoHandler_HeapAlloc | |
| CDemoHandler_MemSize | |
| CDemoHook | |
| CDemoSeqQaApp | |
| CDemoTableCtrlApp | /////////////////////////////////////////////////////////////////////////// Derive our application class from CwxNCBIApp and use it together with standard CNCBIwxApplication |
| CDemoThemeDlgApp | |
| CDemoThemeDlgApplication | |
| CDenMapRunIterator< CntType > | Run iterator. iterate through runs of equal values in the bins |
| CDense_diag | |
| CDense_diag_Base | For (multiway) diagonals |
| CDense_seg | |
| CDense_seg_Base | Dense-seg: the densist packing for sequence alignments only |
| CDenseSegHit | Wraps a CSeq_align containing CDense_seg and provides a simple API for interpreting it as a pairwise alignment of two sequences |
| CDenseSegHitElement | CDenseSegHitElement - IHitElement implementation for CDense_seg-based alignments |
| CDenseSegReserveLensHook | |
| CDenseSegReserveStartsHook | |
| CDenseSegReserveStrandsHook | |
| CDensity_coordinates | CDensity_coordinates -- |
| CDensity_coordinates_Base | Literal density coordinates define the chemical components whose structure is described by a density grid, parameters of this grid, and density values |
| CDensityMap< CntType > | Class CDensityMap generates a low-resolution view of a set of features |
| CDensityMapDS | CDensityMapDS |
| CDependent_field_rule | |
| CDependent_field_rule_Base | CDependent_field_rule_Base -- |
| CDependent_field_set | CDependent_field_set -- |
| CDependent_field_set_Base | CDependent_field_set_Base -- |
| CDeployDirSuffix | CDeployDirSuffix -- |
| CTraversalNode::CDepthFirstCallback | |
| CDesc_EditCommand< TEditHandle, add > | |
| CTraversalSpecFileParser::CDescFileNode | |
| pythonpp::CDescr | |
| CDescription | CDescription -- |
| CDescription_Base | CDescription_Base -- |
| CDescriptionText | CDescriptionText -- |
| CDescriptionText_Base | CDescriptionText_Base -- |
| CDescriptorTextPanel | |
| CDetachProjectItem_local | |
| CDetachProjectItems_local | |
| CDFamily | |
| CDHManager | |
| CDiagAutoPrefix | CDiagAutoPrefix -- |
| CDiagCollectGuard | Guard for collecting diag messages (affects the current thread only) |
| CDiagCompileInfo | Incapsulate compile time information such as _FILE_ _LINE NCBI_MODULE NCBI_MODULE is used only in .cpp file |
| CDiagConsoleCache | CDiagConsoleCache |
| CDiagConsoleList | CDiagConsoleList |
| CDiagConsolePanel | CDiagConsolePanel |
| CDiagConsoleView | CDiagConsoleView |
| CDiagConsoleViewFactory | CDiagConsoleViewFactory |
| CDiagContext | |
| CDiagContext_Extra | Temporary object for holding extra message arguments |
| CDiagContextThreadData | Thread local context data stored in TLS |
| CDiagErrCodeInfo | CDiagErrCodeInfo -- |
| CwxLogDiagHandler::CDiagEvent | Event for child notification |
| CDiagFactory | CDiagFactory -- |
| CDiagFileHandleHolder | |
| CDiagFilter | CDiagFilter -- |
| CDiagHandler | CDiagHandler -- |
| CDiagHit | |
| CDiagHitElement | CDiagHitElement - IHitElement implementation for CDense_seg-based alignments |
| CDiagLexParser | CDiagLexParser -- |
| CDiagLock | |
| CDiagMatcher | CDiagMatcher -- |
| CNCMessageHandler::CDiagnosticsGuard | Special guard to properly initialize and reset diagnostics |
| CDiagnosticsGuard | Special guard to properly initialize and de-initialize diagnostics |
| oligofar::CAligner::CDiagonalScores | |
| CDiagRangeCollection | |
| CDiagRecycler | |
| CDiagRestorer | CDiagRestorer -- |
| CDiagStrEmptyMatcher | CDiagStrEmptyMatcher -- |
| CDiagStrErrCodeMatcher | CDiagStrErrCodeMatcher -- |
| CDiagStrMatcher | CDiagStrMatcher -- |
| CDiagStrPathMatcher | CDiagStrPathMatcher -- |
| CDiagStrStringMatcher | CDiagStrStringMatcher -- |
| CDiagSyntaxParser | CDiagSyntaxParser -- |
| CDialog | CDialog |
| oligofar::CDibaseScore< TCvtQry, TCvtSubj > | |
| oligofar::CDibaseScore_Base | |
| pythonpp::CDict | |
| pythonpp::CDictHelper< T > | |
| CDictionaryUtil | Standard dictionary utility functions |
| pythonpp::CDictProxy< T > | |
| CDir | CDir -- |
| CDirEntry | CDirEntry -- |
| CDirTest | |
| CDiscNucleotideOptionsHandle | Handle to the nucleotide-nucleotide options to the discontiguous BLAST algorithm |
| CDiscontiguousMegablastArgs | Argument class to retrieve discontiguous megablast arguments |
| CDiscreteDistribution | This class generates a random integer from a series of ranges defined like this: 5, 6 - 9, 10 - 50 |
| CDisplaySeqalign | |
| CDistanceMatrix | |
| CDistanceMatrix_Base | CDistanceMatrix_Base -- |
| CDistanceMatrixHandler | CDistanceMatrix label handler |
| CDistances | Representation of pairwise distances, intended for use in multiple sequence alignment applications |
| CDistBasedClusterer | |
| CPhyTreeCalc::CDistMatrix | Distance matrix (square, symmetric with zeros on diagnol) |
| CDistMethods | |
| CDistribution_point | CDistribution_point -- |
| CDistribution_point_Base | CDistribution_point_Base -- |
| CDL_Assembly | CDL_Assembly -- |
| CDL_Assembly_Base | CDL_Assembly_Base -- |
| CDL_AssmInfo | CDL_AssmInfo -- |
| CDL_AssmInfo_Base | CDL_AssmInfo_Base -- |
| CDL_AssmInfoResponse | CDL_AssmInfoResponse -- |
| CDL_AssmInfoResponse_Base | CDL_AssmInfoResponse_Base -- |
| CDL_TaxId | CDL_TaxId -- |
| CDL_TaxId_Base | CDL_TaxId_Base -- |
| CDll | CDll -- |
| CDllResolver | Class for entry point resolution when there are several DLL candidates |
| CDllResolver_Getter< TClass > | Template function to create dll resolver for interface |
| CDllResolver_Getter< I_DriverContext > | |
| CDllResolver_Getter< IBlobStorage > | |
| CDllResolver_Getter< ICache > | |
| CDllResolver_Getter< objects::CDataLoader > | |
| CDllResolver_Getter< objects::CReader > | |
| CDllResolver_Getter< objects::CWriter > | |
| CDllResolver_Getter< objects::IEditSaver > | |
| CDllResolver_Getter< objects::IEditsDBEngine > | |
| CDllSrcFilesDistr | Distribution if source files by lib projects Uses in dll project to separate source files to groups by libs |
| CDLPatcher_DataLoaderCF | Data Loader Factory for BlastDbDataLoader |
| python::CDMLConnPool | |
| CDMSearchProgress | CDMSearchProgress CDMSearchProgress represents the specialized progress report that may contain intermediate data mining results |
| CDMSearchResult | CDMSearchResult - result object delivered using job progress object |
| CDMToolSelector | CDataMiningService |
| CdnaWithHole | |
| CDNode | |
| CDockContainer | CDockContainer is a window that hosts docked windows |
| CDockLayoutTree | CDockLayoutTree - represents hierarchical layout in a Dock Container as a tree where nodes correspond to windows |
| CDockManager | CDockManager CDockManager sends requests to Window Manager, Window Manager makes decisions about deleting clients and calls Dock Manager functions |
| CDockMarkerWindow | CDockMarkerWindow - top level window with docking markers displayed on top of the application window |
| CDockNotebook | CDockNotebook - an extended version of wxAuiNotebook capable of working with Dock Manager and Window Manager |
| CDockNotebookTabArt | CDockNotebookTabArt - a customized version of wxAuiSimpleTabArt that renders background differently |
| CDockPanel | CDockPanel - a container with a title bar (caption) hosting a single client window (IWMClient) |
| CDockSplitter | CDockSplitter = an extended version of CSplitter capable of working with Dock Manager and Window Manager |
| CDocRef | CDocRef -- |
| CDocRef_Base | Reference to a document |
| CDocSum | CDocSum -- |
| CDocSum_Base | CDocSum_Base -- |
| CDocsumTableModel | |
| CDocumentAccumulator | Visitor that accumulates Project Handles in a container |
| CDOI | CDOI -- |
| CDOI_Base | Document Object Identifier |
| CDomain_parent | CDomain_parent -- |
| CDomain_parent_Base | Domain-parent records an evolutionary relationship which may not be as simple as a classical parent-child relationship in a typical hierarchy, i.e |
| CDonorAcceptorMatrix | |
| CDotMatrixPanel | CDotMatrixPanel |
| CDotMatrixView | CDotMatrixView |
| CDotMatrixViewFactory | CDotMatrixViewFactory |
| CDotMatrixViewManager | CDotMatrixViewManager |
| CDoubleStrandSeq | |
| CDoubleValueHolder | |
| CDownloadJob::CDownloadCallbackData | |
| CDownloadJob | Job to download tarball archive |
| CdPssmInput | |
| CDrawTextOStream | |
| CDRefresher | |
| impl::CDriverContext | CDriverContext:: |
| CDriverManager | |
| CMultiFileInput::CDropTarget | |
| CDSAnnotLockReadGuard | |
| CDSAnnotLockWriteGuard | |
| CdsNumOrder | |
| CdTreeStream | |
| CDummyGlyph | Dummy concreate glyph class for layout purpose |
| CDummyLayoutObject | |
| CDummyLengthGetter | |
| CDummySynonymMapper | |
| CDummyTrack | A dummy layout track for showing an empty area |
| CDumpSequences_local | |
| CDumpSysInfo | |
| CdUpdateParameters | |
| CDUpdater | |
| CDUpdateStats | |
| CDustMaskApplication | |
| CDynamicCharArray | |
| CE2Reply | CE2Reply -- |
| CE2Reply_Base | CE2Reply_Base -- |
| CE2Request | CE2Request -- |
| CE2Request_Base | Request types |
| CEaaToIupacaa | |
| CEaaToStdaa | |
| CEdit_action | CEdit_action -- |
| CEdit_action_Base | CEdit_action_Base -- |
| CEdit_feature_location_action | CEdit_feature_location_action -- |
| CEdit_feature_location_action_Base | CEdit_feature_location_action_Base -- |
| CEdit_location_strand | CEdit_location_strand -- |
| CEdit_location_strand_Base | CEdit_location_strand_Base -- |
| CEditAppJob | CEditAppJob - a base class for Jobs modifying existing data in projects |
| CEditAppTask | CDataLoadingAppTask - a task that executes CDataLoadingAppJob |
| CEditBioseqSampleApp | |
| CEditEvent | Class CEditEvent defines a single type for all editing events |
| CEditException | |
| CEditMacroDlg | |
| CEditObjectDlg | |
| CEditObjectMolInfo | |
| CEditObjectPubdesc | |
| CEditObjectSeq_desc | |
| CEditObjectSeq_feat | |
| CEditScript | Interface for the traceback from blast hits |
| CEditsSaver | |
| CEditStylesDlg | |
| CEFetch_Literature_Request | CEFetch_Literature_Request |
| CEFetch_Request | CEFetch_Request |
| CEFetch_Sequence_Request | CEFetch_Sequence_Request |
| CEFetch_Taxonomy_Request | CEFetch_Taxonomy_Request |
| CEffectiveSearchSpaceCalculator | Auxiliary class to compute the effective search space |
| CEffectiveSearchSpacesMemento | Memento class to save, replace out, and restore the effective search space options of the CBlastOptions object passed to its constructor |
| CEGQuery_Request | CEGQuery_Request |
| CEGQueryResult | CEGQueryResult -- |
| CEGQueryResult_Base | CEGQueryResult_Base -- |
| CEHistory_Request | CEHistory_Request |
| CEHistoryItem | CEHistoryItem -- |
| CEHistoryResult | CEHistoryResult -- |
| CEHistoryResult_Base | CEHistoryResult_Base -- |
| CEInfo_Request | CEInfo_Request |
| CEInfoResult | CEInfoResult -- |
| CEInfoResult_Base | CEInfoResult_Base -- |
| CEJournalSearch | |
| CElementaryMatching | |
| CELink_Request | CELink_Request |
| CELinkResult | CELinkResult -- |
| CELinkResult_Base | CELinkResult_Base -- |
| Cell | |
| CEmailDiagFactory | |
| CEmailDiagHandler | |
| CEmbeddedResource | CEmbeddedResource -- |
| CEmbedManifest | CEmbedManifest -- |
| CEMBL_block | CEMBL_block -- |
| CEMBL_block_Base | CEMBL_block_Base -- |
| CEMBL_dbname | CEMBL_dbname -- |
| CEMBL_dbname_Base | CEMBL_dbname_Base -- |
| CEMBL_xref | CEMBL_xref -- |
| CEMBL_xref_Base | CEMBL_xref_Base -- |
| CEmblFormatter | |
| CEmblGatherer | |
| CEmptyToDash< Other > | |
| CEmptyUrlEncoder | Primitive encoder - all methods return the argument value |
| CEnableSecurityDebugging | CEnableSecurityDebugging -- |
| CEnableSQLServerDebugging | CEnableSQLServerDebugging -- |
| CEnableUnmanagedDebugging | CEnableUnmanagedDebugging -- |
| CEncodedString | CEncodedString -- |
| CEndItem | |
| CEndSectionItem | |
| CEndsTest | |
| pythonpp::CEngine | |
| CEnProjectItemCollector | |
| CEntrez2_boolean_element | CEntrez2_boolean_element -- |
| CEntrez2_boolean_element_Base | CEntrez2_boolean_element_Base -- |
| CEntrez2_boolean_exp | CEntrez2_boolean_exp -- |
| CEntrez2_boolean_exp_Base | The structured form of the boolean is the same in a request or return so that it easy to modify a query |
| CEntrez2_boolean_reply | CEntrez2_boolean_reply -- |
| CEntrez2_boolean_reply_Base | CEntrez2_boolean_reply_Base -- |
| CEntrez2_boolean_term | CEntrez2_boolean_term -- |
| CEntrez2_boolean_term_Base | Term is both sent and received as parts of queries and replies |
| CEntrez2_db_id | CEntrez2_db_id -- |
| CEntrez2_db_id_Base | Database name |
| CEntrez2_db_info | CEntrez2_db_info -- |
| CEntrez2_db_info_Base | Info for one database |
| CEntrez2_docsum | |
| CEntrez2_docsum_Base | CEntrez2_docsum_Base -- |
| CEntrez2_docsum_data | CEntrez2_docsum_data -- |
| CEntrez2_docsum_data_Base | CEntrez2_docsum_data_Base -- |
| CEntrez2_docsum_field_info | CEntrez2_docsum_field_info -- |
| CEntrez2_docsum_field_info_Base | CEntrez2_docsum_field_info_Base -- |
| CEntrez2_docsum_list | CEntrez2_docsum_list -- |
| CEntrez2_docsum_list_Base | CEntrez2_docsum_list_Base -- |
| CEntrez2_docsumHandler | |
| CEntrez2_dt | CEntrez2_dt -- |
| CEntrez2_dt_Base | Entrez2 common elements |
| CEntrez2_dt_filter | CEntrez2_dt_filter -- |
| CEntrez2_dt_filter_Base | CEntrez2_dt_filter_Base -- |
| CEntrez2_eval_boolean | CEntrez2_eval_boolean -- |
| CEntrez2_eval_boolean_Base | When evaluating a boolean query the counts of hits is always returned |
| CEntrez2_field_id | CEntrez2_field_id -- |
| CEntrez2_field_id_Base | Field name |
| CEntrez2_field_info | CEntrez2_field_info -- |
| CEntrez2_field_info_Base | Info about one field |
| CEntrez2_get_links | CEntrez2_get_links -- |
| CEntrez2_get_links_Base | Request links of one type |
| CEntrez2_hier_node | CEntrez2_hier_node -- |
| CEntrez2_hier_node_Base | For hierarchical index |
| CEntrez2_hier_query | CEntrez2_hier_query -- |
| CEntrez2_hier_query_Base | CEntrez2_hier_query_Base -- |
| CEntrez2_id | CEntrez2_id -- |
| CEntrez2_id_Base | Single UID |
| CEntrez2_id_list | |
| CEntrez2_id_list_Base | List of record UIDs |
| CEntrez2_info | CEntrez2_info -- |
| CEntrez2_info_Base | Describes all the databases |
| CEntrez2_limits | CEntrez2_limits -- |
| CEntrez2_limits_Base | Date limits |
| CEntrez2_link_count | CEntrez2_link_count -- |
| CEntrez2_link_count_Base | Link count of one type |
| CEntrez2_link_count_list | CEntrez2_link_count_list -- |
| CEntrez2_link_count_list_Base | All links from 1 uid |
| CEntrez2_link_id | CEntrez2_link_id -- |
| CEntrez2_link_id_Base | Link name |
| CEntrez2_link_info | CEntrez2_link_info -- |
| CEntrez2_link_info_Base | Info about one link |
| CEntrez2_link_set | CEntrez2_link_set -- |
| CEntrez2_link_set_Base | Links are returned in sets also using OCTET STRINGS |
| CEntrez2_reply | CEntrez2_reply -- |
| CEntrez2_reply_Base | Replies from the Entrez server all replies contain the date/time stamp when they were executed to do reqular date bounded searches use this value+1 to search again later instead of recording the date/time on the client machine the cookie allows a simple key string to represent UID lists in the history |
| CEntrez2_request | CEntrez2_request -- |
| CEntrez2_request_Base | Entrez2 Request types |
| CEntrez2_term | CEntrez2_term -- |
| CEntrez2_term_Base | CEntrez2_term_Base -- |
| CEntrez2_term_list | CEntrez2_term_list -- |
| CEntrez2_term_list_Base | CEntrez2_term_list_Base -- |
| CEntrez2_term_pos | CEntrez2_term_pos -- |
| CEntrez2_term_pos_Base | Request portions of term list |
| CEntrez2_term_query | CEntrez2_term_query -- |
| CEntrez2_term_query_Base | CEntrez2_term_query_Base -- |
| CEntrez2Client | |
| CEntrez2Client_Base | CEntrez2Client_Base -- |
| CEntrez2ClientApp | |
| CEntrez_general | CEntrez_general -- |
| CEntrez_general_Base | CEntrez_general_Base -- |
| CEntrezCache | Class CEntrezCache provides a simple, thread-safe interface for storing the temporary results of queries to Entrez using CEntrez2Client |
| CEntrezDB | CEntrezDB |
| CEntrezgene | CEntrezgene -- |
| CEntrezgene_Base | Entrezgene is the "document" indexed in Entrez and presented in the full display It also contains the Entrez ID and date information |
| CEntrezgene_Set | CEntrezgene_Set -- |
| CEntrezgene_Set_Base | CEntrezgene_Set_Base -- |
| CEntrezgene_SetHandler | CEntrezgene_Set label handler |
| CEntrezgeneHandler | CEntrezgene label handler |
| CEntrezSearchForm | CTestSearchForm |
| CEntrezSearchJob | CEntrezSearchJob |
| CEntrezSearchQuery | CEntrezSearchTool |
| CEntrezSearchTool | CEntrezSearchTool |
| CEnumDataType | |
| CEnumDataTypeValue | |
| CEnumeratedTypeInfo | |
| CEnumeratedTypeValues | |
| CEnumParser< TEnum > | |
| CEnumRefTypeStrings | |
| CEnumTypeStrings | |
| CEnvironmentCleaner | CEnvironmentCleaner -- |
| pythonpp::CEnvironmentError | |
| CEnvironmentRegistry | CEnvironmentRegistry -- |
| CEnzymatic_search_constraint | CEnzymatic_search_constraint -- |
| CEnzymatic_search_constraint_Base | Required peptide termini |
| pythonpp::CEOFError | |
| CEofException | |
| CEpigenomicsDS | CEpigenomicsDS - Epigenomics data source |
| CEpigenomicsDSType | CEpigenomicsDSType - Epigenomics data source type |
| CEpigenomicsJob | CEpigenomicsJob |
| CEpigenomicsTrack | CEpigenomicsTrack -- A special track for showing epigenomics map |
| CEpigenomicsTrackFactory | CEpigenomicsTrackFactory |
| CEPost_Request | CEPost_Request |
| CEPostResult | CEPostResult -- |
| CEPostResult_Base | CEPostResult_Base -- |
| CEResidueVec | |
| CErrHandler | |
| CErrnoAdapt | |
| CErrnoTemplException< TBase > | CErrnoTemplException -- |
| CErrnoTemplExceptionEx< TBase, PErrCode, PErrStr > | CErrnoTemplExceptionEx -- |
| python::CError | |
| pythonpp::CError | |
| CError_point | CError_point -- |
| CError_point_Base | CError_point_Base -- |
| CErrorContainerBase | |
| CErrorContainerCount | |
| CErrorContainerCustom | |
| CErrorContainerLenient | |
| CErrorContainerLevel | |
| CErrorContainerStrict | |
| CErrorContainerWithLog | |
| CErrorList | CErrorList -- |
| CErrorReport | CErrorReport -- |
| CErrorReportUrl | CErrorReportUrl -- |
| pythonpp::CErrorStackElem | |
| CESearch_Request | CESearch_Request |
| CESearchGeneric | |
| CESearchResult | CESearchResult -- |
| CESearchResult_Base | CESearchResult_Base -- |
| CESpell_Request | CESpell_Request |
| CESpellResult | CESpellResult -- |
| CESpellResult_Base | CESpellResult_Base -- |
| CESummary_Request | CESummary_Request |
| CESummaryGeneric | |
| CESummaryResult | CESummaryResult -- |
| CESummaryResult_Base | CESummaryResult_Base -- |
| CEUtils_ConnContext | CEUtils_ConnContext |
| CEUtils_IdGroup | CEUtils_IdGroup |
| CEUtils_IdGroupSet | CEUtils_IdGroupSet |
| CEUtils_Request | CEUtils_Request |
| CEUtilsApp | |
| CEUtilsGeneric | |
| CEUtilsProcess | |
| CEvent | CEvent - generic event implementation TODO TODO - Attachments |
| CAlnMultiPane::CEvent | |
| CEventAttachmentFor< T > | Templatized IEventAttachment wrapper |
| SNetScheduleServiceAutomationObject::CEventHandler | |
| CEventHandler | CEventHandler |
| CEventLogService | CEventLogService - the standard implementation of IEventLogService |
| CEventRecord | CEventRecord - standard implementation of IEventRecord |
| CEventRecordDetailsDlg | CEventRecordDetails |
| CEventTablePanel | CEventTablePanel - the table displaying events; used in Event View |
| CEventView | CEventView - system view that displays events from Event Logging Service |
| CEventViewFactory | CEventViewFactory - factory for creating Event View |
| CEventViewModel | CEventViewModel - a model for Event View table |
| CEvidenceBasis | CEvidenceBasis -- |
| CEvidenceBasis_Base | CEvidenceBasis_Base -- |
| CException | CException -- |
| CExceptionReporter | CExceptionReporter -- |
| CExceptionReporterStream | CExceptionReporterStream -- |
| CExceptionWrapper | |
| CExchangeSet | CExchangeSet -- |
| CExchangeSet_Base | Set of dbSNP refSNP docsums, version 3.2 |
| CExec | CExec -- |
| CExecException | CExecException -- |
| CExecJob | |
| CExecute | |
| CProcess::CExitInfo | Extended exit information for waited process |
| CExitThreadException | |
| CExon | |
| CExon_params | CExon_params -- |
| CExon_params_Base | CExon_params_Base -- |
| CExonParameters | |
| CPhyTreeFormatter::CExpander | Tree visitor class, expands all nodes and corrects node colors |
| CExpandGlyph | |
| CExpandItem | |
| CExpansionScorer | |
| CExpectedError | |
| CExperimentsPanel | |
| CExperimentSupport | CExperimentSupport -- |
| CExperimentSupport_Base | CExperimentSupport_Base -- |
| CExplorerItem | CExplorerItem - an abstract item in Application Explorer icons are represented as integers - indexes in the tree image list |
| CExplorerItemData | CExplorerItemData - tree item attachment pointing back to CExplorerItem |
| CExplorerItemEx< TData > | |
| CExportDlgTask | CExportDlgTask - shows "Export" dialog |
| CExportStrategy | |
| CExprParser | |
| CExprParserException | |
| CExprSymbol | |
| CExprValue | |
| CExt_loc | CExt_loc -- |
| CExt_loc_Base | CExt_loc_Base -- |
| CExtend_to_feature | CExtend_to_feature -- |
| CExtend_to_feature_Base | CExtend_to_feature_Base -- |
| CExtensionDeclaration | CExtensionDeclaration - static declaration helper |
| CExtensionPoint | CExtensionPoint - standard implementation of IExtensionPoint |
| CExtensionPointDeclaration | CExtensionPointDeclaration - static declaration helper |
| CExtensionRegistry | CExtensionRegistry - standard implementation of IExtensionRegistry |
| IPhyloTreeRenderer::CExtentDimension | This is a set of positions (for nodes) and associated x or y pixel offset values |
| CExternalLayoutTrack | CExternalLayoutTrack -- the layout track for holding and visualizing the external graphical views' visible ranges |
| CExternalLayoutTrackFactory | CExternalLayoutTrackFactory |
| pythonpp::CExtModule< T > | |
| pythonpp::CExtObject< T > | |
| CExtraDecoder | |
| CExtraEncoder | |
| CExtraFeaturePanel | |
| pythonpp::CExtType | |
| CFactory< Type > | |
| oligofar::CFaDiceApp | |
| CFastaAlignmentBuilder | Helper class to build pairwise alignments, with double gaps automatically spliced out |
| CFastaBioseqSource | |
| CFastaExporter | |
| CFastaExporterFactory | |
| CFastaExportJob | CFastaExportJob |
| CFastaExportPage | |
| CFastaExportParams | |
| CFastaFileSet | |
| CFASTAFormatLoadManager | CFASTAFormatLoadManager |
| CFASTAFormatParamsPanel | CFASTAFormatParamsPanel |
| CFastaIdsResolver | Default implementation of a Seq-id resolver, which knows about FASTA-formatted sequence identifiers |
| CFastaIOWrapper | |
| CFastaLoadJob | CFastaLoadJob |
| CFastaLoadParams | |
| CFastaMapper | |
| CFastaOstream | FASTA-format output; see also ReadFasta in <objtools/readers/fasta.hpp> |
| CFastaProcess | |
| CFastaProgressReader | FASTA reader with progress report |
| CFastaReader | Base class for reading FASTA sequences |
| CFastaReaderEx | Modification of the CFastaReader class that allows for reading a single sequence as a degenarate multiple sequence alignment |
| CFastaRetrieveJob | |
| CFastaRetrieveLocJob | |
| CFastaSeqBlockItem | |
| CFastaSeqHdrItem | |
| CFastaTextDisplay | |
| CFastaTextDS | |
| CFastaTitleItem | |
| CFastBuffer< KEmbeddedSize, TType > | |
| CFastIScore | |
| CFastLocalTime | CFastLocalTime -- |
| CFastMutex | CFastMutex -- |
| oligofar::CFastqFileReader | |
| CFastRWLock | CFastRWLock -- |
| CFatalRequest | |
| CFatalRequest_ForServer | |
| CFeat_CI | CFeat_CI -- |
| CFeat_id | CFeat_id -- |
| CFeat_id_Base | Feature identifiers ******************************** |
| CFeat_qual_choice | CFeat_qual_choice -- |
| CFeat_qual_choice_Base | CFeat_qual_choice_Base -- |
| CFeat_qual_legal_set | CFeat_qual_legal_set -- |
| CFeat_qual_legal_set_Base | CFeat_qual_legal_set_Base -- |
| CFeat_qual_legal_val | CFeat_qual_legal_val -- |
| CFeat_qual_legal_val_Base | CFeat_qual_legal_val_Base -- |
| CFeat_qual_legal_val_choice | CFeat_qual_legal_val_choice -- |
| CFeat_qual_legal_val_choice_Base | CFeat_qual_legal_val_choice_Base -- |
| CFeatCheckBrowser | |
| CFeatComparatorByLabel | |
| CFeatCompare_Result | AppJobs for background loading and preparation |
| CFeatCompareJob | Alignment-based data source |
| CFeatCompareJob_Align | |
| CFeatCompareJob_Location | Annotation Comparison by location alone This is done by checking a few constraints |
| CFeatConfigShow | |
| CFeatConfigValues< V >::CFeatConfigValue | |
| CFeatConfigValues< V > | Template for configured values, indexed by feature type and subtype where values can inherit from master feature types |
| CFeatDef | CFeatDef -- |
| CFeatDef_Base | CFeatDef_Base -- |
| CFeatDefGroupSet | CFeatDefGroupSet -- |
| CFeatDefGroupSet_Base | CFeatDefGroupSet_Base -- |
| CFeatDefSet | CFeatDefSet -- |
| CFeatDefSet_Base | Collections of defintions |
| CFeatDispGroup | CFeatDispGroup -- |
| CFeatDispGroup_Base | CFeatDispGroup_Base -- |
| CFeatDispGroupSet | CFeatDispGroupSet -- |
| CFeatDispGroupSet_Base | CFeatDispGroupSet_Base -- |
| CFeatFilterQueryException | Query parser exceptions class CFeatFilterQueryException |
| CFeatFindContext | |
| CFeatGlyph | Class for storing a set of nested features |
| CFeatHeaderItem | |
| CFeatHistogramDS | CFeatHistogramDS |
| CFeatIdRemapper | |
| CFeatTree::CFeatInfo | |
| CFeatList | CConfigurableItems - a static list of items that can be configured |
| CFeatListItem | CFeatListItem - basic configuration data for one "feature" type |
| oligofar::CFeatMap | |
| CFeatShowExtraItem | |
| CFeatShowPanel | |
| CFeatTableDS | CFeatTableDS Data source for Feature Table widget |
| CFeatTableUpdate | |
| CFeatTableView | CFeatTableView |
| CFeatTableViewFactory | CFeatTableViewFactory |
| CFeatTableWidget | CFeatTableWidget |
| CFeatTree | CFeatTree |
| CFeatTreeIndex | |
| CFeatTreeSampleApp | |
| CFeature_evidence | CFeature_evidence -- |
| CFeature_evidence_Base | CFeature_evidence_Base -- |
| CFeature_field | CFeature_field -- |
| CFeature_field_Base | CFeature_field_Base -- |
| CFeature_field_legal | CFeature_field_legal -- |
| CFeature_field_legal_Base | CFeature_field_legal_Base -- |
| CFeature_field_pair | CFeature_field_pair -- |
| CFeature_field_pair_Base | CFeature_field_pair_Base -- |
| CFeature_table_reader | |
| CFeature_table_reader_imp | |
| CFeatureCheckDialog | |
| CFeatureCheckPanel | |
| CFeatureConfigParams | File Description: configuration class for everything needed to render a single feature |
| CFeatureCreateDialog | |
| CFeatureDescr | CFeatureDescr -- |
| CFeatureDescr_Base | CFeatureDescr_Base -- |
| CFeatureDictSet | CFeatureDictSet -- |
| CFeatureDictSet_Base | CFeatureDictSet_Base -- |
| CFeatureFilter | Class CFeatureFilter |
| CFeatureFilterDlg | |
| CFeatureGatherer | |
| CFeatureGenerator | |
| CFeatureGraph | CFeatureGraph |
| CFeatureGraphProperties | CFeatureGraphProperties |
| CFeatureItem | |
| CFeatureItemBase | |
| CFeatureItemGff | |
| CFeatureLoadingJob | CFeatureLoadingJob |
| CFeatureLoadingJobResult | CFeatureLoadingJobResult |
| CFeaturePanel | |
| CFeaturePanelDS | CFeaturePanelDS |
| CFeaturePanelDSType | CFeaturePanelDSType |
| CFeatureParams | CFeatureParams: the data structure holding feature rendering parameters |
| CFeatureRetrievalJob | Alignment-based data source |
| CFeatureRetrievalResult | AppJobs for background loading and preparation |
| CFeatureSearchForm | |
| CFeatureSearchJob | CFeatureSearchJob |
| CFeatureSearchQuery | CFeatureSearchTool |
| CFeatureSearchTool | CFeatureSearchTool |
| CFeaturesGroup | |
| CFeatureTrack | CFeatureTrack -- |
| CFeatureTrackFactory | CFeatureTrackFactory |
| CFeedbackTextArrayPrinter | |
| CFetchURL | |
| CFFile | CFFile -- |
| CFFile_Base | CFFile_Base -- |
| CQuery::CField | Class representing value in result set or output parameter of stored procedure |
| CField | CField -- |
| CField_constraint | CField_constraint -- |
| CField_constraint_Base | CField_constraint_Base -- |
| CField_edit | CField_edit -- |
| CField_edit_Base | CField_edit_Base -- |
| CField_pair_type | CField_pair_type -- |
| CField_pair_type_Base | CField_pair_type_Base -- |
| CField_rule | |
| CField_rule_Base | CField_rule_Base -- |
| CField_set | CField_set -- |
| CField_set_Base | CField_set_Base -- |
| CField_type | CField_type -- |
| CField_type_Base | CField_type_Base -- |
| CFieldList | CFieldList -- |
| CFieldList_Base | CFieldList_Base -- |
| pythonpp::CFile | |
| CFile | CFile -- |
| CFileAPI | Global settings related to the file API |
| CFileAssociation | CFileAssociation -- |
| CFileAutoLoader | CFileAutoLoader |
| CFileByteSource | |
| CFileByteSourceReader | |
| CFileCode | |
| CFileConfiguration | CFileConfiguration -- |
| CFileConfiguration_Base | CFileConfiguration_Base -- |
| CFileDBEngine | |
| CFileDeleteAtExit | CFileDeleteAtExit -- |
| CFileDeleteList | CFileDeleteList -- |
| CFileLoadManager::CFileDescriptor | |
| CFileDiagHandler | |
| CFileErrnoException | |
| CFileException | CFileException -- |
| CFileExtensions | Class CFileExtensions Helper class to provide info on particular (biological content) file types To be used in File dialogs |
| CFileHandleDiagHandler | CFileHandleDiagHandler -- |
| CFileIO | Class for support low level input/output for files |
| CFileIO_Base | Base class for CFileIO, CFileReader, CFileWriter, CFileReaderWriter |
| CFileLoader | |
| CFileLoadManager | CFileLoadManager CFileLoadManager - a Loader Manager implementing "File" option in "Open" dialog |
| CFileLoadOptionPanel | |
| CFileLock | File locking |
| CFileModules | |
| CFileName | CFileName -- |
| CFilenameSelector | CFilenameSelector find a Project by its filename |
| CFileObsolete | Find and remove old files |
| CFileReader | |
| CFileReaderWriter | |
| CFileReaderWriter_Base | File based IReader/IWriter/IReaderWriter with low level IO for speed |
| CFiles | CFiles -- |
| CFiles_Base | CFiles_Base -- |
| CFileSet | |
| CFileSourceCollector | |
| CFileUtil | CFileUtil -- |
| CFileWriter | |
| oligofar::CFilter | |
| CFilter | CFilter -- |
| CFilter2 | |
| CFilter_Base | CFilter_Base -- |
| CFilterDefault< T > | |
| CFilterDialog | |
| CFilteringArgs | Argument class for collecting filtering options |
| CFilteringFastaOstream | |
| CFilteringMemento | Memento class to save, null out, and restore the filtering options of the CBlastOptionsMemento object passed to its constructor This prevents side effects (like filtering the query sequence) to occur during calculation of the effective search space |
| CFilterNull< T > | |
| CFilterRegEx | |
| CFilterSet | |
| CFilterSet2 | |
| CFilterT< T > | |
| CConcurrentMap< Key, Value, Comparator, Allocator, CntChildsInNode, MaxTreeHeight, DeletionDelay, DelStoreCapacity >::CFinalNodeDeleter | |
| CFindFileNamesFunc< TNames > | Functor for generic FindFiles, adds file name to the specified container |
| CFindGapIntronRow | |
| CFindOverlapJob | CFindOverlapJob |
| CFindOverlapPanel | |
| CFindOverlapParams | |
| CFindOverlapTool | CFindOverlapTool |
| CFindPattern | |
| CFindRSites | This class contains the static member functions Find, which find restriction sites in a sequence |
| CBioTree< TBioNode >::CFindUidFunc | Find node by UID functor |
| IWMClient::CFingerprint | CFingerprint identifies an instance of IWMClient and is used for labeling layout positions |
| CFIntornData | |
| CFIntron | |
| CFIntronDon | |
| CFirstChars | CFirstChars -- |
| CFirstExon | |
| CFix_author_caps | CFix_author_caps -- |
| CFix_author_caps_Base | CFix_author_caps_Base -- |
| CFix_caps_action | CFix_caps_action -- |
| CFix_caps_action_Base | CFix_caps_action_Base -- |
| CFix_format_action | CFix_format_action -- |
| CFix_format_action_Base | CFix_format_action_Base -- |
| CFix_pub_caps_action | CFix_pub_caps_action -- |
| CFix_pub_caps_action_Base | CFix_pub_caps_action_Base -- |
| CFix_sets_action | CFix_sets_action -- |
| CFix_sets_action_Base | CFix_sets_action_Base -- |
| CFixGenericListCtrl | |
| CFlatAnticodonQVal | |
| CFlatBondQVal | |
| CFlatBoolQVal | |
| CFlatCodeBreakQVal | |
| CFlatCodonQVal | |
| CFlatException | |
| CFlatExperimentQVal | |
| CFlatFeature | |
| CFlatFeatureRetrieveJob | |
| CFlatFileConfig | |
| CFlatFileContext | |
| CFlatFileDemoDlg | |
| CFlatFileExporter | |
| CFlatFileExporterFactory | |
| CFlatFileExportJob | CFlatFileExportJob |
| CFlatFileExportPage | |
| CFlatFileExportParams | |
| CFlatFileFactoryBuilder | |
| CFlatFileFeatureCollapsed | |
| CFlatFileGenerator | |
| CFlatFileHeader | |
| CFlatFileRetrieveJob | |
| CFlatFileSeqBlockCollapsed | |
| CFlatFileTextItem | |
| CFlatFileViewContext | |
| CFlatFileViewState | |
| CFlatGapLoc | |
| CFlatGatherer | |
| CFlatGeneQVal | |
| CFlatGeneSynonymsQVal | |
| CFlatGoQVal | |
| CFlatIllegalQVal | |
| CFlatInferenceQVal | |
| CFlatIntQVal | |
| CFlatItem | |
| CFlatItemFormatter | |
| CFlatItemOStream | |
| CFlatLabelQVal | |
| CFlatModelEvQVal | |
| CFlatMolTypeQVal | |
| CFlatNomenclatureQVal | |
| CFlatNumberQVal | |
| CFlatOrganelleQVal | |
| CFlatOrgModQVal | |
| CFlatProductNamesQVal | |
| CFlatPubSetQVal | |
| CFlatSeqIdQVal | |
| CFlatSeqLoc | |
| CFlatSeqLocQVal | |
| CFlatSiteQVal | |
| CFlatStringListQVal | |
| CFlatStringQVal | |
| CFlatSubSourcePrimer | |
| CFlatSubSourceQVal | |
| CFlatTrnaCodonsQVal | |
| CFlatXrefQVal | |
| CFlexibleDatePanel | |
| pythonpp::CFloat | |
| CFloatingFrame | |
| pythonpp::CFloatingPointError | |
| CFloatTextValidator | |
| CLog::CFlusher | |
| CFolder | CFolder -- |
| CFolderEditDlg | |
| CFolderInfo | |
| CFolderInfo_Base | CFolderInfo_Base -- |
| CFolderNameValidator< TFolder > | |
| CFontConfig | File Description: |
| CFontDemoPanel | |
| CFontWindow | |
| CForceJob | Class used to run deformation on separate thread |
| CFormArgDesc | |
| CFileLoadOptionPanel::CFormatDescriptor | |
| CFormatGuess | Class implements different ad-hoc unreliable file format identifications |
| CFormatGuessApp | |
| CFormatGuessEx | Wraps CFormatGuess, and if CFormatGuess's result is Unknown, it tries every file reader until one works |
| CFormatGuess::CFormatHints | Hints for guessing formats |
| CFormatItemOStream | |
| CFormatQual | |
| CFormatReadHook | |
| CFormatRpsDbParameters | |
| CFormatRpsDbParameters_Base | This structure is used to create the RPS-BLAST database auxiliary file (*.aux) and it contains parameters set at creation time of the PSSM |
| CFormattedQualPanel | |
| CFormattingArgs | Argument class to collect formatting options, use this to create a CBlastFormat object |
| CFormicAcid | |
| CFragment_masses | CFragment_masses -- |
| CFragment_masses_Base | Quantitation channel |
| CFrAlignRow | |
| CFrameFinder | Function object to assist in finding all CSeqLocInfo objects which corresponds to a given frame |
| CFrameShiftArgs | Argument class to collect the frame shift penalty for out-of-frame searches |
| CFrameworkDemoApp | Derive our application class from CwxNCBIApp and use it together with standard CNCBIwxApplication |
| CFrameworkDemoGUI | CFrameworkDemoFrame |
| CFrameworkDemoGUIDropTarget | CFrameworkDemoGUIDropTarget |
| CFrameworkDemoToolBarFactory | CFrameworkDemoToolBarFactory |
| CFStreamByteSource | |
| CFtableFormatter | |
| CFtableGatherer | |
| CFullTreeConstIterator | |
| CFuncPtr | |
| CFuncPtr1< RetType, Arg1 > | |
| CFuncPtrTmpl< T > | |
| CFuncPtrTmpl1< T, RetType, Arg1 > | |
| pythonpp::CFunction | |
| CFutex | |
| CConnTest::CFWConnPoint | Auxiliary class to hold FWDaemon CP(connection point) information and its current status |
| CFxnSet | CFxnSet -- |
| CFxnSet_Base | Functional relationship of SNP (and possibly alleles) to genes at contig location as defined in organism-specific bxxx_SNPContigLocusId_xxx tables |
| CGapItem | |
| CGapJob | CGapJob |
| CGappedArgs | Argument class for collecting gapped options |
| CLocMapper_Default::CGappedRange | |
| CGapTrack | |
| CGapTrackFactory | |
| CGapTriggerArgs | Argument class to retrieve the gap trigger option |
| CGather_Iter | |
| CGB_block | |
| CGB_block_Base | GenBank specific descriptions |
| CGB_Coordinate | CGB_Coordinate -- |
| CGB_Coordinate_Base | ========================================================================== |
| CGB_Coordinate_Set | CGB_Coordinate_Set -- |
| CGB_Coordinate_Set_Base | CGB_Coordinate_Set_Base -- |
| CGB_DataLoaderCF | |
| CGb_qual | .hpp User-defined methods of the data storage class |
| CGb_qual_Base | CGb_qual_Base -- |
| CGB_Writer_PluginManager_DllResolver | |
| CGBAltSeqData | CGBAltSeqData -- |
| CGBAltSeqData_Base | CGBAltSeqData_Base -- |
| CGBAltSeqItem | CGBAltSeqItem -- |
| CGBAltSeqItem_Base | CGBAltSeqItem_Base -- |
| CGBankLoadingJob | |
| CGBAuthor | CGBAuthor -- |
| CGBAuthor_Base | CGBAuthor_Base -- |
| CGBComment | CGBComment -- |
| CGBComment_Base | CGBComment_Base -- |
| CGBCommentItem | CGBCommentItem -- |
| CGBCommentItem_Base | CGBCommentItem_Base -- |
| CGBCommentParagraph | CGBCommentParagraph -- |
| CGBCommentParagraph_Base | CGBCommentParagraph_Base -- |
| CGBDataLoader | |
| CGBDocument | CGBDocument |
| CGBDocumentLabelHandler | |
| CGBenchFeedbackAttachment | |
| CGBenchFeedbackAttachment_Base | CGBenchFeedbackAttachment_Base -- |
| CGBenchFeedbackRequest | |
| CGBenchFeedbackRequest_Base | CGBenchFeedbackRequest_Base -- |
| CGBenchInitReply | |
| CGBenchInitReply_Base | We reply to 'init' with the current version so the client can make a decision about whether to request an update We also send some configuration information, including: |
| CGBenchInitRequest | |
| CGBenchInitRequest_Base | At initialization, we only ask for the version of Genome Workbench being run |
| CGBenchPipe | CGBenchPipe |
| CGBenchService | |
| CGBenchService_Base | CGBenchService_Base -- |
| CGBenchServiceReply | |
| CGBenchServiceReply_Base | Matched replies for our request |
| CGBenchServiceRequest | |
| CGBenchServiceRequest_Base | A request is a choice of a few different entities |
| CGBenchToolResults | |
| CGBenchToolResults_Base | CGBenchToolResults_Base -- |
| CGBenchVersionInfo | |
| CGBenchVersionInfo_Base | CGBenchVersionInfo_Base -- |
| CGBenchVersionReply | |
| CGBenchVersionReply_Base | CGBenchVersionReply_Base -- |
| CGBenchVersionRequest | |
| CGBenchVersionRequest_Base | CGBenchVersionRequest_Base -- |
| CGbEntryHandler | Handler for GenBank release files |
| CGBFeature | CGBFeature -- |
| CGBFeature_Base | CGBFeature_Base -- |
| CGBFeatureSet | CGBFeatureSet -- |
| CGBFeatureSet_Base | CGBFeatureSet_Base -- |
| CGBInterval | CGBInterval -- |
| CGBInterval_Base | CGBInterval_Base -- |
| CGBKeyword | CGBKeyword -- |
| CGBKeyword_Base | CGBKeyword_Base -- |
| CGBLoaderParams | |
| CGBProject | |
| CGBProject_Base | Version 1 (unversioned) project This project description is frozen as of 12/1/2005 and should not be modified |
| CGBProject_ver2 | CGBProject_ver2 |
| CGBProject_ver2_Base | Version 2 project With version two we start a new paradigm The first item in the project *MUST* be a non-optional version stamp, composed as an integer |
| CGBProject_ver2LabelHandler | |
| CGBProjectHandle | |
| CGBProjectHandle_Base | A project handle is an abstraction that binds all possible versions This is stored in a workspace; the serialized component |
| CGBProjectLabelHandler | |
| CGBProjectTool | |
| CGBQualDirectionPanel | |
| CGBQualifier | CGBQualifier -- |
| CGBQualifier_Base | CGBQualifier_Base -- |
| CGBQualPanel | |
| CGBQualStringListValidator | |
| CGBQualTextPanel | |
| CGBReaderCacheManager | |
| CGBReaderRequestResult | |
| CGBReference | CGBReference -- |
| CGBReference_Base | CGBReference_Base -- |
| CGBReleaseFile | CGBReleaseFile is a utility class to ease the processing of Genbank release files one Seq-entry at a time |
| CGBReleaseFileImpl | |
| CGBRequestStatistics | |
| CGbScopeLoader | |
| CGBSecondary_accn | CGBSecondary_accn -- |
| CGBSecondary_accn_Base | CGBSecondary_accn_Base -- |
| CGBSeq | CGBSeq -- |
| CGBSeq_Base | CGBSeq_Base -- |
| CGBSeqFormatter | |
| CGBSeqid | CGBSeqid -- |
| CGBSeqid_Base | CGBSeqid_Base -- |
| CGBSet | CGBSet -- |
| CGBSet_Base | GBSeq represents the elements in a GenBank style report of a sequence with some small additions to structure and support for protein (GenPept) versions of GenBank format as seen in Entrez |
| CGBStrucComment | CGBStrucComment -- |
| CGBStrucComment_Base | CGBStrucComment_Base -- |
| CGBStrucCommentItem | CGBStrucCommentItem -- |
| CGBStrucCommentItem_Base | CGBStrucCommentItem_Base -- |
| CGBWorkspace | CGBWorkspace |
| CGBWorkspace_Base | A workspace is a hierarchically organized set of projects Projects represent the leaves in the tree |
| CGBWorkspaceLabelHandler | |
| CGBXref | CGBXref -- |
| CGBXref_Base | CGBXref_Base -- |
| CGC_Assemblies | CGC_Assemblies -- |
| CGC_Assemblies_Base | CGC_Assemblies_Base -- |
| CGC_Assembly | |
| CGC_Assembly_Base | A GC-Assembly is either a single assembly unit or it is a set of assemblies |
| CGC_AssemblyDesc | CGC_AssemblyDesc -- |
| CGC_AssemblyDesc_Base | CGC_AssemblyDesc_Base -- |
| CGC_AssemblySet | |
| CGC_AssemblySet_Base | CGC_AssemblySet_Base -- |
| CGC_AssemblyUnit | |
| CGC_AssemblyUnit_Base | CGC_AssemblyUnit_Base -- |
| CGC_DbTagAlias | CGC_DbTagAlias -- |
| CGC_DbTagAlias_Base | |
| CGC_External_Seqid | CGC_External_Seqid -- |
| CGC_External_Seqid_Base | CGC_External_Seqid_Base -- |
| CGC_Genome | CGC_Genome -- |
| CGC_Genome_Base | CGC_Genome_Base -- |
| CGC_GenomicPart | CGC_GenomicPart -- |
| CGC_GenomicPart_Base | CGC_GenomicPart_Base -- |
| CGC_Project | CGC_Project -- |
| CGC_Project_Base | CGC_Project_Base -- |
| CGC_Query | CGC_Query -- |
| CGC_Query_Base | A GC-Assemblies is a mere set of assemblies |
| CGC_Replicon | |
| CGC_Replicon_Base | CGC_Replicon_Base -- |
| CGC_Scaf_stats | CGC_Scaf_stats -- |
| CGC_Scaf_stats_Base | CGC_Scaf_stats_Base -- |
| CGC_SeqIdAlias | |
| CGC_SeqIdAlias_Base | Seq-id-alias a sequence has multiple seq-ids - refseq, genbank, local and each one has both gi and accession.version We cannot provide them as simply a list of seq-ids since it will be unclear which gi goes with which accession, therefore we group the related ones as alias pair |
| CGC_Sequence | |
| CGC_Sequence_Base | GC-Sequence: Used for scaffolds, scaffold-sets and components in Gencoll terminology |
| CGC_SequenceStats | CGC_SequenceStats -- |
| CGC_SequenceStats_Base | Stats of complex objects Used at assembly and chromosome levels |
| CGC_TaggedSequences | CGC_TaggedSequences -- |
| CGC_TaggedSequences_Base | GC-TaggedSequences: set of sequences in a specific role |
| CGC_TypedSeqId | CGC_TypedSeqId -- |
| CGC_TypedSeqId_Base | CGC_TypedSeqId_Base -- |
| CGCAssemblyLoadingJob | CGCAssemblyLoadingJob |
| CGCAssemblyLoadManager | CGCAssemblyLoadManager - Load Manager that loads genome collection assembly |
| CGCAssemblySearchWizard | CGCAssemblySearchWizard - A wizard that helps searching gc assembly |
| CGCAssmGet | Help class to retrieve gencoll assembly |
| CGCAsssemblyHandler | CGCAsssemblyHandler label handler |
| CGCClient_Error | CGCClient_Error -- |
| CGCClient_Error_Base | CGCClient_Error_Base -- |
| CGCClient_GetAssemblyRequest | CGCClient_GetAssemblyRequest -- |
| CGCClient_GetAssemblyRequest_Base | CGCClient_GetAssemblyRequest_Base -- |
| CGCClientRequest | CGCClientRequest -- |
| CGCClientRequest_Base | CGCClientRequest_Base -- |
| CGCClientResponse | CGCClientResponse -- |
| CGCClientResponse_Base | CGCClientResponse_Base -- |
| CGen_code_table | |
| CGen_code_table_imp | |
| CGenBankDSEvtHandler | CGenBankDSEvtHandler - wxEvtHandler-derived adapter for GenBank data source |
| CGenbankFormatter | |
| CGenbankGatherer | |
| CGenBankLoadingJob | CGenBankLoadingJob |
| CGenBankLoadOptionPanel | CGenBankLoadOptionPanel |
| CGenBankUIDataSource | CGenBankUIDataSource |
| CGenBankUIDataSourceType | CGenBankUIDataSourceType |
| CGenBankUILoadManager | |
| CGeneFileWriter::CGene2AccnProcessor | Gene->Accession line processor |
| CGeneFileWriter::CGene2PMProcessor | Gene->PubMed line processor |
| CGene_commentary | |
| CGene_commentary_Base | CGene_commentary_Base -- |
| CGene_nomenclature | CGene_nomenclature -- |
| CGene_nomenclature_Base | CGene_nomenclature_Base -- |
| CGene_ref | |
| CGene_ref_Base | Gene *********************************************** |
| CGene_source | CGene_source -- |
| CGene_source_Base | CGene_source_Base -- |
| CGene_track | CGene_track -- |
| CGene_track_Base | CGene_track_Base -- |
| CGene_xref_type | CGene_xref_type -- |
| CGene_xref_type_Base | CGene_xref_type_Base -- |
| CGeneContentEvtHandler | |
| CGeneFileUtils | CGeneFileUtils |
| CGeneFileWriter | CGeneFileWriter |
| CGeneGroup | CGeneGroup is a subclass of CLayoutGroup contains gene, RNA, cds, and Exon features |
| CGeneInfo | CGeneInfo |
| CGeneInfoException | CGeneInfoException |
| CGeneInfoFileReader | CGeneInfoFileReader |
| CGeneFileWriter::CGeneInfoProcessor | Gene Info line processor |
| CGeneModel | |
| CGeneModelConfig | |
| CGeneModelDemoApp | |
| CGeneModelFactory | CGeneModelFactory |
| CGeneModelFeatJob | CGeneModelFeatJob: a job class for loading annotated main features, including genes, RNAs, CDSs and exons from a given sequence and a given visible range |
| CGeneModelTrack | CGeneModelTrack -- |
| CGeneOverlapProcess | |
| CGenePanel | |
| CGeneralException | |
| CGeneralParseException | |
| CGeneralScoreMatrix | Score matrix that can take any value |
| CGeneralScoreMatrixException | Exceptions for CGeneralScoreMatrix |
| CGenerateCodeCallback | |
| CGenerateIncludesCallback | |
| CGenerateStoredArgInitializerCallback | |
| CGenerateStoredArgVariablesCallback | |
| pythonpp::CGenerator | |
| CGenericPropsPanel | |
| CGenericSearchArgs | Argument class for general search BLAST algorithm options: evalue, gap penalties, query filter string, ungapped x-drop, initial and final gapped x-drop, word size, percent identity, and effective search space |
| CGeneSearchPlugin | |
| CGeneSelector | |
| CGeneSelectorArgUtil | |
| CGenetic_code | |
| CGenetic_code_Base | Each code is 64 cells long, in the order where T=0,C=1,A=2,G=3, TTT=0, TTC=1, TCA=4, etc NOTE: this order does NOT correspond to a Seq-data encoding |
| CGenetic_code_table | |
| CGenetic_code_table_Base | Table of genetic codes |
| CGeneticCodeArgs | Argument class to collect the genetic code for all queries/subjects |
| CGenomeAnnotComment | |
| CGenomeItem | |
| CGenomeProjectItem | |
| CGenomicCollectionsService | |
| CGenomicCollectionsService_Base | CGenomicCollectionsService_Base -- |
| CGet1TypeInfoSource | |
| CGet2TypeInfoSource | |
| CGetBioseqHandle_local | Functor to get seq_id_handle (used for async execution) |
| CGetFeature | |
| CGetJobCmdExecutor | |
| CGetJobNotificationThread | |
| CGetLoadProcessor | |
| CGetNetTaxIds | |
| CGetOpt | |
| CGetOverlappingFeaturesPlugin | |
| CGetPasswordFromConsoleException | Exception class for g_GetPasswordFromConsole |
| CGetSeqLocFromStringHelper | |
| CGetSeqLocFromStringHelper_ReadLocFromText | |
| CGetStatisticsProcessor | |
| CGetTaxIdLabels | Functor class for background labels preparation |
| CGetTaxonLabels_local | Functor to retrieve taxonomy labels (used for async execution) |
| CGetTooltip_local | Functor to retrieve tooltip (used for async execution) |
| CGetVersionProcessor | |
| CGff2Reader | |
| CGff2Record | |
| CGff2Writer | CWriterBase implementation that formats Genbank objects as plain GFF files |
| CGFF3_CIGAR_Formatter | |
| CGff3Reader | |
| CGff3ReadRecord | |
| CGff3SofaTypes | |
| CGff3SourceRecord | |
| CGff3Writer | |
| CGff3WriteRecordFeature | |
| CGffAlignmentRecord | |
| CGffExporter | |
| CGffExporterFactory | |
| CGffExportJob | CGffExportJob |
| CGffExportPage | |
| CGffExportParams | |
| CGffFeatureContext | |
| CGFFGatherer | |
| CGffLoadManager | CGffLoadManager |
| CGffLoadParams | |
| CGffLoadTask | CGffLoadTask |
| CGffParamsPanel | |
| CGFFReader | |
| CGffRecord | |
| CGffWriteRecord | |
| CGffWriteRecordFeature | |
| CGi2TaxIdApp | |
| CGiCache | Class CGiCache provides a simple, thread-safe interface for storing the older or outdated versions of sequence records viewed in GBench |
| CGICacheReader | |
| CGICacheReaderCF | Class factory for ID1 reader |
| CGiimport_id | CGiimport_id -- |
| CGiimport_id_Base | CGiimport_id_Base -- |
| CGl3dDemoPanel | |
| CGl3dWindow | |
| CGL_matrix | CGL_matrix -- |
| CGL_matrix_Base | CGL_matrix_Base -- |
| CGlArcBall | |
| CGlAttrGuard | CGlAttrGuard - guard class for restoring OpenGL attributes |
| CGlBackground | |
| CGlBitmapFont | |
| CGlBuffer< T > | CGlBuffer Concrete buffers (to store vertices, vertex attributes, or indices to vertex buffers) are derived from this class |
| CGlBuffer11< T > | CGlBuffer11 Implement abstract buffer interface using simple STL array |
| CGlBuffer20< T > | CGlBuffer20 Implement the abstract buffer interface based on OpenGL vertex buffer objects |
| CGlCamera | |
| CGLCanvas | CGLCanvas |
| CGlCgiImageApplication | |
| CGlContainer | |
| CGLContextCache | |
| CGlCurve< Curve > | Class ICurve defines a basic interface for all curves |
| CGLDemoDlg | |
| CGlDisplayList | |
| CGlDisplayListCompile | |
| CGlDrawScale | |
| CGlEvent | |
| CGlFeedbackFont | |
| CGLFrameBuffer | CGLFrameBuffer |
| CGlGeometry | |
| CGLGlewContext | CGLGlewContext - Store instance of glew context in a singleton that is available to all opengl libs, not just ones dependent on wx |
| CGlimmerReader | |
| CGlInfoDemoPanel | |
| CGlInfoWindow | |
| CGlLight | |
| CGlMaterial | |
| CGlModel2D | CGlModel2D Base class for a model set up for rendering purposes |
| CGlobal_id | CGlobal_id -- |
| CGlobal_id_Base | Cdd's should not exist without a unique accession, but alternative id's may be present as well |
| CGlObject | CGlObject Base class for OpenGl objects like buffers and models |
| CGlOsContext | |
| CGlPane | Class CGlPane |
| CGlPaneGuard | |
| CGlPaneWidgetChildDemo | |
| CGlPaneWidgetDemoPanel | |
| CGlPoint< T > | |
| CGlPreviewSetupWidget | |
| CGlRect< T > | CGlRect reprsents rectangle in the coordinate system with origin located in the left bottom corner |
| CGlRenderBuffer< T > | CGlRenderBuffer This is a thin wrapper for buffer objects derived from CGlBuffer |
| CGlRenderNode | CGlRenderNode A unit of renderable geometry and the associated state information needed for rendering |
| CGlResMgr | |
| CGlState | CGlState Class to encapsulate OpenGL state so that a set of user-selected GL state options can be saved and then enabled as needed, particularly before the rendering of some object |
| CGlTestApplication | |
| CGLTestWMClient | CTextWMClient |
| CGlTexture | |
| CGlTextureManager | |
| CGlTube< Curve > | Class ICurve defines a basic interface for all curves |
| CGluC | Glu-C, Cterm of E |
| CGluCAspN | Glu-C and Asp-N |
| CGluCDE | EMSEnzymes_gluc_de Glu-C that cuts at D and E |
| CGlUtils | |
| CGlVboGeom | CGlVboGeom This is an abstract base class to hold 1 or more buffers needed to render application geometry |
| CGlVboGeom11 | CGlVboGeom11 This class holds one or more OpenGL vertex buffers implemented as c++ arrays |
| CGlVboGeom20 | CGlVboGeom20 This class holds one or more OpenGL vertex buuffer objects and implements the CGlVboGeom interface |
| CGlVboNode | CGlVboNode A rendering node that holds a vertex buffer object |
| CGlViewport | |
| CGlWidget | |
| CGlWidgetBase | Class CGlWidgetBase |
| CGlWidgetDemo | CGlWidgetDemo |
| CGlWidgetPane | CGlWidgetPane represent a window component residing in CGlWidgetBase client area |
| CGlyph | |
| CGlyphContainer | File Description: |
| CGlyphSearchVisitor | |
| CGlZoomLens | |
| CGnomon_param | CGnomon_param -- |
| CGnomon_param_Base | CGnomon_param_Base -- |
| CGnomon_params | CGnomon_params -- |
| CGnomon_params_Base | CGnomon_params_Base -- |
| CGnomonAnnotator | |
| CGnomonAnnotator_Base | |
| CGnomonAnnotatorArgUtil | |
| CGnomonEngine | |
| CGnomonException | |
| CGoQualLessThan | |
| CGoTermSortStruct | |
| CGPipeAlignmentScorer | |
| CGradientColorPanel | |
| CGradientPanel | |
| CGraph_CI | CGraph_CI -- |
| CGraphBase | CGraphBase |
| CGraphContainer | CGraphContainer CGraphContainer a composite IRenderable that manages several child IRenderable graphs |
| CGraphContainerEvtHandler | |
| CGraphDotMarker | Class CGraphDotMarker |
| CGraphFindContext | |
| CGraphGlyph | CGraphGlyph -- a speical histograms glyph converted from a seq-graph |
| CGraphNotification | CGraphEvent |
| CGraphPanel | Class CGraphPanel CGraphPanel class is an assembly of a number of "graph" library objects |
| CGraphRanges | Helper class for mapping graphs |
| CGraphTrack | CGraphTrack -- |
| CGraphTrackFactory | CGraphTrackFactory |
| CGrid | CGrid |
| CGridCgiApplication | Grid Cgi Application |
| CGridCgiContext | Grid CGI Context Context in which a request is processed |
| CGridCgiSampleApplication | |
| CGridCleanupThread | |
| CGridClient | Grid Client (the submitter) |
| CGridClientApp | Grid Client Application |
| CGridClientException | Grid Client exception |
| CGridClientSampleApp | |
| CGridCommandLineInterfaceApp | |
| CGridControlThread | |
| CGridDebugContext | |
| CGridGlobals | |
| CGridJobBatchSubmitter | Grid Job Batch Submitter |
| CGridThreadContext | |
| CGridWidget | |
| CGridWorkerApp | Main Worker Node application |
| CGridWorkerNode | Grid Worker Node |
| CGridWorkerNodeApp_Listener | An adapter class for IGridWorkerNodeApp_Listener |
| CGridWorkerNodeException | |
| CGroupAlignmentsJob | CGroupAlignmentsJob |
| CGroupAlignmentsParamsPanel | CGroupAlignmentsParamsPanel |
| CGroupAlignmentsToolManager | CGroupAlignmentsToolManager |
| CGroupCheckboxes | |
| CGroupMapWidget::CGroupItem | CGroupItem //////////////////////////////////////////////////////////// |
| CGroupMapWidget | CGroupMapWidget |
| CGroupRadioButtons | |
| CGroupTableModel | |
| CGsdbComment | |
| CGtfReader | |
| CGtfRecord | |
| CGtfWriter | |
| CLDS_CollectSeq_idsReader::CGuard | |
| CLDS2_Seq_id_Hook::CGuard | |
| CGuard< Resource, Lock, Unlock > | |
| CFlatSeqLoc::CGuardedToAccessionMap | |
| CGuiConfigException | Exceptions thrown by CSettings Set and Factory default classes should derive from this |
| oligofar::CGuideFile | |
| CGuiDependentPkg | |
| CGuiDependentPkg_Base | CGuiDependentPkg_Base -- |
| oligofar::CGuideSamFile | |
| CGuideTreeApplication | |
| CGuidGenerator | |
| CGUIEvent | CGUIEvent provides mapping of FLTK events to Semantic Events |
| CGuiObjectInfoBioseq | |
| CGuiObjectInfoBioseq_set | |
| CGuiObjectInfoBioTreeContainer | |
| CGuiObjectInfoDefault | |
| CGuiObjectInfoDistanceMatrix | |
| CGuiObjectInfoEntrez2_docsum | |
| CGuiObjectInfoEntrezgene | |
| CGuiObjectInfoGCAssembly | |
| CGuiObjectInfoSeq_align | |
| CGuiObjectInfoSeq_align_set | |
| CGuiObjectInfoSeq_annot | |
| CGuiObjectInfoSeq_feat | |
| CGuiObjectInfoSeq_id | |
| CGuiObjectInfoSeq_loc | |
| CGuiObjectInfoValidError | |
| CGuiPkgDependency | |
| CGuiPkgDependency_Base | CGuiPkgDependency_Base -- |
| CGuiPkgManifest | |
| CGuiPkgManifest_Base | CGuiPkgManifest_Base -- |
| CGuiRegistry | |
| CGuiRegistryUtil | |
| CGuiSeqInfoDefault | |
| CGuiSeqInfoSeq_id | |
| CGUIUserType | CGUIUserType |
| CGumbelParamsApplication | Application for computing Gumbel parameters |
| CGumbelParamsCalc | Wrapper for Gumbel parameter calculation |
| CGumbelParamsCalcVersion | Keeps track of Gumbel params calculation library version |
| CGumbelParamsException | Exception class |
| CGumbelParamsOptions | Input parameters for Gumbel parameters calculation |
| CGumbelParamsOptionsFactory | Class used for creation of sets of input parameters |
| CGumbelParamsRandDiagnostics | Options that control random values used in internal parts of Gumbel parameter calculation for gapped aligmment |
| CGumbelParamsResult | Result of Gumbel parameters calculation along with diagnostic info |
| CGvfReader | |
| CGvfReadRecord | |
| CGvfWriter | |
| CGvfWriteRecord | |
| CGwasGlyph | |
| CGwasLoadJob | CGwasLoadJob |
| CGwasLoadParams | |
| CGwasTrackLoadManager | CGwasTrackLoadManager |
| CGwasTrackParamsPanel | |
| CGZipChunkHandler | |
| ChainInfo | |
| CHandleRange | |
| CHandleRangeMap | |
| mu::Parser::change_dec_sep< TChar > | A facet class used to change decimal and thousands separator |
| CHapmapJob | CHapmapJob |
| CHapmapTrack | |
| CHapmapTrackFactory | |
| CObjectIStream::CharBlock | |
| CObjectOStream::CharBlock | |
| oligofar::CHashAtom | |
| oligofar::fourplanes::CHashCode | |
| oligofar::fourplanes::CHashGenerator | |
| oligofar::fourplanes::CHashIterator | |
| CHashParam | |
| oligofar::fourplanes::CHashPlanes | |
| oligofar::CHashPopulator | |
| CHeapElement | |
| CHeapScope | |
| Check< T > | |
| ncbi::boost_fp_impl::check_is_close_t | |
| ncbi::boost_fp_impl::check_is_small_t | |
| CHelloApp | |
| CHelloBasicCommand | |
| CHelloCommand | |
| CHelloReplyCommand | |
| CHelloResource | |
| CHelloWorldDlg | |
| ChemicalGraph | |
| CHeterogen | CHeterogen -- |
| CHeterogen_Base | Cofactor, prosthetic group, inhibitor, etc |
| CHG_Alignment | CHG_Alignment -- |
| CHG_Alignment_Base | CHG_Alignment_Base -- |
| CHG_AlignmentSet | CHG_AlignmentSet -- |
| CHG_AlignmentSet_Base | CHG_AlignmentSet_Base -- |
| CHG_Commentary | CHG_Commentary -- |
| CHG_Commentary_Base | CHG_Commentary_Base -- |
| CHG_CommentaryContainer | CHG_CommentaryContainer -- |
| CHG_CommentaryContainer_Base | CHG_CommentaryContainer_Base -- |
| CHG_CommentarySet | CHG_CommentarySet -- |
| CHG_CommentarySet_Base | CHG_CommentarySet_Base -- |
| CHG_Domain | CHG_Domain -- |
| CHG_Domain_Base | CHG_Domain_Base -- |
| CHG_Entry | |
| CHG_Entry_Base | CHG_Entry_Base -- |
| CHG_EntrySet | CHG_EntrySet -- |
| CHG_EntrySet_Base | HomoloGeneEntry taxid is the tax id of the group node, which can be the same as the Gene tax id in case of singletons |
| CHG_Gene | |
| CHG_Gene_Base | CHG_Gene_Base -- |
| CHG_Link | CHG_Link -- |
| CHG_Link_Base | CHG_Link_Base -- |
| CHG_Node | CHG_Node -- |
| CHG_Node_Base | CHG_Node_Base -- |
| CHG_Node_id | CHG_Node_id -- |
| CHG_Node_id_Base | CHG_Node_id_Base -- |
| CHG_Stats | CHG_Stats -- |
| CHG_Stats_Base | CHG_Stats_Base -- |
| variation_ref::CHgvsParser | |
| variation::CHgvsParser | |
| variation_ref::CHgvsParser::CHgvsParserException | |
| variation::CHgvsParser::CHgvsParserException | |
| CHiddenSetting | CHiddenSetting -- |
| CHiddenSetting_Base | CHiddenSetting_Base -- |
| CHIntronScore | |
| CHistComment | |
| CHistConfigDlg | |
| CHistConfParams | File Description: |
| CHistogramGlyph | |
| CHistogramGraph | CHistogramGraph |
| CHistParams | File Description: |
| CHistParamsManager | CHistParamsManager: class for manage histogram/graph settings for all feature subtype and various graphs |
| oligofar::CHit | |
| CHit | A generalized representation of a pairwise alignment |
| CCddInputData::CHit | Single RPS-BLAST hit |
| CHit_Base | CHit_Base -- |
| CHitCluster | |
| CHitClustering | |
| CHitComparator< THit > | |
| CHitCoverageAccumulator< THit > | |
| CHitElemGlyph | CHitElemGlyph is a simple graphical object representing a Hit Element |
| CHitFilter< THit > | |
| CHitGlyph | CHitGlyph is a simple graphical object representing a Hit as a set of corresponding Hit Elements |
| CHitList | An ordered collection of CHit objects |
| CHitMatrixDataSource | CHitMatrixDataSource |
| CHitMatrixDemoApp | Derive our application class from CwxNCBIApp and use it together with standard CNCBIwxApplication |
| CHitMatrixDemoDlg | |
| CHitMatrixDSBuilder | CHitMatrixDSBuilder |
| CHitMatrixGraph | CHitMatrixGraph |
| CHitMatrixPane | Class CHitMatrixPane |
| CHitMatrixRenderer | CHitMatrixRenderer - renders Hit Matrix Graph, Rulers, axes, grid, sequence and features graphs |
| CHitMatrixSeqGraph | CHitMatrixSeqGraph |
| CHitMatrixWidget | Class CHitMatrixWidget |
| CCddInputData::CHitSegment | Represents one alignment segment of a RPS-BLAST hit |
| CHitSeqId | CHitSeqId |
| CHitSeqRowId | CHitSeqRowId |
| CHMM_State | |
| CHMMParameters | HMM model parameters just create it and pass to a Gnomon engine |
| CHookBioseq__Seq_id | |
| CHookBioseqContext | |
| CHookData< Hook, Function > | |
| CHookDataBase | |
| CHookDefline | |
| CHookSeq_annot__Seq_annot | |
| CHookSeq_annot__Seq_id | |
| CHookSeq_entry__Copy | |
| CHookSeq_entry__Copy__Seq_annot | |
| CHookSeq_entry__Skip | |
| CHookSeq_entry__Skip__Seq_annot | |
| CHookSeq_entry__Skip__Seq_id | |
| CHookTax_id | |
| CHostEntryPointImpl< TClassFactory > | Template implements entry point |
| CHsp | CHsp -- |
| CHsp_Base | CHsp_Base -- |
| CHspFilteringArgs | Argument class to retrieve options for filtering HSPs (e.g |
| CHspStreamWriteThread | |
| CHTML_a | |
| CHTML_area | |
| CHTML_basefont | |
| CHTML_br | |
| CHTML_button | |
| CHTML_checkbox | |
| CHTML_color | |
| CHTML_dir | |
| CHTML_dl | |
| CHTML_fieldset | |
| CHTML_file | |
| CHTML_font | |
| CHTML_form | |
| CHTML_hidden | |
| CHTML_hr | |
| CHTML_html | |
| CHTML_image | |
| CHTML_img | |
| CHTML_input | |
| CHTML_input_button | |
| CHTML_label | |
| CHTML_legend | |
| CHTML_map | |
| CHTML_menu | |
| CHTML_meta | |
| CHTML_ol | |
| CHTML_optgroup | |
| CHTML_option | |
| CHTML_password | |
| CHTML_radio | |
| CHTML_reset | |
| CHTML_script | |
| CHTML_select | |
| CHTML_submit | |
| CHTML_table | |
| CHTML_table_Cache | |
| CHTML_tc | |
| CHTML_tc_Cache | |
| CHTML_text | |
| CHTML_textarea | |
| CHTML_tr | |
| CHTML_tr_Cache | |
| CHTML_ul | |
| CHTMLActiveArea | |
| CHtmlAnchorItem | |
| CHTMLBasicPage | CHTMLBasicPage -- |
| CHTMLBlockElement | |
| CHTMLComment | |
| CHTMLDualNode | |
| CHTMLElement | |
| CHTMLException | CHTMLException -- |
| CHTMLHelper | |
| CHTMLInlineElement | |
| CHTMLListElement | |
| CHTMLNode | |
| CHTMLOpenElement | |
| CHTMLPage | CHTMLPage -- |
| CHTMLPageStat | |
| CHTMLPlainText | |
| CHTMLPopupMenu | CHTMLPopupMenu -- |
| CHTMLSingleElement | |
| CHTMLSpecialChar | |
| CHTMLTagNode | |
| CHTMLText | |
| CHTMLWMClient | CHTMLWMClient |
| CICacheCF< TDriver > | Utility class for ICache class factories |
| CIconUrl | CIconUrl -- |
| CId | CId -- |
| CID1blob_info | CID1blob_info -- |
| CID1blob_info_Base | CID1blob_info_Base -- |
| CID1Client | |
| CID1Client_Base | CID1Client_Base -- |
| CId1FetchApp | |
| CId1Reader | |
| CId1ReaderBase | |
| CId1ReaderCF | Class factory for ID1 reader |
| CID1Seq_hist | CID1Seq_hist -- |
| CID1Seq_hist_Base | CID1Seq_hist_Base -- |
| CID1SeqEntry_info | CID1SeqEntry_info -- |
| CID1SeqEntry_info_Base | CID1SeqEntry_info_Base -- |
| CID1server_back | .hpp User-defined methods of the data storage class |
| CID1server_back_Base | CID1server_back_Base -- |
| CID1server_debug | CID1server_debug -- |
| CID1server_debug_Base | CID1server_debug_Base -- |
| CID1server_maxcomplex | CID1server_maxcomplex -- |
| CID1server_maxcomplex_Base | Complexity stuff will be for ID1 |
| CID1server_request | CID1server_request -- |
| CID1server_request_Base | Requests |
| CID2_Blob_Id | CID2_Blob_Id -- |
| CID2_Blob_Id_Base | Utility types |
| CID2_Blob_Seq_id | CID2_Blob_Seq_id -- |
| CID2_Blob_Seq_id_Base | CID2_Blob_Seq_id_Base -- |
| CID2_Blob_Seq_ids | CID2_Blob_Seq_ids -- |
| CID2_Blob_Seq_ids_Base | Data packed within ID2-Reply-Get-Blob-Seq-ids reply |
| CID2_Error | CID2_Error -- |
| CID2_Error_Base | CID2_Error_Base -- |
| CID2_Get_Blob_Details | CID2_Get_Blob_Details -- |
| CID2_Get_Blob_Details_Base | The following structure describes what parts of blob are required immediately after ID2-Request-Get-Blob-Info in case blob is split |
| CID2_Param | CID2_Param -- |
| CID2_Param_Base | CID2_Param_Base -- |
| CID2_Params | CID2_Params -- |
| CID2_Params_Base | CID2_Params_Base -- |
| CID2_Reply | CID2_Reply -- |
| CID2_Reply_Base | Reply types |
| CID2_Reply_Data | CID2_Reply_Data -- |
| CID2_Reply_Data_Base | Data packing |
| CID2_Reply_Get_Blob | CID2_Reply_Get_Blob -- |
| CID2_Reply_Get_Blob_Base | Reply to ID2-Request-Get-Blob-Info |
| CID2_Reply_Get_Blob_Id | CID2_Reply_Get_Blob_Id -- |
| CID2_Reply_Get_Blob_Id_Base | Reply to ID2-Request-Get-Blob-Id |
| CID2_Reply_Get_Blob_Seq_ids | CID2_Reply_Get_Blob_Seq_ids -- |
| CID2_Reply_Get_Blob_Seq_ids_Base | Reply to ID2-Request-Get-Blob-Info |
| CID2_Reply_Get_Package | CID2_Reply_Get_Package -- |
| CID2_Reply_Get_Package_Base | Reply to ID2-Request-Get-Packages |
| CID2_Reply_Get_Seq_id | CID2_Reply_Get_Seq_id -- |
| CID2_Reply_Get_Seq_id_Base | Reply to ID2-Request-Get-Seq-id |
| CID2_Reply_ReGet_Blob | CID2_Reply_ReGet_Blob -- |
| CID2_Reply_ReGet_Blob_Base | Reply to ID2-Request-ReGet-Blob |
| CID2_Request | CID2_Request -- |
| CID2_Request_Base | CID2_Request_Base -- |
| CID2_Request_Get_Blob_Id | CID2_Request_Get_Blob_Id -- |
| CID2_Request_Get_Blob_Id_Base | Return blob-id with specified seq-id |
| CID2_Request_Get_Blob_Info | CID2_Request_Get_Blob_Info -- |
| CID2_Request_Get_Blob_Info_Base | Return some information related to the blob |
| CID2_Request_Get_Packages | CID2_Request_Get_Packages -- |
| CID2_Request_Get_Packages_Base | Request for set of params packages know by server |
| CID2_Request_Get_Seq_id | CID2_Request_Get_Seq_id -- |
| CID2_Request_Get_Seq_id_Base | Requested sequence ID, can be any string or Seq-id |
| CID2_Request_Packet | CID2_Request_Packet -- |
| CID2_Request_Packet_Base | Request types |
| CID2_Request_ReGet_Blob | CID2_Request_ReGet_Blob -- |
| CID2_Request_ReGet_Blob_Base | This is similar to FTP reget command |
| CID2_Seq_id | CID2_Seq_id -- |
| CID2_Seq_id_Base | CID2_Seq_id_Base -- |
| CID2Client | CID2Client -- |
| CID2Client_Base | CID2Client_Base -- |
| CId2Compressor | |
| CId2FetchApp | |
| CId2Reader | |
| CId2ReaderBase | |
| CId2ReaderCF | Class factory for ID2 reader |
| CID2S_Bioseq_Ids | CID2S_Bioseq_Ids -- |
| CID2S_Bioseq_Ids_Base | CID2S_Bioseq_Ids_Base -- |
| CID2S_Bioseq_Info | CID2S_Bioseq_Info -- |
| CID2S_Bioseq_Info_Base | CID2S_Bioseq_Info_Base -- |
| CID2S_Bioseq_place_Info | CID2S_Bioseq_place_Info -- |
| CID2S_Bioseq_place_Info_Base | CID2S_Bioseq_place_Info_Base -- |
| CID2S_Bioseq_set_Ids | CID2S_Bioseq_set_Ids -- |
| CID2S_Bioseq_set_Ids_Base | CID2S_Bioseq_set_Ids_Base -- |
| CID2S_Bioseqs_Info | CID2S_Bioseqs_Info -- |
| CID2S_Bioseqs_Info_Base | CID2S_Bioseqs_Info_Base -- |
| CID2S_Chunk | CID2S_Chunk -- |
| CID2S_Chunk_Base | CID2S_Chunk_Base -- |
| CID2S_Chunk_Content | CID2S_Chunk_Content -- |
| CID2S_Chunk_Content_Base | Description of information in this chunk Place means id of Bioseq or Bioseq-set |
| CID2S_Chunk_Data | CID2S_Chunk_Data -- |
| CID2S_Chunk_Data_Base | CID2S_Chunk_Data_Base -- |
| CID2S_Chunk_Id | CID2S_Chunk_Id -- |
| CID2S_Chunk_Id_Base | Utility types |
| CID2S_Chunk_Info | CID2S_Chunk_Info -- |
| CID2S_Chunk_Info_Base | CID2S_Chunk_Info_Base -- |
| CID2S_Feat_type_Info | CID2S_Feat_type_Info -- |
| CID2S_Feat_type_Info_Base | CID2S_Feat_type_Info_Base -- |
| CID2S_Gi_Interval | CID2S_Gi_Interval -- |
| CID2S_Gi_Interval_Base | CID2S_Gi_Interval_Base -- |
| CID2S_Gi_Ints | CID2S_Gi_Ints -- |
| CID2S_Gi_Ints_Base | CID2S_Gi_Ints_Base -- |
| CID2S_Gi_Range | CID2S_Gi_Range -- |
| CID2S_Gi_Range_Base | CID2S_Gi_Range_Base -- |
| CID2S_Interval | CID2S_Interval -- |
| CID2S_Interval_Base | CID2S_Interval_Base -- |
| CID2S_Reply_Get_Chunk | CID2S_Reply_Get_Chunk -- |
| CID2S_Reply_Get_Chunk_Base | Reply to ID2S-Request-Get-Chunks |
| CID2S_Reply_Get_Split_Info | CID2S_Reply_Get_Split_Info -- |
| CID2S_Reply_Get_Split_Info_Base | Reply to ID2-Request-Get-Blob-Info |
| CID2S_Request_Get_Chunks | CID2S_Request_Get_Chunks -- |
| CID2S_Request_Get_Chunks_Base | Request for specific chunks |
| CID2S_Seq_annot_Info | CID2S_Seq_annot_Info -- |
| CID2S_Seq_annot_Info_Base | CID2S_Seq_annot_Info_Base -- |
| CID2S_Seq_annot_place_Info | CID2S_Seq_annot_place_Info -- |
| CID2S_Seq_annot_place_Info_Base | CID2S_Seq_annot_place_Info_Base -- |
| CID2S_Seq_assembly_Info | CID2S_Seq_assembly_Info -- |
| CID2S_Seq_assembly_Info_Base | CID2S_Seq_assembly_Info_Base -- |
| CID2S_Seq_data_Info | CID2S_Seq_data_Info -- |
| CID2S_Seq_data_Info_Base | CID2S_Seq_data_Info_Base -- |
| CID2S_Seq_descr_Info | CID2S_Seq_descr_Info -- |
| CID2S_Seq_descr_Info_Base | CID2S_Seq_descr_Info_Base -- |
| CID2S_Seq_feat_Ids_Info | CID2S_Seq_feat_Ids_Info -- |
| CID2S_Seq_feat_Ids_Info_Base | CID2S_Seq_feat_Ids_Info_Base -- |
| CID2S_Seq_id_Interval | CID2S_Seq_id_Interval -- |
| CID2S_Seq_id_Interval_Base | CID2S_Seq_id_Interval_Base -- |
| CID2S_Seq_id_Ints | CID2S_Seq_id_Ints -- |
| CID2S_Seq_id_Ints_Base | CID2S_Seq_id_Ints_Base -- |
| CID2S_Seq_loc | CID2S_Seq_loc -- |
| CID2S_Seq_loc_Base | ID2S-Seq-loc is used to represent unordered and unstranded set of intervals on set of sequences |
| CID2S_Seq_map_Info | CID2S_Seq_map_Info -- |
| CID2S_Seq_map_Info_Base | CID2S_Seq_map_Info_Base -- |
| CID2S_Sequence_Piece | CID2S_Sequence_Piece -- |
| CID2S_Sequence_Piece_Base | CID2S_Sequence_Piece_Base -- |
| CID2S_Split_Info | CID2S_Split_Info -- |
| CID2S_Split_Info_Base | Blob split info types |
| CId_EditCommand< add > | |
| CId_pat | |
| CId_pat_Base | Just to identify a patent |
| CIdCheckList | CIdCheckList -- |
| CIdCheckList_Base | CIdCheckList_Base -- |
| CIdDataValue | |
| CIdDeMux< TBV, TBVFact > | Id to coordinates demultiplexer |
| CIdentifiersPanel | |
| CIdentityRelation | |
| CIdGenerator | CIdGenerator - generates consecutive integer identifiers |
| CIdHandler | |
| CIdlerWrapper | |
| CIdleWatcher | |
| CIdLinkSet | CIdLinkSet -- |
| CIdLinkSet_Base | CIdLinkSet_Base -- |
| CIdList | CIdList -- |
| CIdList_Base | CIdList_Base -- |
| CIdLoc | |
| CIdMapper | IdMapper base class implementation |
| CIdMapperApp | |
| CIdMapperBuiltin | IdMapper implementation using hardcoded values |
| CIdMapperConfig | IdMapper implementation using an external configuration file |
| CIdMapperDatabase | IdMapper implementation using an external database |
| CIdMapperException | |
| CIDs | CIDs class to hold sorted list of IDs |
| CWinMaskUtil::CIdSet | Base class for sets of seq_id representations used with |
| CWinMaskUtil::CIdSet_SeqId | Implementation of CIdSet that compares CSeq_id handles |
| CWinMaskUtil::CIdSet_TextMatch | Implementation of CIdSet that does substring matching |
| CIdUrlList | CIdUrlList -- |
| CIdUrlList_Base | CIdUrlList_Base -- |
| CIdUrlSet | CIdUrlSet -- |
| CIdUrlSet_Base | CIdUrlSet_Base -- |
| CIgAnnotation | |
| CIgAnnotationInfo | |
| CIgapIntron | |
| CIgapIntronChain | |
| CIgBlast | |
| CIgBlastArgs | Argument class to collect options specific to igBLAST |
| CIgBlastnApp | |
| CIgBlastnAppArgs | Handles command line arguments for igblastn binary |
| CIgBlastOptions | |
| CIgBlastpApp | |
| CIgBlastpAppArgs | Handles command line arguments for igblastp binary |
| CIgBlastResults | |
| CIgBlastTabularInfo | Class containing information needed for tabular formatting of BLAST results |
| CIgBlastVersion | Keeps track of the version of IgBLAST in the NCBI C++ toolkit |
| CIgnoreImportLibrary | CIgnoreImportLibrary -- |
| CImage | |
| CImageException | |
| CImageIO | |
| CImageIOBmp | |
| CImageIOGif | |
| CImageIOHandler | Class CImageIOHandler This is the base class for all image I/O handlers, and defines the standard interface required for a class that supports reading and writing an image |
| CImageIOJpeg | |
| CImageIOPng | |
| CImageIORaw | |
| CImageIOSgi | |
| CImageIOTiff | |
| CImageTestApp | |
| CImageUtil | |
| CImp_feat | .hpp User-defined methods of the data storage class |
| CImp_feat_Base | Import *********************************************** |
| CProSplign::CImplementation | |
| CAnnotationASN1::CImplementationData | |
| CImport | CImport -- |
| pythonpp::CImportError | |
| CImportFeaturePanel | |
| CImportGroup | CImportGroup -- |
| CImportGroup_Base | ======================================================================================= Groups import definitions |
| CImportStrategy | Class to return parts of the CBlast4_request, or data associated with a CBlast4_request, such as options |
| CImportStrategyData | This is the "mutable" data for CImportStrategy |
| CImprint | CImprint -- |
| CImprint_Base | Imprint group |
| CInc | |
| CIncreasingTime | |
| CInDelInfo | |
| oligofar::CAligner::CIndelLimits | |
| CIndelMapper | |
| pythonpp::CIndentationError | |
| CIndentingOstream | |
| CIndentingStreambuf | |
| CIndexedDb | This class is responsible for loading indices and doing the actual seed search |
| CIndexedDb_New | Index wrapper for new style MegaBLAST indexing functionality |
| CIndexedDb_Old | Index wrapper for old style MegaBLAST indexing functionality |
| CIndexedDbException | Index wrapper exceptions |
| CIndexedOctetStrings | |
| CIndexedStrings | |
| pythonpp::CIndexError | |
| CIndexSorter | |
| CIndexSuperHeader< CIndexSuperHeader_Base::INDEX_FORMAT_VERSION_1 > | Superheader for old style indices |
| CIndexSuperHeader_Base | Base class for index superheaders |
| CIndexSuperHeader_Exception | Exceptions that superheader objects can throw |
| CIndProgressBar | |
| CInferenceListPanel | |
| CInferencePanel | |
| CInferencePrefixList | |
| CInferenceSupport | CInferenceSupport -- |
| CInferenceSupport_Base | CInferenceSupport_Base -- |
| python::CInfoHandler_CursorCollect | |
| CInfoItem | |
| CInGroupThread | |
| CIniParser | |
| CIniPrint | |
| CInitDS_local | Functor to initialize data source (used for async execution) |
| CInitGuard | |
| CInitMutex< C > | |
| CInitMutex_Base | |
| CInitMutexPool | |
| CInitRegister | |
| CInitRegistrar | |
| CInlineLayout | CInlineLayout is the anther simple layout policy that put a list of glyphs in a single line horizontally sorted by glyph's start position |
| CWinMaskUtil::CInputBioseq_CI | Function iterating over bioseqs in input |
| CInputException | Defines user input exceptions |
| CInputfile | CInputfile -- |
| CInputfile_Base | CInputfile_Base -- |
| CInputGiList | Gi List for database construction |
| CInputModel | |
| CINSDAltSeqData | CINSDAltSeqData -- |
| CINSDAltSeqData_Base | CINSDAltSeqData_Base -- |
| CINSDAltSeqItem | CINSDAltSeqItem -- |
| CINSDAltSeqItem_Base | CINSDAltSeqItem_Base -- |
| CINSDAuthor | CINSDAuthor -- |
| CINSDAuthor_Base | CINSDAuthor_Base -- |
| CINSDComment | CINSDComment -- |
| CINSDComment_Base | CINSDComment_Base -- |
| CINSDCommentItem | CINSDCommentItem -- |
| CINSDCommentItem_Base | CINSDCommentItem_Base -- |
| CINSDCommentParagraph | CINSDCommentParagraph -- |
| CINSDCommentParagraph_Base | CINSDCommentParagraph_Base -- |
| CINSDFeature | CINSDFeature -- |
| CINSDFeature_Base | CINSDFeature_Base -- |
| CINSDFeatureSet | CINSDFeatureSet -- |
| CINSDFeatureSet_Base | INSDFeature_operator contains a string value describing the relationship among a set of INSDInterval within INSDFeature_intervals |
| CINSDInterval | CINSDInterval -- |
| CINSDInterval_Base | INSDInterval_iscomp is a boolean indicating whether an INSDInterval_from / INSDInterval_to location represents a location on the complement strand |
| CINSDKeyword | CINSDKeyword -- |
| CINSDKeyword_Base | CINSDKeyword_Base -- |
| CINSDQualifier | CINSDQualifier -- |
| CINSDQualifier_Base | CINSDQualifier_Base -- |
| CINSDReference | CINSDReference -- |
| CINSDReference_Base | INSDReference_position contains a string value indicating the basepair span(s) to which a reference applies |
| CINSDSecondary_accn | CINSDSecondary_accn -- |
| CINSDSecondary_accn_Base | CINSDSecondary_accn_Base -- |
| CINSDSeq | CINSDSeq -- |
| CINSDSeq_Base | CINSDSeq_Base -- |
| CINSDSeqid | CINSDSeqid -- |
| CINSDSeqid_Base | CINSDSeqid_Base -- |
| CINSDSet | CINSDSet -- |
| CINSDSet_Base | INSDSeq provides the elements of a sequence as presented in the GenBank/EMBL/DDBJ-style flatfile formats, with a small amount of additional structure |
| CINSDStrucComment | CINSDStrucComment -- |
| CINSDStrucComment_Base | CINSDStrucComment_Base -- |
| CINSDStrucCommentItem | CINSDStrucCommentItem -- |
| CINSDStrucCommentItem_Base | CINSDStrucCommentItem_Base -- |
| CINSDXref | CINSDXref -- |
| CINSDXref_Base | INSDXref provides a method for referring to records in other databases |
| CInsertAnnotHookAnnot | |
| CInsertAnnotHookCopy | |
| CInsertAnnotHookId | |
| CInsertAnnotManager | |
| CInstall | CInstall -- |
| CInstallFrom | CInstallFrom -- |
| CInstallUrl | CInstallUrl -- |
| pythonpp::CInstance | |
| CInstance | |
| CInstancedAligner | |
| CInstInfoMap | |
| CInStringPred | |
| pythonpp::CInt | |
| CInt_fuzz | |
| CInt_fuzz_Base | Int-fuzz ********************************************** |
| CInt_graph | CInt_graph -- |
| CInt_graph_Base | CInt_graph_Base -- |
| CIntDataType | |
| python::CIntegrityError | |
| CIntensity | CIntensity -- |
| CIntensity_Base | Integrated mass intensity |
| CIntEnumDataType | |
| CInter_residue_bond | CInter_residue_bond -- |
| CInter_residue_bond_Base | Inter-residue bonds are defined by a reference to two atoms |
| CInteract_summary | CInteract_summary -- |
| CInteract_summary_Base | Combined datasets |
| python::CInterfaceError | |
| CInterfaceHook< I > | |
| CInterfaceObjectLocker< Interface > | |
| CInterfaceRegistry | |
| CInterfaceVersion< TClass > | CInterfaceVersion<> -- |
| CIntergenic | |
| CIntergenic_params | CIntergenic_params -- |
| CIntergenic_params_Base | CIntergenic_params_Base -- |
| CIntergenicParameters | |
| python::CInternalError | |
| CInternalExon | |
| CInternalRWLock | |
| CInterProcessLock | CInterProcessLock -- |
| CInterProcessLockException | CInterProcessLockException -- |
| CIntersectionGiList | GI list containing the intersection of two other lists of GIs |
| CIntervalTree | |
| CIntervalTreeConstIteratorTraits< Traits > | |
| CIntervalTreeIterator< Traits > | |
| CIntervalTreeIteratorTraits< Traits > | |
| CIntervalTreeTraits | |
| CIntra_residue_bond | CIntra_residue_bond -- |
| CIntra_residue_bond_Base | Intra-residue-bond specifies connectivity between atoms in Residue-graph |
| CIntron | |
| CIntron_params | CIntron_params -- |
| CIntron_params_Base | CIntron_params_Base -- |
| CIntronless | |
| CIntronlessNew | |
| CIntronlessOld | |
| CIntronParameters | |
| CIntValueHolder | |
| CInvalidChoiceSelection | Thrown on an attempt to access wrong choice variant |
| CInvalidConversionException | |
| CInvalidDataException | Defines invalid user input exceptions |
| CInvalidDrvVer< TClass > | |
| CInvalidIdList | CInvalidIdList -- |
| CInvalidParamException | |
| CInversionMergeAligner | |
| CIO_Exception | IO exception |
| pythonpp::CIOError | |
| CIOException | |
| CIRByteSourceReader | Class adapter from IReader to CByteSourceReader |
| CIRef< Interface, Locker > | |
| CIsAlnum | |
| CIsBadCRefPCRSubSource | |
| CIsGraph | |
| CIsLowercase | |
| CIsNotAlnum | |
| CIsNotSpace | |
| CIsotopic_contributions | CIsotopic_contributions -- |
| CIsotopic_contributions_Base | Isotopic contributions from one channel to others |
| CIsotropic_temperature_factors | CIsotropic_temperature_factors -- |
| CIsotropic_temperature_factors_Base | CIsotropic_temperature_factors_Base -- |
| CIsSpace | |
| CLDS_IStreamCache::CIStream | |
| CIStreamBuffer | |
| CIStreamClassMemberIterator | Reading (iterating through) members of the class (SET, SEQUENCE) |
| CIStreamContainerIterator | Reading (iterating through) elements of containers (SET OF, SEQUENCE OF) |
| CIStreamFrame | |
| CWinMaskConfig::CIstreamProxy | |
| CItem | CItem -- |
| CDiagConsoleCache::CItem | |
| CItem_Base | |
| CItemDefinitionGroup | CItemDefinitionGroup -- |
| CItemDefinitionGroup_Base | ======================================================================================= |
| CItemGroup | CItemGroup -- |
| CItemGroup_Base | ======================================================================================= Groups item list definitions |
| CItemInfo | |
| CItemSelectionPanel | CItemSelectionPanel |
| CItemsInfo | |
| CIteration | CIteration -- |
| CIteration_Base | CIteration_Base -- |
| CClassTypeInfoBase::CIterator | |
| CContainerTypeInfo::CIterator | |
| CItemsInfo::CIterator | |
| CSymDustMasker::CIupac2Ncbi2na_converter | |
| CIUPACaa | CIUPACaa -- |
| CIUPACaa_Base | IUPAC 1 letter codes, no spaces |
| CIupacaaToStdaa | |
| CIUPACna | CIUPACna -- |
| CIUPACna_Base | IUPAC 1 letter codes, no spaces |
| CIupacnaAmbig | |
| oligofar::CIupacnaBase | |
| CIupacnaCmp | |
| CIupacnaTo2na | |
| CIupacnaTo2naExpand | |
| CIupacnaTo4na | |
| CIupacnaTo8na | |
| CIupacnaToIupacna | |
| CJob | |
| CJobCancelable | Base class to build jobs with cancel functionality |
| CJobEvent | |
| CJobGCRegistry | |
| CJobQueueCleanerThread | Thread class, removes obsolete job records |
| CJobQueueExecutionWatcherThread | Thread class, watches job execution, reschedules forgotten jobs |
| CSchedulerEngine::CJobRecord | Record that holds infromation about a job |
| CJobResultBase | CJobResultBase -- the basic job result class holding a token |
| CJobResultsDlg | |
| CJobStatusTracker | In-Memory storage to track status of all jobs Syncronized thread safe class |
| CBDB_MergeBlobWalkerAsync< BF >::CJobThread | Background thread class (executes async requests) |
| CBDB_MergeStoreAsync< BStore >::CJobThread | Background thread class (executes async requests) |
| CJobUpdate | |
| CJournalPanel | |
| CJsonNode | |
| CJsonOverUTTPReader | |
| CJsonOverUTTPWriter | |
| pythonpp::CKeyboardInterrupt | |
| pythonpp::CKeyError | |
| CNCBlobStorage::CKeysCleaner | |
| CKeyword | CKeyword -- |
| CKeywordsItem | |
| CKmerCountsException | Exception class for Kmer counts |
| CLabel | |
| CLabelDescriptionCache | Class to control runtime cache for description labels label generation can be slow if we need to retrieve molecules, this class controls session only runtime cache for the labels |
| CLabelDescriptionCacheImpl | |
| CPhyTreeNodeGroupper::CLabeledNode | |
| CLadder | |
| CLadderContainer | |
| CLangQueryApp | |
| CLangVersion | CLangVersion -- |
| CLargestIntronSizeArgs | Argument class for collecting the largest intron size |
| CLastExon | |
| CLatLonCountryId | |
| CLatLonCountryMap | |
| CLayeredLayout | CLayeredLayout is a standard 2D layout policy |
| CLayout | Class CLayout is a container of objects laid out in a series of rows or tracks |
| CLayoutAlign | |
| CLayoutAlignSmear | |
| CLayoutComment | |
| CLayoutEngine | Class CLayoutEngine defines the abstract interface for a given alyout algorithm |
| CLayoutFeat | |
| CLayoutFeatLabel | |
| CLayoutFeatPack | |
| CLayoutGraph | |
| CLayoutGroup | CLayoutGroup is a container of CSeqGlyphs (layout objects) |
| CLayoutHistogram | |
| CLayoutMatePair | |
| CLayoutObject | Class CLayoutObject defines an interface that wraps a rectilinear abstract object |
| CLayoutPWAlign | |
| CLayoutSeqMap | |
| CLayoutSequence | |
| CLayoutSwitchPoints | |
| CLayoutTrack | File Description: |
| CLayoutTrackHandler | CLayoutTrackHandler - is the handler for handling the user interactions on layout tracks |
| CLayoutVisRange | |
| CLDBlockDS | |
| CLDBlockDSType | |
| CLDBlockGlyph | |
| CLDBlockJob | CLDBlockJob |
| CLDBlockLine | |
| CLDBlockTrack | |
| CLDBlockTrackFactory | |
| CLDFilterDialog | |
| CLDFilterParams | |
| CLDS2_Annot_Hook | |
| CLDS2_AnnotType_Hook | |
| CLDS2_BioseqIds_Hook | |
| CLDS2_BioseqSet_Hook | |
| CLDS2_Database | |
| CLDS2_DataLoader | |
| CLDS2_DataLoaderCF | |
| CLDS2_Exception | |
| CLDS2_DataLoader::CLDS2_LoaderMaker | |
| CLDS2_Manager | Class for managing LDS2 database and related data files |
| CLDS2_ObjectParser | |
| CLDS2_Seq_id_Hook | |
| CLDS2_SeqEntry_Hook | |
| CLDS2_UrlHandler_Base | Base class for URL handler |
| CLDS2_UrlHandler_File | Default handler for local files - registered automatically by LDS2 manager and data loader |
| CLDS2_UrlHandler_GZipFile | Handler for GZip local files. Not registered by default |
| CLDS2IndexerApplication | |
| CLDS_BuildIdIdx | Scanner functor to build id index |
| CLDS_CollectSeq_idsReader | |
| CLDS_CoreObjectsReader | |
| CLDS_Database | LDS database |
| CLDS_DatabaseHolder | LDS database incapsulated into CObject compatible container |
| CLDS_DataLoader | |
| CLDS_DataLoaderCF | |
| CLDS_Exception | |
| CLDS_FastaScanner | |
| CLDS_File | SLDS_FileDB related methods |
| CLDS_FindSeqIdBase | Base class for sequence search functors |
| CLDS_FindSeqIdFunc | Objects scanner |
| CLDS_FindSeqIdFunctor | Functor used for scanning the Berkeley DB database |
| CLDS_FindSeqIdListFunctor | Functor used for scanning the SLDS_SeqId_List database |
| CLDS_GBReleaseReadHook | |
| CLDS_IdTableScanner | Query scanner functor for objects |
| CLDS_IStreamCache | |
| CLDS_DataLoader::CLDS_LoaderMaker | |
| CLDS_Manager | |
| CLDS_Object | SLDS_ObjectDB and SLDS_AnnotDB related methods |
| CLDS_Query | CLDS_Query different queries to the LDS database |
| CLDS_Seq_ids | |
| CLDS_Seq_idsCollector | |
| CLDS_SkipObjectHook | |
| CLDSIndexerApplication | |
| CLeafTypeConstIterator< C > | Template class for iteration on objects of class C (non-medifiable version) |
| CLeafTypeIterator< C > | Template class for iteration on objects of class C |
| CLeafTypeIteratorBase< Parent > | Template base class for CTypeIterator<> and CTypeConstIterator<> Do not use it directly |
| CLegend | Class CLegend |
| CLegendDataSource | Class CLegendDataSource |
| CLegendHandler | Class CLegendHandler represents in GUI a informational popup with color legend |
| CLength_distribution_params | CLength_distribution_params -- |
| CLength_distribution_params_Base | CLength_distribution_params_Base -- |
| CLessThanNoCaseViaUpper | |
| CLessTypeInfo | |
| CLevelGuard | |
| CLevelSort | |
| CLIB | CLIB -- |
| CLib | CLib -- |
| CLibra_result | CLibra_result -- |
| CLibra_result_Base | Libra quantitation for search hit |
| CLibra_summary | CLibra_summary -- |
| CLibra_summary_Base | Summary info for libra quantitation analysis |
| CLibrarianToolDummyImpl | CLibrarianToolDummyImpl -- |
| CLibrarianToolImpl | CLibrarianToolImpl -- |
| CLightString | |
| CLinearSelHandler | Class CLinearSelHandler represents in GUI a one-dimnesional multi-segment selection |
| CLineError | |
| CGeneFileWriter::CLineProcessor | Line processor base class |
| CLink | CLink -- |
| CLink_Base | Cmd=neighbor |
| CLink_set | CLink_set -- |
| CLink_set_Base | Links between same class = neighbors links between other classes = links |
| CLinkage_evidence | |
| CLinkage_evidence_Base | CLinkage_evidence_Base -- |
| CLinkedFeatsGroup | CLinkedFeatsGroup is a container class contains related features |
| CLinkedFeature | |
| CLinkedMultiset< Mapped > | |
| CLinkedMultisetBase< Key > | |
| CLinkerToolDummyImpl | CLinkerToolDummyImpl -- |
| CLinkerToolImpl< ConfTrait > | CLinkerToolImpl -- |
| CLinkIncremental | CLinkIncremental -- |
| CLinkInfo | CLinkInfo -- |
| CLinkInfo_Base | CLinkInfo_Base -- |
| CLinkList | CLinkList -- |
| CLinkList_Base | CLinkList_Base -- |
| CLinkReduce< TBV, TMapFunc1, TMapFunc2 > | Implementation of Many-to-One mapping with source set reduction |
| CLinks | Set of edges with weights between nodes represented by zero-based positive integers |
| CLinkSet | CLinkSet -- |
| CLinkSet_Base | Common |
| CLinkSetDb | CLinkSetDb -- |
| CLinkSetDb_Base | CLinkSetDb_Base -- |
| CLinkSetDbHistory | CLinkSetDbHistory -- |
| CLinksException | Exceptions for CLinks class |
| pythonpp::CList | |
| CListeningSocket | CListeningSocket:: |
| CListTypeStrings | |
| CLoaderDescriptor | CLoaderDescriptor -- |
| CLoaderDescriptor_Base | CLoaderDescriptor_Base -- |
| CLoaderException | Data loader exceptions, used by GenBank loader |
| CLoaderMaker_Base | |
| CLoadInfo | |
| CLoadInfoBlob_ids | |
| CLoadInfoLock | |
| CLoadInfoMap< Key, Info > | |
| CLoadInfoSeq_ids | |
| CLoadLock_Base | |
| CLoadLockBlob | |
| CLoadLockBlob_ids | |
| CLoadLockSeq_ids | |
| CTSE_Info::CLoadMutex | |
| CLoadOptionPanel | |
| CLocalBlast | Class to perform a BLAST search on local BLAST databases Note that PHI-BLAST can be run using this class also, one only need to configure it as a regular blastp or blastn search and set the pattern in the CBlastOptionsHandle object |
| CLocalBlastDbAdapter | This class allows retrieval of sequence data from locally installed BLAST databases via CSeqDB |
| CLocalDbAdapter | Interface to create a BlastSeqSrc suitable for use in CORE BLAST from a a variety of BLAST database/subject representations |
| CLocalePanel | |
| CLocalFinderApp | |
| CLocalHookSet< Hook > | |
| CLocalHookSetBase | |
| CLocalIdComment | |
| CLocalPssmSearch | |
| CLocalRange< Position > | Sufficient extra functionality is needed from CRange that it justifies extending the class |
| CLocalRPSBlast | |
| CLocalSearchFactory | Factory for CLocalSearch |
| CLocalSeqSearch | Local sequence search |
| CLocaseCharPtrConverter | |
| CLocaseStringConverter | |
| CLocation_choice | CLocation_choice -- |
| CLocation_choice_Base | CLocation_choice_Base -- |
| CLocation_constraint | CLocation_constraint -- |
| CLocation_constraint_Base | CLocation_constraint_Base -- |
| CLocation_edit_type | CLocation_edit_type -- |
| CLocation_edit_type_Base | CLocation_edit_type_Base -- |
| CLocation_interval | CLocation_interval -- |
| CLocation_interval_Base | CLocation_interval_Base -- |
| CLocation_pos_constraint | CLocation_pos_constraint -- |
| CLocation_pos_constraint_Base | CLocation_pos_constraint_Base -- |
| CLocationListCtrl | |
| CLocationPanel | |
| CLockerTraits< C > | |
| CLocksMonitor | |
| CLockVector< BV > | Class implements bit-vector based lock storage registering millions of int numbered objects |
| CLockVectorGuard< TLockVect > | Lock guard for the CLockVector |
| CLocMapper_Default | |
| CLocObjects_SplitInfo | |
| CLocusItem | |
| CLog | |
| pythonpp::bind::CLong | |
| pythonpp::CLong | |
| pythonpp::CLookupError | |
| CLookupTableOptions | Wrapper class for LookupTableOptions |
| CLookupTableWrap | Wrapper class for LookupTableWrap |
| CLoopConstraint | CLoopConstraint -- |
| CLoopConstraint_Base | CLoopConstraint_Base -- |
| CLorentz | |
| ncbi::boost_fp_impl::close_at_tolerance< FPT > | |
| CLysC | |
| CLysCP | |
| CLysN | EMSEnzymes_lysn Cuts N term of lysine |
| CLZOBuffer | CLZOBuffer -- |
| CLZOCompression | CLZOCompression -- |
| CLZOCompressionFile | CLZOCompressionFile class -- |
| CLZOCompressor | CLZOCompressor -- LZO based compressor |
| CLZODecompressor | CLZODecompressor -- LZO based decompressor |
| CLZOStreamCompressor | CLZOStreamCompressor -- lzo based compression stream processor |
| CLZOStreamDecompressor | CLZOStreamDecompressor -- lzo based decompression stream processor |
| CMacOSX | |
| CMacro_action_choice | CMacro_action_choice -- |
| CMacro_action_choice_Base | CMacro_action_choice_Base -- |
| CMacro_action_list | CMacro_action_list -- |
| CMacro_action_list_Base | CMacro_action_list_Base -- |
| CMacroException | CAppJobException - Exception thrown by Job Dispatcher and Job Engines |
| CQueryMacro::CMacroFunction | Class describes macro function |
| CMacroTestProcess | |
| CMainFrame | CMainFrame Base class for Application Main Frame, derive your frames from this one |
| CMake_gene_xref_action | CMake_gene_xref_action -- |
| CMake_gene_xref_action_Base | CMake_gene_xref_action_Base -- |
| CMakeBlastDBApp | The main application class |
| CMakeCdrProds | |
| impl::CMakeConnActualParams | |
| CMakeDbPosMatrix | |
| value_slice::CMakeObject< CP, R, S > | |
| value_slice::CMakeObject< CP, deque< T >, CDB_Result > | |
| value_slice::CMakeObject< CP, R, CDB_Result > | |
| value_slice::CMakeObject< CP, set< T >, CDB_Result > | |
| value_slice::CMakeObject< CP, stack< T >, CDB_Result > | |
| value_slice::CMakeObject< CP, vector< T >, CDB_Result > | |
| value_slice::CMakeObject< SRunTimeCP, map< K, V >, CDB_Result > | |
| value_slice::CMakeObject< SRunTimeCP, pair< T1, T2 >, CDB_Result > | |
| value_slice::CMakeObject< SSafeCP, map< K, V >, CDB_Result > | |
| value_slice::CMakeObject< SSafeCP, pair< T1, T2 >, CDB_Result > | |
| CMakeProfileDBApp | |
| CMakeScoreMethodApp | |
| CManagedWrapperGeneratorToolDummyImpl | |
| CManifest | CManifest -- |
| CManipulatorIProxy< TInputStream, TOutputStream > | CManipulatorIProxy -- base class for manipulators using in operator>> |
| CManipulatorOProxy< TInputStream, TOutputStream > | CManipulatorOProxy -- base class for manipulators using in operator<< |
| CMap_ext | CMap_ext -- |
| CMap_ext_Base | CMap_ext_Base -- |
| CMapCompLen | |
| CMapControl | CMapControl owns all its items |
| CMapFileExtensions | CMapFileExtensions -- |
| CMapItem | CMapItem This is a base class for IwxMapItem implementations |
| CMapLoc | CMapLoc -- |
| CMapLoc_Base | Position of a single hit of a variation on a contig |
| oligofar::CMappedAlignment | |
| CMappedFeat | CMappedFeat -- |
| CMappedGraph | CMappedGraph -- |
| CDBConnectionFactory::CMapperFactory | |
| CMappingRange | CMappingRange - describles a single interval to interval mapping |
| CMappingRangeRef_Less | |
| CMappingRangeRef_LessRev | |
| CMappingRanges | Storage for multiple mapping ranges |
| CMaps | CMaps -- |
| CMaps_Base | CMaps_Base -- |
| CMapTypeStrings | |
| CMarkov_chain_array | CMarkov_chain_array -- |
| CMarkov_chain_array_Base | CMarkov_chain_array_Base -- |
| CMarkov_chain_params | CMarkov_chain_params -- |
| CMarkov_chain_params_Base | CMarkov_chain_params_Base -- |
| CMarkovChain< order > | |
| CMarkovChain< 0 > | |
| CMarkovChainArray< order > | |
| CMask | CMask -- |
| CMaskBDBReader | Class for reading sequences from BLAST databases |
| CMaskedRangeSet | |
| CMaskedRangesVector | This represents a set of masks for a given sequence |
| CMaskFastaReader | Class for reading sequences from fasta files |
| CMaskFileName | CMaskFileName -- |
| CMaskFromFasta | |
| CSubjectMap_Factory_Base::CMaskHelper | A helper class used when creating internal set masked locations in the process of converting the sequence data to NCBI2NA and storing it in seq_store_ |
| CMaskInfoRegistry | Registry class for the sequence masking/filtering algorithms used to create masks to be added to a CWriteDB object |
| CMaskReader | Virtual base class for all input readers |
| CMaskRegexp | CMaskRegexp -- |
| CMaskWriter | A base class for winmasker output writers |
| CMaskWriterBlastDbMaskInfo | Output filter to print masked sequence locations as Blast-db-mask-info objects |
| CMaskWriterFasta | Output filter to write masked data in fasta format |
| CMaskWriterInt | Output filter to print masked sequences as sets of intervals |
| CMaskWriterSeqLoc | Output filter to print masked sequence locations as NCBI Seq-loc objects |
| CMassArray | |
| CMassMaskCompare | |
| CMasterContext | |
| CMasterSeqSegments | |
| CMatchCDS | |
| CMatchmRNA | |
| CMatePairConfig | CMatePairConfig: the data structure holding alignment rendering parameters |
| CMatePairGlyph | |
| CMath | CMath -- |
| CMath_Base | CMath_Base -- |
| CMathResponse | CMathResponse -- |
| CMathResponse_Base | CMathResponse_Base -- |
| CMatrix | CMatrix -- |
| CMatrix3< T > | |
| CMatrix4< T > | |
| CMatrix_Base | Matrix definitions, these are supposed to store PSSMs and corresponding matrices of relative residue frequencies |
| CMatrixNameArg | Argument class to retrieve and set the scoring matrix name BLAST algorithm option |
| CMatrixScoringMethod | CMatrixScoringMethod |
| CMatrixScoringPanel | CMatrixScoringPanel |
| oligofar::CAligner::CMaxGapLengths | |
| CMbIndexArgs | Argument class to retrieve megablast database indexing options |
| CMC3_CodingRegion< order > | |
| CMC_NonCodingRegion< order > | |
| CMD5 | |
| CMDReturn< CMD > | |
| CMDReturn< CAttachAnnot_EditCommand< Annot > > | |
| CMDReturn< CAttachEntry_EditCommand< Entry > > | |
| CMDReturn< CDesc_EditCommand< TEditHandle, add > > | |
| CMDReturn< CId_EditCommand< add > > | |
| CMDReturn< CSeq_annot_Add_EditCommand< Handle > > | |
| CMDReturn< CSeq_entry_Select_EditCommand< Handle, Data > > | |
| CMedia | |
| CMedlars_entry | CMedlars_entry -- |
| CMedlars_entry_Base | MEDLARS entry |
| CMedlars_record | CMedlars_record -- |
| CMedlars_record_Base | CMedlars_record_Base -- |
| CMedline_entry | |
| CMedline_entry_Base | MEDLINE or PubMed entry regular medline record |
| CMedline_field | CMedline_field -- |
| CMedline_field_Base | CMedline_field_Base -- |
| CMedline_mesh | CMedline_mesh -- |
| CMedline_mesh_Base | CMedline_mesh_Base -- |
| CMedline_qual | CMedline_qual -- |
| CMedline_qual_Base | CMedline_qual_Base -- |
| CMedline_rn | CMedline_rn -- |
| CMedline_rn_Base | Medline substance records |
| CMedline_si | CMedline_si -- |
| CMedline_si_Base | Medline cross reference records |
| CMedlineUID | CMedlineUID -- |
| CMedlineUID_Base | Id from MEDLINE |
| CMeeting | CMeeting -- |
| CMeeting_Base | CMeeting_Base -- |
| CMemberId | |
| CMemberInfo | |
| CMemberInfoFunctions | |
| CMemeto< T > | |
| CMemoryByteSource | |
| CMemoryByteSourceReader | |
| CMemoryChunk | |
| pythonpp::CMemoryError | |
| CMemoryFile | CMemoryFile -- |
| CMemoryFile_Base | CMemoryFile_Base -- |
| CMemoryFileMap | CMemoryFileMap -- |
| CMemoryFileSegment | CMemoryFileSegment -- |
| CMemoryLineReader | Simple implementation of ILineReader for regions of memory (such as memory-mapped files) |
| CMemoryRegistry | CMemoryRegistry -- |
| CMemorySourceCollector | |
| CMemPot | |
| CMemStore | |
| CMenuItem | CMenuItem - represents a menu items in IMenu-style menus |
| CMenuService | CMenuService - standard implementation of IMenuService |
| CMerge_Exception | Base Merge algorithms exception class |
| CMergeAligner | |
| CMergeAlignmentsJob | CMergeAlignmentsJob |
| CMergeAlignmentsParamsPanel | CMergeAlignmentsParamsPanel |
| CMergeAlignmentsToolManager | CMergeAlignmentsToolManager |
| CMergeBitsetBlob< BV > | Implementation of merger interface for bitsets |
| CMergedPairwiseAln | |
| CMergeItemsJob | CMergeItemsJob |
| CMergePanel | |
| CMergeParams | |
| CMergeTool | CCleanupTool |
| CMergeVolumes | Main volume merge algorithm class |
| CMessageHistoryInfo | |
| CMessageHistoryInfo_Base | |
| CMessageSlot | |
| CMessageSlotPopupWindow | CMessageSlotPopupWindow |
| CMetaDataTest | |
| CMetaRegistry | |
| pythonpp::CMethod | |
| CMicroArrayReader | |
| CMidl | CMidl -- |
| CMIDLToolDummyImpl | |
| CMim_allelic_variant | CMim_allelic_variant -- |
| CMim_allelic_variant_Base | CMim_allelic_variant_Base -- |
| CMim_author | CMim_author -- |
| CMim_author_Base | CMim_author_Base -- |
| CMim_cit | CMim_cit -- |
| CMim_cit_Base | CMim_cit_Base -- |
| CMim_date | CMim_date -- |
| CMim_date_Base | CMim_date_Base -- |
| CMim_edit_item | CMim_edit_item -- |
| CMim_edit_item_Base | CMim_edit_item_Base -- |
| CMim_entries | CMim_entries -- |
| CMim_entries_Base | CMim_entries_Base -- |
| CMim_entry | CMim_entry -- |
| CMim_entry_Base | CMim_entry_Base -- |
| CMim_index_term | CMim_index_term -- |
| CMim_index_term_Base | CMim_index_term_Base -- |
| CMim_link | CMim_link -- |
| CMim_link_Base | CMim_link_Base -- |
| CMim_page | CMim_page -- |
| CMim_page_Base | CMim_page_Base -- |
| CMim_reference | CMim_reference -- |
| CMim_reference_Base | CMim_reference_Base -- |
| CMim_set | CMim_set -- |
| CMim_set_Base | CMim_set_Base -- |
| CMim_text | CMim_text -- |
| CMim_text_Base | CMim_text_Base -- |
| CMinimapHandler | CMinimapHandler provides support for mouse-driven zoom and pan operations |
| CMinimumRequiredVersion | CMinimumRequiredVersion -- |
| CMiniMutex | |
| CMinPanelContainer | CMinPanelContainer |
| CSRSearch::CMismatchResultsInfo | |
| CMixture_model | CMixture_model -- |
| CMixture_model_Base | CMixture_model_Base -- |
| CMixturemodel_distribution | CMixturemodel_distribution -- |
| CMixturemodel_distribution_Base | CMixturemodel_distribution_Base -- |
| CMkIndexApplication | Main application class |
| CMla_back | CMla_back -- |
| CMla_back_Base | CMla_back_Base -- |
| CMla_request | CMla_request -- |
| CMla_request_Base | Requests |
| CMLAClient | |
| CMLAClient_Base | CMLAClient_Base -- |
| CMMAligner | |
| CMmdb_id | CMmdb_id -- |
| CMmdb_id_Base | CMmdb_id_Base -- |
| CMod | Information for a post translational modification at a particular sequence site |
| CMod_aminoacid_mass | CMod_aminoacid_mass -- |
| CMod_aminoacid_mass_Base | CMod_aminoacid_mass_Base -- |
| CModel_coordinate_set | CModel_coordinate_set -- |
| CModel_coordinate_set_Base | Atomic coordinates may be assigned literally or by reference to another biostruc |
| CModel_coordinate_set_id | CModel_coordinate_set_id -- |
| CModel_coordinate_set_id_Base | CModel_coordinate_set_id_Base -- |
| CModel_descr | CModel_descr -- |
| CModel_descr_Base | CModel_descr_Base -- |
| CModel_id | CModel_id -- |
| CModel_id_Base | CModel_id_Base -- |
| CModel_space | CModel_space -- |
| CModel_space_Base | The model space defines measurement units and any external reference frame |
| CModel_space_point | CModel_space_point -- |
| CModel_space_point_Base | CModel_space_point_Base -- |
| CModel_space_points | CModel_space_points -- |
| CModel_space_points_Base | The atoms whose location is described by each coordinate are identified via a hierarchical pointer to the chemical graph of the biomolecular assembly |
| CModelCluster< Model > | |
| CModelClusterSet< Cluster > | |
| CModelCompare | |
| CModelEvidenceItem | CModelEvidenceItem -- |
| CModelEvidenceItem_Base | CModelEvidenceItem_Base -- |
| CModelEvidenceSupport | CModelEvidenceSupport -- |
| CModelEvidenceSupport_Base | CModelEvidenceSupport_Base -- |
| CModelExon | |
| CModelFilters | |
| CModification_info | CModification_info -- |
| CModification_info_Base | Positions and masses of modifications |
| pythonpp::CModule | |
| CModuleContainer | |
| pythonpp::CModuleExt | |
| CMolecule_graph | CMolecule_graph -- |
| CMolecule_graph_Base | A molecule chemical graph is defined by a sequence of residues |
| CMolecule_id | CMolecule_id -- |
| CMolecule_id_Base | CMolecule_id_Base -- |
| CMolecule_pntrs | CMolecule_pntrs -- |
| CMolecule_pntrs_Base | CMolecule_pntrs_Base -- |
| CMolInfo | |
| CMolInfo_Base | NOTE: mol-type, modif, method, and org are consolidated and expanded in Org-ref, BioSource, and MolInfo in this specification |
| CMolinfo_block | CMolinfo_block -- |
| CMolinfo_block_Base | CMolinfo_block_Base -- |
| CMolinfo_completedness_pair | CMolinfo_completedness_pair -- |
| CMolinfo_completedness_pair_Base | CMolinfo_completedness_pair_Base -- |
| CMolinfo_field | CMolinfo_field -- |
| CMolinfo_field_Base | CMolinfo_field_Base -- |
| CMolinfo_field_constraint | CMolinfo_field_constraint -- |
| CMolinfo_field_constraint_Base | CMolinfo_field_constraint_Base -- |
| CMolinfo_field_list | CMolinfo_field_list -- |
| CMolinfo_field_list_Base | CMolinfo_field_list_Base -- |
| CMolinfo_field_pair | CMolinfo_field_pair -- |
| CMolinfo_field_pair_Base | CMolinfo_field_pair_Base -- |
| CMolinfo_mol_class_pair | CMolinfo_mol_class_pair -- |
| CMolinfo_mol_class_pair_Base | CMolinfo_mol_class_pair_Base -- |
| CMolinfo_molecule_pair | CMolinfo_molecule_pair -- |
| CMolinfo_molecule_pair_Base | CMolinfo_molecule_pair_Base -- |
| CMolinfo_strand_pair | CMolinfo_strand_pair -- |
| CMolinfo_strand_pair_Base | CMolinfo_strand_pair_Base -- |
| CMolinfo_technique_pair | CMolinfo_technique_pair -- |
| CMolinfo_technique_pair_Base | CMolinfo_technique_pair_Base -- |
| CMolinfo_topology_pair | CMolinfo_topology_pair -- |
| CMolinfo_topology_pair_Base | CMolinfo_topology_pair_Base -- |
| CMolInfoPanel | |
| CMolTypeValidator | |
| CMoreTableColsDlg | |
| CMouseZoomHandler | CMouseZoomHandler provides support for mouse-driven zoom and pan operations |
| CMove | CMove -- |
| CMove_Base | CMove_Base -- |
| CMPCrossAlignView | CMPCrossAlignView |
| CMPCrossAlignViewFactory | CMPCrossAlignViewFactory |
| CmRNAAndCDSIndex | |
| CValidError_bioseq::CmRNACDSIndex | |
| CmRNASubPanel | |
| CMRUItemsProvider< T > | |
| CMRUItemsProvider< string > | |
| CMRUList< T > | CMRUList |
| CMSBasicMatchedPeak | Information about a matched peak |
| CMSBasicPeak | Minimal information about a peak |
| CMSBioseq | CMSBioseq -- |
| CMSBioseq_Base | Bioseq container |
| CMSBioseqSet | |
| CMSBioseqSet_Base | CMSBioseqSet_Base -- |
| CMSBuild | CMSBuild -- |
| CMSChargeHandle | CMSChargeHandle -- |
| CMSChargeHandle_Base | How to handle precursor charge |
| IStatusBarService::CMsgGuard | Message guard - helper class for resetting messages |
| CMsgHandlerGuard | |
| impl::CMsgHandlerGuard | |
| CMSHit | Class to contain preliminary hits |
| CMSHits | .hpp User-defined methods of the data storage class |
| CMSHits_Base | Hits to a given spectrum |
| CMSHitSet | CMSHitSet -- |
| CMSHitSet_Base | Set of hits to a single spectrum |
| CMSImmonium | CMSImmonium -- |
| CMSImmonium_Base | Type of immonium ion |
| CMSInFile | CMSInFile -- |
| CMSInFile_Base | CMSInFile_Base -- |
| CMSIon | CMSIon -- |
| CMSIon_Base | Ion type at a finer level than ion series |
| CMSIonAnnot | CMSIonAnnot -- |
| CMSIonAnnot_Base | Annotated comments about the ion |
| CMSIterativeSettings | CMSIterativeSettings -- |
| CMSIterativeSettings_Base | Iterative search settings |
| CMSLibrarySettings | CMSLibrarySettings -- |
| CMSLibrarySettings_Base | Library search settings |
| CMSMassSet | CMSMassSet -- |
| CMSMassSet_Base | Mass container |
| CMSMatchedPeak | Holds match of a spectrum peak to a theoretical m/z value |
| CMSMatchedPeakSet | Container for a set of matches |
| CMSMatchedPeakSetMap | Map of charge and series to a set of matches |
| CMSMod | |
| CMSModHit | CMSModHit -- |
| CMSModHit_Base | Modifications to a hit peptide |
| CMSModInfo | Class to hold mod information for a hit |
| CMSModSpec | CMSModSpec -- |
| CMSModSpec_Base | Modification Definition |
| CMSModSpecSet | .hpp User-defined methods of the data storage class |
| CMSModSpecSet_Base | Holds a set of modifications |
| CMsms_pipeline_analysis | CMsms_pipeline_analysis -- |
| CMsms_pipeline_analysis_Base | CMsms_pipeline_analysis_Base -- |
| CMsms_run_summary | CMsms_run_summary -- |
| CMsms_run_summary_Base | Search results for LC/MS/MS run |
| CMSMZHit | CMSMZHit -- |
| CMSMZHit_Base | Defines a particular ion |
| CMSOutFile | CMSOutFile -- |
| CMSOutFile_Base | CMSOutFile_Base -- |
| CMSPeak | Class to hold spectral data for filtering and statistical characterization |
| CMSPeakList | Class for holding a set of peaks |
| CMSPeakSet | |
| CMSPepHit | CMSPepHit -- |
| CMSPepHit_Base | Information about sequences with identical peptide sequences |
| CMSRequest | |
| CMSRequest_Base | The search request that is given to the OMSSA algorithm |
| CMSResponse | |
| CMSResponse_Base | Search results |
| CMSScoreSet | CMSScoreSet -- |
| CMSScoreSet_Base | Sets of scores |
| CMSSearch | |
| CMSSearch_Base | Holds both search requests and responses |
| CMSSearchSettings | .hpp User-defined methods of the data storage class |
| CMSSearchSettings_Base | Generic search settings |
| CMSSearchSettingsSet | CMSSearchSettingsSet -- |
| CMSSearchSettingsSet_Base | CMSSearchSettingsSet_Base -- |
| CMSSpectrum | CMSSpectrum -- |
| CMSSpectrum_Base | Holds a single spectrum |
| CMSSpectrumMatch | Container for match between a spectrum and a mass ladder |
| CMSSpectrumset | CMSSpectrumset -- |
| CMSSpectrumset_Base | Holds a set of spectra |
| CMsvc7RegSettings | CMsvc7RegSettings -- |
| CMsvcCombinedProjectMakefile | Combining of rules and project makefile |
| CMsvcConfigure | Configurator for msvc projects: |
| CMsvcMetaMakefile | CMsvcMetaMakefile -- |
| CMsvcPrjFilesCollector | |
| CMsvcPrjGeneralContext | CMsvcPrjGeneralContext -- |
| CMsvcPrjProjectContext | CMsvcPrjProjectContext -- |
| CMsvcProjectMakefile | CMsvcProjectMakefile -- |
| CMsvcProjectRuleMakefile | Abstraction of rule for generation of project settings based on component usage |
| CMsvcSite | CMsvcSite -- |
| CMsvcTools | CMsvcTools -- |
| CMt | CMt -- |
| CMTArgs | Argument class to collect multi-threaded arguments |
| CMultEditCommand | |
| CMultiAligner | Simultaneously align multiple protein sequences |
| CMultiAlignerException | |
| CMultiAlignerFixture | Fixture class initialized for each multialigner test |
| CMultiAlignerOptions | Options and parameters for multiple alignement |
| CMultiAlignerTest | Test class for accessing CMultiAligner private attributes and methods |
| CMultiAlignerVersion | Keeps track of CMultiAligner version |
| CMultiAlignView | CMultiAlignView |
| CMultiAlignViewFactory | CMultiAlignViewFactory |
| CMultiAlnPrinter | Printer for popular multiple alignmnet formats |
| CMultiApplication | |
| CMultiCommandApplication | |
| CMultiDictionary | Class CMultiDictionary permits the creation of a linked, prioritized set of dictionaries |
| CMultiFileInput | CMultiFileInput |
| CMultiOrgName | CMultiOrgName -- |
| CMultiOrgName_Base | First will be used to assign division |
| CMultiReaderApp | |
| CMultiSeqInfo | Contains information about all sequences in a set |
| CMultisourceException | CMultisourceException |
| CMultiWriter | IWriter which can write simultaneously to the different streams |
| CMuscleTool | CMuscleTool |
| CMuscleToolJob | CMuscleToolJob |
| CMuscleToolPanel | |
| CMuscleToolParams | |
| CMutableAtomicCounter | CMutableAtomicCounter -- |
| CMutex | CMutex -- |
| CMutexException | CMutexException -- |
| CMyClass | CMyClass |
| CMySQL_Connection | |
| CMySQL_LangCmd | |
| CMySQL_RowResult | |
| CMySQLContext | |
| CMytestApplication | |
| CMyType | CMyType -- |
| CMZI | Class for holding an m/z value, intensity, and rank |
| CMZICompare | |
| CMZICompareHigh | |
| CMZICompareIntensity | |
| Cn3DApp | |
| Cn3DGLCanvas | |
| Cn3DNoWin | |
| CName_std | .hpp User-defined methods of the data storage class |
| CName_std_Base | Structured names |
| CNamedDataValue | |
| CNamedPipe | CNamedPipe -- |
| CNamedPipeClient | CNamedPipeClient -- |
| CNamedPipeServer | CNamedPipeServer -- |
| pythonpp::CNameError | |
| CNameGetter< Value > | Get name attribute for Value object |
| CNamespace | |
| CNamespaceInfoItem | |
| CNameValue | CNameValue -- |
| CNameValue_Base | Generic holder for experimental info |
| CNanoTimeout | CNanoTimeout -- Timeout interval, using nanoseconds |
| CNativeReference | CNativeReference -- |
| CNCActiveClientHub | |
| CNCActiveHandler | |
| CNCActiveHandler_Proxy | |
| CNCActiveSyncControl | |
| CNCBGThread< Functor > | Thread running background task |
| CNCBI2na | CNCBI2na -- |
| CNCBI2na_Base | 00=A, 01=C, 10=G, 11=T |
| oligofar::CNcbi2naBase | |
| CNcbi2naRandomizer | CNcbi2naRandomizer -- |
| CNCBI4na | CNCBI4na -- |
| CNCBI4na_Base | 1 bit each for agct 0001=A, 0010=C, 0100=G, 1000=T/U 0101=Purine, 1010=Pyrimidine, etc |
| CNcbi4naAmbig | |
| oligofar::CNcbi4naBase | |
| CNCBI8aa | CNCBI8aa -- |
| CNCBI8aa_Base | For modified amino acids |
| CNCBI8na | CNCBI8na -- |
| CNCBI8na_Base | For modified nucleic acids |
| CNcbi8naAmbig | |
| oligofar::CNcbi8naBase | |
| CNcbi8naPrinter | |
| oligofar::CNcbi8naScore< TCvtQry, TCvtSubj > | |
| CNcbi_mime_asn1 | |
| CNcbi_mime_asn1_Base | CNcbi_mime_asn1_Base -- |
| CNCBI_Sample_ASN_Type | CNCBI_Sample_ASN_Type -- |
| CNCBI_Sample_ASN_Type_Base | Some simple type |
| CNcbiApplication | CNcbiApplication -- |
| CNcbiApplogApp | |
| CNcbiArguments | CNcbiArguments -- |
| CNcbiBoostLogger | Logger for embedding in Boost framework and adding non-standard information to logging given by Boost |
| CNcbiBoostReporter | Reporter for embedding in Boost framework and adding non-standard information to detailed report given by Boost |
| CNcbiCommand | |
| CNcbiDiag | CNcbiDiag -- |
| CNCBIeaa | CNCBIeaa -- |
| CNCBIeaa_Base | ASCII extended 1 letter aa codes IUPAC codes + U=selenocysteine |
| CNcbiEmptyString | Empty "C++" string |
| CNcbiEnvironment | CNcbiEnvironment -- |
| CNcbiEnvRegMapper | CNcbiEnvRegMapper -- |
| CNcbiMatrix< T > | |
| CNCBINode | |
| CNcbiOstrstreamToString | |
| CNCBIpaa | CNCBIpaa -- |
| CNCBIpaa_Base | 25 octets/aa, prob for IUPAC aas in order: A-Y,B,Z,X,(ter),anything probabilities are coded 0-255 = 0.0-1.0 |
| CNCBIpna | CNCBIpna -- |
| CNCBIpna_Base | 5 octets/base, prob for a,c,g,t,n probabilities are coded 0-255 = 0.0-1.0 |
| oligofar::CNcbipnaBase | |
| CNcbipnaPrinter | |
| oligofar::CNcbipnaScore< TCvtQry, TCvtSubj > | |
| oligofar::CNcbiqnaBase | |
| CNcbiqnaPrinter | |
| oligofar::CNcbiqnaScore< TCvtQry, TCvtSubj > | |
| CNcbiRegistry | CNcbiRegistry -- |
| CNcbiRelocateCommand | |
| CNcbiResource | |
| CNcbiResourceInfo | Class for storing encrypted resource information |
| CNcbiResourceInfoException | Exception thrown by resource info classes |
| CNcbiResourceInfoFile | Class for handling resource info files |
| CNcbiResPresentation | |
| CNCBIstdaa | CNCBIstdaa -- |
| CNCBIstdaa_Base | Codes 0-25, 1 per byte |
| CNcbiTable< TValue, TRow, TColumn > | Template class to create a table with custom row-column access |
| CNcbiTable_Exception | |
| CNcbiTestApplication | Application for all unit tests |
| CNcbiTestParamTestCaseGenerator< ParamType, ParamIter > | Special generator of test cases for function accepting one parameter |
| CNcbiTestsCollector | Class that can walk through all tree of tests and register them inside CNcbiTestApplication |
| CNcbiTestsObserver | Special observer to embed in Boost.Test framework to initialize test dependencies before they started execution |
| CNcbiTestsTreeBuilder | Class for traversing all Boost tests tree and building tree structure in our own accessible manner |
| CNcbiTestTreeElement | Element of tests tree |
| CNCBitMask< num_bits > | Class for working with bit masks containing given number of bits |
| CNCBitMaskBase< num_elems > | Base class for bit masks of any size |
| CNCBitMaskBase< 1 > | Optimized specialization of bit mask that fits entirely in 1 element of type TNCBitMaskElem |
| CNCBitMaskBase< 2 > | Optimized specialization of bit mask that fits entirely in 2 elements of type TNCBitMaskElem |
| CNcbiToolkit | |
| ncbi::CNcbiToolkit_LogMessage | Logging message |
| CNcbiToolkitImpl_Application | |
| CNcbiToolkitImpl_DiagHandler | |
| CNcbiToolkitImpl_LogMessage | |
| CNCBIwxApplication | CNCBIwxApplication - a base class for NCBI GUI applications using wxWidgets |
| CNCBlobAccessor | Object holding lock on NetCache blob |
| CNCBlobBuffer | |
| CNCBlobStorage | Blob storage for NetCache |
| CNCBlobVerManager | |
| CNCDBIndexFile | Connection to index database in NetCache storage |
| CNCDeferredDeleter< ElemType, FinalDeleter, DeleteDelay, ElemsPerStorage > | |
| CNCDistributionConf | |
| CNCLongOpGuard | |
| CNCLongOpNotification | |
| CNCLongOpTrigger | |
| CNCMemManager | Utility class for tuning memory usage in NetCache including database cache and all other memory allocations |
| CNCMessageHandler | Handler of all NetCache incoming requests |
| CNCMethodWrap< Executor > | Special wrapper for object's method that can be used as functor, e.g |
| CNCMMBigBlockSet | Special "set of equally-sized blocks" containing only one block which size is equal to size of memory chunk (a bit less actually) or more (several chunks combined) |
| CNCMMBigBlockSlab | Special memory slab representing blocks bigger than kNCMMSlabSize (or actually kNCMMMaxCombinedSize) |
| CNCMMBlocksSet | Set of equally-sized blocks with size less than size of the chunk (when subtracted size of meta-data of the set |
| CNCMMBlocksSetBase | Base class for set of equally-sized blocks |
| CNCMMCentral | Central part of memory manager - all interaction with it not related to database cache starts here |
| CNCMMChainsPool | Per-thread pool of free chains of chunks for speeding up their allocation and deallocation |
| CNCMMChainsPool_Getter | Helper class to make CNCMMChainsPool available different for each thread |
| CNCMMChunksPool | Per-thread pool of free chunks for speeding up allocation and deallocation of individual chunks |
| CNCMMChunksPool_Getter | Helper class to make CNCMMChunksPool available different for each thread |
| CNCMMFreeChunk | Representation of the free memory chunk, i.e |
| CNCMMFreeChunkBase | Base class for CNCMMFreeChunk |
| CNCMMMutex | |
| CNCMMReserve | Central storage of all memory chunks that are not used by anybody but cannot be released to the system because of necessity to combine them in slabs |
| CNCMMSizePool | Per-thread pool of equally-sized memory blocks |
| CNCMMSizePool_Getter | Helper class to make CNCMMSizePool available different for each thread |
| CNCMMSlab | Representation of the memory slab - big piece of memory containing several memory chunks |
| CNCMMSlabBase | Base class for memory slab containing all meta-information about it |
| CNCMMStats | Per-thread statistics of memory manager operations |
| CNCMMStats_Getter | Helper class to make CNCMMStats available different for each thread |
| CNCMsgHandler_Factory | Factory creating CNCMessageHandler objects |
| CNCMsgHandler_Proxy | Special proxy for NetCache handler to allow handlers pooling |
| CNCMsgHndlFactory_Proxy | Special proxy for handler factory |
| CNCPeerControl | |
| CNCPeriodicSync | |
| CNCRef< C, Locker > | |
| CncRNASubPanel | |
| CNCStat | Class collecting statistics about NetCache server |
| CNCStat_Getter | |
| CNCStatFigure< T > | Class representing one statistical value |
| CNCSyncLog | |
| CNCThrottler_Getter | |
| CNCTimeThrottler | |
| CNCTlsObject< Derived, ObjType > | Base class for the object specific for each thread |
| CAnnotObjectType_Less::CNearnessTester | |
| CNeedlemanWunschToolParams | |
| CNegativeIdList | |
| CNegmodel_distribution | CNegmodel_distribution -- |
| CNegmodel_distribution_Base | CNegmodel_distribution_Base -- |
| CNetBLAST_DMSearchForm | CTestSearchForm |
| CNetBLAST_DMSearchJob | CNetBLAST_DMSearchJob |
| CNetBLAST_DMSearchQuery | CNetBLAST_DMSearchQuery |
| CNetBLAST_DMSearchTool | CNetBLAST_DMSearchTool - a search tool for Data Mining Service that searches and explores Net BLAST Data Source |
| CNetBlastDMSearchFormPanel | |
| CNetBlastDSEvtHandler | CNetBlastDSEvtHandler - wxEvtHandler-derived adapter for Net BLAST data source |
| CNetBlastJobDescriptor | CNetBlastJobDescriptor |
| CNetBlastJobDescriptorLabelHandler | CNetBlastJobDescriptorLabelHandler |
| CNetBlastJobTableModel | |
| CNetBlastLoadDBListJob | |
| CNetBlastLoadingJob | CNetBlastLoadingJob - an application job for loading RIDs from NCBI Net BLAST server |
| CNetBLASTLoadOptionPanel | |
| CNetBlastMonitoringJob | |
| CNetBlastSubmittingJob | CNetBlastSubmittingJob |
| CNetBLASTUIDataSource | CNetBLASTUIDataSource |
| CNetBLASTUIDataSourceType | CNetBLASTUIDataSourceType |
| CNetBLASTUILoadManager | CNetBLASTUILoadManager |
| CNetCacheAdmin | |
| CNetCacheAPI | Client API for NetCache server |
| CNetCacheAPICF | |
| CNetCacheBlobFetchApp | NetCache BLOB/image fetch application |
| CNetCacheCheckApp | NetCache check application |
| CNetCacheControl | Netcache stop application |
| CNetCacheDApp | NetCache daemon application |
| CNetCacheException | NetCache internal exception |
| CNetCacheKey | Meaningful information encoded in the NetCache key |
| CNetCachePasswordGuard | |
| CNetCacheReader | |
| CNetCacheServer | Netcache server |
| CNetCacheServerListener | |
| CNetCacheWriter | |
| CNetComponentCounterLocker< S > | |
| CNetICacheCF | Class factory for NetCache implementation of ICache |
| CNetICacheClient | Client to NetCache server (implements ICache interface) |
| CNetICachePasswordGuard | |
| CNetICacheServerListener | |
| CNetSchedule_AccessList | List of hosts allowed |
| CNetScheduleAdmin | |
| CNetScheduleAPI | Client API for NCBI NetSchedule server |
| CNetScheduleAPICF | |
| CNetScheduleBackgroundHost | Host for background threads |
| CNetScheduleCheck | NetSchedule check application |
| CNetScheduleClientFactory | NetSchedule Client Factory interface |
| CNetScheduleConnectionFactory | CNetScheduleConnectionFactory:: |
| CNetScheduleControl | NetSchedule control application |
| CNetScheduleDApp | NetSchedule daemon application |
| CNetScheduleException | NetSchedule internal exception |
| CNetScheduleExceptionMap | Map from exception names to codes |
| CNetScheduleExecutor | Smart pointer to a part of the NetSchedule API that does job retrieval and processing on the worker node side |
| CNetScheduleHandler | ConnectionHandler for NetScheduler |
| CNetScheduleJob | Job description |
| CNetScheduleKey | Meaningful information encoded in the NetSchedule key |
| CNetScheduleKeyGenerator | |
| CNetScheduleNotificationHandler | |
| CNetScheduleRequestExecutor | Executor for long-standing requests |
| CNetScheduleServer | NetScheduler threaded server |
| CNetScheduleServerListener | |
| CNetScheduleSubmitter | Smart pointer to the job submission part of the NetSchedule API |
| CNetServer | |
| CNetServerConnection | |
| CNetServerInfo | |
| CNetServerMultilineCmdOutput | |
| CNetServerPool | |
| CNetService | |
| CNetServiceException | Net Service exception |
| CNetServiceIterator | |
| CNetServProtoParser< Extra > | |
| CNetServProtoParserBase | |
| CNetSrvConnException | Net Service exception |
| CNewCleanup_imp | |
| CNGAlignBLASTPanel | |
| CNgAligner | |
| CNGAlignJob | CNGAlignJob |
| CNGAlignPanel | |
| CNGAlignParams | |
| CNGAlignTool | CNGAlignTool |
| CNlmZipBtRdr | |
| CNlmZipReader | |
| CNmer_repeatsApplication | |
| CNmerIterator | Type used to iterate over the consecutive Nmer values of the query sequence |
| CNoConfig | CNoConfig -- |
| CNode | CNode -- |
| CDockLayoutTree::CNode | CNode - a node in layout tree corresponding to a window |
| CNode_annotation | CNode_annotation -- |
| CNode_annotation_Base | CNode_annotation_Base -- |
| CNode_Base | CNode_Base -- |
| CTraversalNode::CNodeCall | |
| CNodeFeature | CNodeFeature -- |
| CNodeFeature_Base | CNodeFeature_Base -- |
| CNodeFeatureSet | CNodeFeatureSet -- |
| CNodeFeatureSet_Base | CNodeFeatureSet_Base -- |
| CTraversalMerger::CNodeLabeler | |
| CNodeSet | CNodeSet -- |
| CNodeSet_Base | CNodeSet_Base -- |
| CNodesToBitset< TNode, TSet, TNodeList > | Utility to join to node lists according to a set of ids |
| CNoEnzyme | EMSEnzymes_no_enzyme search without enzyme (precursor mass only) |
| CNoLock | CNoLock is a simple no-op lock which does no real locking |
| CTraversalSpecFileParser::CNoMoreTokens | |
| CNonCodingRegion | |
| pythonpp::CNone | |
| CNone | CNone -- |
| CNonException | |
| CNormalize | CNormalize -- |
| CNormalize_Base | CNormalize_Base -- |
| CNormalizer | This class converts model units to the integers distribited in [0, m_IntRange] and vice versa |
| CNoStandardLibraries | CNoStandardLibraries -- |
| CNoStdLib | CNoStdLib -- |
| CNotAlnum | |
| CNotFoundException | |
| NStr::CNotImplemented< Type > | |
| pythonpp::CNotImplementedError | |
| python::CNotSupportedError | |
| CNoWarn | CNoWarn -- |
| CNPiece | |
| CNRCriteria | |
| CNRItem | |
| CNSAffinityRegistry | |
| CNSClient | |
| CNSClientFactoryException | |
| CNSClientId | |
| CNSClientsRegistry | |
| CNSeq | |
| CNSGroupsRegistry | |
| CNSInfoCollector | |
| CNSInfoRenderer | |
| CNSJobInfo | |
| CNSJobListRenderAction | |
| CNSNotificationList | |
| CNSProtoParserException | |
| CNSRemoteJobControlApp | |
| CNSSubmitRemoteJobApp | |
| CNSTransaction | |
| CNuclArgs | Defines values for match and mismatch in nucleotide comparisons as well as non-greedy extension |
| CNucProp | This class defines functions for calculating various properties of nucleotide sequences |
| CNullBoolFunctions | |
| CNullDataType | |
| CNullDataValue | |
| CNullFunctions | |
| CNullProcess | |
| CNullPssmInput | Mock object for the PSSM input data which returns NULLs for all its methods |
| CNullRegion | |
| CNullTypeInfo | |
| CNullTypeStrings | |
| CNullWriter | NULL stream writer for test serialization |
| CNum_cont | CNum_cont -- |
| CNum_cont_Base | Continuous display numbering system |
| CNum_enum | CNum_enum -- |
| CNum_enum_Base | Any tags to residues |
| CNum_real | CNum_real -- |
| CNum_real_Base | Mapping to floating point system |
| CNum_ref | CNum_ref -- |
| CNum_ref_Base | By reference to other sequences |
| CNumAdderCtx | |
| python::CNumber | |
| CNumbering | CNumbering -- |
| CNumbering_Base | Any display numbering system |
| CNumberOrBlankValidator | |
| CNumberValidator | |
| CAlnMap::CNumSegWithOffset | |
| CNWAligner | |
| CNWAlignerThread_Align | |
| CNWFormatter | |
| CObjClipboard | |
| CObjConvProfile | |
| pythonpp::bind::CObject< T > | |
| pythonpp::CObject | |
| CObject | CObject -- |
| CObject_id | |
| CObject_id_Base | Object-id can tag or name anything |
| CObjectConverter | |
| CObjectConverterBase< DstType, SrcType > | |
| CObjectCoords | |
| CObjectCounterLocker | |
| CObjectDestroyerGuard | Helper class for destruction of field 'first' in pair<> if exception is thrown while constructing 'second' |
| CObjectEx | CObjectEx -- |
| CObjectException | CObjectException -- |
| CObjectFor< T > | CObjectFor -- |
| CObjectGetTypeInfo | |
| CObjectHookGuard< T > | Helper class: installs hooks in constructor, and uninstalls in destructor |
| CObjectHookGuardBase | |
| CObjectIndex | |
| CObjectInfo | CObjectInfo -- |
| CObjectInfoCV | CObjectInfoCV -- |
| CObjectInfoEI | CObjectInfoEI -- |
| CObjectInfoMI | CObjectInfoMI -- |
| CObjectInterfaceFactory< T > | |
| CObjectIStream | CObjectIStream -- |
| CObjectIStreamAsn | CObjectIStreamAsn -- |
| CObjectIStreamAsnBinary | CObjectIStreamAsnBinary -- |
| CObjectIStreamHelper< ASNContainerClass > | |
| CObjectIStreamJson | CObjectIStreamJson -- |
| CObjectIStreamXml | CObjectIStreamXml -- |
| CObjectList | CObjectList Data structure representing a list of CObjects with associated Scopes and other optional attributes (strings and numbers) |
| CObjectList_Base | CObjectList_Base -- |
| CObjectListException | CObjectListException |
| CObjectListSelTM | |
| CObjectListTableModel | CObjectListTableModel |
| CObjectListWidget | CObjectListWidget - mediator widget |
| CObjectListWidgetSel | |
| CObjectManager | CObjectManager -- |
| CObjectManagerEngine | CAppJobDispatcher |
| CObjectManagerEngineAction | |
| CObjectManagerEngineListener | |
| CObjectMemoryPool | |
| CObjectMemoryPoolChunk | |
| CObjectOStream | CObjectOStream -- |
| CObjectOStreamAsn | CObjectOStreamAsn -- |
| CObjectOStreamAsnBinary | CObjectOStreamAsnBinary -- |
| CObjectOStreamJson | CObjectOStreamJson -- |
| CObjectOStreamXml | CObjectOStreamXml -- |
| CObjectPool< C > | |
| CObjectSelector | CObjectSelector -- |
| CObjectSelector_Base | CObjectSelector_Base -- |
| CObjectsSniffer | Serialized objects sniffer |
| CObjectStack | |
| CObjectStackFrame | |
| CObjectStoreProtectedBase | Protected base class for CSingletonObjectStore Holds a syncronization mutex |
| CObjectStreamCopier | CObjectStreamCopier -- |
| CObjectTextItem | |
| CObjectTextParams | |
| CObjectTypeInfo | CObjectTypeInfo -- |
| CObjectTypeInfoCV | CObjectTypeInfoCV -- |
| CObjectTypeInfoII | CObjectTypeInfoII -- |
| CObjectTypeInfoMI | CObjectTypeInfoMI -- |
| CObjectTypeInfoVI | CObjectTypeInfoVI -- |
| CObjectTypeIs< T > | |
| CObjectUrl | CObjectUrl -- |
| CObjectUrl_Base | CObjectUrl_Base -- |
| CObjectVector< T > | |
| CObjElement | |
| CObjExtractApp | |
| CObjFactory_New< TObjType > | Object factory for simple creation and deletion of the object |
| CObjFactory_NewMethod< TObjType, TMethodClass > | Object factory for creation implemented by method of some class and simple deletion |
| CObjFactory_NewParam< TObjType, TParamType > | Object factory for simple creation and deletion of the object with one parameter passed to object's constructor |
| CObjFingerprint | |
| impl::CDBHandlerStack::CUserHandlerWrapper::CObjGuard | CObjGuard is not the same as CRef |
| CObjMgr_LocalQueryData | Provides access (not ownership) to the C structures used to configure local BLAST search class implementations |
| CObjMgr_QueryFactory | NCBI C++ Object Manager dependant implementation of IQueryFactory |
| CObjMgr_RemoteQueryData | |
| CObjMgrException | Base class for all object manager exceptions |
| CObjMgrFree_LocalQueryData | |
| CObjMgrFree_RemoteQueryData | |
| CObjmgrUtilException | Exceptions for objmgr/util library |
| CObjPool< TObjType, TObjFactory > | General object pool |
| CObjPoolGuard< TObjPool > | Guard that can be used to automatically return object to the pool after leaving some scope |
| CObjReaderException | |
| CObjReaderLineException | |
| CObjReaderParseException | |
| CObjUrl | CObjUrl -- |
| CObjUrl_Base | CObjUrl_Base -- |
| CObjWriterException | |
| CObservable | CObservable - default implementation of IObservable, can be used as a base class (mix-in) |
| CObservableUpdateEvent | CObservableUpdateEvent |
| CObserverUpdate | CUpdate - update object holding information about changes in IObservable derive your classes from CUpdate to supply specific information |
| COctetStringDataType | |
| COctetStringTypeInfo | |
| CODBC_BCPInCmd | |
| CODBC_Connection | |
| CODBC_CursorCmd | |
| CODBC_CursorCmdBase | |
| CODBC_CursorCmdExpl | |
| CODBC_CursorResult | |
| CODBC_CursorResultExpl | |
| CODBC_LangCmd | |
| CODBC_ParamResult | |
| CODBC_Reporter | |
| CODBC_RowResult | |
| CODBC_RPCCmd | |
| CODBC_SendDataCmd | |
| CODBC_StatusResult | |
| CODBCContext | |
| CODBCContextRegistry | |
| CODBCString | |
| code | |
| COffDiagonalRangeArg | Argument class to retrieve and set the off-diagonal range used in 2-hit algorithm |
| COffsetData< iterator_t > | Type of objects maintaining the offset list data for all Nmers and the corresponding hash table |
| COffsetData_Base | Class representing index hash table and offset list database |
| COffsetData_Factory | A class responsible for creation and management of Nmer offset lists |
| COffsetList | Type representing an offset list corresponding to an Nmer |
| COffsetReadHook | |
| CSeqTextPane::COffsetStart | |
| COldAsnTypeInfo | |
| oligofar::COligoFarApp | |
| oligofar::COligofarCfg | |
| COligoSpecificityCheck | |
| CollisionEntry | Class CollisionEntry This is the class that is stored int the collision data structure - each entry in the collision data structure has one of these which stores the set of geometry that overlaps that (2d) spatial region |
| Colors | |
| ColumnAddress | |
| ColumnReader | |
| ColumnResidueProfile | |
| ColumnScorer | |
| ctlib::Command | |
| FileMessenger::CommandInfo | |
| CommandProcessor | |
| xml::node::comment | Helper struct for creating a xml::node of type_comment |
| CLocalHookSetBase::Compare | |
| compare_hit_redundant | Callback used to sort hits into canonical order |
| compare_hit_score | Callback used to sort hits in order of decreasing score |
| compare_hit_seq1_start | Callback used for sorting HSP lists |
| compare_hit_seq2_idx | Callback to sort a list of hits in order of increasing sequence 2 index |
| compare_hit_start | Callback used to sort hits in order of increasing sequence offset |
| CCddInputData::compare_hits_by_seqid_eval | Class used for sorting hits by subject seq-id and e-value |
| CCddInputData::compare_hitseg_range | Class used for sorting hit segments by range |
| tree< T, tree_node_allocator >::compare_nodes< StrictWeakOrdering > | |
| CCddInputData::compare_range | Class used for sorting ranges |
| CMultiAligner::compare_sseg_db_idx | |
| compare_tree_edge_descending | Callback for sorting tree edges in order of decreasing edge weight |
| CompareLabelX | |
| compile_data | |
| Compo_FrequencyData | The structure used to store frequency data; used only in matrix_frequency_data.c |
| CompoundColumnScorer | |
| CompressedLookupBackboneCell | Structure for hashtable of indexed query offsets |
| CompressedMixedOffsets | "alternative" structure of CompressedLookupBackboneCell storage |
| CompressedNeighborInfo | Structure containing information needed for adding neighboring words (specific to compressed lookup table) |
| CompressedOverflowCell | Cell in list for holding query offsets |
| COMSSA | |
| COmssa2pepxmlApplication | |
| COMSSABase | |
| COMSSAException | Generic exception class for omssa |
| COMSSAMerge | |
| COMSSASearch | |
| CondensedColumn | |
| CondensedColumnAligned | |
| CondensedColumnUnaligned | |
| COnError | COnError -- |
| COneSeqRange | |
| COneStage | |
| config_s | |
| COnlinePublicationPanel | |
| ctlib::Connection | |
| ConnectsParalogs | |
| ConnInfoDeleter2 | |
| ConnNetInfoDeleter | |
| ConsensusMaker | |
| ConservationColorer | |
| db_map_base< K, T >::const_iterator | |
| xml::attributes::const_iterator | Const Iterator class for accessing attribute pairs |
| xml::node::const_iterator | The xml::node::const_iterator provides a way to access children nodes similar to a standard C++ container |
| xml::node_set::const_iterator | The xml::node_set::const_iterator class is used to iterate over nodes in a node set |
| pythonpp::CSequnceHelper< T >::const_iterator | |
| CRegularGridGen::const_iterator | |
| SSeqIdRange::const_iterator | |
| CAttrRangeCollection< Attr, Position >::const_iterator | |
| CAttrRangeCollection< Attr, Position >::const_pos_iterator | |
| Threader::Contact | |
| conv_result | |
| convert_to_string_type | |
| CoordSet | |
| COpenDlg | COpenDlg |
| COpenDlgTask | COpenDlgTask - shows "Open" dialog |
| COpenGLException | |
| COpenGLPrintBuffer | |
| COpenRange< Position > | |
| COpenViewDlg | |
| COpenViewEventRecord | COpenViewEventRecord is en example of a specialized Event Record |
| COpenViewlDlgTask | |
| COpenViewManager | |
| COperand | COperand -- |
| COperand_Base | COperand_Base -- |
| python::COperationalError | |
| COptArg< T > | |
| COptArg< bool > | |
| COptArg< pair< T, T > > | |
| COptArg< string > | |
| COptArg< unsigned > | |
| COptArgList< List > | |
| COptArgSet< Set > | |
| COptChoice< T > | |
| COptFlag< T > | |
| COptFlags< T > | |
| COptGroup | |
| COptHelp | |
| COptimize | COptimize -- |
| oligofar::COligofarCfg::COption | |
| COption | |
| COptionCompare | COptionCompare -- |
| COptionDescription | |
| COptionExplicit | COptionExplicit -- |
| COptionInfer | COptionInfer -- |
| COptionStrict | COptionStrict -- |
| COptVersion | |
| bm::copy_to_array_functor< B > | Adaptor to copy 1 bits to array |
| bm::copy_to_array_functor_inc< B > | Adaptor to copy 1 bits to array with base increment |
| COrdinalFeatIdGenerator | Default implementation for a generator of identifiers, as integers, mashalled as CFeat_id objects |
| COrf | This class provides functions for finding all the ORFs of a specified minimum length in a DNA sequence |
| COrfSearchForm | |
| COrfSearchJob | COrfSearchJob |
| COrfSearchQuery | COrfSearchTool |
| COrfSearchTableModel | |
| COrfSearchTool | COrfSearchTool |
| COrg_ref | |
| COrg_ref_Base | Org-ref *********************************************** |
| COrganismListPanel | |
| COrgMod | .hpp User-defined methods of the data storage class |
| COrgMod_Base | COrgMod_Base -- |
| COrgModEquals | |
| COrgName | |
| COrgName_Base | COrgName_Base -- |
| COrgRefCache | |
| COriginItem | |
| pythonpp::COSError | |
| COStreamBuffer | |
| COStreamClassMember | Writing class members |
| COStreamContainer | Writing containers (SET OF, SEQUENCE OF) |
| COStreamFrame | |
| COStreamHelper | COStreamHelper |
| COStreamTextOStream | |
| COSVersion | COSVersion -- |
| COther_feature | COther_feature -- |
| COther_feature_Base | Other-feature allows for specifying location via reference to another Biostruc-feature and its location |
| COther_source | COther_source -- |
| COther_source_Base | COther_source_Base -- |
| bm::bvector< Alloc >::counted_enumerator | Constant input iterator designed to enumerate "ON" bits counted_enumerator keeps bitcount, ie number of ON bits starting from the position 0 in the bit string up to the currently enumerated bit |
| COutDir | COutDir -- |
| COutput | |
| oligofar::COutputFormatter | |
| COutputPath | COutputPath -- |
| COutputType | COutputType -- |
| pythonpp::COverflowError | |
| COverlapPairLess | |
| COverlapScorer | |
| COpenViewManager::COVMException | |
| CPackageInfo | |
| CPacked_seg | CPacked_seg -- |
| CPacked_seg_Base | For (multiway) global or partial alignments |
| CPacked_seqint | |
| CPacked_seqint_Base | CPacked_seqint_Base -- |
| CPacked_seqpnt | |
| CPacked_seqpnt_Base | CPacked_seqpnt_Base -- |
| CSeqConvert_imp::CPacker | |
| CPackString | |
| CPackStringChoiceHook | |
| CPackStringClassHook | |
| CPad | CPad -- |
| CPad_Base | CPad_Base -- |
| CPage | CPage -- |
| CPageBuffers | |
| CPageHandler | |
| CPageList | |
| CPager | |
| CPagerBox | |
| CPagerView | |
| CPagerViewButtons | |
| CPagerViewJavaLess | |
| CPageStat | CPageStat -- |
| CPairConverter< DstType, SrcType > | Implementation of converter for pair<> conversion |
| CPairNodeKeyGetter< TNode > | Default key getter for pair-node (id + value) |
| CPairSorter< TKey, TValue > | CPairSorter |
| CPairwise_CI | CPairwiseAln iterator. Iterates over aligned ranges and gaps |
| CPairwiseAln | A pairwise aln is a collection of ranges for a pair of rows |
| CPairwiseAlnApp | Types we use here: |
| CPaneContentConf | Class: CPaneContentConf configuration class for the graphics view, specifying what is displayed |
| CPanel | |
| CPanelGrid | |
| CPanelHandle | Panel helper class that allows mouse click and motion events to grab the control's parent class and move it around |
| CParam< TDescription > | CParam |
| CParamBase | CParamBase |
| CParameter | CParameter -- |
| CParameter_Base | CParameter_Base -- |
| CParameterGroup | CParameterGroup -- |
| CParameters | CParameters -- |
| CParameters_Base | CParameters_Base -- |
| CParamException | CParamException |
| python::CParamFmt | |
| CParamLoaderMaker< TDataLoader, TParam > | |
| CParamParser< TDescription > | CParamParser |
| CParamRecordset | CParamRecordset:: Parametrized recordset |
| CParamsPanel | |
| CParamStmt | CParamStmt:: Parametrized statement |
| CParse | |
| CParse_action | CParse_action -- |
| CParse_action_Base | CParse_action_Base -- |
| CParse_dest | CParse_dest -- |
| CParse_dest_Base | CParse_dest_Base -- |
| CParse_dst_org | CParse_dst_org -- |
| CParse_dst_org_Base | CParse_dst_org_Base -- |
| CParse_src | CParse_src -- |
| CParse_src_Base | CParse_src_Base -- |
| CParse_src_general_id | CParse_src_general_id -- |
| CParse_src_general_id_Base | For Parse-src-general-id tag, specify the db of the id from which you want to retrieve the tag |
| CParse_src_org | CParse_src_org -- |
| CParse_src_org_Base | CParse_src_org_Base -- |
| CParse_src_org_choice | CParse_src_org_choice -- |
| CParse_src_org_choice_Base | CParse_src_org_choice_Base -- |
| CTraversalSpecFileParser::CParseError | |
| CParseTemplException< TBase > | CParseTemplException -- |
| CPartial_3_set_action | CPartial_3_set_action -- |
| CPartial_3_set_action_Base | CPartial_3_set_action_Base -- |
| CPartial_5_set_action | CPartial_5_set_action -- |
| CPartial_5_set_action_Base | CPartial_5_set_action_Base -- |
| CPartial_both_set_action | CPartial_both_set_action -- |
| CPartial_both_set_action_Base | CPartial_both_set_action_Base -- |
| CPartialOrgName | CPartialOrgName -- |
| CPartialOrgName_Base | When we don't know the genus |
| CPassParam | |
| CPatent_priority | CPatent_priority -- |
| CPatent_priority_Base | CPatent_priority_Base -- |
| CPatent_seq_id | |
| CPatent_seq_id_Base | CPatent_seq_id_Base -- |
| CPatentPanel | |
| CPathHook | |
| CMultiAlignerOptions::CPattern | Representation of CDD pattern |
| CSeqSearch::CPatternInfo | Holds information associated with a pattern, such as the name of the restriction enzyme, location of cut site etc |
| CPatternRec | |
| CPatternStats | |
| CPBuffer | |
| CPC_AnnotatedXRef | CPC_AnnotatedXRef -- |
| CPC_AnnotatedXRef_Base | Annotated Cross-Reference (XRef) Information to allow the XRef to be qualified, as to its meaning or context |
| CPC_AssayContainer | CPC_AssayContainer -- |
| CPC_AssayContainer_Base | EXPORTS ; Container for multiple Assay Data Submissions |
| CPC_AssayData | CPC_AssayData -- |
| CPC_AssayData_Base | Assay Readouts/Results for a Tested Substance |
| CPC_AssayDescription | CPC_AssayDescription -- |
| CPC_AssayDescription_Base | Assay Description provided by an Organization that describes the assay/protocol performed and defines the measured end-points and parameters to be stored |
| CPC_AssayDRAttr | CPC_AssayDRAttr -- |
| CPC_AssayDRAttr_Base | Assay Dose-response attribute information used to define a set of readouts as being part of a dose-response curve (for curve plotting/analysis) |
| CPC_AssayPanel | CPC_AssayPanel -- |
| CPC_AssayPanel_Base | Description for Panel Assay Describe general information about the panel, and link to information for each panel member |
| CPC_AssayPanelMember | CPC_AssayPanelMember -- |
| CPC_AssayPanelMember_Base | Specific information about each panel member(or component), such as target, cell line name, cross-reference .. |
| CPC_AssayPanelTestResult | CPC_AssayPanelTestResult -- |
| CPC_AssayPanelTestResult_Base | CPC_AssayPanelTestResult_Base -- |
| CPC_AssayResults | CPC_AssayResults -- |
| CPC_AssayResults_Base | Container for multiple Assay Result Sets PC-AssayResultsSet ::= SEQUENCE OF PC-AssayResults Assay Results provided for a given Substance tested, with respect to the results types defined in the referenced Assay Description |
| CPC_AssaySubmit | CPC_AssaySubmit -- |
| CPC_AssaySubmit_Base | Container for Data Depositions and Assay Definitions |
| CPC_AssayTargetInfo | CPC_AssayTargetInfo -- |
| CPC_AssayTargetInfo_Base | Molecular target information provides by organization describes the functionality of the target, facilitates the linking between PubChem bioassays, and the linking between target molecule to other NCBI resources |
| CPC_AtomInt | CPC_AtomInt -- |
| CPC_AtomInt_Base | Specification of an Association between an Atom Identifier and an Integer Value |
| CPC_AtomRadical | CPC_AtomRadical -- |
| CPC_AtomRadical_Base | Rudimentary Atom Electronic Configuration Designation |
| CPC_Atoms | CPC_Atoms -- |
| CPC_Atoms_Base | Atom Information (in Parallel Arrays) |
| CPC_AtomSource | CPC_AtomSource -- |
| CPC_AtomSource_Base | Specification of an Association between an Atom Identifier and Source |
| CPC_AtomString | CPC_AtomString -- |
| CPC_AtomString_Base | Specification of an Association between an Atom Identifier and a String Value |
| CPC_Bonds | CPC_Bonds -- |
| CPC_Bonds_Base | Bond Description Information (in Parallel Arrays) |
| CPC_CategorizedComment | CPC_CategorizedComment -- |
| CPC_CategorizedComment_Base | Definition for Categorized description/comment This field is added to provide flexibility for depositors to present textual description/comments in a desirable way and to facilitate information validation by the depositor and data exchange with PubChem |
| CPC_Compound | CPC_Compound -- |
| CPC_Compound_Base | Compound Record |
| CPC_Compounds | CPC_Compounds -- |
| CPC_Compounds_Base | Holder for groups of Compounds |
| CPC_CompoundType | CPC_CompoundType -- |
| CPC_CompoundType_Base | Qualification used to describe the type of Compound deposited, standardized, or derived |
| CPC_ConcentrationAttr | CPC_ConcentrationAttr -- |
| CPC_ConcentrationAttr_Base | The concentration attribute is to indicate that the readout under this test result field is biological concentration-response data, the attribute provides the value and unit of the tested concentration |
| CPC_Conformer | CPC_Conformer -- |
| CPC_Conformer_Base | Drawing/Conformer Definition (in Parallel Arrays, synchronized to aid integer list) 3D coordinates are specified in a right-handed coordinate system |
| CPC_Conformers | CPC_Conformers -- |
| CPC_Conformers_Base | Holder for groups of Conformers |
| CPC_Coordinates | CPC_Coordinates -- |
| CPC_Coordinates_Base | Coordinates for the Compound of a given type |
| CPC_Count | CPC_Count -- |
| CPC_Count_Base | Counts of various properties of a Compound |
| CPC_DBTracking | CPC_DBTracking -- |
| CPC_DBTracking_Base | External DB Tracking Information |
| CPC_DrawAnnotations | CPC_DrawAnnotations -- |
| CPC_DrawAnnotations_Base | Drawing Annotations (in Parallel Arrays) [Note: A pair of atoms can have multiple annotations] |
| CPC_ID | CPC_ID -- |
| CPC_ID_Base | ID and Version Description Information |
| CPC_InfoData | CPC_InfoData -- |
| CPC_InfoData_Base | Compound Description/Descriptor Data |
| CPC_IntegerMinMax | CPC_IntegerMinMax -- |
| CPC_IntegerMinMax_Base | Mininum and Maximum Constraints on an Integer Value (used for validating incoming data) |
| CPC_MMDBSource | CPC_MMDBSource -- |
| CPC_MMDBSource_Base | MMDB Source Record detailing specific location or part of an MMDB Record |
| CPC_RealMinMax | CPC_RealMinMax -- |
| CPC_RealMinMax_Base | Mininum and Maximum Constraints on a Real Value (used for validating incoming data) |
| CPC_ResultType | CPC_ResultType -- |
| CPC_ResultType_Base | Definition of Allowed Result Types for a given Assay |
| CPC_Source | CPC_Source -- |
| CPC_Source_Base | Describes Substance Source, if from another database |
| CPC_StereoCenter | CPC_StereoCenter -- |
| CPC_StereoCenter_Base | Allowed Stereogenic Center Types [Using IUPAC Stereogenic Center recommendations and terminology] |
| CPC_StereoGroup | CPC_StereoGroup -- |
| CPC_StereoGroup_Base | List of atom identifiers which are in a common stereochemistry group |
| CPC_StereoOctahedral | CPC_StereoOctahedral -- |
| CPC_StereoOctahedral_Base | Octahedral (OC-6) and Square Pyramid (SPY-5) StereoCenters [Using IUPAC Stereogenic Center recommendations and terminology] [Note: "-1" can be used for the Atom Identifier to represent a lone-pair or implicit hydrogen] |
| CPC_StereoPentagonalBiPyramid | CPC_StereoPentagonalBiPyramid -- |
| CPC_StereoPentagonalBiPyramid_Base | Pentagonal BiPyramid (PBPY-7) StereoCenters [Using IUPAC Stereogenic Center recommendations and terminology] [Note: "-1" can be used for the Atom Identifier to represent a lone-pair or implicit hydrogen] |
| CPC_StereoPlanar | CPC_StereoPlanar -- |
| CPC_StereoPlanar_Base | SP2 Planar Stereogenic Center, Cumulenic StereoCenter (Linear systems on an odd number of double bonds present planar stereochemistry) [Using IUPAC Stereogenic Center recommendations and terminology] [Note: "-1" can be used for the Atom Identifier to represent a lone-pair or implicit hydrogen] |
| CPC_StereoSquarePlanar | CPC_StereoSquarePlanar -- |
| CPC_StereoSquarePlanar_Base | Square Planar (SP4) StereoCenters [Using IUPAC Stereogenic Center recommendations and terminology] [Note: "-1" can be used for the Atom Identifier to represent a lone-pair or implicit hydrogen] |
| CPC_StereoTetrahedral | CPC_StereoTetrahedral -- |
| CPC_StereoTetrahedral_Base | SP3 Tetrahedral StereoCenter, Trigonal Pyramid Stereogenic Center, Cumulenic StereoCenter (Linear systems of an even number of double bonds), or Hindered biaryl stereocenter (All biaryls have hindered rotation that to some extent the ortho-hydrogens prevent coplanarity) [Using IUPAC Stereogenic Center recommendations and terminology] [Note: "-1" can be used for the Atom Identifier to represent a lone-pair or implicit hydrogen] |
| CPC_StereoTrigonalBiPyramid | CPC_StereoTrigonalBiPyramid -- |
| CPC_StereoTrigonalBiPyramid_Base | Trigonal BiPyramid (TBPY-4 and TBPY-5) StereoCenters [Using IUPAC Stereogenic Center recommendations and terminology] [Note: "-1" can be used for the Atom Identifier to represent a lone-pair or implicit hydrogen] |
| CPC_StereoTShape | CPC_StereoTShape -- |
| CPC_StereoTShape_Base | T-Shaped (TS-3) StereoCenters [Using IUPAC Stereogenic Center recommendations and terminology] [Note: "-1" can be used for the Atom Identifier to represent a lone-pair or implicit hydrogen] |
| CPC_Substance | CPC_Substance -- |
| CPC_Substance_Base | Root Record for Chemical Substance Definition |
| CPC_Substances | CPC_Substances -- |
| CPC_Substances_Base | Holder for groups of Substances |
| CPC_Urn | CPC_Urn -- |
| CPC_Urn_Base | Universal Resource Name Provides explicit source information on derived or calculated data |
| CPC_XRefData | CPC_XRefData -- |
| CPC_XRefData_Base | Depositor Provided X-Ref and LinkOut data for Entrez |
| CPCRParsedSet | |
| CPCRPrimer | CPCRPrimer -- |
| CPCRPrimer_Base | CPCRPrimer_Base -- |
| CPCRPrimerName | CPCRPrimerName -- |
| CPCRPrimerName_Base | CPCRPrimerName_Base -- |
| CPCRPrimerSeq | CPCRPrimerSeq -- |
| CPCRPrimerSeq_Base | CPCRPrimerSeq_Base -- |
| CPCRPrimerSet | CPCRPrimerSet -- |
| CPCRPrimerSet_Base | CPCRPrimerSet_Base -- |
| CPCRReaction | CPCRReaction -- |
| CPCRReaction_Base | CPCRReaction_Base -- |
| CPCRReactionSet | CPCRReactionSet -- |
| CPCRReactionSet_Base | CPCRReactionSet_Base -- |
| CPCRSet | |
| CPCRSetList | |
| CPCSubstance_id | CPCSubstance_id -- |
| CPCSubstance_id_Base | Pubchem substance id |
| CPctCoverageScorer | |
| CPctIdentScorer | |
| CPDB_block | CPDB_block -- |
| CPDB_block_Base | PDB specific descriptions |
| CPDB_mol_id | CPDB_mol_id -- |
| CPDB_mol_id_Base | Name of mol, 4 chars |
| CPDB_replace | CPDB_replace -- |
| CPDB_replace_Base | CPDB_replace_Base -- |
| CPDB_seq_id | |
| CPDB_seq_id_Base | CPDB_seq_id_Base -- |
| CPdf | |
| CPdfArray | |
| CPdfDictionary | |
| CPdfFontHandler | |
| CPdfIndirectObj | |
| CPdfName | |
| CPdfNumber | |
| CPdfObj | |
| CPdfObject | |
| CPdfObjectWriter | |
| CPdfRotate | |
| CPdfString | |
| CPdfTrailer | |
| CPdfTranslate | |
| CPepsinA | |
| CPeptideprophet_result | CPeptideprophet_result -- |
| CPeptideprophet_result_Base | PeptideProphet validation results for search hit |
| CPeptideprophet_summary | CPeptideprophet_summary -- |
| CPeptideprophet_summary_Base | Summary information for PeptideProphet analysis |
| CPepXML | |
| CPerfLogger | CPerfLogger -- |
| CPerfLogGuard | CPerfLogGuard -- |
| CPeriodicTestJob | CPrimeNumbersJob |
| oligofar::CPermutator8b | |
| CPerson_id | |
| CPerson_id_Base | Person-id is to define a std element for people |
| CPhenotype | CPhenotype -- |
| CPhenotype_Base | CPhenotype_Base -- |
| CPhiBlastArgs | Argument class to collect options specific to PHI-BLAST |
| CPHIBlastNuclOptionsHandle | Handle to the nuclein PHI BLAST options |
| CPHIBlastProtOptionsHandle | Handle to the protein PHI BLAST options |
| CPhiblastTestFixture | |
| CPhrap_Contig | |
| CPhrap_Read | |
| CPhrap_Seq | |
| CPhrap_Sequence | |
| CPhrapReader | |
| CPhyExporter | |
| CPhyExporterFactory | |
| CPhyExportJob | CPhyExportJob |
| CPhyExportPage | |
| CPhyLoader | CPhyLoader |
| CPhyLoadJob | CPhyLoadJob |
| CPhyLoadPage | |
| CPhyLoadParams | |
| CPhyloForce | Main layout class |
| CPhyloImageGrabber | |
| CPhyloPhylipReader | |
| CPhyloRadial | |
| CPhyloRectCladogram | |
| CPhyloSlantedCladogram | |
| CPhyloTreeCalculator | |
| CPhyloTreeCGIApplication | |
| CPhyloTreeCGIException | |
| CPhyloTreeCGIMap | |
| CPhyloTreeDataSource | |
| CPhyloTreeDemoApp | Derive our application class from CwxNCBIApp and use it together with standard CNCBIwxApplication |
| CPhyloTreeDemoDlg | |
| CPhyloTreeException | |
| CPhyloTreeFilter_Depth | |
| CPhyloTreeFilter_Distance | |
| CPhyloTreeFilter_Export | |
| CPhyloTreeFilter_Selector | |
| CPhyloTreeJob | CPhyloTreeJob |
| CPhyloTreeLabel | |
| CPhyloTreeMaxIdCalculator | |
| CPhyloTreeNode | |
| CPhyloTreePane | Class CPhyloTreePane |
| CPhyloTreePS | Class CPhyloTreePS |
| CPhyloTreeRectCalculator | |
| CPhyloTreeScheme | |
| CPhyloTreeSorter | |
| CPhyloTreeWidget | Class CPhyloTreeWidget |
| CPhyNewickNode | |
| CPhyNodeData | Data contained at each node of a phylogenetic tree |
| CPhyRebuildIndexVisitor | |
| CPhyTreeCalc | Computaion of distance-based phylognetic tree |
| CPhyTreeCalcException | Guide tree calc exceptions |
| CPhyTreeFormatter | Class for adding tree features, maniplating and printing tree in standard text formats |
| CPhyTreeFormatterException | Guide tree exceptions |
| CPhyTreeLabelTracker | Tree visitor, finds all labels and node colors for leafes |
| CPhyTreeNode | |
| CPhyTreeNodeGroupper | This file provides tree visitor classes and functions for node groupping and simplification of phylogenetic trees |
| CPhyTreeView | CPhyTreeView |
| CPhyTreeViewFactory | CPhyTreeViewFactory |
| CPIDGuard | CPIDGuard -- |
| CPIDGuardException | CPIDGuardException -- |
| CPieDataSource | CPieDataSource |
| CPieGraph | CPieGraph |
| CPII | CPII -- |
| CPII_Base | Controlled Publisher Identifier |
| CPipe | CPipe -- |
| CPipeException | CPipeException -- |
| CPipeProcessWatcher | |
| CPipeProcessWatcher_Base | |
| CPIR_block | CPIR_block -- |
| CPIR_block_Base | PIR specific descriptions |
| CPkgManager | CPkgManager - application Package Manager |
| CPlace_SplitInfo | |
| CPlaceId | |
| CPlainTextItem | |
| CPlatform | CPlatform -- |
| CPlatform_Base | CPlatform_Base -- |
| CPlatformFamilyName | CPlatformFamilyName -- |
| CPlatformID | CPlatformID -- |
| CPlatformName | CPlatformName -- |
| CPlatforms | CPlatforms -- |
| CPlatforms_Base | CPlatforms_Base -- |
| CPlatformTarget | CPlatformTarget -- |
| CPlugin< PluginType > | |
| CPluginArg | |
| CPluginArg_Base | |
| CPluginArgSet | Namespace ncbi::objects:: |
| CPluginArgSet_Base | |
| CPluginBase | |
| CPluginCache | |
| CPluginCache_Base | |
| CPluginCommand | |
| CPluginCommand_Base | |
| CPluginException | |
| CPluginIconInfo | |
| CPluginIconInfo_Base | CPluginIconInfo_Base -- |
| CPluginInfo | |
| CPluginInfo_Base | CPluginInfo_Base -- |
| CPluginInfoSet | .hpp User-defined methods of the data storage class |
| CPluginInfoSet_Base | |
| CPluginLibInfo | |
| CPluginLibInfo_Base | |
| CPluginManager< TClass > | CPluginManager<> -- |
| CPluginManager_DllResolver | Service class for DLLs resolution |
| CPluginManagerBase | |
| CPluginManagerException | CPluginManagerException -- |
| CPluginManagerGetter< Interface > | |
| CPluginManagerGetterImpl | |
| CPluginManagerStore | Deprecated interface to CPluginManager |
| CPluginMessage | |
| CPluginMessage_Base | |
| CPluginMessageChain | |
| CPluginMessageChain_Base | |
| CPluginMRUEntry | |
| CPluginMRUEntry_Base | |
| CPluginObject | Namespace ncbi::objects:: |
| CPluginObject_Base | |
| CPluginReply | |
| CPluginReply_Base | |
| CPluginReplyAction | |
| CPluginReplyAction_Base | |
| CPluginRequest | |
| CPluginRequest_Base | |
| CPluginUserType | |
| CPluginUserType_Base | User types for determining which plugins apply to a given set of objects |
| CPluginValue | |
| CPluginValue_Base | |
| CPluginValueConstraint | |
| CPluginValueConstraint_Base | |
| CPluginValueRangeConstraint | |
| CPluginValueRangeConstraint_Base | CPluginValueRangeConstraint_Base -- |
| CPluginVersion | |
| CPmcID | CPmcID -- |
| CPmcID_Base | PubMed Central Id |
| CPmcPid | CPmcPid -- |
| CPmcPid_Base | Publisher Id supplied to PubMed Central |
| CPluginManagerStore::CPMMaker< TInterface > | Utility class to get plugin manager from the store If it is not there, class will create and add new instance to the store |
| CPmPid | CPmPid -- |
| CPmPid_Base | Publisher Id supplied to PubMed |
| CPointerPot | |
| CPointerTypeInfo | |
| CPointerTypeStrings | |
| CPollable | |
| CInitMutexPool::CPoolMutex | |
| CPoolOfThreads< TRequest > | CPoolOfThreads<> -- abstract pool of threads sharing a request queue |
| CPoolOfThreads_ForServer | |
| CPopulation_data | CPopulation_data -- |
| CPopulation_data_Base | CPopulation_data_Base -- |
| CPopupMenuEvent | CPopupMenuEvent - an event that is sent when a popup menu needs to be shown |
| CPosmodel_distribution | CPosmodel_distribution -- |
| CPosmodel_distribution_Base | CPosmodel_distribution_Base -- |
| CPostBuildEvent | CPostBuildEvent -- |
| CPostBuildEventToolDummyImpl | |
| CEventHandler::CPostQueue | CPostQueue - singleton queue for asynchronous events all methods are synchronized |
| CPostReadHook | |
| CPostscript | |
| CPostWriteHook | |
| CPowerOfTwoResizeStrategy | |
| CPreBuildEvent | CPreBuildEvent -- |
| CPreBuildEventTool | |
| CPreBuildEventToolDummyImpl | |
| CPreBuildEventToolLibImpl | |
| CPrefetchBioseq | |
| CPrefetchBioseqActionSource | |
| CPrefetchCanceled | This exception is used to interrupt actions canceled by user |
| CPrefetchComplete< Handle > | |
| CPrefetchComplete< CBioseq_Handle > | |
| CPrefetchFailed | This exception is used to report failed actions |
| CPrefetchFeat_CI | |
| CPrefetchFeat_CIActionSource | |
| CPrefetchHandles_local | |
| CPrefetchManager | |
| CPrefetchManager_Impl | |
| CPrefetchRequest | |
| CPrefetchSequence | |
| CPrefetchThreadOld | |
| CPrefetchTokenOld | CPrefetchToken -- |
| CPrefetchTokenOld_Impl | |
| CPrelimSearchRunner | Functor to run the preliminary stage of the BLAST search |
| CPrelimSearchThread | Thread class to run the preliminary stage of the BLAST search |
| CPreLinkEvent | CPreLinkEvent -- |
| CPreLinkEventToolDummyImpl | |
| CPreOrderedOffsetIterator | Iterator for 0-terminated pre-ordered offset lists |
| CPreReadChoiceVariantHook | Read hook for a choice variant (CHOICE) |
| CPreReadClassMemberHook | Read hook for data member of a containing object (eg, SEQUENCE) |
| CPreReadHook | |
| CPreviewSetupDlg | |
| CPreWriteHook | |
| CPRF_block | CPRF_block -- |
| CPRF_block_Base | CPRF_block_Base -- |
| CPRF_ExtraSrc | CPRF_ExtraSrc -- |
| CPRF_ExtraSrc_Base | CPRF_ExtraSrc_Base -- |
| CPrimaryItem | |
| CPrimarySequence | CPrimarySequence -- |
| CPrimarySequence_Base | CPrimarySequence_Base -- |
| CPrimeNumberClient | CPrimeNumberClient |
| CPrimeNumbersJob | CPrimeNumbersJob |
| CPrimitiveTypeFunctions< T > | |
| CPrimitiveTypeFunctionsBase | |
| CPrimitiveTypeInfo | |
| CPrimitiveTypeInfoAnyContent | |
| CPrimitiveTypeInfoBitString | |
| CPrimitiveTypeInfoBool | |
| CPrimitiveTypeInfoChar | |
| CPrimitiveTypeInfoCharPtr< T > | |
| CPrimitiveTypeInfoDouble | |
| CPrimitiveTypeInfoFloat | |
| CPrimitiveTypeInfoInt | |
| CPrimitiveTypeInfoIntFunctions< T > | |
| CPrimitiveTypeInfoString | |
| CPrintableCharPtrConverter | |
| CPrintableStringConverter | |
| CPrintContext | |
| CPrintForm | CPrintForm -- |
| CPrintForm_Base | Forms for various ASN.1 components |
| CPrintFormat | CPrintFormat -- |
| CPrintFormat_Base | CPrintFormat_Base -- |
| CPrintFormBlock | CPrintFormBlock -- |
| CPrintFormBlock_Base | For SEQUENCE, SET |
| CPrintFormBoolean | CPrintFormBoolean -- |
| CPrintFormBoolean_Base | CPrintFormBoolean_Base -- |
| CPrintFormEnum | CPrintFormEnum -- |
| CPrintFormEnum_Base | CPrintFormEnum_Base -- |
| CPrintFormText | CPrintFormText -- |
| CPrintFormText_Base | CPrintFormText_Base -- |
| CPrintHanderWx | Shows a basic example of how to print stuff in wx |
| CPrintOptions | |
| CPrintSetupDlg | |
| CPrintState | |
| CPrintTemplate | CPrintTemplate -- |
| CPrintTemplate_Base | CPrintTemplate_Base -- |
| CPrintTemplateSet | CPrintTemplateSet -- |
| CPrintTemplateSet_Base | CPrintTemplateSet_Base -- |
| CPrintTextProxy | Stream-like class to help unify printing some text messages to diagnostics and to any iostream |
| CPrintTraversalNodeCallback | |
| CArgDescriptions::CPrintUsage | |
| CArgDescriptions::CPrintUsageXml | |
| CPriority_I | |
| CPriorityNode | |
| CPriorityTaxNodes | |
| CPriorityTree | |
| CPrjItemNameValidator | |
| CPrjItemSelector_Data | |
| CPrjItemSelector_Id | CIdSelector finds a Project Item by Id |
| CPrjItemSelector_Label | CLabelSelector finds a Project Item by Label |
| CProceedingsChapterPanel | |
| CProceedingsPanel | |
| CProcess | CProcess -- |
| CProcessor | |
| CProcessor_AnnotInfo | |
| CProcessor_ExtAnnot | |
| CProcessor_ID1 | |
| CProcessor_ID1_SNP | |
| CProcessor_ID2 | |
| CProcessor_ID2_Split | |
| CProcessor_ID2AndSkel | |
| CProcessor_SE | |
| CProcessor_SE_SNP | |
| CProcessor_St_SE | |
| CProcessor_St_SE_SNPT | |
| CProduct_pos | CProduct_pos -- |
| CProduct_pos_Base | CProduct_pos_Base -- |
| CProductName | CProductName -- |
| CProductVersion | CProductVersion -- |
| CProfileData | Represent databases of PSSM data and residue frequencies |
| CProgram_id | CProgram_id -- |
| CProgram_id_Base | CProgram_id_Base -- |
| CProgramDescriptionArgs | Argument class to populate an application's name and description |
| python::CProgrammingError | |
| oligofar::CProgressIndicator | |
| CValidator::CProgressInfo | |
| CProgressPanel | |
| CProjBulderApp | CProjBulderApp -- |
| CProjBulderAppException | CProjBulderAppException -- |
| CProjdesc | CProjdesc -- |
| CProjdesc_Base | CProjdesc_Base -- |
| CProject | CProject -- |
| CProject_Base | This is a stripped-down and modified version of Microsoft.Build.Commontypes.xsd =================== INCLUDE COMMON SCHEMA =========================== This is a stripped-down and modified version of Microsoft.Build.Core.xsd ======================================================================================= |
| CProject_descr | CProject_descr -- |
| CProject_descr_Base | CProject_descr_Base -- |
| CProject_id | CProject_id -- |
| CProject_id_Base | CProject_id_Base -- |
| CProject_item | CProject_item -- |
| CProject_item_Base | CProject_item_Base -- |
| CProjectAnnot | |
| CProjectAnnot_Base | CProjectAnnot_Base -- |
| CProjectCmdHandler | CProjectCmdHandler - handles wxWidget commands and translates them to CProjectTasks |
| CProjectConfiguration | CProjectConfiguration -- |
| CProjectConstPrx | CProjectConstPrx |
| CProjectDescr | .hpp User-defined methods of the data storage class |
| CProjectDescr_Base | CProjectDescr_Base -- |
| CProjectEditDlg | |
| CProjectExtensions | CProjectExtensions -- |
| CProjectFileWriter | |
| CProjectFolder | |
| CProjectFolder_Base | CProjectFolder_Base -- |
| CProjectFolderConstPrx | CProjectFolderConstPrx |
| CProjectFolderPrx | CProjectFolderPrx |
| CProjectFolderTreeItem | |
| CProjectFormatLoadManager | CProjectFormatLoadManager |
| CProjectGuid | CProjectGuid -- |
| CProjectHistoryItem | |
| CProjectHistoryItem_Base | CProjectHistoryItem_Base -- |
| IPhyloTreeRenderer::CProjectionExtents | This class extracts for each of the 4 directions (+x,-x,+y,-y) the maximum coordinates to which any element in the graph projects |
| CProjectItem | |
| CProjectItem_Base | CProjectItem_Base -- |
| CProjectItemConstPrx | CProjectItemConstPrx |
| CProjectItemLabelHandler | |
| CProjectItemPrx | CProjectItemPrx |
| CProjectItemsTree | CProjectItemsTree -- |
| CProjectLoadingJob | CProjectLoadingJob - a job that load a project with the given ID |
| CProjectLoadingTask | CProjectLoadingTask - a composite task that loads the given projects |
| CProjectLoadManager | CProjectLoadManager -Load Manager that loads both Projects and Workspaces |
| CProjectLoadOptionPanel | CProjectLoadOptionPanel CProjectLoadOptionPanel - dialog panel for loading Projects and Workspaces |
| CProjectPrx | CProjectPrx |
| CProjectReference | CProjectReference -- |
| CProjectSelector_Id | CIdSelector finds a Project by Id |
| CProjectSelectorDlg | |
| CProjectSelectorPanel | CProjectSelectorPanel - a panel that allows the user to specify how the project items created by a plug-in should be packaged |
| CProjectService | CProjectService - a service providing API for operations with Workspaces and Projects |
| CProjectServiceException | CProjectServiceException |
| CProjectServiceTestJob | CProjectServiceTestJob |
| CProjectServiceTestTask | CProjectServiceTestTask - concurrency test for Project Service |
| CProjectServiceUpdate | CProjectServiceUpdate |
| CProjectsLstFileFilter | |
| CProjectTask | CProjectTask - a task that supports typical application operations applicable to Workspaces and Projects |
| CProjectTreeBuilder | CProjectTreeBuilder -- |
| CProjectTreeCtrl | CProjectTreeCtrl - subclass of wxTreeCtrl to allow functions to be overridden for application-specific behavior |
| CProjectTreeFolders | CProjectTreeFolders -- |
| CProjectTreePanel | CProjectTreePanel - a window that represents Project View |
| CProjectTreeView | CProjectTreeView - a system view that displays Project Tree |
| CProjectTreeViewDropTarget | CProjectTreeViewDropTarget - a drop target associated with CProjectTreeView |
| CProjectTreeViewFactory | CProjectTreeViewFactory - a factory producing CProjectTreeView |
| CProjectType | CProjectType -- |
| CProjectTypeGuids | CProjectTypeGuids -- |
| CProjectView | CProjectView |
| CProjectViewBase | CProjectViewBase - default implementation of IProjectView, the base class for CProjectView and CProjectViewComposite |
| CProjectViewEvent | CProjectViewEvent |
| CProjectViewEvtHandler | CProjectViewEvtHandler - wxEvtHandler that is attached to view window |
| CProjectViewToolBatFactory | CProjectViewToolBatFactory - provides standard toolbars for Project Views |
| CProjectViewTypeDescriptor | CProjectViewTypeDescriptor - holds description of a project view type |
| CProjItem | CProjItem -- |
| CProjKey | CProjKey -- |
| CProjSRCResolver | Resolver for SRC keys in Makefiles: |
| CPromote | |
| CPromoteRule | Class CPromoteRule |
| CPropertiesPanelDlg | |
| CProperty | CProperty -- |
| CPropertyGroup | CPropertyGroup -- |
| CPropertyGroup_Base | ======================================================================================= Groups property definitions |
| CProSplign | Spliced protein to genomic alignment |
| CProSplignApp | |
| CProSplignException | |
| CProSplignOptions_Base | Scoring parameters object |
| CProSplignOutputOptions | Output filtering parameters |
| CProSplignOutputOptionsExt | Extended output filtering parameters deprecated, used in older programs |
| CProsplignProcess | |
| CProSplignScaledScoring | |
| CProSplignScoring | |
| CProSplignText | Text representation of ProSplign alignment |
| CProt_pos | CProt_pos -- |
| CProt_pos_Base | Codon based position on protein (1/3 of aminoacid) |
| CProt_ref | |
| CProt_ref_Base | Prot-ref *********************************************** |
| CProteinAlignText | Text representation of ProSplign alignment |
| CProteinModel | |
| CProtProp | This class defines functions for calculating properties of amino acid sequences |
| CProvider | CProvider -- |
| CProvider_Base | CProvider_Base -- |
| CSerializable::CProxy | |
| CPSeq | |
| CPseudoTransparentFrame | CPseudoTransparentFrame - this is a transparent window that is used as a visual hint during D&D docking |
| CPsiBl2Seq | Runs a single iteration of the PSI-BLAST algorithm between 2 sequences |
| CPsiBl2SeqTestFixture | |
| CPsiBlast | Runs a single iteration of the PSI-BLAST algorithm on a BLAST database |
| CPsiBlastAlignmentProcessor | Auxiliary class to retrieve sequence identifiers its position in the alignment which are below the inclusion evalue threshold |
| CPsiBlastApp | |
| CPsiBlastAppArgs | Handle command line arguments for psiblast binary Programs supported: psiblast, phi-blastn, phi-blastp |
| CPsiBlastArgs | Argument class to collect options specific to PSI-BLAST |
| CPsiBlastImpl | Implementation class for PSI-BLAST (database search and 2 sequences) |
| CPsiBlastInputClustalW | This class is a concrete strategy for IPssmInputData which converts the CLUSTALW-style output containing a multiple sequence alignment into the data structures needed by the PSSM engine |
| CPsiBlastInputData | This class is a concrete strategy for IPssmInputData, and it implements the traditional PSI-BLAST algorithm for building a multiple sequence alignment from a list of pairwise alignments using the C++ object manager |
| CPsiBlastInputFreqRatios | Implements the interface to retrieve data for the last 2 stages of the PSSM creation |
| CPsiBlastIterationState | Represents the iteration state in PSI-BLAST |
| CPSIBlastOptions | Wrapper class for PSIBlastOptions |
| CPSIBlastOptionsHandle | Handle to the protein-protein options to the BLAST algorithm |
| CPsiBlastTestFixture | |
| CPsiBlastValidate | Auxialiry class containing static methods to validate PSI-BLAST search components |
| CPSIDiagnosticsRequest | Wrapper class for PSIDiagnosticsRequest |
| CPSIDiagnosticsResponse | Wrapper class for PSIDiagnosticsResponse |
| CPSIMatrix | Wrapper class for PSIMatrix |
| CPSIMsa | Wrapper class for PSIMsa |
| CPssm | |
| CPssm_Base | Position-specific scoring matrix |
| CPSSMAligner | |
| CPssmCddInputTest | Class for testing methods of CCddInputData class |
| CPssmCreateTestFixture | This class exists merely to call private methods in CPsiBlastInputData and CPssmEngine |
| CPssmEngine | Computes a PSSM as specified in PSI-BLAST |
| CPssmEngineArgs | Argument class to collect PSSM engine options |
| CPssmEngineException | Exception class for the CPssmEngine class |
| CPssmEngineFreqRatiosTestFixture | |
| CPssmFinalData | CPssmFinalData -- |
| CPssmFinalData_Base | =========================================================================== PSI-BLAST, formatrpsdb, RPS-BLAST workflow: =========================================== |
| CPssmInputFlankingGaps | Mock object for the PSSM input data which returns multiple sequence alignment data which has flanking gaps |
| CPssmInputGapsInQuery | Mock object for the PSSM input data which returns a query sequence with a gap in it |
| CPssmInputQueryLength0 | Mock object for the PSSM input data which returns a query sequence with a gap in it |
| CPssmInputTestData | Mock object for the PSSM input data which can be configured to have different combinations of aligned sequences |
| CPssmInputUnsupportedMatrix | |
| CPssmInputWithGapsInQuery | PSSM computation strategy with gaps in query |
| CPssmInputWithNegativeFreqs | PSSM computation strategy with domains with negative residue frequencies |
| CPssmInputWithNoCDs | Simple PSSM computation strategy with one CD |
| CPssmInputWithSingleCD | Simple PSSM computation strategy with one CD |
| CPssmInputWithTwoCDs | Simple PSSM computation strategy with two CDs |
| CPssmInputWithUnnormalizedFreqs | PSSM computation strategy with domains with frequencies that do not sum to 1 |
| CPssmInputWithZeroObservations | PSSM computation strategy with domains with zero observations |
| CPssmIntermediateData | CPssmIntermediateData -- |
| CPssmIntermediateData_Base | Contains the PSSM's intermediate data used to create the PSSM's scores and statistical parameters |
| CPssmParameters | CPssmParameters -- |
| CPssmParameters_Base | Populated by PSSM engine of PSI-BLAST, original source for these values are the PSI-BLAST options specified using the BLAST options API |
| CPssmWithParameters | |
| CPssmWithParameters_Base | Envelope containing PSSM and the parameters used to create it |
| CPtbRegistry | |
| CPtrToObjectProxy | CPtrToObjectProxy -- |
| CPub | |
| CPub_Base | CPub_Base -- |
| CPub_equiv | |
| CPub_equiv_Base | Equivalent identifiers for same citation |
| CPub_field_constraint | CPub_field_constraint -- |
| CPub_field_constraint_Base | CPub_field_constraint_Base -- |
| CPub_field_special_constraint | CPub_field_special_constraint -- |
| CPub_field_special_constraint_Base | CPub_field_special_constraint_Base -- |
| CPub_field_special_constraint_type | CPub_field_special_constraint_type -- |
| CPub_field_special_constraint_type_Base | CPub_field_special_constraint_type_Base -- |
| CPub_set | |
| CPub_set_Base | CPub_set_Base -- |
| CPubdesc | .hpp User-defined methods of the data storage class |
| CPubdesc_Base | How sequence presented in pub |
| CPublication_constraint | CPublication_constraint -- |
| CPublication_constraint_Base | CPublication_constraint_Base -- |
| CPublicationTypePanel | |
| CPublisherName | CPublisherName -- |
| CPublisherPanel | |
| CPublishFile | CPublishFile -- |
| CPublishUrl | CPublishUrl -- |
| CPubmed_entry | CPubmed_entry -- |
| CPubmed_entry_Base | PubMed entry PUBMED records must include the PubMedId |
| CPubmed_url | CPubmed_url -- |
| CPubmed_url_Base | CPubmed_url_Base -- |
| CPubMedId | CPubMedId -- |
| CPubMedId_Base | Id from the PubMed database at NCBI |
| CPubseq2Reader | |
| CPubseq2ReaderCF | Class factory for Pubseq reader |
| CPubseqReader | |
| CPubseqReaderCF | Class factory for Pubseq reader |
| CPubStatusDate | CPubStatusDate -- |
| CPubStatusDate_Base | Done as a structure so fields can be added |
| CPubStatusDateSet | CPubStatusDateSet -- |
| CPubStatusDateSet_Base | CPubStatusDateSet_Base -- |
| CPurgeFlagGuard | |
| CPushback_Streambuf | |
| CPVecBuffer | |
| CPVecLine | |
| CPVecObj | |
| CPVecPoint | |
| CPVecPolygon | |
| CPVecText | |
| CPVFactoryCombinator | |
| CQualContainer< Key > | |
| CQualityScoringMethod | CQualityScoringMethod - Like CSimpleScoringMethod, in that it calculate the quality of the alignment column and residue, based on how different each residue is from the columns consensus |
| CQualityScoringMethodAA | CQualityScoringMethodAA - Quality scoring method for Amino Acids (Protein alignments) |
| CQualityScoringMethodNA | CQualityScoringMethodNA - Quality scoring method for Nucleic Acids (DNA alignments) |
| CQualityScoringPanel | CQualityScoringPanel |
| CQualListItemPanel | |
| CQuantity_constraint | CQuantity_constraint -- |
| CQuantity_constraint_Base | CQuantity_constraint_Base -- |
| CQuat< T > | |
| oligofar::CQuery | |
| CQuery | Object used to execute queries and stored procedures on the database server and retrieve result sets |
| CQueryBox | |
| CQueryDataPerChunk | Auxiliary class to determine information about the query that was split into chunks |
| CQueryDataTestFixture | |
| CQueryEval_BV_Value< BV > | Query tree user object for storing bit-vectors |
| CQueryParsePanel::CQueryEvent | Event class for notifying attached widget that query is complete |
| CQueryExec | Query execution environment holds the function registry and the execution context |
| CQueryExecEnv | Query execition environment |
| CQueryExecEvalFunc | Expression evaluation visitor functor |
| CQueryExecException | Class CQueryExecException |
| CQueryExecPreProcessFunc | Class CQueryExecPreProcessFunc |
| CQueryFactoryInfo | Contains information about all sequences in a set |
| CQueryFilter | |
| CQueryFuncEqualityCompares | Class CQueryFuncEqualityCompares |
| CQueryFuncGtLtCompares | Class CQueryFuncGtLtCompares |
| CQueryFuncLike | Class CQueryFuncLike |
| CQueryFuncPromoteBase | Class CQueryFuncPromoteBase |
| CQueryFuncPromoteBetween | Class CQueryFuncPromoteBetween |
| CQueryFuncPromoteCompare | Class CQueryFuncPromoteCompare |
| CQueryFuncPromoteEq | Class CQueryFuncPromoteEq |
| CQueryFuncPromoteGtLt | Class CQueryFuncPromoteGtLt |
| CQueryFuncPromoteIn | Class CQueryFuncPromoteIn |
| CQueryFuncPromoteLogic | Class CQueryFuncPromoteLogic |
| CQueryFuncPromoteValue | Class CQueryFuncPromoteValue |
| CQueryFunction_BV_Base< BV > | Base class for all bit-vector oriented function implementations |
| CQueryFunction_BV_In_Or< BV > | Implementation of IN as OR-ed EQ search |
| CQueryFunction_BV_Logic< BV > | Implementation of logical functions |
| CQueryFunction_BV_Not< BV > | Implementation of logical NOT |
| CQueryFunctionBase | Base class for evaluation functions |
| oligofar::CQueryHash | |
| CQueryHighlightFunction | Class for extracting positions of data fields from the query |
| CQueryImpl | |
| CQueryParsePanel::CQueryJob | Job class used to run query on separate thread |
| CQueryMacro | Class describes macro language for bulk bio-editing |
| CQueryMatchAccumulator< THit > | |
| CPhyTreeFormatter::CQueryNodeChecker | Tree visitor for checking whether a subtree contains a query node |
| CQueryNodeValue | Class CQueryNodeValue |
| CQueryOptionsArgs | Argument class to collect query options |
| CQueryParseException | Query parser exceptions |
| CQueryParseNode | Query node class |
| CQueryParsePanel | CQueryParsePanel |
| CQueryParserEnv | Class passed to Lex/Bison (yylex/yyparse) functions |
| CQueryParseTree | Query tree and associated utility methods |
| CQuerySet | |
| CQuerySetUpOptions | Wrapper class for QuerySetUpOptions |
| CQuerySplitter | Class responsible for splitting query sequences and providing data to the BLAST search class to search a split query chunk |
| CQueryTreeCleanPoolFunc | Query tree garbage collection functor |
| CQueryTreeFieldResolveFunc | Field resolution functor |
| CQueryTreePrintFunc | The main tree printing functor class |
| CQueryTreeResetFunc | Reset query node |
| CQueue | Mutex protected Queue database with job status FSM |
| CQueueClientInfo | Netschedule queue client info |
| CQueueClientInfoList | All clients registered to connect |
| CQueueCollection | |
| CQueueConstIterator | |
| CQueueDataBase | Top level queue database |
| CQueueDbBlockArray | |
| CQueueEnumCursor | |
| CBlockingQueue< TRequest >::CQueueItem | |
| CBlockingQueue_ForServer::CQueueItem | |
| CQueueItemBase | CQueueItemBase -- skeleton blocking-queue item, sans actual request |
| CQueueItemBase_ForServer | |
| CQueueIterator | |
| CQueueParamAccessor | |
| CQuickSortStack | |
| CQuickStrStream | Stream-like class to accumulate all in one string without actual streams-related overhead |
| CRAMonitor | |
| CRandom | |
| TestUtil::CRandomIntGen< lowest_value, highest_value > | |
| CRandomlyFailMockBlastSeqSrc | Mock BlastSeqSrc implementation which fails randomly |
| CRandomRowSelector | |
| CRange< Position > | |
| pythonpp::CRange | |
| CRange_Less | |
| CRange_ReverseLess | |
| CRangeCollection< Position > | |
| CRangeMap< Mapped, Position > | |
| CRangeMapBase< Traits > | |
| CRangeMapConstIteratorTraits< MapTraits > | |
| CRangeMapIterator< Traits > | |
| CRangeMapIteratorTraits< MapTraits > | |
| CRangeMapper | |
| CRangeMapTraits< Position, Mapped > | |
| CRangeMapTraitsBase< Position, Mapped > | |
| CRangeMultimap< Mapped, Position > | |
| CRangeMultimapTraits< Position, Mapped > | |
| CRangeWithFuzz | |
| CRasterizer< A > | |
| CRateMonitor | |
| CRawPointer | Helper address class |
| CRawScoreVector< Key, Score > | Class CRawScoreVector stores its data in a (sorted) STL vector this gives a better memory profile and ias easier to serialize |
| CRawSeqDBSource | |
| CRC | CRC -- |
| CRCache | |
| CReadBlastApp | |
| CReadChoiceVariantHook | Read hook for a choice variant (CHOICE) |
| CReadClassMemberHook | Read hook for data member of a containing object (eg, SEQUENCE) |
| CReadCmdExecutor | |
| CReadCMHook_Date_std__year | |
| CReadContainerElementHook | Read hook for a container element (SEQUENCE OF) |
| CReadDispatcher | |
| CReadDispatcherCommand | |
| CReader | |
| CReaderAllocatedConnection | |
| CReaderBase | Defines and provides stubs for a general interface to a variety of file readers |
| CReaderCacheManager | |
| oligofar::CReaderFactory | |
| CReaderRequestResult | |
| CReaderServiceConnector | |
| CReadFilesApp | CReadFilesApp |
| CReadHook_SkipError | This class is intended to skip over plugin messages in gbench projects that do not meet the current spec for a plugin message |
| CReadHookWriter | Simple read hook - when it finds its object, it reads it in and dumps it to the stream |
| CReadInSkipClassMemberHook< Member > | |
| CReadInSkipObjectHook< Object > | |
| CReadObjectHook | Read hook for a standalone object |
| CReadObjectInfo | |
| CReadObjectList | |
| CReadresult | |
| CReadSeqSetHook | |
| CReadSharedObjectIdHookBase | |
| CReadSharedScoreIdHook | |
| CReadTagger | |
| oligofar::CReadTagger | |
| CGuiRegistry::CReadView | |
| CGuiRegistry::CReadWriteView | |
| CReal_graph | CReal_graph -- |
| CReal_graph_Base | CReal_graph_Base -- |
| CRealDataType | |
| python::CRealResultSet | |
| python::CRealSetProxy | |
| CRealValue | CRealValue -- |
| CRealValue_Base | CRealValue_Base -- |
| Creater< X > | Functor template for allocating object |
| CReaderRequestResult::CRecurse | |
| CRecursionGuard | |
| CRecursionLock | |
| CRedoAlignmentTestFixture | |
| CRef< C, Locker > | CRef -- |
| CRef_ext | CRef_ext -- |
| CRef_ext_Base | CRef_ext_Base -- |
| CRefArgs | CRefArgs:: |
| CReference | Class to keep track of the various BLAST references |
| CReference_frame | CReference_frame -- |
| CReference_frame_Base | An external reference frame is a pointer to another biostruc, with an optional operator to rotate and translate coordinates into its model space |
| CReferenceDataType | |
| pythonpp::CReferenceError | |
| CReferenceItem | |
| CRefTypeInfo< Data > | |
| CRefTypeStrings | |
| CRegexp | CRegexp -- |
| CRegexp_loc | Class used to convert a PCRE match to a char* sequence into a CSeq_loc |
| CRegexpException | CRegexpException -- |
| CRegexpLocApp | |
| CRegexpTemplateFilter | |
| CRegexpUtil | CRegexpUtil -- |
| CRegexpValidator | |
| CRegion_boundary | CRegion_boundary -- |
| CRegion_boundary_Base | Region boundaries are defined by regular solids located in the model space |
| CRegion_coordinates | CRegion_coordinates -- |
| CRegion_coordinates_Base | Coordinate sites describe a region in space by reference to individual coordinates, in a particular model |
| CRegion_pntrs | CRegion_pntrs -- |
| CRegion_pntrs_Base | Region motifs describe features defined by spatial location, such as the site specified by a coordinate value, or a rgeion within a bounding volume |
| CRegion_similarity | CRegion_similarity -- |
| CRegion_similarity_Base | A biostruc similarity describes spatial features which are similar between two or more biostrucs |
| CRegion_type | CRegion_type -- |
| CRegion_type_Base | Other choice is to create protein sequences, skipping bad |
| CRegionMap | CRegionMap |
| CRegistryException | CRegistryException -- |
| CRegistryFile | |
| CRegistryReadGuard | CRegistry{Read,Write}Guard -- |
| CRegularGridGen | CRegularGridGen |
| CRegularGridRenderer | CRegularGridRenderer |
| CReject_id | CReject_id -- |
| CReject_id_Base | CReject_id_Base -- |
| CRelatedObjectListCtrl | |
| CRelation | |
| CRelationTypeConverterAdapter | |
| CReleaseFilePresenter | |
| CRemap_db_id | CRemap_db_id -- |
| CRemap_db_id_Base | Database name |
| CRemap_dt | CRemap_dt -- |
| CRemap_dt_Base | Date/time stamp |
| CRemap_query | CRemap_query -- |
| CRemap_query_Base | CRemap_query_Base -- |
| CRemap_reply | CRemap_reply -- |
| CRemap_reply_Base | Replies from the server all replies contain the date/time stamp when they were executed |
| CRemap_request | CRemap_request -- |
| CRemap_request_Base | Remap Request types |
| CRemap_result | CRemap_result -- |
| CRemap_result_Base | Remapped locations |
| CRemapClient | .hpp User-defined methods of the data storage class |
| CRemapClient_Base | CRemapClient_Base -- |
| CRemarksAndSerialNumberPanel | |
| CRemoteAppClientSampleApp | |
| CRemoteAppIdleTask | |
| CRemoteAppJob | The remote_app NetSchedule job |
| CRemoteAppLauncher | |
| CRemoteAppRequest | Remote Application Request (both client side and application executor side) |
| CRemoteAppResult | Remote Application Result (both client side and application executor side) |
| CRemoteArgs | Argument class to collect remote vs. local execution |
| CRemoteBlast | API for Remote Blast Requests |
| CRemoteBlastAligner | |
| CRemoteBlastDbAdapter | This class allows retrieval of sequence data from BLAST databases at NCBI |
| CRemoteBlastDbDataLoader | |
| CRemoteBlastException | Exception class for the CRemoteBlast class |
| CRemoteCgiApp | |
| CRemoteCgiJob | NetSchedule sample job |
| CRemoteDebugEnabled | CRemoteDebugEnabled -- |
| CRemoteDebugMachine | CRemoteDebugMachine -- |
| CRemotePssmSearch | Remote Sequence Search |
| CRemoteSearchFactory | Factory for CRemoteSearch |
| CRemoteSeqSearch | Remote Sequence Search |
| CRemove_action | CRemove_action -- |
| CRemove_action_Base | CRemove_action_Base -- |
| CRemove_descriptor_action | CRemove_descriptor_action -- |
| CRemove_descriptor_action_Base | CRemove_descriptor_action_Base -- |
| CRemove_duplicate_feature_action | CRemove_duplicate_feature_action -- |
| CRemove_duplicate_feature_action_Base | CRemove_duplicate_feature_action_Base -- |
| CRemove_EditCommand< TEditHandle > | |
| CRemove_feature_action | CRemove_feature_action -- |
| CRemove_feature_action_Base | CRemove_feature_action_Base -- |
| CRemove_outside_action | CRemove_outside_action -- |
| CRemove_outside_action_Base | CRemove_outside_action_Base -- |
| CRemove_sequences_action | CRemove_sequences_action -- |
| CRemove_sequences_action_Base | CRemove_sequences_action_Base -- |
| CRemove_xrefs_action | CRemove_xrefs_action -- |
| CRemove_xrefs_action_Base | CRemove_xrefs_action_Base -- |
| CRemoveBioseqChecker | |
| CRemoveFeatChecker | |
| CRemoveIdChecker | |
| CRemoveIntegerChecks | CRemoveIntegerChecks -- |
| CRemoveTSE_EditCommand | |
| CRenameDlg | |
| CRenderableImpl | CRenderableImpl |
| CRenderingContext | CRenderingContext offers the basic context and utility methods for rendering layout objects in feature panel |
| CREnzResult | This class represents the results of a search for sites of a particular enzyme |
| CREnzyme | This class represents a restriction enzyme (an enzyme name and a vector of cleavage specificities) |
| CRepeatLibrary | Class acting as an interface to a RepeatMasker library |
| CRepeatMaskerReader | Implements a concrete class for reading RepeatMasker output from tabular form and rendering it as ASN.1 using the NCBI data model |
| CRepeatToFeat | Class which, given an input IRepeatRegion, can generate an appropriate and normalized NCBI ASN.1 representation as a sequence feature |
| CReplace_func | CReplace_func -- |
| CReplace_func_Base | CReplace_func_Base -- |
| CReplace_rule | CReplace_rule -- |
| CReplace_rule_Base | CReplace_rule_Base -- |
| CReportEntry | |
| CRequestContext | |
| CRequestExecutor | |
| CRequestRateControl | CRequestRateControl -- |
| CRequestRateControlException | CRequestRateControlException -- |
| CRequestStateGuard | |
| CRequestStatus | |
| CSRSearch::CResCache | |
| CSeq_graph::CReserveHook | |
| CDense_seg::CReserveHook | |
| CSeqTable_multi_data::CReserveHook | |
| CResetIdChecker | |
| CResetIds_EditCommand | |
| CResetScopeHistoryJob | Job to reset scope history in the background |
| CResetValue_EditCommand< TEditHandle, T > | |
| CResidue | CResidue -- |
| CResidue_Base | Residues may be assigned a text-string name as well as an id number |
| CResidue_explicit_pntrs | CResidue_explicit_pntrs -- |
| CResidue_explicit_pntrs_Base | CResidue_explicit_pntrs_Base -- |
| CResidue_graph | CResidue_graph -- |
| CResidue_graph_Base | Residue graphs define atomic formulae, connectivity, chirality, and names |
| CResidue_graph_id | CResidue_graph_id -- |
| CResidue_graph_id_Base | CResidue_graph_id_Base -- |
| CResidue_graph_pntr | CResidue_graph_pntr -- |
| CResidue_graph_pntr_Base | Residue graphs from different sources may be referenced within a molecule graph |
| CResidue_id | CResidue_id -- |
| CResidue_id_Base | CResidue_id_Base -- |
| CResidue_interval_pntr | CResidue_interval_pntr -- |
| CResidue_interval_pntr_Base | CResidue_interval_pntr_Base -- |
| CResidue_pntrs | CResidue_pntrs -- |
| CResidue_pntrs_Base | CResidue_pntrs_Base -- |
| CResizingIterator< TSeq, TVal > | |
| CResolvedTypeSet | |
| CResolveIdDlg | |
| CResolveRequest | Wrapper class for a resolution request |
| CResolveRequestFatal | Siple fatal request used for terminating processing |
| CResource | CResource -- |
| CResourceCompile | CResourceCompile -- |
| CResourceCompilerToolDummyImpl | CResourceCompilerToolImpl -- |
| CResourceCompilerToolImpl< DebugReleaseTrait > | CResourceCompilerToolImpl -- |
| CResourcePool< Value, Lock, CF > | General purpose resource pool (standard version, requiring CF to have a default constructor) |
| CResourcePool_Base< Value, Lock, CF > | General purpose resource pool (base class, sans default constructor arguments for maximum versatility) |
| CResourcePoolGuard< Pool > | Guard object |
| CResoursePool_NewClassFactory< Value > | Default class factory for resource pool (C++ new/delete) |
| CResponseFile | CResponseFile -- |
| CPrimeNumbersJob::CResult | |
| impl::CResult | CResult:: |
| CResult | CResult -- |
| CExec::CResult | The result type for Spawn methods |
| CResult_Base | CResult_Base -- |
| CResultItem | CResultItem -- |
| CResultSet | |
| CResultSetMetaData | |
| python::CResultSetProxy | |
| CResultZBtSrcX | |
| CReturnSeqBuffer | RIAA class for GetSequence/RetSequence |
| CRevComp_It< Iterator > | Implementation [in header because of templates] |
| CReverseAndComplement< T > | |
| CReverseComplementHelper | Wraps up any functionality needed that might be outside the scope of this library |
| CReverseObjectStore< TKey, TObject > | Storage container for CObject derived classes Objects are indexed by a key (usually string or integer) |
| CReverseSorter | |
| CRgbaColor | Class CRgbaColor provides a simple abstraction for managing colors |
| CRgbaColorTable | CRgbaColorTable |
| CRgbaGradColorTable | CRgbaGradColorTable Provides a storage for colors (to eliminate color creation overhead) and Functions for initializing the table |
| CRichTextCtrl | CRichTextCtrl - a wrapper for wxRichTextCtrl that handles additional keyboard events (such as Clipboard shortcuts) |
| CRichTextHandle | Rich Text helper class that allows mouse click and motion events to grab the control's parent object and move it around |
| CRMBlastnApp | |
| CRMBlastnAppArgs | Handles command line arguments for blastn binary |
| CRMBlastNArg | RMH: Argument class to retrieve and set the options specific to the RMBlastN algorithm |
| CRMLoader | CRMLoader |
| CRMLoadJob | CRMLoadJob |
| CRmReader | Deprecated, old API for loading RepeatMasker output |
| CRMReply | CRMReply -- |
| CRMReply_Base | CRMReply_Base -- |
| CRMRequest | CRMRequest -- |
| CRMRequest_Base | Request types |
| CRmtBlastDb_DataLoaderCF | Data Loader Factory for BlastDbDataLoader |
| CRna_feat_type | CRna_feat_type -- |
| CRna_feat_type_Base | CRna_feat_type_Base -- |
| CRNA_gen | |
| CRNA_gen_Base | CRNA_gen_Base -- |
| CRna_qual | CRna_qual -- |
| CRNA_qual | CRNA_qual -- |
| CRna_qual_Base | CRna_qual_Base -- |
| CRNA_qual_Base | Additional data values for RNA-gen, |
| CRna_qual_pair | CRna_qual_pair -- |
| CRna_qual_pair_Base | CRna_qual_pair_Base -- |
| CRNA_qual_set | CRNA_qual_set -- |
| CRNA_qual_set_Base | CRNA_qual_set_Base -- |
| CRNA_ref | .hpp User-defined methods of the data storage class |
| CRNA_ref_Base | Rnas *********************************************** |
| CRNAPanel | |
| CRoc_data_point | CRoc_data_point -- |
| CRoc_data_point_Base | CRoc_data_point_Base -- |
| CRootNamespace | CRootNamespace -- |
| CRot_matrix | CRot_matrix -- |
| CRot_matrix_Base | A rotation matrix is defined by 9 numbers, given by row, i.e., with column indices varying fastest |
| CRotatingLogStream | A file stream variant that automatically rotates its output when it grows beyond a specified size |
| CRotatingLogStreamBuf | |
| CRowDisplayStyle | CRowDisplayStyle is a base class representing a display style for IAlignRow |
| python::CRowID | |
| impl::CRowInfo_SP_SQL_Server | |
| CQuery::CRowIterator | Iterator class doing main navigation through result sets |
| CRowSelector | |
| CRowStyleCatalog | CRowStyleCatalog is a collection of CRowDisplayStyle-s assigned to rows in alignment |
| CRPCClient< TRequest, TReply > | CRPCClient -- prototype client for ASN.1/XML-based RPC |
| CRpsAuxFile | This class represents the .aux file in a RPS-BLAST file, which contains information about the scoring matrix to be used during the RPS-BLAST search, the scaling factor, an array of K statistical values (karlin_k), as well as various fields that are currently unused |
| CRPSBlastApp | |
| CRPSBlastAppArgs | Handles command line arguments for blastp binary |
| CRpsFreqsFile | This class represents the .wcounts file in a RPS-BLAST file, which contains the weighted residue frequencies for the database |
| CRpsLookupTblFile | This class represents the .loo file in a RPS-BLAST file, which contains the pre-computed lookup table |
| CRpsMmappedFile | Encapsulates logic of mmap'ing and performing sanity checks on RPS-BLAST database files |
| CRpsObsrFile | This class represents the .obsr file in a RPS-BLAST file, which contains the numbers of independent observations for the database |
| CRpsPssmFile | This class represents the .rps file in a RPS-BLAST file, which contains the PSSMs for the database |
| CRPSTBlastnApp | |
| CRPSTBlastnAppArgs | Handles command line arguments for blastx binary |
| CRPSTBlastnOptionsHandle | Handle to the options for translated nucleotide-RPS blast |
| CRPSThread | |
| CRptTypePanel | |
| CRptUnitRangePanel | |
| CrRNASubPanel | |
| CRs | CRs -- |
| CRs_Base | Defines the docsum structure for refSNP clusters, where a refSNP cluster (rs) is a grouping of individual dbSNP submissions that all refer to the same variation |
| CRSite | This class represents a particular occurrence of a restriction site on a sequence (not to be confused with a CRSpec, which represents a *type* of restriction site) |
| CRsite_ref | CRsite_ref -- |
| CRsite_ref_Base | CRsite_ref_Base -- |
| CRsLinkout | CRsLinkout -- |
| CRsLinkout_Base | Link data for another resource |
| CRSpec | This class represents a restriction enzyme specificity, i.e., a sequence recognition pattern and vectors of cleavage sites on the two strands |
| CRsStruct | CRsStruct -- |
| CRsStruct_Base | Structure information for SNP |
| CRStream | Note about the "buf_size" parameter for streams in this API |
| CRule | CRule -- |
| CRule_Base | CRule_Base -- |
| CRuler | CRuler is a renderable object drawing a scale with position labels |
| CRulerDemoPanel | |
| CRulerPanel | CRulerPanel -- the ruler panel class |
| CRuleToMany | CRuleToMany -- |
| CRuleToMany_Base | CRuleToMany_Base -- |
| CRunOfDigits | |
| CRunPostBuildEvent | CRunPostBuildEvent -- |
| CRunTaskOnWorkerThread | |
| CDBConnectionFactory::CRuntimeData | |
| pythonpp::CRuntimeError | |
| CRunToolDlg | |
| CRunToolDlgTask | CRunToolDlgTask - shows "Run Tool" dialog |
| CRCache::CRVPool | |
| CRWLock | CRWLock -- |
| CRWLockHolder | Holder of the lock inside CYieldingRWLock |
| CRWLockHolder_Pool | Default implementation of IRWLockHolder_Factory |
| CRWStream | Reader-writer based stream |
| CRWStreambuf | Reader-writer based stream buffer |
| cs_diag_msg | |
| cs_diag_msg_client | |
| cs_diag_msg_svr | |
| CSafeParamString | |
| CSafeStatic_Less | Comparison for safe static ptrs |
| CSafeStaticGuard | CSafeStaticGuard:: |
| CSafeStaticLifeSpan | CSafeStaticLifeSpan:: |
| CSafeStaticPtr< T > | CSafeStaticPtr<>:: |
| CSafeStaticPtr_Base | CSafeStaticPtr_Base:: |
| CSafeStaticRef< T > | CSafeStaticRef<>:: |
| CSageData | |
| CSAM_CIGAR_Formatter | |
| CSAM_Formatter | |
| oligofar::CSamBase | |
| oligofar::CSamFormatter | |
| oligofar::CSamMdFormatter | |
| oligofar::CSamMdParser | |
| CSample_enzyme | CSample_enzyme -- |
| CSample_enzyme_Base | Defines the net cleavage specificity of an enzyme, chemical reagent, or a mixture of these, for mass spectrometry purposes |
| CSampleAlnmgrApplication | |
| CSampleAsnApplication | |
| CSampleBasicApplication | |
| CSampleEditSaver | |
| CSampleIdleTask | |
| CSampleJob | NetSchedule sample job |
| CSampleJobCleanupListener | |
| CSampleLds2Application | |
| CSampleLdsApplication | |
| CSampleLibraryObject | |
| CSampleLibtestApplication | |
| CSampleNetCacheClient | Sample application |
| CSampleNetScheduleClient | Sample application |
| CSampleNetScheduleNode | Test application |
| CSampleObjectsApplication | |
| CSampleObjmgrApplication | |
| CSampleSoapClient | |
| CSampleSoapClientApplication | |
| CSampleSoapServerApplication | |
| CSampleTest | |
| oligofar::CSamRecord | |
| oligofar::CSamSource | |
| CSaveDlg | CSaveDlg - a dialog for saving workspace and projects |
| CSaveImagesSetupDlg | |
| CSaveProject_local | |
| CSaveToNetCacheApp | Save a file or stdin to NetCache BLOB |
| CSBlastProgress | Wrapper class for SBlastProgress |
| oligofar::CScanCallback | |
| CScannerEvaluateFunc | The main tree evaluation functor |
| CScannerFunctor | Base class for functions of the evaluation engine |
| CScannerFunctorAND | AND function |
| CScannerFunctorArgN | Base class for N argument functions |
| CScannerFunctorComp | Basic class for all comparison (GT, LT, etc) functors |
| CScannerFunctorEQ | EQ function |
| CScannerFunctorGE | GE function |
| CScannerFunctorGT | GT function |
| CScannerFunctorLE | LE function |
| CScannerFunctorLT | LT function |
| CScannerFunctorNOT | NOT function |
| CScannerFunctorOR | OR function |
| CScatterDataSource< TX, TY > | CScatterDataSource |
| CScatterGraph | Class CScatterGraph |
| CScheduler_ExecThread_Impl | Standalone thread to execute scheduled tasks - implementation |
| CScheduler_ExecutionThread | |
| CScheduler_MT | Thread-safe implementation of IScheduler interface |
| CScheduler_QueueEvent | Class storing full information about scheduled event for task execution |
| CSchedulerEngine | CSchedulerEngine CSchedulerEngine is an engine that can be used with CAppJobDispatcher |
| CSchedulerEngineThread | CSchedulerEngineThread |
| CSchemaVersion | CSchemaVersion -- |
| CScope | CScope -- |
| CScope_Impl | |
| CScope_Mapper_Sequence_Info | |
| CScopeAlnSeqIdConverter< TAlnSeqId > | Scope-aware seq-id converter |
| CScopedObjectsAttachment | |
| CScopedProcess | |
| CScopeInfo_Base | |
| CScopeInfo_Ref< Info > | |
| CScopeInfo_RefBase | |
| CScopeInfoLocker | |
| CValidError_imp::CScopeRestorer | |
| CScopeSource | |
| CScopeTransaction | Scope Transaction |
| CScopeTransaction_Impl | |
| CScore | |
| CScore_3PrimeUnaligned | |
| CScore_AlignLength | |
| CScore_AlignLengthRatio | |
| CScore_AlignStartStop | |
| CScore_Base | Use of Score is discouraged for external ASN.1 specifications |
| CScore_BlastRatio | |
| CScore_CdsInternalStops | |
| CScore_CdsScore | |
| CScore_ExonCount | |
| CScore_FrameShifts | |
| CScore_GapCount | |
| CScore_InternalUnaligned | |
| CScore_LastSpliceSite | |
| CScore_LongestGapLength | |
| CScore_MaxIntronLength | |
| CScore_MinExonLength | |
| CScore_Overlap | |
| CScore_SequenceLength | |
| CScore_set | CScore_set -- |
| CScore_set_Base | Use of Score-set is encouraged for external ASN.1 specifications |
| CScore_StartStopCodon | |
| CScore_SymmetricOverlap | |
| CScore_Taxid | |
| CScore_TblastnScore | |
| CScoreAlignmentDS | CScoreAlignmentDS |
| CScoreBuilder | |
| CScoreBuilderBase | |
| CScoreCache | |
| CScoreLookup | |
| CScorematPssmConverter | Auxiliary class to convert data encoded in the PSSM to CNcbiMatrix |
| CScoreMethodsDlg | |
| oligofar::CScoreParam | |
| CScorePValues | Results of score P-values calculation |
| CScorePValuesCalc | Wrapper for P-values calculation |
| CScorePValuesException | |
| CScorePValuesOptions | Input parameters for P-values calculation |
| oligofar::CScoreTbl | |
| CScoreVector< Key, Score > | |
| oligofar::CScoring | |
| oligofar::CScoringFactory | |
| CScoringJob | CScoringJob |
| CScoringJobResult | CDMSearchResult |
| CScoringMethodsDlg | CScoringMethodsDlg |
| CScoringMethodSelector | |
| CScoringParams | CScoringParams |
| CSDB_ConnectionParam | Convenience class to initialize database connection parameters from URL-like strings and/or application configuration and/or hard-code |
| CSDB_Exception | Exception class used throughout the API |
| CSDBAPI | |
| CSdbapiSimpleApp | |
| CSdbapiTest | |
| CSDustMasker | This class encapsulates the dusting functionality of winmask |
| CSearch< LEGACY, NHITS > | |
| CSearch_Base< LEGACY, NHITS, derived_t > | This is the object representing the state of a search over the index |
| CSearch_database | CSearch_database -- |
| CSearch_database_Base | CSearch_database_Base -- |
| CSearch_func | CSearch_func -- |
| CSearch_func_Base | CSearch_func_Base -- |
| CSearch_hit | CSearch_hit -- |
| CSearch_hit_Base | Peptide assignment |
| CSearch_result | CSearch_result -- |
| CSearch_result_Base | CSearch_result_Base -- |
| CSearch_score | CSearch_score -- |
| CSearch_score_Base | CSearch_score_Base -- |
| CSearch_score_summary | CSearch_score_summary -- |
| CSearch_score_summary_Base | CSearch_score_summary_Base -- |
| CSearch_summary | CSearch_summary -- |
| CSearch_summary_Base | Database search settings |
| CSearchControl | CSearchControl |
| CSearchDatabase | Blast Search Subject |
| CSearchException | Exception class |
| CSearchFormBase | CSearchFormBase |
| CSearchHelper | Class to hold various helper functions for CSearch |
| CSearchJobBase | CSearchJobBase |
| CSearchMessage | Error or Warning Message from search |
| CSearchQueryBase | CSearchQueryBase |
| CSearchQueryNull | A variant of IDMSearchQuery with a dummy search string (not advised for real use) |
| CDbIndex::CSearchResults | This class represents a set of seeds obtained by searching all subjects represented by the index |
| CSearchResults | Search Results for One Query |
| CSearchResultSet | Search Results for All Queries |
| CSearchStrategyArgs | Argument class to import/export the search strategy |
| CSearchToolBase | CSearchToolBase |
| CSecureScoping | CSecureScoping -- |
| CSeedRoots | Seed roots container for all subjects |
| CSeedTop | |
| CSeedTopApp | |
| CSeg_ext | CSeg_ext -- |
| CSeg_ext_Base | CSeg_ext_Base -- |
| CSegMasker | This class encapsulates the SEG filtering algorithm |
| CSeqMap::CSegment | |
| CSegmentConfig | CSegmentConfig |
| CSegmentedRangeCollection | |
| CSegmentGlyph | |
| CSegmentItem | |
| CSegmentMapTrack | CSegmentMapTrack -- |
| CSegmentMapTrackFactory | CSegmentMapTrackFactory |
| CSegmentSmearGlyph | |
| python::CSelectConnPool | |
| CSelectDescription | |
| CSelectFeatureDlg | |
| CSelection | |
| CSelectionControl | |
| CSelectionEvent | CSelectionEvent CSelectionEvent is used for broadcasting selection between views |
| CSelectionHelper | |
| CSelectionPanel | CSelectionPanel |
| CSelectionService | CSelectionService |
| CSelectionServiceUpdate | |
| CSelectionView | CSelectionView |
| CSelectionViewEventHandler | |
| CSelectionViewFactory | CSelectionViewFactory |
| CSelectionVisitor | Class CSelectionVisitor is a concrete glyph visitor for selection traversal and deselection traversal on a layout tree |
| CSelFeatHandle | CSelFeatHandle |
| CSelListController< Item > | Class CSelListController |
| CSelListModelImpl< Item > | CSelListModelImpl provides a defult implementation of ISelListModel |
| CSelNodeHandle | |
| CSelRowHandle | |
| CSemaphore | CSemaphore -- |
| CSemiChymotrypsin | Chymotrypsin, cuts N terminal at A,F,I,L,M or V |
| CSemiGluC | Glu-C, Cterm of E |
| CSemiTryptic | EMSEnzymes_semi_tryptic semi tryptic search (one end of peptide has to be tryptic) |
| impl::CSendDataCmd | |
| CSeq_align | |
| CSeq_align_Base | CSeq_align_Base -- |
| CSeq_align_Handle | |
| CSeq_align_Mapper | |
| CSeq_align_Mapper_Base | Class used to map seq-alignments |
| CSeq_align_set | |
| CSeq_align_set_Base | Sequence Alignment ******************************** |
| CSeq_align_setHandler | |
| CSeq_alignHandler | |
| CSeq_annot | |
| CSeq_annot_Add_EditCommand< Handle > | |
| CSeq_annot_Base | Features in table form |
| CSeq_annot_CI | CSeq_annot_CI -- |
| CSeq_annot_EditHandle | |
| CSeq_annot_Finder | |
| CSeq_annot_ftable_CI | |
| CSeq_annot_ftable_I | |
| CSeq_annot_Handle | CSeq_annot_Handle -- |
| CSeq_annot_Info | |
| CSeq_annot_Remove_EditCommand< Handle > | |
| CSeq_annot_Replace_EditCommand< Handle > | |
| CSeq_annot_ScopeInfo | |
| CSeq_annot_SNP_Info | |
| CSeq_annot_SNP_Info_Reader | |
| CSeq_annot_SplitInfo | |
| CSeq_annotHandler | |
| CSeq_bond | |
| CSeq_bond_Base | Bond between residues |
| CSeq_code_set | CSeq_code_set -- |
| CSeq_code_set_Base | For distribution |
| CSeq_code_table | CSeq_code_table -- |
| CSeq_code_table_Base | For names of coded values |
| CSeq_data | |
| CSeq_data_Base | Various internal sequence representations ************ all are controlled, fixed length forms sequence representations |
| CSeq_data_SplitInfo | |
| CSeq_descr | .hpp User-defined methods of the data storage class |
| CSeq_descr_Base | Descriptors ***************************** |
| CSeq_descr_CI | CSeq_descr_CI -- |
| CSeq_descr_SplitInfo | |
| CSeq_entry | |
| CSeq_entry_Base | CSeq_entry_Base -- |
| CSeq_entry_CI | CSeq_entry_CI -- |
| CSeq_entry_EditHandle | CSeq_entry_Handle -- |
| CSeq_entry_Handle | CSeq_entry_Handle -- |
| CSeq_entry_I | CSeq_entry_I -- |
| CSeq_entry_Info | |
| CSeq_entry_Remove_EditCommand | |
| CSeq_entry_ScopeInfo | |
| CSeq_entry_Select_EditCommand< Handle, Data > | |
| CSeq_entry_SelectNone_EditCommand | |
| CSeq_entryHandler | |
| CSeq_ext | CSeq_ext -- |
| CSeq_ext_Base | Sequence Extensions ********************************** for representing more complex types const type uses Seq-hist.assembly |
| CSeq_feat | Namespace ncbi::objects:: |
| CSeq_feat_Base | Seq-feat ******************************************* sequence feature generalization |
| CSeq_feat_Descr | CSeq_feat_Descr |
| CSeq_feat_EditHandle | CSeq_feat_EditHandle -- |
| CSeq_feat_Handle | CSeq_feat_Handle -- |
| CSeq_featChangedEvent | Class CSeq_featChangedEvent provides an interface for notifying classes that a feature or set of features have changed |
| CSeq_featHandler | |
| CSeq_gap | CSeq_gap -- |
| CSeq_gap_Base | CSeq_gap_Base -- |
| CSeq_graph | |
| CSeq_graph_Base | Sequence Graph ******************************** |
| CSeq_graph_Handle | |
| CSeq_hist | CSeq_hist -- |
| CSeq_hist_Base | Sequence History Record *********************************** assembly = records how seq was assembled from others replaces = records sequences made obsolete by this one replaced-by = this seq is made obsolete by another(s) |
| CSeq_hist_rec | CSeq_hist_rec -- |
| CSeq_hist_rec_Base | CSeq_hist_rec_Base -- |
| CSeq_hist_SplitInfo | |
| CSeq_id | |
| CSeq_id_Base | Sequence identifiers ******************************** |
| CSeq_id_Descr | |
| CSeq_id_GB_Tree | |
| CSeq_id_General_Id_Info | |
| CSeq_id_General_Str_Info | |
| CSeq_id_General_Tree | |
| CSeq_id_Gi_Info | |
| CSeq_id_Gi_Tree | |
| CSeq_id_Gibbmt_Tree | |
| CSeq_id_Gibbsq_Tree | |
| CSeq_id_Giim_Tree | |
| CSeq_id_Gpipe_Tree | |
| CSeq_id_Handle | |
| CSeq_id_Info | |
| CSeq_id_InfoLocker | |
| CSeq_id_int_Tree | |
| CSeq_id_Local_Tree | |
| CSeq_id_Mapper | |
| CSeq_id_Named_annot_track_Tree | |
| CSeq_id_not_set_Tree | |
| CSeq_id_Other_Tree | |
| CSeq_id_Patent_Tree | |
| CSeq_id_PDB_Tree | |
| CSeq_id_Pir_Tree | |
| CSeq_id_Prf_Tree | |
| CSeq_id_Resolver | A helper class to convert a string to a seq-id |
| CSeq_id_Resolver__CCDS | Resolve CCDS-id to an NM |
| CSeq_id_Resolver__ChrNamesFromGC | Resolve chromosome names based on GC_Assembly |
| CSeq_id_Resolver__LRG | Resolve LRG seq-ids, e.g. LRG_123, LRG_123t1, LRG_123p1 |
| CSeq_id_set | CSeq_id_set -- |
| CSeq_id_set_Base | CSeq_id_set_Base -- |
| CSeq_id_Swissprot_Tree | |
| CSeq_id_Textseq_Info | |
| CSeq_id_Textseq_Tree | |
| CSeq_id_Tpd_Tree | |
| CSeq_id_Tpe_Tree | |
| CSeq_id_Tpg_Tree | |
| CSeq_id_Which_Tree | |
| CSeq_idHandler | |
| CSeq_idValidator | |
| CSeq_inst | |
| CSeq_inst_Base | Instances of sequences ******************************* |
| CSeq_inst_SplitInfo | |
| CSeq_interval | |
| CSeq_interval_Base | CSeq_interval_Base -- |
| CSeq_literal | CSeq_literal -- |
| CSeq_literal_Base | CSeq_literal_Base -- |
| CSeq_loc | |
| CSeq_loc_Base | Sequence locations ********************************** |
| CSeq_loc_CI | Seq-loc iterator class -- iterates all intervals from a seq-loc in the correct order |
| CSeq_loc_CI_Impl | |
| CSeq_loc_Conversion | |
| CSeq_loc_Conversion_Set | |
| CSeq_loc_equiv | |
| CSeq_loc_equiv_Base | For a set of equivalent locations |
| CSeq_loc_Mapper | CSeq_loc_Mapper -- |
| CSeq_loc_Mapper_Base | CSeq_loc_Mapper_Base -- |
| CSeq_loc_mix | |
| CSeq_loc_mix_Base | This will hold anything |
| CSeq_locHandler | |
| CSeq_map_table | CSeq_map_table -- |
| CSeq_map_table_Base | For tables of sequence mappings |
| CSeq_point | |
| CSeq_point_Base | CSeq_point_Base -- |
| CSeq_submit | |
| CSeq_submit_Base | Deletions of entries |
| CSeq_table | CSeq_table -- |
| CSeq_table_Base | CSeq_table_Base -- |
| CSeq_test_result | CSeq_test_result -- |
| CSeq_test_result_Base | CSeq_test_result_Base -- |
| CSeq_test_result_set | CSeq_test_result_set -- |
| CSeq_test_result_set_Base | CSeq_test_result_set_Base -- |
| CSeqAlignCmp | Class to perform BLAST sequence alignment comparisons |
| CSeqAlignCmpOpts | Configuration options for CSeqAlignCmp class |
| CSeqAlignContainer | |
| CSeqAlignFilter | CSeqAlignFilter |
| CSeqAlignSeqIdVec< TSeqAlignVec, TSeqIdPtrComp, TSeqIdPtr > | Implementation includes |
| CSeqAnnotFromFasta | |
| CSeqAnnotSplicerApp | |
| CSeqAnnotSplicerStats | |
| oligofar::CSeqBuffer | |
| oligofar::CSeqCoding | |
| CSeqConvert | |
| CSeqConvert_imp | |
| CSequenceIStream::CSeqData | Type containing the sequence itself along with the masking information |
| CSeqDB | CSeqDB |
| CSeqDB_AliasExplorer | CSeqDBAliasExplorer class |
| CSeqDB_AliasMask | Something else yet again etc |
| CSeqDB_AliasWalker | CSeqDBAliasWalker class |
| CSeqDB_AtlasAccessor | Check file existence using CSeqDBAtlas |
| CSeqDB_AtlasRegionHolder | Hold a memory region refcount, return to atlas when destroyed |
| CSeqDB_BaseName | CSeqDB_BaseName |
| CSeqDB_BasePath | CSeqDB_BasePath |
| CSeqDB_BitSet | Bit set class |
| CSeqDB_ColumnEntry | Database-wide column information |
| CSeqDB_ColumnReader | Reader for BlastDb format column files |
| CSeqDB_DirName | CSeqDB_DirName |
| CSeqDB_FileExistence | File existence test interface |
| CSeqDB_FileName | CSeqDB_FileName |
| CSeqDB_FilterTree | Tree of nodes describing filtering of database sequences |
| CSeqDB_IdListValuesTest | Test for completeness of GI list alias file values |
| CSeqDB_IdRemapper | Map user algorithm IDs to volume algorithm IDs |
| CSeqDB_MaxLengthWalker | Walker for MAX_SEQ_LENGTH field of alias file |
| CSeqDB_MembBitWalker | Walker for membership bit |
| CSeqDB_MinLengthWalker | |
| CSeqDB_NOIDsWalker | Walker for OID count accumulation |
| CSeqDB_NSeqsStatsWalker | Walker for STATS_NSEQ field of alias file |
| CSeqDB_NSeqsWalker | Walker for NSEQ field of alias file |
| CSeqDB_Path | CSeqDB_Path |
| CSeqDB_SimpleAccessor | Check file existence using CFile |
| CSeqDB_SortGiLessThan | Compare SGiOid structs by GI |
| CSeqDB_SortOidLessThan | Compare SGiOid structs by OID |
| CSeqDB_SortSiLessThan | Compare SSeqIdOid structs by SeqId |
| CSeqDB_SortTiLessThan | Compare SGiOid structs by GI |
| CSeqDB_Substring | String slicing |
| CSeqDB_TitleWalker | Walker for TITLE field of alias file |
| CSeqDB_TotalLengthStatsWalker | Walker for total length stats accumulation |
| CSeqDB_TotalLengthWalker | Walker for total length accumulation |
| CSeqDB_VolumeLengthWalker | Walker for volume length accumulation |
| CSeqDBAliasFile | CSeqDBAliasFile class |
| CSeqDBAliasNode | CSeqDBAliasNode class |
| CSeqDBAliasSets | CSeqDBAliasSets class |
| CSeqDBAliasStack | CSeqDBAliasStack |
| CSeqDBAtlas | CSeqDBAtlas class |
| CSeqDBAtlasHolder | Guard object for the SeqDBAtlas singleton |
| CSeqDBAutoFree | Simple idiom for RIIA with malloc + free |
| CSeqDBBitVector | CSeqDBBitVector |
| CSeqDBColumn | CSeqDBColumn class |
| CSeqDBColumnFlush | CSeqDBColumnFlush class |
| CSeqDBDemo_ChunkIteration | Demo for chunk iteration methods |
| CSeqDBDemo_GetSequence | Demo for GetSequence() methods |
| CSeqDBDemo_SeqidToBioseq | Demo for fetching a bioseq from a seqid methods |
| CSeqDBDemo_SimpleIteration | Demo for simple (single threaded) iteration methods |
| CSeqDBException | CSeqDBException |
| CSeqDBExpert | CSeqDBExpert |
| CSeqDBExtFile | Database component file |
| CSeqDBFileGiList | CSeqDBFileGiList |
| CSeqDBFlushCB | CSeqDBFlushCB |
| CSeqDBGiIndex | CSeqDBGiIndex |
| CSeqDBGiList | CSeqDBGiList |
| CSeqDBGiListSet | CSeqDBGiListSet class |
| CSeqDBGiMask | CSeqDBGiMask class |
| CSeqDBHdrFile | Header file |
| CSeqDBIdSet | SeqDB ID list for performing boolean set operations |
| CSeqDBIdSet_Vector | Helper class to allow copy-on-write semantics for CSeqDBIdSet |
| CSeqDBIdxFile | Index file |
| CSeqDBImpl | CSeqDBImpl class |
| CSeqDBImplFlush | CSeqDBImplFlush class |
| CSeqDBIntCache< TValue > | Simple int-keyed cache |
| CSeqDBIsam | CSeqDBIsam |
| CSeqDBIter | CSeqDBIter |
| CSeqDBLockHold | CSeqDBLockHold |
| CSeqDBMapStrategy | CSeqDBMapStrategy |
| CSeqDBMemLease | CSeqDBMemLease |
| CSeqDBMemReg | CSeqDBMemReg |
| CSeqDBMovingAverage | CSeqDBMovingAverage |
| CSeqDBNegativeList | CSeqDBNegativeList |
| CSeqDBNodeFileIdList | CSeqDBNodeIdList |
| CSeqDBOIDList | CSeqDBOIDList |
| CSeqDBRangeList | CSeqDBRangeList |
| CSeqDBRawFile | Raw file |
| CSeqDBSeqFile | Sequence data file |
| CSeqDbSeqInfoSrc | Implementation of the IBlastSeqInfoSrc interface to encapsulate retrieval of sequence identifiers and lengths from a BLAST database |
| CSeqDBSequence | CSeqDBSequence -- |
| CSeqDbSrcNewArgs | Encapsulates the arguments needed to initialize CSeqDB |
| CSeqDBTaxId | CSeqDBTaxId class |
| CSeqDBTaxInfo | CSeqDBTaxInfo class |
| CSeqDBVol | CSeqDBVol class |
| CSeqDBVolEntry | CSeqDBVolEntry |
| CSeqDBVolSet | CSeqDBVolSet |
| oligofar::CSeqIds::CSeqDef | |
| CSeqdesc | |
| CSeqdesc_Base | CSeqdesc_Base -- |
| CSeqdesc_CI | CSeqdesc_CI -- |
| CSeqDescrRetrievalJob | CSeqDescrRetrievalJob - class |
| CSeqdescTitleEdit | |
| CSeqEdit_Cmd | |
| CSeqEdit_Cmd_AddAnnot | CSeqEdit_Cmd_AddAnnot -- |
| CSeqEdit_Cmd_AddAnnot_Base | Add an annotaion object to a bioseq or a bioseq-set |
| CSeqEdit_Cmd_AddDesc | CSeqEdit_Cmd_AddDesc -- |
| CSeqEdit_Cmd_AddDesc_Base | Add a descriptor ot an object |
| CSeqEdit_Cmd_AddDescr | CSeqEdit_Cmd_AddDescr -- |
| CSeqEdit_Cmd_AddDescr_Base | Add descriptors to an object |
| CSeqEdit_Cmd_AddId | CSeqEdit_Cmd_AddId -- |
| CSeqEdit_Cmd_AddId_Base | Add a new seq-id to bioseq |
| CSeqEdit_Cmd_AttachAnnot | CSeqEdit_Cmd_AttachAnnot -- |
| CSeqEdit_Cmd_AttachAnnot_Base | Add an annotation to a bioseq or a bioseq-set |
| CSeqEdit_Cmd_AttachSeq | CSeqEdit_Cmd_AttachSeq -- |
| CSeqEdit_Cmd_AttachSeq_Base | Attach a bioseq to seq entry |
| CSeqEdit_Cmd_AttachSeqEntry | CSeqEdit_Cmd_AttachSeqEntry -- |
| CSeqEdit_Cmd_AttachSeqEntry_Base | Attach a seq entry to bioseq-set |
| CSeqEdit_Cmd_AttachSet | CSeqEdit_Cmd_AttachSet -- |
| CSeqEdit_Cmd_AttachSet_Base | Attach a bioseq-set to seq entry |
| CSeqEdit_Cmd_Base | CSeqEdit_Cmd_Base -- |
| CSeqEdit_Cmd_ChangeSeqAttr | CSeqEdit_Cmd_ChangeSeqAttr -- |
| CSeqEdit_Cmd_ChangeSeqAttr_Base | Change bioseq's attribure |
| CSeqEdit_Cmd_ChangeSetAttr | CSeqEdit_Cmd_ChangeSetAttr -- |
| CSeqEdit_Cmd_ChangeSetAttr_Base | Change bioseq-set's attribute |
| CSeqEdit_Cmd_RemoveAnnot | CSeqEdit_Cmd_RemoveAnnot -- |
| CSeqEdit_Cmd_RemoveAnnot_Base | Remove an annotation object from a bioseq or a bioseq-set |
| CSeqEdit_Cmd_RemoveDesc | CSeqEdit_Cmd_RemoveDesc -- |
| CSeqEdit_Cmd_RemoveDesc_Base | Remove a descripor from an object |
| CSeqEdit_Cmd_RemoveId | CSeqEdit_Cmd_RemoveId -- |
| CSeqEdit_Cmd_RemoveId_Base | Remove a seq-id from bioseq |
| CSeqEdit_Cmd_RemoveSeqEntry | CSeqEdit_Cmd_RemoveSeqEntry -- |
| CSeqEdit_Cmd_RemoveSeqEntry_Base | Remove a seq entry from bioseq-set |
| CSeqEdit_Cmd_ReplaceAnnot | CSeqEdit_Cmd_ReplaceAnnot -- |
| CSeqEdit_Cmd_ReplaceAnnot_Base | Replace an annotation object of a bioseq or a bioseq-set |
| CSeqEdit_Cmd_ResetDescr | CSeqEdit_Cmd_ResetDescr -- |
| CSeqEdit_Cmd_ResetDescr_Base | Reset an objects's descriptors |
| CSeqEdit_Cmd_ResetIds | CSeqEdit_Cmd_ResetIds -- |
| CSeqEdit_Cmd_ResetIds_Base | Reset ids field of bioseq |
| CSeqEdit_Cmd_ResetSeqAttr | CSeqEdit_Cmd_ResetSeqAttr -- |
| CSeqEdit_Cmd_ResetSeqAttr_Base | Reset bioseq's attribute |
| CSeqEdit_Cmd_ResetSeqEntry | CSeqEdit_Cmd_ResetSeqEntry -- |
| CSeqEdit_Cmd_ResetSeqEntry_Base | Detach an object from seq entry |
| CSeqEdit_Cmd_ResetSetAttr | CSeqEdit_Cmd_ResetSetAttr -- |
| CSeqEdit_Cmd_ResetSetAttr_Base | Reset bioseq-set's attibute |
| CSeqEdit_Cmd_SetDescr | CSeqEdit_Cmd_SetDescr -- |
| CSeqEdit_Cmd_SetDescr_Base | Set an objects's descriptors |
| CSeqEdit_Id | CSeqEdit_Id -- |
| CSeqEdit_Id_Base | CSeqEdit_Id_Base -- |
| CSeqEditPackage | Declare the Package Object |
| CSeqEntryPresenter | |
| CSeqEntryProcess | |
| CSeqEntrySource | |
| CSeqFeatData | |
| CSeqFeatData_Base | CSeqFeatData_Base -- |
| CSeqFeatRemoveDlg | |
| CSeqFeatSupport | CSeqFeatSupport -- |
| CSeqFeatSupport_Base | CSeqFeatSupport_Base -- |
| CSeqFeatXref | CSeqFeatXref -- |
| CSeqFeatXref_Base | Both optional because can have one or both |
| CSeqFetchQueue | |
| CSeqFormatter | Customizable sequence writer interface |
| CSeqFormatterConfig | Configuration object for CSeqFormatter |
| CSeqGlyph | Class CSeqGlyph defines an interface that wraps a rectilinear abstract object |
| CSeqGraphicColorConfig | |
| CSeqGraphicColorConfigWrite | |
| CSeqGraphicConfig | |
| CSeqGraphicConfigMediator | |
| CSeqGraphicConfigPanel | |
| CSeqGraphicDemoApp | Derive our application class from CwxNCBIApp and use it together with standard CNCBIwxApplication |
| CSeqGraphicDemoDlg | |
| CSeqGraphicJob | CSeqGraphicJob -- the base class of seqgraphic job for handling the job status such as reporting the progress and returning the result |
| CSeqGraphicPane | Class CSeqGraphicPane |
| CSeqGraphicPreview | |
| CSeqGraphicRenderer | |
| CSeqGraphicWidget | |
| CSeqIdAlignBitmap< TSeqAlignSeqIdVec > | Seq-id to Seq-align map |
| CSeqIdBioseqHandleComp< TSeqIdPtr > | |
| CSeqIdDictionary | |
| CSeqIdEquals | |
| CSeqIdException | CSeqIdException -- |
| CSeqIdFromHandleException | |
| CSeqIdGenerator | |
| CSeqIdList | |
| CSeqIdListSet | |
| oligofar::CSeqIds | |
| pythonpp::CSeqIterator | |
| CSeqLocFormBase | |
| CSeqLocInfo | Structure for seqloc info |
| CBestFeatFinder::CSeqLocSort | |
| CSeqLocToolBase | CSeqLocToolBase |
| CSeqManip | |
| CSeqMap | CSeqMap -- |
| CSeqMap_CI | Iterator over CSeqMap |
| CSeqMap_CI_SegmentInfo | |
| CSeqMapException | SeqMap related exceptions |
| CSeqMapSwitchPoint | |
| CSeqMarkHandler | Class CSeqMarkHandler represents in GUI a single "hairpin" on a sequence bar |
| CSeqMasker | Main interface to window based masker functionality |
| CSeqMaskerCacheBoost | Interface to the bit array used to check if the score of a unit is below t_extend |
| CSeqMasker::CSeqMaskerException | Represents different error situations that can occur in the masking process |
| CSeqMaskerIstat | Defines an interface for accessing the unit counts information |
| CSeqMaskerIstatAscii | Unit counts read from an ascii file |
| CSeqMaskerIstatBin | Read counts information from a binary file |
| CSeqMaskerIstatFactory | Factory class to generate an appropriate CSeqMaskerIstat derived class based on the format name |
| CSeqMaskerIstatOAscii | Unit counts read from an ascii file in optimized form |
| CSeqMaskerIstatOBinary | Read counts information from a binary file in optimized format |
| CSeqMaskerOstat | Base class for computing and saving unit counts data |
| CSeqMaskerOstatAscii | Class responsible for creation of unit counts statistics in text format |
| CSeqMaskerOstatAscii::CSeqMaskerOstatAsciiException | Exceptions that CSeqMaskerOstatAscii might throw |
| CSeqMaskerOstatBin | Compute and save counts information in simple binary format |
| CSeqMaskerOstat::CSeqMaskerOstatException | Exceptions that CSeqMaskerOstat can throw |
| CSeqMaskerOstatFactory | Factory of CSeqMaskerOstat objects |
| CSeqMaskerOstatFactory::CSeqMaskerOstatFactoryException | Exceptions that CSeqMaskerOstatFactory might throw |
| CSeqMaskerOstatOpt | Class responsible for collecting unit counts statistics and representing it in optimized hash-based format |
| CSeqMaskerOstatOptAscii | This class is responsible for saving optimized unit counts in text format |
| CSeqMaskerOstatOptBin | This class is responsible for saving optimized unit counts in binary format |
| CSeqMaskerScore | Abstract base class for score function objects |
| CSeqMaskerScoreMean | Score function object computing mean of unit in a window |
| CSeqMaskerScoreMeanGlob | Average unit score form the start of the sequence to the end of current window |
| CSeqMaskerScoreMin | The score function object that computes maxmin of k consecutive units in a window |
| CSeqMaskerUsetArray | Unit counts container based on simple arrays |
| CSeqMaskerUsetHash | This class encapsulates the implementation of the hash based container for unit counts |
| CSeqMaskerUsetSimple | This class implements simple, unoptimized unit counts container |
| CSeqMaskerUtil | Collection of various support utilities |
| CSeqMaskerWindow | Sliding window skipping over the ambiguities |
| CSeqMaskerWindowAmbig | Windows with units that may contain ambiguities |
| CSeqMaskerWindowPattern | Window iterator used for discontiguous units |
| CSeqMaskerWindowPatternAmbig | Window iterator for discontiguous units used for the merging pass |
| CSeqMatch | This class provides functions for determining where sequences, perhaps containing ambiguity codes, must or can match patterns |
| CSeqPackage | Declare the Package Object |
| CSeqportUtil | |
| CSeqportUtil_implementation | |
| CSeqref | |
| oligofar::CSeqScanner | |
| CSeqScores | |
| CSeqSearch | ============================================================================// Sequence Search // ============================================================================// |
| CSeqsetException | |
| CSeqsetParseException | |
| CSeqSetPresenter | |
| CSeqShortText | |
| CSeqsRange | |
| CSeqTable_column | |
| CSeqTable_column_Base | CSeqTable_column_Base -- |
| CSeqTable_column_info | |
| CSeqTable_column_info_Base | CSeqTable_column_info_Base -- |
| CSeqTable_multi_data | |
| CSeqTable_multi_data_Base | CSeqTable_multi_data_Base -- |
| CSeqTable_single_data | CSeqTable_single_data -- |
| CSeqTable_single_data_Base | CSeqTable_single_data_Base -- |
| CSeqTable_sparse_index | |
| CSeqTable_sparse_index_Base | CSeqTable_sparse_index_Base -- |
| CSeqTableColumnInfo | |
| CSeqTableGraphTrack | CSeqTableGraphTrack -- |
| CSeqTableGraphTrackFactory | CSeqTableGraphTrackFactory |
| CSeqTableInfo | |
| CSeqTableLocColumns | |
| CSeqTableNextObject | |
| CSeqTableNextObjectChoiceVariant | |
| CSeqTableNextObjectClassMember | |
| CSeqTableNextObjectElementNew | |
| CSeqTableNextObjectPointer | |
| CSeqTableNextObjectPtrElementNew | |
| CSeqTableNextObjectUserField | |
| CSeqTableSetAnyFeatField | |
| CSeqTableSetAnyLocField | |
| CSeqTableSetAnyObjField | |
| CSeqTableSetComment | |
| CSeqTableSetDataImpKey | |
| CSeqTableSetDataRegion | |
| CSeqTableSetDbxref | |
| CSeqTableSetExt | |
| CSeqTableSetExtType | |
| CSeqTableSetFeatField | |
| CSeqTableSetLocField | |
| CSeqTableSetLocFuzzFromLim | |
| CSeqTableSetLocFuzzToLim | |
| CSeqTableSetQual | |
| CSeqTest | Class CSeqTest provides a general API for performing a given test on |
| CSeqTestApplication | |
| CSeqTestContext | CSeqTestContext defines any contextual information that a derived class might need |
| CSeqTestManager | |
| CSeqTestResults | CSeqTestResults -- |
| CSeqTestResults_Base | CSeqTestResults_Base -- |
| CSeqTextConfig | |
| CSeqTextDataSource | CSeqTextDataSource implements Adapter design pattern |
| CSeqTextDefs | Class CSeqTextDefs |
| CSeqTextDemoApp | Derive our application class from CwxNCBIApp and use it together with standard CNCBIwxApplication |
| CSeqTextDemoDlg | |
| CSeqTextDlg | |
| CSeqTextFontList | |
| CSeqTextJob | CSeqTextJob |
| CSeqTextJobResult | CSeqTextJobResult |
| CSeqTextPane | Class CSeqTextPane |
| CSeqTextPaneConfig | |
| CSeqTextPanel | |
| CSeqTextVariationGraph | Class CSeqTextVariationGraph |
| CSeqTextView | CSeqTextView |
| CSeqTextViewFactory | CSeqTextViewFactory |
| CSeqTextWidget | Class CSeqTextWidget |
| CSeqTranslator | |
| CSeqTree_node | CSeqTree_node -- |
| CSeqTree_node_Base | CSeqTree_node_Base -- |
| CSequence | Class for representing protein sequences |
| CSequence_constraint | CSequence_constraint -- |
| CSequence_constraint_Base | CSequence_constraint_Base -- |
| CSequence_constraint_mol_type_constraint | CSequence_constraint_mol_type_constraint -- |
| CSequence_constraint_mol_type_constraint_Base | CSequence_constraint_mol_type_constraint_Base -- |
| CSequence_list | CSequence_list -- |
| CSequence_list_Base | CSequence_list_Base -- |
| CSequence_list_choice | CSequence_list_choice -- |
| CSequence_list_choice_Base | CSequence_list_choice_Base -- |
| CSequence_search_constraint | CSequence_search_constraint -- |
| CSequence_search_constraint_Base | Required amino acid string |
| CSequence_tree | CSequence_tree -- |
| CSequence_tree_Base | Record sequence trees generated by a suitable algorithm |
| CSequenceDataTester | |
| CLDS_Query::CSequenceFinder | Utility class to search sequences |
| CSequenceGotoData | |
| CSequenceGotoDlg | |
| CSequenceGotoEvent | |
| CSequenceGroup | |
| CSequenceInputStats | |
| CSequenceIStream | Class used to abstract reading nucleotide sequences from various sources |
| CSequenceIStream::CSequenceIStream_Exception | Class representing error conditions in the sequence stream |
| CSequenceIStreamBlastDB | Sequence stream that reads BLAST nucleotide databases |
| CSequenceIStreamFasta | Sequence stream for reading FASTA formatted files |
| CSequenceItem | |
| CSequenceOfInt | CSequenceOfInt -- |
| CSequenceOfInt_Base | CSequenceOfInt_Base -- |
| CSequenceOfTypeInfo | |
| CSequenceOfTypeInfoFunctions | |
| CSequenceOfTypeInfoFunctionsCI | |
| CSequenceOfTypeInfoFunctionsI | |
| CSequenceReturn | |
| CSequenceSearchForm | |
| CSequenceSearchJob | CSequenceSearchJob |
| CSequenceSearchQuery | CSequenceSearchTool |
| CSequenceSearchTool | CSequenceSearchTool |
| CSequenceTextGraph | CSequenceTextGraph |
| CSequenceTickGraph | CSequenceTickGraph |
| CSequenceTrack | CSequenceTrack -- the layout track for holding and visualizing a molecule sequence superimposed by component map |
| CSequenceTrackFactory | CSequenceTrackFactory |
| pythonpp::CSequnceHelper< T > | |
| pythonpp::CSequnceProxy< T > | |
| CSeqUtil | |
| CSeqUtilException | |
| CSeqUtils | |
| oligofar::CSeqVecProcessor | |
| CSeqVecSeqInfoSrc | Implementation of the IBlastSeqInfoSrc interface to encapsulate retrieval of sequence identifiers and lengths from a vector of Seq-locs |
| CSeqVector | CSeqVector -- |
| CSeqVector_CI | |
| CSeqVectorException | SeqVector related exceptions |
| CSeqVectorTypes | |
| CSerial_FilterObjectsHook< TObject > | Helper hook for Serial_FilterObjects function template; User hook class should be derived from this base class |
| CSerial_FilterReadObjectsHook< TObject > | |
| CSerialAttribInfoItem | XML attribute information item |
| CSerialBoolValidator | |
| CSerialEnumValidator | |
| CSerialException | Root class for all serialization exceptions |
| CSerializable | |
| CSerialMemberValidator | |
| CSerialObject | Base class for all serializable objects |
| CSerialStringListValidator | |
| CSerialTextValidator | |
| CSerialTitleValidator | |
| CSerialUserOp | Base class for user-defined serializable classes to allow for objects assignment and comparison |
| CSeriesBase | Class CSeriesBase CSeries represents a set of colinear IDataArrays and provides basic access and management |
| CServer | CServer:: |
| CServer_Connection | |
| CServer_ConnectionFactory< TServer_ConnectionHandler > | CServer_ConnectionFactory:: |
| CServer_ConnectionPool | |
| CServer_ControlConnection | |
| CServer_Exception | CServer_Exception:: |
| CServer_Listener | |
| CServer_Monitor | Server monitor |
| CServer_Request | |
| CServerConnectionRequest | |
| CService | CService -- |
| CServiceThread | Thread class, prints the statistics counters and makes decision about shutdown in case if draining was requested |
| CSetOfTypeInfo | |
| CSettingsSet | CSettingsSet is an adapter of the CGuiRegistry to provide persistance of and easy access to view's (or other plugins') configuration settings |
| CSetTypeStrings | |
| CSetupFactory | Auxiliary class to create the various C structures to set up the preliminary and/or traceback stages of the search |
| CSetValue_EditCommand< TEditHandle, T > | |
| CSFTransDS | CSFTransDS - Six-frames translation data source |
| CSFTransDSType | CSFTransDSType - Six-frames translation data source type |
| CSFTranslationJob | CSFTranslationJob - Graphical view six-frame translation job |
| CSGAlignmentDS | |
| CSGAlignmentDSType | |
| CSGAlignmentJob | CSGAlignmentJob |
| CSGAlignScoringJob | CSGAlignScoreJob |
| CSGAlignStatJob | CSGAlignStatJob |
| CSGAnnotJob | CSGAnnotJob -- Job based on SAnnotSelector for loading data using ObjectManager |
| CSGCalcFeatHistJob | CSGCalcFeatHistJob |
| CSGConfigUtils | |
| CSGDataSource | Default seqgraphic data source implementation |
| CSGDataSourceContext | |
| CSGFeatureDS | CSGFeatureDS |
| CSGFeatureDSType | CSGFeatureDSType |
| CSGFeatureJob | CSGFeatureJob: a job class for loading annotated features from a given sequence and visible range |
| CSGGapDS | |
| CSGGapDSType | |
| CSGGenBankDS | CSGGenBankDS |
| CSGGraphDS | CSGGraphDS |
| CSGGraphDSType | CSGGraphDSType |
| CSGHapmapDS | |
| CSGHapmapDSType | |
| CSGJobResult | CSGJobResult -- the data structure holding the seqgraphic job results |
| CSGQueryFunctionCompare | Class CSGQueryFunctionCompare |
| CSGQueryFunctionLogic | Class CSGQueryFunctionLogic |
| CSGQueryFunctionValue | Class CSGQueryFunctionValue |
| CSGQueryNodePreprocessor | Class CSGQueryNodePreprocessor |
| CSGQueryNodeValue | Class CQueryNodeValue |
| CSGSegmentMapDS | CSGSegmentMapDS |
| CSGSegmentMapDSType | CSGFeatureDSType |
| CSGSegmentMapJob | CSGSegmentMapJob declaration |
| CSGSegmentSmearJob | CSGSegmentSmearJob declaration |
| CSGSegmentsSeqIDJob | CSGSegmentsSeqIDJob declaration |
| CSGSeqGraphJob | CSGSeqGraphJob |
| CSGSequenceDS | CSGSequenceDS |
| CSGSequenceDSType | CSGSequenceDSType |
| CSGSnpDS | |
| CSGSnpDSType | |
| CSGSwitchPointJob | CSGSwitchPointJob declaration |
| CSGUtils | Utility classes for sequence graphical view rendering |
| oligofar::CShl< Type, cnt > | |
| CShowBlastDefline | This class displays the defline for BLAST result |
| CShowBlastDeflineTest | |
| oligofar::CShr< Type, cnt > | |
| CShutdownProcessor | |
| CSignal | CSignal -- |
| CSignalSeq | Protein signal sequence prediction according to von Heijne, 1986 (PMID 3714490, as modified in his book) |
| CSignAssembly | CSignAssembly -- |
| CSignManifests | CSignManifests -- |
| CSimple_replace | CSimple_replace -- |
| CSimple_replace_Base | CSimple_replace_Base -- |
| CSimpleB2SWrapper | |
| CSimpleBlobStore | |
| CSimpleBufferT< T, ResizeStrategy > | Reallocable memory buffer (no memory copy overhead) Mimics vector<>, without the overhead of explicit initialization of all items |
| CSimpleClassFactoryImpl< IFace, TDriver > | Template class helps to implement one driver class factory |
| CSimpleClipboard | |
| CSimpleConverter< DstType, SrcType > | Implementation of converter for a single-object conversion |
| CSimpleDataLoaderFactory< TDataLoader > | |
| CSimpleDictionary | Class CSimpleDictionary implements a simple dictionary strategy, providing forward and reverse phonetic look-ups |
| CSimpleEnvRegMapper | CSimpleEnvRegMapper -- |
| CSimpleGiList | |
| CSimpleJobFactory< TWorkerNodeJob > | |
| CSimpleJobFactoryEx< TWorkerNodeJob, TWorkerNodeIdleTask > | |
| CSimpleLayout | CSimpleLayout is the simpliest layout policy that simply stack a set of glyphs one on top of the other vertically |
| CSimpleLoaderMaker< TDataLoader > | |
| CSimpleMakeFileContents | CSimpleMakeFileContents -- |
| CSimpleOM | This class provides a simplified interface to the Object Manager |
| CSimpleRebalanceStrategy | |
| CSimpleResizeStrategy | |
| CSimpleScoringMethod | CSimpleScoringMethod - trivial implementation of IScoringMethod |
| CSimpleScoringPanel | |
| CSimpleTableFilter | |
| CSingleAuthorPanel | |
| CPhyTreeFormatter::CSingleBlastNameExaminer | |
| CSingleCDSExceptionPanel | |
| CClusterer::CSingleCluster | Single cluster |
| CSingleDbxref_SubPanel | |
| CSingleExon | |
| CSingleGbQualSubPanel | |
| CSingletonObjectStore< TKey, TObject > | System wide dumping ground for objects |
| CAnyIntron::CSIntronScore | |
| CSite_annot | CSite_annot -- |
| CSite_annot_Base | CSite_annot_Base -- |
| CSite_annot_set | CSite_annot_set -- |
| CSite_annot_set_Base | CSite_annot_set_Base -- |
| CSiteList | |
| CSixFramesTransTrack | CSixFramesTransTrack -- A special track for doing six-frames translation of the current sequence |
| CSixFramesTransTrackFactory | CSixFramesTransTrackFactory |
| CSize | |
| CSkipChoiceVariantHook | Skip hook for a choice variant (CHOICE) |
| CSkipClassMemberHook | Skip hook for data member of a containing object (eg, SEQUENCE) |
| CSkipObjectHook | Skip hook for a standalone object |
| CSkipReadClassMemberHook | |
| pythonpp::CSlice | |
| CSmallDNS | CSmallDNS -- |
| CSmallPagerBox | |
| CSniffReader | Class CSniffReader reads NCBI object files in number of different formats |
| CSnpBitfield | CSnpBitfield is a facade for representing any version of the SNP bitfield |
| CSnpBitfield1_2 | Implement SNP Bitfield format v1.2 |
| CSnpBitfield2 | Implement SNP Bitfield format v2 |
| CSnpBitfield3 | Implement SNP Bitfield format v3 (nearly identical to v2) |
| CSnpBitfield4 | Implement SNP Bitfield format v4 (nearly identical to v3) |
| CSnpBitfield5 | Implement SNP Bitfield format v5 |
| CSnpBitfieldFactory | |
| CSnpBitfieldNull | |
| CSNPColorPicker | |
| oligofar::CSnpDb | |
| oligofar::CSnpDbBase | |
| oligofar::CSnpDbCreator | |
| CSNPFeatureParams | |
| CSnpFilterJob | |
| CSnpFilterListDialog | |
| CSnpFilterUI | |
| CSnpJob | CSnpJob |
| CSnpPackage | Declare the Package Object |
| CSNPScoringMethod | CSNPScoringMethod |
| CSNPScoringPanel | CSNPScoringPanel |
| CSnpTableData | |
| CSnpTableJob | |
| CSnpTableModel | CSnpTableModel Data source for Feature Table widget |
| CSnpTableView | CSnpTableView |
| CSnpTableViewFactory | |
| CSnpTableWidget | |
| CSnpTrack | |
| CSnpTrackFactory | |
| CSoapBody | |
| CSoapBody_Base | |
| CSoapEnvelope | |
| CSoapEnvelope_Base | Envelope, header and body |
| CSoapFault | |
| CSoapFault_Base | Fault reporting structure |
| CSoapHeader | |
| CSoapHeader_Base | |
| CSoapHttpClient | |
| CSoapMessage | |
| CSoapReadHook | |
| CSoapServerApplication | |
| CSoapWriteHook | |
| CSocket | CSocket:: |
| CSocketAPI | CSocketAPI:: |
| CSocketReaderWriter | |
| CSocketRequest | |
| CSofaMap | |
| oligofar::CSolexaFileReader | |
| CSolutionDir | CSolutionDir -- |
| CSolutionExt | CSolutionExt -- |
| CSolutionFileName | CSolutionFileName -- |
| CSolutionName | CSolutionName -- |
| CSolutionPath | CSolutionPath -- |
| CSort_fields_action | CSort_fields_action -- |
| CSort_fields_action_Base | CSort_fields_action_Base -- |
| CSorterByColumn | |
| CSorterByMultiCols | |
| CSortHitByMolecularTypeEx | Class to sort by linkout bit |
| CTreeIterator::CSortPredicate | |
| CSource_constraint | CSource_constraint -- |
| CSource_constraint_Base | CSource_constraint_Base -- |
| CSource_qual_choice | CSource_qual_choice -- |
| CSource_qual_choice_Base | CSource_qual_choice_Base -- |
| CSource_qual_pair | CSource_qual_pair -- |
| CSource_qual_pair_Base | CSource_qual_pair_Base -- |
| CSource_qual_text_val | CSource_qual_text_val -- |
| CSource_qual_text_val_Base | CSource_qual_text_val_Base -- |
| CSource_qual_val_choice | CSource_qual_val_choice -- |
| CSource_qual_val_choice_Base | CSource_qual_val_choice_Base -- |
| CSource_qual_val_set | CSource_qual_val_set -- |
| CSource_qual_val_set_Base | CSource_qual_val_set_Base -- |
| CSourceFeatureItem | |
| CSourceItem | |
| CSourceModParser | CSourceModParser |
| CSourceModParserWrapper | CSourceModParserWrapper |
| CSP_block | CSP_block -- |
| CSP_block_Base | SWISSPROT specific descriptions |
| oligofar::CSpacialRanges | |
| CSparse_align | |
| CSparse_align_Base | CSparse_align_Base -- |
| CSparse_CI | Implementation of IAlnSegmentIterator for CSparseAln |
| CSparse_seg | |
| CSparse_seg_Base | ========================================================================== |
| CSparse_seg_ext | CSparse_seg_ext -- |
| CSparse_seg_ext_Base | CSparse_seg_ext_Base -- |
| CSparseAlignment | CSparseAlignment - an alignment based on CSparse_seg and CAlingRangeCollection classes rather than on CDense_seg |
| CSparseAln | Sparse alignment |
| CSparseAlnGraphicDataSource | |
| CSparseIterator | CSparseIterator - IAlnSegmentIterator implementation for CAlnMap::CAlnChunkVec |
| CSparseKmerCounts | Kmer counts for alignment free sequence similarity computation implemented as a sparse vector |
| CSparseMultiDataSource | |
| CSparseRowHandle | CSparseRowHandle |
| CSparseSegment | Implementation of IAlnSegment for CSparseAln |
| CSpatialHash2D< T > | Class CSpatialHash2D Class for simple 2D spatial organization that allows for some collision checking and visibility determination |
| CSpecificity | CSpecificity -- |
| CSpecificity_Base | Component cleavage specificity |
| CSpectrum_query | CSpectrum_query -- |
| CSpectrum_query_Base | MS/MS spectrum, precursor ion charge and mass |
| CSpectrumSet | |
| CSpelledQuery | CSpelledQuery -- |
| CSphere | CSphere -- |
| CSphere_Base | Geometrical primitives are used in the definition of region motifs, and also non-atomic coordinates |
| CSpinControl | |
| CSpinLock | CSpinLock -- |
| CSplice_site | CSplice_site -- |
| CSplice_site_Base | Site involved in splice |
| CSpliced_exon | |
| CSpliced_exon_Base | Complete or partial exon two consecutive Spliced-exons may belong to one exon |
| CSpliced_exon_chunk | CSpliced_exon_chunk -- |
| CSpliced_exon_chunk_Base | Spliced-exon-chunk: piece of an exon lengths are given in nucleotide bases (1/3 of aminoacid when product is a protein) |
| CSpliced_seg | |
| CSpliced_seg_Base | CSpliced_seg_Base -- |
| CSpliced_seg_modifier | CSpliced_seg_modifier -- |
| CSpliced_seg_modifier_Base | CSpliced_seg_modifier_Base -- |
| CSplicedAligner | |
| CSplicedAligner16 | |
| CSplicedAligner32 | |
| CSpliceRanker | |
| CSplign | CSplign is the central library object for computing spliced cDNA-to-genomic alignments |
| CSplignApp | |
| CSplignAppException | |
| CSplignArgUtil | |
| CSplignFormatter | |
| CSplignJob | CSplignJob |
| CSplignPanel | |
| CSplignParams | |
| CSplignSimple | |
| CSplignTool | CSplignTool |
| CSplitBlob | |
| CSplitCacheApp | |
| CSplitContentIndex | |
| CSplitDataLoader | |
| CSplitDataMaker | |
| CSplitException | |
| CSplitParser | |
| CSplitQueryBlk | Wrapper class around SSplitQueryBlk structure |
| CSplitQueryTestFixture | |
| CSplitSeqAlignMerger | |
| CSplitSeqIdListSet | |
| CSplitter | CSplitter - container with resizable separators |
| CSQLITE3_BlobCacheCF | Class factory for SQLITE3 BLOB cache |
| CSQLITE3_Cache | SQLITE3 cache implementation |
| CSQLITE3_ICacheException | SQLITE3 ICache exception |
| CSQLITE3_Statement | |
| CSQLITE_Blob | Object reading and writing blob directly (mostly without executing select or update statements), can read and write blob incrementally |
| CSQLITE_Connection | Connection to SQLite database |
| CSQLITE_Exception | Exception thrown from all SQLite-related objects and functions |
| CSQLITE_Global | Utility class for some global-purpose functions tuning SQLite as a whole as opposed to tuning connection-by-connection |
| CSQLITE_HandleFactory | Object factory creating sqlite3* handles |
| CSQLITE_Statement | SQL statement executing on SQLite database |
| CSQLITE_StatementLock | "Scoped" statement activity object |
| oligofar::CSRead | |
| CSRSearch | |
| CSRSearch_Impl< index_t > | |
| CSRSearchApplication | Main application class |
| CSrzAccValidator | |
| CSs | CSs -- |
| CSs_Base | Data for an individual submission to dbSNP |
| CStackTrace | |
| CStackTraceImpl | |
| CStandaloneRequestResult | |
| pythonpp::CStandardError | |
| CStartAction | CStartAction -- |
| CStartArguments | CStartArguments -- |
| CStartItem | |
| CStartPage | CStartPage -- |
| CStartProgram | CStartProgram -- |
| CStartSectionItem | |
| CStartupObject | CStartupObject -- |
| CStartURL | CStartURL -- |
| CStartWorkingDirectory | CStartWorkingDirectory -- |
| CTextFsm< MatchType >::CState | |
| CStatement | |
| CStatementBase | |
| CStaticArrayMap< KeyType, ValueType, KeyCompare > | Class CStaticArrayMap<> provides access to a static array in much the same way as CStaticArraySet<>, except that it provides arbitrary binding of a value type to each sorted key, much like an STL map<> would |
| CStaticArraySearchBase< KeyValueGetter, KeyCompare > | Class CStaticArraySet<> is an array adaptor that provides an STLish interface to statically-defined arrays, while making efficient use of the inherent sort order of such arrays |
| CStaticArraySet< KeyType, KeyCompare > | |
| CStaticDataType | |
| CStaticPairArrayMap< KeyType, ValueType, KeyCompare > | Class CStaticArrayMap<> is an array adaptor that provides an STLish interface to statically-defined arrays, while making efficient use of the inherent sort order of such arrays |
| CStaticTextHandle | Static text helper class that allows mouse click and motion events to grab the control's parent object and move it around |
| CStaticTls< TValue > | |
| CStatistics | CStatistics -- |
| CStatistics_Base | CStatistics_Base -- |
| CStatisticsCounters | |
| CStatusBar | CStatusBar CStatusBar provides basic support for adding windows to status bar slots when status bar is resized the windows are resized automatically |
| CStatusBarService | CStatusBarService - the standard implementation of IStatusBarService interface |
| CStatusBarServiceEvtHandler | CStatusBarServiceEvtHandler |
| CStatusMessageSlotPanel | |
| CStd_seg | |
| CStd_seg_Base | CStd_seg_Base -- |
| CStdaaToEaa | |
| CStdaaToIupacaa | |
| CStdAliasBase< TStd > | |
| CStdAnnotTypes | |
| CStdCmdLineArgs | Argument class to retrieve input and output streams for a command line program |
| CStderrDiagFactory | |
| CStdPoolOfThreads | |
| CStdPrefetch | |
| CStdRequest | |
| CStdSegHit | Wraps a CSeq_align containing CStd_seg and provides a simple API for interpreting it as a pairwise alignment of two sequences |
| CStdSegHitElement | CStdSegHitElement - IHitElement implementation for CStd_seg-based alignments |
| CStdSeq_idSource< Container > | |
| CStdThreadInPool | |
| CStdTypeConstIterator< T > | Template class for iteration on objects of standard C++ type T Non-modifiable version |
| CStdTypeInfo< T > | |
| CStdTypeInfo< bool > | |
| CStdTypeInfo< CBitString > | |
| CStdTypeInfo< char * > | |
| CStdTypeInfo< char > | |
| CStdTypeInfo< const char * > | |
| CStdTypeInfo< CTime > | |
| CStdTypeInfo< double > | |
| CStdTypeInfo< float > | |
| CStdTypeInfo< int > | |
| CStdTypeInfo< Int8 > | |
| CStdTypeInfo< long > | |
| CStdTypeInfo< ncbi::CAnyContentObject > | |
| CStdTypeInfo< ncbi::CStringUTF8 > | |
| CStdTypeInfo< short > | |
| CStdTypeInfo< signed char > | |
| CStdTypeInfo< string > | |
| CStdTypeInfo< Uint8 > | |
| CStdTypeInfo< unsigned > | |
| CStdTypeInfo< unsigned char > | |
| CStdTypeInfo< unsigned long > | |
| CStdTypeInfo< unsigned short > | |
| CStdTypeInfo< vector< char > > | |
| CStdTypeInfo< vector< signed char > > | |
| CStdTypeInfo< vector< unsigned char > > | |
| CStdTypeIterator< T > | Template class for iteration on objects of standard C++ type T |
| CStdTypeStrings | |
| CStep_id | CStep_id -- |
| CStep_id_Base | CStep_id_Base -- |
| CStickyTooltipHandler | CStickyTooltipHandler : Class that manages all the tooltips for a specific window |
| CStlClassInfo_auto_ptr< Data > | |
| CStlClassInfo_list< Data > | |
| CStlClassInfo_map< Key, Value > | |
| CStlClassInfo_map3< Key, Value, Comparator > | |
| CStlClassInfo_multimap< Key, Value > | |
| CStlClassInfo_multimap3< Key, Value, Comparator > | |
| CStlClassInfo_multiset< Data > | |
| CStlClassInfo_multiset2< Data, Comparator > | |
| CStlClassInfo_set< Data > | |
| CStlClassInfo_set2< Data, Comparator > | |
| CStlClassInfo_vector< Data > | |
| CStlClassInfoFunctions< Container > | |
| CStlClassInfoFunctions_multiset< Container > | |
| CStlClassInfoFunctions_set< Container > | |
| CStlClassInfoFunctions_vec< Container > | |
| CStlClassInfoFunctionsCI< Container > | |
| CStlClassInfoFunctionsI< Container > | |
| CStlClassInfoFunctionsI_set< Container > | |
| CStlClassInfoFunctionsIBase< Container, StlIterator, ContainerPtr, ElementRef, TypeInfoIterator > | |
| CStlClassInfoUtil | |
| CStlOneArgTemplate | |
| CStlTwoArgsTemplate | |
| python::CStmtHelper | |
| CStatement::CStmtParamsMetaData | |
| python::CStmtStr | |
| pythonpp::CStopIteration | |
| CStopWatch | CStopWatch -- |
| CNCDeferredDeleter< ElemType, FinalDeleter, DeleteDelay, ElemsPerStorage >::CStorageForDelete | |
| CStrDummyTargetReserve< TStr, TV, TP, TCount > | Do nothing target reservation trait |
| CStrDummyTokenCount< TStr > | Do nothing token counter |
| CStrDummyTokenPos | Do-nothing token position container |
| CStreamByteSource | |
| CStreamByteSourceReader | |
| CStreamDelayBufferGuard | Guard class for CObjectIStream::StartDelayBuffer/EndDelayBuffer |
| CStreamDiagHandler | CStreamDiagHandler -- |
| CStreamDiagHandler_Base | CStreamDiagHandler_Base -- |
| CStreamLineReader | Simple implementation of ILineReader for i(o)streams |
| CStreamObjectPathHook< THook > | |
| CStreamPathHook< TInfo, THook > | |
| CStreamPathHookBase | |
| CStreamReader | Istream-based IReader |
| CStreamState< T > | |
| CStreamTestApp | |
| CStreamUtils | |
| CStreamWriter | Ostream-based IWriter |
| CStrideTest | |
| pythonpp::CString | |
| pythonpp::bind::CString | |
| CString2Args | Auxiliary class to convert a string into an argument count and vector |
| CString_constraint | CString_constraint -- |
| CString_constraint_Base | CString_constraint_Base -- |
| CString_constraint_set | CString_constraint_set -- |
| CString_constraint_set_Base | CString_constraint_set_Base -- |
| CStringAliasBase< TString > | |
| CStringDataType | |
| CStringDecoder_Url | URL-decoder for string pairs parser |
| CStringEncoder_Url | URL-encoder for string pairs parser |
| CStringException | CStringException -- |
| CStringFunctions< T > | |
| CStringIsEmpty | |
| CStringListCtrl | |
| CStringOrBlobStorageReader | String or Blob Storage Reader |
| CStringOrBlobStorageRWException | |
| CStringOrBlobStorageWriter | String or Blob Storage Writer |
| CStringPairs< TContainer > | Template for parsing string into pairs of name and value or merging them back into a single string |
| CStringReader | String-based IReader |
| CStringStoreDataType | |
| CStringStoreFunctions | |
| CStringStoreTypeStrings | |
| CStringTokenCount | Token count trait for std::string |
| python::CStringType | |
| CStringTypeStrings | |
| CStringUTF8 | |
| CStringUtil | |
| CStrip | CStrip -- |
| CStrip_Base | CStrip_Base -- |
| CStrTargetReserve< TStr, TV, TP, TCount > | Target reservation trait (applies for vector<>) |
| CStrTokenize< TStr, TV, TP, TCount, TReserve > | Main tokenization algorithm |
| CStrTokenizeBase | Base class for string splitting |
| CStrTokenPosAdapter< TPosContainer > | Adapter for token position container pointer(NULL legal) Makes pointer to a container look as a legal container |
| CStructured_comment_field | CStructured_comment_field -- |
| CStructured_comment_field_Base | Structured comment fields |
| CStructured_comment_field_pair | CStructured_comment_field_pair -- |
| CStructured_comment_field_pair_Base | CStructured_comment_field_pair_Base -- |
| CStructuredCommentPanel | |
| CStructWrapper< TData > | |
| CAlnMultiHeader::CStyle | |
| CStyledTextOStream | |
| CSubFileByteSource | |
| CSubFileByteSourceReader | |
| CSubImageApp | |
| CSubjectMap | Type representing subject map data |
| CSubjectMap_Factory | To be merged with CSubjectMap_Factory_Base |
| CSubjectMap_Factory_Base | Part of the CSubjectMap_Factory class that is independent of template parameters |
| CSubjectMap_Factory_TBase | To be merged with CSubjectMap_Factory_Base |
| CSubjectRanges | Set of ranges of subject sequences to fetch during the traceback stage |
| CSubjectRangesSet | Set of ranges of subject sequence offsets to fetch during the traceback stage |
| CSubmit_block | CSubmit_block -- |
| CSubmit_block_Base | CSubmit_block_Base -- |
| CSubmitDescription | |
| CSubObjectSelector | CSubObjectSelector -- |
| CSubObjectSelector_Base | End of ObjectList group End of ObjectSelector group Libraries must use SubObjectSelector to refer to the sub providers |
| CSubProvider | CSubProvider -- |
| CSubs | CSubs -- |
| CSubs_Base | CSubs_Base -- |
| CSubSource | |
| CSubSource_Base | CSubSource_Base -- |
| CSubSourceCollector | Abstract class for implementing "sub collectors" |
| CSubstMatrix | Substitution Matrix for Scoring Amino-Acid Alignments |
| CSubtreeBoundary | CSubtreeBoundary -- |
| CSubtypeEquals | |
| CSuiteName | CSuiteName -- |
| CSupportInfo | |
| CSupportUrl | CSupportUrl -- |
| CSurface_coordinates | CSurface_coordinates -- |
| CSurface_coordinates_Base | Literal surface coordinates define the chemical components whose structure is described by a surface, and the surface itself |
| CSurveyBrowser | |
| CSuspect_rule | CSuspect_rule -- |
| CSuspect_rule_Base | CSuspect_rule_Base -- |
| CSuspect_rule_set | CSuspect_rule_set -- |
| CSuspect_rule_set_Base | CSuspect_rule_set_Base -- |
| CSwap_action | CSwap_action -- |
| CSwap_action_Base | CSwap_action_Base -- |
| CSwitchPointGlyph | |
| CSymbolGuard | |
| CSymDustMasker | Looks for low complexity parts of sequences according to the symmetric version of DUST algorithm |
| CSymLink | CSymLink -- |
| CSymResolver | |
| CSyncQueue< Type, Container > | Thread-safe queue object with a blocking mechanism |
| CSyncQueue_AccessGuard< Type, Container > | Access guard to non-constant CSyncQueue |
| CSyncQueue_ConstAccessGuard< Type, Container > | Access guard to a constant CSyncQueue |
| CSyncQueue_I< Type, Container, TNativeIterator > | Iterator for CSyncQueue (constant or non-constant depending on template parameters) |
| CSyncQueue_I_Base< Type, Container > | Base class for both iterator and const_iterator for SyncQueue Used internally for unifying storage of iterators in guardian |
| CSyncQueue_InternalAutoLock< Type, Container > | Auto-lock the queue and unlock it when object will be destroyed |
| CSyncQueue_multiset< Key, Compare, Allocator > | Adaptor class to use STL multiset<> in CSyncQueue |
| CSyncQueue_priority_queue< Type, Container, Compare > | Adaptor class to use STL priority_queue<> in CSyncQueue |
| CSyncQueue_set< Key, Compare, Allocator > | Adaptor class to use STL set<> in CSyncQueue |
| CSyncQueueException | Exception object used throughout all CSyncQueue classes |
| CSynonymsPanel | |
| CSynonymsSet | |
| pythonpp::CSyntaxError | |
| CSysLog | |
| CSysPath | |
| pythonpp::CSystemError | |
| pythonpp::CSystemExit | |
| CSystemPath | |
| CT3Data | |
| CT3Data_Base | CT3Data_Base -- |
| CT3Error | |
| CT3Error_Base | CT3Error_Base -- |
| CT3RefreshFlags | CT3RefreshFlags -- |
| CT3RefreshFlags_Base | CT3RefreshFlags_Base -- |
| CT3Reply | CT3Reply -- |
| CT3Reply_Base | CT3Reply_Base -- |
| CT3Request | CT3Request -- |
| CT3Request_Base | CT3Request_Base -- |
| CT3StatusFlags | CT3StatusFlags -- |
| CT3StatusFlags_Base | CT3StatusFlags_Base -- |
| ct_data_s | |
| CT_mesh | CT_mesh -- |
| CT_mesh_Base | CT_mesh_Base -- |
| pythonpp::CTabError | |
| CTable_match | CTable_match -- |
| CTable_match_Base | CTable_match_Base -- |
| CTable_match_type | CTable_match_type -- |
| CTable_match_type_Base | CTable_match_type_Base -- |
| CTableDataAlnSummary | |
| CTableDataBioTreeContainer | |
| CTableDataGCAssembly | |
| CTableDataSeq_table | |
| CTableDataSorter | |
| CTableFieldHandle< FieldType > | |
| CTableFieldHandle_Base | |
| CTableListColumn | |
| CTableNames | |
| CTableQueryExec | Class CTableQueryExec |
| CTableSortMultiChoice | CTableSortMultiChoice |
| CTableView | CTableView |
| CTableViewFactory | CTableViewFactory |
| CTandemSorter | |
| CTar | CTar class |
| CTarCheckpointed | |
| CTarEntryInfo | CTarEntryInfo class |
| CTarException | CTarException -- |
| CTarget | CTarget -- |
| CTarget_Base | ======================================================================================= Groups tasks into a section of the build process |
| CTargetCulture | CTargetCulture -- |
| CTargetExt | CTargetExt -- |
| CTargetFrameworkProfile | CTargetFrameworkProfile -- |
| CTargetFrameworkVersion | CTargetFrameworkVersion -- |
| CTargetName | CTargetName -- |
| CTargetZone | CTargetZone -- |
| CTarReader | |
| CTarUserEntryInfo | |
| CTask | CTask -- |
| CTaskCmdLineArgs | Argument class to specify the supported tasks a given program |
| CTaskDetailsDlg | |
| CTaskEventRecord | CTaskEventRecord CTaskEventRecord represents a special kind of Event Record generated by Task Manager |
| CTaskProgressReporter | Tasks that report progress derive from this class |
| CAppTaskService::CTaskRecord | |
| CTaskTablePanel | CTaskTablePanel - panel that owns a Table and a Table Model, this is the window for CTaskView |
| CTaskView | CTaskView - IView, that uses CTaskTablePanel as its window |
| CTaskViewFactory | CTaskViewFactory |
| CTaskViewModel | CTaskViewModel - table model for Task View |
| CTaxElement | CTaxElement -- |
| CTaxElement_Base | CTaxElement_Base -- |
| CTaxIdHelper | |
| CTaxIdSet | |
| CTaxNRCriteria | |
| CTaxNRItem | |
| CTaxon1 | |
| CTaxon1_data | CTaxon1_data -- |
| CTaxon1_data_Base | CTaxon1_data_Base -- |
| CTaxon1_error | |
| CTaxon1_error_Base | CTaxon1_error_Base -- |
| CTaxon1_info | CTaxon1_info -- |
| CTaxon1_info_Base | CTaxon1_info_Base -- |
| CTaxon1_name | CTaxon1_name -- |
| CTaxon1_name_Base | CTaxon1_name_Base -- |
| CTaxon1_req | CTaxon1_req -- |
| CTaxon1_req_Base | Requests to the Taxon server |
| CTaxon1_resp | CTaxon1_resp -- |
| CTaxon1_resp_Base | CTaxon1_resp_Base -- |
| CTaxon1ConvertToBioTreeContainer< TBioTreeContainer, TTaxon1, TITaxon1Node, TITreeIterator > | |
| CTaxon1Node | |
| CTaxon1NodeConvertVisitor< TITaxon4Each, TITaxon1Node, TITreeIterator, TBioTreeContainer > | Taxon1 tree visitor functor |
| CTaxon2_data | CTaxon2_data -- |
| CTaxon2_data_Base | CTaxon2_data_Base -- |
| CTaxon3 | |
| CTaxon3_reply | CTaxon3_reply -- |
| CTaxon3_reply_Base | CTaxon3_reply_Base -- |
| CTaxon3_request | CTaxon3_request -- |
| CTaxon3_request_Base | CTaxon3_request_Base -- |
| CTaxonCache | |
| CTaxTreeBrowser | Class CTaxTreeBrowser implements a tree-based view of a taxonomic hierarchy |
| CTaxTreeConstIterator | |
| CTaxTreeDataSource | |
| CTaxTreeDS_ObjMgr | |
| CTaxTreeTestDlg | |
| CTaxTreeToolJob | CTaxTreeToolJob |
| CTaxTreeToolPanel | |
| CTaxTreeToolParams | |
| CTBackAlignInfo< T > | |
| Ctbl | |
| Ctbl_feat | |
| Ctbl_seg | |
| CTblastnApp | |
| CTblastnAppArgs | Handles command line arguments for blastx binary |
| CTBlastnOptionsHandle | Handle to the protein-translated nucleotide options to the BLAST algorithm |
| CTblastxApp | |
| CTblastxAppArgs | Handles command line arguments for blastx binary |
| CTBlastxOptionsHandle | Handle to the translated nucleotide-translated nucleotide options to the BLAST algorithm |
| CTeeDiagHandler | |
| CTemplate1TypeStrings | |
| CTemplate2TypeStrings | |
| CHTMLPage::CTemplateLibFilter | Interface for a filter, which must be passed to one the LoadTemplateLib methods to select relevant parts of the loaded template library |
| CTemplateName | CTemplateName -- |
| CTemplateName_Base | CTemplateName_Base -- |
| CTemplateScoringMethod | CTemplateMethod - describes a class of similar methods |
| CTempPusher< TStack > | |
| CTempString | CTempString implements a light-weight string on top of a storage buffer whose lifetime management is known and controlled |
| CTempStringEx | |
| CTempTrackProxy | File Description: |
| CSeqVector_CI::CTempValue | Special temporary holder for return value from postfix operators |
| CTempXStr< _TChar > | |
| CTerminal | |
| CTerminal_modification | CTerminal_modification -- |
| CTerminal_modification_Base | Modification to the N or C terminus, static or variable |
| CTermSet | CTermSet -- |
| CTest | |
| CTestAction | |
| CTestActionList | |
| CTestArguments | |
| CTestBlastp | |
| CTestBlastp_All | |
| CTestCmdUI | CTestCmdUI |
| CTestCommandHandler | |
| CTestCompartApplication | |
| CAgpwriteProcess::CTestCompIdMapper | |
| CTestConfigMediator | |
| CTestData | |
| CTestDispatchApp | |
| CTestDispatcher | |
| CTestEvent | |
| CTestEventAttachment | CTestEventAttachment CTestEventAttachment is used for testing attachment management policies (how attachments are deleted) |
| CTestGuiRegistryApp | |
| CTestMapperSeqInfo | |
| CTestObjMgr | This class wraps the C++ Object Manager to control its lifetime and to facilitate the creation of SSeqLoc structures |
| CTestPhyTreeCalc | Test class for accessing CPhyTreeCalc private methods and attributes |
| CTestProtProd | |
| CTestProtProd_Cdd | |
| CTestProtProd_EntrezNeighbors | |
| CTestProtProd_ProteinLength | |
| CTestReceiver | |
| CTestSeqBasedMethod | CTestSeqBasedMethod |
| CTestSeqId | |
| CTestSeqId_Biomol | |
| CTestSettings | |
| CTestSingleAln | |
| CTestSingleAln_All | |
| CTestThemeSettings | |
| CTestThread | |
| CTestTranscript | |
| CTestTranscript_CdsFlags | Check coding regions for "partial", "pseudo", and "except" flags |
| CTestTranscript_CdsStartCodon | Check to see if the sequence contains a CDS feature that has a start codon |
| CTestTranscript_CdsStopCodon | Check to see if the sequence contains a CDS feature that has a stop codon |
| CTestTranscript_Code_break | Count code-breaks on CDS |
| CTestTranscript_CodingPropensity | Measure the coding propensity of the CDS feature annotated on a CDS feature |
| CTestTranscript_CompareProtProdToTrans | Compare the annotated protein product of a CDS in the database to actual translation of that CDS |
| CTestTranscript_CountAmbiguities | Count ambiguous residues in transcript and CDS |
| CTestTranscript_CountCdregions | Count the number of annotated coding regions |
| CTestTranscript_InframeUpstreamStart | Check to see if the sequence contains a CDS feature that has an in-frame upstream start codon |
| CTestTranscript_InframeUpstreamStop | Check to see if the sequence contains a CDS feature that has an in-frame upstream stop codon |
| CTestTranscript_OrfExtension | See how far the annotated CDS can be extended 5' to an ATG without hitting a stop |
| CTestTranscript_Orfs | Categorize ORFs in this transcript sequence |
| CTestTranscript_PolyA | Count the number of As at the end of the sequence |
| CTestTranscript_PrematureStopCodon | Check CDS features for premature stop codons |
| CTestTranscript_TranscriptCdsLength | Measure the length of an CDS feature on a transcript sequence |
| CTestTranscript_TranscriptLength | Measure the length of an mRNA sequence |
| CTestTranscript_Utrs | Compare the annotated protein product of a CDS in the database to actual translation of that CDS |
| CTestTreeApp | |
| CText_marker | CText_marker -- |
| CText_marker_Base | CText_marker_Base -- |
| CText_portion | CText_portion -- |
| CText_portion_Base | CText_portion_Base -- |
| CText_transform | CText_transform -- |
| CText_transform_Base | CText_transform_Base -- |
| CText_transform_set | CText_transform_set -- |
| CText_transform_set_Base | CText_transform_set_Base -- |
| CTextannot_id | CTextannot_id -- |
| CTextannot_id_Base | Sequence Annotation ************************************* |
| CTextArrayPrinter | |
| CTextBlock | |
| CTextColumn | |
| CTextDataSource | |
| CTextFsa | |
| CTextFsm< MatchType > | |
| CTextInputDescription | |
| CTextItem | |
| CTextItemDefault | |
| CTextItemPanel | |
| CTextItemSeq_align | |
| CTextItemSeq_feat | |
| CTextPanel | |
| CTextPanelContext | |
| CTextPanelState | |
| CTextPosition | |
| CTextPrinter | |
| CTextReportDlg | |
| CTextRetrieveJob | |
| CTextSelectItem | |
| CTextSelHandler | Class CTextSelHandler represents in GUI a two-dimnesional multi-segment selection |
| CTextseq_id | |
| CTextseq_id_Base | CTextseq_id_Base -- |
| CTextStyle | |
| CTextTableModel | CwxTextTableModel - very simple model for storing SMALL numbers fo strings |
| CTextTagWriter | |
| CTextUtil | |
| CTextUtils | Temporary placed here, later should be moved to the appropriate location |
| CTextView | CTextView |
| CTextViewFactory | CTextViewFactory |
| CTextViewRetrieveProgress | Progress report class for text viewer |
| CTextViewRetrieveResult | Class to deliver partial results as part of progress report of text viewer |
| CTextWidgetEvent | |
| CTextWMClient | CTextWMClient |
| CThemeConfigPanel2 | |
| CThemeConfigPanelBase | CThemeConfigPanelBase The default implementation for Theme widget panels |
| CThemeDlg | |
| CThemeMediator | |
| CThemePreviewMediator | |
| CThemeSet | Styles other types of values |
| CThermolysinP | EMSEnzymes_thermolysin_p cuts N terminal at A,F,I,L,M or V |
| CThread | CThread -- |
| CThreadable | Class that supports setting the number of threads to use with a given algorithm |
| CThreadDoSM | |
| CThreadedApp | CThreadedApp -- |
| CThreadedServerException | Exceptions thrown by CThreadedServer::Run |
| CThreadException | |
| CThreadGroup | |
| CThreadInPool< TRequest > | |
| CThreadInPool_ForServer | |
| CThreadLocalTransactional | Thread local transactional object |
| CThreadNonStop | Adaptation of CThread class repeatedly running some job |
| CThreadPool | Main class implementing functionality of pool of threads |
| CThreadPool_Controller | Abstract class for controlling the number of threads in pool |
| CThreadPool_Controller_PID | Default ThreadPool controller based on Proportional-Integral-Derivative algorithm |
| CThreadPool_EmptyTask | Special task which does nothing It's used in FlushThreads to force pool to wait while all old threads finish their operation to start new ones |
| CThreadPool_Guard | Guardian for protecting pool by locking its main mutex |
| CThreadPool_Impl | Real implementation of all ThreadPool functions |
| CThreadPool_ServiceThread | Thread used in pool for different internal needs: execution of exclusive tasks and passing events to controller |
| CThreadPool_Task | Abstract class for representing single task executing in pool of threads To use this class in application you should inherit your own class from it and define method Execute() - the main method where all task logic executes |
| CThreadPool_Thread | Base class for a thread running inside CThreadPool and executing tasks |
| CThreadPool_ThreadImpl | Real implementation of all CThreadPool_Thread functions |
| CThreadPoolEngine | CThreadPoolEngine |
| CThreadPoolException | Exception class for all ThreadPool-related classes |
| CThreadRunOnTop | |
| CThreadSystemID | CThreadSystemID -- |
| CThreadPoolEngine::CThreadTask | IAppJob to CThreadPool_Task Adaptor |
| pythonpp::CTime | |
| CTime | CTime -- |
| pythonpp::CTimeDelta | |
| CTimedReporter | CTimedReporter -- helper class for reporting time |
| CTimeException | CTimeException -- |
| CTimeFormat | CTimeFormat -- |
| CTimeFunctions | |
| CTimeLine< BV > | Timeline class for fast approximate time tracking |
| CTimeMRUList< T > | CTimeMRUList - a MRU list where "recent" items are determined based on provided time, not on insertion order |
| CTimeout | CTimeout -- Timeout interval |
| CTimer | |
| CTimerGuard | |
| CTimeSpan | CTimeSpan |
| CTimeTypeInfo | |
| CTitle | |
| CTitle_Base | Title Group Valid for = A = Analytic (Cit-art) J = Journals (Cit-jour) B = Book (Cit-book) Valid for: |
| CTitle_msg | CTitle_msg -- |
| CTitle_msg_Base | Title match request/response |
| CTitle_msg_list | CTitle_msg_list -- |
| CTitle_msg_list_Base | CTitle_msg_list_Base -- |
| CTitlePanel | |
| CTitleProcess | |
| CTL_BCPInCmd | |
| CTL_Cmd | |
| CTL_CmdBase | |
| CTL_ComputeResult | |
| CTL_Connection | |
| CTL_CursorCmd | |
| CTL_CursorCmdExpl | |
| CTL_CursorResult | |
| CTL_CursorResultExpl | |
| CTL_ITDescriptor | |
| CTL_LangCmd | |
| CTL_LRCmd | |
| CTL_ParamResult | |
| CTL_RowResult | |
| CTL_RPCCmd | |
| CTL_SendDataCmd | |
| CTL_StatusResult | |
| CTLibContext | |
| CTLibContextRegistry | |
| CTls< TValue > | CTls -- |
| CTlsBase | CTlBase -- |
| CTmpDirEntryDeleter | |
| CTmpEnvironmentSetter | |
| CTmpFile | CTmpFile -- |
| CAgpFastaComparator::CTmpSeqVecStorage | |
| CTmpStream | |
| CTmpStreamGuard | |
| CtmRNASubPanel | |
| CValidateAccesions::CToken | |
| CTraversalSpecFileParser::CTokenizer | |
| CTolower | CTolower -- |
| CTolower_Base | CTolower_Base -- |
| CToMultiExHandler | |
| CTool | CTool -- |
| CTool_Base | CTool_Base -- |
| CToolManagerItem | CToolManagerItem |
| CToolRecentItem | CRecentToolItem |
| CTooltip | |
| CTooltipFrame | The tooltip window that displays tip information |
| CTooltipHandler | CTooltipHandler |
| CTooltipInfo | Contents of a single tool tip including display text and an ID that will indicate which underlying visual element the tip is attached to |
| CTooltipWnd | |
| CTopDown | EMSEnzymes_top_down top-down search of ETD spectra |
| CTopLevelSeqEntryContext | |
| CToupper | CToupper -- |
| CToupper_Base | CToupper_Base -- |
| CTrace_DataLoaderCF | |
| CTracebackSearchTestFixture | |
| CTracebackTestFixture | |
| CTraceChromatogramLoader | |
| CTraceData | CTraceData |
| CTraceDataProxy | CTraceDataProxy - an object controlling availability and creation of CTraceData instance |
| CTraceEvent | CTraceEvent |
| CTraceGraph | CTraceGraph - trace data renderer |
| CTraceGraphProperties | CTraceGraphProperties |
| CTracingHandler | CTracingHandler |
| CTracingHandler_1 | CTracingHandler_1 |
| CTracingHandler_2 | CTracingHandler_2 |
| CTrackConfig | CTrackConfig -- |
| CTrackConfig_Base | CTrackConfig_Base -- |
| CTrackConfigManager | CTrackConfigManager a help class to manage layout track configuration |
| CTrackConfigSet | CTrackConfigSet -- |
| CTrackConfigSet_Base | CTrackConfigSet_Base -- |
| CTrackConfigUtils | File Description: |
| CTrackContainer | CTrackContainer - a track container in the form of layout track |
| CTrackContainerEvtHandler | |
| CTrackContainerFactory | CTrackContainerFactory |
| CTrackCreatorUI | |
| CTrackData | |
| CTrackedSeeds< ONE_HIT > | Specialization for one-hit searches |
| CTrackedSeeds< TWO_HIT > | Specialization for two-hit searches |
| CTrackedSeeds_Base< NHITS > | Representation of a collection of tacked seeds for a specific subject sequence |
| CTrackingEnvHolder | |
| CTrackInitializationJob | CTrackInitializationJob |
| CTrackInitJobResult | CTrackInitJobResult |
| CTrackProxy | CTrackProxy data structure contains information about the position of a track in its parent scope, and information about intializing the layout track and its associated data source |
| CTrackTypeInfo | CTrackTypeInfo - holds description of a layout track type |
| CTrans_matrix | CTrans_matrix -- |
| CTrans_matrix_Base | CTrans_matrix_Base -- |
| CTrans_table | |
| python::CTransaction | |
| CTransferable< T > | |
| CTransform | CTransform -- |
| CTransform_Base | CTransform_Base -- |
| CTranslation | CTranslation -- |
| CTranslation_constraint | CTranslation_constraint -- |
| CTranslation_constraint_Base | CTranslation_constraint_Base -- |
| CTranslationConfig | |
| CTranslationGlyph | |
| CTranslationSet | CTranslationSet -- |
| CTranslationSet_Base | CTranslationSet_Base -- |
| CTranslationStack | CTranslationStack -- |
| CTranslationStack_Base | CTranslationStack_Base -- |
| CTranslationTable | |
| CTransmissionReader | IReader implementation with transmission control |
| CTransmissionWriter | IWriter with transmission control |
| CTransparentFrame | For platforms that support transparent frames - we derive our Hint Frame form different base classes on different platforms |
| CTraversalCodeGenerator | |
| CTraversalMerger | |
| CTraversalNode | |
| CTraversalPatternMatchCallback | |
| CTraversalSpecFileParser | |
| oligofar::CTrBase | |
| CTreatWarningsAsErrors | CTreatWarningsAsErrors -- |
| CTree | A wrapper for controlling access to the phylogenetic tree generated by CDistMethods |
| CTree2TreeFunc< TDstTreeNode, TSrcTreeNode, TNodeConvFunc > | Visitor functor to convert one tree to another |
| CTreeBestIterator | |
| CTreeBlastIterator | |
| CTreeBoundaryNode | Class CTreeBoundaryNode |
| CTreeBuilderJob | CTreeBuilderJob |
| CTreeBuilderPanel | |
| CTreeBuilderParams | |
| CTreeBuilderTool | CTreeBuilderTool |
| CTreeCollapsedNode | Class CTreeCollapsedNode |
| CTreeCollisionModel2D | Class CTreeCollisionModel2D This is a subclass of the spatial collision detection datastructure specialized to support data important to (phylogenetic) trees |
| CTreeConstIterator | |
| CTreeCont | |
| CTreeContNodeBase | |
| CTreeDemoDlg | |
| CTreeFiller | |
| CTreeGraphicsEdge | Class CTreeGraphicsEdge |
| CTreeGraphicsModel | Class CTreeGraphicsModel Model for rendering tree graphics data |
| CTreeGraphicsNode | Class CTreeGraphicsNode |
| CTreeIdToSetFunc< TTreeNode, TBackInsert > | Functor to trace node pointers to root and create set of parents (TreeForEachParent) |
| CTreeIterator | Base class for all iterators over modifiable object |
| CTreeIteratorTmpl< LevelIterator > | Base class for all iterators over non-modifiable object Do not use it directly |
| CTreeLeavesBranchesIterator | |
| CTreeLevelIterator | |
| CTreeLevelIteratorMany< ChildIterator > | |
| CTreeLevelIteratorOne | |
| CTreeMarkerNode | Class CTreeMarkerNode |
| CTreeMinimalSet< TNode, TSet, TNodeList > | Functor takes a single nodelist as an argument and tries to push that nodelist as high as it can |
| CTreeNode< TValue, TKeyGetter > | Definition of a Culling tree |
| CTreeNodesAnd< TNode, TSet, TNodeList > | Node list AND (set intersection) |
| CTreeNodesOr< TNode, TSet, TNodeList > | Node list OR (set union) |
| CTreeNonRedundantSet< TNode, TSet, TNodeList > | Class-algorithm to compute Non Redundant Set |
| CTreePair< TId, TValue > | Node data template for id-value trees |
| CTreeParentTraceFunc< TTreeNode, TTraceContainer > | Functor to trace node pointers to root (TreeForEachParent) |
| CTreePrintFunc< TTreeNode, TConverter > | Tree print functor used as a tree traversal payload |
| CTreeQueryExec | Class CTreeQueryExec |
| CTreeSet2NodeListFunc< TTreeNode, TSet, TNodeList > | Functor to convert tree to a nodelist by the set pattern |
| CTreeTriFanNode | Class CTreeTriFanNode |
| CTreeWMClient | CTreeWMClient |
| CTriangle | CTriangle -- |
| CTriangle_Base | Definition for matrix of pairwise "distances", stored as the upper triangle of a squared n x n matrix (excluding the diagonal), this is supposed to store pairwise percentages of identical residues, pairwise alignment scores or E-values from pairwise BLAST sequence comparisons |
| CTriangles | CTriangles -- |
| CTriangles_Base | CTriangles_Base -- |
| CTrigger | CTrigger:: |
| oligofar::CTrItemPacked< bitst, bitsc > | |
| CTrivialConnValidator | |
| CTrna_ext | CTrna_ext -- |
| CTrna_ext_Base | TRNA feature extensions |
| CtRNASubPanel | |
| oligofar::CTrSequence< bitst, bitsc > | |
| CTruncateRequest | |
| CTrustUrlParameters | CTrustUrlParameters -- |
| oligofar::CTrVector< T > | |
| CTrypChymo | |
| CTrypCNBr | |
| CTrypsin | |
| CTrypsinP | |
| CTSAItem | |
| CTSE_Chunk_Info | |
| CTSE_Default_Assigner | |
| CTSE_Handle | |
| CTSE_Info | |
| CTSE_Info_Object | |
| CTSE_LoadLock | |
| CTSE_LoadLockGuard | |
| CTSE_Lock | |
| CTSE_LockSet | |
| CTSE_ScopeInfo | |
| CTSE_ScopeInfo_Base | |
| CTSE_ScopeInternalLocker | |
| CTSE_ScopeLocker | |
| CTSE_ScopeUserLocker | |
| CTSE_SetObjectInfo | |
| CTSE_Split_Info | |
| CTSEAnnotObjectMapper | |
| CTSeq | CTSeq -- |
| CTSeq_Base | CTSeq_Base -- |
| CTSeqSet | CTSeqSet -- |
| CTSeqSet_Base | Bunch of them |
| pythonpp::CTuple | |
| CTwoLayerRegistry | CTwoLayerRegistry -- |
| CTwoPartQualPanel | |
| CTwoStage | |
| CTwoStageNew | |
| CTwoStageOld | |
| CTx_evidence | CTx_evidence -- |
| CTx_evidence_Base | CTx_evidence_Base -- |
| CTxinit | CTxinit -- |
| CTxinit_Base | CTxinit_Base -- |
| pythonpp::CType | |
| CType< C > | |
| CType_Base | |
| CTypeComplianceDiagnostics | CTypeComplianceDiagnostics -- |
| CTypeConstIterator< C, TypeGetter > | Template class for iteration on objects of class C (non-medifiable version) |
| CTypeConverter< T > | |
| CTypedArrayAdapter< Type, TBase > | Class CTypedArrayAdapter<Type, TBase> |
| pythonpp::CTypeError | |
| CTypeInfo | CTypeInfo class contains all information about C++ types (both basic and classes): members and layout in memory |
| CTypeInfoFunctions | |
| CTypeInfoMap | |
| CTypeInfoMap2 | |
| CTypeInfoMap2Data | |
| CTypeInfoMapData | |
| CTypeInfoSource | |
| CTypeInterfaceFactory< T > | |
| CTypeIterator< C, TypeGetter > | Template class for iteration on objects of class C |
| CTypeIteratorBase< Parent > | Template base class for CTypeIterator<> and CTypeConstIterator<> Do not use it directly |
| CTypeRef | |
| CTypesIteratorBase< Parent > | Template base class for CTypesIterator and CTypesConstIterator Do not use it directly |
| CTypeStrings | |
| pythonpp::CTZInfo | |
| CUICommand | CUICommand |
| CUICommandRegistry | CUICommandRegistry – a centralized registry where all application commands should be registered |
| CUICulture | CUICulture -- |
| CUIDataSourceService | CUIDataSourceService |
| CUIDataSourceTask | CUIDataSourceTask - a task for opening / closing data sources |
| CUIObject | CUIObject - default mix-in implementation of IUIObject |
| CUIToolRegistry | CUIToolRegistry - is a registry providing access to various tools registred in the application |
| CUnassignedMember | Thrown on an attempt to write unassigned data member |
| pythonpp::CUnboundLocalError | |
| CUndoManager | |
| CUnfocusedScrollbar | |
| pythonpp::CUnicodeDecodeError | |
| pythonpp::CUnicodeEncodeError | |
| pythonpp::CUnicodeError | |
| CUnicodeToAsciiTranslation | |
| pythonpp::CUnicodeTranslateError | |
| CUnionBuffer< T > | |
| CUniqueLabelGenerator | CUniqueLabelGenerator Modifies the given label so that it becomes unique in the given set of labels by appending a numeric postfix ( "name" -> "name (1)" ) |
| CUniSequenceDataType | |
| CUniSetDataType | |
| CUnit | |
| CUNIXListeningSocket | |
| CUNIXSocket | |
| CUnknownProcessor | |
| CUnloadProject_local | |
| CUnorderedSplitter | |
| CUnpublishedPanel | |
| CUnsupportedEditSaver | |
| CUnsupportedEditSaverException | |
| CUpcaseCharPtrConverter | |
| CUpcaseStringConverter | |
| CDataChangeNotifier::CUpdate | CUpdate - notification send by CUIDataSource to the listener |
| CUpdate_align | CUpdate_align -- |
| CUpdate_align_Base | Both fields are optional, as the Update-align may be a Seq-annot without description, or a suggestion to add a sequence without the corresponding alignment |
| CUpdate_comment | CUpdate_comment -- |
| CUpdate_comment_Base | Update-align is supposed to contain alignments that still need some work done to fit into the CD-proper alignment |
| CUpdate_sequences_action | CUpdate_sequences_action -- |
| CUpdate_sequences_action_Base | CUpdate_sequences_action_Base -- |
| CUpdateEnabled | CUpdateEnabled -- |
| CUpdateGuard< Resource > | CUpdateGuard - works like CGuard, but relies on functions LockUpdates() and UnlockUpdates() |
| CUpdateInterval | CUpdateInterval -- |
| CUpdateIntervalUnits | CUpdateIntervalUnits -- |
| CUpdateMode | CUpdateMode -- |
| CUpdatePeriodically | CUpdatePeriodically -- |
| CUpdateRequired | CUpdateRequired -- |
| CUpdateUrl | CUpdateUrl -- |
| CUpdMirrorServerParams | |
| CUpgradeBackupLocation | CUpgradeBackupLocation -- |
| CUrl | CUrl -- |
| CUrlArgs | CUrlArgs:: |
| CUrlArgs_Parser | CUrlArgs_Parser:: |
| CUrlException | CUrlException -- |
| CUrlParserException | CUrlParserException -- |
| CUseAppConfigForCompiler | CUseAppConfigForCompiler -- |
| CUseApplicationTrust | CUseApplicationTrust -- |
| CUsedTlsBases | |
| CUseOfAtl | CUseOfAtl -- |
| CUseOfMfc | CUseOfMfc -- |
| CUser_field | |
| CUser_field_Base | CUser_field_Base -- |
| CUser_object | |
| CUser_object_Base | User-object ********************************************** |
| CTraversalNode::CUserCall | |
| pythonpp::CUserError< T, B > | |
| CUserFeatHandler | Handler specific for User-object features |
| CUserFormat | CUserFormat -- |
| CUserFormat_Base | CUserFormat_Base -- |
| impl::CDBHandlerStack::CUserHandlerWrapper | |
| CUseVSHostingProcess | CUseVSHostingProcess -- |
| CUsingTask | CUsingTask -- |
| CUsingTask_Base | ======================================================================================= Defines the assembly containing a task's implementation, or contains the implementation itself |
| CustomSpinCtrl | |
| CUTF8OutPut | CUTF8OutPut -- |
| CUtilException | |
| CutShortPartialExons | |
| CUTTPReader | Class for reading series of chunks sent by a CUTTPWriter instance as a stream of bytes |
| CUTTPWriter | Class that serializes series of chunks of data for sending over binary streams |
| CValidateAccesions | |
| CValidator | |
| CValidatorArgUtil | |
| CValidErrItem | |
| CValidErrItem_Base | CValidErrItem_Base -- |
| CValidError | |
| CValidError_align | |
| CValidError_annot | |
| CValidError_base | |
| CValidError_Base | CValidError_Base -- |
| CValidError_bioseq | |
| CValidError_bioseqset | |
| CValidError_CI | |
| CValidError_desc | |
| CValidError_descr | |
| CValidError_feat | |
| CValidError_graph | |
| CValidError_imp | |
| CValidErrorHandler | |
| value_slice::CValueConvert< CP, bool > | |
| value_slice::CValueConvert< CP, CDB_BigInt > | |
| value_slice::CValueConvert< CP, CDB_Bit > | |
| value_slice::CValueConvert< CP, CDB_Char > | |
| value_slice::CValueConvert< CP, CDB_CursorCmd * > | |
| value_slice::CValueConvert< CP, CDB_CursorCmd > | |
| value_slice::CValueConvert< CP, CDB_DateTime > | |
| value_slice::CValueConvert< CP, CDB_Double > | |
| value_slice::CValueConvert< CP, CDB_Float > | |
| value_slice::CValueConvert< CP, CDB_Int > | |
| value_slice::CValueConvert< CP, CDB_LangCmd * > | |
| value_slice::CValueConvert< CP, CDB_LangCmd > | |
| value_slice::CValueConvert< CP, CDB_LongChar > | |
| value_slice::CValueConvert< CP, CDB_Numeric > | |
| value_slice::CValueConvert< CP, CDB_RPCCmd * > | |
| value_slice::CValueConvert< CP, CDB_RPCCmd > | |
| value_slice::CValueConvert< CP, CDB_SmallDateTime > | |
| value_slice::CValueConvert< CP, CDB_SmallInt > | |
| value_slice::CValueConvert< CP, CDB_TinyInt > | |
| value_slice::CValueConvert< CP, CDB_VarChar > | |
| value_slice::CValueConvert< CP, const char * > | |
| value_slice::CValueConvert< CP, CTime > | |
| value_slice::CValueConvert< CP, CVariant > | |
| value_slice::CValueConvert< CP, double > | |
| value_slice::CValueConvert< CP, float > | |
| value_slice::CValueConvert< CP, Int1 > | |
| value_slice::CValueConvert< CP, Int2 > | |
| value_slice::CValueConvert< CP, Int4 > | |
| value_slice::CValueConvert< CP, Int8 > | |
| value_slice::CValueConvert< CP, long double > | |
| value_slice::CValueConvert< CP, string > | |
| value_slice::CValueConvert< CP, Uint1 > | |
| value_slice::CValueConvert< CP, Uint2 > | |
| value_slice::CValueConvert< CP, Uint4 > | |
| value_slice::CValueConvert< CP, Uint8 > | |
| value_slice::CValueConvert< SRunTimeCP, CDB_Object > | |
| value_slice::CValueConvert< SRunTimeCP, CDB_Result > | |
| value_slice::CValueConvert< SRunTimeSqlCP, CDB_Object > | |
| value_slice::CValueConvert< SRunTimeSqlCP, CDB_Result > | |
| value_slice::CValueConvert< SSafeCP, CDB_Object > | |
| value_slice::CValueConvert< SSafeCP, CDB_Result > | |
| value_slice::CValueConvert< SSafeSqlCP, CDB_Object > | |
| value_slice::CValueConvert< SSafeSqlCP, CDB_Result > | |
| pythonpp::CValueError | |
| CValueHolder< T > | Interface class to hold values and to determine whether some difference in these values should be reported or not |
| CValuesCount | |
| CQueryMacro::CVariable | Class describes a macro language variable |
| CVariant | |
| CVariantException | |
| CVariantInfo | |
| CVariantInfoFunctions | |
| CVariantPlacement | CVariantPlacement -- |
| CVariantPlacement_Base | CVariantPlacement_Base -- |
| CVariantProperties | |
| CVariantProperties_Base | Historically, the dbSNP definitions document data structures used in the processing and annotation of variations by the dbSNP group |
| variation::CVariationUtil::CVariantPropertiesIndex | Given a seq-loc, compute CVariantProperties::TGene_location from annotation |
| python::CVariantSet | |
| python::CVariantSetProxy | |
| CVariation | |
| CVariation_Base | CVariation_Base -- |
| CVariation_inst | CVariation_inst -- |
| CVariation_inst_Base | Variation instance |
| CVariation_ref | |
| CVariation_ref_Base | CVariation_ref_Base -- |
| CVariationException | CVariationException -- |
| CVariationException_Base | CVariationException_Base -- |
| CVariationMethod | CVariationMethod -- |
| CVariationMethod_Base | CVariationMethod_Base -- |
| variation_ref::CVariationUtil | |
| variation::CVariationUtil | |
| CVarTrack | CVarTrack -- |
| CVarTrackFactory | CVarTrackFactory |
| CVcfData | |
| CVcfFilterSpec | |
| CVcfFormatSpec | |
| CVcfInfoSpec | |
| CVcfReader | |
| CVcfWriter | |
| CVecscreen | Example: |
| CVecscreenRun | This class runs vecscreen |
| CVecscreenTest | |
| CVect2< T > | |
| CVect3< T > | |
| CVect4< T > | |
| CVectorOutput< T > | |
| CVectorPrinter | |
| CVectorSet< T > | |
| CVectorTypeStrings | |
| CVectorWrap< T > | A vector or pointer based sequence wrapper |
| CVersion | CVersion -- |
| CVersion_Base | CVersion_Base -- |
| CVersionInfo | CVersionInfo -- |
| CVersionItem | |
| CVersionResponse | CVersionResponse -- |
| CVersionResponse_Base | CVersionResponse_Base -- |
| CVersionStruct | CVersionStruct -- |
| CVersionStruct_Base | CVersionStruct_Base -- |
| CViewDataLink | |
| CViewDataLink_Base | CViewDataLink_Base -- |
| CViewDesc | |
| CViewDesc_Base | CViewDesc_Base -- |
| CViewDescriptor | |
| CViewDescriptor_Base | CViewDescriptor_Base -- |
| CViewEvent | |
| CViewException | |
| CViewFactoryItem | CToolManagerItem |
| CViewGraphic | CViewGraphic |
| CViewGraphicFactory | CViewGraphicFactory |
| CViewManagerService | CViewManagerService - the standard implementation of IViewManagerService interface |
| CViewMemento | |
| CViewMemento_Base | CViewMemento_Base -- |
| CViewTypeDescriptor | CViewTypeDescriptor - holds description of a view type |
| CVisibleRange | |
| CVisibleRangeService | CVisibleRangeService |
| CVisRangeGlyph | |
| CVisualStudioProject | CVisualStudioProject -- |
| CVisualStudioProject_Base | CVisualStudioProject_Base -- |
| CVoidFuncPtr1< Arg1 > | |
| CVoidFuncPtrTmpl1< T, Arg1 > | |
| CVoidTypeFunctions | |
| CVoidTypeInfo | |
| CWAM_Acceptor< order > | |
| CWAM_Donor< order > | |
| CWAM_Stop | |
| python::CWarning | |
| CWarningLevel | CWarningLevel -- |
| CWarningList | CWarningList -- |
| CWarningsAsErrors | CWarningsAsErrors -- |
| CWeakInterfaceLocker< Interface > | CWeakInterfaceLocker -- |
| CWeakIRef< Interface, Locker > | CWeakIRef -- |
| CWeakLockerTraits< C > | |
| CWeakMap< Object > | |
| CWeakMapKey< Object > | |
| CWeakObject | CWeakObject -- |
| CWeakObjectLocker< C > | CWeakObjectLocker -- |
| pythonpp::CWeakRef | |
| CWeakRef< C, Locker > | CWeakRef -- |
| CWebPage | CWebPage -- |
| CWebReferences | CWebReferences -- |
| CWebReferenceUrl | CWebReferenceUrl -- |
| CWebServiceProxyGeneratorToolDummyImpl | Dummy (name-only) tool implementations |
| CWGSItem | |
| CWholeProgramOptimization | CWholeProgramOptimization -- |
| CWholeProtein | Whole protein (no cleavage) |
| CWidgetDisplayStyle | CWidgetDisplayStyle is a collection of display properties common for all rows in the CAlnMultiWidget |
| CWidgetHandle | Helper class that allows mouse click and motion events to grab the control's parent object and move it around |
| CWig2tableApplication | |
| CWigBufferedLineReader | |
| CWiggleData | |
| CWiggleReader | |
| CWiggleRecord | |
| CWiggleTrack | |
| CWiggleWriter | |
| CWigLoadJob | CWigLoadJob |
| CWigLoadManager | CWigLoadManager |
| CWigLoadParams | |
| CWigParamsPanel | |
| CWin32ResourceFile | CWin32ResourceFile -- |
| CWindowManager | CWindowManager - component controlling windowing of client windows |
| CWindowManagerEvent | CWindowManagerEvent |
| CWindowManagerService | CWindowManagerService - standard implementation of IWindowManagerService interface built on CWindowManager class |
| CWindowMaskerJob | CWindowMaskerJob |
| CWindowMaskerPanel | |
| CWindowMaskerParams | |
| CWindowMaskerTool | CWindowMaskerTool |
| CWindowsCmdErrorHandler | Windows-specific command-line logger This is used to format error output in such a way that the Windows error logger can pick this up |
| CWindowsDlg | CWindowsDlg |
| CWindowSizeArg | Argument class to retrieve and set the window size BLAST algorithm option |
| CWinMaskApplication | Window based masker main class |
| CWinMaskConfig | Objects of this class contain winmasker configuration data |
| CWinMaskConfigException | Winmasker configuration errors |
| CWinMaskCountsConverter | Class responsible for converting unit counts between different formats |
| CWinMaskCountsGenerator | This class encapsulates the n-mer frequency counts generation functionality of winmasker |
| CWinMaskerFileStorage | |
| CWinMaskFilesDlg | |
| CWinMaskFilesParams | |
| CWinMaskUtil | |
| CWinSecurity | CWinSecurity -- |
| impl::CWinSock | |
| CWMM_Start | |
| CWNCTConnectionFactory | |
| CWNCTConnectionHandler | |
| CWNJobsWatcher | |
| CWNodeListRenderAction | |
| CWNodeShutdownAction | |
| CWord_substitution | CWord_substitution -- |
| CWord_substitution_Base | CWord_substitution_Base -- |
| CWord_substitution_set | CWord_substitution_set -- |
| CWord_substitution_set_Base | CWord_substitution_set_Base -- |
| oligofar::CWordHash | |
| CWordThresholdArg | Argument class to retrieve and set the word threshold BLAST algorithm option |
| CWorkbench | CWorkbench - default implementation of IWorkbench |
| CWorkbenchFrame | CWorkbenchFrame Main Application Frame for Workbench-based applications |
| CWorkerNodeControlServer | |
| CWorkerNodeIdleTaskContext | Worker Node Idle Task Context |
| CWorkerNodeIdleThread | |
| CWorkerNodeJobContext | Worker Node job context |
| CWorkerNodeJobWatchers | |
| CWorkerNodeRequest | |
| CWorkspaceConstPrx | A workspace proxy MUST be used only on the thread on which it is acquired |
| CWorkspaceFolder | |
| CWorkspaceFolder_Base | CWorkspaceFolder_Base -- |
| CWorkspaceFolderConstPrx | CWorkspaceFolderConstPrx |
| CWorkspaceFolderPrx | CWorkspaceFolderPrx |
| CWorkspaceFormatLoadManager | CWorkspaceFormatLoadManager |
| CWorkspacePrx | CWorkspacePrx |
| CSeqportUtil_implementation::CWrapper_2D< T > | |
| CSeqportUtil_implementation::CWrapper_table< T > | |
| CWrapperUpper | |
| CWriteChoiceVariantHook | Write hook for a choice variant (CHOICE) |
| CWriteClassMemberHook | Write hook for data member of a containing object (eg, SEQUENCE) |
| CWriteDB | CWriteDB |
| CWriteDB_Column | CWriteDB_Column class |
| CWriteDB_ColumnBuilder | Builder for BlastDb format column files |
| CWriteDB_ColumnData | CWriteDB_ColumnData class |
| CWriteDB_ColumnIndex | CWriteDB_ColumnIndex class |
| CWriteDB_File | CWriteDB_IndexFile class |
| CWriteDB_GiIndex | CWriteDB_GiIndex class |
| CWriteDB_GiMask | CWriteDB_GiMask class |
| CWriteDB_GiMaskData | CWriteDB_GiMaskData class |
| CWriteDB_GiMaskIndex | CWriteDB_GiMaskIndex class |
| CWriteDB_GiMaskOffset | CWriteDB_GiMaskOffset class |
| CWriteDB_HeaderFile | This class builds the volume header file (phr or nhr) |
| CWriteDB_Impl | CWriteDB_Impl class |
| CWriteDB_IndexFile | This class builds the volume index file (pin or nin) |
| CWriteDB_Isam | CWriteDB_Isam class |
| CWriteDB_IsamData | CWriteDB_IsamData class |
| CWriteDB_IsamIndex | CWriteDB_IsamIndex class |
| CWriteDB_IsamKey< T > | Class to support searching for duplicate isam keys |
| CWriteDB_IsamKey_Compare< T > | Comparison function for set<CWriteDB_IsamKey<T> *> |
| CWriteDB_PackedBuffer< ALLOCSIZE > | Sortable packed array of null terminated strings |
| CWriteDB_PackedSemiTree | Packed string data container with sorting and iteration |
| CWriteDB_PackedStrings< ALLOCSIZE > | Sortable packed array of strings, optimized for space |
| CWriteDB_PackedStringsCompare | Comparator for sorting null terminated strings |
| CWriteDB_SequenceFile | |
| CWriteDB_Volume | CWriteDB_Volume class |
| CWriteDBException | CWriteDBException |
| CWriteObjectHook | Write hook for a standalone object |
| CWriteObjectInfo | |
| CWriteObjectList | |
| CWriter | |
| CWriter_HTMLEncoder | |
| CWriterBase | Defines and provides stubs for a general interface to a variety of file formatters |
| CWriterByteSourceReader | Stream based byte source reader |
| CWriterCopyByteSourceReader | |
| CWriterSourceCollector | Class adapter IWriter - CSubSourceCollector |
| CSQLITE3_Cache::CWriterThread | Thread for delayed writes |
| CWriteSeqEntryHook | |
| CWriteSeqSetHook | |
| CWriteUtil | |
| CWsdlDataType | |
| CWsdlTypeStrings | |
| CWStream | Writer-based stream |
| CWString | |
| CwxAboutDlg | |
| CwxAbstractTableModel | CwxAbstractTableModel - simple TableModel implementation |
| CwxAlnStatOptionsDlg | |
| CwxAnnotConfigDlg | |
| CwxBoolSorter | |
| CwxCharSorter | |
| CwxChooseSeqDlg | |
| CwxClipboardHelper< T > | |
| CwxClipboardHelper< wxBitmap > | |
| CwxClipboardHelper< wxString > | |
| CwxCSVExportDlg | |
| CwxDemoAlignTableFrame | |
| CwxDemoFeatureTableFrame | |
| CwxDemoTableCtrlFrame | |
| CwxDemoTableModel | |
| CwxDoublePrintfFormat | |
| CwxDoubleSorter | |
| CwxGLTestView | CwxGLTestView |
| CwxGLTestViewFactory | CwxGLTestViewFactory |
| CwxGridTableAdapter | CGridTableQuery |
| CwxHairlineDlg | |
| CwxHistogramDlg | |
| CwxHtmlWindow | |
| CwxIntPrintfFormat | |
| CwxIntWithFlagsFormat | |
| CwxLabelEditDlg | |
| CwxLogDiagHandler | CwxLogDiagHandler - provides a centralized logging facility that integrates both with C++ Toolkit (CDiagHandler) and wxWidgets (wxLog) |
| CwxLongSorter | |
| CwxMainFrame | |
| CwxNCBIApp | CwxNCBIApp - this class should be used in NCBI applications instead of wxApp it provides polling support for CEventHandler and CAppJobDispatcher |
| CwxObject | |
| CwxPhyloEditDlg | |
| CwxPhyloSettingsDlg | |
| CwxScopedObject | |
| CwxScoreDlg | |
| CwxSeqMarkerSetDlg | |
| CwxSeqTextViewOptions | |
| CwxSettingsDlg | |
| CwxSplittingArtProvider | CwxSplittingArtProvider - an adapter for old-style image aliases |
| CwxStringSorter | |
| CwxTableListCtrl | CwxTableListCtrl - generic wxListCtrl-based Table Control |
| CwxTableModelNotice | CwxTableModelNotice |
| CwxTableRow | |
| CwxThemeConfigPanel | |
| CwxTrackNameDlg | |
| CwxTrackSettingsDlg | |
| CwxTreeCtrlEx | |
| CxBlobReader | |
| CxBlobWriter | |
| CXcompareAnnotsApplication | |
| CXmlBaseItem | |
| CXmlClosedBlock | |
| CXmlCloseTagItem | |
| CXMLDataGeneratorToolDummyImpl | |
| CXmlDoctypeItem | |
| CXmlExpandItem | |
| CXmlOpenTagItem | |
| CXmlRetrieveJob | |
| CXmlStyles | |
| CXmlTagWriter | |
| CXmlValueItem | |
| CXmlVersionItem | |
| CXpressratio_result | CXpressratio_result -- |
| CXpressratio_result_Base | Quantitation |
| CXpressratio_summary | CXpressratio_summary -- |
| CXpressratio_summary_Base | Quantitation |
| CXpressratio_timestamp | CXpressratio_timestamp -- |
| CXpressratio_timestamp_Base | CXpressratio_timestamp_Base -- |
| CXref_type | CXref_type -- |
| CXref_type_Base | CXref_type_Base -- |
| CXtra_Terms | CXtra_Terms -- |
| CXtra_Terms_Base | See note 2 |
| CYieldingRWLock | Read/write lock without blocking calls |
| pythonpp::CZeroDivisionError | |
| CZipCompression | CZipCompression -- |
| CZipCompressionFile | CZipCompressionFile -- |
| CZipCompressor | CZipCompressor -- zlib based compressor |
| CZipDecompressor | CZipCompressor -- zlib based decompressor |
| CZipStreamCompressor | CZipStreamCompressor -- zlib based compression stream processor |
| CZipStreamDecompressor | CZipStreamDecompressor -- zlib based decompression stream processor |
| bm::d_copy_func< T > | D-Gap copy functor |
| data_for_lambda_equation | |
| DataLoaderRevoker | |
| CwxDemoTableModel::DataRow | |
| DB_BCPINFO | |
| db_map< K, T > | Db_map template, mimics std::map<> using BerkeleyDB as the underlying Btree mechanism |
| db_map_base< K, T > | Db_map_base |
| db_multimap< K, T > | Db_multimap template, mimics std::multimap<> using BerkeleyDB as the underlying Btree mechanism |
| DBCOL | |
| dbdaterec | |
| DBDATETIME | |
| DBDATETIME4 | |
| DBFunc< THandle, T > | |
| DBFunc< CBioseq_EditHandle, CSeq_inst > | |
| DBFunc< CBioseq_EditHandle, CSeq_inst::TExt > | |
| DBFunc< CBioseq_EditHandle, CSeq_inst::TFuzz > | |
| DBFunc< CBioseq_EditHandle, CSeq_inst::THist > | |
| DBFunc< CBioseq_EditHandle, CSeq_inst::TLength > | |
| DBFunc< CBioseq_EditHandle, CSeq_inst::TMol > | |
| DBFunc< CBioseq_EditHandle, CSeq_inst::TRepr > | |
| DBFunc< CBioseq_EditHandle, CSeq_inst::TSeq_data > | |
| DBFunc< CBioseq_EditHandle, CSeq_inst::TStrand > | |
| DBFunc< CBioseq_EditHandle, CSeq_inst::TTopology > | |
| DBFunc< CBioseq_set_EditHandle, CBioseq_set::TClass > | |
| DBFunc< CBioseq_set_EditHandle, CBioseq_set::TColl > | |
| DBFunc< CBioseq_set_EditHandle, CBioseq_set::TDate > | |
| DBFunc< CBioseq_set_EditHandle, CBioseq_set::TId > | |
| DBFunc< CBioseq_set_EditHandle, CBioseq_set::TLevel > | |
| DBFunc< CBioseq_set_EditHandle, CBioseq_set::TRelease > | |
| DBFunc< CSeq_entry_EditHandle, CSeq_descr > | |
| DBFunc< Handle, CSeq_descr > | |
| dblib_buffer_row | |
| dblib_context | |
| DBMONEY | |
| DBMONEY4 | |
| DBNUMERIC | |
| dboption | |
| dbstring | |
| DBT_ptr | |
| dbtypeinfo | |
| DBVARYCHAR | |
| bm::DeBruijn_bit_position< T > | |
| bm::decoder | Class for decoding data from memory buffer |
| bm::decoder_base | Base class for all decoding functionality |
| bm::decoder_little_endian | Class for decoding data from memory buffer |
| bm::decoder_range_adapter< DEC > | Adapter to get words from a range stream (see range serialized bit-block) |
| DefaultStyle | |
| variation::CHgvsParser::SGrammar::definition< ScannerT > | |
| variation_ref::CHgvsParser::SGrammar::definition< ScannerT > | |
| Deleter< X > | Functor template for deleting object |
| Deleter< _PSIAlignedBlock > | Template specializations to automate deallocation of internal BLAST structures with ncbi::AutoPtr |
| Deleter< _PSIInternalPssmData > | |
| Deleter< _PSIMsa > | |
| Deleter< _PSIPackedMsa > | |
| Deleter< _PSISequenceWeights > | |
| Deleter< BlastHSPStream > | |
| Deleter< SConnNetInfo > | |
| deleter_type | |
| DeltaBlock | |
| des_key | |
| DescDBFunc< Handle > | |
| DescDBFunc< CSeq_entry_EditHandle > | |
| DescEditAction< TEditHandle, add > | |
| DescEditAction< TEditHandle, false > | |
| bm::deseriaizer_base< DEC > | Base deserialization class |
| bm::deserializer< BV, DEC > | Class deserializer |
| DestinationFile | |
| Destroyer< P > | |
| dfa_match_data | |
| DFS | |
| bm::bvector< Alloc >::iterator_base::dgap_descr | Information about current DGAP block |
| DiagHashCell | Structure for keeping last hit information for a diagonal in a hash table, when eRight or eRightAndLeft methods are used for initial hit extension |
| diagStr | |
| DiagStruct | Structure for keeping last hit information for a diagonal |
| DiscNucleotideOptionsHandleFixture | |
| Dispatcher | |
| DisplayRow | |
| DisplayRowFromAlignment | |
| DisplayRowFromSequence | |
| DisplayRowFromString | |
| bm::distance_metric_descriptor | Distance metric descriptor, holds metric code and result |
| DistanceMatrix | |
| distanceReportStr | |
| DistanceSelectDialog | |
| DM_AlignedScore | |
| DM_BlastScore | |
| DM_Identities | |
| DMAlignedOptimalScore | |
| xml::impl::doc_impl | |
| xml::document | The xml::document class is used to hold the XML tree and various bits of information about it |
| xml::document_proxy | The xml::document_proxy class to be a relay between XSLT results and the document |
| CDisplaySeqalign::DomainInfo | Structure for showing domains on the master sequence |
| DoNotBelieveFrameShiftsWithoutCdsEvidence | |
| DoNotBelieveShortPolyATail | |
| DP_AlignmentResult | |
| DP_BlockInfo | |
| DP_MultipleAlignmentResults | |
| DPApp | |
| ds_cmp< T, Pred > | Strict weak ordering for pairs (by first) Used by CreateDensegFromDisc |
| DState | |
| DSTR_STRUCT | |
| xml::dtd | The xml::dtd class represents an XML dtd from a file |
| xml::impl::dtd_impl | |
| DTDAttribute | |
| DTDElement | |
| DTDEntity | |
| DTDEntityLexer | |
| DTDLexer | |
| DTDParser | |
| dup_lookup_table | |
| CPhyloTreeDataSource::dynamic_to_tree | |
| DynProgProb | |
| DynProgProbLim | |
| DynProgProbProto | |
| CPhyloTreePS::Edge | Data structure for an edge between two nodes |
| Element | |
| CAttrRangeCollection< Attr, Position >::element_proxy | |
| CString2Args::empty_string_remover | Functor to help remove empty strings from a container |
| bm::encoder | Memory encoding |
| BondStyle::EndStyle | |
| CSeqMaskerUsetArray::entry | |
| bm::bvector< Alloc >::enumerator | Constant input iterator designed to enumerate "ON" bits |
| xml::impl::epimpl | |
| eptrblock | |
| EResidue | |
| erfc_table | Tabulated results for faster erfc(x) lookup |
| ErrCode | ErrCode -- |
| error | |
| pvalues::error | |
| error_for_single_realization | |
| xml::error_message | The xml::error_message class is used to store a single error message which may appear while parsing or validating an XML document |
| xml::error_messages | The xml::error_messages class is used to store all the error message which are collected while parsing or validating an XML document |
| EState | |
| xml::event_parser | The xml::event_parser is used to parse an XML document by calling member functions when certain things in the XML document are parsed |
| CSeqMaskerOstatOpt::Exception | Exceptions that CSeqMaskerOstatOpt might throw |
| xml::exception | This exception class is thrown by xmlwrapp for all runtime XML-related errors along with the xml::parser_exception |
| CSeqMaskerIstatBin::Exception | Exceptions that CSeqMaskerIstatBin might throw |
| CSeqMaskerIstatFactory::Exception | Exceptions that CSeqMaskerIstatFactory might throw |
| CSeqMaskerIstatOAscii::Exception | Exceptions that CSeqMaskerIstatOAscii might throw |
| CSeqMaskerUsetSimple::Exception | Exceptions that CSeqMaskerUsetSimple might throw |
| CWinMaskCountsConverter::Exception | Class defining exceptions specific to CWinMaskCountsConverter |
| CSeqMaskerIstatOBinary::Exception | Exceptions that CSeqMaskerIstatOBinary might throw |
| CSeqMaskerUsetHash::Exception | Exceptions that CSeqMaskerUsetHash can throw |
| CSeqMaskerUsetArray::Exception | Exceptions that CSeqMaskerUsetArray might throw |
| CSeqMaskerIstatAscii::Exception | Exceptions that CSeqMaskerIstatAscii might throw |
| CMaskReader::Exception | Exceptions thrown by CMaskReader class |
| EXCEPTION_VIRTUAL_BASE public CCgiException | |
| EXCEPTION_VIRTUAL_BASE public CCgiRequestException | |
| EXCEPTION_VIRTUAL_BASE public CCoreException | |
| EXCEPTION_VIRTUAL_BASE public CGeneralException | |
| EXCEPTION_VIRTUAL_BASE public CObjReaderException | |
| EXCEPTION_VIRTUAL_BASE public CSeqsetException | |
| EXCEPTION_VIRTUAL_BASE public CUrlException | |
| ExtendableBlock | |
| ExtendInfo | |
| FailingMockSeqSrcTestFixture | Initializes m_SeqSrc with a BlastSeqSrc that always fails |
| CCdFromFasta::Fasta2CdParams | |
| FBlockSplitterLayout | |
| FClientCreator | |
| FCountWindowsWithFingerprint | |
| CDisplaySeqalign::FeatureInfo | Structure for store feature display info |
| FFindHiddenClient | |
| FFindVisibleNode | |
| FHideAllNodes | |
| db_map_base< K, T >::File | |
| FileInfo | |
| FileMessagingManager | |
| FileMessenger | |
| bm::first_bit_table< T > | Structure keeps index of first right 1 bit for every byte |
| tree< T, tree_node_allocator >::fixed_depth_iterator | |
| FlexiDm | |
| FloatingPointSpinCtrl | |
| FloatingPointTextCtrl | |
| FNodeFingerprintEquals | |
| FNodeHasFingerprint | |
| CGlFeedbackFont::FPackChar | |
| ncbi::boost_fp_impl::tt_detail::fpt_limits< FPT > | |
| ncbi::boost_fp_impl::fraction_tolerance_t< FPT > | |
| FSaveSplitterLayout | |
| FSplitterRestorer | Saving and Loading Layouts Loads a full layout tree from the given CUser_object IWMClientFactory is used for instantiating the clients refered by the layout |
| func_info | |
| FWeightedSum | |
| bm::gamma_decoder< T, TBitIO > | Elias Gamma decoder |
| bm::gamma_encoder< T, TBitIO > | Functor for Elias Gamma encoding |
| bm::gap_len_table< T > | Default GAP lengths table |
| bm::gap_len_table_min< T > | Alternative GAP lengths table. Good for for memory saver mode and very sparse bitsets |
| bm::blocks_manager< Alloc >::gap_level_func | |
| bm::gap_transpose_engine< GT, BT, BLOCK_SIZE > | Bit-plain splicing of a GAP block |
| gap_vector | |
| GapEditScript | Edit script: linked list of correspondencies between two sequences |
| GapPrelimEditBlock | Preliminary version of GapEditBlock, used directly by the low- level dynamic programming routines |
| GapPrelimEditScript | A version of GapEditScript used to store initial results from the gapped alignment routines |
| GapStateArrayStruct | Structure to keep memory for state structure |
| CWinMaskCountsGenerator::GenCountsException | Exceptions that CWinMaskCountsGenerator may throw |
| GeneralRefinerParams | |
| StyleSettings::GeneralStyle | |
| getcontig | |
| GetFloatingPointDialog | |
| GetTypeWhenNotEqual< Type, NotType > | Helper template returning some Type when it's not equal to NotType |
| GetTypeWhenNotEqual< Type, Type > | |
| GiFootPrint | |
| GlZoomSpec::GlDim | |
| bm::globals< T > | Internal structure |
| GlZoomSpec | |
| GPermutatorCallback | |
| GreedyBoundaryExtender | |
| GroupUpdater | |
| gz_header_s | |
| gz_stream | |
| hash< _Key > | |
| hash< CEventHandler * > | |
| hash< char * > | |
| hash< char > | |
| hash< const char * > | |
| hash< const string > | |
| hash< int > | |
| hash< long > | |
| hash< short > | |
| hash< signed char > | |
| hash< string > | |
| hash< unsigned char > | |
| hash< unsigned int > | |
| hash< unsigned long > | |
| hash< unsigned short > | |
| hashtable< _Val, _Key, _HF, _ExK, _EqK, _All > | |
| HasNoExons | |
| HasShortIntron | |
| HasValue< Cont > | |
| Helix3D | |
| HelixStyle | |
| HitDistributor | |
| hitStr | |
| HMACMD5Context | |
| COligoSpecificityCheck::Hsp_index | |
| ITreeIterator::I4Each | |
| I_BaseCmd | I_BaseCmd:: |
| I_BCPInCmd | |
| I_Connection | I_Connection:: |
| I_ConnectionExtra | |
| I_CursorCmd | |
| I_DriverContext | |
| I_ITDescriptor | I_ITDescriptor:: |
| I_LangCmd | I_LangCmd:: I_RPCCmd:: I_BCPInCmd:: I_CursorCmd:: I_SendDataCmd:: |
| I_Result | I_Result:: |
| I_RPCCmd | |
| I_SendDataCmd | |
| IAbstractCitation | Basic citation GetLabel interface, suitable both for actual citation objects such as CCit_* and containers such as CPub |
| CNSInfoCollector::IAction< TInfo > | |
| IAgpRowOutput | |
| oligofar::IAligner | |
| IAlignMarkHandlerHost | Interface IAlignMarkHandlerHost |
| IAlignmentFactory | |
| IAlignmentFilter | |
| oligofar::IAlignmentMap | |
| IAlignmentScorer | |
| IAlignRow | Interface IAlignRow - abstracts row rendering in Multiple Alignment Widget |
| IAlignRowHandle | IAlignRowHandle provides an abstract way to access alignment row data |
| IAlignRowHost | IAlignRowHost represents a context in which IAlignRow lives |
| CAlignSort::IAlignSortedOutput | |
| IAlignSource | |
| IAlnExplorer | Alignment explorer interface |
| IAlnGraphicDataSource | IAlnGraphicDataSource - interface to a data source representing an abstract alignment used in graphical view |
| IAlnMultiDataSource | IAlnMultiDataSource - interface to a data source representing an abstract multiple alignment |
| IAlnMultiHeaderContext | IAlnMultiHeaderContext |
| IAlnMultiPaneParent | Interface IAlnMultiPaneParent represents a context in which an instance of CAlnMultiPane lives |
| IAlnMultiRendererContext | IAlnMultiRendererContext - this interface represents context in which CAlnMultiRenderer lives |
| IAlnRowGraphProperties | IAlnRowGraphProperties |
| IAlnSegment | Alignment segment interface |
| IAlnSegmentIterator | Alignment segment iterator interface |
| IAlnSeqId | Wrapper interface for seq-ids used in alignments |
| IAlnVecRowGraph | IAlnVecRowGraph - abstract graph that can be rendered in the "expandable" space below the CAlnVecRow |
| IAMHeaderHandlerHost | IAMHeaderHandlerHost |
| IAppJob | IAppJob |
| IAppJobEngine | IAppJobEngine |
| IAppJobEngineListener | IAppJobEngineListener - receives notifications about changes in job state |
| IAppJobEngineParams | IAppJobEngineParams A base class for Engine Parmeters classes |
| IAppJobError | IAppJobError |
| IAppJobProgress | IAppJobProgress |
| IAppNamedPipeClient | IAppNamedPipeClient is an interface that must be implemented by extension that is to be registered at AppNamedPipe extension point |
| IAppTask | IAppTask |
| IAsnLoadExtension | IAsnLoadExtension is interface of extension point to register ASN types in packages, to be loaded by ASN loader |
| IAsnLoadRegister | IAsnLoadRegister - interface to register ASN types that could be loaded by ASN loader |
| IAsyncInterface | Interface defines async |
| IAutoDefCombo | |
| IAuxiliaryManagedWrapperGeneratorTool | |
| IBDB_Field | BDB Data Field interface definition |
| IBDB_FieldConvert | BDB Data Field conversion interface definition |
| IBioseqSource | Interface to a source of Bioseq objects |
| IBISAnnotateDialog | |
| IBISInteraction | |
| IbisQuery | |
| IBlastCmdLineArgs | BLAST Command line arguments design The idea is to have several small objects (subclasses of IBlastCmdLineArgs) which can do two things: 1) On creation, add flags/options/etc to a CArgs object 2) When passed in a CBlastOptions object, call the appropriate methods based on the CArgs options set when the NCBI application framework parsed the command line |
| IBlastDbAdapter | Interface that provides a common interface to retrieve sequence data from local vs |
| IBlastQuerySource | Lightweight wrapper around an indexed sequence container |
| IBlastSeqInfoSrc | Abstract base class to encapsulate retrieval of sequence identifiers |
| IBlastSeqVector | Lightweight wrapper around sequence data which provides a CSeqVector-like interface to the data |
| IBlastXMLReportData | Interface for filling the top layer of the XML report |
| IBlobStorage | Blob Storage interface |
| IBlobStorageFactory | Blob Storage Factory interface |
| IBookmarksHandlerHost | IBookmarksHandlerHost |
| IBoundaryShape | IBoundaryShape -- |
| IBulkInsert | IBulkInsert -- |
| ICache | BLOB cache read/write/maintenance interface |
| ICallableStatement | ICallableStatement -- |
| oligofar::CSeqVecProcessor::ICallback | |
| oligofar::IAlignmentMap::ICallback | |
| ICanceled | Interface for testing cancellation request in a long lasting operation |
| ICgiSessionStorage | ICgiSessionStorage -- |
| IChunkHandler | Interface class to scan data source for seekable data chunks |
| ICitationBase | GetLabel interface for actual citation objects, as opposed to mere containers such as CPub |
| IClassFactory< TClass > | IClassFactory<> -- |
| IClickAction | |
| CSeqSearch::IClient | Client interface: ================== A class that uses the SeqSearch facility should implement the Client interface and register itself with the search utility to be notified of matches detection |
| IClipboardHandler | |
| ICmdUI | ICmdUI - interface for updating command GUI elements such as menu itms and tool bar buttons |
| IColumnScoringMethod | IColumnScoringMethod - column-based method |
| IComboChartDataSource | Interface IComboChartDataSource |
| ICompilerTool | ICompilerTool -- |
| ICompression | |
| IConfigMediator | |
| IConfigPanel | |
| IConfiguration | IConfiguration -- |
| IConnection | |
| IConnValidator | IConnValidator |
| ICoordMapper | ICoordMapper interface for converting location between two coordinate systems |
| ICreateParams | |
| ICursor | ICursor -- |
| ICurve | Class ICurve defines a basic interface for all curves |
| ICustomBuildTool | Dummies - Name - only tools. Must present in msvc proj: |
| IDataArray | Interface IDataArray |
| IDataLoaderProvider | IDataLoaderProvider - an interface representing a Data Source |
| IDataMiningContext | IDataMiningContext IDataMiningContext represents an abstract context for a Search |
| IDataSource | IDataSource -- |
| IDBConnectionFactory | IDBConnectionFactory |
| IDBServiceMapper | IDBServiceMapper |
| IDeleteObjectsCommand | |
| IDeleteParams | |
| IDictionary | Class IDictionary defines an abstract interface for dictionaries |
| IDMContextMenuContributor | IDMContextMenuContributor - contributes menu to Data Mining Service |
| IDMSearchForm | IDMSearchForm - interface for abstract Search From |
| IDMSearchFormController | IDMSearchFormController - interface representing an entity that controls the lifecycle of search Form and Tool |
| IDMSearchQuery | IDMSearchQuery - abstract data mining query |
| IDMSearchTool | IDMSearchTool interface representing a single search tool in Data Mining Service |
| IDockableWindow | IDockableWindow - repersents a window that can be docked in Dock Manager |
| IDockContWindow | IDockContWindow - abstract window container for use with Dock Manager |
| IDockDropTarget | IDockDropTarget - interface representing a component that can serve as a drop target during D&D docking |
| IDockManagerKeyHook | IDockManagerKeyHook |
| IDockPanel | IDockPanel |
| IEditAction | |
| IEditCommand | Interface (functor) for object editing |
| IEditObject | GUI editing interface |
| IEditSaver | Edit Saver Interface |
| IEditsDBEngine | |
| IEmbeddedStreamWriter | |
| CSnpBitfield::IEncoding | |
| IEnvRegMapper | IEnvRegMapper -- |
| IErrorContainer | |
| IEventAttachment | Object, that will be attached to event |
| CNetScheduleAPI::IEventHandler | This class is for use by the grid_cli utility only |
| IEventListener | |
| IEventLogService | IEventLogService - records application events |
| IEventRecord | IEventRecord |
| IEventRecordAction | IEventRecordAction |
| IEvidence | |
| IExpandable | |
| IExplorerItemCmdContributor | IExplorerItemCmdContributor - interface representing a component that contributes commands applicable to Explorer Items |
| IExplorerItemSelectionSource | IExplorerItemSelectionSource - the interface that provides selection to CAppExplorerCmdHandler |
| IExporterFactory | IViewFactory |
| IExtension | IExtension IExtension interface represents an abstract pluggable component |
| IExtensionPoint | IExtensionPoint |
| IExtensionRegistry | IExtensionRegistry IExtensionRegistry is an interface representing a Registry where Extension Points and Extensions are registered |
| IFastaEntryScan | Callback interface to scan fasta file for entries |
| IFeatComparator | IFeatComparator |
| IFileFormatLoaderManager | IFileFormatLoaderManager |
| IFilesToProjectInserter | |
| IFindContext | |
| IFlatItem | |
| IFlatQVal | |
| IFlatTextOStream | |
| IFNameValidator | |
| IFormatter | |
| IGBProject | IGBProject - abstract interface for a project used by CGBProjectHandle |
| IGeneInfoInput | IGeneInfoInput |
| IGenericHandlerHost | IGenericHandlerHost |
| IGlBuffer< T > | IGlBuffer This class provides and abstract interface for an OpenGL buffer |
| IGlEventHandler | IGlEventHandler |
| IGlFont | |
| IGlyphDialogHost | IGlyphDialogHost An interface used for handling issues related to any dialog pops up that requires some special cares, such as disallow tooltip pop up from the underlying objects |
| CSeqGlyph::IGlyphRenderer | Layout renderer interface |
| IGlyphVisitor | Visitor interface for applying any potential actions or algorithms |
| IGraph | IGraph |
| IGraphContainerHost | IGraphContainerHost |
| IGraphDataSource | IGraphDataSource |
| IGridTableAdapter | |
| IGridWorkerNodeApp_Listener | Listener of events generated by CGridWorkerNodeApp |
| oligofar::IGuideFile | |
| IGuiObjectInfo | |
| IGuiPackage | TODO - Document |
| IGuiSeqInfo | |
| IHelpHandler | |
| IHelpService | IHelpService TODO - this is just a placeholder, the interface needs to be extended |
| CMainFrame::IHintListener | IHintListener - an interface for a component that shows command help hints |
| IHistogramGraphDS | IHistogramGraphDS interface |
| IHit | IHit |
| IHitElement | IHitElement |
| IHitMatrixDataSource | IHitMatrixDataSource - abstract Data Source for Hit Matrix Widget |
| IHitMatrixGraphHost | IHitMatrixGraphHost |
| IHitSeqId | IHitSeqId - abstract identifier of a sequence in an alignment |
| IIconProvider | IIconProvider interface for tracks providing track icons |
| IIdGenerator< T > | Templated interface for a generator of identifiers (IDs) of any type |
| IIdMapper | General IdMapper interface |
| IImageGrabber | |
| IImageGrabberProgress | |
| IInterfaceFactory | |
| IInterruptible | Interface describing interruptability of a job or process |
| IItemsProvider | |
| IItemWithDescription | |
| IIterationBeginner | |
| ILabelHandler | ILabelHandler interface |
| ILayoutPolicy | Class ILayoutPolicy defines the abstract interface required for generating layout based on a set of given CSeqGlyphs (layout objects) |
| ILayoutTrackFactory | ILayoutTrackFactory |
| ILayoutTrackHost | ILayoutTrackHost An interface used for handling GUI-related events, such as layout change event that requires refresh the screen, zoom event that requires zooming to a certain range, and menu event that pops up a context-sensitive menu |
| ILegendDataSource | ILegendDataSource |
| ILegendHandlerHost | Class ILegendHandlerHost |
| ILengthGetter | Interface for getting bioseq length |
| ILibrarianTool | ILibrarianTool -- |
| ILineError | |
| ILineReader | Abstract base class for lightweight line-by-line reading |
| ILinkerTool | ILinkerTool -- |
| ILinkoutDB | Setting up scope |
| CScoreCache::IListener | |
| CDataChangeNotifier::IListener | CDataChangeNotifier listener receiving notification about changes in data(source) |
| ILocalQueryData | Provides access (not ownership) to the C structures used to configure local BLAST search class implementations |
| ILocMapper | |
| IManagedWrapperGeneratorTool | |
| oligofar::IMappedAlignment | |
| IMapper_Sequence_Info | IMapper_Sequence_Info |
| IMaskDataSource | An interface providing lookups of mask-data by Seq-id |
| IMemento | IMemento - abstract base for Memento objects |
| IMementoOriginator | IMementoOriginator |
| IMenuContributor | IMenuContributor - contributes menu to Menu Service |
| IMenuService | IMenuService - Menu Service |
| IMergeBlob | BLOB merge interface, merges one or more BLOBs together |
| IMergeStore | Interface to store merged BLOBs |
| IMergeVolumeWalker | Interface to traverse volume for merge |
| IMIDLTool | |
| IMinimapHandlerHost | Interface IMinimapHandlerHost represents a context in which CMinimapHandler functions |
| IMockBlastSeqSrc | Abstract base class which defines a common interface for mock BlastSeqSrc objects to implement |
| IMouseZoomHandlerHost | Interface IMouseZoomHandlerHost represents a context in which CMouseZoomHandler functions |
| CDataTypeModule::Import | |
| importance_sampling | |
| IMsvcMetaMakefile | Interface of master msvc makefile |
| IMsvcProjectMakefile | Interface of msvc project makefile |
| INcbi2naRandomizer | |
| INcbiIdler | Interface for application idler |
| ncbi::INcbiToolkit_LogHandler | Logging interface |
| INCBlockedOpListener | |
| Indent | |
| IndexAlnLocToSeqLocRow | |
| INetServerConnectionListener | |
| INetServerFinder | |
| INextDiagMessage | Callback interface for stream parser |
| inflate_state | |
| InfoContentColumnScorer | |
| xml::init | The xml::init class is used to configure the XML parser |
| xslt::init | The xslt::init class is used to configure the XSLT engine |
| bm::bvector< Alloc >::insert_iterator | Output iterator iterator designed to set "ON" bits based on input sequence of integers (bit indeces) |
| IntegerSpinCtrl | |
| IntegerTextCtrl | |
| internal_state | |
| CSRSearch::InternalException | |
| oligofar::INucSeq | |
| IObjDeMux< TObj > | Abstract object demultiplexer |
| IObjectBasedGlyph | File Description: |
| IObjectCmdContributor | IObjectCmdContributor - contributes commands applicable to scoped objects |
| IObjectCombinator | |
| IObjectConverter | Helper class for single object conversion from static type to work type |
| IObjectCreator | |
| IObjectInterfaceFactory | |
| IObjectListAccValidator | |
| IObservable | IObservable interface |
| IObserver | IObserver |
| IObserverUpdate | IObserverUpdate |
| IOpenViewManager | IOpenViewManager - interface dealing with a series of open view operations |
| IOperationTest | |
| IOptionsDlgExtension | IOptionsDlgExtension - abstract provider of dialog panels for "Options" dialog |
| oligofar::IOutputFormatter | |
| CSeqConvert::IPackTarget | |
| IPhyGraphicsNode | |
| IPhyloTreeFilter | |
| IPhyloTreeLOD | |
| IPhyloTreeReader | |
| IPhyloTreeRenderer | |
| IPhyloTreeRendererHost | |
| IPhyloTreeVisitor | |
| IPhyNode | |
| IPieDataSource | IPieDataSource |
| IPostBuildEventTool | |
| IPreBuildEventTool | Not a dummy for lib projects |
| IPrefetchAction | |
| IPrefetchActionSource | |
| IPrefetchListener | |
| IPreLinkEventTool | |
| CPipe::IProcessWatcher | Callback interface for ExecWait method |
| oligofar::IProgressIndicator | |
| IProjectFilter | Filter for projects in project tree |
| CProjectFolder::IProjectItemVisitor | |
| IProjectSelectionSource | IProjectSelectionSource |
| IProjectView | Class IProjectView defines the abstract interface for views observing projects |
| IProjectViewFactory | IProjectViewFactory |
| CWorkspaceFolder::IProjectVisitor | |
| IPropertiesPanel | IPropertiesPanel - abstract dialog panel representing properties of a method |
| IPssmInput_Base | Base class for the IPssmInputData and IPssmInputFreqRatios interfaces, provided to avoid duplicating the methods that are common to both interfaces |
| IPssmInputCdd | Interface for strategy to pre-process multiple alignment of conserved domains matches as input data for PSSM engine |
| IPssmInputData | Abstract base class to encapsulate the source(s) and pre-processing of PSSM input data as well as options to the PSI-BLAST PSSM engine |
| IPssmInputFreqRatios | Interface used to retrieve the PSSM frequency ratios to allow for "restart" processing in PSI-BLAST: Given a preliminary |
| IPssmSearch | Experimental interface (since this does not provide a full interface to PSI-BLAST) |
| IQueryDataSource | Class IQueryDataSource |
| IQueryFactory | Source of query sequence data for BLAST Provides an interface for search classes to retrieve sequence data to be used in local/remote searches without coupling them to the actual means of retrieving the data |
| IQueryParseUserObject | Base class for query node user defined object |
| IQueryWidget | IQueryWidget |
| ir_diag_data_ | Part of the hash table entry describing the diagonal |
| ir_diag_hash_ | Hash table structure |
| ir_fp_entry_ | Free memory block structure |
| ir_hash_entry_ | Hash table entry |
| IRawRepeatRegion | Minimalist pure virtual (except destructor) interface defining a read-only RepeatMasker repeat feature |
| IRawSequenceSource | Interface to a source of raw sequence data |
| IReader | A very basic data-read interface |
| IReaderWriter | A very basic data-read/write interface |
| IRegistry | IRegistry -- |
| IRegSettings | IRegSettings An interface for objects that save / restore settings using CGuiRegistry |
| IRemoteQueryData | |
| IRenderable | IRenderable class IRenderable defines an abstract interface required for rendering graphical panels in the given space (see CGlPane) |
| IRepeat | Minimalist pure virtual (except destructor) interface defining a read-only RepeatMasker library repeat |
| IRepeatRegion | Interface defining a read-only RepeatMasker repeat feature |
| IReporter | |
| CWorkerNodeControlServer::IRequestProcessor | |
| IResourceCompilerTool | IResourceCompilerTool -- |
| IResultSet | |
| IResultSetMetaData | IResultSetMetaData -- |
| IRmReaderFlags | Pure interface to define flags controlling how repeats are read from RepeatMasker output into a Seq-feat |
| IRowFilter | |
| IRowScoringMethod | IRowScoringMethod - row-based method |
| IRowSorter | |
| IRWLockHolder_Factory | Interface for factory creating CRWLockHolder objects |
| IRWLockHolder_Listener | Interface for receiving messages about state changes in CRWLockHolder |
| IRWRegistry | IRWRegistry -- |
| Is_ID_equal | |
| IScatterDataSource | IScatterDataSource |
| IScheduledAppJob | |
| IScheduler | Task scheduler interface |
| IScheduler_Listener | Interface to get notifications about selected changes in the scheduler timeline |
| IScheduler_Task | General interface for scheduled tasks |
| IScopeTransaction_Impl | |
| CScoreLookup::IScore | |
| oligofar::IScore | |
| IScoringAlignment | IScoringAlignment |
| IScoringMethod | IScoringMethod represents an abstract algorithm for calculating alignment scores and assigning colors to residues |
| IsCRef< T > | |
| IsCRef< CSeq_descr > | |
| ISearch | Single Iteration Blast Database Search |
| ISearchFactory | Factory for ISearch |
| ISelectionClient | ISelectionClient - represents an object that support a notion of selection |
| ISelectionService | ISelectionService - an interface |
| CUIToolRegistry::ISelector | |
| ISelHandlerHost | Class ISelHandlerHost |
| ISelListModel< Item > | Interface ISelListModel |
| ISelListView< Item > | Interface ISelListView |
| ISelObjectHandle | |
| ISeq_feat | |
| ISeq_idSource | |
| ISeqDBDemoCase | Demo case base class |
| CGBReleaseFile::ISeqEntryHandler | Interface for handling Seq-entry objects |
| ISeqFeatDeleteParams | |
| ISeqIdResolver | Interface for resolving a sequence identifier given a textual representation |
| ISeqLocSearchContext | ISeqlocSearchContext |
| ISeqMarkHandlerHost | Class ISeqMarkHandlerHost |
| ISeqSearch | Single Iteration Search of Sequence(s) Against Blast Database(s) |
| ISeqTaskProgressCallback | Task clients implement this callback interface |
| ISeqTextGeometry | Class ISeqTextGeometry |
| ISeqTextWidgetHost | Class ISeqTextWidgetHost |
| ISequenceSet | |
| ISequenceSource | |
| ISequenceTextGraphHost | Class ISequenceTextGraphHost |
| IServer_ConnectionBase | |
| IServer_ConnectionFactory | IServer_ConnectionFactory:: |
| IServer_ConnectionHandler | IServer_ConnectionHandler:: |
| IServer_LineMessageHandler | IServer_LineMessageHandler:: |
| IServer_MessageHandler | IServer_MessageHandler:: |
| IServer_Monitor | Base interface for monitoring |
| IServer_StreamHandler | IServer_StreamHandler:: |
| IService | IService – an abstraction that represents an application component providing specific functional capabilities via a special interface |
| IServiceLocator | IServiceLocator - an abstract mechanism for locating services |
| IServiceLocatorConsumer | IServiceLocatorConsumer - classes that need IServiceLocator should implement this interface |
| ISGDataSource | File Description: |
| ISGDataSourceContext | ISGDSManager is seqgraphic data source manage that serves as an data source context |
| ISGDataSourceType | ISGDataSourceFactory |
| IsGene_commentaryHeading | |
| IsGene_commentaryHeadingAndType | |
| IsGene_commentaryType | |
| oligofar::IShortRead | |
| oligofar::IShortReader | |
| IsStandard | |
| IStatement | |
| IStatusBarService | |
| IStickyTooltipHandlerHost | IStickyTooltipHandlerHost - Class from which windows that want to support sticky tooltips ultimately need to be derived |
| IStringDecoder | CStringPairsParser -- |
| IStringEncoder | Encoder interface. Names and values can be encoded with different rules |
| CSeq_loc::ISubLocFilter | Used as a helper for determining which pieces of a CSeq_loc to compare |
| ISynonymMapper | Interface for mapping IDs to the best synonym |
| ITableData | |
| ITableFilter | |
| ITagWriter | |
| ITaskProgressCallback | Task clients implement this callback interface |
| ITaxon1Node | |
| ITaxonomyResolver | Interface for looking up taxonomy IDs given taxonomic names |
| ItDescriptorMaker | |
| ITemplateUITool | ITemplateUITool |
| xml::node_set::iterator | The xml::node_set::iterator class is used to iterate over nodes in a node set |
| xml::attributes::iterator | Iterator class for accessing attribute pairs |
| pythonpp::CSequnceHelper< T >::iterator | |
| IEvidence::iterator | |
| CWriteDB_PackedSemiTree::Iterator | Class providing iteration over string data |
| xml::node::iterator | The xml::node::iterator provides a way to access children nodes similar to a standard C++ container |
| db_map_base< K, T >::iterator_base | |
| tree< T, tree_node_allocator >::iterator_base | |
| bm::bvector< Alloc >::iterator_base | Base class for all iterators |
| tree< T, tree_node_allocator >::iterator_base_less | |
| bm::iterator_deserializer< BV, SerialIterator > | Iterator to walk forward the serialized stream |
| ITextItem | |
| IThemeConfigPanelBase | IThemeConfigPanelBase |
| IThreadSafeIdGenerator< T > | Thread-safe version of IIdGenerator |
| ITool | ITool -- |
| IToolBarContext | IToolBarContext - represent a UI object that requires toolbars |
| IToolBarFactory | IToolBarFactory - a factory that produces toolbars |
| IToolBarService | IToolBarService |
| ITooltipHandlerHost | |
| ITrackConfigurable | ITrackConfigurable interface for tracks that are configurable |
| ITrackContainer | ITrackContainer The interface for layout track that is also a container of tracks |
| ITrackHandlerHost | ITrackHandlerHost ITrackHandlerHost represents a context for handling the user interactions on a layout track |
| ITrackInitObserver | ITrackInitObserver: interface class work as an observer of a track that is responsible of intializing subtracks |
| ITransaction | Transaction interface |
| ITransactional | Interface for transactional objects |
| ITransactionalRegistry | Registration of transactional objects |
| ITransferable | |
| ITreeIterator | |
| ITSE_Assigner | |
| ITypeConverter | |
| ITypedDataArray< Type > | Class ITypedDataArray<Type> |
| IUIAlgoToolManager | IUIAlgoToolManager is a IUIToolManager that represents an algorithmic tool |
| IUIDataSource | IUIDataSource - an interface representing a Data Source |
| IUIDataSourceType | IUIDataSourceType - defines a type of a Data Source, can serve as a Data Source factory |
| IUIExportTool | IUIExporter is a IUIToolManager that represents an export tool |
| IUIObject | IUIObject - object that provides basic properties often required in a UI object |
| IUITool | IUITool represents an abstract algorithm that is bound to a UI component |
| IUIToolManager | |
| IUIToolWithGUI | IUIToolWithGUI - represents a method that can be integrated in GUI |
| IUndoManager | Undo/Redo interface for editing operations |
| IUrlEncoder | IUrlEncoder:: |
| IUserObjectConvertible | IMemento - abstract base for Memento objects |
| IView | IView - represents a standard visual part of Workbench UI |
| IViewFactory | IViewFactory - view factory for use with IViewManagerService |
| IViewManagerService | IViewManagerService IViewManagerService manages views in Workbench |
| IVisibleRangeClient | IVisibleRangeClient - represents an object that wants notifications about visible range changes |
| IVisibleRangeService | IVisibleRangeService - an interface |
| IWebServiceProxyGeneratorTool | Dummies - Name - only tools. Must present in msvc proj: |
| IWindowManager | IWindowManager - the callback interface to Window Manager used by its components |
| IWindowManagerAdvisor | IWindowManagerAdvisor |
| IWindowManagerMenuListener | |
| IWindowManagerService | IWindowManagerService Window Manager Service provides access to Window Manager functionality |
| IWindowScoringMethod | IWindowScoringMethod - Method that can be windowed, i.e |
| IWMClient | IWClient - abstract Window Manager client |
| IWMClientFactory | IWMClientFactory - IWMClient factory |
| IWorkbench | IWorkbench is the central interface in the application framework |
| IWorkbenchAdvisor | IWorkbenchAdvisor This is an interface that assists IWorkbench in carrying out its functions |
| IWorkerNodeCleanupEventListener | |
| IWorkerNodeCleanupEventSource | Clean-up event source for the worker node |
| IWorkerNodeIdleTask | Worker Node Idle Task Interface |
| IWorkerNodeInitContext | Worker Node initialize context |
| IWorkerNodeJob | Worker Node Job interface |
| IWorkerNodeJobFactory | Worker Node Job Factory interface |
| IWorkerNodeJobWatcher | Jobs watcher interface |
| IWriter | A very basic data-write interface |
| IwxDecoratedTableModel | IwxDecoratedTableModel |
| IwxMapItem | IwxMapItem Abstarct item of the Map Control |
| IwxRowModel | |
| IwxStringFormat | |
| IwxTableModel | |
| IwxTableModelListener | IwxTableModelListener |
| IwxVariantSorter | |
| IXMLDataGeneratorTool | |
| Kappa_compactSearchItems | Structure used to pass data into the scaling routines |
| Kappa_posSearchItems | Structure used to pass data into the scaling routines |
| keyqualval | |
| StyleSettings::LabelStyle | |
| LeaveOneOutParams | |
| LeftEndOrder | |
| LeftOrder | |
| LeftOrderD | |
| CAnalysisFile::less_icase | |
| LessByFootPrint | |
| LessBySeqId | |
| LessThan | |
| LetterAndScoreDifferencePair | Structure used as a helper for sorting matrix according to substitution score |
| xml::libxml2_document | Extension to the xml::document class which allows working with raw libxml2 documents |
| LinkedHSP | Linked list of HSPs used to store hsps in culling tree |
| LinkedHSP_BH | Linked list of HSPs used to keep best hits for each query |
| LinkHelpStruct | The helper array contains the info used frequently in the inner for loops of the HSP linking algorithm |
| LinkHSPStruct | Structure containing all information internal to the process of linking HSPs |
| LinkHspTestFixture | |
| ListNode | A generic linked list node structure |
| LocalMaxStat | |
| LocalMaxStatMatrix | |
| lock_type | |
| locker_type | |
| LOG_tag | |
| LookupTableOptions | Options needed to construct a lookup table Also needed: query sequence and query length |
| LookupTableWrap | Wrapper structure for different types of BLAST lookup tables |
| LowSupport_Noncoding | |
| LSOCK_tag | |
| map< Key, T, Compare > | |
| map_checker< Container > | |
| MarkupCappedEst | |
| MarkupTrustedGenes | |
| MasterColumnCounter | |
| MasterDependentAlignment | |
| MasterSlaveAlignment | |
| match_data | |
| MATR< el > | |
| Matrix< T > | |
| MatrixData | Structure containing intermediate data to be processed |
| MatrixInfo | Used to temporarily store matrix values for retrieval |
| max_func< Type > | TEMPLATE STRUCT max |
| MCompress_Proxy_BZip2 | Classes that we actually put on the stream when using manipulators |
| MCompress_Proxy_GZipFile | |
| MCompress_Proxy_LZO | |
| MCompress_Proxy_Zip | |
| MD4Context | |
| MD5Context | |
| MDecompress_Proxy_BZip2 | |
| MDecompress_Proxy_ConcatenatedGZipFile | |
| MDecompress_Proxy_GZipFile | |
| MDecompress_Proxy_LZO | |
| MDecompress_Proxy_Zip | |
| MDiagClass | MDiagClass -- |
| MDiagFile | MDiagFile -- |
| MDiagFunction | MDiagFunction -- |
| MDiagModule | MDiagModule -- |
| MedianColumnScorer | |
| meEdge | |
| bm::mem_alloc< BA, PA > | BM style allocator adapter |
| MemetoFunctions< TEditHandle, T > | |
| MemetoFunctions< CBioseq_EditHandle, CSeq_inst > | |
| MemetoFunctions< CBioseq_EditHandle, CSeq_inst::TExt > | |
| MemetoFunctions< CBioseq_EditHandle, CSeq_inst::TFuzz > | |
| MemetoFunctions< CBioseq_EditHandle, CSeq_inst::THist > | |
| MemetoFunctions< CBioseq_EditHandle, CSeq_inst::TLength > | |
| MemetoFunctions< CBioseq_EditHandle, CSeq_inst::TMol > | |
| MemetoFunctions< CBioseq_EditHandle, CSeq_inst::TRepr > | |
| MemetoFunctions< CBioseq_EditHandle, CSeq_inst::TSeq_data > | |
| MemetoFunctions< CBioseq_EditHandle, CSeq_inst::TStrand > | |
| MemetoFunctions< CBioseq_EditHandle, CSeq_inst::TTopology > | |
| MemetoFunctions< CBioseq_set_EditHandle, CBioseq_set::TClass > | |
| MemetoFunctions< CBioseq_set_EditHandle, CBioseq_set::TColl > | |
| MemetoFunctions< CBioseq_set_EditHandle, CBioseq_set::TDate > | |
| MemetoFunctions< CBioseq_set_EditHandle, CBioseq_set::TId > | |
| MemetoFunctions< CBioseq_set_EditHandle, CBioseq_set::TLevel > | |
| MemetoFunctions< CBioseq_set_EditHandle, CBioseq_set::TRelease > | |
| MemetoFunctions< TEditHandle, CSeq_descr > | |
| MemetoTrait< T, cref > | |
| MemetoTrait< T, true > | |
| meNode | |
| meSet | |
| MessageResponder | |
| Messenger | |
| meTree | |
| MFastaReader | |
| min_func< Type > | TEMPLATE STRUCT min |
| bm::miniset< A, N > | Template class implements memory saving set functionality |
| CSeqMasker::mitem | |
| Molecule | |
| MoleculeIdentifier | |
| MSAAInterface | |
| MSerial_Flags | |
| MSerial_Format | |
| MSerial_Format_AsnBinary | |
| MSerial_Format_AsnText | |
| MSerial_Format_Json | |
| MSerial_Format_Xml | |
| MSerial_VerifyData | MSerial_VerifyData -- |
| MSerialXml_DefaultStringEncoding | MSerialXml_DefaultStringEncoding -- |
| MsgFrame | |
| MT_LOCK_tag | |
| multimap< Key, T, Compare > | |
| multimap_checker< Container > | |
| MultipleAlignment | |
| multiset< Key, Compare > | |
| MultiTextDialog | |
| MultiTextDialogOwner | |
| NaLookupBackboneCell | Structure defining one cell of the compacted lookup table |
| names_blob_prefix_t | |
| native_info | |
| NB | |
| ncbi_numeric_limits< char > | |
| ncbi_numeric_limits< double > | |
| ncbi_numeric_limits< float > | |
| ncbi_numeric_limits< signedchar > | |
| ncbi_numeric_limits< signedint > | |
| ncbi_numeric_limits< signedlong > | |
| ncbi_numeric_limits< signedshort > | |
| ncbi_numeric_limits< unsigned char > | |
| ncbi_numeric_limits< unsigned int > | |
| ncbi_numeric_limits< unsigned long > | |
| ncbi_numeric_limits< unsigned short > | |
| NeighborInfo | Structure containing information needed for adding neighboring words |
| NewLine | |
| xml::impl::nipimpl | |
| NJ_TreeAlgorithm | |
| CPhyloTreePS::Node | Data structure for a node in the particle system |
| xml::node | The xml::node class is used to hold information about one XML node |
| xml::impl::node_cmp | |
| xml::impl::node_impl | |
| xml::impl::node_iterator | |
| xml::impl::node_private_data | |
| xml::node_set | The xml::node_set class is used to store xpath query result set |
| NodeData | |
| IPhyloTreeRenderer::NodePointer | Structure holds a 'pointer' from an active tooltip to its corresponding node |
| non_zero_min< Type > | TEMPLATE STRUCT non_zero_min |
| NotifyingSpinButton | |
| xml::ns | The xml::ns class is used to access and handle namespaces of nodes and attributes |
| xml::impl::ns_util | |
| xml::impl::nset_impl | |
| NSnp | NSnp -- |
| NStr | NStr -- |
| NtlookupTestFixture | |
| NuclWordFinderTextFixture | |
| nwaln_mrnaguide | |
| nwaln_mrnaseg | Naive pattern generator (a la Rabin-Karp) |
| Object3D | |
| ObjectStyle | |
| CPdfObjectWriter::ObjOffset | |
| CPdfObjectWriter::ObjOffsetCompare | |
| OpenGLRenderer | |
| bm::operation_deserializer< BV > | Class deserializer, can perform logical operation on bit-vector and serialized bit-vector |
| bm::operation_functions< T > | |
| CSeqMaskerIstat::optimization_data | Structure containing information about optimization parameters used |
| option_item | |
| OrgNode | |
| OverlapsSameAccessionAlignment | |
| p_equal_to< T > | Check for equality of objects pointed to by pointer |
| pair_base_member< Base, Member > | Template used for empty base class optimization |
| pair_equal_to< Pair > | Check whether a pair's second element matches a given value |
| PAlignRangeFromLess< TAlignRange > | |
| PAlignRangeToLess< TAlignRange > | |
| CSeqMaskerOstatOpt::params | Parameters of the optimized data structure |
| mu::Parser | Mathematical expressions parser |
| xml::parser_exception | The xml::parser_exception class is used to store parsing and validating exception information |
| mu::ParserBase | Mathematical expressions parser (base parser engine) |
| mu::ParserByteCode | Bytecode implementation of the Math Parser |
| mu::ParserCallback | Encapsulation of prototypes for a numerical parser function |
| mu::ParserComplex | Mathematical expressions parser |
| mu::ParserError | Error class of the parser |
| mu::ParserErrorMsg | A class that handles the error messages |
| mu::ParserInt | Mathematical expressions parser |
| mu::ParserStack< TValueType > | Parser stack implementation |
| mu::Test::ParserTester | Test cases for unit testing |
| mu::ParserToken< TBase, TString > | Encapsulation of the data for a single formula token |
| mu::ParserTokenReader | Token reader for the ParserBase class |
| PathFinder | Functor object for s_RemoveAliasComponents where the path name is matched in SSeqDBInitInfo |
| PatternDialog | |
| PCase_Generic< T > | Define Case-sensitive string comparison methods |
| PConvertToString< const void * > | |
| PConvertToString< CSeq_id_Handle > | |
| PConvertToString< int > | |
| PConvertToString< Int8 > | |
| PConvertToString< string > | |
| PConvertToString< TBlastDbId > | Template specialization to convert BLAST DB (blob) IDs to human readable strings |
| pcre_callout_block | |
| pcre_extra | |
| pcre_study_data | |
| ncbi::boost_fp_impl::percent_tolerance_t< FPT > | |
| PercentAtOrOverThresholdColumnScorer | |
| PercentOfWeightOverThresholdColumnScorer | |
| CSymDustMasker::perfect | |
| perfectHitStr | |
| PeriodicTableClass | |
| PFindByName< T > | |
| PFindConflict | |
| CThemeConfigPanelBase::PFindDesc | |
| PFindMod | |
| PFindModByType | |
| CThemeConfigPanelBase::PFindType | |
| xml::impl::phantom_attr | |
| CTreeQueryExec::PhyloTreePointer | For iterating through the node tree without recursion |
| CPhyloTreePS::PhysicsParms | |
| xml::node::pi | Helper struct for creating a xml::node of type_pi |
| xslt::stylesheet::pimpl | |
| xml::attributes::pimpl | |
| xml::impl::pimpl_base< T > | |
| PInterProcessLock | |
| PIsExcludedByDisuse | |
| PIsExcludedByProjectMakefile | |
| PIsExcludedByRequires | |
| PIsExcludedByTag | |
| PIsExcludedByUser | |
| PItLess< TAlnRng > | |
| CAlignRangeCollExtender< TColl >::PItLess | |
| CDiagRangeCollection::PItLess | |
| GlZoomSpec::PixelDim | |
| CSourceModParser::PKeyCompare | |
| CSeq_id_General_Str_Info::PKeyLess | |
| PKeyValuePair< Value > | |
| PKeyValueSelf< Value > | |
| PLessByKey< KeyValueGetter, KeyCompare > | |
| CCgiCookie::PLessCPtr | |
| PLessObjectPtr | |
| CSeq_id_Handle::PLessOrdered | Predicate for sorting CSeq_id_Handles in a defined order |
| PLibExclude | |
| plus_func< Type > | TEMPLATE STRUCT max |
| PNGOptionsDialog | |
| PNocase_CompareChar | |
| PNocase_Conditional_Generic< T > | Define Case-insensitive string comparison methods |
| PNocase_EqualChar | |
| PNocase_Generic< T > | Define Case-insensitive string comparison methods |
| PNocase_LessChar | |
| pool_block_allocator | |
| pool_ptr_allocator | |
| tree< T, tree_node_allocator >::post_order_iterator | |
| PPtrLess< T > | Compare objects pointed to by (smart) pointer |
| PQuickStringLess | PQuickStringLess implements an ordering of strings, that is more efficient than usual lexicographical order |
| PRangeLess< Range > | |
| PRangeLessPos< Range, Position > | |
| tree< T, tree_node_allocator >::pre_order_iterator | |
| Precedence | |
| Predicate | |
| CPhyloTreeNode::predicate_sort_by_leaves_count | |
| PreferencesDialog | |
| PRemoveSynAnamorph | |
| PRequested< T > | |
| problemStr | |
| ProfileParam | |
| ProgressMeter | |
| ProjectCDS | |
| IPhyloTreeRenderer::ProjectionElement | A coord (in one of +x,-x,+y,-y) and pixel offset in the same direction |
| proteinabbrev | |
| ProteinOptiosHandleFixture | |
| ProteinWithBigHole | |
| PScheduler_QueueEvent_Compare | Class for comparing references to CSchedQueueTask by its execution time |
| PScoreGreater< C > | Compare alignments by score |
| PSeq_locLess | |
| PSIBlastOptions | Options used in protein BLAST only (PSI, PHI, RPS and translated BLAST) Some of these possibly should be transfered elsewhere |
| PSIBlastOptiosHandleFixture | |
| PSICdMsa | Data structure representing multiple alignemnt of CDs and query sequence along with data needed for PSSM computation |
| PSICdMsaCell | Alignment cell that represents one column of CD aligned to a position in the query |
| PSICdMsaCellData | Data needed for PSSM computation stored in MSA cell for single column in CD aligned to a position in the query |
| PSIDiagnosticsRequest | Structure to allow requesting various diagnostics data to be collected by PSSM engine |
| PSIDiagnosticsResponse | This structure contains the diagnostics information requested using the PSIDiagnosticsRequest structure |
| PSIMatrix | This is the main return value from the PSSM engine |
| PSIMsa | Multiple sequence alignment (msa) data structure containing the raw data needed by the PSSM engine to create a PSSM |
| PSIMsaCell | Structure to describe the characteristics of a position in the multiple sequence alignment data structure |
| PSIMsaDimensions | Structure representing the dimensions of the multiple sequence alignment data structure |
| PSourcesExclude | |
| PssmMaker | |
| PssmMakerOptions | |
| PssmScorer | |
| PSSMWrapper | |
| bm::ptr_allocator | Default malloc based bitblock allocator class |
| bm::ptr_guard< T > | Mini auto-pointer for internal memory management |
| pvalues | |
| PyObject | |
| q_elem | |
| QuerySetUpOptions | Options required for setting up the query sequence |
| bm::random_subset< BV > | |
| RandomlyFailingMockSeqSrcTestFixture | Initializes m_SeqSrc with a BlastSeqSrc that fails randomly |
| Block::Range | |
| rangemultimap_checker< Container > | |
| pcrecpp::RE | |
| pcrecpp::RE_Options | |
| ReadyTagMapper | |
| real_pcre | |
| SConstructAllocator< Value >::rebind< Other > | |
| recursion_info | |
| bm::bvector< Alloc >::reference | Class reference implements an object for bit assignment |
| RefinerAU | |
| REG_tag | |
| regex_t | |
| RegionDialog | |
| CSeqDBAtlas::RegionMapLess | RegionMapLess |
| regmatch_t | |
| RemoveAction< TEditHandle > | |
| RemoveAction< CBioseq_EditHandle > | |
| RemoveAction< CBioseq_set_EditHandle > | |
| RemoveAction< CSeq_annot_EditHandle > | |
| RemoveTrailingNs | |
| ReNewtonSystem | Represents the inverse of the matrix of the linear system that must be solved at every iteration of Newton's method |
| res_traits< Res > | |
| res_traits< EResidue > | |
| Residue | |
| ResidueCell | |
| ResidueMatrix | |
| ResidueProfiles | |
| xslt::impl::result | The xslt::result class is used as a callback by xml::document to allow special treatment of XML documents which were created by XSLT |
| tracker::result | |
| CCompareSeq_locs::ResultCounts | |
| RightEndOrder | |
| RightOrder | |
| RightOrderD | |
| CBoundaryShapeTri::RoundedCorner | Rounded corners are drawn as circles that replace the corner that would extend from intersection[1,2] to initial_vertex |
| RowScorer | |
| RowSource | |
| RowSourceTable | |
| CMakeProfileDBApp::RPS_DbInfo | |
| RPSBackboneCell | Structure defining one cell of the RPS lookup table |
| RPSBucket | Structure used for bucket sorting offsets retrieved from the RPS blast lookup table |
| RpsTestFixture | |
| bm::tmatrix< T, ROWS, COLS >::rstat | Row characteristics for transposed matrix |
| s_ByAccVerLen | |
| CInitDS_local::S_InputObj | |
| s_SqlMsgMap | |
| s_v3to2map | |
| s_WindowInfo | S_WindowInfo - a struct whose instances represent a range of data in a sequence |
| SAccGuide | |
| CHandleRangeMap::SAddState | |
| SAffinityDictDB | BDB table to store affinity |
| CNetScheduleAdmin::SAffinityInfo | Affinity information returned by AffinitySnapshot() |
| SAffinityStatistics | |
| CAltValidator::SAgpLineInfo | |
| CSplign::SAlignedCompartment | |
| SAlignedSeq | This is a building block for a Builder represents a Sequence aligned to an Anchor (pairwise alignment) |
| CAlignSort::SAlignExtractor | |
| SAlignFileRaw | |
| CPhrap_Contig::SAlignInfo | |
| CAlnGraphic::SAlignInfo | |
| CNWAligner::SAlignInOut | |
| CAlignCompare::SAlignment | |
| CAlnTableDS::SAlignment | Alignment we store with its parsed data |
| SAlignment_PtrLess | |
| SAlignment_Segment::SAlignment_Row | Single row of a single alignment segment |
| SAlignment_Segment | Structure to hold information about a single alignment segment |
| SAlignmentFile | |
| SAlignOrder | |
| SAlignRawSeq | |
| SAlignSmearSort | |
| CContigAssembly::SAlignStats | Alignment characterization |
| CDisplaySeqalign::SAlignTemplates | |
| SAlignTools | TODO merge with CAlignUtils ? |
| CSplicedAligner::SAllocator< T > | |
| CIncreasingTime::SAllParams | |
| COligoSpecificityCheck::SAlnCache | Key for coordinate-alignment cache |
| CDisplaySeqalign::SAlnDispParams | |
| CDisplaySeqalign::SAlnFeatureInfo | Store feature information |
| CDisplaySeqalign::SAlnInfo | Store alnvec and score info |
| CDisplaySeqalign::SAlnLinksParams | Info used to contstruct seq url obtained from processing the whole seq align for particular subject sequnce |
| CSplign::SAlnMapElem | |
| CDisplaySeqalign::SAlnRowInfo | |
| SAlnSeqIdIRefComp | |
| SAlnSeqIdRefEqual | |
| CDisplaySeqalign::SAlnSeqlocInfo | Store seqloc info |
| IDictionary::SAlternate | SAlternate wraps a word and its score |
| IDictionary::SAlternatesByScore | Functor for sorting alternates list by score |
| dup_lookup_table::sample | |
| dup_lookup_table::sample_loc | |
| SAnnotCmdPreparer< type > | |
| CSplitDataLoader::SAnnotData | |
| CLDS2_ObjectParser::SAnnotInfo | |
| CSGGapDS::SAnnotInfo | |
| SAnnotObject_Index | |
| SAnnotObject_Key | |
| SAnnotObjectsIndex | |
| SAnnotPiece | |
| SAnnotSelector | SAnnotSelector -- |
| SAnnotTypeSelector | |
| SApp | Congiguration Type (Target type) traits |
| SAppProjectT | SAppProjectT -- |
| CArgDescriptions::SArgDependency | |
| CSeqConvert_imp::CPacker::SArrangement | |
| SAsnConn_Cbdata | |
| SAsnProjectMultipleT | SAsnProjectMultipleT -- |
| SAsnProjectSingleT | SAsnProjectSingleT -- |
| SAsnProjectT | SAsnProjectT -- |
| CPhrapReader::SAssmTag | |
| SAttributeSupport | |
| CNCBINode::SAttributeValue | |
| SAttrRangeCollectionElement< Attr, Position > | TAttrRangeCollection represents a sequence of continious attributed intervals |
| SAutoDefModifierComboSort | |
| SAutodefParams | |
| SAutoDefSourceDescByStrings | |
| SAutoDefSourceGroupByStrings | |
| CSimpleB2SWrapper::SB2SSeq | |
| CBadResiduesException::SBadResiduePositions | |
| CBamLoadingJob::SBamFile | |
| CPhrap_Contig::SBaseSeg | |
| CTSE_Info::SBaseTSE | |
| CTL_BCPInCmd::SBcpBind | |
| SBDB_BvStore_Id< TBV > | Id based BV store |
| SBDB_CacheStatistics | BDB cache statistics |
| SBDB_CacheUnitStatistics | BDB cache statistics (covers one elemntary unit of measurements) |
| SBDB_FieldDescription | |
| SBDB_TimeAccessStatistics | BDB cache access statistics |
| SBDB_TypeTraits< Type > | Type trait classes for finding the correct BDB field type automagically |
| SBDB_TypeTraits< double > | |
| SBDB_TypeTraits< float > | 32- and 64- bit floating point types |
| SBDB_TypeTraits< Int1 > | 8-bit signed and unsigned integral types |
| SBDB_TypeTraits< Int2 > | 16-bit signed and unsigned integral types |
| SBDB_TypeTraits< Int4 > | 32-bit signed and unsigned integral types |
| SBDB_TypeTraits< Int8 > | 64-bit signed and unsigned integral types |
| SBDB_TypeTraits< string > | String types |
| SBDB_TypeTraits< Uint1 > | |
| SBDB_TypeTraits< Uint2 > | |
| SBDB_TypeTraits< Uint4 > | |
| SBDB_TypeTraits< Uint8 > | |
| SBestCodings | |
| CGwasGlyph::SBin | |
| CBinsGlyph::SBin | |
| CBinsGlyph::SBinMapped | |
| SBinsJobResult | SBinsJobResult |
| CChangeSeqFeatCommand::SBioseq | |
| CChangeUnindexedObjectCommand< T >::SBioseq | |
| CTSE_SetObjectInfo::SBioseq_set_Info | |
| CLDS2_ObjectParser::SBioseqInfo | |
| SBioseqInfo | |
| SBlastDbMaskData | Structure describing filtered regions created using a particular sequence filtering algorithm |
| CBlastDbDataLoader::SBlastDbParam | |
| CAlignFormatUtil::SBlastError | Error info structure |
| SBlastFilterOptions | All filtering options |
| SBlastHitsParameters | Keeps prelim_hitlist_size and HitSavingOptions together, mostly for use by hspstream |
| SBlastProgress | Progress monitoring structure |
| SBlastScoreMatrix | Scoring matrix used in BLAST |
| SBlastSequence | Structure to store sequence data and its length for use in the CORE of BLAST (it's a malloc'ed array of Uint1 and its length) FIXME: do not confuse with blast_seg.c's SSequence |
| SBlastSetupData | Return type of BlastSetupPreliminarySearch |
| SBlastTargetTranslation | Information about target translations |
| ICache::SBlobAccessDescr | BLOB access descriptor |
| CBDB_ExtBlobMap::SBlobChunkLoc | BLOB chunk location: offset in file + chunk size |
| SBlobEvent | |
| CBDB_ExtBlobMap::SBlobLoc | Blob id + blob location table (list of chunks and sizes) |
| ILayoutPolicy::SBoundingBox | |
| SBracketedCommentList | |
| SBroadcastDlgParams | |
| SBroadcastParams | |
| SBrowser | |
| CChangePhyloTreeCommand::SBTree | |
| CNCBlobStorage::SBucketCache | |
| SBufChunkTag | |
| impl::SBufferWriter_SupportedType< T > | |
| impl::SBufferWriter_SupportedType< CSimpleBufferT< char > > | |
| impl::SBufferWriter_SupportedType< CSimpleBufferT< signed char > > | |
| impl::SBufferWriter_SupportedType< CSimpleBufferT< unsigned char > > | |
| impl::SBufferWriter_SupportedType< std::string > | |
| impl::SBufferWriter_SupportedType< std::vector< char > > | |
| impl::SBufferWriter_SupportedType< std::vector< signed char > > | |
| impl::SBufferWriter_SupportedType< std::vector< unsigned char > > | |
| impl::SBufferWriter_Write< T > | |
| impl::SBufferWriter_Write< ncbi::CSimpleBufferT< T > > | |
| impl::SBufferWriter_Write< std::vector< T > > | |
| CAppHitFilter::SBuildIDs | |
| SCache_AttrDB | BLOB attributes DB |
| SCache_IdIDX | BLOB ID -> key, value, subkey index |
| SCacheDeadCompare | |
| SCacheDescr | |
| SCacheElement< TKey, TSize > | Generic cache |
| COrgRefCache::SCacheEntry | |
| SCacheInfo | Structure for common cache reader&writer implementation |
| CConvertCache::SCacheKey | |
| SCacheKeyCompare | |
| CConvertCache::SCacheKeySort | |
| SCallbackData | |
| CConcurrentMap< Key, Value, Comparator, Allocator, CntChildsInNode, MaxTreeHeight, DeletionDelay, DelStoreCapacity >::SCallContext | |
| CLDS_FindSeqIdFunc::SCandidate | |
| CObjectsSniffer::SCandidateInfo | |
| pcrecpp::Scanner | |
| SCaseInsensitiveCompare | |
| SCaseInsensitiveStrComp | |
| SCategoryInfo | |
| CCategoryConfig::SCategorySettings | |
| variation::CVariationUtil::CCdregionIndex::SCdregion | |
| SCgiStatus | |
| SChainMember | |
| xml::schema | The xml::schema class represents an XML schema |
| xml::impl::schema_impl | |
| SChunkInfo | |
| SChunkTranslator | |
| SCigarAlignment | |
| CFileCode::SClassInfo | |
| SCleanupAlignmentsParams | |
| CSparseIterator::SClip | |
| CClonePlacementGlyph::SCloneEnd | |
| CAlignedFeatureGraph::SCluster | |
| SCmd | |
| SCmdCreator< type > | |
| SCmdLineArgListImpl | |
| CResultSetMetaData::SColMetaData | |
| CWidgetDisplayStyle::SColumn | |
| IAlnMultiHeaderContext::SColumn | SColumn describes a single column |
| CMultiAligner::SColumn | Column in an alignment used for combining result from multiple alignment and pair-wise in-cluster alignments |
| SComboChartElem | |
| SCommandCategoryDefinition | |
| SCommandDefinition | |
| CNCMessageHandler::SCommandExtra | Extra information about each NetCache command |
| CNetScheduleHandler::SCommandExtra | |
| SCommandInfo | |
| SCommandLineParserImpl | |
| SCommentLoc | |
| SCommonParts | |
| SComp_Less | |
| SCompareFeats_OpLess | Comparison functor for pqueue storing related comparisons |
| SCompareLocation | |
| SCompareOrdered< TSeqIdPtr > | Implementation includes |
| SCompareSeqLoc | |
| SCompareSpecs | |
| SComparison | |
| SCompartment | |
| SCompartmentData | |
| SComplement | |
| SCompliment | |
| SCompressedAlphabet | Scoring matrix data used for compressed protein alphabets |
| SCompressionParam | Structure to define parameters for some level of compression |
| CProteinModel::SComputedFields | |
| SConfigInfo | SConfigInfo -- |
| SCONN_Callback | |
| CPubseq2Reader::SConnection | |
| SConnectionTag | |
| SConnectorTag | Connector specification |
| CReaderServiceConnector::SConnInfo | |
| SConnNetInfo | |
| CReader::SConnSlot | |
| SConstCharCompare | |
| CMultiAlignerOptions::SConstraint | Structure for representing single user constraint for pair-wise alignment |
| SConstructAllocator< Value > | |
| SConstScopedObject | |
| SConstScopedObjectLess | |
| SContentType | |
| SContext_tag | Thread-specific context data |
| CPhrap_Contig::SContigTag | |
| SConverterEntry | |
| value_slice::SConvertUsingRunTimeCP< to_is_integer, from_is_integer > | |
| value_slice::SConvertUsingRunTimeCP< true, true > | |
| SCoordRect | |
| ScoreMatrix | |
| ScoreOrder | |
| SCpGIsland | |
| SCreateGeneModelParams | |
| SCrtMultiThreaded | Traits for MSVC projects: |
| SCrtMultiThreadedDebug | |
| SCrtMultiThreadedDebugDLL | |
| SCrtMultiThreadedDLL | |
| SCrtSingleThreaded | |
| SCrtSingleThreadedDebug | |
| SCSVExportDlgModel | |
| SCSVExportParams | |
| SCustomBuildInfo | SCustomBuildInfo -- |
| SCustomScriptInfo | |
| CCancelRequestException::SData | |
| CColorPanel::SData | |
| CCgiEntry::SData | |
| SDatabaseScanData | Structure to hold results of the preliminary (databases scanning phase) part of the search that are needed for the traceback |
| CRCache::SDataItem | |
| SDataLoaderConfig | Configuration structure for the CBlastScopeSource |
| CAnalysisFile::SDataRow | |
| COffsetList::SDataUnit | |
| SDBAPI_CacheDescr | |
| impl::SDBConfParams | |
| CAlignFormatUtil::SDbInfo | Blast database info |
| SDBL_ColDescr | SDBL_ColDescr:: |
| SDbSumInfo | |
| SDebug | Debug/Release traits |
| SPluginParams::SDefaultValue | |
| CShowBlastDefline::SDeflineInfo | Data Representing each defline |
| CShowBlastDefline::SDeflineTemplates | |
| SDeltaSeqSummary | |
| SDemoDB | |
| IDBServiceMapper::SDereferenceLess | |
| CSplitDataLoader::SDescrData | |
| CHMMParameters::SDetails | |
| SDiagErrCodeDescription | SDiagErrCodeDescription -- |
| SDiagMessage | SDiagMessage -- |
| SDiagMessageData | |
| SDictByPriority | CMultiDictionary |
| CMultiDictionary::SDictionary | |
| SDiscoveredServers | |
| SDISPD_Data | |
| COrgRefCache::SDivision | |
| SDll | |
| SDllHandle | |
| SDllProjectT | |
| SDNALongPatternItems | Auxiliary items needed for a DNA pattern search with pattern containing multiple words |
| SDNAShortPatternItems | Structure containing auxiliary items needed for a DNA search with a pattern that fits in a single word |
| SDriverInfo | |
| CPluginManager< TClass >::SDriverInfo | Information about a driver, with maybe a pointer to an instantiated class factory that contains the driver |
| C_xDriverMgr::SDrivers | |
| SDubiousShortSequence | |
| SDustOptions | Options for dust algorithm, applies only to nucl |
| SDynamicInt4Array | Data structure to maintain a dynamically allocated array of Int4 |
| SDynamicSGenCodeNodeArray | Data structure to maintain a dynamically allocated array of SGenCodeNode |
| SDynamicUint4Array | Data structure to maintain a dynamically allocated array of Uint4 |
| SegByFirstRow_Less | |
| SegMaskerApplication | |
| SegParameters | Structure to hold parameters for seg search |
| CMetaRegistry::SEntry | |
| CMemoryRegistry::SEntry | |
| CEnumDataType::SEnumCInfo | |
| SEnumDescription< TValue > | |
| CNcbiEnvironment::SEnvValue | Cached environment <name,value> pair |
| SeqAlign | Neutral sequence alignment (for representing an HSP in BLAST) |
| SeqEntrySelectAction< CBioseq_EditHandle, Data > | |
| SeqEntrySelectAction< CBioseq_set_EditHandle, Data > | |
| SeqItem | |
| SeqLoc | |
| SeqSwapper | |
| SeqTree | |
| SeqTreeAPI | |
| SeqTreeAsnizer | |
| SeqTreeLayout | |
| SeqTreeRootedLayout | |
| Sequence | |
| SequenceDisplay | |
| SequenceSet | |
| SequenceTable | |
| SequenceViewer | |
| SequenceViewerWidget | |
| SequenceViewerWidget_SequenceArea | |
| SequenceViewerWidget_TitleArea | |
| SequenceViewerWindow | |
| bm::serial_stream_iterator< DEC > | Serialization stream iterator |
| bm::serializer< BV > | Bit-vector serialization class |
| SErrorInfo | |
| set< Key, Compare > | |
| set_of_parameters | |
| setcontig | |
| SEventsDB | BDB table to store events information Every instantiation of a job is reflected in this table under corresponding (id, event) key |
| Severity | Severity -- |
| SEvtMap | Command Map |
| SEvtMapEntry | Command map entry |
| CNetServer::SExecResult | |
| SExtMagicInfo | |
| SExtraLongPatternItems | Auxiliary items needed for a PHI BLAST search with pattern that contains pieces longer than a word |
| ILayoutTrackFactory::SExtraParams | Extra parameter for initializing a track |
| SFactoryList< Type > | |
| SFastaFileMap::SFastaEntry | |
| SFastaFileMap | |
| variation::SFastLocSubtract | Note: this is strand-agnostic |
| SFeatBatchJobRequest | |
| SFeatByPos | |
| CSeqFeatData::SFeatDataInfo | |
| CTSE_Info::SFeatIdIndex | |
| CTSE_Info::SFeatIdInfo | |
| CTSE_Chunk_Info::SFeatIds | |
| SFeatInfo | |
| SFeatLengthPredicate | |
| SFeatListItem | |
| CAlignedFeatureGraph::SFeatRec | |
| SFeats_OpLess | |
| SFeatSortPredicate | |
| CChangeSeqFeatCommand::SFeature | |
| SFeatureByName | |
| SFeatureByPos | |
| SFeatureBySize | |
| SFeatureFilter | SFeatureFilter |
| CFeatTableDS::SFeatureRow | Our actual features |
| SFILE_ConnAttr | |
| SFileChunkDataRec | |
| SFileChunkMapRec | |
| SFileConnector | |
| SFileDlgData | File dialog utilities |
| SFileIndexRec | |
| CLZOCompression::SFileInfo | Structure to keep compressed file information |
| CZipCompression::SFileInfo | Structure to keep compressed file information |
| SFileMetaRec | |
| SFileServRecord | |
| SFileSystem | |
| CFileUtil::SFileSystemInfo | Structure to store information about file system |
| SFillTypes | |
| SFixedPart | |
| variation_ref::CVariationUtil::SFlankLocs | Calculate upstream (first) and downstream(second) flanks for loc |
| variation::CVariationUtil::SFlankLocs | Calculate upstream (first) and downstream(second) flanks for loc |
| SFolderDlgParams | |
| SForceRegister | |
| SFormatSpec | Structure to store the format specification strings, their description and their corresponding enumeration |
| SFrame | |
| SFreqRatios | Stores the frequency ratios along with their bit scale factor |
| SFShiftsCluster | |
| SFTP_Callback | |
| SFTPConnector | |
| pythonpp::CExtModule< T >::SFunct | Workaround for GCC 2.95 |
| pythonpp::CExtObject< T >::SFunct | Workaround for GCC 2.95 |
| variation::CHgvsParser::SFuzzyInt | |
| variation_ref::CHgvsParser::SFuzzyInt | |
| CFastaReader::SGap | |
| SGapJobResult | SSnpJobResult |
| SGapRange | |
| SGenCodeNode | Elements of the SDynamicSGenCodeNodeArray dynamic array |
| CGeneFileWriter::SGene2AccnLine | Structure representing a parsed gene->accession line |
| CGeneFileWriter::SGene2PMLine | Structure representing a parsed gene->pubmed line |
| CGeneFileWriter::SGeneInfoLine | Structure representing a parsed gene info line |
| SGeneInfoListSorter | |
| SGFFrec | |
| SGiDataIndex | |
| CSeqDBGiList::SGiOid | Structure that holds GI,OID pairs |
| CAltValidator::SGiVerLenTaxid | |
| SGlyphByPos | Basic sort by geometry position function |
| SGlyphBySeqPos | Basic sort by sequence position function |
| SGlyphBySeqSize | Basic sort by sequence size function Larger size objects will be put in front |
| SGlyphBySize | Basic sort by geometry size function |
| SGlyphRangeSorter | CLayeredLayout |
| SGlyphSorter | Special sort by glyph geometry size |
| CGnomonEngine::SGnomonEngineImplData | |
| variation_ref::CHgvsParser::SGrammar | |
| variation::CHgvsParser::SGrammar | |
| CHitMatrixRenderer::SGraphDescr | |
| CHitMatrixPane::SGraphDescr | |
| SGraphElem | SGraphElem |
| CMultiAligner::SGraphNode | |
| SGraphObject | |
| value_slice::SGreaterThanTypeMax< false, false > | |
| value_slice::SGreaterThanTypeMax< false, true > | |
| value_slice::SGreaterThanTypeMax< true, false > | |
| value_slice::SGreaterThanTypeMax< true, true > | |
| SGreedyAlignMem | All auxiliary memory needed for the greedy extension algorithm |
| SGreedyOffset | Bookkeeping structure for greedy alignment |
| SGreedySeed | Structure for locating high-scoring seeds for greedy alignment |
| CGroupMapWidget::SGroup | |
| SGroupAlignmentsParams | |
| CGroupMapWidget::SGroupDescr | |
| SGroupDictDB | BDB table to store groups |
| SGumbelParams | Gumbel parameters and estimation errors |
| CGlWidgetPane::SHandlerRec | |
| SHapmapJobResult | SHapmapJobResult |
| SHeader | POSIX "ustar" tar archive member header |
| CObjectMemoryPoolChunk::SHeader | |
| SHEAP_Block | |
| SHEAP_HeapBlock | |
| SHEAP_tag | |
| SHINFO_Params | |
| SHit | Representation of a hit for computing constraints |
| SHitColoringParams | |
| CHitFilter< THit >::SHitEnd | |
| CElementaryMatching::SHitIndexEntry | |
| CCompartmentFinder< THit >::SHitStatus | |
| CSRSearch::SHKData | |
| SHostInfoTag | |
| ShowHideCallbackObject | |
| ShowHideDialog | |
| ShowHideDomain | |
| ShowHideInfo | |
| ShowHideManager | |
| ShowHideMolecule | |
| ShowHideObject | |
| COligoSpecificityCheck::SHspIndexInfo | |
| COligoSpecificityCheck::SHspInfo | |
| SHspWrap | Auxiliary structure for sorting HSPs |
| SHttpConnector | |
| tree< T, tree_node_allocator >::sibling_iterator | |
| CNetCacheControl::SICacheBlobAddress | |
| CGridCommandLineInterfaceApp::SOptions::SICacheBlobKey | |
| CLayoutTrack::SIconInfo | A help struct for storing information about a icon |
| SId2BlobInfo | |
| SId2LoadedSet | |
| CTSE_Info::SIdAnnotInfo | |
| SIdAnnotObjs | |
| SIdAnnotPieces | |
| CWriteDB_IsamIndex::SIdOid | Element type for numeric tables |
| CIgBlastTabularInfo::SIgDomain | Struct containing annotated domain information |
| CIgBlastTabularInfo::SIgGene | Struct containing annotated gene information |
| SimpleBoundaryExtender | |
| SimpleBoundaryExtenderAndShrinker | |
| SimpleBoundaryShrinker | |
| CFeatureGenerator::SImplementation | |
| SImportEntry | |
| SIndexHeader | Structure into which an index header is loaded |
| CDelayBuffer::SInfo | |
| impl::CCachedRowInfo::SInfo | |
| SInfo_tag | Application access log and error postings info structure (global) |
| SingleExon_AllEst | |
| SingleExon_Noncoding | |
| CStlClassInfoFunctions_set< Container >::SInitializer | |
| CStlClassInfoFunctions_multiset< Container >::SInitializer | |
| CDisplaySeqalign::SInsertInformation | Internal insert information aln_start |
| CLocationListCtrl::SIntData | |
| SInternalData | Lightweight wrapper to enclose C structures needed for running the preliminary and traceback stages of the BLAST search |
| CTypeStrings::SInternalNames | |
| CCompareSeq_locs::SIntervalComparisonResult | |
| CCompareSeq_locs::SIntervalComparisonResultGroup | This helper struct is used to accumulate the neighboring comparisons of the same class, such that the comparison [.. |
| SIntervalNode | Structure describing a node of an interval tree |
| SIntervalTreeNode< Traits > | |
| SIntervalTreeNodeIntervals< Traits > | |
| SIntLink | |
| CDBInterfacesFileConnParams::SIRecord | |
| CSeqDBIsam::SIsamKey | Stores a key for an ISAM file |
| SIsOldName | |
| CHTMLPopupMenu::SItem | Menu item type |
| CMinPanelContainer::SItem | |
| CThemeConfigPanelBase::SItemData | |
| CGroupMapWidget::SItemDescr | |
| CBlockingQueue< TRequest >::SItemHandleGreater | |
| SIteratorFunctions | |
| CWNJobsWatcher::SJobActivity | |
| SJobDB | BDB table to store frequently used job info |
| SJobGCInfo | |
| SJobInfoDB | BDB table to store infrequently needed job info |
| CAppJobDispatcher::SJobRecord | SJobRecord describes a Job registered in Dispatcher |
| CAppJobDispatcher::SJobStateEvent | |
| SJsonArrayNodeImpl | |
| SJsonFixedSizeNodeImpl | |
| SJsonNodeImpl | |
| SJsonObjectNodeImpl | |
| SJsonStringNodeImpl | |
| CEntrezCache::SKey | Key for Entrez objects is the namespace (=database) and the UID |
| CMetaRegistry::SKey | Members |
| CCalcSizeCache::SKey | |
| CCalcSizeCache::SKeyHash | |
| CEntrezCache::SKeyHash | |
| CGuiRegistry::SKeyInfo | |
| SKeyValue | Utilits for Project Tree Builder: |
| COrfSearchForm::SKozakPattern | |
| CAxisRenderer::SLabelDescr | |
| CSGFeatureJob::SLandmarkFeat | |
| SLandmarkFeatByScore | CSGFeatureJob implementation |
| SLandmarkFeatBySeqPos | |
| COligoSpecificityCheck::slave_range_sort_order | |
| CAlignedFeatureGraph::SLayer | |
| SLayoutByPos | Basic sort by position function |
| SLayoutBySize | Basic sort by size function |
| SLB_Candidate | |
| SLC_TreeAlgorithm | |
| SLDS2_Annot | |
| SLDS2_Blob | Top level object info |
| SLDS2_Chunk | Chunk info |
| CLDS2_Database::SLDS2_DbConnection | |
| SLDS2_File | LDS2 database |
| SLDS_Annot2ObjectDB | |
| SLDS_AnnotDB | |
| SLDS_FileDB | |
| SLDS_FileNameIDX | |
| SLDS_IntIdIDX | Persistent index for numeric ids (like GI) |
| SLDS_ObjectDB | |
| SLDS_ObjectTypeDB | |
| SLDS_SeqId_List | |
| SLDS_SeqIdBase | Indexing base for sequence id, (accession or integer) |
| SLDS_TablesCollection | |
| SLDS_TxtIdIDX | Persistent index for text based ids (like GenBank id) |
| CConcurrentMap< Key, Value, Comparator, Allocator, CntChildsInNode, MaxTreeHeight, DeletionDelay, DelStoreCapacity >::SLeafNode | |
| SLegalImport | |
| SLengthList | |
| SLengthRange | |
| SLessByInfo | |
| value_slice::SLessThanTypeMin< x_is_signed, y_is_signed > | |
| value_slice::SLessThanTypeMin< false, true > | |
| value_slice::SLessThanTypeMin< true, false > | |
| SLib | |
| CMsvcSite::SLibChoice | |
| SLibInfo | SLibInfo -- |
| SLibProjectT | SLibProjectT -- |
| CSubjectMap_Factory::SLIdMapElement | Element of mapping of local sequence ids to chunks |
| CAltValidator::SLineData | |
| SLineInfo | |
| SLineInfoReader | |
| CLinks::SLink | Single link |
| CPhyTreeCalc::SLink | Structure for storing divergences between sequences as list of links |
| SLinkedSetValue< Key > | |
| SLoadTokens | |
| SLOCAL_Data | |
| SLock | |
| CBDB_BlobSplitStore< TBV, TObjDeMux, TL >::SLockedDb | BDB Database together with the locker One database is opened twice, one regular mode, another - dedicated read-only instance to improve concurrency |
| CLocksMonitor::SLocks | |
| SLOG_Handler | Message and miscellaneous data to pass to log post callback FLOG_Handler |
| SLogData | |
| impl::SLoginData | |
| SLongPatternItems | Auxiliary items needed for a PHI BLAST search with pattern containing multiple words |
| SMagicInfo | |
| CProjectTreeBuilder::SMakeFiles | |
| SMakeProjectT::SMakeInInfo | |
| SMakeProjectT | SMakeProjectT -- |
| SMappedFeatLoc | |
| CSeq_loc_Mapper_Base::SMappedRange | |
| CFeatureGenerator::SImplementation::SMapper | |
| CIdMapper::SMapper | |
| CIdMapper::SMappingContext | |
| CAlignMap::SMapRange | |
| CAlignMap::SMapRangeEdge | |
| CAlignMarkHandler::SMarkDelta | Helper class representing range being edited |
| CTar::SMask | Mask storage |
| CWindowMaskerPanel::SMaskerInfo | |
| SMaskResult | |
| CSeqportUtil_implementation::SMasksArray::SMasks | |
| CSeqportUtil_implementation::SMasksArray | |
| CSeqMatch::SMatchNcbi8na< Seq, Pat > | |
| CBDB_MatrixBvStore< TBV, TM >::SMatrixDescr | Sparse matrix descriptor |
| SMBSpace | Space structure for greedy alignment algorithm |
| CTraversalSpecFileParser::SMember | |
| SMemberCopyFunctions | |
| CClassTypeStrings::SMemberInfo | |
| SMemberReadFunctions | |
| SMemberSkipFunctions | |
| CMemStore::SMemBlock | |
| SMemoryConnector | |
| SMemoryFileAttrs | |
| SMemoryFileHandle | |
| SMenuItemRec | SMenuItemRec |
| SMergeAlignmentsParams | |
| CwxLogDiagHandler::SMessage | |
| SMessageOrigin | Structure to enclose the origin of an error message or warning |
| SMetaConnector | Standard set of connector methods to handle a connection (corresponding connectors are also here), part of connection handle("CONN") |
| pythonpp::SMethodDef | Introduces constructor methods for a python PyMethodDef structure .. |
| SMinScor | |
| SMirrorInfo | |
| SMirrorServInfo | |
| CSRSearch::SMismatchInfo | |
| CSRSearch::SMismatchResultsEntry | |
| CSourceModParser::SMod | |
| SModelData | |
| SModelEvidance | |
| SModuleEntry | |
| SMsvcProjectT | SUserProjectT -- |
| CGeneFileUtils::SMultiIntRecord< k_nFields > | SMultiIntRecord - an n-tuple of integers |
| SMultiSeqSrcNewArgs | Encapsulates the arguments needed to initialize multi-sequence source |
| CDllResolver::SNamedEntryPoint | DLL entry point name -> function pair |
| SNamedPipeConnector | |
| SNCBIFullScoreMatrix | |
| SNcbiLog_Param | Structure to describe pairs 'key=value', used to posting parameters |
| SNcbiMatrix2DoubleMatrix | Auxiliary class to convert from a CNcbiMatrix into a double** as required by the C API |
| SNCBIPackedScoreMatrix | |
| SNcbiTestRegistrar | Extension auto-registrar from Boost.Test that can automatically set the timeout for unit |
| SNcbiTestTCTimeout< T > | Copy of auto_tc_exp_fail from Boost.Test to store the value of timeout for each test |
| SNcbiTestUserFuncReg | Class for implementing automatic registration of user functions |
| SNCBlobSummary | |
| SNCBlobVerData | Full information about NetCache blob (excluding key, subkey, version) |
| SNCBlockedOpListeners | |
| SNCCacheData | |
| SNCChunkMapInfo | |
| SNCDataCoord | |
| SNCDBFileInfo | Information about database part in NetCache storage |
| SNCFastMutex | Special equivalent of SSystemFastMutex that exposes necessary method to public |
| SNCMirrorEvent | |
| SNCMirrorIterationBeginner | |
| SNCMirrorProlong | |
| SNCMMChainInfo | Helper structure used to transfer information about free chunks chains between different classes |
| SNCSpecificParams | |
| SNCSyncEvent | Single event record |
| SNCTempBlobInfo | |
| CPanelGrid::SNeighbors | |
| SNetCacheAdminImpl | |
| SNetCacheAPIImpl | |
| SNetCacheAutomationObject | |
| SNetICacheClientImpl | |
| SNetScheduleAdminImpl | |
| SNetScheduleAPIImpl | |
| SNetScheduleBaseAutomationObject | |
| SNetScheduleExecutorImpl | |
| SNetScheduleServerAutomationObject | |
| SNetScheduleServiceAutomationObject | |
| SNetScheduleSubmitterImpl | |
| SNetServerConnectionImpl | |
| SNetServerImpl | |
| SNetServerInfoImpl | |
| SNetServerInPool | |
| SNetServerMultilineCmdOutputImpl | |
| SNetServerPoolImpl | |
| SNetServiceImpl | |
| SNetServiceIterator_Circular | |
| SNetServiceIterator_OmitPenalized | |
| SNetServiceIterator_RandomPivot | |
| SNetServiceIteratorImpl | |
| CConcurrentMap< Key, Value, Comparator, Allocator, CntChildsInNode, MaxTreeHeight, DeletionDelay, DelStoreCapacity >::SNode | |
| CPackString::SNode | |
| CConcurrentMap< Key, Value, Comparator, Allocator, CntChildsInNode, MaxTreeHeight, DeletionDelay, DelStoreCapacity >::SNodeBase | |
| CIntervalTreeTraits::SNodeMapValue | |
| SNodeNameUpdater | |
| impl::SNoLock | |
| SNS_Parameters | Parameters for server |
| SNSCommandArguments | |
| SNSDBEnvironmentParams | |
| SNSGroupJobs | |
| SNSGroupTokenCompare | |
| SNSJobsAffinity | |
| SNSNotificationAttributes | |
| SNSProtoArgument | |
| SNSProtoCmdDef< Extra > | |
| SNSProtoParsedCmd< Extra > | |
| SNSTokenCompare | |
| value_slice::SNumericLimits< T, is_signed > | |
| value_slice::SNumericLimits< bool, false > | |
| value_slice::SNumericLimits< T, false > | |
| ITypeConverter::SObject | Struct SObject provides an interface for defining what is returned from object conversion |
| CRelation::SObject | Struct SObject provides an interface for defining what is returned from object conversion |
| CLDS_Query::SObjectDescr | Structure describes the indexed object |
| CObjectsSniffer::SObjectDescription | |
| CLDS_CoreObjectsReader::SObjectDetails | |
| CLDS_CoreObjectsReader::SObjectParseDescr | |
| SOCK_tag | |
| SOCKSSL_struct | |
| SofaType | |
| SOffsetInfo | |
| variation_ref::CHgvsParser::SOffsetLoc | |
| variation_ref::CHgvsParser::SOffsetPoint | |
| variation::CHgvsParser::SOffsetPoint | |
| CDbIndex::SOffsetValue | |
| CPhrap_Contig::SOligo | |
| CBlastOptionsBuilder::SOptional< T > | Optional-value idiom |
| SOptionDefinition | |
| SOptionInfo | |
| SOptionOrCommandInfo | |
| CDbIndex::SOptions | Simple record type used to specify index creation parameters |
| CGridCommandLineInterfaceApp::SOptions | |
| xml::impl::sort_callback< T > | |
| COligoSpecificityCheck::sort_order | Strict weak ordering functor |
| CGBSeqFormatter::SOStreamContainer | |
| SourceFile | |
| CJsonOverUTTPWriter::SOutputStackFrame | |
| SPairBy1stLess< T, U > | |
| SPairLessByFirst< T, U > | |
| SPairLessBySecond< T, U > | |
| CIncreasingTime::SParam | |
| impl::CDB_Params::SParam | |
| CDataLoaderPatcher::SParam | |
| SParamDescription< TValue > | |
| SParamDescription< string > | |
| SParamEnumDescription< TValue > | |
| IHitMatrixDataSource::SParams | |
| CGapJob::SParams | |
| CHapmapJob::SParams | |
| CBinsJob::SParams | |
| CLDBlockDS::SParams | |
| CSnpJob::SParams | |
| CGetTooltip_local::SParamStruct | |
| CSimpleMakeFileContents::SParser | |
| CSeq_id_Patent_Tree::SPat_idMap | |
| CMultiAlignerOptions::CPattern::SPattern | |
| SPatternHit | Intermediate representation of a pattern hit |
| SPatternUnit | |
| CMsvcMetaMakefile::SPchInfo | |
| SPerson | |
| OpenGLRenderer::SphereInfo | |
| OpenGLRenderer::SpherePtr | |
| SPHIHspInfo | In PHI BLAST: information about pattern match in a given HSP |
| SPHIPatternInfo | Information about a single pattern occurence in the query |
| SPHIPatternSearchBlk | Structure containing all auxiliary information needed in a pattern search |
| SPHIQueryInfo | In PHI BLAST, structure containing information about all pattern occurrences in query |
| SPhoneBookDB | |
| SPhoneBookZipIDX | |
| SPipeConnector | |
| SPluginParams | |
| CSocketAPI::SPoll | Polling structure |
| SPOLLABLE_Poll | |
| CHTML_html::SPopupMenuInfo | |
| CHTMLPage::SPopupMenuInfo | Popup menu info structure |
| SPositionTraits< Position > | |
| SPositionTraits< double > | |
| SPositionTraits< float > | |
| SPositionTraits< long double > | |
| SPositionTraitsBySignedness< Signed, Position > | |
| SPositionTraitsBySignedness< false, Position > | |
| SPositionTraitsBySignedness< true, Position > | |
| CSeqMap::SPosLessSegment | |
| CEventHandler::SPostRequest | |
| CAlignSort::SPQSort | |
| SPrefetchTypes | |
| COligoSpecificityCheck::SPrimerHitInfo | Primer hit to the blast dababase |
| COligoSpecificityCheck::SPrimerInfo | Input primer pair information only the left and right range information is needed by this API |
| COligoSpecificityCheck::SPrimerMatch | Value for coordinate-alignment cache |
| SPrintIdentifier | |
| CBLASTParams::SProgInfo | Describes static attributes of a BLAST program |
| CBLASTParams::SProgParams | Describes parameters for a BLAST program |
| CMultiAligner::SProgress | Structure for reporting alignment progress |
| CNWAligner::SProgressInfo | |
| SProjectSelectorParams | SProjectSelectorParams - holds data for CProjectSelectorPanel |
| SProjectTreeFolder | SProjectTreeFolder -- |
| SProjectTreeInfo | Abstraction of project tree general information |
| SPromoteTraits< T, U > | |
| SPromoteTraits< char, char > | |
| SPromoteTraits< char, double > | |
| SPromoteTraits< char, float > | |
| SPromoteTraits< char, int > | |
| SPromoteTraits< char, short > | |
| SPromoteTraits< char, unsigned char > | |
| SPromoteTraits< char, unsigned int > | |
| SPromoteTraits< char, unsigned short > | |
| SPromoteTraits< double, char > | |
| SPromoteTraits< double, double > | |
| SPromoteTraits< double, float > | |
| SPromoteTraits< double, int > | |
| SPromoteTraits< double, short > | |
| SPromoteTraits< double, unsigned char > | |
| SPromoteTraits< double, unsigned int > | |
| SPromoteTraits< double, unsigned short > | |
| SPromoteTraits< float, char > | |
| SPromoteTraits< float, double > | |
| SPromoteTraits< float, float > | |
| SPromoteTraits< float, int > | |
| SPromoteTraits< float, short > | |
| SPromoteTraits< float, unsigned char > | |
| SPromoteTraits< float, unsigned int > | |
| SPromoteTraits< float, unsigned short > | |
| SPromoteTraits< int, char > | |
| SPromoteTraits< int, double > | |
| SPromoteTraits< int, float > | |
| SPromoteTraits< int, int > | |
| SPromoteTraits< int, short > | |
| SPromoteTraits< int, unsigned char > | |
| SPromoteTraits< int, unsigned int > | |
| SPromoteTraits< int, unsigned short > | |
| SPromoteTraits< short, char > | |
| SPromoteTraits< short, double > | |
| SPromoteTraits< short, float > | |
| SPromoteTraits< short, int > | |
| SPromoteTraits< short, short > | |
| SPromoteTraits< short, unsigned char > | |
| SPromoteTraits< short, unsigned int > | |
| SPromoteTraits< short, unsigned short > | |
| SPromoteTraits< unsigned char, char > | |
| SPromoteTraits< unsigned char, double > | |
| SPromoteTraits< unsigned char, float > | |
| SPromoteTraits< unsigned char, int > | |
| SPromoteTraits< unsigned char, short > | |
| SPromoteTraits< unsigned char, unsigned char > | |
| SPromoteTraits< unsigned char, unsigned int > | |
| SPromoteTraits< unsigned char, unsigned short > | |
| SPromoteTraits< unsigned int, char > | |
| SPromoteTraits< unsigned int, double > | |
| SPromoteTraits< unsigned int, float > | |
| SPromoteTraits< unsigned int, int > | |
| SPromoteTraits< unsigned int, short > | |
| SPromoteTraits< unsigned int, unsigned char > | |
| SPromoteTraits< unsigned int, unsigned int > | |
| SPromoteTraits< unsigned int, unsigned short > | |
| SPromoteTraits< unsigned short, char > | |
| SPromoteTraits< unsigned short, double > | |
| SPromoteTraits< unsigned short, float > | |
| SPromoteTraits< unsigned short, int > | |
| SPromoteTraits< unsigned short, short > | |
| SPromoteTraits< unsigned short, unsigned char > | |
| SPromoteTraits< unsigned short, unsigned int > | |
| SPromoteTraits< unsigned short, unsigned short > | |
| CMapControl::SProperties | |
| CHistogramGraph::SProperties | |
| CBasicRelation::SPropPair | |
| SPsiBlastScoreMatrix | Scoring matrix data used in PSI-BLAST |
| SPurgeAttributes | |
| SQueryFactorySrcNewArgs | Encapsulates the arguments needed to initialize multi-sequence source |
| SQueryParamInfo | |
| SQueueDbBlock | Queue databases |
| SQueueDescription | |
| SQueueDescriptionDB | BDB table for storing queue descriptions |
| SQueueInfo | |
| CAppJobDispatcher::SQueueItem | SQueueItem - element of the Polling Queue |
| SQueueParameters | Queue parameters |
| SRandomIterationBeginner | |
| SRangesByPctIdent | |
| SRangesByScore | |
| SRangesBySize | |
| SRangeSorter< T > | Sorting functor for finding a range inside a collection of layout objects |
| SRangeStartSort | Auxiliary structure used for sorting CRange<int> objects in increasing order of starting positions |
| CPhrap_Read::SReadDS | |
| CReaderCacheManager::SReaderCacheInfo | |
| SReadInt4 | |
| CPhrap_Read::SReadTag | |
| CObjectIndex::SRec | |
| CGFFReader::SRecord | |
| CConcurrentMap< Key, Value, Comparator, Allocator, CntChildsInNode, MaxTreeHeight, DeletionDelay, DelStoreCapacity >::SRefedKey | |
| CTraversalNode::SRefNodeCallLessthan | |
| SRegisterLoaderInfo< TLoader > | SRegisterLoaderInfo -- |
| SRelease | |
| SRelLoc | Location relative to a base Seq-loc: one (usually) or more ranges of offsets |
| SRepeat | Implementation of IRepeat backed by a simple structure |
| SRepeatFilterOptions | Filtering options for organsim specific repeats filtering |
| SRepeatRegion | Structure implementing the IRepeatRegion API as a simple store of data memebers |
| SRequestCtxWrapper | |
| SRequestDetails | |
| CNcbiResourceInfoFile::SResInfoCache | |
| CDllResolver::SResolvedEntry | DLL resolution descriptor |
| CSnpTableJob::SResult | |
| CSRSearch::SResultData | |
| CSRSearch::SResults | |
| SRetry | |
| CGlTube< Curve >::SRingPos | |
| SRombergCbackArgs | Internal data structure used by Romberg integration callbacks |
| CTraversalSpecFileParser::SRootInfo | |
| SRotatedFontCachePurger | |
| SRotateKey | Rotated versions of the above we store a cache of these that is generated on the fly these fonts are only created as needed, and the data structures will only be created once per session |
| SRotateKeyLess | |
| CAlignSeqTableModel::SRow | |
| CAnnotCompareDS::SRow | |
| CSparseAlignment::SRowRec | Describes a sequence in the alignment |
| CAlnMultiModel::SRowRecord | SRowRecord is a record representing a single alignment row |
| SRState | |
| value_slice::SRunTimeCP | |
| value_slice::SRunTimeSqlCP | |
| AutoArray< X, Del >::SSafeBoolTag | Bool operator for use in if() clause |
| AutoPtr< X, Del >::SSafeBoolTag | Bool operator for use in if() clause |
| value_slice::SSafeCP | |
| value_slice::SSafeSqlCP | |
| SSaveProjectsDlgParams | |
| SSaveResultLevel | |
| CGumbelParamsResult::SSbsArrays | |
| SScheduler_SeriesInfo | Information about scheduled series |
| CSearchQueryBase::SScopedLoc | |
| SScopedObject | |
| SScopedObjectLess | |
| CShowBlastDefline::SScoreInfo | Internal data with score information for each defline |
| SScPix | Pixel with a score, if several intervals cover a pixel, the interval with the maximum coverage will "own" the pixel (i.e |
| SScPix2 | Pixel with two scores, one corresponds to a gap interval, another - to an aligned segment |
| bm::sse_empty_guard | SSE2 reinitialization guard class |
| CSRSearch::SSearchData | |
| CDbIndex::SSearchOptions | Simple record type used to specify index search parameters |
| CMemoryRegistry::SSection | |
| SSeedRoot | Representation of a seed root |
| SSeedTopPattern | |
| SSeg | List of sequence segments (hits) |
| CNWFormatter::SSegment | |
| SCigarAlignment::SSegment | |
| CMultiAligner::SSegmentLoc | |
| SSegOptions | Options for SEG algorithm, applies only to protein-protein comparisons |
| SSemaphore | |
| SSendMailInfo | |
| CTSE_SetObjectInfo::SSeq_annot_Info | |
| SSeq_id_ScopeInfo | |
| SSeq_loc_CI_RangeInfo | |
| SSeqAlignsByPctIdent | |
| SSeqAlignsByScore | |
| SSeqAlignsBySize | |
| CAlignFormatUtil::SSeqAlignSetCalcParams | Structure that holds information for all hits of one subject in Seq Align Set |
| SSeqAttrChanger< CSeqEdit_Cmd_ChangeSeqAttr::TData::e_Ext > | |
| SSeqAttrChanger< CSeqEdit_Cmd_ChangeSeqAttr::TData::e_Fuzz > | |
| SSeqAttrChanger< CSeqEdit_Cmd_ChangeSeqAttr::TData::e_Hist > | |
| SSeqAttrChanger< CSeqEdit_Cmd_ChangeSeqAttr::TData::e_Inst > | |
| SSeqAttrChanger< CSeqEdit_Cmd_ChangeSeqAttr::TData::e_Length > | |
| SSeqAttrChanger< CSeqEdit_Cmd_ChangeSeqAttr::TData::e_Mol > | |
| SSeqAttrChanger< CSeqEdit_Cmd_ChangeSeqAttr::TData::e_Repr > | |
| SSeqAttrChanger< CSeqEdit_Cmd_ChangeSeqAttr::TData::e_Seq_data > | |
| SSeqAttrChanger< CSeqEdit_Cmd_ChangeSeqAttr::TData::e_Strand > | |
| SSeqAttrChanger< CSeqEdit_Cmd_ChangeSeqAttr::TData::e_Topology > | |
| CAlnMixSegment::SSeqComp | |
| variation::CVariationUtil::CCdregionIndex::SSeqData | |
| CSplitDataLoader::SSeqData | |
| SSeqDB_ArraySource | Forward iteration (only) for an array of sequence data |
| SSeqDB_IndexCountPair | Defines a pair of integers and a sort order |
| SSeqDB_SeqSrc_Data | Simple container to support SeqSrc-local data |
| SSeqDB_SVCISource | Forward iteration (only) for sequence data of a Bioseq object |
| SSeqDBInitInfo | Structure to define basic information to initialize a BLAST DB |
| SSeqDBSlice | OID-Range type to simplify interfaces |
| SSeqDBTaxInfo | SSeqDBTaxInfo |
| CSeq_align::SSeqIdChooser | Create a Dense-seg from a Std-seg Used by AlnMgr to handle nucl2prot alignments |
| SSeqIdDeleter | |
| SSeqIdKey | Auxiliary type to embed a CConstRef<objects::CSeq_id> in STL containers that require operator< to be defined |
| SSeqIdRange | SSeqIdRange -- |
| CAlnMixSequences::SSeqIds | |
| CElementaryMatching::SSeqInfo | |
| CSubjectMap_Factory_TBase::SSeqInfo | Information about the sequence chunk |
| SSeqLoc | Structure to represent a single sequence to be fed to BLAST |
| SSeqMapSelector | Selector used in CSeqMap methods returning iterators |
| SSeqMatch_DS | |
| SSeqMatch_Scope | |
| SSeqMatch_TSE | |
| SSeqRange | A structure containing two integers, used e.g |
| CSeqDBImpl::SSeqRes | Structure to keep sequence retrieval results |
| CSeqDBImpl::SSeqResBuffer | Structure to buffer multiple TSeqRes |
| CSubjectMap_Factory_Base::SSeqSeg | Type used to store a masked segment internally |
| SSequence | General sequence information |
| SSequenceInfo | |
| CAlignFormatUtil::SSeqURLInfo | Structure that holds information needed for creation seqID URL in descriptions and alignments |
| SSERV_Attr | |
| SSERV_DnsInfo | |
| SSERV_FirewallInfo | |
| SSERV_HttpInfo | |
| SSERV_Info | |
| SSERV_Info_VTable | |
| SSERV_IterTag | |
| SSERV_NcbidInfo | |
| SSERV_StandaloneInfo | |
| SSERV_VTable | |
| SServer_Parameters | SServer_Parameters:: |
| SServerAddress | |
| CNetScheduleAPI::SServerParams | |
| CNetScheduleAdmin::SServerQueueList | |
| SServerScanInfo | |
| SSERVICE_Extra | |
| SServiceConnectorTag | |
| CSearchToolBase::SSession | |
| SSetAttrChanger< CSeqEdit_Cmd_ChangeSetAttr::TData::e_Class > | |
| SSetAttrChanger< CSeqEdit_Cmd_ChangeSetAttr::TData::e_Coll > | |
| SSetAttrChanger< CSeqEdit_Cmd_ChangeSetAttr::TData::e_Date > | |
| SSetAttrChanger< CSeqEdit_Cmd_ChangeSetAttr::TData::e_Id > | |
| SSetAttrChanger< CSeqEdit_Cmd_ChangeSetAttr::TData::e_Level > | |
| SSetAttrChanger< CSeqEdit_Cmd_ChangeSetAttr::TData::e_Release > | |
| SShortPatternItems | Auxiliary items needed for a PHI BLAST search with a pattern that fits in a single word |
| CSchedulerEngine::SSignal | Signals that Engine send to its scheduling thread |
| SSimpleLock< Resource > | SSimpleLock is a functor to wrap calling Lock() |
| SSimpleReadLock< Class > | SSimpleReadLock -- |
| SSimpleReadUnlock< Class > | SSimpleReadUnlock -- |
| SSimpleUnlock< Resource > | SSimpleLock is a functor to wrap calling Unlock() |
| SSimpleWriteLock< Class > | SSimpleWriteLock -- |
| SSimpleWriteUnlock< Class > | SSimpleWriteUnlock -- |
| CSeqDBGiList::SSiOid | Structure that holds Seq-id,OID pairs |
| SSizeInfo | |
| COligoSpecificityCheck::SSlaveRange | |
| SSlotData | |
| SSmartStringItem | |
| CBinsGlyph::SSnp | |
| SSNP_Info | |
| SSnpData | |
| SSNPFeatParamDefiner | |
| SSnpFilter | |
| SSnpJobResult | SSnpJobResult |
| SSOCK_Poll | I/O polling structure |
| SSockConnector | |
| SSortByFirst< T, U > | |
| SSortByScoreStruct | Auxiliary structure to allow sorting the results by score for the composition-based statistics code |
| SSortBySecond< T, U > | |
| CAlignSort::SSortKey | |
| CAlignSort::SSortKey_Less | |
| SSortSourceByLoc | |
| CAlnSpanVertModel::SSpanRow | Alignment we store with its parsed data |
| CNetCacheServer::SSpecParamsEntry | |
| CNetCacheServer::SSpecParamsSet | |
| SSplitQueryBlk | Structure to keep track of which query sequences are allocated to each query chunk |
| SSplitterParams | |
| SSQLITE_BlobClose | Helper structure for closing the blob from CGuard<> |
| SSQLITE_BlobOpen< readwrite > | Helper structure for opening the blob from CGuard<> |
| CQueryParseNode::SSrcLoc | Source location (points to the position in the original src) All positions are 0 based |
| CSRSearch::SSRResult | |
| SSrvGroupInfo | |
| SSrvSyncedData | |
| CStackTrace::SStackFrameInfo | Structure for holding stack trace data |
| SStartCounterDB | |
| CDirEntry::SStat | Alternate stat structure for use instead of the standard struct stat |
| CIntervalTree::SStat | |
| CWig2tableApplication::SStat | |
| SStateScores | |
| SStaticPair< FirstType, SecondType > | Template structure SStaticPair is simlified replacement of STL pair<> Main reason of introducing this structure is o allow static initialization by { xxx } construct |
| SStats | |
| CAlnStatGlyph::SStatStruct | |
| SStringCount | |
| SStringHash | Functor-adaptor for StringHash17 |
| SStringLess< TComp > | String comparison using integers instead of const char* this is coded in C++ and beats an assembler-based memcmp() this algorithm makes no adjustment for memory alignment and may be either slower or illegal on some platforms |
| SSubjRootsInfo | SSeedRoot container for one subject |
| CGFFReader::SRecord::SSubLoc | |
| SAccGuide::SSubMap | |
| SSubString | |
| SSubtypeAbbr | |
| SSubtypeInfo | |
| SSyncSlotData | |
| SSyncSlotSrv | |
| SSyncSrvData | |
| SSyncTaskInfo | |
| SSystemFastMutex | SSystemFastMutex -- |
| SSystemMutex | SSystemMutex -- |
| STableRowHook_Ctx | |
| STagGuard | |
| CSeq_id_General_Tree::STagMap | |
| CContigAssembly::SAlignStats::STails | |
| state | |
| stateblock | |
| mu::STATIC_ASSERTION_FAILURE< true > | |
| static_tree_desc_s | |
| StaticTagMapper | |
| StaticTagMapperByData | |
| StaticTagMapperByDataAndName | |
| StaticTagMapperByName | |
| StaticTagMapperByNode< C > | |
| StaticTagMapperByNodeAndData< C, T > | |
| StaticTagMapperByNodeAndDataAndName< C, T > | |
| StaticTagMapperByNodeAndName< C > | |
| bm::bvector< Alloc >::statistics | Statistical information about bitset's memory allocation details |
| STaxidTaxname | |
| CTaxTreeBrowser::STaxInfo | Our internal tree structure |
| STaxSeqInfo | Sequence information record |
| STempFileLocker | |
| CUIToolRegistry::STemplateToolRecord | |
| CPrintOptions::SText | |
| stFolderInfo | |
| CThreadedApp::SThreadGroup | Thread group description parameters |
| CThread::SThreadInfo | |
| SThreadPool_PID_ErrInfo | Entry in "error" changing history Information about "error" in some point of time in the past kept in CThreadPool_Control_PID |
| SThreadPool_TaskCompare | Functor to compare tasks by priority |
| STime_tag | Application access log and error postings info structure |
| STimeoutTag | Timeout structure |
| CNCBlobStorage::STimeTable | |
| CSeqDBGiList::STiOid | Structure that holds TI,OID pairs |
| CTlsBase::STlsData | Internal structure to store all three pointers in the same TLS |
| STmpDirGuard | |
| STopologyInfo | |
| CGradientColorPanel::stParams | |
| STPFinder | Base help functor to search a track proxy using a key value |
| STPFinderByKey | Help functor to search a track proxy by track key |
| STPFinderByName | Help functor to search a track proxy by track name |
| STPFinderBySubkey | Help functor to search a track proxy by track subkey |
| CTrackProxy::STPSorterByID | Help functor for less comparison |
| CEditScript::STracebackOp | Runlength-encoded representation of a traceback operation |
| STrackedSeed< ONE_HIT > | Specialization for one-hit based search |
| STrackedSeed< TWO_HIT > | Specializarion for two-hit based search |
| STrackSettings | Help struct for storing track settings passed from url |
| Strand3D | |
| StrandStyle | |
| CTree::STreeEdge | Structure for listing tree edges |
| CTree::STreeLeaf | Structure for listing tree leaves |
| CIntervalTreeTraits::STreeMapValue | |
| STreeNodeMapper | |
| string_linked_list | |
| string_nocase_less | |
| StringCmp | |
| StrLenAdd | Auxiliary functor to compute the length of a string (shamlessly copied from seq_writer.cpp) |
| struct_for_lambda_calculation | |
| struct_for_randomization | |
| UpdateViewer::StructureAlignmentInfo | |
| StructureBase | |
| StructureObject | |
| StructureSet | |
| StructureWindow | |
| CGeneFileUtils::STwoIntRecord | STwoIntRecord - a pair of integers |
| StyleDialog | |
| StyleManager | |
| StyleSettings | |
| xslt::stylesheet | The xslt::stylesheet class is used to hold information about an XSLT stylesheet |
| STypeChooser< CSeqEdit_Cmd::e_Add_annot > | |
| STypeChooser< CSeqEdit_Cmd::e_Add_desc > | |
| STypeChooser< CSeqEdit_Cmd::e_Add_descr > | |
| STypeChooser< CSeqEdit_Cmd::e_Add_id > | |
| STypeChooser< CSeqEdit_Cmd::e_Attach_annot > | |
| STypeChooser< CSeqEdit_Cmd::e_Attach_seq > | |
| STypeChooser< CSeqEdit_Cmd::e_Attach_seqentry > | |
| STypeChooser< CSeqEdit_Cmd::e_Attach_set > | |
| STypeChooser< CSeqEdit_Cmd::e_Change_seqattr > | |
| STypeChooser< CSeqEdit_Cmd::e_Change_setattr > | |
| STypeChooser< CSeqEdit_Cmd::e_Remove_annot > | |
| STypeChooser< CSeqEdit_Cmd::e_Remove_desc > | |
| STypeChooser< CSeqEdit_Cmd::e_Remove_id > | |
| STypeChooser< CSeqEdit_Cmd::e_Remove_seqentry > | |
| STypeChooser< CSeqEdit_Cmd::e_Replace_annot > | |
| STypeChooser< CSeqEdit_Cmd::e_Reset_descr > | |
| STypeChooser< CSeqEdit_Cmd::e_Reset_ids > | |
| STypeChooser< CSeqEdit_Cmd::e_Reset_seqattr > | |
| STypeChooser< CSeqEdit_Cmd::e_Reset_seqentry > | |
| STypeChooser< CSeqEdit_Cmd::e_Reset_setattr > | |
| STypeChooser< CSeqEdit_Cmd::e_Set_descr > | |
| STypeLink | |
| STypeSelector< Type > | Class STypeSelector |
| STypeSelector< IDataArray::eColor > | |
| STypeSelector< IDataArray::eNumeric > | |
| STypeSelector< IDataArray::ePointer > | |
| STypeSelector< IDataArray::eString > | |
| SU_PSSMInput | |
| SUApp | |
| SubjectSplitStruct | Structure used for subject sequence split |
| SUidCollector | |
| SUidCounter | |
| SumOfScoresColumnScorer | |
| SUnicodeTranslation | Structure to keep substititutions for the particular unicode character |
| CChangeUnindexedObjectCommand< T >::SUnindexedObject | |
| CTSE_ScopeInfo::SUnloadedInfo | |
| impl::SUnLock | |
| CUrlArgs::SUrlArg | Name-value pair |
| SUtility | |
| CAnalysisFileLoader::SValue | |
| CGwasGlyph::SValue | |
| CLDBlockGlyph::SValue | |
| CWig2tableApplication::SValueInfo | |
| CCache< TKey, TValue, THandler, TLock, TSize >::SValueWithIndex | |
| CChoiceTypeStrings::SVariantInfo | |
| CChoicePtrTypeStrings::SVariantInfo | |
| CVecscreenRun::SVecscreenSummary | Summary of hits |
| CSparseKmerCounts::SVectorElement | Element of the sparse vector |
| CwxTableListCtrl::SViewState | |
| CBDB_BlobSplitStore< TBV, TObjDeMux, TL >::SVolume | Volume split on optimal page size |
| CIndexedDb_New::SVolumeDescriptor | |
| CBDB_SplitCursor< BDB_SplitStore, BDB_Vol >::SVolumeLess | |
| SVolumesDB | BDB file for storing volumes registry |
| CInstInfoMap::SVoucherInfo | |
| SW | |
| SWFileDlgData | |
| SwGapInfo | A structure used internally by the Smith-Waterman algorithm to represent gaps |
| SWindowMaskerOptions | Filtering options for organism-specific filtering with Window Masker |
| CNetScheduleAdmin::SWorkerNodeInfo | |
| CSQLITE3_Cache::SWriteRequest | Delayed write request object |
| SWritingInfo | |
| SwxMapItemProperties | SwxMapItemProperties - properties of the IwxMapItem |
| SwxMenuItemRec | |
| CODBC_RowResult::t_SODBC_ColDescr | |
| tag_DBPROC_ROWBUF | |
| tag_FaultcodeEnum | |
| tag_HtmlEntities | |
| tagDATE_STRUCT | |
| TagMapper< C > | |
| TagMapperByData< C, T > | |
| TagMapperByDataAndName< C, T > | |
| TagMapperByName< C > | |
| tagMODULEENTRY32 | |
| tagODBC_VS_ARGS | |
| tagTIME_STRUCT | |
| tagTIMESTAMP_STRUCT | |
| oligofar::TAligner_fast< CQuery, CSubject > | |
| oligofar::TAligner_HSP< CQuery, CSubject > | |
| oligofar::TAligner_SW< CQuery, CSubject > | |
| oligofar::TAlignerBase< CQuery, CSubject > | |
| TaxClient | |
| TaxNode | |
| TaxonomyTree | |
| TaxonomyTreeNode | |
| TaxonomyWindow | |
| TaxTreeData | |
| TBlock | Block as a header |
| IDMSearchTool::TConversions | |
| CTime::TData | |
| TDataExchange< T > | TDataExchange - a simple class for use with wxDataObject |
| TDBTimeI | Database format for time where day and time is signed 32 bit |
| TDBTimeU | Database format for time where day and time is unsigned 16 bit |
| TDS8_COLLATION | TDS 8.0 collation information |
| tds_align_struct | |
| tds_answer | |
| tds_authentication | |
| tds_blob | Information about blobs (e.g |
| tds_column | Metadata about columns in regular and compute rows |
| tds_connection | |
| tds_context | |
| tds_dblib_dbprocess | |
| tds_dblib_loginrec | |
| tds_dynamic | |
| tds_env | |
| tds_locale | |
| tds_login | |
| tds_message | |
| tds_multiple | |
| tds_option_arg | |
| tds_result_info | Hold information for any results |
| tds_save_context | |
| tds_save_env | |
| tds_save_msg | |
| tds_socket | |
| tds_time | |
| tds_upd_col | |
| tdsdaterec | Information on data, used by tds_datecrack |
| tdsdatetime | |
| tdsdatetime4 | |
| tdsiconvinfo | |
| tdsmoney | |
| tdsmoney4 | |
| tdsnumeric | |
| tdsoldmoney | |
| tdsunique | |
| tdsvarbinary | |
| tdsvarchar | |
| CDll::TEntryPoint | Entry point -- pointer to either a function or a data |
| TestFixture | |
| TestRec | |
| xml::node::text | Helper struct for creating a xml::node of type_text |
| TExtRNA | |
| TextRow | |
| IDMSearchTool::TFilters | |
| TGenfo | |
| Threader | |
| ThreaderOptions | |
| ThreaderOptionsDialog | |
| TIdWrapper< TId, Type > | |
| TInfo | |
| IStickyTooltipHandlerHost::TipLocation | |
| CSeq_id_Textseq_Info::TKey | |
| CSeq_id_General_Str_Info::TKey | |
| TKmerMethods< TKmerCounts > | Interface for computing and manipulating k-mer counts vectors that allows for different implementations of K-mer counts vectors |
| TMaskedQueryRegions | Collection of masked regions for a single query sequence |
| bm::tmatrix< T, ROWS, COLS > | Mini-matrix for bit transposition purposes |
| CNCBINode::TMode | |
| TNcbiLog_MTLock_tag | |
| tODBCINSTWND | |
| CSeqDB::TOffsetPair | Structure to represent a range |
| ToolCmp | |
| ToStr< T > | |
| ToStr< int > | |
| ToStr< string > | |
| ToStr< unsigned int > | |
| TProblem_loc | |
| TQueryMessages | Class for the messages for an individual query sequence |
| TQueryMessagesComparator | |
| TQueryMessagesEqualComparator | |
| TQueryMessagesLessComparator | |
| Traceback | |
| tracker | |
| TransformFunction | |
| tree< T, tree_node_allocator > | |
| tree_desc_s | |
| xml::impl::tree_impl | |
| tree_node_< T > | |
| xml::tree_parser | The xml::tree_parser class is used to parse an XML document and generate a tree like structure of xml::node objects |
| CPhyloTreeDataSource::tree_to_dynamic | |
| TreeAlgorithm | |
| TreeFactory | |
| CPhyloTreePane::TreeNavHistory | |
| TreeNodePair | |
| TreeOptions | |
| TrialStats | |
| TRIGGER_tag | |
| TrimAlignment | |
| CSymDustMasker::triplets | |
| CGroupTableModel::TRow | |
| TruncatedSequence | |
| TSearchMessages | Typedef for the messages for an entire BLAST search, which could be comprised of multiple query sequences |
| oligofar::TSeqRef< Base, incr, coding > | |
| CSeqDB::TSequenceRanges | List of sequence offset ranges |
| TSimplePair | |
| TSimpleSeq | |
| TSortCit | |
| TVector | |
| TypeStringAssociator< T > | |
| ucd_record | |
| ucp_type_table | |
| CByteSwap::UDoubleInt8 | |
| CByteSwap::UFloatInt4 | |
| UInt64 | |
| oligofar::UintH | |
| UnalignedBlock | |
| UnalignedInterval | |
| UnalignedSegReader | |
| UngappedAlignedBlock | |
| UniversalOptiosHandleFixture | |
| UpdaterInterface | |
| UpdateViewer | |
| UpdateViewerWindow | |
| StyleManager::UserAnnotation | |
| USERV_Info | |
| value_compare | |
| value_equals< K, V > | |
| Vector< T > | |
| verbitem | |
| ViewableAlignment | |
| ViewerBase | |
| ViewerWindowBase | |
| Threader::VirtualCoordinate | |
| CPhyloTreeDataSource::visitor_leafs_reader | |
| CPhyloTreeDataSource::visitor_node_finder | |
| CPhyloTreeDataSource::visitor_read_properties | |
| CPhyloTreeDataSource::visitor_selection_reader | |
| CPhyloTreeDataSource::visitor_set_dirty | |
| CPhyloTreeDataSource::visitor_show_all | |
| CPhyloTreeDataSource::visitor_sorter | |
| CPhyloTreeDataSource::visitor_string_query | |
| CPhyloTreeDataSource::visitor_string_query_no_case | |
| VSRunSampleApplication | |
| WRONG_ERROR_SUBCODE_IN_POST_MACRO< errorCode, errorSubcode, maxErrorSubcode, false > | Specialization of template: when error subcode is valid existence of this specialization will be valuable for not issuing compiler error |
| WRONG_USAGE_OF_DEFINE_ERR_SUBCODE_MACRO< errorCode, false > | Specialization of template: when usage of NCBI_DEFINE_ERR_SUBCODE_X is correct existence of this specialization will be valuable for not issuing compiler error |
| WSDLEntityLexer | |
| WSDLLexer | |
| WSDLParser | |
| CExtraFeaturePanel::wxExtraFeatItemData | |
| CFeatureCheckPanel::wxFeatItemData | |
| wxFileArtDirNameSet | |
| wxFileArtNameAndImageCache | |
| wxFileArtProvider | |
| CTaxTreeBrowser::wxTaxTreeData | |
| CQueue::x_SJobPick | |
| xml::impl::xmlchar_helper | |
| xml::xpath_expression | The xml::xpath_expression class is used to store xpath query string and optional XML namespaces |
| XPrintTotalsItem | Output the count as text or as xml |
| XSDEntityLexer | |
| XSDLexer | |
| XSDParser | |
| XStr | XStr -- |
| yy_buffer_state | |
| yyalloc | |
| YYSTYPE | |
| z_stream_s | |
| zzzz | |
