| __bigint_struct | |
| __bigint_struct_u | |
| __Enter__ | |
| _Alloc_traits< _Tp, _Allocator > | |
| _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 | |
| AbstractLexer::CComment | |
| AbstractParser | |
| AbstractToken | |
| 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 | |
| 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 | |
| Alpha | Information about the alphabet used by seg |
| AMatrix | |
| AMatrix_base | |
| 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_map< K, V, Cmp, kCapacityIncrement > | |
| 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 | |
| AtomPntr | |
| AtomSet | |
| AtomStyle | |
| xml::attributes | The xml::attributes class is used to access all the attributes of one xml::node |
| xml::attributes::attr | The xml::attributes::attr class is used to hold information about one attribute |
| xml::attributes::const_iterator | Const Iterator class for accessing attribute pairs |
| xml::attributes::iterator | Iterator class for accessing attribute pairs |
| xml::attributes::pimpl | |
| auto_ptr< X > | Auto_ptr -- |
| auto_ptr< X >::auto_ptr_ref< Y > | |
| AutoArray< X, Del > | AutoArray -- |
| AutoPtr< X, Del > | AutoPtr -- |
| 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::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_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 |
| 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 | Auxillary data structure used by culling |
| 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 | Structure holding a pair of offsets |
| 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 |
| 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 | |
| Block::Range | |
| Block::Range | |
| bm::block_allocator | Default malloc based bitblock allocator class |
| bm::block_set_table< T > | Structure keeps all-left/right ON bits masks |
| BlockAligner | |
| BlockAligner::BlockAlignerOptions | |
| BlockAlignerOptionsDialog | |
| BlockBoundaryAlgorithm | |
| BlockEditingParams | |
| BlockExtender | |
| BlockFormater | |
| BlockIntersector | |
| BlockModel | |
| BlockModelPair | |
| BlockMultipleAlignment | |
| BlockMultipleAlignment::BlockInfo | |
| BlockMultipleAlignment::BlockInfo | |
| bm::blocks_manager< Alloc, MS > | 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, MS >::block_any_func | Functor detects if any bit set |
| bm::blocks_manager< Alloc, MS >::block_copy_func | Block copy functor |
| bm::blocks_manager< Alloc, MS >::block_count_arr_func | Bitcounting functor filling the block counts array |
| bm::blocks_manager< Alloc, MS >::block_count_base | Base class for bitcounting functors |
| bm::blocks_manager< Alloc, MS >::block_count_change_func | Bit value change counting functor |
| bm::blocks_manager< Alloc, MS >::block_count_func | Bitcounting functor |
| bm::blocks_manager< Alloc, MS >::block_free_func | Block deallocation functor |
| bm::blocks_manager< Alloc, MS >::block_invert_func | Bitblock invert functor |
| bm::blocks_manager< Alloc, MS >::block_one_func | Fill block with all-one bits functor |
| bm::blocks_manager< Alloc, MS >::block_opt_func | |
| bm::blocks_manager< Alloc, MS >::block_zero_func | Set block zero functor |
| bm::blocks_manager< Alloc, MS >::bm_func_base | Base functor class (block visitor) |
| bm::blocks_manager< Alloc, MS >::bm_func_base_const | Base functor class connected for "constant" functors |
| bm::blocks_manager< Alloc, MS >::gap_level_func | |
| BMARefinerInterface | |
| BMARefinerOptions | |
| BMARefinerOptionsDialog | |
| BMAUtils | |
| Bond | |
| BondStyle | |
| BondStyle::EndStyle | |
| branch_chain | |
| BUF_tag | |
| bm::bv_statistics | Structure with statistical information about bitset's memory allocation details |
| bm::bvector< Alloc, MS > | Bitvector with runtime compression of bits |
| bm::bvector< Alloc, MS >::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 |
| bm::bvector< Alloc, MS >::enumerator | Constant input iterator designed to enumerate "ON" bits |
| bm::bvector< Alloc, MS >::insert_iterator | Output iterator iterator designed to set "ON" bits based on input sequence of integers (bit indeces) |
| bm::bvector< Alloc, MS >::iterator_base | Base class for all iterators |
| bm::bvector< Alloc, MS >::iterator_base::bitblock_descr | Information about current bitblock |
| bm::bvector< Alloc, MS >::iterator_base::block_descr | |
| bm::bvector< Alloc, MS >::iterator_base::dgap_descr | Information about current DGAP block |
| bm::bvector< Alloc, MS >::reference | Class reference implements an object for bit assignment |
| bm::bvector< Alloc, MS >::statistics | Statistical information about bitset's memory allocation details |
| bm::bvector_mini< A > | Bitvector class with very limited functionality |
| bm::bvmini< N > | Mini bitvector used in bvector template to keep block type flags |
| bz_stream | |
| bzFile | |
| C2DLayoutEngine | Class C2DLayoutEngine defines the interface for a standard 2D layout engine |
| C2naCmp | |
| C2naExpandToIupacna | |
| C2naRevCmp | |
| C2naReverse | |
| C2naTo2naExpand | |
| C2naTo4na | |
| C2naTo8na | |
| C2naToIupacna | |
| C4naCmp | |
| C4naRevCmp | |
| C4naReverse | |
| C4naTo2na | |
| C4naTo2naExpand | |
| C4naTo8na | |
| C4naToIupacna | |
| C8naCmp | |
| C8naTo2na | |
| C8naToIupacna | |
| C_DriverMgr | |
| C_FA_Storage | |
| C_RA_Storage | |
| C_SA_Storage | |
| C_xDriverMgr | |
| C_xDriverMgr::SDrivers | |
| CAA | |
| CAboutDlg | control identifiers |
| CAbstractProjectItem | .hpp User-defined methods of the data storage class |
| CAbstractProjectItem_Base | CAbstractProjectItem_Base -- |
| CAccelTable | CAccelTable - Accelerator Table |
| CAcceptRequest | |
| CAccessionExtractor | Extracts the accession for a given sequence id (CSeqFormatter associates this with a) |
| CAccessionItem | |
| CAccPatternCounter | Accession naming patterns; find ranges for consequtive digits |
| CAce2AsnApp | |
| CAcqSpecification | CAcqSpecification -- |
| CAcqSpecification_Base | Specification for combining raw scans/acquisitions into a single peak list or spectrum |
| CAcqSpecification_Base::C_Attlist | C_Attlist -- |
| CAcquisition | CAcquisition -- |
| CAcquisition_Base | Scan or acquisition from original raw file used to create this peak list, as specified in sourceFile |
| CAcquisition_Base::C_Attlist | C_Attlist -- |
| CAcquisition_Base::C_Attlist | C_Attlist -- |
| CAcquisition_Base::C_E_Acquisition | Scan or acquisition from original raw file used to create this peak list, as specified in sourceFile |
| CAcquisitionList | CAcquisitionList -- |
| CAcquisitionList_Base | List and descriptions of acquisitions |
| CAcquisitionList_Base::C_Attlist | C_Attlist -- |
| CAcquisitionSettings | CAcquisitionSettings -- |
| CAcquisitionSettings_Base | Description of the acquisition settings of the instrument prior to the start of the run |
| CAcquisitionSettings_Base::C_Attlist | C_Attlist -- |
| CAcquisitionSettingsList | CAcquisitionSettingsList -- |
| CAcquisitionSettingsList_Base | List with the descriptions of the acquisition settings applied prior to the start of data acquisition |
| CAcquisitionSettingsList_Base::C_Attlist | C_Attlist -- |
| CActivation | CActivation -- |
| CActivation_Base | CActivation_Base -- |
| CActivation_Base::C_E | The type and energy level used for activation |
| CActiveObject | |
| CAddBioseqChecker | |
| CAddDescr_EditCommand< TEditHandle > | |
| CAddFeatChecker | |
| CAddIdChecker | |
| CAdditional | CAdditional -- |
| CAdditional_Base | CAdditional_Base -- |
| CAdditional_Base::C_E | Subsidiary information about the instrument; a run of additional parameters captured as name-value pairs |
| CAdmin | CAdmin -- |
| CAdmin_Base | Administrative information pertaining to the entire mzData file (i.e |
| CAdvancedFileInput | CAdvancedFileInput |
| CAffil | .hpp User-defined methods of the data storage class |
| CAffil_Base | CAffil_Base -- |
| CAffil_Base::C_Std | Std representation |
| CAffinityDict | Affinity dictionary database class |
| CAffinityDictGuard | |
| CAffinityResolver | |
| 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 | |
| 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 | |
| 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 | |
| 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 |
| CAlignDataSource | |
| CAlignDataSourceException | |
| CAlignedFeatureGraph | CFeatureGraph |
| CAlignedFeatureGraph::SCluster | |
| CAlignedFeatureGraph::SFeatRec | |
| CAlignedFeatureGraph::SLayer | |
| CAlignedGis | Class to contain the gis of the aligned sequences |
| oligofar::CAligner | |
| oligofar::CAligner::CCell | |
| oligofar::CAligner::CDiagonalScores | |
| oligofar::CAligner::CIndelLimits | |
| oligofar::CAligner::CMaxGapLengths | |
| oligofar::CAligner_fast | |
| oligofar::CAligner_HSP | |
| oligofar::CAligner_SW | |
| oligofar::CAligner_SW_Base | |
| oligofar::CAlignerBase | |
| CAlignFilter | |
| CAlignFindContext | |
| CAlignFormatUtil | This class contains misc functions for displaying BLAST results |
| CAlignFormatUtil::SBlastError | Error info structure |
| CAlignFormatUtil::SDbInfo | Blast database info |
| CAlignGlyph | |
| CAlignGroup | |
| CAlignInfo | |
| CAlignMap | |
| CAlignMap::SMapRange | |
| CAlignMap::SMapRangeEdge | |
| CAlignMarkHandler | CAlignMarkHandler manages handling and editing of marks on alignments |
| CAlignMarkHandler::SMarkDelta | Helper class representing range being edited |
| CAlignmentBasedRowSelector | |
| CAlignmentConfig | CAlignmentConfig: the data structure holding alignment rendering parameters |
| 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 |
| CAlignRangeCollExtender< TColl >::PItLess | |
| CAlignResultsSet | |
| CAlignRow | |
| CAlignRowGraphCont | CAlignRowGraphCont |
| CAlignSeqTableModel | CAlignSeqTableModel |
| CAlignSeqTableModel::SRow | |
| CAlignShadow | |
| CAlignSmearGlyph | |
| CAlignSpanView | CAlignSpanView |
| CAlignSpanViewFactory | CAlignSpanViewFactory |
| oligofar::CAlignTest | |
| CAliPiece | |
| CAliToSeq_align | |
| CAllOtherFeaturesTrack | CAllOtherFeaturesTrack - a track container in the form of layout track |
| CAllOtherFeaturesTrackFactory | CAllOtherFeaturesTrackFactory |
| CAlnAsnReader | |
| CAlnBuildApp | |
| CAlnChunkSegment | CAlnChunkSegment - IAlnSegment implementation for CAlnMap::CAlnChunk |
| CAlnContainer | |
| CAlnError | |
| CAlnException | |
| CAlnGraphic | |
| CAlnGraphic::SAlignInfo | |
| CAlnIdMap< _TAlnVec, TAlnSeqIdExtract > | Vector of Seq-ids per Seq-align |
| CAlnMap | |
| CAlnMap::CAlnChunk | |
| CAlnMap::CAlnChunkVec | |
| CAlnMap::CNumSegWithOffset | |
| CAlnMapPrinter | |
| CAlnMix | |
| CAlnMixMatch | |
| CAlnMixMatches | |
| CAlnMixMerger | |
| CAlnMixSegment | |
| CAlnMixSegment::SSeqComp | |
| CAlnMixSegments | |
| CAlnMixSeq | |
| CAlnMixSequences | |
| CAlnMixSequences::SSeqIds | |
| CAlnMixStarts | |
| CAlnMrgApp | |
| CAlnMrgTaskProgressCallback | |
| CAlnMultiCGIApplication | |
| CAlnMultiCGIException | Number of gradient colors in alignment |
| CAlnMultiDSBuilder | |
| CAlnMultiHeader | CAlnMultiHeader |
| CAlnMultiHeader::CStyle | |
| CAlnMultiHeaderHandler | CAlnMultiHeaderHandler |
| CAlnMultiModel | Class CAlnMultiModel - represents a visual model of an alignment |
| CAlnMultiModel::SRowRecord | SRowRecord is a record representing a single alignment row |
| CAlnMultiModelFactory | CAlnMultiModelFactory - a factory to separate creation of the model from widget |
| CAlnMultiPane | Class CAlnMultiPane |
| CAlnMultiPane::CEvent | |
| 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 | |
| CAlnSeqIdsExtract< TAlnSeqId > | IAlnSeqId extracting functor |
| CAlnSpanSettingsDlg | |
| CAlnSpanVertModel | |
| CAlnSpanVertModel::SSpanRow | Alignment we store with its parsed data |
| CAlnSpanWidget | |
| CAlnStats< _TAlnIdVec > | |
| CAlnTableDS | |
| CAlnTableDS::SAlignment | Alignment we store with its parsed data |
| CAlnTableWidget | |
| CAlnTestApp | Types we use here: |
| CAlnUserOptions | |
| 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 |
| CAltSplice | |
| CAltValidator | |
| CAltValidator::SAgpLineInfo | |
| CAltValidator::SGiVerLenTaxid | |
| CAltValidator::SLineData | |
| CAmbigDataBuilder | Encode ambiguities in blast database format |
| CAmbiguiousTypes | |
| CAmbiguityContext | |
| CAmbiguousRegion | Ambiguous portion of a sequence |
| CAnalysisFile | |
| CAnalysisFile::less_icase | |
| CAnalysisFile::SDataRow | |
| CAnalysisFileLoader | |
| CAnalysisFileLoader::SValue | |
| CAnalyzer | CAnalyzer -- |
| CAnalyzer_Base | CAnalyzer_Base -- |
| CAnalyzer_Base::C_Attlist | C_Attlist -- |
| CAnalyzer_Base::C_E | A single component of the mass analyzer (e.g |
| CAnalyzerList | CAnalyzerList -- |
| CAnalyzerList_Base | Mass analyzer component list; ordered so as to reflect the physical order of the desribed components in the mass spectrometer |
| CAnalyzerList_Base::C_Attlist | C_Attlist -- |
| 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 | |
| CAnnotationASN1::CImplementationData | |
| CAnnotCompare | |
| CAnnotCompare_AlignDS | CAnnotCompare_AlignDS |
| CAnnotCompare_LocationDS | CAnnotCompare_LocationDS |
| CAnnotCompareDS | CAnnotCompareDS |
| CAnnotCompareDS::SRow | |
| CAnnotCompareFilterDlg | |
| CAnnotCompareView | CAnnotCompareView |
| CAnnotCompareViewFactory | CAnnotCompareViewFactory |
| CAnnotCompareWidget | CAnnotCompareWidget |
| CAnnotConfigDlg | |
| CAnnotConfigUtils | |
| CAnnotdesc | CAnnotdesc -- |
| CAnnotdesc_Base | CAnnotdesc_Base -- |
| CAnnotException | Annotation iterators exceptions |
| CAnnotMapperException | Seq-loc and seq-align mapper exceptions |
| CAnnotMapping_Info | |
| CAnnotMappingCollector | |
| CAnnotName | |
| CAnnotObject_Info | |
| CAnnotObject_Less | |
| CAnnotObject_LessReverse | |
| CAnnotObject_Ref | |
| CAnnotObject_SplitInfo | |
| CAnnotObjectType_Less | |
| CAnnotPieces | |
| CAnnotReadConfig | |
| CAnnotRecord | |
| CAnnotType_Index | |
| CAnnotTypes_CI | |
| CAnnotWriteConfig | |
| CAnnotWriteConfig::CAnnotConfigSettings | |
| CAnnotWriterApp | |
| CAntigenic | |
| CAnyContentDataType | |
| CAnyContentFunctions | |
| CAnyContentObject | Serializable object that stores any combination of parsable data |
| CAnyContentTypeStrings | |
| CAnyIntron | |
| CAnyIntron::CSIntronScore | |
| CAnyTypeChoice | |
| CAnyTypeClassInfo | |
| CAnyTypeSource | |
| CApad | CApad -- |
| CApad_Base | CApad_Base -- |
| CApad_Base::C_Attlist | C_Attlist -- |
| CApad_Base::C_E_Apad | C_E_Apad -- |
| CApp | |
| oligofar::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 | |
| CAppHitFilter::SBuildIDs | |
| 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 |
| CAppJobDispatcher::SJobRecord | SJobRecord describes a Job registered in Dispatcher |
| CAppJobDispatcher::SJobStateEvent | |
| CAppJobDispatcher::SQueueItem | SQueueItem - element of the Polling Queue |
| CAppJobError | CAppJobError Default implementation for IAppJobError - encapsulates a text error message |
| CAppJobEventTranslator | CAppJobEventTranslator Standard Listener that generates notification events |
| CAppJobException | CAppJobException - Exception thrown by Job Dispatcher and Job Engines |
| 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) |
| CAppJobRequest | CAppJobRequest CAppJobRequest serves as an adapter between IAppJob, CStdPoolOfThreads and CThreadPoolEngine |
| CAppJobTask | This class is NOT thread-safe and is designed to be used on the main UI thread only (what is consistent with Task Manager design) |
| CAppJobTestApplication | CAppJobTestApplication |
| CAppJobTextResult | CAppJobTextResult Default implementation for result object - encapsulates a text error message |
| 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 |
| CAppTaskService::CTaskRecord | |
| CAppTaskServiceEvent | CAppTaskServiceEvent |
| CAppTaskServiceException | CAppTaskServiceException |
| CAppTaskServiceSlot | CAppTaskServiceSlot - a Status Bar slot that displays information about tasks in Application Task Service |
| CArg_Boolean | |
| CArg_Double | |
| CArg_InputFile | |
| CArg_Int8 | |
| CArg_Integer | |
| 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 |
| CArgC | |
| CArgDesc | CArgDesc -- |
| CArgDesc_agp_validate | |
| CArgDesc_Alias | |
| CArgDesc_Flag | |
| CArgDesc_Key | |
| CArgDesc_KeyDef | |
| CArgDesc_KeyOpt | |
| CArgDesc_NameOnly | |
| CArgDesc_Pos | |
| CArgDesc_PosDef | |
| CArgDesc_PosOpt | |
| CArgDescDefault | |
| CArgDescMandatory | |
| CArgDescOptional | |
| CArgDescriptions | CArgDescriptions -- |
| CArgDescriptions::SArgDependency | |
| CArgDescSynopsis | |
| CArgErrorHandler | CArgErrorHandler -- |
| CArgException | CArgException -- |
| CArgHelpException | CArgHelpException -- |
| CArgs | CArgs -- |
| CArgumentsException | CArgumentsException -- |
| CArgValue | CArgValue -- |
| pythonpp::CArithmeticError | |
| 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 -- |
| CAsBodyDiagFactory | |
| CAscii85 | |
| CAsn2Asn | |
| CAsn2AsnThread | |
| CAsn2FastaApp | |
| CAsn2FlatApp | |
| CAsnBinaryDefs | |
| CAsnBlockEndItem | |
| CAsnConverter< TCpp, TC > | |
| CAsnElementBlockCollapsed | |
| CAsnElementBlockStart | |
| CAsnElementItem | |
| CAsnElementPrimitive | |
| CAsnExporter | |
| CAsnExporterFactory | |
| CAsnExportJob | CAsnExportJob |
| CAsnExportPage | |
| CAsnExportParams | |
| CASNFormatLoadManager | CASNFormatLoadManager |
| CAsnHeaderItem | |
| CAsnHeaderPrimitive | |
| CAsnLoadJob | CAsnLoadJob |
| CAsnRetrieveJob | |
| CAsnSizer | |
| CAsnStyles | |
| CAsnvalApp | |
| 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 -- |
| CAssay_Base::C_Attlist | C_Attlist -- |
| CAssay_Base::C_Method | C_Method -- |
| CAssay_Base::C_Method::C_EMethod | C_EMethod -- |
| CAssay_Base::C_Method::C_EMethod::C_Attlist | C_Attlist -- |
| CAssay_Base::C_Taxonomy | C_Taxonomy -- |
| CAssay_Base::C_Taxonomy::C_Attlist | C_Attlist -- |
| 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 |
| CAssembly_Base::C_Attlist | C_Attlist -- |
| CAssembly_Base::C_SnpStat | C_SnpStat -- |
| CAssembly_Base::C_SnpStat::C_Attlist | C_Attlist -- |
| pythonpp::CAssertionError | |
| 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 > | |
| pythonpp::CAttributeError | |
| CAttrRangeCollection< Attr, Position > | |
| CAttrRangeCollection< Attr, Position >::const_iterator | |
| CAttrRangeCollection< Attr, Position >::const_pos_iterator | |
| CAttrRangeCollection< Attr, Position >::element_proxy | |
| CAuth_list | .hpp User-defined methods of the data storage class |
| CAuth_list_Base | Authorship Group |
| CAuth_list_Base::C_Names | C_Names -- |
| CAuthor | - Author:
- .hpp User-defined methods of the data storage class
|
| CAuthor_Base | CAuthor_Base -- |
| CAutoCompleteCombo | CAutoCompleteComboBox |
| CAutoDef | |
| 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 | |
| CAutoDiagnosticsRedirector | |
| CAutoEnvironmentVariable | CAutoEnvironmentVariable -- |
| 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 |
| 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 | |
| CAuxiliaryManagedWrapperGeneratorToolDummyImpl | |
| CAVApp | |
| CAxisArea | Class CAxisArea |
| CAxisRenderer | Class CAxisRenderer |
| CAxisRenderer::SLabelDescr | |
| CBackgroundHost | |
| CBandAligner | |
| pythonpp::bind::CBase | |
| CBase64BinaryDataType | |
| CBaseClusterer | |
| impl::CBaseCmd | |
| CBaseCountItem | |
| CBaseNRCriteria | |
| CBaseTextOStream | |
| CBaseURL | CBaseURL -- |
| CBaseURL_Base | URL value from dbSNP_main.BaseURL links table |
| CBaseURL_Base::C_Attlist | C_Attlist -- |
| CBasicFastaWrapper | Concrete implementations of the CFastaIOWrapper virtual class |
| CBasicRelation | |
| CBasicRelation::SPropPair | |
| oligofar::CBatch | |
| 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_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 |
| CBDB_BlobSplitStore< TBV, TObjDeMux, TL >::SVolume | Volume split on optimal page size |
| 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_Cache::CacheKey | Cache accession for internal in-memory storage |
| 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_ExtBlobMap::SBlobChunkLoc | BLOB chunk location: offset in file + chunk size |
| CBDB_ExtBlobMap::SBlobLoc | Blob id + blob location table (list of chunks and sizes) |
| 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_MatrixBvStore< TBV, TM >::SMatrixDescr | Sparse matrix descriptor |
| 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_MergeBlobWalkerAsync< BF >::CAsync | IAsync implementation |
| CBDB_MergeBlobWalkerAsync< BF >::CJobThread | Background thread class (executes async requests) |
| CBDB_MergeStore< BStore > | Merge store saves result to BLOB store |
| CBDB_MergeStoreAsync< BStore > | Merge store saves result to BLOB store |
| CBDB_MergeStoreAsync< BStore >::CAsync | IAsync implementation |
| CBDB_MergeStoreAsync< BStore >::CJobThread | Background thread class (executes async requests) |
| 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_ResultStore< TBV > | Main result set storage parameterised by bit-vector implementation |
| CBDB_ResultStore< TBV >::CResultStoreEnumerator | Result set traverse iterator |
| CBDB_ResultStore< TBV >::TSubset | Subset loaded in memory, union fields correspond to format types |
| CBDB_ResultStoreBase | Query result store |
| CBDB_ResultStoreBase::TResultSetPosition | Structure encoding current position in the result set |
| CBDB_SplitCursor< BDB_SplitStore, BDB_Vol > | |
| CBDB_SplitCursor< BDB_SplitStore, BDB_Vol >::SVolumeLess | |
| 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 |
| CBedLoadJob | CBedLoadJob |
| CBedLoadManager | CBedLoadManager |
| CBedLoadParams | |
| CBedParamsPanel | |
| 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) |
| CBestI | |
| CBestIntron | |
| xml::impl::cbfo_node_compare | |
| CBigIntDataType | |
| CBigIntEnumDataType | |
| python::CBinary | |
| CBinaryDataArray | CBinaryDataArray -- |
| CBinaryDataArray_Base | The structure into which encoded binary data goes |
| CBinaryDataArray_Base::C_Attlist | C_Attlist -- |
| CBinaryDataArrayList | CBinaryDataArrayList -- |
| CBinaryDataArrayList_Base | List of binary data arrays |
| CBinaryDataArrayList_Base::C_Attlist | C_Attlist -- |
| CBinaryListBuilder | Binary GI or TI List Builder |
| CBinomialOrgName | CBinomialOrgName -- |
| CBinomialOrgName_Base | CBinomialOrgName_Base -- |
| CBinsDS | |
| CBinsDSType | |
| CBinsGlyph | |
| CBinsGlyph::accum_study | |
| CBinsGlyph::SBin | |
| CBinsGlyph::SBinMapped | |
| CBinsGlyph::SSnp | |
| CBinsJob | CBinsJob |
| CBinsJob::SParams | |
| CBinsTrack | |
| CBinsTrackFactory | |
| CBiomol_descr | CBiomol_descr -- |
| CBiomol_descr_Base | A biomolecule description refers to the chemical structure of a molecule or component substructures |
| 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_setUserType | |
| CBioseq_SplitInfo | |
| CBioseqContext | |
| CBioseqHandler | |
| CBioseqSeqInfoSrc | Implementation of the IBlastSeqInfoSrc interface to encapsulate retrieval of sequence identifiers and lengths from a CBioseq/CBioseq_set object |
| CBioseqUserType | |
| 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_Base::C_Location | C_Location -- |
| CBiostruc_feature_Base::C_Property | C_Property -- |
| 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_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_aligns_cdd_Base::C_Seq_align_data | C_Seq_align_data -- |
| 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 |
| CBiostruc_source_Base::C_Version_of_database | C_Version_of_database -- |
| CBioTree< TBioNode > | Basic tree structure for biological applications |
| CBioTree< TBioNode >::CAssignTreeFunc | Functor to reset tree pointer in all nodes |
| CBioTree< TBioNode >::CBioNode | |
| CBioTree< TBioNode >::CFindUidFunc | Find node by UID functor |
| CBioTreeContainer | |
| CBioTreeContainer_Base | CBioTreeContainer_Base -- |
| CBioTreeContainerHandler | CBioTreeContainer label handler |
| CBioTreeContainerUserType | |
| 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) |
| oligofar::CBitHacks | |
| oligofar::CBitmaskAccess | |
| oligofar::CBitmaskBase | |
| oligofar::CBitmaskBuilder | |
| CBitStringDataType | |
| CBitStringDataValue | |
| CBitStringFunctions | |
| CBitStringTypeStrings | |
| CBitVectorDecoder | |
| CBitVectorEncoder | |
| 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_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_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_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_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 | CBlast_db_mask_info_Base -- |
| 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 struct_name |
| CBlast_mask_list | CBlast_mask_list -- |
| CBlast_mask_list_Base | CBlast_mask_list_Base -- |
| CBlast_Message | Wrapper class for struct_name |
| CBLAST_SequenceBlk | Wrapper class for struct_name |
| 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 struct_name |
| CBlastDb_DataLoaderCF | Data Loader Factory for BlastDbDataLoader |
| CBlastDBAliasApp | The main application class |
| CBlastDbBlob | `Blob' Class for SeqDB (and WriteDB) |
| CBlastDbCheckApplication | CBlastDbCheckApplication: the main application class |
| CBlastDbCheckLog | |
| CBlastDBCmdApp | The application class |
| CBlastDbDataLoader | |
| CBlastDbDataLoader::SBlastDbParam | |
| 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 struct_name |
| CBlastEffectiveLengthsParameters | Wrapper class for struct_name |
| CBlastException | Defines BLAST error codes (user errors included) |
| CBlastExtendTestFixture | |
| CBlastExtensionOptions | Wrapper class for struct_name |
| CBlastExtensionParameters | Wrapper class for struct_name |
| 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 | This class contains misc functions for displaying BLAST results |
| CBlastGapAlignStruct | Wrapper class for struct_name |
| CBlastHitMatrix | This class displays the defline for BLAST result |
| 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 struct_name |
| CBlastHitSavingParameters | Wrapper class for struct_name |
| CBlastHSPListQueueData | Data structure for the queue implementation of BlastHSPStream |
| CBlastHSPResults | Wrapper class for struct_name |
| CBlastInitialWordOptions | Wrapper class for struct_name |
| CBlastInitialWordParameters | Wrapper class for struct_name |
| 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 struct_name |
| 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 |
| CBlastOptionsBuilder::SOptional< T > | Optional-value idiom |
| 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 |
| CBLASTParams::SProgInfo | Describes static attributes of a BLAST program |
| CBLASTParams::SProgParams | Describes parameters for a BLAST program |
| 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 struct_name |
| 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 struct_name |
| CBlastScorer | |
| CBlastScoringOptions | Wrapper class for struct_name |
| CBlastScoringParameters | Wrapper class for struct_name |
| CBLASTSearchOptionsPanel | |
| CBLASTSearchParamsPanel | |
| CBlastSearchQuery | Search Query |
| CBlastSearchTask | TODO |
| CBLASTSearchToolManager | CBLASTSearchToolManager |
| CBlastSeqLoc | Wrapper class for struct_name |
| CBlastSeqLocWrap | Wrapper for BlastSeqLoc structure |
| CBlastSeqSrc | Wrapper class for struct_name |
| CBlastSeqSrcIterator | Wrapper class for struct_name |
| CBLASTSeqToolJob | CBLASTSeqToolJob |
| CBLASTSeqToolManager | CBLASTSeqToolManager |
| 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 | |
| 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_File | CBlobStorage_File --- Implementaion of IBlobStorage interface based on files service |
| CBlobStorage_NetCache | CBlobStorage_NetCache --- Implementation of IBlobStorage interface based on NetCache service |
| CBlobStorage_Null | An Empty implemention of Blob Storage Interface |
| CBlobStorageException | Blob Storage Exception |
| CBlobStorageFactory | Blob Storage Factory interafce |
| CBlobStorageFactory_Null | Blob Storage Factory interafce |
| CBlobStorageFileCF | |
| CBlobStorageNetCacheCF | |
| CBlobStoreBase | |
| CBlobStoreDynamic | |
| CBlobStoreStatic | |
| CBlobStreamHelper | |
| CBlobWriter | |
| CBlockDataValue | |
| CBlockedAlignmentEditor | |
| CBlockedAlignmentEditor::BlockExtensionBound | |
| CBlockingQueue< TRequest > | CBlockingQueue<> -- queue of requests, with efficiently blocking Get() |
| 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< TRequest >::CQueueItem | |
| CBlockingQueue< TRequest >::SItemHandleGreater | |
| 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 | |
| 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 |
| pythonpp::CBool | |
| CBoolDataType | |
| CBoolGuard | |
| CBoundaryParams | IBoundaryParams |
| 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 | |
| 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 |
| CBufferedSockReaderWriter::CReadWriteTimeoutGuard | Special guard for setting and resetting value of read/write timeout on the socket |
| CBufferWriter< Buffer > | |
| 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 | |
| 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 |
| CBV_PoolBlockAlloc< BA, Lock >::CBlockFactory | |
| 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 -- |
| CByteSwap::UDoubleInt8 | |
| CByteSwap::UFloatInt4 | |
| 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 |
| CCache< TKey, TValue, THandler, TLock, TSize >::SValueWithIndex | |
| 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 | |
| impl::CCachedRowInfo::SInfo | |
| 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 |
| 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 | |
| CCalcNBPosOStream | |
| CCalcSizeCache | |
| CCalcSizeCache::SKey | |
| CCalcSizeCache::SKeyHash | |
| 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 |
| 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 | |
| CCdFromFasta | |
| CCdFromFasta::Fasta2CdParams | |
| 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 |
| CCdsConfig | |
| CCdsGlyph | |
| CCDSInfo | |
| CCDSProductPanel | |
| CCDSProteinPanel | |
| pythonpp::CCell | |
| CCgi2RCgiApp | |
| CCgiApplication | |
| CCgiApplicationCached | |
| CCgiArgs | CCgiArgs:: |
| CCgiArgs::SCgiArg | Name-value pair |
| CCgiArgs_Parser | CCgiArgs_Parser:: |
| CCgiArgsException | CCgiArgsException -- |
| CCgiArgsParserException | CCgiArgsParserException -- |
| CCgiContext | |
| CCgiCookie | CCgiCookie:: |
| CCgiCookie::PLessCPtr | |
| CCgiCookieException | CCgiCookieException -- |
| CCgiCookies | CCgiCookies:: |
| CCgiEntries_Parser | |
| CCgiEntry | |
| CCgiEntry::SData | |
| 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 | |
| CChainer::CChainerImpl | |
| CChainerArgUtil | |
| CChainMembers | |
| CChangeParams | |
| CChangePhyloTreeCommand | |
| CChangePhyloTreeCommand::SBTree | |
| CChangeSeqFeatCommand | |
| CChangeSeqFeatCommand::SFeature | |
| CChangeSeqFeatCommandFactory | |
| pythonpp::CChar | |
| CCharPtrFunctions< T > | |
| CChartElem | |
| CCharVectorFunctions< Char > | |
| CCharVectorFunctionsBase | |
| CCharVectorTypeInfo< Char > | |
| CChecksum | Checksum calculator |
| 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_pntrs | CChem_graph_pntrs -- |
| CChem_graph_pntrs_Base | Atom, residue or molecule motifs describe a substructure defined by a set of nodes from the chemical graph |
| CChiral_center | CChiral_center -- |
| CChiral_center_Base | Chiral centers are atoms with tetrahedral geometry |
| CChoiceDataType | |
| CChoicePointerTypeInfo | |
| CChoicePtrRefTypeStrings | |
| CChoicePtrTypeStrings | |
| CChoicePtrTypeStrings::SVariantInfo | |
| CChoiceRefTypeStrings | |
| CChoiceTypeInfo | |
| CChoiceTypeInfoFunctions | |
| CChoiceTypeStrings | |
| CChoiceTypeStrings::SVariantInfo | |
| CChromatogram | CChromatogram -- |
| CChromatogram_Base | A single chromatogram |
| CChromatogram_Base::C_Attlist | C_Attlist -- |
| CChromatogramList | CChromatogramList -- |
| CChromatogramList_Base | All chromatograms for thsi run |
| CChromatogramList_Base::C_Attlist | C_Attlist -- |
| CChymoP | EMSEnzymes_chymotrypsin_p chymotrypsin without proline rule |
| CChymotrypsin | |
| CCit_art | |
| CCit_art_Base | Citation Types article in journal or book |
| CCit_art_Base::C_From | 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 |
| CCitRetract | CCitRetract -- |
| CCitRetract_Base | CCitRetract_Base -- |
| CClassCode | |
| CClassContext | |
| CClassInfoHelper< C > | |
| CClassInfoHelperBase | |
| CClassPrePostReadWrite< Class > | |
| CClassRefTypeStrings | |
| CClassTypeInfo | |
| CClassTypeInfoBase | |
| CClassTypeInfoBase::CIterator | |
| CClassTypeStrings | |
| CClassTypeStrings::SMemberInfo | |
| CCleanup | |
| CCleanup_imp | |
| 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 | |
| CClipboard | |
| 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: |
| CClusterer | Interface for CClusterer class used for clustering any type of data based on distance matrix |
| CClusterer::CSingleCluster | Single cluster |
| 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 |
| 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 |
| CCode_break_Base::C_Aa | Amino acid |
| CCodeGenerator | |
| CCodingPropensity | |
| CCodingRegion | |
| CCoiledCoil | |
| oligofar::CColFileReader | |
| CColor_prop | CColor_prop -- |
| CColor_prop_Base | CColor_prop_Base -- |
| CColorPanel | |
| CColorPanel::SData | |
| 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 |
| CComboChart | Class CComboChart |
| CComboChartDataSource | Class CComboChartDataSource |
| impl::CCommand | |
| CCommandProcessor | |
| CCommandToFocusHandler | |
| CComment_rule | |
| CComment_rule_Base | CComment_rule_Base -- |
| CComment_set | |
| CComment_set_Base | CComment_set_Base -- |
| 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 -- |
| CCommonTaxonomicNameExtractor | Extracts the common taxonomy name for a given sequence id (CSeqFormatter associates this with L) |
| CCompactLayout | CCompactLayout is amed to generate more compact 2D layout policy than layered layout for glyphs with non-uniform height |
| 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 |
| CCompareSeq_locs::ResultCounts | |
| CCompareSeq_locs::SIntervalComparisonResult | |
| CCompareSeq_locs::SIntervalComparisonResultGroup | This helper struct is used to accumulate the neighboring comparisons of the same class, such that the comparison [ |
| CCompareSeqRegions | Compare multiple feature annotations on the specified seq_locs |
| CCompartApp | |
| CCompartApp::CCompartment | |
| CCompartmentAccessor< THit > | |
| CCompartmentFinder< THit > | |
| CCompartmentFinder< THit >::CCompartment | Individual compartment representation |
| CCompartmentFinder< THit >::SHitStatus | |
| CCompartOptions | |
| CCompatDiagHandler | |
| CCompatStreamDiagHandler | |
| CCompilerToolImpl | CCompilerToolImpl -- |
| pythonpp::CComplex | |
| oligofar::CComplexityMeasure | |
| CComplexRelation | |
| CComponent | CComponent -- |
| CComponent_Base | CComponent_Base -- |
| CComponent_Base::C_Attlist | C_Attlist -- |
| CComponentList | CComponentList -- |
| CComponentList_Base | CComponentList_Base -- |
| CComponentList_Base::C_Attlist | C_Attlist -- |
| CComponentList_Base::C_E_ComponentList | C_E_ComponentList -- |
| CComponentList_Base::C_E_ComponentList::C_SAD | List with the different components used in the mass spectrometer |
| 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 | |
| CCompSpans | |
| CCompVal | |
| CCone | CCone -- |
| CCone_Base | CCone_Base -- |
| CConfig | |
| CConfigException | CConfigException -- |
| CConfigMediator | |
| CConfiguration | CConfiguration -- |
| CConfiguration_Base | CConfiguration_Base -- |
| CConfiguration_Base::C_Attlist | C_Attlist -- |
| CConfigurationImpl< ConfTrait > | CConfigurationImpl -- |
| CConfigurations | CConfigurations -- |
| CConfigurations_Base | CConfigurations_Base -- |
| 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_FTPDownloadStream | CConn_FTPDownloadStream |
| CConn_HttpStream | This stream exchanges data with an HTTP server found by URL: http://host[:port]/path[?args] |
| CConn_IOStream | Base class, inherited from "std::iostream", does both input and output, using the specified CONNECTOR |
| CConn_MemoryStream | In-memory stream |
| CConn_NamedPipeStream | CConn_NamedPipeStream |
| CConn_PipeStream | CConn_PipeStream |
| CConn_ServiceStream | This stream exchanges the 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 | |
| CConnIniter | Helper hook-up class that installs default logging/registry/locking (but only if they have not yet been installed explicitly by user) |
| CConnValidatorCoR | CConnValidatorCoR |
| CConstBeginInfo | Class holding information about root of non-modifiable object hierarchy Do not use it directly |
| CConstContainerElementIterator | |
| CConstIRef< Interface, Locker > | |
| CConstObjectInfo | Facilitate read access to a particular instance of an object of the specified type |
| CConstObjectInfoCV | Choice variant iterator |
| CConstObjectInfoEI | Container iterator |
| CConstObjectInfoMI | Class member iterator |
| CConstRef< C, Locker > | CConstRef -- |
| CConstRefTypeInfo< Data > | |
| CConstResizingIterator< TSeq, TOut > | |
| CConstSageData | |
| CConstTreeLevelIterator | Class describing stack level of traversal do not use it directly |
| CConstTreeLevelIteratorMany< ChildIterator > | |
| CConstTreeLevelIteratorOne | |
| CContact | CContact -- |
| CContact_Base | Audit information concerning the means by which the originator/owner of this mzData file can be identified, and contacted if necessary |
| CContact_info | CContact_info -- |
| CContact_info_Base | Who to contact to discuss the submission |
| CContainerElementIterator | |
| CContainerTypeInfo | |
| CContainerTypeInfo::CConstIterator | |
| CContainerTypeInfo::CIterator | |
| CContainerTypeInfoFunctions | |
| CContElemConverter< TElem > | Template<typename TElem> CContElemConverter |
| CContElemConverter< CCgiEntry > | Template<> CContElemConverter<CCgiEntry> |
| CContElemConverter< objects::CSeq_id_Handle > | |
| CContElemConverter< string > | Template<> CContElemConverter<string> |
| CContentAdvClickAct | CContentAdvClickAct What to do when someone clicks on the advanced/detailed button for Content of the graphics view |
| CContentCheckDialog | |
| 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 |
| CContigAssembly::CAlnStats | |
| CContigAssembly::SAlignStats | Alignment characterization |
| CContigAssembly::SAlignStats::STails | |
| CContigItem | |
| CConversionApp | |
| CConversionRef_Less | |
| CConversionResultPanel | |
| CConvert2BlastMaskApplication | |
| CConvertCache | |
| CConvertCache::SCacheKey | |
| CConvertCache::SCacheKeySort | |
| 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 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 | |
| CCoordinates | CCoordinates -- |
| CCoordinates_Base | Literal coordinates map chemical components into the model space |
| CCoordMapper_SeqLocMapper | CCoordMapper_SeqLocMapper coordinate mapper based on CSeq_Loc_Mapper |
| 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 | |
| CCountryBlock | |
| CCountryLatLonMap | |
| CCpGDemoApp | |
| CCpGIslands | |
| CCpgSearchForm | |
| CCpgSearchJob | CCpgSearchJob |
| CCpgSearchQuery | CCpgSearchTool |
| CCpgSearchTableModel | |
| CCpgSearchTool | CCpgSearchTool |
| CCPPToolkitConnParams | |
| CCreatedFeat_Ref | |
| CCreateFeat | |
| CCreateGeneModelJob | CCreateGeneModelJob |
| CCreateGeneModelParamsPanel | |
| CCreateGeneModelToolManager | CCreateGeneModelToolManager |
| CCreateNeedlemanWunschJob | CCreateNeedlemanWunschJob |
| CCreateNeedlemanWunschToolManager | CCreateNeedlemanWunschToolManager |
| 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 | |
| CCurveBezier | |
| CCurveCubic | |
| CCustomBuildToolDummyImpl | |
| CCustomErrorHandler | |
| CCustomizedFastaReader | CFastaReader-derived class which contains customizations for processing BLAST sequence input |
| CCv | CCv -- |
| CCv_Base | Information about an ontology or CV source and a short 'lookup' tag to refer to |
| CCv_Base::C_Attlist | C_Attlist -- |
| CCvList | CCvList -- |
| CCvList_Base | Container for one or more controlled vocabulary definitions |
| CCvList_Base::C_Attlist | C_Attlist -- |
| CCvLookup | CCvLookup -- |
| CCvLookup_Base | This stores the location, name, version and a short, arbitrarily assigned in-file reference label, for one or more controlled vocabulary sources |
| CCvLookup_Base::C_Attlist | C_Attlist -- |
| CCvParam | CCvParam -- |
| CCvParam_Base | This element holds additional data or annotation |
| CCvParam_Base::C_Attlist | C_Attlist -- |
| CCvParam_Base::C_Attlist | C_Attlist -- |
| oligofar::CCvtQryNcbi8naBisulfite< mask, Shift > | |
| oligofar::CCvtQryNcbi8naEquiv | |
| oligofar::CCvtQryNcbipnaBisulfite< from, to > | |
| oligofar::CCvtQryNcbipnaEquiv | |
| oligofar::CCvtSubjNcbi8naFwd | |
| oligofar::CCvtSubjNcbi8naRev | |
| CCyclicDepends | CCyclicDepends -- |
| CCylinder | CCylinder -- |
| CCylinder_Base | CCylinder_Base -- |
| CData | CData -- |
| CData_Base | Name of the supplemental data array |
| CData_Base::C_Attlist | C_Attlist -- |
| CData_set_id | CData_set_id -- |
| CData_set_id_Base | CData_set_id_Base -- |
| CData_set_id_Base::C_Data_set_id_type | C_Data_set_id_type -- |
| CData_set_id_Base::C_Data_set_id_type::C_Attlist | C_Attlist -- |
| CData_set_id_Base::C_Data_set_id_uids | C_Data_set_id_uids -- |
| CData_set_id_Base::C_Data_set_id_uids::C_E_EData_set_id_uids | C_E_EData_set_id_uids -- |
| CData_set_id_type | CData_set_id_type -- |
| CData_set_id_type_Base | CData_set_id_type_Base -- |
| CData_set_id_type_Base::C_Attlist | C_Attlist -- |
| CData_set_id_uids | CData_set_id_uids -- |
| CData_set_id_uids_Base | CData_set_id_uids_Base -- |
| python::CDatabaseError | |
| CDatabaseError | |
| CDataChangeNotifier | Data notification relay class, sends data change notifications to the subscribed listener |
| CDataChangeNotifier::CUpdate | CUpdate - notification send by CUIDataSource to the listener |
| CDataChangeNotifier::IListener | CDataChangeNotifier listener receiving notification about changes in data(source) |
| CDataContainerType | |
| python::CDataError | |
| CDatagramSocket | CDatagramSocket:: |
| CDataHandle | |
| CDataHandle_Base | CDataHandle_Base -- |
| CDataHandleAction | |
| CDataHandleAction_Base | CDataHandleAction_Base -- |
| CDataHandleAction_Base::C_Action | C_Action -- |
| CDataHandleSelector | |
| CDataHandleSelector_Base | CDataHandleSelector_Base -- |
| CDataHandleTransformer | |
| CDataHandleTransformer_Base | CDataHandleTransformer_Base -- |
| CDataHandleViewer | |
| CDataHandleViewer_Base | CDataHandleViewer_Base -- |
| CDataItemValidator | |
| CDataLoader | |
| CDataLoaderFactory | |
| CDataLoaderPatcher | |
| CDataLoaderPatcher::SParam | |
| CDataLoadingAppJob | CDataLoadingAppJob - a base class for Jobs loading data into projects |
| CDataLoadingAppTask | CDataLoadingAppTask - a task that executes CDataLoadingAppJob |
| CDataLoadingOptions | CDataLoadingOptions - describes how new Project Items shall be addeed to a workspace |
| CDataMember | |
| CDataMemberContainerType | |
| CDataMiningPanel | CDataMiningPanel |
| CDataMiningService | CDataMiningService |
| CDataMiningView | CDataMiningView |
| CDataMiningViewFactory | CDataMiningViewFactory |
| CDataProcessing | CDataProcessing -- |
| CDataProcessing_Base | Description of the default processing by which the peak list(s) were generated |
| CDataProcessing_Base::C_Attlist | C_Attlist -- |
| CDataProcessingList | CDataProcessingList -- |
| CDataProcessingList_Base | List and descriptions of data processing applied to this data |
| CDataProcessingList_Base::C_Attlist | C_Attlist -- |
| CDataSequenceType | |
| CDataSetType | |
| CDataSource | |
| CDataSource_ScopeInfo | |
| CDataSourcesOptionsDlgExtension | |
| CDataSourcesPage | |
| CDataStore | |
| CDataTool | |
| CDatatoolException | |
| CDataToolGeneratedSrc | |
| CDataTrack | CDataTrack - a abstract base class for layout tracks which need to deal with background data retrieval |
| CDataType | |
| CDataTypeModule | |
| CDataTypeModule::Import | |
| 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 | |
| CDateTypeConverter | |
| 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 | |
| impl::CDB_Params::SParam | |
| 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 | |
| CDbapiClosedEvent | |
| CDbapiConnMgr | CDbapiConnMgr |
| CDbapiCtlibCF_Sybase | |
| CDbapiCtlibCFBase | |
| CDbapiCursorApp | |
| CDbapiDblibCF2 | |
| CDbapiDeletedEvent | |
| CDbapiDriverSampleApp | |
| CDbapiEvent | |
| CDbapiException | |
| CDbapiFetchCompletedEvent | |
| python::CDBAPIModule | |
| CDbapiMySqlCF2 | |
| CDbapiNewResultEvent | |
| CDbapiOdbcCF | |
| CDbapiOdbcCFBase | |
| CDbapiQueryApp | |
| CDbapiSampleApp | |
| CDbapiSampleErrHandler | |
| CDbapiSendDataApp | |
| CDbapiTest | |
| CDbapiTestSpeedApp | |
| impl::CDBBindedParams | |
| CDBConnectionFactory | |
| CDBConnectionFactory::CMapperFactory | |
| CDBConnectionFactory::CRuntimeData | |
| CDBConnParams | CDBConnParams:: |
| impl::CDBConnParamsBase | Impl::CDBConnParamsBase:: |
| CDBConnParamsBase | CDBConnParamsBase:: |
| CDBConnParamsDelegate | |
| CDbCopyApp | |
| CDBDefaultConnParams | CDBDefaultConnParams:: |
| CDBDefaultServiceMapper | CDBDefaultServiceMapper |
| CDBEnvConnParams | |
| impl::CDBExceptionStorage | |
| CDBGiveUpFactory | Helper class This policy will give up without trying to connect to alternative db servers |
| impl::CDBHandlerStack | |
| impl::CDBHandlerStack::CUserHandlerWrapper | |
| impl::CDBHandlerStack::CUserHandlerWrapper::CObjGuard | CObjGuard is not the same as CRef |
| CDbIndex | Base class providing high level interface to index objects |
| CDbIndex::CSearchResults | This class represents a set of seeds obtained by searching all subjects represented by the index |
| CDbIndex::SOffsetValue | |
| CDbIndex::SOptions | Simple record type used to specify index creation parameters |
| CDbIndex::SSearchOptions | Simple record type used to specify index search parameters |
| 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 | |
| CDBInterfacesFileConnParams::SIRecord | |
| 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 | |
| CDbList | CDbList -- |
| CDBParams | CDBParams |
| CDBParamVariant | |
| CDBRedispatchFactory | Helper class This policy will redispatch every time after a successful dispatch |
| 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 |
| CDbtagTypeConverter | |
| CDbTest | |
| CDBUDPriorityMapper | CDBUDPriorityMapper |
| CDBUDRandomMapper | CDBUDRandomMapper |
| CDBUniversalMapper | |
| CDBUriConnParams | |
| CDDAnnotateDialog | |
| CDDBookRefDialog | |
| CDDEvidenceDialog | |
| CDDRefDialog | |
| CDDSplashDialog | |
| CDDV_DDX_Exception | CDDV_DDX_Exception |
| CDebugArgs | Argument class to collect debugging options |
| CDebugDumpable | |
| CDebugDumpContext | |
| CDebugDumpFormatter | |
| CDebugDumpFormatterText | |
| CDebugDumpViewer | |
| CDefaultConnectPolicy | |
| CDefaultDriverVersion< TInterface > | |
| CDefaultEditor | |
| CDefaultIdler | Default idler |
| CDefaultLengthGetter | |
| CDefaultNodeKeyGetter< TValue > | Default key getter for CTreeNode |
| CDefaultSynonymMapper | |
| CDefaultTypeConverter | |
| 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 |
| CDelayBuffer::SInfo | |
| 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_seq | CDelta_seq -- |
| CDelta_seq_Base | CDelta_seq_Base -- |
| 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 | |
| CDemoControlsClient | |
| CDemoeApp | |
| CDemoFeatTableApp | /////////////////////////////////////////////////////////////////////////// Derive our application class from CwxNCBIApp and use it together with standard CNCBIwxApplication |
| CDemoHandler_EmptyOnOverflow | |
| CDemoHandler_HeapAlloc | |
| CDemoHandler_MemSize | |
| 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 |
| 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 -- |
| CDesc_EditCommand< TEditHandle, add > | |
| pythonpp::CDescr | |
| CDescription | CDescription -- |
| CDescription_Base | Each data set starts with a description section |
| CDescriptionText | CDescriptionText -- |
| CDescriptionText_Base | CDescriptionText_Base -- |
| CDetector | CDetector -- |
| CDetector_Base | CDetector_Base -- |
| CDetector_Base::C_Attlist | C_Attlist -- |
| CDetector_Base::C_E | Ion detector information, as a run of name-value pairs |
| 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 |
| CDiagConsoleCache::CItem | |
| 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 -- |
| CDiagFactory | CDiagFactory -- |
| CDiagFilter | CDiagFilter -- |
| CDiagHandler | CDiagHandler -- |
| CDiagHit | |
| CDiagHitElement | CDiagHitElement - IHitElement implementation for CDense_seg-based alignments |
| CDiagLexParser | CDiagLexParser -- |
| CDiagMatcher | CDiagMatcher -- |
| CDiagRangeCollection | |
| CDiagRangeCollection::PItLess | |
| 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 -- |
| CDirEntry::SStat | Alternate stat structure for use instead of the standard struct stat |
| 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 | |
| CDisplaySeqalign::FeatureInfo | Structure for store feature display info |
| CDisplaySeqalign::SAlnFeatureInfo | Store feature information |
| CDisplaySeqalign::SAlnInfo | Store alnvec and score info |
| CDisplaySeqalign::SAlnSeqlocInfo | Store seqloc info |
| CDisplaySeqalign::SInsertInformation | Internal insert information aln_start |
| CDistanceMatrix | |
| CDistanceMatrix_Base | CDistanceMatrix_Base -- |
| CDistanceMatrixHandler | CDistanceMatrix label handler |
| CDistanceMatrixUserType | |
| CDistances | Representation of pairwise distances, intended for use in multiple sequence alignment applications |
| CDistBasedClusterer | |
| CDistMethods | |
| CDll | CDll -- |
| CDll::TEntryPoint | Entry point -- pointer to either a function or a data |
| CDllResolver | Class for entry point resolution when there are several DLL candidates |
| CDllResolver::SNamedEntryPoint | DLL entry point name -> function pair |
| CDllResolver::SResolvedEntry | DLL resolution descriptor |
| 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 |
| CDockLayoutTree::CNode | CNode - a node in layout tree corresponding to a window |
| CDockManager | CDockManager CDockManager sends requests to Window Manager, Window Manager makes decisions about deleting clients and calls Dock Manager functions |
| CDockManager::CDeadFrameDescr | |
| 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 | |
| CdPssmInput | |
| CDrawTextOStream | |
| CDRefresher | |
| impl::CDriverContext | CDriverContext:: |
| CDriverManager | |
| CDSAnnotLockReadGuard | |
| CDSAnnotLockWriteGuard | |
| CdTreeStream | |
| CDummyGlyph | Dummy concreate glyph class for layout purpose |
| CDummyLayoutObject | |
| CDummyLengthGetter | |
| CDummySynonymMapper | |
| CDummyTrack | A dummy layout track for showing an empty area |
| CDumpSysInfo | |
| CdUpdateParameters | |
| CDUpdater | |
| CDUpdateStats | |
| CDustMaskApplication | |
| CDynamicCharArray | |
| CE2Reply | CE2Reply -- |
| CE2Reply_Base | CE2Reply_Base -- |
| CE2Request | CE2Request -- |
| CE2Request_Base | Request types |
| CEaaToIupacaa | |
| CEaaToStdaa | |
| CEditAppJob | CEditAppJob - a base class for Jobs modifying existing data in projects |
| CEditAppTask | CDataLoadingAppTask - a task that executes CDataLoadingAppJob |
| CEditBioseqSampleApp | |
| CEditCommand | |
| CEditEvent | Class CEditEvent defines a single type for all editing events |
| CEditException | |
| CEditObjectDlg | |
| CEditPanelEntry | |
| CEditResFile | |
| CEditScript | Interface for the traceback from blast hits |
| CEditScript::STracebackOp | Runlength-encoded representation of a traceback operation |
| 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 -- |
| CElementaryMatching | |
| CElementaryMatching::CBoolVector | |
| CElementaryMatching::SHitIndexEntry | |
| CElementaryMatching::SSeqInfo | |
| CELink_Request | CELink_Request |
| CELinkResult | CELinkResult -- |
| CELinkResult_Base | CELinkResult_Base -- |
| Cell | |
| CEmailDiagFactory | |
| CEmailDiagHandler | |
| 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 |
| 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_docsumUserType | |
| 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 -- |
| CEntrez_general_Base::C_Data | C_Data -- |
| CEntrezCache | Class CEntrezCache provides a simple, thread-safe interface for storing the temporary results of queries to Entrez using CEntrez2Client |
| CEntrezCache::SKey | Key for Entrez objects is the namespace (=database) and the UID |
| CEntrezCache::SKeyHash | |
| 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 |
| CEntrezgeneUserType | |
| CEntrezSearchForm | CTestSearchForm |
| CEntrezSearchJob | CEntrezSearchJob |
| CEntrezSearchQuery | CEntrezSearchTool |
| CEntrezSearchTool | CEntrezSearchTool |
| CEnumDataType | |
| CEnumDataType::SEnumCInfo | |
| CEnumDataTypeValue | |
| CEnumeratedTypeInfo | |
| CEnumeratedTypeValues | |
| CEnumParser< TEnum > | |
| CEnumRefTypeStrings | |
| CEnumTypeStrings | |
| pythonpp::CEnvironmentError | |
| CEnvironmentRegistry | CEnvironmentRegistry -- |
| 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 -- |
| CEPostResult_Base::C_History | C_History -- |
| CEResidueVec | |
| CErrHandler | |
| CErrnoAdapt | |
| CErrnoTemplException< TBase > | CErrnoTemplException -- |
| CErrnoTemplExceptionEx< TBase, PErrCode, PErrStr > | CErrnoTemplExceptionEx -- |
| python::CError | |
| pythonpp::CError | |
| CErrorContainerBase | |
| CErrorContainerCount | |
| CErrorContainerCustom | |
| CErrorContainerLenient | |
| CErrorContainerLevel | |
| CErrorContainerStrict | |
| CErrorList | CErrorList -- |
| pythonpp::CErrorStackElem | |
| CESearch_Request | CESearch_Request |
| CESearchResult | CESearchResult -- |
| CESearchResult_Base | CESearchResult_Base -- |
| CESearchResult_Base::C_Data | C_Data -- |
| CESearchResult_Base::C_Data::C_Info | Response tags |
| CESearchResult_Base::C_Data::C_Info::C_Content | C_Content -- |
| CESpell_Request | CESpell_Request |
| CESpellResult | CESpellResult -- |
| CESpellResult_Base | CESpellResult_Base -- |
| CESummary_Request | CESummary_Request |
| CESummaryResult | CESummaryResult -- |
| CESummaryResult_Base | CESummaryResult_Base -- |
| CESummaryResult_Base::C_Data | C_Data -- |
| CEUtils_ConnContext | CEUtils_ConnContext |
| CEUtils_IdGroup | CEUtils_IdGroup |
| CEUtils_IdGroupSet | CEUtils_IdGroupSet |
| CEUtils_Request | CEUtils_Request |
| CEUtilsApp | |
| CEvent | CEvent - generic event implementation TODO TODO - Attachments |
| CEventAttachmentFor< T > | Templatized IEventAttachment wrapper |
| CEventHandler | CEventHandler |
| CEventHandler::CPostQueue | CPostQueue - singleton queue for asynchronous events all methods are synchronized |
| CEventHandler::SPostRequest | |
| 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 |
| CException | CException -- |
| CExceptionReporter | CExceptionReporter -- |
| CExceptionReporterStream | CExceptionReporterStream -- |
| CExceptionWrapper | |
| CExchangeSet | CExchangeSet -- |
| CExchangeSet_Base | Set of dbSNP refSNP docsums |
| CExchangeSet_Base::C_Attlist | C_Attlist -- |
| CExchangeSet_Base::C_Query | C_Query -- |
| CExchangeSet_Base::C_Query::C_Attlist | C_Attlist -- |
| CExchangeSet_Base::C_SourceDatabase | C_SourceDatabase -- |
| CExchangeSet_Base::C_SourceDatabase::C_Attlist | C_Attlist -- |
| CExchangeSet_Base::C_Summary | C_Summary -- |
| CExchangeSet_Base::C_Summary::C_Attlist | C_Attlist -- |
| CExec | CExec -- |
| CExec::CResult | The result type for Spawn methods |
| CExecException | CExecException -- |
| CExecute | |
| CExitThreadException | |
| CExon | |
| CExon_params | CExon_params -- |
| CExon_params_Base | CExon_params_Base -- |
| CExonParameters | |
| CExpandGlyph | |
| CExpandItem | |
| CExpectedError | |
| 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 |
| CExprParser | |
| CExprParserException | |
| CExprSymbol | |
| CExprValue | |
| CExtensionDeclaration | CExtensionDeclaration - static declaration helper |
| CExtensionPoint | CExtensionPoint - standard implementation of IExtensionPoint |
| CExtensionPointDeclaration | CExtensionPointDeclaration - static declaration helper |
| CExtensionRegistry | CExtensionRegistry - standard implementation of IExtensionRegistry |
| CExternalLayoutTrack | CExternalLayoutTrack -- the layout track for holding and visualizing the external graphical views' visible ranges |
| CExternalLayoutTrackFactory | CExternalLayoutTrackFactory |
| pythonpp::CExtModule< T > | |
| pythonpp::CExtModule< T >::CClass< N > | |
| pythonpp::CExtModule< T >::SFunct | Workaround for GCC 2.95 |
| pythonpp::CExtObject< T > | |
| pythonpp::CExtObject< T >::CClass< N > | |
| pythonpp::CExtObject< T >::SFunct | Workaround for GCC 2.95 |
| CExtraDecoder | |
| CExtraEncoder | |
| CExtraFeaturePanel | |
| CExtraFeaturePanel::wxExtraFeatItemData | |
| pythonpp::CExtType | |
| CFactory< T > | |
| oligofar::CFaDiceApp | |
| CFastaAlignmentBuilder | Helper class to build pairwise alignments, with double gaps automatically spliced out |
| CFastaBioseqSource | |
| CFastaExporter | |
| CFastaExporterFactory | |
| CFastaExportJob | CFastaExportJob |
| CFastaExportPage | |
| CFastaExportParams | |
| CFastaExtractor | Extracts the FASTA for a given sequence id (CSeqFormatter associates this with f) |
| CFastaFileSet | |
| CFASTAFormatLoadManager | CFASTAFormatLoadManager |
| CFASTAFormatParamsPanel | CFASTAFormatParamsPanel |
| CFastaIOWrapper | |
| CFastaLoadJob | CFastaLoadJob |
| CFastaLoadParams | |
| CFastaMapper | |
| CFastaOstream | FASTA-format output; see also ReadFasta in <objtools/readers/fasta.hpp> |
| CFastaProcess | |
| CFastaReader | Base class for reading FASTA sequences |
| CFastaReader::SGap | |
| CFastaRetrieveJob | |
| CFastaSeqBlockItem | |
| CFastaSeqHdrItem | |
| CFastaTextDisplay | |
| CFastaTextDS | |
| CFastaTitleItem | |
| CFastIScore | |
| CFastLocalTime | CFastLocalTime -- |
| CFastMutex | CFastMutex -- |
| oligofar::CFastqFileReader | |
| CFastRWLock | CFastRWLock -- |
| CFatalRequest | |
| CFeat_CI | CFeat_CI -- |
| CFeat_id | CFeat_id -- |
| CFeat_id_Base | Feature identifiers ******************************** |
| 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 > | Template for configured values, indexed by feature type and subtype where values can inherit from master feature types |
| CFeatConfigValues< V >::CFeatConfigValue | |
| 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 -- |
| CFeatFindContext | |
| CFeatGlyph | Class for storing a set of nested features |
| CFeatHeaderItem | |
| CFeatHistogramDS | CFeatHistogramDS |
| CFeatIdRemapper | |
| CFeatList | CConfigurableItems - a static list of items that can be configured |
| CFeatListItem | CFeatListItem - basic configuration data for one "feature" type |
| oligofar::CFeatMap | |
| CFeatRetrievalResult | AppJobs for background loading and preparation |
| CFeatRetrieveJob | Alignment-based data source |
| CFeatShowExtraItem | |
| CFeatShowPanel | |
| CFeatTableDS | CFeatTableDS Data source for Feature Table widget |
| CFeatTableDS::SFeature | Our actual features |
| CFeatTableView | CFeatTableView |
| CFeatTableViewFactory | CFeatTableViewFactory |
| CFeatTableWidget | CFeatTableWidget |
| CFeatTree | |
| CFeatTree::CFeatInfo | |
| CFeatTree::SFeatSet | |
| CFeature_evidence | CFeature_evidence -- |
| CFeature_evidence_Base | CFeature_evidence_Base -- |
| CFeature_table_reader | |
| CFeature_table_reader_imp | |
| CFeatureCheckDialog | |
| CFeatureCheckPanel | |
| CFeatureCheckPanel::wxFeatItemData | |
| 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 -- |
| CFeatureEditor | |
| CFeatureGatherer | |
| CFeatureGraph | CFeatureGraph |
| CFeatureGraphProperties | CFeatureGraphProperties |
| CFeatureItem | |
| CFeatureItemBase | |
| CFeatureLoadingJob | CFeatureLoadingJob |
| CFeatureLoadingJobResult | CFeatureLoadingJobResult |
| CFeaturePanel | |
| CFeaturePanelDS | CFeaturePanelDS |
| CFeaturePanelDSType | CFeaturePanelDSType |
| CFeatureParams | CFeatureParams: the data structure holding feature rendering parameters |
| CFeatureSearchForm | |
| CFeatureSearchJob | CFeatureSearchJob |
| CFeatureSearchQuery | CFeatureSearchTool |
| CFeatureSearchTool | CFeatureSearchTool |
| CFeaturesGroup | |
| CFeatureTrack | CFeatureTrack -- |
| CFeatureTrackFactory | CFeatureTrackFactory |
| CFeatureTypesBrowser | CFeatureTypesBrowser Display a list of feature type-subtype pairs and allows to select them |
| CFeatureTypesDlg | |
| CFeatureTypesParser | CFeatureTypesParser |
| CFeedbackReport | Class CFeedbackReport serves as a data model for all pages and coordinates the submission of a report |
| CFeedbackTextArrayPrinter | |
| CFeedbackWizard | |
| CFetchURL | |
| CFFile | CFFile -- |
| CFFile_Base | CFFile_Base -- |
| CFFile_Base::C_Attlist | C_Attlist -- |
| CField | CField -- |
| CField_rule | |
| CField_rule_Base | CField_rule_Base -- |
| CField_set | CField_set -- |
| CField_set_Base | CField_set_Base -- |
| CFieldList | CFieldList -- |
| CFieldList_Base | CFieldList_Base -- |
| pythonpp::CFile | |
| CFile | CFile -- |
| CFileAPI | Global settings related to the file API |
| CFileAutoLoader | CFileAutoLoader |
| CFileByteSource | |
| CFileByteSourceReader | |
| CFileCode | |
| CFileCode::SClassInfo | |
| CFileConfiguration | CFileConfiguration -- |
| CFileConfiguration_Base | CFileConfiguration_Base -- |
| CFileConfiguration_Base::C_Attlist | C_Attlist -- |
| CFileContent | CFileContent -- |
| CFileContent_Base | This summarizes the different types of spectra that can be expected in the file |
| CFileDBEngine | |
| CFileDeleteAtExit | CFileDeleteAtExit -- |
| CFileDeleteList | CFileDeleteList -- |
| CFileDescription | CFileDescription -- |
| CFileDescription_Base | Information pertaining to the entire mzML file (i.e |
| CFileDiagHandler | |
| CFileErrnoException | |
| CFileException | CFileException -- |
| CFileHandleDiagHandler | CFileHandleDiagHandler -- |
| CFileIO | Class for suppport 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 | |
| CFileLoadOptionPanel::CFormatDescriptor | |
| 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 -- |
| CFileUtil::SFileSystemInfo | Structure to store information about file system |
| CFileWriter | |
| CFilter | CFilter -- |
| oligofar::CFilter | |
| CFilter2 | |
| CFilter_Base | CFilter_Base -- |
| CFilter_Base::C_Attlist | C_Attlist -- |
| CFilter_Base::C_FF | C_FF -- |
| CFilter_Base::C_FF::C_E_FF | C_E_FF -- |
| CFilterDefault< T > | |
| CFilterDialog | |
| CFilteringArgs | Argument class for collecting filtering options |
| 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 > | |
| 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 |
| CFIntornData | |
| CFIntron | |
| CFIntronDon | |
| CFirstExon | |
| CFixMsHdf5Application | |
| 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 | |
| CFlatGapLoc | |
| CFlatGatherer | |
| CFlatGeneQVal | |
| CFlatGeneSynonymsQVal | |
| CFlatGoQVal | |
| CFlatIllegalQVal | |
| CFlatInferenceQVal | |
| CFlatIntQVal | |
| CFlatItem | |
| CFlatItemFormatter | |
| CFlatItemOStream | |
| CFlatLabelQVal | |
| CFlatModelEvQVal | |
| CFlatMolTypeQVal | |
| CFlatNumberQVal | |
| CFlatOrganelleQVal | |
| CFlatOrgModQVal | |
| CFlatProductNamesQVal | |
| CFlatPubSetQVal | |
| CFlatSeqIdQVal | |
| CFlatSeqLoc | |
| CFlatSeqLocQVal | |
| CFlatSiteQVal | |
| CFlatStringListQVal | |
| CFlatStringQVal | |
| CFlatSubSourcePrimer | |
| CFlatSubSourceQVal | |
| CFlatTrnaCodonsQVal | |
| CFlatXrefQVal | |
| CFlCurrentGuard | CFlCurrentGuard locks and restores Fl_Group::current() |
| pythonpp::CFloat | |
| CFloatingFrame | |
| pythonpp::CFloatingPointError | |
| CFloatTextValidator | |
| CFltkCursorGuard | Class CFltkCursorGuard implements a guard paradigm for changing and restoring the current cursor |
| CFltkGuard | Class CFltkGuard is a simple exception-safe guard wrapper for FLTK's GUI locking mechanism |
| CFltkUtils | |
| CFolderEditDlg | |
| CFolderInfo | |
| CFolderInfo_Base | CFolderInfo_Base -- |
| CFolderNameValidator< TFolder > | |
| CFontConfig | Configuration class for types of layouts |
| CFontDemoApp | |
| CFontDemoPanel | |
| CFontDemoUI | |
| CFontWindow | |
| CFormArgDesc | |
| CFormatGuess | Class implements different ad-hoc unreliable file format identifications |
| CFormatGuess::CFormatHints | Hints for guessing formats |
| CFormatGuessApp | |
| 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 |
| CFormattingArgs | Argument class to collect formatting options, use this to create a CBlastFormat object |
| CFormicAcid | |
| 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 | |
| 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 |
| CFxnSet_Base::C_Attlist | C_Attlist -- |
| CGapItem | |
| CGapJob | CGapJob |
| CGapJob::SParams | |
| CGappedArgs | Argument class for collecting gapped options |
| CGapTrack | |
| CGapTrackFactory | |
| CGapTriggerArgs | Argument class to retrieve the gap trigger option |
| CGB_block | |
| CGB_block_Base | GenBank specific descriptions |
| CGB_DataLoaderCF | |
| CGb_qual | .hpp User-defined methods of the data storage class |
| CGb_qual_Base | CGb_qual_Base -- |
| CGB_Writer_PluginManager_DllResolver | |
| CGBankLoadingJob | |
| CGBAuthor | CGBAuthor -- |
| CGBAuthor_Base | CGBAuthor_Base -- |
| CGBDataLoader | |
| CGBDocument | CGBDocument |
| CGBDocumentLabelHandler | |
| CGBenchApp | Derive our application class from CwxNCBIApp and use it with CNCBIwxApplication |
| CGBenchApplication | CGBenchApplication |
| CGBenchAppTraits | CNCBI_GUIAppTraits |
| CGBenchFeedbackAgent | |
| CGBenchFeedbackAgentApp | |
| CGBenchFeedbackAttachment | |
| CGBenchFeedbackAttachment_Base | CGBenchFeedbackAttachment_Base -- |
| CGBenchFeedbackRequest | |
| CGBenchFeedbackRequest_Base | CGBenchFeedbackRequest_Base -- |
| CGBenchGUI | CGBenchGUI |
| CGBenchGUIDropTarget | CGBenchGUIDropTarget |
| CGBenchGUIMenuDisabler | CGBenchGUIMenuDisabler - disables commands not handled by other components such as views |
| CGBenchIndexCgi | |
| 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 |
| CGBenchMonitorApp | |
| CGBenchObjectCmdContributor | CGBenchObjectCmdContributor This extension contributes commands applicable to scoped objects |
| CGBenchPipe | CGBenchPipe |
| CGBenchProjectTreeContextMenuContributor | CGBenchProjectTreeContextMenuContributor This extension contributes to Project Tree context menus additional commands |
| CGBenchSampleCgi | |
| 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 |
| CGBenchToolBarFactory | CGBenchToolBarFactory |
| 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 -- |
| 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 | |
| CGBQualifier | CGBQualifier -- |
| CGBQualifier_Base | CGBQualifier_Base -- |
| 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 |
| CGBReleaseFile::ISeqEntryHandler | Interface for handling Seq-entry objects |
| CGBReleaseFileImpl | |
| CGBRequestStatistics | |
| CGbScopeLoader | |
| CGBSecondary_accn | CGBSecondary_accn -- |
| CGBSecondary_accn_Base | CGBSecondary_accn_Base -- |
| CGBSeq | CGBSeq -- |
| CGBSeq_Base | CGBSeq_Base -- |
| CGBSeqFormatter | |
| CGBSeqFormatter::SOStreamContainer | |
| 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 |
| CGBTag | CGBTag -- |
| CGBTag_Base | CGBTag_Base -- |
| CGBTagNames | CGBTagNames -- |
| CGBTagNames_Base | CGBTagNames_Base -- |
| CGBTags | CGBTags -- |
| CGBTags_Base | CGBTags_Base -- |
| CGBTagset | CGBTagset -- |
| CGBTagset_Base | CGBTagset_Base -- |
| CGBTagsetRules | CGBTagsetRules -- |
| CGBTagsetRules_Base | CGBTagsetRules_Base -- |
| CGBTagsetRuleSet | CGBTagsetRuleSet -- |
| CGBTagsetRuleSet_Base | CGBTagsetRuleSet_Base -- |
| CGBUserType | CGBUserType |
| CGBUserTypeParent_CI | |
| CGBUserTypeReg | CGBUserTypeReg - container of registered user types |
| 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_Assembly | CGC_Assembly -- |
| CGC_Assembly_Base | CGC_Assembly_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_Replicon | CGC_Replicon -- |
| CGC_Replicon_Base | CGC_Replicon_Base -- |
| 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 |
| CGC_Scaf_stats | CGC_Scaf_stats -- |
| CGC_Scaf_stats_Base | Scaf-stats All stats for one type of data Can be at any level |
| CGC_Scaf_stats_Base::C_Composition | C_Composition -- |
| CGC_Scaf_stats_Base::C_Gap_closure | C_Gap_closure -- |
| CGC_Scaf_stats_Base::C_Length | C_Length -- |
| CGC_Sequence | 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 |
| 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 | |
| CGenbankWriter | |
| 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 -- |
| CGeneFileUtils | CGeneFileUtils |
| CGeneFileUtils::SMultiIntRecord< k_nFields > | SMultiIntRecord - an n-tuple of integers |
| CGeneFileUtils::STwoIntRecord | STwoIntRecord - a pair of integers |
| CGeneFileWriter | CGeneFileWriter |
| CGeneFileWriter::CGene2AccnProcessor | Gene->Accession line processor |
| CGeneFileWriter::CGene2PMProcessor | Gene->PubMed line processor |
| CGeneFileWriter::CGeneInfoProcessor | Gene Info line processor |
| CGeneFileWriter::CLineProcessor | Line processor base class |
| 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 |
| CGeneGroup | CGeneGroup is a subclass of CLayoutGroup contains gene, RNA, cds, and Exon features |
| CGeneInfo | CGeneInfo |
| CGeneInfoException | CGeneInfoException |
| CGeneInfoFileReader | CGeneInfoFileReader |
| CGeneModel | |
| CGeneModelConfig | |
| CGeneModelDemoApp | |
| CGeneModelFactory | CGeneModelFactory |
| CGeneModelFeatJob | CGeneModelFeatJob |
| CGeneModelTrack | CGeneModelTrack -- |
| CGeneOverlapProcess | |
| CGenePanel | |
| CGeneralException | |
| CGeneralParseException | |
| 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 |
| 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_Base::C_E | C_E -- |
| CGenetic_code_table | |
| CGenetic_code_table_Base | Table of genetic codes |
| CGenetic_codeTypeConverter | |
| CGeneticCodeArgs | Argument class to collect the genetic code for all queries/subjects |
| CGenomeAnnotComment | |
| CGenomeItem | |
| CGenomeProjectItem | |
| CGet1TypeInfoSource | |
| CGet2TypeInfoSource | |
| CGetFeature | |
| CGetJobCmdExecutor | |
| CGetLoadProcessor | |
| CGetOpt | |
| CGetPasswordFromConsoleException | Exception class for g_GetPasswordFromConsole |
| CGetStatisticsProcessor | |
| CGetVersionProcessor | |
| CGFF3_Formatter | |
| CGff3Reader | |
| CGffExporter | |
| CGffExporterFactory | |
| CGffExportJob | CGffExportJob |
| CGffExportPage | |
| CGffExportParams | |
| CGFFFormatter | |
| CGFFGatherer | |
| CGffLoadManager | CGffLoadManager |
| CGffLoadParams | |
| CGffLoadTask | CGffLoadTask |
| CGffParamsPanel | |
| CGFFReader | |
| CGFFReader::SRecord | |
| CGFFReader::SRecord::SSubLoc | |
| CGi2TaxIdApp | |
| CGiCache | Class CGiCache provides a simple, thread-safe interface for storing the older or outdated versions of sequence records viewed in GBench |
| CGiExtractor | Extracts the GI for a given sequence id (CSeqFormatter associates this with g) |
| CGiimport_id | CGiimport_id -- |
| CGiimport_id_Base | CGiimport_id_Base -- |
| CGl3dDemoApp | |
| CGl3dDemoPanel | |
| CGl3dDemoUI | |
| CGl3dWindow | |
| CGL_matrix | CGL_matrix -- |
| CGL_matrix_Base | CGL_matrix_Base -- |
| CGlArcBall | |
| CGlAttrGuard | CGlAttrGuard - guard class for restoring OpenGL attributes |
| CGlBackground | |
| CGlBitmapFont | Stand-in for GLUT fonts |
| CGlCamera | |
| CGLCanvas | CGLCanvas |
| CGlCgiImageApplication | |
| CGlContainer | |
| CGLContextCache | |
| CGlCurve< Curve > | Class ICurve defines a basic interface for all curves |
| CGLDemoDlg | |
| CGlDisplayList | |
| CGlDisplayListCompile | |
| CGlDrawScale | |
| CGlDrawScale::CCoordConverter | |
| CGlEvent | |
| CGlFeedbackFont | |
| CGlFeedbackFont::FPackChar | |
| CGlGeometry | |
| CGlimmerReader | |
| CGlInfoDemoPanel | |
| CGlInfoWindow | |
| CGlLight | |
| CGlMaterial | |
| 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 |
| CGlOsContext | |
| CGlPane | Class CGlPane |
| CGlPaneGuard | |
| CGlPaneWidgetChildDemo | |
| CGlPaneWidgetDemoPanel | |
| CGlPoint< T > | |
| CGlRect< T > | CGlRect reprsents rectangle in the coordinate system with origin located in the left bottom corner |
| CGlTestApplication | |
| CGLTestWMClient | CTextWMClient |
| CGlTexture | |
| CGlTextureManager | |
| CGlTube< Curve > | Class ICurve defines a basic interface for all curves |
| CGlTube< Curve >::SRingPos | |
| 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 | |
| CGlViewport | |
| CGlWidget | |
| CGlWidgetBase | Class CGlWidgetBase |
| CGlWidgetDemo | CGlWidgetDemo |
| CGlWidgetPane | CGlWidgetPane represent a window component residing in CGlWidgetBase client area |
| CGlWidgetPane::SHandlerRec | |
| CGlyph | |
| CGlyphContainer | CGlyphContainer - a glyph container in the form of layout track |
| CGlZoomLens | |
| CGnomon_param | CGnomon_param -- |
| CGnomon_param_Base | CGnomon_param_Base -- |
| CGnomon_param_Base::C_Gc_content_range | Percents |
| CGnomon_param_Base::C_Param | C_Param -- |
| CGnomon_params | CGnomon_params -- |
| CGnomon_params_Base | CGnomon_params_Base -- |
| CGnomonAnnotator | |
| CGnomonAnnotator_Base | |
| CGnomonAnnotatorArgUtil | |
| CGnomonEngine | |
| CGnomonEngine::SGnomonEngineImplData | |
| CGnomonException | |
| CGoTermSortStruct | |
| CGradientColorPanel | |
| CGradientColorPanel::stParams | |
| CGradientPanel | |
| CGraph_CI | CGraph_CI -- |
| CGraphBase | CGraphBase |
| CGraphContainer | CGraphContainer CGraphContainer a composite IRenderable that manages several child IRenderable graphs |
| 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 |
| CGridCgiApplication | Grid Cgi Application |
| CGridCgiContext | Grid Cgi Context Context in which a request is processed |
| CGridCgiSampleApplication | |
| CGridCleanupThread | |
| CGridClient | Grid Client |
| CGridClientApp | Grid Client Application |
| CGridClientException | Grid Client exception |
| CGridClientSampleApp | |
| CGridControlThread | |
| CGridDebugContext | |
| CGridGlobals | |
| CGridJobBatchSubmitter | Grid Job Batch Submitter |
| CGridJobStatus | Grid Job Status checker |
| CGridJobSubmitter | Grid Job Submitter |
| CGridThreadContext | |
| CGridWorkerApp | Main Worker Node application |
| CGridWorkerAppException | |
| CGridWorkerNode | Grid Worker Node |
| CGridWorkerNodeApp_Listener | An adapter class for IGridWorkerNodeApp_Listener |
| CGridWorkerNodeException | |
| CGroupAlignmentsJob | CGroupAlignmentsJob |
| CGroupAlignmentsParamsPanel | CGroupAlignmentsParamsPanel |
| CGroupAlignmentsToolManager | CGroupAlignmentsToolManager |
| CGroupCheckboxes | |
| CGroupMapWidget | CGroupMapWidget |
| CGroupMapWidget::CGroupItem | CGroupItem //////////////////////////////////////////////////////////// |
| CGroupMapWidget::SGroup | |
| CGroupMapWidget::SGroupDescr | |
| CGroupMapWidget::SItemDescr | |
| CGroupRadioButtons | |
| CGsdbComment | |
| CGuard< Resource, Lock, Unlock > | |
| CGuiConfigException | Exceptions thrown by CSettings Set and Factory default classes should derive from this |
| oligofar::CGuideFile | |
| CGuiDependentPkg | |
| oligofar::CGuideSamFile | |
| oligofar::CGuideSamFile::C_Key | |
| oligofar::CGuideSamFile::C_Value | |
| CGuideTree | Wrapper around libw_phylo_tree.a classes: CPhloTreeDataSource, IPhyloTreeRenderer, etc, used for manipulation of phylogenetic tree |
| CGuideTree::CExpander | Tree visitor class, expands all nodes and corrects node colors |
| CGuideTree::CLeaveFinder | Tree visitor, finds pointers to all leaves in a subtree |
| CGuideTree::CNodeFinder | Tree visitor, finds tree node by id |
| CGuideTree::CSingleBlastNameExaminer | |
| CGuideTree::STreeInfo | Information about tree leaves |
| CGuideTreeApplication | |
| CGuideTreeCalc | Computaion of distance-based phylognetic/guide tree |
| CGuideTreeCalcException | Guide tree calc exceptions |
| CGuideTreeCGIMap | Class for creating image map |
| CGuideTreeException | Guide tree exceptions |
| CGuidGenerator | |
| CGUIEvent | CGUIEvent provides mapping of FLTK events to Semantic Events |
| CGuiPkgDependency | |
| CGuiPkgManifest | |
| CGuiRegistry | |
| CGuiRegistry::CReadView | |
| CGuiRegistry::CReadWriteView | |
| CGuiRegistry::SKeyInfo | |
| CGuiRegistryUtil | |
| CGUIUserType | CGUIUserType |
| CGwasGlyph | |
| CGwasGlyph::accum_study | |
| CGwasGlyph::SBin | |
| CGwasGlyph::SValue | |
| CGwasLoadJob | CGwasLoadJob |
| CGwasLoadParams | |
| CGwasTrackLoadManager | CGwasTrackLoadManager |
| CGwasTrackParamsPanel | |
| ChainInfo | |
| CHairlineOptionsDlg | |
| CHandleRange | |
| CHandleRangeMap | |
| CHapmapJob | CHapmapJob |
| CHapmapJob::SParams | |
| CHapmapTrack | |
| CHapmapTrackFactory | |
| oligofar::CHashAtom | |
| oligofar::fourplanes::CHashCode | |
| CHashExtractor | Computes the sequence hash value for a given sequence id (CSeqFormatter associates this with h) |
| oligofar::fourplanes::CHashGenerator | |
| oligofar::fourplanes::CHashIterator | |
| CHashParam | |
| oligofar::fourplanes::CHashPlanes | |
| oligofar::CHashPopulator | |
| CHdf2mzXMLApplication | |
| 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 -- |
| CHIntronScore | |
| CHistComment | |
| CHistConfigDlg | |
| CHistConfParams | CHistParams: the data structure holding feature rendering parameters |
| CHistogramGlyph | |
| CHistogramGraph | CHistogramGraph |
| CHistogramGraph::SProperties | |
| CHistParams | CHistParams: the data structure holding feature rendering parameters |
| CHistParamsManager | CHistParamsManager: class for manage histogram/graph settings for all feature subtype and various graphs |
| CHit | A generalized representation of a pairwise alignment |
| oligofar::CHit | |
| oligofar::CHit::C_NextCtl | |
| CHit_Base | CHit_Base -- |
| CHitCluster | |
| CHitClustering | |
| CHitComparator< THit > | |
| CHitCoverageAccumulator< THit > | |
| CHitElemGlyph | CHitElemGlyph is a simple graphical object representing a Hit Element |
| CHitFilter< THit > | |
| CHitFilter< THit >::SHitEnd | |
| 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 |
| CHitMatrixPane::SGraphDescr | |
| CHitMatrixRenderer | CHitMatrixRenderer - renders Hit Matrix Graph, Rulers, axes, grid, sequence and features graphs |
| CHitMatrixRenderer::SGraphDescr | |
| CHitMatrixSeqGraph | CHitMatrixSeqGraph |
| CHitMatrixWidget | Class CHitMatrixWidget |
| CHitSeqId | CHitSeqId |
| CHitSeqRowId | CHitSeqRowId |
| CHMM_State | |
| CHMMParameters | HMM model parameters just create it and pass to a GNOMON engine |
| CHMMParameters::SDetails | |
| CHookData< Hook, Function > | |
| CHookDataBase | |
| 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_html::SPopupMenuInfo | |
| 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 | |
| CHTMLBasicPage | CHTMLBasicPage -- |
| CHTMLBlockElement | |
| CHTMLComment | |
| CHTMLDualNode | |
| CHTMLElement | |
| CHTMLException | CHTMLException -- |
| CHTMLHelper | |
| CHTMLInlineElement | |
| CHTMLListElement | |
| CHTMLNode | |
| CHTMLOpenElement | |
| CHTMLPage | CHTMLPage -- |
| CHTMLPage::SPopupMenuInfo | Popup menu info structure |
| CHTMLPageStat | |
| CHTMLPlainText | |
| CHTMLPopupMenu | CHTMLPopupMenu -- |
| CHTMLPopupMenu::SItem | Menu item type |
| 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_Base::C_Reply | Reply data moved at the end to make it easier to construct the reply data manually from precalculated data |
| 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_Base::C_Request | C_Request -- |
| 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_Blob_Info_Base::C_Blob_id | Id can be supplied by inner request |
| CID2_Request_Get_Blob_Info_Base::C_Blob_id::C_Resolve | Generate blob-ids from request |
| 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 | |
| CId2ReaderBase::CDebugPrinter | |
| CId2ReaderCF | Class factory for ID2 reader |
| CID2S_Bioseq_Ids | CID2S_Bioseq_Ids -- |
| CID2S_Bioseq_Ids_Base | CID2S_Bioseq_Ids_Base -- |
| CID2S_Bioseq_Ids_Base::C_E | C_E -- |
| 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_Data_Base::C_Id | Place of data to insert |
| 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 |
| CId_pat_Base::C_Id | C_Id -- |
| CIdCheckList | CIdCheckList -- |
| CIdCheckList_Base | CIdCheckList_Base -- |
| CIdCheckList_Base::C_II | Cmd=ncheck & lcheck & acheck |
| CIdCheckList_Base::C_II::C_E_II | Cmd=ncheck & lcheck & acheck |
| CIdDataValue | |
| CIdDeMux< TBV, TBVFact > | Id to coordinates demultiplexer |
| 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 |
| CIdMapper::SMapper | |
| CIdMapper::SMappingContext | |
| 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 |
| CIdUrlList | CIdUrlList -- |
| CIdUrlList_Base | CIdUrlList_Base -- |
| CIdUrlSet | CIdUrlSet -- |
| CIdUrlSet_Base | CIdUrlSet_Base -- |
| CIdUrlSet_Base::C_Data | C_Data -- |
| CIgapIntron | |
| CIgapIntronChain | |
| 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 *********************************************** |
| pythonpp::CImportError | |
| CImprint | CImprint -- |
| CImprint_Base | Imprint group |
| CInc | |
| CInDelInfo | |
| CIndelMapper | |
| pythonpp::CIndentationError | |
| CIndentingOstream | |
| CIndentingStreambuf | |
| CIndexedDb | This class is responsible for loading indices and doing the actual seed search |
| CIndexedDb::SThreadLocal | Data local to a running thread |
| CIndexedDbException | Index wrapper exceptions |
| CIndexedOctetStrings | |
| CIndexedStrings | |
| pythonpp::CIndexError | |
| CIndexSorter | |
| CInferencePrefixList | |
| python::CInfoHandler_CursorCollect | |
| CInfoItem | |
| CIniParser | |
| CIniPrint | |
| CInitGuard | |
| CInitMutex< C > | |
| CInitMutex_Base | |
| CInitMutexPool | |
| CInitMutexPool::CPoolMutex | |
| 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 |
| CInputException | Defines user input exceptions |
| CInputGiList | Gi List for database construction |
| CInputModel | |
| CINSDAuthor | CINSDAuthor -- |
| CINSDAuthor_Base | INSDReference_position contains a string value indicating the basepair span(s) to which a reference applies |
| CINSDFeature | CINSDFeature -- |
| CINSDFeature_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 | CINSDReference_Base -- |
| 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 |
| CINSDTag | CINSDTag -- |
| CINSDTag_Base | CINSDTag_Base -- |
| CINSDTagNames | CINSDTagNames -- |
| CINSDTagNames_Base | CINSDTagNames_Base -- |
| CINSDTags | CINSDTags -- |
| CINSDTags_Base | CINSDTags_Base -- |
| CINSDTagset | CINSDTagset -- |
| CINSDTagset_Base | INSDTagset is used for community-specific data elements in a tag/value format |
| CINSDTagsetRules | CINSDTagsetRules -- |
| CINSDTagsetRules_Base | INSDTagsetRules defines mandatory, optional, and unique tags for a given community's INSDTagset |
| CINSDTagsetRuleSet | CINSDTagsetRuleSet -- |
| CINSDTagsetRuleSet_Base | CINSDTagsetRuleSet_Base -- |
| CINSDXref | CINSDXref -- |
| CINSDXref_Base | INSDXref provides a method for referring to records in other databases |
| CInsertAnnotHookAnnot | |
| CInsertAnnotHookCopy | |
| CInsertAnnotHookId | |
| CInsertAnnotManager | |
| pythonpp::CInstance | |
| CInstance | |
| CInstancedAligner | |
| CInstrument | CInstrument -- |
| CInstrument_Base | Instrument descripton (not 'run time' parameters, which should properly be captured in spectrumInstrument); these features must be common to all acquisitions |
| CInstrumentConfiguration | CInstrumentConfiguration -- |
| CInstrumentConfiguration_Base | Description of a particular hardware configuration of a mass spectrometer |
| CInstrumentConfiguration_Base::C_Attlist | C_Attlist -- |
| CInstrumentConfigurationList | CInstrumentConfigurationList -- |
| CInstrumentConfigurationList_Base | List and descriptions of instrument configurations |
| CInstrumentConfigurationList_Base::C_Attlist | C_Attlist -- |
| pythonpp::CInt | |
| CInt_fuzz | |
| CInt_fuzz_Base | Int-fuzz ********************************************** |
| CInt_fuzz_Base::C_Range | Max to min |
| CInt_graph | CInt_graph -- |
| CInt_graph_Base | CInt_graph_Base -- |
| CIntDataType | |
| python::CIntegrityError | |
| CIntenArrayBinary | CIntenArrayBinary -- |
| CIntenArrayBinary_Base | The intensities for each member of the m/z array, also in base64 encoded binary as IEEE-754 floating point, with specified precision and endianess |
| CIntEnumDataType | |
| CInter_residue_bond | CInter_residue_bond -- |
| CInter_residue_bond_Base | Inter-residue bonds are defined by a reference to two atoms |
| python::CInterfaceError | |
| CInterfaceHook< I > | |
| CInterfaceObjectLocker< Interface > | |
| 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 | |
| CIntervalTree::SStat | |
| CIntervalTreeConstIteratorTraits< Traits > | |
| CIntervalTreeIterator< Traits > | |
| CIntervalTreeIteratorTraits< Traits > | |
| CIntervalTreeTraits | |
| CIntervalTreeTraits::SNodeMapValue | |
| CIntervalTreeTraits::STreeMapValue | |
| 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 | |
| CIO_Exception | IO exception |
| pythonpp::CIOError | |
| CIOException | |
| CIonSelection | CIonSelection -- |
| CIonSelection_Base | CIonSelection_Base -- |
| CIonSelection_Base::C_E | This captures the type of ion selection being performed, and trigger m/z (or m/z's), neutral loss criteria etc |
| CIRByteSourceReader | Class adapter from IReader to CByteSourceReader |
| CIRef< Interface, Locker > | |
| CIsolationWindow | CIsolationWindow -- |
| CIsolationWindow_Base | This element captures the isolation (or 'selection') window configured to isolate one or more precursors |
| CIsotropic_temperature_factors | CIsotropic_temperature_factors -- |
| CIsotropic_temperature_factors_Base | CIsotropic_temperature_factors_Base -- |
| CIStreamBuffer | |
| CIStreamClassMemberIterator | Reading (iterating through) members of the class (SET, SEQUENCE) |
| CIStreamContainerIterator | Reading (iterating through) elements of containers (SET OF, SEQUENCE OF) |
| CIStreamFrame | |
| CItem | CItem -- |
| CItem_Base | |
| CItem_Base::C_Attlist | C_Attlist -- |
| CItem_Base::C_E_Item | |
| CItemInfo | |
| CItemSelectionPanel | CItemSelectionPanel |
| CItemsInfo | |
| CItemsInfo::CIterator | |
| CIteration | CIteration -- |
| CIteration_Base | CIteration_Base -- |
| 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 | |
| CJobNotificationThread | Thread class, removes obsolete job records |
| CJobQueueCleanerThread | Thread class, removes obsolete job records |
| CJobQueueExecutionWatcherThread | Thread class, watches job execution, reschedules forgotten jobs |
| CJobResultsDlg | |
| CJobRun | |
| CJobStatusTracker | In-Memory storage to track status of all jobs Syncronized thread safe class |
| CJobUpdate | |
| pythonpp::CKeyboardInterrupt | |
| pythonpp::CKeyError | |
| CKeywordsItem | |
| CKmerCountsException | Exception class for Kmer counts |
| CLabel | |
| CLadder | |
| CLadderContainer | |
| CLangQueryApp | |
| CLargestIntronSizeArgs | Argument class for collecting the largest intron size |
| CLastExon | |
| 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 | |
| CLayoutConfig | Configuration class for types of layouts |
| 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 | CLayoutTrack - the abstract base class for various tracks |
| CLayoutTrack::SIconInfo | A help struct for storing information about a icon |
| CLayoutTrackHandler | CLayoutTrackHandler - is the handler for handling the user interactions on layout tracks |
| CLayoutVisRange | |
| CLDBlockDS | |
| CLDBlockDS::SParams | |
| CLDBlockDSType | |
| CLDBlockGlyph | |
| CLDBlockGlyph::SValue | |
| CLDBlockJob | CLDBlockJob |
| CLDBlockLine | |
| CLDBlockTrack | |
| CLDBlockTrackFactory | |
| CLDFilterDialog | |
| CLDFilterParams | |
| CLDS_BuildIdIdx | Scanner functor to build id index |
| CLDS_CollectSeq_idsReader | |
| CLDS_CollectSeq_idsReader::CGuard | |
| CLDS_CoreObjectsReader | |
| CLDS_CoreObjectsReader::SObjectDetails | |
| CLDS_CoreObjectsReader::SObjectParseDescr | |
| CLDS_Database | LDS database |
| CLDS_DatabaseHolder | LDS database incapsulated into CObject compatible container |
| CLDS_DataLoader | |
| CLDS_DataLoader::CLDS_LoaderMaker | |
| 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_FindSeqIdFunc::SCandidate | |
| 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_IStreamCache::CIStream | |
| CLDS_Manager | |
| CLDS_Object | SLDS_ObjectDB and SLDS_AnnotDB related methods |
| CLDS_Query | CLDS_Query different queries to the LDS database |
| CLDS_Query::CSequenceFinder | Utility class to search sequences |
| CLDS_Query::SObjectDescr | Structure describes the indexed object |
| 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 -- |
| CLength_distribution_params_Base::C_Range | C_Range -- |
| CLessTypeInfo | |
| CLevelGuard | |
| CLevelSort | |
| CLexToken | |
| CLexTokenInt | |
| CLexTokenParenPair | |
| CLexTokenString | |
| CLibrarianToolDummyImpl | CLibrarianToolDummyImpl -- |
| CLibrarianToolImpl | CLibrarianToolImpl -- |
| CLightString | |
| CLinearSelHandler | Class CLinearSelHandler represents in GUI a one-dimnesional multi-segment selection |
| CLineError | |
| CLink | CLink -- |
| CLink_Base | Cmd=neighbor |
| CLink_Base::C_Selector | C_Selector -- |
| CLink_set | CLink_set -- |
| CLink_set_Base | Links between same class = neighbors links between other classes = links |
| CLinkButton | |
| CLinkButton::SLink | |
| CLinkedFeature | |
| CLinkedMultiset< Mapped > | |
| CLinkedMultisetBase< Key > | |
| CLinkerToolDummyImpl | CLinkerToolDummyImpl -- |
| CLinkerToolImpl< ConfTrait > | CLinkerToolImpl -- |
| CLinkInfo | CLinkInfo -- |
| CLinkList | CLinkList -- |
| CLinkList_Base | CLinkList_Base -- |
| CLinkReduce< TBV, TMapFunc1, TMapFunc2 > | Implementation of Many-to-One mapping with source set reduction |
| CLinkSet | CLinkSet -- |
| CLinkSet_Base | Common |
| CLinkSet_Base::C_Data | C_Data -- |
| CLinkSet_Base::C_Data::C_Links | C_Links -- |
| CLinkSet_Base::C_Data::C_Links::C_LL | C_LL -- |
| CLinkSet_Base::C_Data::C_Links::C_LL::C_LW | C_LW -- |
| CLinkSetDb | CLinkSetDb -- |
| CLinkSetDb_Base | CLinkSetDb_Base -- |
| CLinkSetDb_Base::C_Data | C_Data -- |
| CLinkSetDbHistory | CLinkSetDbHistory -- |
| pythonpp::CList | |
| CListeningSocket | CListeningSocket:: |
| CListTypeStrings | |
| 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 | |
| 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 |
| CLocalFinderApp | |
| CLocalHookSet< Hook > | |
| CLocalHookSetBase | |
| CLocalHookSetBase::Compare | |
| CLocalIdComment | |
| CLocalPssmSearch | |
| CLocalRange< Position > | Sufficient extra functionality is needed from CRange that it justifies extending the class |
| CLocalSearchFactory | Factory for CLocalSearch |
| CLocalSeqSearch | Local sequence search |
| CLocaseCharPtrConverter | |
| CLocaseStringConverter | |
| CLocationListCtrl | |
| CLocationListCtrl::SIntData | |
| CLocationPanel | |
| CLockerTraits< C > | |
| CLockVector< BV > | Class implements bit-vector based lock storage registering millions of int numbered objects |
| CLockVectorGuard< TLockVect > | Lock guard for the CLockVector |
| CLocMapper_Default | |
| CLocMapper_Default::CGappedRange | |
| CLocObjects_SplitInfo | |
| CLocusItem | |
| CLog | |
| CLog::CFlusher | |
| pythonpp::CLong | |
| pythonpp::bind::CLong | |
| pythonpp::CLookupError | |
| CLookupTableOptions | Wrapper class for struct_name |
| CLookupTableWrap | Wrapper class for struct_name |
| 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 |
| CMacOSX | |
| CMacroTestProcess | |
| CMainFrame | CMainFrame Base class for Application Main Frame, derive your frames from this one |
| CMainFrame::IHintListener | IHintListener - an interface for a component that shows command help hints |
| CMakeBlastDBApp | The main application class |
| CMakeCdrProds | |
| CMakeConnActualParams | |
| 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 > | |
| CMakeScoreMethodApp | |
| CManagedWrapperGeneratorToolDummyImpl | |
| CMap_ext | CMap_ext -- |
| CMap_ext_Base | CMap_ext_Base -- |
| CMapCompLen | |
| CMapControl | CMapControl owns all its items |
| CMapControl::SProperties | |
| 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 |
| CMapLoc_Base::C_Attlist | C_Attlist -- |
| oligofar::CMappedAlignment | |
| CMappedFeat | CMappedFeat -- |
| CMappedGraph | CMappedGraph -- |
| CMappingRange | |
| CMappingRangeRef_Less | |
| CMappingRangeRef_LessRev | |
| CMappingRanges | |
| CMaps | CMaps -- |
| CMaps_Base | CMaps_Base -- |
| CMaps_Base::C_Method | C_Method -- |
| 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 -- |
| CMarkov_chain_params_Base::C_E_Probabilities | C_E_Probabilities -- |
| CMarkovChain< order > | |
| CMarkovChain< 0 > | |
| CMarkovChainArray< order > | |
| CMask | CMask -- |
| CMaskBDBReader | Class for reading sequences from BLAST databases |
| CMaskData | |
| CMaskedRangeSet | |
| CMaskedRangesVector | This represents a set of masks for a given sequence |
| CMaskFastaReader | Class for reading sequences from fasta files |
| CMaskFileName | CMaskFileName -- |
| CMaskFromFasta | |
| CMaskInfoRegistry | Registry class for the sequence masking/filtering algorithms used to create masks to be added to a CWriteDB object |
| CMaskingDataExtractor | Extracts the masking data for a given sequence id (CSeqFormatter associates this with m) |
| CMaskingFmtSpecHelper | Auxiliary class to help parse the masking algorithm specification to assist the CSeqFormatter class |
| CMaskReader | Virtual base class for all input readers |
| CMaskReader::Exception | Exceptions thrown by CMaskReader class |
| 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 | |
| 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 |
| CMbIndexArgs | Argument class to retrieve megablast database indexing options |
| CMC3_CodingRegion< order > | |
| CMC_NonCodingRegion< order > | |
| CMD5 | |
| CMD5StreamWriter | |
| 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 -- |
| CMemoryRegistry::SEntry | |
| CMemoryRegistry::SSection | |
| CMemorySourceCollector | |
| CMemPot | |
| CMemStore | |
| CMemStore::SMemBlock | |
| 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 | |
| CMergeVolumes | Main volume merge algorithm class |
| CMessageHistoryInfo | |
| CMessageHistoryInfo_Base |
- MessageHistoryInfo holds information about plugin commands
|
| CMessageSlot | |
| CMessageSlotPopupWindow | CMessageSlotPopupWindow |
| CMetaDataTest | |
| CMetaRegistry | |
| CMetaRegistry::SEntry | |
| CMetaRegistry::SKey | Members |
| pythonpp::CMethod | |
| CMicroArrayReader | |
| 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 |
| CMinPanelContainer | CMinPanelContainer |
| CMinPanelContainer::SItem | |
| 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 |
| 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_Base::C_Coordinates | C_Coordinates -- |
| 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 | |
| CModelExon | |
| 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 |
| CMolTypeValidator | |
| CMouseZoomHandler | CMouseZoomHandler provides support for mouse-driven zoom and pan operations |
| CMove | CMove -- |
| CMove_Base | CMove_Base -- |
| CMPCrossAlignView | CMPCrossAlignView |
| CMPCrossAlignViewFactory | CMPCrossAlignViewFactory |
| CmRNASubPanel | |
| CMRUCache | |
| CMRUCache_Base | CMRUCache_Base -- |
| 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 -- |
| CMSChargeHandle | CMSChargeHandle -- |
| CMSChargeHandle_Base | How to handle precursor charge |
| CMsgHandlerGuard | |
| impl::CMsgHandlerGuard | |
| CMsHdf5 | |
| CMsHdf5::iter_info | |
| CMsHdf5::MSMapEntry | |
| CMsHdf5::OutOfBounds | |
| CMsHdf5::UnknownGroup | |
| 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 |
| 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 -- |
| CMsvcMetaMakefile::SPchInfo | |
| CMsvcPrjFilesCollector | |
| CMsvcPrjGeneralContext | CMsvcPrjGeneralContext -- |
| CMsvcPrjProjectContext | CMsvcPrjProjectContext -- |
| CMsvcProjectMakefile | CMsvcProjectMakefile -- |
| CMsvcProjectRuleMakefile | Abstraction of rule for generation of project settings based on component usage |
| CMsvcSite | CMsvcSite -- |
| CMsvcSite::SLibChoice | |
| CMsvcTools | CMsvcTools -- |
| CMTArgs | Argument class to collect multi-threaded arguments |
| CMultEditCommand | |
| CMultiAligner | Simultaneously align multiple protein sequences |
| CMultiAligner::compare_sseg_db_idx | |
| CMultiAligner::SColumn | Column in an alignment used for combining result from multiple alignment and pair-wise in-cluster alignments |
| CMultiAligner::SGraphNode | |
| CMultiAligner::SProgress | Structure for reporting alignment progress |
| CMultiAligner::SSegmentLoc | |
| CMultiAlignerException | |
| CMultiAlignerOptions | Options and parameters for multiple alignement |
| CMultiAlignerOptions::CPattern | Representation of CDD pattern |
| CMultiAlignerOptions::CPattern::SPattern | |
| CMultiAlignerOptions::SConstraint | Structure for representing single user constraint for pair-wise alignment |
| CMultiAlignerVersion | Keeps track of CMultiAligner version |
| CMultiAlignView | CMultiAlignView |
| CMultiAlignViewFactory | CMultiAlignViewFactory |
| CMultiAlnPrinter | Printer for popular multiple alignmnet formats |
| CMultiApplication | |
| CMultiDictionary | Class CMultiDictionary permits the creation of a linked, prioritized set of dictionaries |
| CMultiDictionary::SDictionary | |
| CMultiFileInput | CMultiFileInput |
| CMultiFileInput::CDropTarget | |
| CMultiOrgName | CMultiOrgName -- |
| CMultiOrgName_Base | First will be used to assign division |
| CMultiReader | |
| CMultiReaderApp | |
| CMultiSeqInfo | Contains information about all sequences in a set |
| CMultisourceException | CMultisourceException |
| CMultiWriter | IWriter which can write simultaneously to the different streams |
| CMutableAtomicCounter | CMutableAtomicCounter -- |
| CMutex | CMutex -- |
| CMutexException | CMutexException -- |
| CMyClass | CMyClass |
| CMySQL_Connection | |
| CMySQL_LangCmd | |
| CMySQL_RowResult | |
| CMySQLContext | |
| CMytestApplication | |
| CMzArrayBinary | CMzArrayBinary -- |
| CMzArrayBinary_Base | The list of m/z values (for any type of spectrum) |
| CMzData | CMzData -- |
| CMzData_Base | CMzData_Base -- |
| CMzData_Base::C_Attlist | C_Attlist -- |
| CMZI | Class for holding an m/z value, intensity, and rank |
| CMZICompare | |
| CMZICompareHigh | |
| CMZICompareIntensity | |
| CMzML | CMzML -- |
| CMzML_Base | This is the root element for the Proteomics Standards Initiative (PSI) mzML schema, which is intended to capture the use of a mass spectrometer, the data generated, and the initial processing of that data (to the level of the peak list) |
| CMzML_Base::C_Attlist | C_Attlist -- |
| CMzXML2hdf5Application | |
| Cn3DApp | |
| Cn3DGLCanvas | |
| Cn3DNoWin | |
| CName_std | .hpp User-defined methods of the data storage class |
| CName_std_Base | Structured names |
| CNamedDataValue | |
| CNamedPipe | Initially all timeouts are infinite |
| CNamedPipeClient | CNamedPipeClient -- |
| CNamedPipeDefClient | |
| CNamedPipeProcessTask | CNamedPipeProcessTask |
| CNamedPipeServer | CNamedPipeServer -- |
| pythonpp::CNameError | |
| CNameGetter< Value > | Get name attribute for Value object |
| CNamespace | |
| CNamespaceInfoItem | |
| CNameValue | CNameValue -- |
| CNameValue_Base | Generic holder for experimental info |
| 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 -- |
| 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 -- |
| CNcbiEnvironment::SEnvValue | Cached environment <name,value> pair |
| CNcbiEnvRegMapper | CNcbiEnvRegMapper -- |
| CNcbiMatrix< T > | |
| CNCBINode | |
| CNCBINode::SAttributeValue | |
| CNCBINode::TMode | |
| 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 |
| CNcbiResourceInfoFile::SResInfoCache | |
| 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 |
| 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 |
| CNCBIwxApplication | CNCBIwxApplication - a base class for NCBI GUI applications using wxWidgets |
| CNCBlob | Object for reading or writing to NetCache blob |
| CNCBlobLockHolder | Object holding lock of NetCache blob |
| CNCBlobStorage | Blob storage for NetCache |
| CNCBlobStorageException | Exception which is thrown from all CNCBlobStorage-related classes |
| CNCDBDataFile | Connection to the database file in NetCache storage containing all actual blobs data |
| CNCDBFile | Connection to one database file in NetCache storage |
| CNCDBFileLock< TFile > | Scoped pointer to database file object |
| CNCDBFileObjFactory< TFile > | Factory class for creating connections to database files |
| CNCDBFilesPool | Central pool of connections to database files belonging to one database part |
| CNCDBIndexFile | Connection to index database in NetCache storage |
| CNCDBMetaFile | Connection to the database file in NetCache storage containing all meta-information about blobs and their chunks |
| CNCDBStat | Object accumulating statistics for NetCache storage |
| CNCFileSystem | Class representing file system which NetCache works with |
| CNCFSOpenFile | Class representing one open file in file system |
| CNCFSVirtFile | Virtual file in the file system opened by SQLite |
| CNCMemManager | Utility class for tuning memory usage in NetCache including database cache and all other memory allocations |
| CNCMessageHandler | Handler of all NetCache incoming requests |
| CNCMessageHandler::CDiagnosticsGuard | Special guard to properly initialize and de-initialize diagnostics |
| CNCMessageHandler::SCommandExtra | Extra information about each NetCache command |
| 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 |
| CNCMMDBCache | Instance of database cache which will cache pages from one database file |
| CNCMMDBPage | Object with one page from database |
| CNCMMDBPagesHash | Hash-table of pages belonging to one instance of CNCMMDBCache |
| CNCMMFreeChunk | Representation of the free memory chunk, i.e |
| CNCMMFreeChunkBase | Base class for CNCMMFreeChunk |
| 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 |
| CNCServerStat | Class collecting statistics about whole server |
| CNCServerStat_Getter | Helper class to maintain different instances of server statistics in different threads |
| CNCStatFigure< T > | Class representing one statistical value |
| CNCStatTimer | Object to measure time consumed for some operations worth remembering in storage statistics |
| CNCStorage_StoppedException | Special exception to terminate background thread when storage is destroying |
| CNCTlsObject< Derived, ObjType > | Base class for the object specific for each thread |
| CNegativeIdList | |
| 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 |
| CNetCacheReader | |
| CNetCacheServer | Netcache server |
| CNetCacheServerListener | |
| CNetCacheWriter | |
| CNetICacheCF | Class factory for NetCache implementation of ICache |
| CNetICacheClient | Client to NetCache server (implements ICache interface) |
| CNetObject | |
| CNetObjectRef< TYPE > | |
| CNetObjectRef_Base | |
| CNetSchedule_AccessList | List of hosts allowed |
| CNetSchedule_JS_Guard | |
| CNetSchedule_JSGroupGuard | |
| CNetScheduleAdmin | |
| CNetScheduleAdmin::SServerQueueList | |
| CNetScheduleAdmin::SWorkerNodeInfo | |
| CNetScheduleAPI | Client API for NCBI NetSchedule server |
| CNetScheduleAPI::SServerParams | |
| CNetScheduleAPICF | |
| CNetScheduleBackgroundHost | Host for background threads |
| CNetScheduleCheck | NetSchedule check application |
| CNetScheduleClientFactory | |
| CNetScheduleConnectionFactory | CNetScheduleConnectionFactory:: |
| CNetScheduleControl | NetSchedule control application |
| CNetScheduleDApp | NetSchedule daemon application |
| CNetScheduleException | NetSchedule internal exception |
| CNetScheduleExceptionMap | Map from exception names to codes |
| CNetScheduleExecuter | Smart pointer to a part of the NetSchedule API that does job retrieval and processing on the worker node side |
| CNetScheduleHandler | ConnectionHandler for NetScheduler |
| CNetScheduleHandler::SCommandExtra | |
| CNetScheduleJob | Job description |
| CNetScheduleKey | Meaningful information encoded in the NetSchedule key |
| CNetScheduleKeys | |
| CNetScheduleKeys::const_iterator | |
| CNetScheduleRequestExecutor | Executor for long-standing requests |
| CNetScheduleServer | NetScheduler threaded server |
| CNetScheduleSubmitter | Smart pointer to the job submission part of the NetSchedule API |
| CNetServer | |
| CNetServer::SExecResult | |
| CNetServerConnection | |
| CNetServerGroup | |
| CNetServerGroupIterator | |
| CNetServerMultilineCmdOutput | |
| CNetService | |
| CNetServiceException | Net Service exception |
| CNetServProtoParser< Extra > | |
| CNetServProtoParserBase | |
| CNetSrvConnException | Net Service exception |
| CNetworkOptionsDlgExtension | |
| CNetworkOptionsPage | |
| CNgAligner | |
| CNlmZipBtRdr | |
| CNlmZipReader | |
| CNmer_repeatsApplication | |
| CNmerIterator | Type used to iterate over the consecutive Nmer values of the query sequence |
| CNode | CNode -- |
| CNode_annotation | CNode_annotation -- |
| CNode_annotation_Base | CNode_annotation_Base -- |
| CNode_Base | CNode_Base -- |
| CNodeFeature | CNodeFeature -- |
| CNodeFeature_Base | CNodeFeature_Base -- |
| CNodeFeatureSet | CNodeFeatureSet -- |
| CNodeFeatureSet_Base | CNodeFeatureSet_Base -- |
| 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 |
| CNonCodingRegion | |
| pythonpp::CNone | |
| CNonException | |
| CNormalize | CNormalize -- |
| CNormalize_Base | CNormalize_Base -- |
| CNormalize_Base::C_Data | C_Data -- |
| CNormalizer | This class converts model units to the integers distribited in [0, m_IntRange] and vice versa |
| CNotFoundException | |
| pythonpp::CNotImplementedError | |
| python::CNotSupportedError | |
| CNPiece | |
| CNRCriteria | |
| CNRItem | |
| CNS_Transaction | |
| CNSClientFactoryException | |
| CNSeq | |
| CNSInfoCollector | |
| CNSInfoCollector::IAction< TInfo > | |
| CNSInfoRenderer | |
| CNSJobInfo | |
| CNSJobListRenderAction | |
| CNSProtoParserException | |
| CNSRemoveJobControlApp | |
| CNSRequestContextFactory | |
| CNSSubmitRemoteJobApp | |
| CNSTagMap | |
| 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 |
| CNumberValidator | |
| CNWAligner | |
| CNWAligner::CBacktraceMatrix4 | |
| CNWAligner::SAlignInOut | |
| CNWAligner::SProgressInfo | |
| CNWAlignerThread_Align | |
| CNWFormatter | |
| CNWFormatter::SSegment | |
| CObjClipboard | |
| pythonpp::bind::CObject< T > | |
| pythonpp::CObject | |
| CObject | CObject -- |
| CObject_id | |
| CObject_id_Base | Object-id can tag or name anything |
| CObjectConverter | |
| CObjectCounterLocker | |
| CObjectEx | CObjectEx -- |
| CObjectException | CObjectException -- |
| CObjectFactory | |
| CObjectFor< T > | CObjectFor -- |
| CObjectGetTypeInfo | |
| CObjectHookGuard< T > | Helper class: installs hooks in constructor, and uninstalls in destructor |
| CObjectHookGuardBase | |
| CObjectIndex | CVisibleRangeEvent |
| CObjectIndex::SRec | |
| CObjectInfo | Facilitate read/write access to a particular instance of an object of the specified type |
| CObjectInfoCV | Choice variant iterator |
| CObjectInfoEI | Container iterator |
| CObjectInfoMI | Class member iterator |
| CObjectIStream | CObjectIStream -- |
| CObjectIStream::ByteBlock | |
| CObjectIStream::CharBlock | |
| CObjectIStreamAsn | CObjectIStreamAsn -- |
| CObjectIStreamAsnBinary | CObjectIStreamAsnBinary -- |
| CObjectIStreamHelper< ASNContainerClass > | |
| CObjectIStreamXml | CObjectIStreamXml -- |
| CObjectList | CObjectList Data structure representing a list of CObjects with associated Scopes and other optional attributes (strings and numbers) |
| CObjectList::_CColumn | |
| CObjectList_Base | CObjectList_Base -- |
| CObjectList_Base::C_Data | All Entrez databases may be configured to include LinkOut |
| CObjectListException | CObjectListException |
| CObjectListTableModel | CObjectListTableModel |
| CObjectListWidget | CObjectListWidget - mediator widget |
| CObjectListWidgetSel | |
| CObjectManager | CObjectManager -- |
| CObjectManagerEngine | CAppJobDispatcher |
| CObjectManagerEngineAction | |
| CObjectManagerEngineListener | |
| CObjectMemoryPool | |
| CObjectMemoryPoolChunk | |
| CObjectMemoryPoolChunk::SHeader | |
| CObjectOStream | CObjectOStream -- |
| CObjectOStream::ByteBlock | |
| CObjectOStream::CharBlock | |
| CObjectOStreamAsn | CObjectOStreamAsn -- |
| CObjectOStreamAsnBinary | CObjectOStreamAsnBinary -- |
| CObjectOStreamJson | CObjectOStreamJson -- |
| CObjectOStreamXml | CObjectOStreamXml -- |
| CObjectPanelsEntry | |
| CObjectPool< C > | |
| CObjectSelector | CObjectSelector -- |
| CObjectSelector_Base | CObjectSelector_Base -- |
| CObjectsSniffer | Serialized objects sniffer |
| CObjectsSniffer::SCandidateInfo | |
| CObjectsSniffer::SObjectDescription | |
| CObjectStack | |
| CObjectStackFrame | |
| CObjectStoreProtectedBase | Protected base class for CSingletonObjectStore Holds a syncronization mutex |
| CObjectStreamCopier | CObjectStreamCopier -- |
| CObjectTextWidget | CObjectTextWidget - mediator widget |
| CObjectTypeInfo | Facilitate access to the data type information |
| CObjectTypeInfoCV | Choice variant iterator |
| CObjectTypeInfoII | Item iterator (either member or variant) |
| CObjectTypeInfoMI | Class member iterator |
| CObjectTypeInfoVI | Choice variant iterator |
| CObjectTypeIs< T > | |
| CObjectUrl | CObjectUrl -- |
| CObjectUrl_Base | CObjectUrl_Base -- |
| CObjectUrl_Base::C_Attlist | C_Attlist -- |
| CObjectUrl_Base::C_Data | C_Data -- |
| CObjectUrl_Base::C_Data::C_BaseData | C_BaseData -- |
| CObjectUrl_Base::C_Data::C_BaseData::C_Rule | End of SubObjectSelector group |
| CObjectUrl_Base::C_Data::C_Rule | C_Rule -- |
| 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 | |
| CObjMemberSelector | |
| 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_QueryFactory | NCBI C++ Object Manager free implementation of IQueryFactory |
| 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 | |
| CObjTypeConverterContext | |
| 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_RowResult::t_SODBC_ColDescr | |
| 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 |
| COffsetList::CData | |
| COffsetList::CData::CDataIterator | |
| COffsetList::CDataPool | |
| COffsetList::SDataUnit | |
| COffsetReadHook | |
| COidExtractor | Extracts the OID for a given sequence id (CSeqFormatter associates this with o) |
| COldAsnTypeInfo | |
| oligofar::COligoFarApp | |
| Colors | |
| ColumnAddress | |
| ColumnReader | |
| ColumnResidueProfile | |
| ColumnScorer | |
| ctlib::Command | |
| CommandProcessor | |
| 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 |
| compare_tree_edge_descending | Callback for sorting tree edges in order of decreasing edge weight |
| 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 | |
| COneSeqRange | |
| COneStage | |
| config_s | |
| ctlib::Connection | |
| ConnectsParalogs | |
| ConnInfoDeleter2 | |
| ConnNetInfoDeleter | |
| ConsensusMaker | |
| ConservationColorer | |
| conv_result | |
| convert_to_string_type | |
| CoordSet | |
| COpenDlg | COpenDlg |
| COpenDlgTask | COpenDlgTask - shows "Open" dialog |
| COpenGLException | |
| COpenGLPrintBuffer | |
| COpenRange< Position > | |
| COpenViewDlg | |
| COpenViewEventRecord | COpenViewEventRecord - event log record for "open view" event |
| COpenViewlDlgTask | |
| COpenViewManager | |
| COpenViewManager::COVMException | |
| COperand | COperand -- |
| COperand_Base | COperand_Base -- |
| COperand_Base::C_Attlist | C_Attlist -- |
| python::COperationalError | |
| COptArg< T > | |
| COptArg< bool > | |
| COptArg< pair< T, T > > | |
| COptArg< string > | |
| COptArgList< List > | |
| COptArgSet< Set > | |
| COptChoice< T > | |
| COptFlag< T > | |
| COptFlags< T > | |
| COptGroup | |
| COptHelp | |
| COption | |
| COptionDescription | |
| 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 |
| 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 *********************************************** |
| COrgMod | .hpp User-defined methods of the data storage class |
| COrgMod_Base | COrgMod_Base -- |
| COrgName | |
| COrgName_Base | COrgName_Base -- |
| COrgName_Base::C_Name | C_Name -- |
| COrgRefCache | |
| COrgRefCache::SCacheEntry | |
| COrgRefCache::SDivision | |
| COriginItem | |
| pythonpp::COSError | |
| COStreamBuffer | |
| COStreamClassMember | Writing class members |
| COStreamContainer | Writing containers (SET OF, SEQUENCE OF) |
| COStreamFrame | |
| COStreamHelper | COStreamHelper |
| COStreamTextOStream | |
| 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 -- |
| COutput | |
| oligofar::COutputFormatter | |
| pythonpp::COverflowError | |
| CPackageInfo | |
| CPacked_seg | CPacked_seg -- |
| CPacked_seg_Base | For (multiway) global or partial alignments |
| CPacked_seqint | |
| CPacked_seqint_Base | CPacked_seqint_Base -- |
| CPacked_seqintTypeConverter | |
| CPacked_seqpnt | |
| CPacked_seqpnt_Base | CPacked_seqpnt_Base -- |
| CPackString | |
| CPackString::SNode | |
| CPackStringChoiceHook | |
| CPackStringClassHook | |
| CPad | CPad -- |
| CPad_Base | CPad_Base -- |
| CPad_Base::C_Attlist | C_Attlist -- |
| CPad_Base::C_E_Pad | C_E_Pad -- |
| CPageBuffers | |
| CPageHandler | |
| CPageList | |
| CPager | |
| CPagerBox | |
| CPagerView | |
| CPagerViewButtons | |
| CPagerViewJavaLess | |
| CPageStat | CPageStat -- |
| CPairNodeKeyGetter< TNode > | Default key getter for pair-node (id + value) |
| CPairSorter< TKey, TValue > | CPairSorter |
| 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 | |
| CPanelGrid::SNeighbors | |
| CParam< TDescription > | CParam |
| CParamBase | CParamBase |
| 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 | |
| CParseTemplException< TBase > | CParseTemplException -- |
| 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 -- |
| CPathHook | |
| 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_AssayData_Base::C_Value | Assay Result, must be the same type as defined for TID |
| 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_AssaySubmit_Base::C_Assay | Assay Description or pre-existing Identifier |
| 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_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_CompoundType_Base::C_Id | Compound Namespace and ID (absent for "deposited" type compounds) |
| 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_InfoData_Base::C_Value | Data Value |
| 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_ResultType_Base::C_Constraints | Allowed Values, used for validating incoming data If type is "float" |
| 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 |
| 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 | |
| CPdfObjectWriter::ObjOffset | |
| CPdfObjectWriter::ObjOffsetCompare | |
| CPdfRotate | |
| CPdfString | |
| CPdfTrailer | |
| CPdfTranslate | |
| CPepsinA | |
| CPepXML | |
| CPeriodicTestJob | CPrimeNumbersJob |
| oligofar::CPermutator8b | |
| oligofar::CPermutator8b::C_Atom | |
| oligofar::CPermutator8b::C_Entry | |
| CPerson_id | |
| CPerson_id_Base | Person-id is to define a std element for people |
| 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_Contig::SAlignInfo | |
| CPhrap_Contig::SBaseSeg | |
| CPhrap_Contig::SContigTag | |
| CPhrap_Contig::SOligo | |
| CPhrap_Read | |
| CPhrap_Read::SReadDS | |
| CPhrap_Read::SReadTag | |
| CPhrap_Seq | |
| CPhrap_Sequence | |
| CPhrapReader | |
| CPhrapReader::SAssmTag | |
| CPhyExporter | |
| CPhyExporterFactory | |
| CPhyExportJob | CPhyExportJob |
| CPhyExportPage | |
| CPhyLoader | CPhyLoader |
| CPhyLoadJob | CPhyLoadJob |
| CPhyLoadPage | |
| CPhyLoadParams | |
| CPhyloForce | |
| CPhyloForce::calc_two_forces | |
| CPhyloPhylipReader | |
| CPhyloRadial | |
| CPhyloRectCladogram | |
| CPhyloSlantedCladogram | |
| CPhyloTreeCalculator | |
| CPhyloTreeCGIApplication | |
| CPhyloTreeCGIException | |
| CPhyloTreeCGIMap | |
| CPhyloTreeDataSource | |
| CPhyloTreeDataSource::dynamic_to_tree | |
| CPhyloTreeDataSource::tree_to_dynamic | |
| CPhyloTreeDataSource::visitor_node_finder | |
| CPhyloTreeDataSource::visitor_read_properties | |
| CPhyloTreeDataSource::visitor_selection_reader | |
| CPhyloTreeDataSource::visitor_set_dirty | |
| CPhyloTreeDataSource::visitor_show_all | |
| CPhyloTreeDataSource::visitor_sorter | |
| CPhyloTreeDemoApp | Derive our application class from CwxNCBIApp and use it together with standard CNCBIwxApplication |
| CPhyloTreeDemoDlg | |
| CPhyloTreeException | |
| CPhyloTreeFilter_Depth | |
| CPhyloTreeFilter_Distance | |
| CPhyloTreeFilter_Export | |
| CPhyloTreeFilter_Selector | |
| CPhyloTreeFilterDlg | |
| CPhyloTreeLabel | |
| CPhyloTreeLabelTracker | Tree visitor, finds all labels and node colors for leafes |
| CPhyloTreeNode | |
| CPhyloTreeNode::predicate_sort_by_leaves_count | |
| CPhyloTreeNodeGroupper | Tree visitor, finds subtrees that form groups based on tree features |
| CPhyloTreeNodeGroupper::CLabeledNode | |
| CPhyloTreePane | Class CPhyloTreePane |
| CPhyloTreeRectCalculator | |
| CPhyloTreeScheme | |
| CPhyloTreeSorter | |
| CPhyloTreeWidget | Class CPhyloTreeWidget |
| CPhyNewickNode | |
| CPhyNodeData | Data contained at each node of a phylogenetic tree |
| CPhyTreeNode | |
| CPhyTreeView | CPhyTreeView |
| CPhyTreeViewFactory | CPhyTreeViewFactory |
| CPIDGuard | CPIDGuard -- |
| CPIDGuardException | CPIDGuardException -- |
| CPieDataSource | CPieDataSource |
| CPieGraph | CPieGraph |
| CPigExtractor | Extracts the PIG for a given sequence id (CSeqFormatter associates this with P) |
| CPII | CPII -- |
| CPII_Base | Controlled Publisher Identifier |
| CPipe | CPipe -- |
| CPipe::IProcessWatcher | Callback interface for ExecWait method |
| CPipeException | CPipeException -- |
| CPipeProcessWatcher | |
| CPipeProcessWatcher_Base | |
| CPIR_block | CPIR_block -- |
| CPIR_block_Base | PIR specific descriptions |
| CPkgManager | CPkgManager - application Package Manager |
| CPkl2hdf5Application | |
| CPkl2hdf5Application::pklSpectrum | |
| CPlace_SplitInfo | |
| CPlaceId | |
| CPlainTextItem | |
| CPlatform | CPlatform -- |
| CPlatform_Base | CPlatform_Base -- |
| CPlatform_Base::C_Attlist | C_Attlist -- |
| CPlatforms | CPlatforms -- |
| CPlatforms_Base | CPlatforms_Base -- |
| CPlugin< PluginType > | |
| CPluginArg | |
| CPluginArg_Base |
- PluginArg defines the properties of a given argument
|
| CPluginArg_Base::C_Data | C_Data -- |
| CPluginArgSet | Namespace ncbi::objects:: |
| CPluginArgSet_Base |
- PluginArgSet defines a set of arguments
|
| CPluginBase | |
| CPluginCache | |
| CPluginCache_Base |
- This defines the object stored in a plugin cache
|
| CPluginCommand | |
| CPluginCommand_Base |
- PluginCommand is the list of arguments that a plugin takes
|
| CPluginException | |
| CPluginIconInfo | |
| CPluginIconInfo_Base | CPluginIconInfo_Base -- |
| CPluginInfo | |
| CPluginInfo_Base | CPluginInfo_Base -- |
| CPluginInfoSet | .hpp User-defined methods of the data storage class |
| CPluginInfoSet_Base |
- PluginInfo defines the basic information that all plugins must support
|
| CPluginLibInfo | |
| CPluginLibInfo_Base |
- kludge around missing CTypeRef code (doesn't support
- SET OF SEQUENCE {
|
| CPluginManager< TClass > | CPluginManager<> -- |
| CPluginManager< TClass >::SDriverInfo | Information about a driver, with maybe a pointer to an instantiated class factory that contains the driver |
| CPluginManager_DllResolver | Service class for DLLs resolution |
| CPluginManagerBase | |
| CPluginManagerException | CPluginManagerException -- |
| CPluginManagerGetter< Interface > | |
| CPluginManagerGetterImpl | |
| CPluginManagerStore | Deprecated interface to CPluginManager |
| 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 |
| CPluginMessage | |
| CPluginMessage_Base |
- PluginMessage holds information regarding a single request to a plugin
|
| CPluginMessageChain | |
| CPluginMessageChain_Base |
- PluginMessageChain holds a set of plugin messages that are intended to
- be called sequentially
|
| CPluginMRUEntry | |
| CPluginMRUEntry_Base |
|
| CPluginObject | Namespace ncbi::objects:: |
| CPluginObject_Base |
- Wrappers for non-serializable objects
- For these we encode a pointer and a name of the object type
|
| CPluginReply | |
| CPluginReply_Base |
- PluginReply defines the responses received from a plugin after completion
- of its activities
|
| CPluginReplyAction | |
| CPluginReplyAction_Base |
- PluginReplyAction lists possible modes of action for the items returned
- from a plugin
|
| CPluginRequest | |
| CPluginRequest_Base |
- PluginRequest defines the commands we can issue to a plugin
|
| 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 |
| CPmPid | CPmPid -- |
| CPmPid_Base | Publisher Id supplied to PubMed |
| CPointerPot | |
| CPointerTypeInfo | |
| CPointerTypeStrings | |
| CPollable | |
| CPoolOfThreads< TRequest > | CPoolOfThreads<> -- abstract pool of threads sharing a request queue |
| CPopupMenuEvent | CPopupMenuEvent - an event that is sent when a popup menu needs to be shown |
| CPostBuildEventToolDummyImpl | |
| CPostReadHook | |
| CPostscript | |
| CPostWriteHook | |
| CPreBuildEventTool | |
| CPreBuildEventToolDummyImpl | |
| CPreBuildEventToolLibImpl | |
| CPrecursor | CPrecursor -- |
| CPrecursor_Base | This is the precursor step |
| CPrecursor_Base::C_Attlist | C_Attlist -- |
| CPrecursor_Base::C_Attlist | C_Attlist -- |
| CPrecursorList | CPrecursorList -- |
| CPrecursorList_Base | List and descriptions of precursors to the spectrum currently being described |
| CPrecursorList_Base::C_Attlist | C_Attlist -- |
| CPrecursorList_Base::C_Attlist | C_Attlist -- |
| CPrefetchBioseq | |
| CPrefetchBioseqActionSource | |
| CPrefetchCanceled | This exception is used to interrupt actions canceled by user |
| CPrefetchComplete< Handle > | |
| CPrefetchComplete< CBioseq_Handle > | |
| CPrefetchFeat_CI | |
| CPrefetchFeat_CIActionSource | |
| 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 |
| CPreLinkEventToolDummyImpl | |
| CPreOrderedOffsetIterator | Iterator for 0-terminated pre-ordered offset lists |
| CPreReadHook | |
| CPreSearchThread | One thread of the indexed seed search |
| 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 -- |
| CPrimarySequence_Base::C_Attlist | C_Attlist -- |
| CPrimeNumberClient | CPrimeNumberClient |
| CPrimeNumbersJob | CPrimeNumbersJob |
| CPrimeNumbersJob::CResult | |
| CPrimeNumbersJob::CResult | |
| CPrimitiveTypeFunctions< T > | |
| CPrimitiveTypeFunctionsBase | |
| CPrimitiveTypeInfo | |
| CPrimitiveTypeInfoAnyContent | |
| CPrimitiveTypeInfoBitString | |
| CPrimitiveTypeInfoBool | |
| CPrimitiveTypeInfoChar | |
| CPrimitiveTypeInfoCharPtr< T > | |
| CPrimitiveTypeInfoDouble | |
| CPrimitiveTypeInfoFloat | |
| CPrimitiveTypeInfoInt | |
| CPrimitiveTypeInfoIntFunctions< T > | |
| CPrimitiveTypeInfoString | |
| CPrintableCharPtrConverter | |
| CPrintableStringConverter | |
| CPrintContext | |
| CPrintDlg | |
| 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 -- |
| CPrintOptions | |
| CPrintOptions::SText | |
| CPrintOptionsDlg | |
| 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 |
| 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 |
| CProcess | CProcess -- |
| CProcess::CExitInfo | The extended exit information for waited process |
| CProcessingMethod | CProcessingMethod -- |
| CProcessingMethod_Base | CProcessingMethod_Base -- |
| CProcessingMethod_Base::C_Attlist | C_Attlist -- |
| CProcessingMethod_Base::C_E | Description of the default peak processing method.This element describes the base method used in the generation of a particular mzData file |
| CProcessor | |
| CProcessor_ExtAnnot | |
| CProcessor_ID1 | |
| CProcessor_ID1_SNP | |
| CProcessor_ID2 | |
| CProcessor_ID2AndSkel | |
| CProcessor_SE | |
| CProcessor_SE_SNP | |
| CProcessor_St_SE | |
| CProcessor_St_SE_SNPT | |
| CProduct_pos | CProduct_pos -- |
| CProduct_pos_Base | CProduct_pos_Base -- |
| CProfileData | Represent databases of PSSM data and residue frequencies |
| CProgramDescriptionArgs | Argument class to populate an application's name and description |
| python::CProgrammingError | |
| oligofar::CProgressIndicator | |
| CProgressPanel | |
| CProjBulderApp | CProjBulderApp -- |
| CProjBulderAppException | CProjBulderAppException -- |
| CProjdesc | CProjdesc -- |
| CProjdesc_Base | CProjdesc_Base -- |
| CProject | CProject -- |
| CProject_Base | CProject_Base -- |
| 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 |
| CProjectConstPrx | CProjectConstPrx |
| CProjectDescr | .hpp User-defined methods of the data storage class |
| CProjectDescr_Base | CProjectDescr_Base -- |
| CProjectEditDlg | |
| CProjectFileWriter | |
| CProjectFolder | |
| CProjectFolder::IProjectItemVisitor | |
| CProjectFolder_Base | CProjectFolder_Base -- |
| CProjectFolderConstPrx | CProjectFolderConstPrx |
| CProjectFolderPrx | CProjectFolderPrx |
| CProjectFolderTreeItem | |
| CProjectFormatLoadManager | CProjectFormatLoadManager |
| CProjectHistoryItem | |
| CProjectHistoryItem_Base | CProjectHistoryItem_Base -- |
| CProjectItem | |
| CProjectItem_Base | CProjectItem_Base -- |
| CProjectItem_Base::C_Item | Item we represent |
| 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 |
| 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 -- |
| CProjectTreeBuilder::SMakeFiles | |
| 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 |
| 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 |
| CProjectViewLink | CProjectViewLink |
| CProjectViewLinkManager | CProjectViewLinkManager |
| CProjectViewToolBatFactory | CProjectViewToolBatFactory - provides standard toolbars for Project Views |
| CProjectViewTypeDescriptor | CProjectViewTypeDescriptor - holds description of a project view type |
| CProjItem | CProjItem -- |
| CProjKey | CProjKey -- |
| CProjSRCResolver | Collect sources in resolve macrodefines |
| CPromote | |
| CPropertiesPanelDlg | |
| CProSplign | Spliced protein to genomic alignment |
| CProSplign::CImplementation | |
| 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 *********************************************** |
| CProtProp | This class defines functions for calculating properties of amino acid sequences |
| CProvider | CProvider -- |
| CProvider_Base | CProvider_Base -- |
| 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 struct_name |
| 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 struct_name |
| CPSIDiagnosticsResponse | Wrapper class for struct_name |
| CPSIMatrix | Wrapper class for struct_name |
| CPSIMsa | Wrapper class for struct_name |
| CPssm | |
| CPssm_Base | Position-specific scoring matrix |
| CPSSMAligner | |
| 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 | |
| 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 | |
| CPtrToObjectExProxy | CPtrToObjectExProxy -- |
| CPub | |
| CPub_Base | CPub_Base -- |
| CPub_equiv | |
| CPub_equiv_Base | Equivalent identifiers for same citation |
| 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 |
| 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 |
| 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 | |
| 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 |
| CQuat< T > | |
| oligofar::CQuery | |
| 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 |
| CQueryExec | Query execution environment holds the function registry and the execution context |
| CQueryExecEnv | Query execition environment |
| CQueryExecEvalFunc | Expression evaluation visitor functor |
| CQueryFactoryInfo | Contains information about all sequences in a set |
| CQueryFilter | |
| 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 |
| CQueryFunctionEQ | |
| oligofar::CQueryHash | |
| oligofar::CQueryHash::C_ListInserter | |
| oligofar::CQueryHash::C_ScanCallback< Callback > | |
| CQueryMatchAccumulator< THit > | |
| CQueryOptionsArgs | Argument class to collect query options |
| CQueryParseException | Query parser exceptions |
| CQueryParseNode | Query node class |
| CQueryParseNode::SSrcLoc | Source location (points to the position in the original src) All positions are 0 based |
| CQueryParserEnv | Class passed to Lex/Bison (yylex/yyparse) functions |
| CQueryParseTree | Query tree and associated utility methods |
| CQuerySet | |
| CQuerySetUpOptions | Wrapper class for struct_name |
| 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 |
| CQueue::CStatisticsThread | |
| CQueueClientInfo | Netschedule queue client info |
| CQueueClientInfoList | All clients registered to connect |
| CQueueCollection | |
| CQueueConstIterator | |
| CQueueDataBase | Top level queue database |
| CQueueDbBlockArray | |
| CQueueEnumCursor | |
| CQueueGuard | |
| CQueueItemBase | CQueueItemBase -- skeleton blocking-queue item, sans actual request |
| CQueueIterator | |
| CQueueJSGuard | |
| CQueueParamAccessor | |
| CQueueWorkerNodeList | |
| CQueueWorkerNodeListGuard | |
| CQuickSortStack | |
| CQuickStrStream | Stream-like class to accumulate all in one string without actual streams-related overhead |
| CRADispatcherClient | |
| CRADispatcherClientException | Remote Application Dispatcher Client internal exception |
| CRADispatcherClientSampleApp | |
| CRAMonitor | |
| CRandom | |
| TestUtil::CRandomIntGen< lowest_value, highest_value > | |
| TestUtil::CRandomIntGen< lowest_value, highest_value > | |
| CRandomRowSelector | |
| pythonpp::CRange | |
| CRange< Position > | |
| 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 > | |
| CRangeVector | Wrapper class for a vector of CRange<ing> objects, needed to avoid manual memory deallocation |
| CRangeWithFuzz | |
| CRasterizer< A > | |
| 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 | |
| CRCache | |
| CRCache::CDataPool | |
| CRCache::CRVPool | |
| CRCache::SDataItem | |
| CReadBlastApp | |
| CReadChoiceVariantHook | Read hook for a choice variant (CHOICE) |
| CReadClassMemberHook | Read hook for data member of a containing object (eg, SEQUENCE) |
| CReadCmdExecutor | |
| CReadContainerElementHook | Read hook for a container element (SEQUENCE OF) |
| CReadDispatcher | |
| CReadDispatcherCommand | |
| CReader | |
| CReaderAllocatedConnection | |
| CReaderBase | |
| CReaderCacheManager | |
|