| __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 | |
| 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_OR< W > | Bit OR functor |
| bm::bit_SUB< W > | Bit SUB functor |
| 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 | |
| CAbstractProjectItem | .hpp User-defined methods of the data storage class |
| CAbstractProjectItem_Base | CAbstractProjectItem_Base -- |
| CAbstractTableModel | CAbstractTableModel |
| CAbstractTCEditor | CAbstractTCEditor is an implementation of main common features of the ITableCellEditor interface |
| 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 | |
| CAddBookmarkDlg | |
| CAddDescr_EditCommand< TEditHandle > | |
| CAddFeatChecker | |
| CAddIdChecker | |
| CAddItemsDlg | |
| 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 |
| 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 |
| 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) |
| CAgpTableDS | |
| CAgpTableDS::SAgpRow | Single row represented in the table, with its transcribed AGP information |
| CAgpTableWidget | |
| CAgpValidateApplication | |
| CAgpValidateReader | |
| CAgressiveResizeStrategy | |
| CAlgoAlignException | |
| CAlgoAlignUtilException | |
| CAlgoBlast_Base | |
| CAlgoFactory< AlgoType > | |
| CAlgoLinkOut | |
| CAlgoLinkOut_EntrezGene | |
| CAlgoLinkOut_LinkoutSNP | Main SNP linkout plugin multiplexer |
| CAlgoLinkOut_LinkoutSNPByGene | Handle SNP linkout by gene feature |
| CAlgoLinkOut_LinkoutSNPByLocation | Handle SNP linkout by sequence location |
| CAlgoLinkOut_LinkoutSNPBySNP | Handle SNP linkout by SNP feature |
| CAlgoLinkOut_Query | |
| CAlgoLinkOut_Viewer | |
| CAlgoPlugin< PluginType > | Class CAlgoPlugin implements the plugin interface required of all algorithm plugins |
| CAlgoPlugin_AAComp | |
| CAlgoPlugin_AlignCleanup | |
| CAlgoPlugin_AlignClustalw | |
| CAlgoPlugin_AlignComponents | |
| CAlgoPlugin_AlignConsensus | |
| CAlgoPlugin_AlignMerge | |
| CAlgoPlugin_AlignMuscle | |
| CAlgoPlugin_AlignPromote | |
| CAlgoPlugin_AlignPropagate | |
| CAlgoPlugin_AlignSubcat | |
| CAlgoPlugin_AlignToNeighbors | |
| CAlgoPlugin_BasicCleanup | |
| CAlgoPlugin_BLAST_Common | |
| CAlgoPlugin_BLAST_Remote | |
| CAlgoPlugin_BLASTn | |
| CAlgoPlugin_BLASTp | |
| CAlgoPlugin_BlastReqdisc | |
| CAlgoPlugin_BlastReqmega | |
| CAlgoPlugin_BlastReqn | |
| CAlgoPlugin_BlastReqp | |
| CAlgoPlugin_BlastReqtn | |
| CAlgoPlugin_BlastReqtx | |
| CAlgoPlugin_BlastReqx | |
| CAlgoPlugin_BLASTx | |
| CAlgoPlugin_BuildTree | |
| CAlgoPlugin_CalculatePI | |
| CAlgoPlugin_CDDSearch | |
| CAlgoPlugin_ChangeSequence | Change the coding for a given bioseq |
| CAlgoPlugin_Cobalt | |
| CAlgoPlugin_CpGIslands | |
| CAlgoPlugin_CreateBioseq | CAlgoPlugin_CreateBioseq wraps the functionality in sequence::CreateBioseqFromBioseq() |
| CAlgoPlugin_CreateDefline | |
| CAlgoPlugin_CreateStudyPreviewDialog | |
| CAlgoPlugin_CreateTrackCreatorDialog | |
| CAlgoPlugin_Dinuc | |
| CAlgoPlugin_DiscMegaBLAST | |
| CAlgoPlugin_DisplayWithTv | |
| CAlgoPlugin_ExtendedCleanup | |
| CAlgoPlugin_FindOrfs | |
| CAlgoPlugin_FindOverlap | |
| CAlgoPlugin_GcContent | |
| CAlgoPlugin_Gnomon | |
| CAlgoPlugin_MegaBLAST | |
| CAlgoPlugin_NamedPatterns | |
| CAlgoPlugin_NeedlemanWunsch | |
| CAlgoPlugin_Nmer | |
| CAlgoPlugin_NmerRepeats | |
| CAlgoPlugin_Pattern | |
| CAlgoPlugin_PredictAntigen | |
| CAlgoPlugin_PredictCoiledCoil | |
| CAlgoPlugin_PredictSignalSeq | |
| CAlgoPlugin_PrositeSearch | |
| CAlgoPlugin_ProSplign | |
| CAlgoPlugin_ReplaceIds | |
| CAlgoPlugin_RestrictionSites | |
| CAlgoPlugin_RetrieveNeighbors | |
| CAlgoPlugin_RunCn3d | |
| CAlgoPlugin_SelectFeature | |
| CAlgoPlugin_SpellCheck | |
| CAlgoPlugin_Splign | |
| CAlgoPlugin_tBLASTn | |
| CAlgoPlugin_tBLASTx | |
| CAlgoPlugin_WindowMasker | |
| CAlgoPlugin_WindowMasker::SMaskerInfo | |
| CAlgorithm_type | CAlgorithm_type -- |
| CAlgorithm_type_Base | CAlgorithm_type_Base -- |
| CAlgoWebService | |
| CAlgoWebServiceInit | |
| 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 | CAlignedFeatureGraph - a graph that displays features in alignment |
| 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 |
| 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 | |
| CAlignmentItem | |
| CAlignmentRefiner | |
| CAlignmentSmear | |
| CAlignModel | |
| 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 |
| CAlignSeqTable | CAlignSeqTable - mediator widget |
| CAlignSeqTableModel | CAlignSeqTableModel |
| CAlignSeqTableModel::SRow | |
| CAlignShadow | |
| oligofar::CAlignTest | |
| CAliPiece | |
| CAliToSeq_align | |
| 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 |
| CAlnInfoTable | |
| CAlnInfoView | |
| 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 |
| CAlnMultiHeaderHandler | CAlnMultiHeaderHandler |
| CAlnMultiHeaderStyle | CAlnMultiHeaderStyle |
| CAlnMultiModel | Class CAlnMultiModel - represents visual model of an alignment |
| CAlnMultiModel::SRowRecord | |
| CAlnMultiModelFactory | CAlnMultiModelFactory - a factory to separate creation of the model from widget |
| CAlnMultiPane | Class CAlnMultiPane |
| CAlnMultiPane::CEvent | |
| CAlnMultiPane::SHandlerRec | |
| CAlnMultiRenderer | Class CAlnMultiRenderer - renders multiple alignment represented by IAlnMultiRendererContext (the Model) |
| CAlnMultiRendererStyle | CAlnMultiRendererStyle is a collection of display properties common for all rows in the CAlnMultiWidget |
| CAlnMultiView | |
| CAlnMultiWidget | Class CAlnMultiWidget |
| CAlnPos_CI | |
| CAlnPropertiesDlg | |
| CAlnReader | Class CAlnReader supports importing a large variety of text-based alignment formats into standard data structures |
| CAlnSeqId | |
| CAlnSeqIdsExtract< TAlnSeqId > | IAlnSeqId extracting functor |
| 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 | CAlnVecRow - implementation of IAlignRow for CAlnVec-based alignments |
| CAlnVecRowHandle | CAlnVecRowHandle is inherited from IAlignRowHandle and represents a row of CAlnVec-based alignment |
| CAlnView | |
| 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 |
| CAltValidator | |
| CAltValidator::SAgpLineInfo | |
| CAltValidator::SGiVerLenTaxid | |
| CAltValidator::SLineData | |
| CAmbigDataBuilder | Encode ambiguities in blast database format |
| CAmbiguiousTypes | |
| CAmbiguityContext | |
| CAmbiguousRegion | Ambiguous portion of a sequence |
| 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 | |
| CAnnotCompareModel | |
| 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 | |
| CAnnotType_Index | |
| CAnnotTypes_CI | |
| CAnnotWriteConfig | |
| CAnnotWriteConfig::CAnnotConfigSettings | |
| CAntigenic | |
| CAnyContentDataType | |
| CAnyContentFunctions | |
| CAnyContentObject | Serializable object that stores any combination of parsable data |
| CAnyContentTypeStrings | |
| CAnyIntron | |
| CAnyIntron::CSIntronScore | |
| CAnyRef< T > | |
| CAnyType | CAnyType represents a Facade for the data of any type |
| CAnyType::CItem | |
| CAnyType::CItemPtr< T > | |
| CAnyType::CSpecItem< T > | |
| 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 -- |
| CAppHitFilter | |
| CAppHitFilter::SBuildIDs | |
| CAppHitFilterException | |
| CAppInfo | Class CAppInfo defines an interface for application registration information |
| CAppJobDispatcher | CAppJobDispatcher |
| CAppJobDispatcher::CDispatcherGuard | Guards Dispatcher's Main Mutex and flushes notification queue |
| CAppJobDispatcher::CDispMutex | Specialized mutex that provides GetLockDepth() |
| CAppJobDispatcher::SJobRecord | |
| CAppJobDispatcher::SJobStateEvent | |
| CAppJobDispatcher::SQueueItem | SQueueItem - element of the Polling Queue |
| CAppJobEngineObjectManagerAction | |
| CAppJobEngineObjectManagerListener | |
| CAppJobError | CAppJobError Default implementation for IAppJobError |
| CAppJobEventTranslator | CAppJobEventTranslator Standard Listener that generates notification events |
| CAppJobException | CAppJobException Exception thrown by Dispatcher and Engines |
| CAppJobNotification | CAppJobNotification Notification send by CAppJobEventTranslator |
| CAppJobProgress | CAppJobProgress Default implementation for IAppJobProgress |
| CAppJobRequest | CAppJobRequest CAppJobRequest serves as an adapter between IAppJob, CStdPoolOfThreads and CThreadPoolEngine |
| CAppJobTestApplication | CAppJobTestApplication |
| CAppNWA | |
| CAppNWAException | |
| 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 |
| 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 -- |
| CArgFormatter | |
| 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 | |
| CAsnConverter< TCpp, TC > | |
| CAsnSizer | |
| 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 -- |
| CAuthorsTableModel | |
| CAutoDef | |
| CAutoDefAvailableModifier | |
| CAutoDefDemo | |
| CAutoDefDlg | |
| CAutoDefExonListClause | |
| CAutoDefFakePromoterClause | |
| CAutoDefFeatureClause | |
| CAutoDefFeatureClause_Base | |
| CAutoDefGeneClusterClause | |
| CAutoDefIntergenicSpacerClause | |
| CAutoDefMiscCommentClause | |
| CAutoDefModifierCombo | |
| CAutoDefNcRNAClause | |
| CAutoDefParsedClause | |
| CAutoDefParsedIntergenicSpacerClause | |
| CAutoDefParsedRegionClause | |
| CAutoDefParsedtRNAClause | |
| CAutoDefPromoterClause | |
| CAutoDefSatelliteClause | |
| CAutoDefSourceDescription | |
| CAutoDefSourceGroup | |
| CAutoDefSourceModifierInfo | |
| CAutoDefTransposonClause | |
| CAutoDefUnknownGeneList | |
| CAutoDiagnosticsRedirector | |
| CAutoEnvironmentVariable | CAutoEnvironmentVariable -- |
| CAutoInitializeStaticFastMutex | CAutoInitializeStaticFastMutex -- |
| CAutoInitializeStaticMutex | CAutoInitializeStaticMutex -- |
| 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 | |
| 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 |
| 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 -- |
| 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_SplitInfo | |
| CBioseqContext | |
| CBioseqHandler | |
| CBioseqSeqInfoSrc | Implementation of the IBlastSeqInfoSrc interface to encapsulate retrieval of sequence identifiers and lengths from a CBioseq/CBioseq_set object |
| CBioSource | |
| CBioSource_Base | BioSource gives the source of the biological material for sequences |
| CBiostruc | |
| CBiostruc_align | CBiostruc_align -- |
| CBiostruc_align_Base | CBiostruc_align_Base -- |
| CBiostruc_align_seq | CBiostruc_align_seq -- |
| CBiostruc_align_seq_Base | Display seq structure align only |
| CBiostruc_annot_set | CBiostruc_annot_set -- |
| CBiostruc_annot_set_Base | A biostruc annotation set is a means to collect ASN.1 data for biostruc features into one file |
| CBiostruc_Base | A structure report or "biostruc" describes the components of a biomolecular assembly in terms of their names and descriptions, and a chemical graph giving atomic formula, connectivity and chirality |
| CBiostruc_descr | CBiostruc_descr -- |
| CBiostruc_descr_Base | The description of a biostruc refers to both the reported chemical and spatial structure of a biomolecular assembly |
| CBiostruc_feature | CBiostruc_feature -- |
| CBiostruc_feature_Base | An explicitly specified type in Biostruc-feature allows for efficient extraction and indexing of feature sets of a specific type |
| CBiostruc_feature_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 |
| 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_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_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 | |
| 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 |
| CBlastPollDlg | |
| CBlastPollItem | |
| CBlastPollTable | |
| 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 |
| CBlastSearchQuery | Search Query |
| CBlastSeqLoc | Wrapper class for struct_name |
| CBlastSeqLocWrap | Wrapper for BlastSeqLoc structure |
| CBlastSeqSrc | Wrapper class for struct_name |
| CBlastSeqSrcIterator | Wrapper class for struct_name |
| 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 |
| CBlastTracebackSearch | |
| CBlastUtils | |
| 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 |
| CBookmarkMgrDlg | |
| CBookmarksHandler | Class CBookmarksHandler represents in GUI a bookmarks on a sequence bar |
| pythonpp::CBool | |
| CBoolDataType | |
| CBoolTCRenderer | |
| CBox | |
| CBoyerMooreMatcher | This implemetation uses the Boyer-Moore alg |
| CBrick | CBrick -- |
| CBrick_Base | A brick is defined by the coordinates of eight corners |
| CBroadcastDlg | |
| CBrowser | CBrowser is an extension of Fl_Browser providing an option to prohibit existance of empty selection |
| CBrowserConfigDlg | |
| CBrowserDemoApp | |
| CBrowserUI | |
| 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 | |
| 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 |
| CButton | |
| CButtonFormatter | Format a button as a built-in argument type for boolean/flag arguments only |
| 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 | |
| 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 |
| CCancelButtonException | |
| 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 |
| CCDSInfo | |
| 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 | |
| CChainer::Predicate | |
| CChainer::TransformFunction | |
| CChainerArgUtil | |
| CChainMembers | |
| CChangeParams | |
| CChangePhyloTreeCommand | |
| CChangePhyloTreeCommand::SBTree | |
| CChangeSeqFeatCommand | |
| CChangeSeqFeatCommand::SFeature | |
| CChangeSeqFeatCommandFactory | |
| pythonpp::CChar | |
| CCharPtrFunctions< T > | |
| CCharTCEditor | |
| CCharTCRenderer | |
| CChartElem | |
| CCharVectorFunctions< Char > | |
| CCharVectorFunctionsBase | |
| CCharVectorTypeInfo< Char > | |
| CCheckBrowser | Class CCheckBrowser is similar to Fl_Check_Browser but is more intuitive to use |
| CCheckButton | |
| 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 |
| CChoice | |
| CChoiceDataType | |
| CChoicePointerTypeInfo | |
| CChoicePtrRefTypeStrings | |
| CChoicePtrTypeStrings | |
| CChoicePtrTypeStrings::SVariantInfo | |
| CChoiceRefTypeStrings | |
| CChoiceTypeInfo | |
| CChoiceTypeInfoFunctions | |
| CChoiceTypeStrings | |
| CChoiceTypeStrings::SVariantInfo | |
| CChooseSeqDlg | |
| 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 | |
| CCleanupApp | |
| CCleanupChange | All the changes made during cleanup |
| CCleanupProcess | |
| CCleave | |
| CCleaveFactory | Factory to return back object for enzyme |
| CClientPseudoDataType | |
| CClientPseudoTypeStrings | |
| CClipboard | |
| 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 -- |
| 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 -- |
| CColorButton | |
| CColorButton::CEvent | |
| CColorButtonPanel | CColorButtonPanel |
| CColorCalcDemo | |
| CColorCalcDemoApp | |
| CColorEditor | CColorEditor Wrapper for color button to fit into the CTable class |
| CColorTableMethod | CColorTableMethod |
| CColorTableScoringModel | |
| CColorTableScoringModel::SColorCategory | |
| CColorTableScoringPanel | |
| oligofar::CColorTwoBase | |
| CColumnScoringMethod | CColumnScoringMethod |
| CColumnScoringPanel | CColumnScoringPanel - Properties Panel for CColumnScoringMethod |
| CColumnSelectDlg | |
| CColumnTableModel | |
| CCombinedScoringMethod | |
| CCombinedScoringPanel | CCombinedScoringPanel - the Properties panel for CCombinedScoringMethod; |
| CComboBox | CComboBox widget -- combination input box & drop-down list box |
| CComboBox::CComboBrowser | Modified version of Fl_Hold_Browser that will (initially) select the first entry upon receiving a down arrow instead of jumping to the second |
| CComboBox::CComboInput | Modified version of Fl_Input that: 1) has an undo feature 2) if ctrl key combination is pressed, checks parent window for shortcuts; iff none is found, then Fl_Input is passed the key |
| CComboBox::CPopupWin | Popupwin class makes up for deficiencies of Fl::grab() function |
| CComboButton | CComboButton |
| CComboChart | Class CComboChart |
| CComboChartDataSource | Class CComboChartDataSource |
| impl::CCommand | |
| CCommandProcessor | |
| CCommandTarget | Class CCommandTarget - the base class for all classes handling commands |
| CComment_rule | |
| CComment_rule_Base | CComment_rule_Base -- |
| CComment_set | |
| CComment_set_Base | CComment_set_Base -- |
| CCommentDiagFactory | |
| CCommentDiagHandler | |
| CCommentItem | |
| 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) |
| 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 | |
| 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 | |
| CConfigDlg | |
| 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 |
| CContextCommandService | CContextCommandService |
| CContextMenuDelegate | CContextMenuDelegate - represent a pluggable operation |
| 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 | |
| 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 |
| 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 | |
| CCPPToolkitConnParams | |
| CCreatedFeat_Ref | |
| CCreateFeat | |
| CCrossAlnDemoApp | |
| CCrossAlnDemoUI | |
| CCrossAlnPane | |
| CCrossAlnRenderer | |
| CCrossAlnWidget | |
| CCrossPanelIR | |
| CCSVExportDlg | |
| CCtrlItem | |
| CCtxCmdMenuHandler | CCtxCmdMenuHandler |
| 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 | |
| CDataContainerType | |
| python::CDataError | |
| CDataFactory< DataType > | |
| 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 -- |
| CDataLoader | |
| CDataLoaderFactory | |
| CDataLoaderPatcher | |
| CDataLoaderPatcher::SParam | |
| CDataMember | |
| CDataMemberContainerType | |
| CDataMiningService | CDataMiningService |
| CDataMiningView | CDataMiningView |
| CDataPlugin< LoaderType > | CDataPlugin is a base class for all data loading plugins |
| CDataPlugin_AgpExport | |
| CDataPlugin_BlastReply | |
| CDataPlugin_ClustalExport | |
| CDataPlugin_DistMatExport | |
| CDataPlugin_EntrezSearch | |
| CDataPlugin_EntrezSearchException | |
| CDataPlugin_FileExport | Basic plugin to handle CSerialObject export |
| CDataPlugin_FileExport_Fasta | Plugin to handle FASTA output |
| CDataPlugin_FileExport_FeatTable | Plugin to handle 5-column feature table format |
| CDataPlugin_FileExport_Flat | Plugin to handle GenBank flat file format |
| CDataPlugin_FileExport_Gbseq | Plugin to handle GBSeq XML format |
| CDataPlugin_FileExport_GFF | Plugin to handle GFF/GTF/GTF3 formats |
| CDataPlugin_FileImport | |
| CDataPlugin_FileImport_Agp | |
| CDataPlugin_FileImport_Alignment | |
| CDataPlugin_FileImport_AssnStudy | |
| CDataPlugin_FileImport_DistMat | |
| CDataPlugin_FileImport_Fasta | |
| CDataPlugin_FileImport_FiveColumn | |
| CDataPlugin_FileImport_Gff | |
| CDataPlugin_FileImport_Glimmer | |
| CDataPlugin_FileImport_Ncbi | |
| CDataPlugin_FileImport_Newick | |
| CDataPlugin_FileImport_Phrap | |
| CDataPlugin_FileImport_RepeatMasker | |
| CDataPlugin_FileImport_Smk | |
| CDataPlugin_GBManage | |
| CDataPlugin_GBManageException | |
| CDataPlugin_GenbankLoader | |
| CDataPlugin_GenbankLoaderException | |
| CDataPlugin_GeneMark | |
| CDataPlugin_IndexedExport | |
| CDataPlugin_LDSLoader | |
| CDataPlugin_LDSLoaderException | |
| CDataPlugin_LDSManage | |
| CDataPlugin_Object2Project | |
| CDataPlugin_TableReader | |
| CDataPlugin_TreeExport | |
| 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 | |
| CDataStore | |
| CDataTool | |
| CDatatoolException | |
| CDataToolGeneratedSrc | |
| CDataType | |
| CDataTypeModule | |
| CDataTypeModule::Import | |
| CDataValue | |
| CDataValueTmpl< Type > | |
| pythonpp::CDate | |
| 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 | |
| CDefaultActionEvent | CDefaultActionEvent |
| CDefaultConnectPolicy | |
| CDefaultDriverVersion< TInterface > | |
| CDefaultHeaderCellRenderer | |
| CDefaultIdler | Default idler |
| CDefaultLayout | |
| CDefaultLayout::osort | |
| CDefaultLayoutPolicy | |
| CDefaultLengthGetter | |
| CDefaultNodeKeyGetter< TValue > | Default key getter for CTreeNode |
| CDefaultPolicy | CDefaultPolicy is a default policy for rendering layout objects in feature panel of seq_graphic widget |
| CDefaultRenderer_Double | Default cell renderer for a 'double' |
| CDefaultRenderer_SizeT | Default cell renderer for a 'size_t' or 'unsigned' |
| CDefaultSelectionModel | CDefaultSelectionModel |
| CDefaultSorter< T > | |
| CDefaultSynonymMapper | |
| CDefaultTCEditor | CDefaultTCEditor is the default implementation for the ITableCellEditor interface |
| CDefaultTCRenderer | CDefaultTCRenderer is the default implementation of ITableCellRenderer interface |
| 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 -- |
| CDemoApp | |
| CDemoApplication | |
| CDemoContigAssemblyApp | |
| CDemoControlsApp | |
| CDemoControlsClient | CDemoControlsClient |
| CDemoeApp | |
| CDemoHandler_EmptyOnOverflow | |
| CDemoHandler_HeapAlloc | |
| CDemoHandler_MemSize | |
| CDemoSeqQaApp | |
| CDemoSerialBrowser | |
| CDemoSerialBrowserApp | |
| CDemoTableModel | |
| CDemoTableModel::DataRow | |
| CDemoWizardApp | |
| 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 |
| 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 -- |
| CDiagPanel | |
| CDiagRangeCollection | |
| CDiagRangeCollection::PItLess | |
| CDiagRecycler | |
| CDiagRestorer | CDiagRestorer -- |
| CDiagStrEmptyMatcher | CDiagStrEmptyMatcher -- |
| CDiagStrErrCodeMatcher | CDiagStrErrCodeMatcher -- |
| CDiagStrMatcher | CDiagStrMatcher -- |
| CDiagStrPathMatcher | CDiagStrPathMatcher -- |
| CDiagStrStringMatcher | CDiagStrStringMatcher -- |
| CDiagSyntaxParser | CDiagSyntaxParser -- |
| CDialog | Class CDialog defines the basic interactions for dialogs |
| CDialogBackground | |
| oligofar::CDibaseScore< TCvtQry, TCvtSubj > | |
| oligofar::CDibaseScore_Base | |
| pythonpp::CDict | |
| pythonpp::CDictHelper< T > | |
| CDictionaryUtil | Standard dictionary utility functions |
| pythonpp::CDictProxy< T > | |
| CDimen | CDimension encapsulates the width and height of a rectangular region in integer precision |
| 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 |
| CDistances | Representation of pairwise distances, intended for use in multiple sequence alignment applications |
| CDistBasedClusterer | |
| CDistMethods | |
| CDlgDemoApp | |
| 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 |
| CDMToolSelector | CDataMiningService |
| CdnaWithHole | |
| CDNode | |
| CDocException | |
| CDockSplitter | Supports only Horizontal and Vertical modes |
| CDocMgrView | CDocMgrView is an Observer on the DocumentManager (not a Document!) |
| CDocRef | CDocRef -- |
| CDocRef_Base | Reference to a document |
| CDocSum | CDocSum -- |
| CDocSum_Base | CDocSum_Base -- |
| CDocsumColumnHandler | CDocsumColumnHandler |
| 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 | |
| CDoubleStrandSeq | |
| CDoubleTCRenderer | |
| CDoubleValueHolder | |
| CdPssmInput | |
| CDRefresher | |
| impl::CDriverContext | CDriverContext:: |
| CDriverManager | |
| CDSAnnotLockReadGuard | |
| CDSAnnotLockWriteGuard | |
| CdTreeStream | |
| CDummyLayoutObject | |
| CDummyLengthGetter | |
| CDummySynonymMapper | |
| CDumpSysInfo | |
| CdUpdateParameters | |
| CDUpdater | |
| CDUpdateStats | |
| CDustMaskApplication | |
| CDynamicCharArray | |
| CE2Reply | CE2Reply -- |
| CE2Reply_Base | CE2Reply_Base -- |
| CE2Request | CE2Request -- |
| CE2Request_Base | Request types |
| CEaaToIupacaa | |
| CEaaToStdaa | |
| CEditAction_UpdateIds | Edit action to manage changing IDs |
| CEditAction_UpdateIds::SId | |
| CEditBioseqSampleApp | |
| CEditCommand | |
| CEditCommand_Defline | |
| CEditCommand_Defline::SDefline | |
| CEditEvent | Class CEditEvent defines a single type for all editing events |
| CEditException | |
| 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 | |
| CEntrez2_boolean_element | CEntrez2_boolean_element -- |
| CEntrez2_boolean_element_Base | CEntrez2_boolean_element_Base -- |
| CEntrez2_boolean_exp | CEntrez2_boolean_exp -- |
| CEntrez2_boolean_exp_Base | The structured form of the boolean is the same in a request or return so that it easy to modify a query |
| CEntrez2_boolean_reply | CEntrez2_boolean_reply -- |
| CEntrez2_boolean_reply_Base | CEntrez2_boolean_reply_Base -- |
| CEntrez2_boolean_term | CEntrez2_boolean_term -- |
| CEntrez2_boolean_term_Base | Term is both sent and received as parts of queries and replies |
| CEntrez2_db_id | CEntrez2_db_id -- |
| CEntrez2_db_id_Base | Database name |
| CEntrez2_db_info | CEntrez2_db_info -- |
| CEntrez2_db_info_Base | Info for one database |
| CEntrez2_docsum | |
| CEntrez2_docsum_Base | CEntrez2_docsum_Base -- |
| CEntrez2_docsum_data | CEntrez2_docsum_data -- |
| CEntrez2_docsum_data_Base | CEntrez2_docsum_data_Base -- |
| CEntrez2_docsum_field_info | CEntrez2_docsum_field_info -- |
| CEntrez2_docsum_field_info_Base | CEntrez2_docsum_field_info_Base -- |
| CEntrez2_docsum_list | CEntrez2_docsum_list -- |
| CEntrez2_docsum_list_Base | CEntrez2_docsum_list_Base -- |
| CEntrez2_docsumHandler | |
| CEntrez2_dt | CEntrez2_dt -- |
| CEntrez2_dt_Base | Entrez2 common elements |
| CEntrez2_dt_filter | CEntrez2_dt_filter -- |
| CEntrez2_dt_filter_Base | CEntrez2_dt_filter_Base -- |
| CEntrez2_eval_boolean | CEntrez2_eval_boolean -- |
| CEntrez2_eval_boolean_Base | When evaluating a boolean query the counts of hits is always returned |
| CEntrez2_field_id | CEntrez2_field_id -- |
| CEntrez2_field_id_Base | Field name |
| CEntrez2_field_info | CEntrez2_field_info -- |
| CEntrez2_field_info_Base | Info about one field |
| CEntrez2_get_links | CEntrez2_get_links -- |
| CEntrez2_get_links_Base | Request links of one type |
| CEntrez2_hier_node | CEntrez2_hier_node -- |
| CEntrez2_hier_node_Base | For hierarchical index |
| CEntrez2_hier_query | CEntrez2_hier_query -- |
| CEntrez2_hier_query_Base | CEntrez2_hier_query_Base -- |
| CEntrez2_id | CEntrez2_id -- |
| CEntrez2_id_Base | Single UID |
| CEntrez2_id_list | |
| CEntrez2_id_list_Base | List of record UIDs |
| CEntrez2_info | CEntrez2_info -- |
| CEntrez2_info_Base | Describes all the databases |
| CEntrez2_limits | CEntrez2_limits -- |
| CEntrez2_limits_Base | Date limits |
| CEntrez2_link_count | CEntrez2_link_count -- |
| CEntrez2_link_count_Base | Link count of one type |
| CEntrez2_link_count_list | CEntrez2_link_count_list -- |
| CEntrez2_link_count_list_Base | All links from 1 uid |
| CEntrez2_link_id | CEntrez2_link_id -- |
| CEntrez2_link_id_Base | Link name |
| CEntrez2_link_info | CEntrez2_link_info -- |
| CEntrez2_link_info_Base | Info about one link |
| CEntrez2_link_set | CEntrez2_link_set -- |
| CEntrez2_link_set_Base | Links are returned in sets also using OCTET STRINGS |
| CEntrez2_reply | CEntrez2_reply -- |
| CEntrez2_reply_Base | Replies from the Entrez server all replies contain the date/time stamp when they were executed to do reqular date bounded searches use this value+1 to search again later instead of recording the date/time on the client machine the cookie allows a simple key string to represent UID lists in the history |
| CEntrez2_request | CEntrez2_request -- |
| CEntrez2_request_Base | Entrez2 Request types |
| CEntrez2_term | CEntrez2_term -- |
| CEntrez2_term_Base | CEntrez2_term_Base -- |
| CEntrez2_term_list | CEntrez2_term_list -- |
| CEntrez2_term_list_Base | CEntrez2_term_list_Base -- |
| CEntrez2_term_pos | CEntrez2_term_pos -- |
| CEntrez2_term_pos_Base | Request portions of term list |
| CEntrez2_term_query | CEntrez2_term_query -- |
| CEntrez2_term_query_Base | CEntrez2_term_query_Base -- |
| CEntrez2Client | |
| CEntrez2Client_Base | CEntrez2Client_Base -- |
| CEntrez2ClientApp | |
| CEntrez_general | CEntrez_general -- |
| CEntrez_general_Base | CEntrez_general_Base -- |
| 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 | |
| CEntrezCreateProjectCommand | |
| CEntrezDB | CEntrezDB |
| CEntrezDB_Gene | |
| CEntrezDB_Genome | |
| CEntrezDB_GenomeProject | |
| CEntrezDB_NucProt | |
| CEntrezDBHandler | Derived class providing basic query functions |
| CEntrezDBManager | Manager for instances |
| CEntrezDBManager::SDbEntry | |
| 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 |
| CEntrezProjectUtils | CEntrezProjectUtils TODO - redesign This class is a temporary placeholder for functions loading data mining results into projects |
| CEntrezSearchForm | |
| CEntrezSearchJob | CEntrezSearchJob |
| CEntrezSearchQuery | CEntrezSearchTool |
| CEntrezSearchTool | CEntrezSearchTool |
| CEntryFormDialog | |
| CEntryFormMenu | |
| CEntryFormMenu::CMenuData | |
| CEnumDataType | |
| CEnumDataType::SEnumCInfo | |
| CEnumDataTypeValue | |
| CEnumeratedTypeInfo | |
| CEnumeratedTypeValues | |
| CEnumParser< TEnum > | |
| CEnumRefTypeStrings | |
| CEnumTypeStrings | |
| pythonpp::CEnvironmentError | |
| CEnvironmentRegistry | CEnvironmentRegistry -- |
| pythonpp::CEOFError | |
| CEofException | |
| 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 | |
| CErrorDisplay | |
| 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 | |
| CEventProc | CEventProc converts FLTK events to simple semantic statuses/signals |
| CEventProc::IAction | And this interface .. |
| CEventProc::IConversion | This interface .. |
| CEventProc::ITransition | This interface .. |
| CEventProc::SStatus | |
| 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 -- |
| CExecPlugin | |
| CExecute | |
| CExitThreadException | |
| CExon | |
| CExon_params | CExon_params -- |
| CExon_params_Base | CExon_params_Base -- |
| CExonParameters | |
| CExpectedError | |
| CExprParser | |
| CExprParserException | |
| CExprSymbol | |
| CExprValue | |
| CExtensionDeclaration | CExtensionDeclaration - static declaration helper |
| CExtensionPoint | CExtensionPoint - default implementation of IExtensionPoint |
| CExtensionPointDeclaration | CExtensionPointDeclaration - static declaration helper |
| CExtensionRegistry | CExtensionRegistry |
| CExternal | |
| CExternalPluginInit | |
| 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 | |
| pythonpp::CExtType | |
| CFactory< T > | |
| oligofar::CFaDiceApp | |
| CFastaAlignmentBuilder | Helper class to build pairwise alignments, with double gaps automatically spliced out |
| CFastaBioseqSource | |
| CFastaExtractor | Extracts the FASTA for a given sequence id (CSeqFormatter associates this with f) |
| CFastaFileSet | |
| CFastaIOWrapper | |
| CFastaMapper | |
| CFastaOstream | FASTA-format output; see also ReadFasta in <objtools/readers/fasta.hpp> |
| CFastaProcess | |
| CFastaReader | Base class for reading FASTA sequences |
| CFastaReader::SGap | |
| CFastaTextDisplay | |
| CFastaTextDS | |
| 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 |
| CFeatConfigDecorate | CFeatConfigDecorate - What decorations should be applied to a given feature type? |
| CFeatConfigDecorateWrite | |
| CFeatConfigShow | |
| CFeatConfigValues< V > | Template for configured values, indexed by feature type and subtype where values can inherit from master feature types |
| CFeatConfigValues< V >::CFeatConfigValue | |
| CFeatDecorations | All the information on how to decorate the rendering of a particular feature |
| 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 | |
| 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 |
| CFeatTablePreferenceDialog | |
| CFeatTableWidget | CFeatTableWidget |
| CFeature_evidence | CFeature_evidence -- |
| CFeature_evidence_Base | CFeature_evidence_Base -- |
| CFeature_table_reader | |
| CFeature_table_reader_imp | |
| CFeatureConfigParams | File Description: configuration class for everything needed to render a single feature |
| CFeatureDescr | CFeatureDescr -- |
| CFeatureDescr_Base | CFeatureDescr_Base -- |
| CFeatureDictSet | CFeatureDictSet -- |
| CFeatureDictSet_Base | CFeatureDictSet_Base -- |
| CFeatureGatherer | |
| CFeatureGraph | CFeatureGraph - a graph that displays features in alignment |
| CFeatureGraphProperties | CFeatureGraphProperties |
| CFeatureItem | |
| CFeatureItemBase | |
| CFeatureLoadingJob | CFeatureLoadingJob |
| CFeatureLoadingJobResult | CFeatureLoadingJobResult |
| CFeatureSearchForm | |
| CFeatureSearchJob | CFeatureSearchJob |
| CFeatureSearchQuery | CFeatureSearchTool |
| CFeatureSearchTool | CFeatureSearchTool |
| CFeaturesPanelIR | |
| 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_Base | CFeedbackWizard_Base provides each page in the feedback wizard with standard support for the reporting interface |
| CFeedbackWizard_Finish | CFeedbackWizard_Finish displays an accept and submit button |
| CFeedbackWizard_Intro | CFeedbackWizard_Intro offers a simple welcome message |
| CFeedbackWizard_Privacy | CFeedbackWizard_Privacy displays a privacy statement |
| CFeedbackWizard_Report | CFeedbackWizard_Report contains user input fields for the actual report |
| CFeedbackWizard_System | CFeedbackWizard_System allows users to display and edit system information |
| 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 |
| 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 | |
| CFileLock | File locking |
| CFileModules | |
| CFileName | CFileName -- |
| 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 -- |
|