| ►Naaa | |
| CA | |
| ►Naaaa | |
| ►Nbbbb | |
| CBBBB | |
| CBBBB_not_binded | |
| ►Ncccc | |
| CCCCC | |
| CT | |
| CAAAA | |
| ►Napps | |
| ►Npilot | |
| ►Nfrankdt | |
| Cconcatenate_poses | Concatenates poses together end-to-end while transforming them to avoid chainbreaks |
| CSmartSEWINGTester | Testing app for SEWING file IO |
| Csteric_fusion_scan | Concatenates poses together end-to-end while transforming them to avoid chainbreaks |
| CMakeSegmentFile | App to make segment files |
| Csegment_file_generator | Generator of smart sewing segment files |
| CSecondaryStruct | |
| CMotif | |
| ►Nmomeara | |
| CHBondConformation | |
| CKicSandbox | |
| CAlignChunkMover | |
| CMultiTemplateAlignChunkMover | |
| CCustomStarTreeMover | |
| CCustomFragmentMover | A Mover that insert fragments to the loop region |
| CHelixMover | |
| CSampleSecondaryStructureAlignmentMover | |
| ►Narls_impl | |
| CPreformattedDescFormatter | |
| CDockingCase | |
| CDockingFile | |
| ►Nbasic | Tags used to tag messeges sent by MPI functions used to decide whether a slave is requesting a new job id or flagging as job as being a bad input |
| ►Ncitation_manager | |
| CAuthorNames | Data structure for author names |
| CCitation | Data structure for storing a citation |
| CCitationCollection | A class for keeping track of a collection of citations for a particular Rosetta module |
| CCitationCollectionBase | Base structure for storing a citation. This is a base class for vitual inheritance. There's not much it actually does itself. Its main purpose is to allow us to put both CitationCollections and UnpublishedModuleInfos into the same list |
| CCitationCollectionList | A collection of CitationCollectionBases |
| CCitationManager | A class that receives lists of works to cite from Rosetta modules, then returns a list of all works to cite on demand. Threadsafe |
| CUnpublishedModuleAuthor | Authorship information for a single author in an unpublished Rosetta module |
| CUnpublishedModuleInfo | Authorship information for an unpublished Rosetta module |
| ►Ndatabase | |
| ►Ninsert_statement_generator | |
| CInsertGenerator | |
| CRowData | |
| CRowDataBase | |
| ►Nschema_generator | |
| CColumn | |
| CConstraint | |
| CUniqueConstraint | |
| CGreaterThanConstraint | |
| CDbDataType | |
| CDbText | |
| CDbTextKey | |
| CDbInteger | |
| CDbBigInt | DOES NOT WORK WITH CPPDB - USE INTEGER INSTEAD /boolean data type |
| CDbDouble | |
| CDbReal | |
| CDbUUID | |
| CForeignKey | |
| CIndex | |
| CPrimaryKey | |
| CSchema | |
| ►Ndatacache | |
| CBasicDataCache | A DataCache storing objects derived from basic::datacache::CacheableData |
| CCacheableData | Base class for data storable within a DataCache |
| CResRotPair | |
| CResRotPairHasher | |
| CCacheableResRotPairFloatMap | Wrapper for std::map< uint64_t, MathMatrix<float> > |
| CCacheableString | Wrapper for std::string |
| CCacheableStringFloatMap | Wrapper for std::map< std::string, float > |
| CCacheableStringIntegerMap | Wrapper for std::map< std::string, integer > |
| CCacheableStringMap | Wrapper for a map< string, string > |
| CCacheableUint64MathMatrixFloatMap | Wrapper for std::map< uint64_t, MathMatrix<float> > |
| CConstDataMap | General-purpose store for any kind of object with the particular copy semantics of copying by value. This is effectively a map of string pairs to (constant) pointers. The first string represents the category of the object, and the second being a name for that particular object. The guarantee with the ConstDataMap is that if an object is put into the map, it may be read from, but it will not be changed underneath you. Data stored in the ConstDataMap can safely be shared between threads |
| CDataCache | Forward declaration for DataCache |
| CDataCache_CacheableData | |
| CDataMap | General-purpose store for any reference-count derived object |
| CDataMapObj | Templated class to make any data type compatible with VirtualBase and OPs. e.g., utility::pointer::owning_ptr< basic::datacache::DataMapObj< bool > > stop; You can then place such constructs on the basic::datacache::DataMap |
| CDiagnosticData | Wrapper for std::map<string, Real> |
| CHierarchicalDataMap | A data map designed to help create hierarchies with complicated shared data requirements |
| CWriteableCacheableData | Base class for data storable within a DataCache |
| CWriteableCacheableDataCreator | Abstract base class for a Mover factory; the Creator class is responsible for creating a particular mover class |
| CWriteableCacheableDataRegistrator | This templated class will register an instance of an WriteableCacheableDataCreator (class T) with the WriteableCacheableDataFactory. It will ensure that no WriteableCacheableDataCreator is registered twice, and, centralizes this registration logic so that thread safety issues can be handled in one place |
| CWriteableCacheableDataFactory | |
| CWriteableCacheableMap | Wrapper for a map< string, string > |
| ►Ngpu | |
| Cfloat4 | |
| CTimer | |
| ►Nmpi | |
| CDbMoverMessageListener | |
| CMessageListener | |
| CMessageListenerFactory | |
| ►Nrandom | |
| CRandomGeneratorSettings | A class to store settings from the options system for the random generator. Moved from core to basic |
| ►Nresource_manager | |
| ►Nlocator | |
| CDatabaseResourceLocator | The DatabaseResourceLocator class is responsible for retreiving data from a Database so that that data can then be used to construct a Resource |
| CDatabaseResourceLocatorCreator | Creator for the DatabaseResourceLocator class |
| CFileListResourceLocator | The FileListResourceLocator concatenates a set of listed files; e.g. useful for constructing a pose from two separate PDB files |
| CFileListResourceLocatorCreator | Creator for the FileSystemResourceLocator class |
| CFileStream | FileStream is a wrapper class for a utility::io::izstream object that derives from ResourceStream |
| CFileSystemResourceLocator | The FileSystemResourceLocator is responsible for opening a file from the file system given its name (as the "locator tag" in the locate_resource_stream method ) and returning a FileStream object that wraps this file. This FileStream can then be used to construct a resource |
| CFileSystemResourceLocatorCreator | Creator for the FileSystemResourceLocator class |
| CNullStream | The NullStream acts as an empty stream object that may be returned by the NullResourceLocator. It does not open any files |
| CNullResourceLocator | The NullResourceLocator is meant for cases where a resource can be created without reading from an input file. It goes through the motions of returning a ResourceStream (an empty NullStream) as is required of all ResourceLocators, but the stream that it creates will not be used |
| CNullResourceLocatorCreator | Creator for the NullResourceLocator class |
| CStringResourceStream | The StringResourceStream is a wrapper class for a std::stringstream that can be used to construct a resource. Useful when reading the resource stream in to memory (e.g. from a database or from multiple files) before trying to construct the resource |
| CResourceLoader | The ResourceLoader is responsible for instantiating a Resource object and initializing it. In order to do so, the ResourceLoader is given an input stream and a XML "Tag" object. The ResourceLoader can also request other Resources from the ResourceManager in trying to construct a particular resource |
| CResourceLoaderCreator | Instantiates a ResourceLoader as part of the ResourceLoaderFactory scheme. Derived classes should be registered with the ResourceLoaderFactory in one of the library init.cc files with a ResourceLoaderRegistrator |
| CResourceLoaderFactory | Instantiates ResourceLoaders. Creators may be registered with the Factory at any point, though it is recommended they be registered at load time. If two Creators are registered and they both give the same name for the ResourceLoader they say they will instantiate, then the Factory will exit with an error message |
| CResourceLoaderRegistrator | The ResourceLoaderRegistrator class is a simple templated registration class that will, at construction, create a ResourceLoader and register it with the ResouceLoaderFactory |
| CResourceStream | The ResourceStream represents an abstract class for packaging up a standard istream so that data that the ResourceLocator needs to deliver to a ResourceLoader can come from arbitrary sources (e.g. from either a file or from a database) |
| CResourceLocator | ResourceLocator classes are responsible for retrieving data from a data store that will be used to construct a Resource. This data store could be a file system or a database or any other place where data is stored |
| CResourceLocatorCreator | The ResourceLocatorCreator class serves to link the name of a locator type and the (derived) ResourceLocator class that's responsible for retrieving data from a data store |
| CResourceLocatorFactory | The ResourceLocatorFactory instantiates ResourceLocator objects given their corresponding locator-type strings. It uses the load-time factory registration scheme, meaning that it is a singleton and takes an instance of a Creator object (a ResourceLocatorCreator) in its "factory_register" method. Templated instances of the ResourceLocatorRegistrator classes should be placed in the library init.cc files (e.g. core/init/init.cc or protocols/init/init.ResourceLocatorRegistrators.ihh) |
| CResourceLocatorRegistrator | The ResourceLocatorRegistrator gives an instance of a ResourceLocatorCreator to the ResourceLocatorFactory in its constructor, calling the ResourceLocatorFactory's factory_register() method. This call is actually accomplished by the WidgetRegistrator parent class. A single (templated) instance of this class for each ResourceLocatorCreator should be placed in the appropriate init.cc file (i.e. ResourceLocatorCreators that live in the protocols library should be put in src/protocols/init/init.ResourceLocatorRegistrators.ihh) |
| CResourceManager | |
| CResourceManagerCreator | Derived classes will be used by the ResourceManagerFactory to decide which of the various ResourceManagers should be instantiated. The ResourceManager is a singleton, but, different ResourceManagers can be instantiated in different contexts |
| CResourceManagerFactory | A factory class for managing the instantiation of the singleton ResourceManager: only one of the various derived classes will be instantiated. Currently, it asks for the JD2ResourceManager; in the future, this should be fixed so that it reads from the options system to figure out which ResourceManager to instantiate |
| CResourceManagerRegistrator | The ResourceManagerRegistrator creates an instantiate of the templated ResourceManagerCreator class and gives it to the ResourceManagerFactory. A single instance for each ResourceManagerCreator should be put in the appropriate init.cc file |
| ►Nsampling | |
| ►Norientations | |
| CQuaternion | |
| CQuatSet | |
| CTriple | |
| CPermute | |
| CQuaternionGrid | |
| CQuatDBMetadata | |
| CQuaternionGridManager | |
| ►Nsvd | |
| CSVD_Solver | |
| ►Ntensorflow_manager | |
| CRosettaTensorflowManager | A manager class for loading Tensorflow sessions and controlling mapping to the CPU or GPU |
| CRosettaTensorflowProtocolBase | A pure virtual base class for storing Tensorflow sessions and the code for executing them and returning a result. Derived classes will be protocol-specific, and will accept a RosettaTensorflowInput and produce a RosettaTensorflowOutput |
| CRosettaTensorflowTensorContainer | |
| CTFDataTypeDetector | |
| CTFDataTypeDetector< float > | |
| CTFDataTypeDetector< double > | |
| CTFDataTypeDetector< bool > | |
| CTFDataTypeDetector< int > | |
| CTFDataTypeDetector< unsigned int > | |
| CTFDataTypeDetector< long int > | |
| CTFDataTypeDetector< unsigned long int > | |
| ►Nthread_manager | |
| CRosettaThreadAllocation | |
| CRosettaThreadAssignmentInfo | |
| CRosettaThreadManager | A manager that maintains a threadpool and handles requests for threads for multithreaded execution of functions. This allows multithreading at many different levels in the Rosetta library hierarchy, from job-level parallel execution down to parallel computation of a score, gradient vector, or interaction graph |
| CRosettaThreadManagerAdvancedAPIKey | A class containing no private member data and only a constructor as a private member function, with friendship to only those classes that should be able to access the advanced RosettaThreadManager API. Since the advanced API requires an instance of a RosettaThreadManagerAdvancedAPIKey, this ensures that only those classes can access the advanced API |
| CRosettaThreadManagerInitializationTracker | A singleton that tracks whether we have already launched threads or not |
| CComparingTracer | |
| CEmitter | Lightweight class to ease writting YAML documents (http://yaml.org) |
| CYamlEmitter | Emitter for more classically formatted YAML |
| CJsonEmitter | Lightweight class to ease writting JSON documents, a subset of YAML (http://json.org) |
| CExecutionResult | Struct that hold result code + output of external process |
| CMemTracerImpl | |
| CMemTracer | |
| CMetricValueBase | |
| CMetricValue | |
| CProfileThis | |
| CDynamicProfileThis | |
| CReport | Data class to hold Report information. Use Reporter class for write access |
| CReporter | Proxy class to access Reporter class though OP. Allow null OP on init (all reporter function in this case do nothing) |
| ►CTracer | Class for handling user debug/warnings/errors. Use instance of this class instead of 'std::cout' for all your regular io. Channel argument must be related to the location of the source file. For example if you create Tracer object in src/basic/scoring/myfile.cc, then channel must be something like 'basic.scoring.myfile' |
| CTracerProxy | |
| CPyTracer | Special PyRosetta friendly Tracer like buffer. Use it to capture Tracer output with set_ios_hook |
| ►Cbasic_otstream | Base class for TracerImpl, TracerProxyImpl and UTracer objects |
| Cbasic_tstringbuf | Inner class declaration |
| CTracerOptions | Data structure to store all system level options for Tracer system |
| ►CTracerImpl | Class for handling user debug/warnings/errors. Use instance of this class instead of 'std::cout' for all your regular io. Channel argument must be related to the location of the source file. For example if you create Tracer object in src/basic/scoring/myfile.cc, then channel must be something like 'src.basic.scoring.myfile' |
| CTracerProxyImpl | Small inner class acting as a proxy to an object that hold it |
| CTracerToFile | |
| ►Nbbb | |
| CB | |
| ►Nbbbb | |
| ►Ncccc | |
| CC | |
| CB | |
| CB2 | |
| ►Nbinder | |
| CIncludeSet | |
| CBinder | Bindings Generator - represent object that can generate binding info for function, class, enum or data variable |
| CConstructorBindingInfo | |
| CClassBinder | |
| CConfig | |
| CContext | Context - root, hold bindings info for whole TranslationUnit |
| CEnumBinder | |
| CFunctionBinder | |
| Cvector_binder | |
| Cmap_binder | |
| ►Nboost | |
| Cunordered_object_pool | |
| ►Ncore | |
| ►Npack | |
| ►Nannealer | |
| CFixbbSimAnnealer | |
| ►Ncreate_a3b_hbs | |
| CA3BHbsCreatorMover | |
| ►Ndetail | |
| ►Ndragonbox | |
| Ccache_accessor | |
| Ccache_accessor< float > | |
| Ccache_accessor< double > | |
| Cfloat_info | |
| Cfloat_info< float > | |
| Cfloat_info< double > | |
| Cdecimal_fp | |
| Cchrono_format_checker | |
| Cmake_unsigned_or_unchanged | |
| Cmake_unsigned_or_unchanged< T, true > | |
| Cchrono_formatter | |
| ►Ccolor_type | |
| Ccolor_union | |
| Cansi_color_escape | |
| Ccompiled_string | |
| Cis_compiled_string | |
| ►Cformat_part | |
| Creplacement | |
| Cvalue | |
| Cpart_counter | |
| Cformat_string_compiler | |
| Cbasic_compiled_format | |
| Ccompiled_format_base | |
| Cformat_part_array | |
| Ccompiled_format_base< S, enable_if_t< is_compile_string< S >::value > > | |
| Ccompiled_format | |
| Cstd_string_view | |
| Cint128_t | |
| Cuint128_t | |
| Cis_string | |
| Cchar_t_impl | |
| Cchar_t_impl< S, enable_if_t< is_string< S >::value > > | |
| Cerror_handler | |
| Cbuffer | |
| Cbuffer_traits | |
| Cfixed_buffer_traits | |
| Citerator_buffer | |
| Citerator_buffer< T *, T > | |
| Citerator_buffer< std::back_insert_iterator< Container >, enable_if_t< is_contiguous< Container >::value, typename Container::value_type > > | |
| Ccounting_buffer | |
| Cbuffer_appender | |
| Cfallback_formatter | |
| Cview | |
| Cnamed_arg | |
| Cnamed_arg_info | |
| Carg_data | |
| Carg_data< T, Char, NUM_ARGS, 0 > | |
| Cis_named_arg | |
| Cis_named_arg< named_arg< Char, T > > | |
| Ctype_constant | |
| Cstring_value | |
| Cnamed_arg_value | |
| Ccustom_value | |
| Cvalue | |
| Cunformattable | |
| Carg_mapper | |
| Cvoid_t_impl | |
| Cis_output_iterator | |
| Cis_output_iterator< It, T, void_t< typename std::iterator_traits< It >::iterator_category, decltype(*std::declval< It >()=std::declval< T >())> > | |
| Cis_back_insert_iterator | |
| Cis_back_insert_iterator< std::back_insert_iterator< Container > > | |
| Cis_contiguous_back_insert_iterator | |
| Cis_contiguous_back_insert_iterator< std::back_insert_iterator< Container > > | |
| Cis_contiguous_back_insert_iterator< buffer_appender< Char > > | |
| Clocale_ref | |
| Cis_reference_wrapper | |
| Cis_reference_wrapper< std::reference_wrapper< T > > | |
| ►Cdynamic_arg_list | |
| Cnode | |
| Ctyped_node | |
| Cbits | |
| Cboundaries | |
| Cfp | |
| Caccumulator | |
| Cbigint | |
| Cfixed_handler | |
| Cstringifier | |
| Cfallback_uintptr | |
| ►Ccounting_iterator | |
| Cvalue_type | |
| Ctruncating_iterator_base | |
| Ctruncating_iterator | |
| Ctruncating_iterator< OutputIt, std::false_type > | |
| Ctruncating_iterator< OutputIt, std::true_type > | |
| Cuint128_wrapper | |
| Cdivtest_table_entry | |
| Cbasic_data | |
| Cdata | |
| Cformat_decimal_result | |
| Cutf8_to_utf16 | |
| Cnull | |
| Cfill_t | |
| Cfloat_specs | |
| Cint_type_checker | |
| Cchar_specs_checker | |
| Ccstring_type_checker | |
| Cwrite_int_data | |
| Cint_writer | |
| Cbig_decimal_fp | |
| Cis_integral | |
| Cis_integral< int128_t > | |
| Cis_integral< uint128_t > | |
| Cdefault_arg_formatter | |
| ►Carg_formatter_base | |
| Cchar_spec_handler | |
| Ccstring_spec_handler | |
| Carg_formatter | |
| Ccustom_formatter | |
| Cwidth_checker | |
| Cprecision_checker | |
| Cspecs_setter | |
| Cnumeric_specs_checker | |
| Cspecs_checker | |
| Cauto_id | |
| Cspecs_handler | |
| ►Carg_ref | |
| Cvalue | |
| Cdynamic_format_specs | |
| Cdynamic_specs_handler | |
| Cwidth_adapter | |
| Cprecision_adapter | |
| Cid_adapter | |
| Cformat_handler | |
| Ccompile_parse_context | |
| Cformat_string_checker | |
| Cformatbuf | |
| Cconverter | |
| Ctest_stream | |
| Cis_streamable | |
| Cfallback_formatter< T, Char, enable_if_t< is_streamable< T, Char >::value > > | |
| Cint_checker | |
| Cint_checker< true > | |
| Cprintf_precision_handler | |
| Cis_zero_int | |
| Cmake_unsigned_or_bool | |
| Cmake_unsigned_or_bool< bool > | |
| Carg_converter | |
| Cchar_converter | |
| Cget_cstring | |
| Cprintf_width_handler | |
| Cis_like_std_string | Return true value if T has std::string interface, like std::string_view |
| Cis_like_std_string< fmt::basic_string_view< Char > > | |
| Cconditional_helper | |
| Cis_range_ | |
| Cis_range_< T, conditional_t< false, conditional_helper< decltype(std::declval< T >().begin()), decltype(std::declval< T >().end())>, void > > | |
| Cis_tuple_like_ | Tuple_size and tuple_element check |
| Cinteger_sequence | |
| Cmake_integer_sequence | |
| Cmake_integer_sequence< T, 0, Ns... > | |
| ►Nenumerate_junctions | |
| CComponent | |
| CDesign | |
| CDHR | |
| CJunction | |
| ►Nerraser_option | |
| Cerraser_option | |
| ►Nerraser_util | |
| CErraserError | |
| ►Nez_setup | |
| CContextualZipFile | |
| ►Njob_manager | |
| CAppWindow | |
| CDatabaseWindow | |
| CJobWindow | |
| CCommandWindow | |
| CCommandRunner | |
| CStatusWindow | |
| CMoveStatsWindow | |
| CCommandManager | |
| CCommandLauncher | |
| CDeleteJob | |
| CWipeCache | |
| CScoreVsRmsd | |
| CScoreVsTime | |
| CTorsionVsTime | |
| CCorrelationTime | |
| CSaveMovie | |
| ►Nkic_runner | |
| CParseIterations | |
| ►Nlocal | |
| CHbondInfo | |
| ►Nmutant_modeler | |
| CMutantModeler | |
| ►Nmyspace | |
| CDataStruct | |
| CEvaluator | |
| CScheduler | |
| CDatumStruct | |
| CDataClass | |
| CInputData | |
| CGraftTester | |
| ►Nn1 | |
| ►Nn2 | |
| CA | |
| CA | |
| ►Nnacl_rosetta | |
| CRosettaURLFileHandler | |
| CRosettaInstance | |
| CRosettaModule | |
| ►Nnumeric | Unit headers |
| ►Nalignment | |
| CQCPKernel | |
| Crmsd_calc | |
| ►Ncoordinate_fitting | |
| CCoordinateArray_RMSD_FlatLookup | |
| CFlatLookup | |
| ►Nexpression_parser | |
| CToken | |
| CLiteralToken | |
| CVariableToken | |
| CFunctionToken | |
| CSimpleToken | |
| CTokenSet | |
| CArithmeticScanner | |
| CBooleanExpressionScanner | |
| CArithmeticASTNode | Base class for Abstract Syntax Tree (AST) for the simple Arithmetic language defined here |
| CArithmeticASTExpression | |
| CArithmeticASTFunction | |
| CArithmeticASTTerm | |
| CArithmeticASTFactor | |
| CArithmeticASTOrClause | |
| CArithmeticASTAndClause | |
| CArithmeticASTValue | Either a variable or a literal |
| CArithmeticASTRestTerm | |
| CArithmeticASTRestOrClause | |
| CArithmeticASTRestAndClause | |
| CArithmeticASTRestExpression | |
| CASTVisitor | Double-dispatch visitor pattern for abstract syntax tree |
| CASTPrinter | Traverse the AST and print it to standard out |
| CExpressionCreator | Class to traverse the abstract syntax tree produced by the parsing of a properly-formed string in the Arithmetic expression language. Produces an Expression tree capable of performing arithmetic. Connects the "variable" nodes in this tree to the owning WrapperOptEMultifunc so that their values can be retrieved during expression evaluation inside the WrapperOptEMultifunc functor |
| CSimpleExpressionCreator | |
| CBooleanExpressionCreator | |
| CExpression | Pure virtual base class to define arbitrary expressions for scripting arithmetic operations (e.g. addition and multipliction) |
| CLiteralExpression | |
| CVariableExpression | |
| CUnaryExpression | |
| CBinaryExpression | |
| CNaryExpression | |
| CSquarerootExpression | |
| CAbsoluteValueExpression | |
| CAddExpression | |
| CSubtractExpression | |
| CMultiplyExpression | |
| CDivideExpression | |
| CMaxExpression | |
| CMinExpression | |
| CMetaMaxExpression | Evaluates ee1 when e1 is larger than e2; evaluates ee2 otherwise |
| CMetaMinExpression | Evaluates ee1 when e1 is less than e2; evaluates ee2 otherwise |
| CEqualsExpression | |
| CGT_Expression | Greater Than |
| CGTE_Expression | Greater Than or Equal To |
| CLT_Expression | Less Than |
| CLTE_Expression | Less Than or Equal To |
| CAndExpression | |
| COrExpression | |
| CNotExpression | |
| CITEExpression | |
| ►Nfourier | |
| Ckiss_fft_state | |
| Ckiss_dct_state | |
| Ckiss_fftsplit_state | |
| Ckiss_fftr_state | |
| Ckiss_fftnd_state | |
| Ckiss_fftndr_state | |
| CSO3coeffs | |
| CSHT | |
| ►Ngeometry | |
| ►Nhashing | |
| CMinimalClashHash | |
| Cbin_index_hasher | Small hashing struct with no private data; simply an algorithm to turn a 64-bit representation of a 6d voxel into an integer |
| CSixDOffsetTree | Returns a list of offsets corresponding to the bins in a hypershell with radius x |
| CSixDCoordinateBinner | Bin the six degrees of freedom that describe the downstream geometry of a hit. These degrees of freedom are, in order, the x, y and z coordinates of orientation atom3, and the phi, psi, and theta euler angles that describe the orientation of the coordinate frame at orientation atom 3. The binner is responsible for maintaining the lower corner of the 6-d space – the first two Euler angles wrap at 360; the third Euler angle, theta, does not wrap in the same way. See the comments for the bin6 method |
| CBall | |
| CCounter | |
| ►CxyzStripeHash | |
| Cconst_iterator | |
| Citer_base | |
| Cushort2 | |
| ►CxyzStripeHashWithMeta | |
| Cfloat4 | |
| Citer_base | |
| Cmeta_iterator | |
| Cushort2 | |
| Cxyz_iterator | |
| Cxyzmeta_iterator | |
| CxyzStripeHashWithMeta_float | |
| CBoundingBox | 3d axis aligned bounding box class |
| ►Nhistograms | |
| COneDHistogram | |
| CTwoDHistogram | |
| ►Ninterpolation | |
| ►Nspline | |
| CBicubicSpline | |
| Ccompare_interp_range | |
| Cinterp_range | |
| CCompoundInterpolator | |
| CCubicSpline | |
| CInterpolator | |
| CPolycubicSpline | |
| CPolycubicSpline< 1 > | |
| CPolycubicSpline< 2 > | |
| CPolycubicSplineBase | |
| CSimpleInterpolator | |
| COrderPoint | |
| CPoint | |
| CLinearFunction | |
| CSplineGenerator | |
| CTricubicSpline | |
| CHistogram | A histogram with fixed-width bins |
| CHistogramOP | |
| CHistogramCOP | |
| CHistogramAP | |
| CHistogramCAP | |
| CInterpolatedPotential | |
| CTempStruct | |
| CTempStruct< T, 1 > | |
| ►Nkdtree | |
| CHyperRectangle | |
| CKDNode | |
| CKDPoint | |
| CCompareKDPoints | |
| CKDPoint_MinDist | |
| CKDPointList | Class for keeping track of the closest N KDPoint objects by distance |
| CKDTree | |
| CWrappedPrimitive | |
| ►Nkinematic_closure | |
| Cp | |
| ►Nlinear_algebra | |
| CEllipseParameters | Container class for ellipse parameters |
| CGeneralizedEigenSolver | Solves generalized eigenvalue problems |
| ►Nmodel_quality | |
| CRmsData | RmsData is a class intended to replace the global rms_obj namespace from rosetta++. Initial implementation is with a singleton design pattern to mimic a global namespace from rosetta++ |
| ►Nnls | |
| Clm_control_struct | |
| Clm_status_struct | |
| ►Nrandom | |
| CDistributionSampler | |
| Cmt19937_RG | |
| CRandomGenerator | Random number generator system |
| CReservoirSampler | Simple container for keeping K random values |
| Cuniform_RG | Uniform random number generator |
| Cstandard_RG | Generator based on rand() < clib > function |
| CWeightedReservoirItem | |
| CWeightedReservoirSampler | |
| CWeightedSampler | |
| CClusterOptions | |
| CAgglomerativeHierarchicalClusterer | |
| CSingleLinkClusterer | |
| CAverageLinkClusterer | |
| CCompleteLinkClusterer | |
| CAxisRotationSampler | |
| CBodyPosition | Rigid body 3-D position/transform |
| CCalculatorParser | |
| CCalculator | |
| CClusteringTreeNode | |
| CCubicPolynomial | |
| CSplineParameters | SplineParameters is a simple struct for holding the cubic spline polynomials used in the etable to interpolate the lennard-jones attractive and LK-solvation terms to zero smoothly. These splines have exactly two knots to represent them, and the same x values are used for all the knots: thus the only parameters needed are the y values at the knots, and the second-derivatives for the polynomials at knots |
| CDiscreteIntervalEncodingTree | |
| ►CDietNode | |
| Csplit_tuple | |
| CEulerAngles | Euler angles 3-D orientation representation |
| CHomogeneousTransform | |
| CHomogeneousTransform_Double | |
| CColPointers | |
| CColsPointer | |
| CColVectors | |
| CRowPointers | |
| CRowsPointer | |
| CRowVectors | |
| CIntervalSet | |
| CIntervalSet_Double | |
| CIOTraits | Numerics input/output type traits |
| CIOTraits< short int > | Numerics input/output type traits short int specialization |
| CIOTraits< int > | Numerics input/output type traits int specialization |
| CIOTraits< long int > | : Numerics input/output type traits long int specialization |
| CIOTraits< unsigned short int > | : Numerics input/output type traits unsigned short int specialization |
| CIOTraits< unsigned int > | : Numerics input/output type traits unsigned int specialization |
| CIOTraits< unsigned long int > | Numerics input/output type traits unsigned long int specialization |
| CIOTraits< float > | Numerics input/output type traits float Specialization |
| CIOTraits< double > | Numerics input/output type traits double specialization |
| CIOTraits< long double > | Numerics input/output type traits long double specialization |
| CMathMatrix | |
| CMathNTensor | |
| CMathNTensorBase | |
| CMathTensor | |
| CMathVector | |
| CMultiDimensionalHistogram | Class for accumulating a histogram of one or more numeric variables |
| CNearestSelector | Nearest function selector class for R non-integer or T integer |
| CNearestSelector< R, T, true > | Nearest function selector class for R integer and T non-integer |
| CModSelector | Mod function selector class for non-integer types |
| CModSelector< T, true > | Mod function selector class for integer types |
| CModuloSelector | Modulo function selector class for non-integer types |
| CModuloSelector< T, true > | Modulo function selector class for integer types |
| CRemainderSelector | Remainder function selector class for non-integer types |
| CRemainderSelector< T, true > | Remainder function selector class for integer types |
| CFastRemainderSelector | Fast remainder function selector class for non-integer types |
| CFastRemainderSelector< T, true > | Fast remainder function selector class for integer types |
| CNumericTraits | NumericTraits: Numeric type traits |
| CNumericTraits< float > | NumericTraits: Numeric type traits float specialization |
| CNumericTraits< double > | NumericTraits: Numeric type traits double specialization |
| CNumericTraits< long double > | NumericTraits: Numeric type traits long double specialization |
| CPolynomial_1d | |
| CQuaternion | Unit quaternion 3-D orientation representation |
| CRocPoint | |
| CRocCurve | |
| CsphericalVector | SphericalVector: Fast spherical-coordinate numeric vector |
| Curs_Quat | |
| CUniformRotationSampler | |
| CVoxelArray | |
| CVoxelGrid | |
| CxyzMatrix | XyzMatrix: Fast 3x3 xyz matrix template |
| ►CxyzTransform | |
| CLine | |
| CPlane | |
| CXformHash32 | |
| CXformHash64 | |
| CXforms | |
| CPy_xyzTransform_double | |
| CxyzTriple | Fast (x,y,z)-coordinate vector container |
| CxyzVector | XyzVector: Fast (x,y,z)-coordinate numeric vector |
| ►NObjexxFCL | |
| ►Nformat | |
| CBite | |
| CSkip | |
| ►Ninternal | |
| CInitializerSentinel | InitializerSentinel: FArray Constructor Initializer Sentinel Class |
| CObserverGraph | ObserverGraph: Observer Graph Representation |
| CProxySentinel | ProxySentinel: FArray Constructor Proxy Sentinel Class |
| CFArrayTraits< numeric::xyzVector< T > > | Specialization for FArrayTraits, to allow reasonable default constructor in FArray context |
| Cbyte | Byte: One-Byte Integer |
| CCArray | CArray: Memory-Managed C Array Wrapper |
| CCArrayP | CArrayP: Memory-Managed C Array Wrapper Supporting Proxies |
| CChunk | Chunk: Contiguous Array for Use in ChunkVector |
| CChunkExponent | ChunkExponent: ChunkVector Exponent Wrapper for Function Disambiguation and Range Clipping |
| CChunkVector | ChunkVector: Chunk-Contiguous Vector for Fast Very Large Vectors |
| CCstring | Cstring: C String Wrapper |
| CDimension | Dimension: Dynamic Dimension |
| CDimensionExpression | DimensionExpression: DimensionExpression Interface Class |
| CDimensionExpressionCon | DimensionExpressionCon: Constant-Valued DimensionExpression |
| CDimensionExpressionCube | DimensionExpressionCube: DimensionExpression Cube Function |
| CDimensionExpressionDiv | DimensionExpressionDiv: DimensionExpression Binary Division |
| CDimensionExpressionMax | DimensionExpressionMax: DimensionExpression Binary Max Function |
| CDimensionExpressionMin | DimensionExpressionMin: DimensionExpression Binary Min Function |
| CDimensionExpressionMul | DimensionExpressionMul: DimensionExpression Binary Product |
| CDimensionExpressionPow | DimensionExpressionPow: DimensionExpression Power Function: expression1^expression2 |
| CDimensionExpressionRef | DimensionExpressionRef: Dimension Reference DimensionExpression |
| CDimensionExpressionSquare | DimensionExpressionSquare: DimensionExpression Square Function |
| CDimensionExpressionSub | DimensionExpressionSub: DimensionExpression Binary Subtraction |
| CDimensionExpressionSum | DimensionExpressionSum: DimensionExpression Binary Sum |
| CDynamicIndexRange | DynamicIndexRange: Dynamic Index Range |
| CFArray | FArray: Fortran-Compatible Array Hierarchy Abstract Base Class |
| CFArray1 | FArray1: Fortran-Compatible 1D Array Abstract Base Class |
| CFArray1D | FArray1D: Fortran-Compatible 1D Array |
| CFArray1P | FArray1P: Fortran-Compatible 1D Proxy Array |
| CFArray1A | FArray1A: Fortran-Compatible 1D Argument Array |
| CKeyFArray1D | KeyFArray1D: Key-Access Fortran-Compatible 1D Array |
| CFArray2 | FArray2: Fortran-Compatible 2D Array Abstract Base Class |
| CFArray2D | FArray2D: Fortran-Compatible 2D Array |
| CFArray2P | FArray2P: Fortran-Compatible 2D Proxy Array |
| CFArray2A | FArray2A: Fortran-Compatible 2D Argument Array |
| CKeyFArray2D | KeyFArray2D: Key-Access Fortran-Compatible 2D Array |
| CFArray3 | FArray3: Fortran-Compatible 3D Array Abstract Base Class |
| CFArray3D | FArray3D: Fortran-Compatible 3D Array |
| CFArray3P | FArray3P: Fortran-Compatible 3D Proxy Array |
| CFArray3A | FArray3A: Fortran-Compatible 3D Argument Array |
| CKeyFArray3D | KeyFArray3D: Key-Access Fortran-Compatible 3D Array |
| CFArray4 | FArray4: Fortran-Compatible 4D Array Abstract Base Class |
| CFArray4D | FArray4D: Fortran-Compatible 4D Array |
| CFArray4P | FArray4P: Fortran-Compatible 4D Proxy Array |
| CFArray4A | FArray4A: Fortran-Compatible 4D Argument Array |
| CKeyFArray4D | KeyFArray4D: Key-Access Fortran-Compatible 4D Array |
| CFArray5 | FArray5: Fortran-Compatible 5D Array Abstract Base Class |
| CFArray5D | FArray5D: Fortran-Compatible 5D Array |
| CFArray5P | FArray5P: Fortran-Compatible 5D Proxy Array |
| CFArray5A | FArray5A: Fortran-Compatible 5D Argument Array |
| CKeyFArray5D | KeyFArray5D: Key-Access Fortran-Compatible 5D Array |
| CFArray6 | FArray6: Fortran-Compatible 6D Array Abstract Base Class |
| CFArray6D | FArray6D: Fortran-Compatible 5D Array |
| CFArray6P | FArray6P: Fortran-Compatible 5D Proxy Array |
| CFArray6A | FArray6A: Fortran-Compatible 5D Argument Array |
| CKeyFArray6D | KeyFArray6D: Key-Access Fortran-Compatible 6D Array |
| CFArrayInitializer | FArrayInitializer: FArray Initializer Class Template |
| CFArraySection | FArraySection: Fortran-Compatible Array Section Proxy |
| CFArrayTraits | FArrayTraits: FArray Traits Template |
| CNearestSelector | Nearest function selector class for R non-integer or T integer |
| CNearestSelector< R, T, true > | Nearest function selector class for R integer and T non-integer |
| CModSelector | Mod function selector class for non-integer types |
| CModSelector< T, true > | Mod function selector class for integer types |
| CModuloSelector | Modulo function selector class for non-integer types |
| CModuloSelector< T, true > | Modulo function selector class for integer types |
| CRemainderSelector | Remainder function selector class for non-integer types |
| CRemainderSelector< T, true > | Remainder function selector class for integer types |
| CFastRemainderSelector | Fast remainder function selector class for non-integer types |
| CFastRemainderSelector< T, true > | Fast remainder function selector class for integer types |
| CFstring | Fstring: Fixed-Length Fortran-Compatible String |
| CFsubstring | Fsubstring: Fixed-Length Fortran-Compatible Substring |
| CIndexRange | IndexRange: Index Range Abstract Base Class |
| CObserver | Observer: Combined Subject + Observer Abstract Base Class |
| CObserverMulti | ObserverMulti: Combined Subject + Multi Observer Abstract Base Class |
| CObserverSingle | ObserverSingle: Combined Subject + Single Observer Abstract Base Class |
| CSetWrapper | SetWrapper: Insulating Wrapper of std::set That Can Be Forward Declared |
| CStar | Star: Sentinel for Assumed Size Array Upper Bound |
| CStaticIndexRange | StaticIndexRange: Static Index Range |
| CTypeTraits | TypeTraits: Type Traits Template |
| CTypeTraits< short int > | TypeTraits: Type Traits short int Specialization |
| CTypeTraits< int > | TypeTraits: Type Traits int Specialization |
| CTypeTraits< long int > | TypeTraits: Type Traits long int Specialization |
| CTypeTraits< unsigned short int > | TypeTraits: Type Traits unsigned short int Specialization |
| CTypeTraits< unsigned int > | TypeTraits: Type Traits unsigned int Specialization |
| CTypeTraits< unsigned long int > | TypeTraits: Type Traits unsigned long int Specialization |
| CTypeTraits< float > | TypeTraits: Type Traits float Specialization |
| CTypeTraits< double > | TypeTraits: Type Traits double Specialization |
| CTypeTraits< long double > | TypeTraits: Type Traits long double Specialization |
| Cubyte | Ubyte: One-Byte Integer |
| ►Noptions | |
| CKeepSameFile | |
| ►Noptions_class | |
| COption | |
| ►Nprotocols | Demo program for implementing loop relax + FA relax |
| ►Nabinitio | |
| CApplicationContext | |
| CCustomAbinitio | |
| CPcaEvaluator | |
| CShowViolation | |
| CComputeTotalDistCst | |
| CStage1Sampler | |
| CJumpSpecificAbrelax | Application level code for Abrelax, Foldconstraints and JumpingFoldconstraints |
| CApplication | |
| ►Nantibody | |
| ►Ndesign | |
| CAntibodyDesignMoverGenerator | Generates pre-configured general MoverOPs for use in AntibodyDesign and modeling Helper functions for setting up FoldTrees. Can set the generated mover to apply, which will include the needed FoldTree and any changing of typeset. FoldTree stuff will eventually be refactored in favor of the TopologyBroker/Environment system |
| ►Ntask_operations | |
| CAddFrameworkProfilesOperation | Add Framework Profiles as the task operation for a framework chain. See protocols/task_operations/ResidueProbTaskOperation for more |
| CAntibodyInfoRMLoaderCreator | |
| CAntibodyInfoRMOptions | |
| CAntibodyInfoRMOptionsCreator | |
| ►Njd2 | |
| CRECONMPIJobDistributor | |
| ►Njumping | |
| CLibraryJumpSetup | |
| CSpecificJumpSetup | |
| ►Nmoves | |
| CSimpleCstMover | |
| CFragCaptureMover | |
| ►Nsurface_docking | |
| CAntibodyInfoRMLoader | AntibodyInfoRMLoader constructs an AntibodyInfo instance from data provided by the resource manager |
| ►NPyMOL-Rosetta-relay-client | |
| CStartUpError | Exceptions |
| CPR_UDPServer | |
| CPR_PyMOLServer | |
| CXYZCoord | |
| CPlanePoints | |
| CMatrix | |
| CSecretInputDialog | |
| ►NPyMOL-RosettaServer | |
| CStartUpError | Exceptions |
| CPR_UDPServer | |
| CPR_PyMOLServer | |
| CXYZCoord | |
| CPlanePoints | |
| CMatrix | |
| ►Npyrosetta | |
| ►Nbindings | |
| ►Npose | |
| CPoseResidueAccessor | |
| CResidueLabelAccessor | |
| CPoseResidueLabelMaskAccessor | |
| CPoseResidueLabelAccessor | |
| CPoseScoreAccessor | |
| ►Nscores | |
| ►Nbase | |
| CClobberWarning | |
| CPoseCacheAccessorBase | |
| ►Ncore | |
| CPoseCacheAccessor | |
| ►Nenergies | |
| CEnergiesAccessor | |
| ►Nextra_scores | |
| CExtraScoresAccessorBase | |
| CExtraFloatScoresDataAccessor | |
| CExtraStringScoresDataAccessor | |
| CExtraScoresAccessor | |
| ►Nserialization | |
| CPoseScoreSerializerBase | |
| CPoseScoreSerializer | |
| ►Nsimple_metrics | |
| CSimpleMetricDataAccessorBase | |
| CSimpleMetricStringDataAccessor | |
| CSimpleMetricRealDataAccessor | |
| CSimpleMetricCompositeStringDataAccessor | |
| CSimpleMetricCompositeRealDataAccessor | |
| CSimpleMetricPerResidueStringDataAccessor | |
| CSimpleMetricPerResidueRealDataAccessor | |
| CSimpleMetricPerResidueProbabilitiesDataAccessor | |
| CSimpleMetricDataAccessor | |
| ►Ndistributed | |
| ►Ncluster | |
| ►Nbase | |
| CTaskBase | |
| ►Ncore | |
| CPyRosettaCluster | |
| ►Nexceptions | |
| CInputError | |
| CInputFileError | |
| COutputError | |
| CWorkerError | |
| ►Nio | |
| CIO | |
| ►Nlogging_filters | |
| CDefaultProtocolNameFilter | |
| CSetProtocolNameFilter | |
| CDefaultSocketAddressFilter | |
| CSetSocketAddressFilter | |
| CSocketAddressFilter | |
| CDefaultTaskIdFilter | |
| CSetTaskIdFilter | |
| ►Nlogging_handlers | |
| CHandlerMixin | |
| CMsgpackHmacSocketHandler | |
| CMultiSocketHandler | |
| ►Nlogging_listeners | |
| CLogRecordRequestHandler | |
| CMaskedBytes | |
| CSocketListener | |
| ►Nlogging_support | |
| CLoggingSupport | |
| ►Nserialization | |
| CSerialization | |
| ►Nutilities | |
| CSchedulerManager | |
| ►Nworker_plugins | |
| CSocketLoggerPlugin | |
| ►Ndocs | |
| CComponentDoc | |
| CInlineDocs | |
| CMoverDocs | |
| CFilterDocs | |
| ►Npacked_pose | |
| ►Ncore | |
| CPackedPose | |
| ►Ntasks | |
| ►Nrosetta_scripts | |
| CBaseRosettaScriptsTask | |
| CMultioutputRosettaScriptsTask | |
| CSingleoutputRosettaScriptsTask | |
| ►Nscore | |
| CScorePoseTask | |
| ►Ntaskbase | |
| CTaskBase | |
| ►Nutility | |
| ►Nlog | |
| Cclassproperty | |
| CLoggerMixin | |
| CProgressLogger | |
| CPlog | |
| CLoggingContext | |
| ►Nviewer | |
| ►Ncore | |
| CViewer | |
| CViewerInputError | |
| ►Nmodules | |
| CsetBackgroundColor | |
| CsetDisulfides | |
| CsetHydrogenBonds | |
| CsetHydrogens | |
| CsetStyle | |
| CsetSurface | |
| CsetZoom | |
| CsetZoomTo | |
| CViewerInputError | |
| ►Nio | |
| ►Nsilent_file_map | |
| CSilentFilePoseAccessor | |
| CSilentFileEnergyAccessor | |
| CSilentFileMap | |
| ►Nlogging_support | |
| CPythonLoggingSink | |
| ►Nnetwork | |
| ►Nrosetta_udp_to_tcp_bridge | |
| CStartUpError | |
| CPR_UDPServer | |
| ►Nprotocols | |
| ►Nh5_fragment_store_provider | |
| CH5PyFragmentStoreProvider | |
| ►Nh5_structure_store_provider | |
| CH5StructureStoreProvider | |
| ►Nstructure_search | |
| CStructureSearchManager | |
| ►NPyMOLRosettaServer | |
| CStartUpError | Exceptions |
| CPR_UDPServer | |
| CPR_PyMOLServer | |
| CXYZCoord | |
| CPlanePoints | |
| CMatrix | |
| ►Ntests | |
| ►Nbindings | |
| ►Ncore | |
| ►Ntest_pose | |
| CTestPoseResidueAccessor | |
| CTestPoseScoresAccessor | |
| CTestPoseCacheAccessor | |
| CTestPoseResidueLabelAccessor | |
| CTestPoseIO | |
| CTestPosesToSilent | |
| ►Ndistributed | |
| ►Ncluster | |
| ►Nskip_command_line_test | |
| CBasicTest | |
| ►Ntest_logging | |
| CLoggingTest | |
| ►Ntest_reproducibility | |
| CTestReproducibility | |
| CTestReproducibilityMulti | |
| ►Ntest_smoke | |
| CSmokeTest | |
| CSmokeTestMulti | |
| CSaveAllTest | |
| CSerializationTest | |
| CMultipleClientsTest | |
| CResourcesTest | |
| CScoresTest | |
| CTestBase | |
| CGeneratorTest | |
| CRuntimeTestLoggingFilter | |
| CRuntimeTest | |
| ►Ntest_concurrency | |
| CTestConcurrentScripts | |
| ►Ntest_dask | |
| CTestDaskDistribution | |
| ►Ntest_dask_worker | |
| CTestDaskArgs | |
| ►Ntest_gil | |
| CHeartBeat | |
| CTestGIL | |
| ►Ntest_smoke | |
| CSmokeTestDistributed | |
| ►Ntest_viewer | |
| CTestViewer | |
| ►Nnumeric | |
| ►Ntest_alignment | |
| CTestAlignment | |
| ►Nprotocols | |
| ►Nindexed_structure_store | |
| ►Ntest_search | |
| CTestStructureSearch | |
| ►Ntoolbox | |
| ►Npy_jobdistributor | |
| CPyJobDistributor | |
| CPyRosettaException | Exception handling |
| CPythonPyExitCallback | |
| CEnergyMethod | |
| ►Nrosetta_binders | |
| ►Nhas_insertion_operator_implementation | |
| Cany_type | |
| Chas_equal_operator_s | |
| Chas_equal_operator_s< T > | |
| Chas_equal_operator_s< std::vector< A > > | |
| Chas_equal_operator_s< std::set< A > > | |
| Chas_equal_operator_s< std::pair< A, B > > | |
| Chas_equal_operator_s< std::map< A, B > > | |
| Chas_equal_operator_s< utility::vector0< A > > | |
| Chas_equal_operator_s< utility::vector1< A > > | |
| Chas_insertion_operator_s | |
| Cutility_vector_binder | |
| ►Nschema | |
| CJob | |
| CMove | |
| CTemperature | |
| CTrajectory | |
| CNumpyCache | |
| ►Nself-test | |
| CNT | |
| ►Nsetup | |
| CPyRosettaDistribution | |
| ►Nsidechain_cst_3 | |
| CResidue | |
| CAtom | |
| ►Ntest | |
| ►NT007_TracerIO | |
| CMyPyTracer | |
| ►NT010_LoadPDB | |
| CLoadPDBTest | |
| ►NT121_core | |
| CTestResidueSelectors | |
| ►NT300_PyJobDistributor | |
| CTestPyJobDistributor | |
| ►NT850_SubClassing | |
| CPyValue | |
| CA | |
| CPyOverloadTest | |
| CMy_New_Mover | |
| CMyNewCI1B_Creator | |
| CMyNewCI1B | |
| ►NT860_SubClassing_EnergyMethods | |
| CMyCI1B_Method | |
| ►NT870_SubClassing_EnergyMethods2 | |
| CCI1B_Method | |
| CCI2B_Method | |
| CCD2B_Method | |
| ►NWorkshop9_my_shapes | |
| CMyShape | |
| CMyCircle | |
| CMySquare | |
| CPhiNByXDegreesMover | |
| CLengthScoreMethod | |
| CCI2BScoreMethod | |
| ►Ntesters | |
| Ctest_my_struct | |
| ►Nui | |
| ►Nconfig | |
| CConfigDialog | |
| CUserCredentials | Structure to hold user login+password |
| ►Nnetwork | |
| CIndexPack | |
| ►CBowmanModel | |
| CFunctionIdentifier | |
| CArgument | |
| CBooleanArgument | |
| CIntegerArgument | |
| CFloatArgument | |
| CStringArgument | |
| CPathArgument | |
| CFunctionID | |
| ►CBowman | |
| CBackEnd | |
| CB | |
| CBowmanThread | |
| CBowmanView | |
| CFunctionSetupDialog | |
| ►Ntask | |
| CPNode | Struct to help represent Project as tree. This is local datatype used only by ProjectModel |
| CProjectModel | |
| CFileID | |
| ►CFile | File node that hold concreate data with concreate file-name |
| CLessFileSP | |
| ►CFileTableModel | |
| CRow | |
| CFunctor | |
| CFunctorSequence | FunctorSequence is essentially a subroutine-like construct that allow you to call sequence of function one-by-one. It guarantee that the next in line function will be called only after all previous calls has finished |
| CFunctorASyncSequence | FunctorASyncSequence: same as FunctorSequence but start excution of all functors at once |
| CFunctorNetworkCall | |
| CJobSubmit | |
| CJobView | |
| CUpdater | |
| CNode | |
| CProject | |
| ►CProjectTasksModel | |
| CRow | |
| CProjectView | |
| ►CTask | |
| CJob | |
| CTaskCancelDialog | |
| CFileTableWatcher | |
| CTaskSubmit | |
| CTaskSyncer_NodeStrategy | |
| CTaskSyncer_TaskStrategy | |
| CTaskView | |
| CNetworkCall | |
| ►Nui_core | |
| ►Npose_draw | |
| CSimplePoseDrawOpenGLWidget | |
| ►Nui_protocols | |
| ►Nhelical_bundle | |
| CHelicalBundleDialogueWidget | |
| CHelicalBundlePoseDrawOpenGLWidget | |
| CHelixOptionWidget | |
| ►Nutil | |
| CBadFileFormatException | |
| ►CTreeNodeModel | |
| CNode | |
| ►Nviewers | |
| CScoreFileView | |
| ►Nwidgets | |
| CPoseEditor | |
| Cui_lib_test | |
| ►Nutility | Unresizable vector whose size is known at compile time, which may be allocated on the stack, and which indexes from 0 |
| ►Nexcn | |
| CException | |
| CIOError | |
| CBadInput | EXCN_BadInput, as an IO error, should only be used for bad user input. Do not use for something which is just bad function input |
| CFileNotFound | |
| CRangeError | |
| CKeyError | |
| CNullPointerError | |
| CUserCorrectableIssue | |
| CRosettaScriptsOptionError | |
| ►Nfactory | |
| CFactory | Pluggable factory |
| CRegistrant | Factory registrant |
| CWidgetFactory | Factory base class holds a map between strings and owning pointers of the creator classes |
| CWidgetRegistrator | This class will register a Creator with a Factory at load time |
| ►Nfile | |
| CFileName | File name class supporting Windows and UN*X/Linux format names |
| CPathName | Path name class supporting Windows and UN*X/Linux format names |
| ►Ngraph | |
| CArray0 | Class Array0 is a c-style array wrapper that does bounds checking in debug mode. It indexes from 0 just like regular c-arrays. Class Array0 does not manage it's own memory. It does not allocate memory if you want to make it larger, nor does it deallocate memory when you destroy it. Bounds checking only ensures that the user does not go outside of the memory Array0 thinks it's in charge of. If the user should happen to point the array0 at memory that has not been allocated, Array0 is not responsible for segmentation fault that will likely occur. Garbage in, garbage out |
| CNegSpaceElement | NegSpaceElement represents a single element in the singly-linked list of negative space in an array pool |
| CArrayPoolElement | |
| CArrayPool | |
| CEXCN_Stop_BFS | Class to raise to do an immediate stop of a breadth first search. ONLY THROW FROM WITHIN A VISITOR PASSED TO breadth_first_visit_prune/breadth_first_search_prune |
| Cnull_bfs_prune_visitor | |
| CHideVertexVisitor | |
| CDirectedEdgeListElement | An extensible directed graph class |
| CDirectedEdgeListIterator | Custom DirectedEdge list (non-const) iterator class, which can return non-const DirectedEdge pointers. This iterator cannot be used to change the structure of its list without access to that list directly. Customized since STL's const-iterator cannot be prevented from giving non-const access to its data. The former workaround to this problem was to define two sets of edge lists on each vertex: a list< DirectedEdge * > and a list< DirectedEdge const * > |
| CDirectedEdgeListConstIterator | Custom DirectedEdge list const iterator class, which returns only const DirectedEdge pointers. This iterator cannot be used to change the structure of its list without access to that list directly. Customized since STL's const-iterator cannot be prevented from giving non-const access to its data |
| CDirectedEdgeList | Custom edge list class. Returns const-iterators which only return DirectedEdge const *'s and non-const-iterators which can return either const or non-const DirectedEdge*'s. Manages its own memory using an unordered-object-pool for fast insertion and deletion of DirectedEdgeListElements. Implemented as a doubly linked list, though there's no practical way to start at the end of a list and work backward since decrementing the end iterator is not a valid operation |
| CDirectedNode | |
| CDirectedEdge | |
| CDigraph | A Digraph with constant time edge insertion and deletion. Extensible |
| CDS_Node | |
| CDisjointSets | |
| CEdgeListElement | An extensible graph class |
| CEdgeListIterator | Custom Edge list (non-const) iterator class, which can return non-const Edge pointers. This iterator cannot be used to change the structure of its list without access to that list directly. Customized since STL's const-iterator cannot be prevented from giving non-const access to its data. The former workaround to this problem was to define two sets of edge lists on each vertex: a list< Edge * > and a list< Edge const * > |
| CEdgeListConstIterator | Custom Edge list const iterator class, which returns only const Edge pointers. This iterator cannot be used to change the structure of its list without access to that list directly. Customized since STL's const-iterator cannot be prevented from giving non-const access to its data. The former workaround to this problem was to define two sets of edge lists on each vertex: a list< Edge * > and a list< Edge const * > |
| CEdgeList | Custom edge list class. Returns const-iterators which only return Edge const *'s and non-const-iterators which can return either const or non-const Edge*'s. Manages its own memory using an unordered-object-pool for fast insertion and deletion of EdgeListElements. Implemented as a doubly linked list, though there's no practical way to start at the end of a list and work backward since decrementing the end iterator is not a valid operation |
| CNode | |
| CEdge | |
| CGraph | A Graph with constant time edge insertion and deletion. Extensible |
| CLowMemGraph | A graph with low memory use and constant time edge insertion. Extensible. @detail For general use, use utility::graph::DefaultLowMemGraph |
| CLowMemEdgeListIter | Non-const iterator for edges |
| CLowMemEdgeListConstIter | Const iterator for edges |
| CLowMemNode | An Node class for LowMemGraph. Will often be overriden @detail Be careful with this class! It doesn't use actual virtual functions. Never do this: LowMemNodeOP op = MyDerivedNodeOP() Instead, if you wish to use an owning pointer, you must do this: MyDerivedNodeOP op = MyDerivedNodeOP() |
| CLowMemEdge | An Edge class for LowMemGraph. Will often be overriden. @detail Be careful with this class! It doesn't use actual virtual functions. Never do this: LowMemEdgeOP op = MyDerivedEdgeOP() Instead, if you wish to use an owning pointer, you must do this: MyDerivedEdgeOP op = MyDerivedEdgeOP() |
| CLowMemGraphBase | Pure virtual baseclass that was required to avoid templating Edges and Nodes |
| CRingSizeVisitor | A class to implement the behavior of the smallest ring size finding algorithm, accessible through the smallest_ring_size() function below |
| CRingEdgeAnnotationVisitor | |
| CRingDetection | Basic chemical Bond |
| CUEVertex | |
| CUEEdge | |
| CUpperEdgeGraph | |
| ►Nio | |
| ►Nmpi_stream | |
| Cbasic_mpi_streambuf | A stream decorator that takes raw input and zips it to a ostream |
| Cbasic_mpi_ostreambase | Base class for mpi ostreams |
| Cbasic_mpi_ostream | A mpiper ostream |
| CFileContentsMap | The FileContentsMap is a class that will minimize the number of times files are accessed from disk. The first time the contents of a file are requested, it will cache the contents the file in memory as a strings. All subsequent requests for the contents of that file will then be delivered without having to go to disk. WARNING: The FileContentsMap will not update the contents that it holds for a file after the first time it loads it, so if the contents change on disk, the FileContentsMap will be out of date |
| CGeneralFileContents | |
| CGeneralFileManager | |
| CGeneralFileContentsVector | |
| CGeneralFileManagerVector | |
| Cicstream | Icstream: Input channel stream wrapper class |
| Cirstream | Orstream: Input stream wrapper abstract base class |
| Cizstream | Izstream: Input file stream wrapper for uncompressed and compressed files |
| Cocstream | Ocstream: Output channel stream wrapper class |
| Corstream | Orstream: Output stream wrapper base class |
| Cozstream | Ozstream: Output file stream wrapper for uncompressed and compressed files |
| CTarFileHeader | |
| CTarParser | |
| ►Njson_spirit | |
| ►Ninternal_ | |
| CType_to_type | |
| CError_position | |
| CSemantic_actions | |
| ►CJson_grammer | |
| Cdefinition | |
| CMulti_pass_iters | |
| CStream_reader | |
| CStream_reader_thrower | |
| CNull | |
| ►CValue_impl | |
| CVariant_converter_visitor | |
| CPair_impl | |
| CConfig_vector | |
| CConfig_map | |
| CGenerator | |
| ►Nkeys | |
| ►Nlookup | |
| Chas | Key lookup has query functor |
| Ckey | Key lookup key query functor |
| Cbegin | Key lookup begin iterator functor |
| Cend | Key lookup end iterator functor |
| Cgen | Key lookup/generator functor |
| Cn_key | Key lookup n_key query functor |
| CAutoKey | Automatic hidden index key abstract base class |
| CClassKeyMap | Keyed-access map with key subset map for each client class |
| CClassKeyVector | Keyed-access vector with key subset map for each client class |
| CKey | Hidden index key interface class |
| CKey2Tuple | 2-tuple meta-key |
| CKey2Vector | 2-key meta-key |
| CKey3Tuple | 3-tuple meta-key |
| CKey3Vector | 3-key meta-key |
| CKey4Tuple | 4-tuple meta-key |
| CKey4Vector | 4-key meta-key |
| CKeyCount | Key counter functor |
| CKeyLess | Key member comparison functor template |
| CPointerKeyLess | Key member comparison functor template for pointers |
| CKeyLookup | Key lookup map and collection |
| CKeyMapTraits | KeyMap traits class |
| CKeySetTraits | KeySet traits class |
| CKeyVector | Keyed-access vector |
| CKeyVectorTraits | KeyVector traits class |
| CNoClient | Default key policy class when no client is needed to distinguish key type |
| CSmallKeyMap | Keyed-access map with key subset map |
| CSmallKeyVector | Keyed-access vector with key subset map |
| CUserKey | User-created hidden index key abstract base class |
| CVariantKey | Variant key class |
| ►Nlibsvm | |
| CSvm_node_rosetta | |
| CSvm_rosetta | |
| ►Noptions | |
| CAnyOption | Program any scalar-valued option abstract base class |
| CAnyVectorOption | Program any vector-valued option abstract base class |
| CBooleanOption | Program boolean option class |
| CBooleanVectorOption | Program boolean vector option class |
| CFileOption | Program file option class |
| CFileVectorOption | Program file vector option class |
| CIntegerOption | Program integer option class |
| CIntegerVectorOption | Program integer vector option class |
| CAnyOptionKey | Automatic hidden index key for any scalar-valued options |
| CAnyVectorOptionKey | Automatic hidden index key for any vector-valued options |
| CBooleanOptionKey | Automatic hidden index key for boolean options |
| CBooleanVectorOptionKey | Automatic hidden index key for boolean options |
| CFileOptionKey | Automatic hidden index key for file options |
| CFileVectorOptionKey | Automatic hidden index key for file options |
| CIntegerOptionKey | Automatic hidden index key for integer options |
| CIntegerVectorOptionKey | Automatic hidden index key for integer options |
| COptionKey | Abstract automatic hidden index key for options |
| CPathOptionKey | Automatic hidden index key for path options |
| CPathVectorOptionKey | Automatic hidden index key for path options |
| CRealOptionKey | Automatic hidden index key for real options |
| CRealVectorOptionKey | Automatic hidden index key for real options |
| CResidueChainVectorOptionKey | Automatic hidden index key for integer options |
| CScalarOptionKey | Abstract automatic hidden index key for scalar-valued options |
| CStringOptionKey | Automatic hidden index key for string options |
| CStringVectorOptionKey | Automatic hidden index key for string options |
| CVectorOptionKey | Abstract automatic hidden index key for vector-valued options |
| COption | Program option interface class |
| COptionCollection | Program options collection |
| CPathOption | Program path option class |
| CPathVectorOption | Program path vector option class |
| CRealOption | Program real option class |
| CRealVectorOption | Program real vector option class |
| CResidueChainVectorOption | Program integer vector option class |
| CScalarOption | Program scalar-valued option interface class |
| CScalarOption_T_ | Program scalar-valued option abstract base class |
| CStringOption | Program string option class |
| CStringVectorOption | Program string option class |
| CVariantOption | Variant option class |
| CVectorOption | Program vector-valued option interface class |
| CVectorOption_T_ | Program vector-valued option abstract base class |
| ►Npointer | |
| CDeepCopyOP | |
| ►Npy | |
| CValue | |
| CBase | |
| COverloadTest | |
| CPyExitCallback | This class for holding callback function |
| CCOP_to_Python_converter | |
| ►Nsignals | |
| CBufferedSignalHub | Forward declaration for SignalHub |
| CLink | Interface wrapper around utility::signals::LinkUnit |
| CLinkUnit | Struct specifying actual link data between observers and subjects |
| CIsLinkUnitInvalid | Struct useful as combined predicate + deallocation of function object contained inside a LinkUnit |
| CPausableSignalHub | Forward declaration for PausableSignalHub |
| CSignalHub | Forward declaration for SignalHub |
| CTokenHub | Forward declaration for TokenHub |
| ►Nsql_database | |
| Csession | |
| Ctransaction | |
| CDatabaseSessionManager | |
| CTransactionMode | |
| CDatabaseMode | |
| ►Ntag | |
| CTag | |
| CXMLSchemaComplexTypeGeneratorImpl | |
| CXMLSchemaType | Class XMLSchemaType represents the name of a defined type that can be used to describe either an XMLElement or an XMLAttribute. It may refer to either a complex type or to a primative type or to a simple type |
| CXMLSchemaTopLevelElement | The XMLSchemaTopLevelElement class signifies a class that could be written out as an XML element, with possible sub-elemets, in an XML schema. When generating a schema, the developer will hand an instance of a class derived from an XMLSchemaTopLevelElement to an XMLSchemaDefinition object |
| CXMLSchemaAttribute | Class XMLSchemaAttribute represents what we refer to in Rosetta as an option for a tag. An attribute would reside inside of a tag, such as "scorefxn" in this tag (this XML Element): <MinMover name="min" scorefxn="talaris2014"> |
| CXMLSchemaRestriction | Class XMLSchemaRestriction describes a refinement on the behavior of existing types. For example, one could define a restriction representing a list of residue indexes separating commas: "15,44,102" and then describe an attribute of a complex type as having to conform to that restriction. An xml-schema validator would be able to say that an input file with "fifteen,fortyfour,onehundredandtwo" did not meet the schema |
| CXMLSchemaParticle | This abstract class is meant to represent either an XMLSChemaElement or an XMLSchemaModelGroup so that the interchangable set of these objects in a ModelGroup can be represented. I may be misusing the term "particle" in the way that it is meant within XML Schema – so the mapping of this term to the term used in XML Schema is probably imperfect |
| CXMLSchemaModelGroup | The ModelGroup covers four XML Schema model groups: xs:sequence, xs:choice, xs:all, and xs:group. A ModelGroup may contain any number of XMLSchemaParticles, interchanging between XMLElements and XMLModelGroups, BUT there are some fairly heavy restrictions on the xs:all model group, marginally enforced by this class and by XMLSchemaComplexType. This class is not exactly a top-level element, in that only xs:group is allowed to appear at the top level, but it is definitely worthwhile for this class to implement the write_definition funciton |
| CXMLSchemaComplexType | Class XMLSchemaComplexType represents the definition of the type for an element – that is, the structure of a set of elements with the same name. If an XMLSchemaElement is analogous to a utility::tag::Tag, an XMLSchemaComplexType is analogous to the wiki page describing the valid format for an instance of that Tag |
| CXMLSchemaElement | An XMLSchema element, e.g. the FixbbMover "tag" <FixbbMover name="fixbb" task_operations="ex1,ex2"> or the And element which contains a sub-element: <And><Chain id="A"></And>. An element can be defined with an unnamed complex type in-line, or it can say that its type is that of a complex type defined elsewhere. (In XML naming a tag is a single block beginning with "<" and ending with ">", so both "<And>" and "</And>" are tags. The block between the opening and closing tags is called an element. The utility::tag::Tag class represents a complete Element, and not simply the opening or closing tag of an element. This is certainly confusing |
| CXMLSchemaDefinition | The XMLSchemaDefinition class's purpose is to collect all of the elements that go into an XML Schema, to filter out the elements that are repeated (e.g. a restriction such as the "int_cslist" given in the description for XMLSchemaRestriction above may be reported twice to the XMLSchemaDefinition by several attributes that rely upon it), to detect non-identical duplicates that have the same name, and to write out the elements that it has been handed into a single string. The XMLSchemaDefinition is intended to be passed between static functions / non-class-member functions as a container for the XML Schema representations that these functions define. Such functions will always take an XMLSchemaDefinition reference as one of their input parameters. It is perfectly legitimate / recommended for one XML-schema-defining function that relies on a complexType or restriction that it does not itself define to pass its input XMLSchemaDefinition to the function that does define that complexType or restriction |
| ►CXMLSchemaSimpleSubelementList | Defines an interface that can be used by those wishing to define a complexType that contains sub-elements. The structure of the XML Schema for the sub-elements will determined by how this list is given to the XMLSchemaComplexTypeGenerator. "simple" subelements are those which themselves contain no subelements (but may contain attributes). Also allowed are subelements that refer to previously-defined complexTypes or those that refer to previously defined xs:groups |
| CElementSummary | |
| CXMLSchemaComplexTypeGenerator | The XMLComplexTypeSchemaGenerator is used to define the schema for a complex type as they typically occurr in Rosetta |
| CXMLSchemaRepeatableCTNode | |
| CXMLValidatorImpl | |
| CXMLErrorHandler | |
| CXMLValidator | |
| CXMLValidationOutput | |
| ►Nthread | |
| CMutableCache | |
| CSharedThreadLocalData | |
| ►Ntype_traits | |
| ►Nhas_insertion_operator_implementation | |
| Cany_type | |
| Chas_insertion_operator_s | |
| Cis_string_constructible | |
| Cis_string_constructible< char * > | |
| Cis_string_constructible< char const * > | |
| Cis_string_constructible< char(&)[]> | |
| Cis_string_constructible< char const(&)[]> | |
| Cis_string_constructible< char(&)[n]> | |
| Cis_string_constructible< char const(&)[n]> | |
| Cis_string_constructible< std::string > | |
| Cis_string_constructible< std::string const > | |
| Cis_string_constructible< std::string & > | |
| Cis_string_constructible< std::string const & > | |
| CBitSet | Simple bit set |
| CBitVector | Simple bit vector |
| CBound | Bound value class |
| CCSI_Sequence | Class to hold all Terminal ASCII codes as static data for CSI_Sequence. Note: that on non-tty terminals the codes will not print to avoid polution of Rosetta logs |
| Cdeep_copy_vector1 | |
| CDenseBoolMap | This struct condenses N boolean values into roughly N bits, saving roughly 4x memory. NUM_ELEMS parameter takes in the number of boolean values. BASE_INDEX parameter takes in the index of the first value. The recommended way to use this struct is with an enum. See core::scoring::hbonds::graph::AtomInfo for an example |
| CDereferenceIterator | Const_iterator class for SilentFileData container |
| CRawType | Meta-programming classes to provide the pointer type for down_cast |
| CRawType< T & > | |
| CRawType< T * > | |
| CUtilityExitException | |
| Cfixedsizearray0 | |
| Cfixedsizearray1 | |
| CFixedSizeLexicographicalIterator | |
| Cheap | |
| Clist_element | |
| Cin_place_list | |
| Cpredicate_cmp_filename | |
| CInline_File_Provider_Hook | |
| CInline_File_Provider | |
| Csubset_mapping | This class handles the bookeeping to map between a set of integer ids in the "source" enumeration to a subset of those ids – the destination enumartion. Elements in the source enumeration that do not map to elements in the destination enumeration are represented by the value 0. Both enumerations should count from 1. Once the class has been initialized, this class offers O(1) mapping between elements in the enumerations |
| CEnumerate1 | |
| CSimpleRange1 | |
| CLexicographicalIterator | |
| COrderedTuple | The ordered tuple takes a container class T and defines comparison operators so that the tuple may be sorted |
| Chistory_queue_struct | |
| Crecent_history_queue | A class for keeping track of a subset of elements in a set that are pushed into a queue in a certain order, and which fall off the end of the queue in ther order in which they arrive. Elements in the set can be bumped to the front of the queue |
| CShow | |
| CSimulateMPIMessage | |
| CSimulateMPIData | |
| CSimulateMPI | Singleton class storing simulated MPI state |
| CSingletonBase | SingletonBase is meant to serve as a base class for singleton classes in Rosetta handling the initialization of the singleton in a thread-safe way |
| Csmall_vectorL | |
| CSortFirst | |
| CSortSecond | |
| CStrongT | |
| CVBWrapper | |
| Cvector0 | Std::vector with assert-checked bounds |
| Cvector0< bool, A > | Std::vector with assert-checked bounds: bool specialization |
| Cvector1 | Std::vector with 1-based indexing |
| Cvector1< bool, A > | Std::vector with 1-based indexing: bool specialization |
| CvectorL | Std::vector with L-based indexing |
| CvectorL< L, bool, A > | Std::vector with L-based indexing: bool specialization |
| CvectorL_IndexSelector | VectorL index type selector: Nonnegative lower index non-specialization |
| CvectorL_IndexSelector< false > | VectorL index type selector: Negative lower index specialization |
| CvectorL_ZeroSelector | VectorL lower index zero selector: Nonzero lower index non-specialization |
| CvectorL_ZeroSelector< false > | VectorL lower index zero selector: Zero lower index specialization |
| CVersion | |
| CVirtualBase | Base class for Polymorphic classes All classes in Rosetta used polymorphically (that is, where a pointer/reference to a base type can point/reference a derived type) should inherit from this class |
| ►Nutility_exit_detail | |
| CStringy | |
| CStringifier | |
| ►Nvariadic_template | |
| CArray | |
| CArray< T, N > | |
| Cst2 | |
| ►Nzinc_stats | |
| CZincStatisticGenerator | |
| ►Nzlib_stream | |
| Cbasic_zip_streambuf | A stream decorator that takes raw input and zips it to a ostream |
| Cbasic_unzip_streambuf | A stream decorator that takes compressed input and unzips it to a istream |
| Cbasic_zip_ostreambase | Base class for zip ostreams |
| Cbasic_zip_istreambase | Base class for unzip istreams |
| Cbasic_zip_ostream | A zipper ostream |
| Cbasic_zip_istream | A zipper istream |
| C_S2 | |
| CA | |
| CA1 | |
| CA2 | |
| CA3 | |
| CA3BHbsCreatorMover | |
| CA3BHbsDockDesignMinimizeMover | |
| CA3BPeptideBuilder | |
| CA4 | |
| CAA | |
| Cabbinding | |
| CAbInitio_MPI | AbInitio_MPI mover |
| CAbsFunc | |
| CAccess | |
| CAllCrmsd | |
| CAnchorFinderMover | AnchorFinder mover |
| CAnimal | |
| CAnonymous | |
| CAPDBCMover | APDBC mover |
| CApplyFilterMover | Utility function to add hotspot bbcst's to a pose |
| CAppSettings | Storage for some data |
| CArch | |
| CArchI32 | |
| CArchI52 | |
| CArchI53 | |
| CArchO32 | |
| CArchO42 | |
| CArchO43 | |
| CArchP4_42 | |
| CArchP4g_42d | |
| CArchP4m_42d | |
| CArchP6_32 | |
| CArchP6m_32d | |
| CArchT32 | |
| CArchT33 | |
| Carg_join | |
| CArrays | |
| CAssignClusterToolMover | |
| CASTConsumer | |
| CASTFrontendAction | |
| CAtom | |
| CAtomNumFilter | |
| CB | |
| CB3AADihedralGrabber | |
| CBacksideHbondFinderMover | |
| ►CBase | |
| CInnerBase | |
| CInnerTemplate | |
| CBaseA | |
| CBaseB | |
| CBaseC | |
| CBaseD | |
| CBaseJumpSetup | |
| Cbasic_cstring_view | |
| ►Cbasic_format_arg | |
| Chandle | |
| Cbasic_format_args | |
| Cbasic_format_context | |
| Cbasic_format_parse_context | |
| Cbasic_format_specs | |
| Cbasic_memory_buffer | |
| Cbasic_printf_context | |
| Cbasic_printf_parse_context | |
| Cbasic_string_view | |
| CBB | |
| CBBG_Cyclic_Mover | |
| CBBGaussianMover | |
| CBBMover | |
| CBenchmark | |
| CBinderASTConsumer | |
| CBinderFrontendAction | |
| CBinderVisitor | |
| CBola | |
| CBond | |
| CBondedRNA_Mover | |
| CBreadthMover | |
| CBruteFunGroupTK | |
| CBruteRotSel | |
| Cbuffered_file | |
| CBuildFullModel | |
| CBUNS_Output | |
| CBuriedUnsatPolarsFinder | |
| Cbytes | |
| ►CCache | |
| Chead_t | |
| CCalcCdrRms | |
| CCalcIrms | |
| CCalcsTestMover | |
| Ccalculation_data_for_one_block_pair | |
| CCapriData | |
| CCapriTotalEnergy | |
| CCapriTwoBodyEnergy | |
| CCartPerturber | A basic example class for bootcamp |
| CCartRefineWrapperMover | |
| CCaToAllAtom | |
| CCAtrace | |
| CCCParam | |
| CCenRelaxMover | |
| CCenRotCanonicalMover | |
| CCenRotDockingMover | |
| CCenRotRBRelaxMover | |
| CCenRotRelaxMover | |
| CCenRotSidechainMover | |
| CChallengeMover | |
| CCheeseFunction | |
| CCheshireCell | |
| CChiMover | |
| CCL | |
| CClashCheck | |
| CClassicAbinitio | |
| CClassVisitor | |
| CClearPoseHeader | |
| CClosabilityScore | |
| CCloseContactWithResidue | |
| CClosureMover | |
| CCloudArchiveManagerWrapper | |
| CCluster | |
| CClusterCycDisulf | |
| CClusterPhilStyle | |
| CCnlRes | Data structure for a residue contributing to a constellation |
| CCollectCoordinates | |
| CCollectNeighbors | |
| CColorByLipidType | |
| CCombine_Tags_Info | |
| Ccompare_VallIndex_gt | |
| Ccompare_VallIndex_lt | |
| Ccompile_string | |
| Ccomplex_interface_optimize | |
| Ccompute_Irmsd | |
| CComputeProfileMover | |
| CComputeSAXSSpectrum | |
| CConcertedTorsionMover | |
| CConsensusFragmentMover | |
| CConstOverload | |
| CConstraintConfig | |
| CConstraintMinimizer | Super-simple attempt to mimick the Modeller algorithm. Similar to FoldConstraints, except moves are made based on minimization rather than based on fragment moves |
| CConstraintStatsMover | |
| CConstraintToolMover | |
| CConsts | |
| CConverter | |
| CConverter1Param | |
| CCountContact | |
| CCoupledFunc | |
| CCovalentPeptidomimeticCreator | |
| CCovalentPeptidomimeticDockDesign | |
| CCrystCluster | |
| CCrystDesign | |
| CCrystFFTDock | |
| CCrystHbondsReporter | |
| CCrystRelax | |
| CCST | |
| CCustomMover | |
| CCycBBMover | |
| CData1 | |
| CDCST | |
| Cdecision_function | |
| CDelete | |
| CDeleteSegments | Local mover for testing purposes |
| CDerived | |
| CDerivedA | |
| CDerivedB | |
| CDerivedC | |
| CDerivedD | |
| CDesignBenchmark | |
| CDesigner | Wrapper to AntibodySeqDesignMover due to needed ab_info object. Designs CDRs based on cluster using probability and conservative strategies |
| CDesignGlycansProtocol | The design_glycans protocol |
| CDesignOpts | |
| CDetectSymmetry | |
| CDistanceMatrix | |
| CDistancePrediction | |
| CDisulfEpos | |
| CDisulfEposDatabase | |
| CDisulfideBondEnergy | |
| CDock | |
| CDockFragmentsMover | |
| CDockGlycansProtocol | The protocol ported from dock_glycans.py |
| CDockingBenchmark | |
| CDog | |
| CDomain | |
| CDomainAssemblerNDocker | |
| CDomainDescription | |
| CDomainFinder | |
| CDougsDockDesignMinimizeMagicMover | |
| CDsfHit | |
| CdsRNA_grow | |
| CDuboisChiMover | |
| CDummyMover | Must have this after BOINC stuff to avoid windows build error |
| ►Cdynamic_format_arg_store | |
| Cneed_copy | |
| ►Cdynamic_formatter | |
| Cnull_handler | |
| CElecDensMinPackMinMover | |
| CElecDensMinPackMinReporter | |
| CEnergyAndFilename | |
| CEnums | |
| CEnvToolMover | |
| Cerror_code | |
| CErrorHandler | |
| CException | |
| CExemplarMover | |
| CExposedStrandMover | |
| CExtractATD | |
| CFaSolReporter | |
| CFastRelaxPerformanceBenchmark | |
| CFastThreadingMover | |
| CFeatures | |
| CfiberHit | |
| CFilter | |
| CFindOptimalHydrophobicThk | |
| CFitMover | |
| CFixbbJobQueen | |
| CFloating_point | |
| CFloatScMonteCarlo | |
| CFloatScRandomChi | |
| CFloatScRotMover | |
| CFloppyTailMover | FloppyTail mover |
| CFoldptn | Local mover for testing purposes |
| CFoldTreeOutputter | |
| CForgetMover | App to clean PDBs - the input is guarunteed to be Rosetta-readable and indexed from 1 (great for writing loopsfiles, etc) |
| Cformat_arg_store | |
| Cformat_args | |
| Cformat_error | |
| Cformat_int | |
| Cformat_to_n_result | |
| Cformattable | |
| Cformatter | |
| Cformatter< arg_join< It, Sentinel, Char >, Char > | |
| Cformatter< bytes > | |
| Cformatter< Char[N], Char > | |
| Cformatter< detail::bigint > | |
| ►Cformatter< std::chrono::duration< Rep, Period >, Char > | |
| Cparse_range | |
| Cspec_handler | |
| Cformatter< std::chrono::time_point< std::chrono::system_clock >, Char > | |
| Cformatter< std::tm, Char > | |
| Cformatter< T, Char, enable_if_t< detail::type_constant< T, Char >::value !=detail::type::custom_type > > | |
| Cformatter< T, Char, enable_if_t< fmt::is_range< T, Char >::value &&(has_formatter< detail::value_type< T >, format_context >::value||detail::has_fallback_formatter< detail::value_type< T >, format_context >::value) > > | |
| Cformatter< tuple_arg_join< Char, T... >, Char > | |
| ►Cformatter< TupleT, Char, enable_if_t< fmt::is_tuple_like< TupleT >::value > > | |
| Cformat_each | |
| Cformatter< void *, Char > | |
| Cformatting_base | |
| Cformatting_range | |
| Cformatting_tuple | |
| CFragID | |
| CFragInfo | |
| CFragmentAssemblyMover | |
| CFragmentBasedDesign | |
| CFragMonteCarlo | |
| CFullModelJobQueen | |
| CFunctorTest | |
| CFunGroupTK | |
| CG | |
| Cgenerate_hbond_geometry | |
| CGetURLHandler | |
| CGlycanClashCheckMover | Class to print out info specific to glycan poses. Will be expanded as needed. Hope to eventually add it as both a mover and a features reporter. Needs to be completely rewritten |
| CGlycomutagenesisProtocol | This protocol exhaustively mutates and glycosylates every possible position of a given protein |
| Cgpu_node_block_ptrs | |
| CGraftDesignCDRs | |
| CGridInfo | |
| CGridWeights | |
| CGunnTest | |
| ChackLAMMover | |
| CHandler | |
| Chbgeom_to_measure | |
| Chbond_energy_strat | |
| Chbond_geom_strat | |
| Chbond_strat | |
| CHBondedPairIterator | |
| CHBondReporter | |
| CHbondZinc | |
| CHbondZincBackbone | |
| CHbsCreatorMover | |
| CHbsDesignMover | |
| CHDdesignMover | |
| CHDmakerMover | |
| CHeapContainer | |
| CHECTAllMover | HECT mover |
| CHECTMover | HECT mover |
| CHECTUBQMover | HECT mover |
| CHelicalPdbGeneratorMover | |
| CHelixHit | |
| CHemaggTrimer | |
| CHemeBindingMover | |
| CHemeReplace | Replaces original porphyrin ligand with heme and rescores the pose. Prints energy difference between two ligands |
| CHit | |
| CHIT | |
| CHitCmp | |
| CHolesTrainingDataMover | |
| CHotspotPlacementMover | |
| CHPatchByChainNPDCalculator | |
| CHPatchByChainNPDCalculatorCreator | |
| CHPatchNPDCalculator | |
| CHPatchNPDCalculatorCreator | |
| CHubDenovo | |
| CIAMover | |
| CIdentifyCDRClusters | |
| CInjectorMover | |
| Cinput_mutation | |
| CInstantiateModulesBenchmark | |
| CIntegral | |
| CInteractionDistMinimizer | |
| CInteractionGraphPerformanceBenchmark | |
| CInterfaceDDGBindInnerJob | |
| CInterfaceDDGBindJobInputter | |
| CInterfaceDDGMover | |
| CInterfaceDDGMutationTask | |
| CInterfaceFeaturesTests | |
| CInterfaceHit | |
| CInterfaceHitComparitor | |
| CInterfaceHitDatabase | |
| CInterfaceStrandFinderMover | |
| CInverseRotlibDumpMover | |
| Cis_char | |
| Cis_char< char > | |
| Cis_char< char16_t > | |
| Cis_char< char32_t > | |
| Cis_char< detail::char8_type > | |
| Cis_char< wchar_t > | |
| Cis_compile_string | |
| Cis_contiguous | |
| Cis_contiguous< basic_memory_buffer< T, SIZE, Allocator > > | |
| Cis_contiguous< std::basic_string< Char > > | |
| Cis_range | |
| Cis_tuple_like | |
| CIsctFast | |
| CJDmover | Local mover for testing purposes |
| CJDtestmover | Local mover for testing purposes |
| CKernel | |
| CKHSandbox | |
| CkhSandbox | |
| CkhSandbox2 | |
| CKinFunGroupTK | |
| CKinRotSel | |
| CKRSQuery | |
| ClatticeHit | |
| CLDConverterMover | |
| CLigandDockBenchmark | |
| CLigandDockingHbondsReporter | |
| CLigandRepackMinimizeProtocol | |
| CLigChiMover | |
| CLink | |
| CListFilter | |
| CLMAX | |
| CLoadMembraneMover | Load Membrane Mover: Load and Initialize a Membrane Protein using Rosetta's new Membrane Framework |
| Clocal_minimum | |
| CLocalRmsd | Local mover for testing purposes |
| CLoopHash_Analyze | |
| CLoopHashRelax_Sampler | |
| CMainWindow | |
| CMakeCanonicalHelix | |
| CMakeSegmentFileMPI | |
| CMammal | |
| CMAT | |
| CMatchAligner | |
| CMatchAlignInfo | |
| CMatchArgs | |
| CMatchBase | |
| CMatchLig | |
| CMatchSet | |
| CMatrix | |
| CMembraneDockingxMover | Membrane Relax Mover: Create a Membrane Pose and Apply Relax Protocol |
| CMembraneMinMover | Membrane Relax Mover: Create a Membrane Pose and Apply Relax Protocol |
| CMembraneRelaxMover | Membrane Relax Mover: Create a Membrane Pose and Apply Relax Protocol |
| CMembraneSampleMover | View membrane planes based on normal/center |
| CMembraneSfxnMover | Membrane Relax Mover: Create a Membrane Pose and Apply Relax Protocol |
| CMembraneTransformMover | Membrane Transform Mover: Transform a pose into a new mover |
| CMembraneViewMover | View membrane planes based on normal/center |
| CMetalSiteFinderMover | |
| CMethods | |
| CMikeLinkerMover | |
| CMinCenrotMover | |
| CMinimize | |
| CMinimizerBenchmark | |
| CMinPackMin | |
| CMinPackMinMover | |
| CMinTestMover | |
| CMinToolMover | |
| CMirrorSymmTest | |
| CMode | |
| Cmonostate | |
| CMotifDock | |
| CMotifScanMover | |
| CMoveThenFixH | |
| CMoveThenFixHMin | |
| CMPDomainAssembly | |
| CMPFindInterfaceTestMover | Load Membrane Mover: Load and Initialize a Membrane Protein using Rosetta's new Membrane Framework |
| CMPFoldingMover | |
| CMPframeworkTest1Mover | Load Membrane Mover: Load and Initialize a Membrane Protein using Rosetta's new Membrane Framework |
| CMPframeworkTestMover | Load Membrane Mover: Load and Initialize a Membrane Protein using Rosetta's new Membrane Framework |
| CMPI_LoopHash_Launcher | |
| CMPI_Refinement_Launcher | |
| CMPInterfaceStatistics | |
| CMPScoreFunctionFingerprintMover | Membrane Sfxn fingerprint mover //// |
| Cmtransferase | |
| CMutate1Randomizer | Different set of choices at each position in Entity's traits |
| CMyApp | |
| CMyAtom | |
| CMyCI1B | |
| CMyCI1B_Creator | |
| CMyFeaturesReporter | |
| CmyMC | |
| CMyMover | |
| CMyProtocol | |
| CMyRotMover | |
| CMyRT | |
| CMyScoreMover | |
| CMySlideMover | |
| CMyTransMover | |
| CNativeEnsemble | |
| CNBuriedUnsatsCalcultor | |
| CNBuriedUnsatsCalcultorCreator | |
| CNCMinimize | |
| Cnode_data | |
| CNodeTest | |
| CNonceHistogram | |
| CNullFilter | |
| CNullKinematicPerturber | |
| Cobject | |
| COctreeIdx | |
| CONE_CLASS_Q | |
| COopDesignMover | |
| COptionCollectionBenchmark | |
| ►Couter | |
| Cinner | |
| Cinner2 | |
| Cinner3 | |
| COutputCenrotIntCoord | |
| COutputManager | |
| COutputMover | |
| CPacking_energies | |
| CPackingAngle | |
| CPairComparator | |
| CPairDistance | Local mover for testing purposes |
| CPairScore | |
| CPathFinder | |
| CPathologicalKinematicPerturber | |
| CPBPotentialMover | |
| CPDB_IOBenchmark | |
| Cpdbline | |
| Cpep_coord_cst | |
| CPepMinMover | |
| CPeptiodMovieMover | |
| CPeptoidDesignMover | |
| CPeptoidDihedralGrabber | |
| CPeptoidRotamerRecoverer | |
| CPerformanceBenchmark | |
| CPerturbers1 | |
| CPerturbers2 | |
| CPerturbStruct | |
| CPhDocking | |
| CPhProtocol | |
| CPickBAB | Local mover for testing purposes |
| CPickSSE | |
| CPOD1 | |
| CPOD2 | |
| CPOD3 | |
| CPOD4 | |
| CPOD5 | |
| CPOD6 | |
| CPointers_and_References | |
| CpointGroupHit | |
| CPoseAndData | |
| CPoseEvaluator | |
| CPosePyObserver | |
| CPoseWrap | |
| Cprintf_arg_formatter | |
| Cprintf_formatter | |
| CPrintFeatures | |
| CPrintPDDF | |
| CPrintSequenceMover | |
| CProtocol_MolecularDynamics | |
| CpseudoCA | |
| CpseudoCAbond | |
| CPseudoCAMultifunc | Bfactor multifunc |
| CpseudoTrace | |
| CpseudoTraceRecords | |
| CPyCallBack_A2 | |
| CPyCallBack_A3 | |
| CPyCallBack_A4 | |
| CPyCallBack_aaa_A_double_t | |
| CPyCallBack_Animal_1_t | |
| CPyCallBack_Base | |
| CPyCallBack_Delete | |
| CPyCallBack_Derived | |
| CPyCallBack_Dog_1_t | |
| CPyCallBack_Mammal_1_t | |
| CPyCallBack_n1_A | |
| CPyCallBack_n1_n2_A | |
| CPyCallBack_X | |
| CQAbstractTableModel | |
| CQDialog | |
| CQException | |
| CQGroupBox | |
| CQMainWindow | |
| CQMatrix | |
| CQObject | |
| CQOpenGLWidget | |
| CQOpenGLWindow | |
| CQThread | |
| CQuat | |
| CQWidget | |
| CRamaTestMover | |
| CRDCScoreMover | |
| CRDCToolMover | |
| CRDF_Mover | |
| CRecursiveASTVisitor | |
| CRelaxCDRsMover | Documentation: |
| CRelaxJobQueen | |
| CRepackCenrotMover | |
| CRepackMinCenrotMover | |
| CRepFunc | |
| CRerootEdgeSorter | Edge sorting: |
| CRerootRestypeVisitor | |
| CRescoreCenrot | |
| CRescorePDDF | |
| CRescoreSAXS | |
| CResults_Keeper | |
| Crgb | |
| CRMS_ScoringScheme | |
| CRMSByResStatistics | |
| CRmsfMover | |
| CRNA_ScoreMover | |
| CRosettaBackend | |
| CRosettaHolesMover | |
| CRosettaJob | |
| CRotamerAssigningAnnealer | |
| CRotateSAXS | |
| CRotSel | |
| CRTminOptMultifunc | |
| Crun_score_hotspot | |
| Crun_score_patchdock_hotspot | |
| ►CS | |
| C_D | |
| CFL_not_binded | |
| CSameResidueTypeConstraint | |
| CSampleTiltProtocol | |
| CSamplingManager | |
| CSasa | Local mover for testing purposes |
| Csasa_qdMover | |
| CScMinMover | |
| CScoreAnalyticEtableBenchmark | |
| CScoreBenchmark | |
| CScoreBreakdown | |
| CScoreEachBenchmark | |
| CScoreFragInfo | |
| CScoreFragmentSetMover | |
| CScoreFunctionFingerprintMover | Sfxn fingerprint mover ///////////// |
| CScoreMover | |
| CScTrials | |
| CSecondaryStructureChunk | |
| CSeqBBTorSRFD | |
| CSequenceCoords | |
| CSequenceProfileDB | |
| CSerializablePose | |
| CServerInfo | |
| CSetOfClusters | |
| CSetupHotspotMover | |
| CSetupMover | |
| CShearMoverBenchmark | |
| CSilentProlineFixMover | |
| CSimpleBBMover | |
| CSimpleComparison | |
| CSimpleDGBindAggregateFunction | |
| CSimulateCryoMover | |
| CSingleInterface | |
| CSleepForATenthOfASecond | |
| CSlideTask | |
| CSmallMoverBenchmark | |
| CSmoothFragRepackMover | |
| CSolutionRescoreMover | |
| ►CSolver | |
| CSolutionInfo | |
| CSolver_NU | |
| CSomeThing | |
| CSomeThingGetter | |
| CSon | |
| Csort_minima_by_scores | |
| CSpacegroup | |
| CSpacegroupHit | |
| CSpartaSuperDeviationMover | |
| CSphereNode | |
| CSphereSample | |
| CSphereSampler | |
| CSSM_energies | |
| CStatefulMover | |
| CStepWiseJobQueen | |
| CStepwiseTorsionMover | |
| CStructureConfidence | |
| CSuperDeviationMover | |
| CSVC_Q | |
| Csvm_model | |
| Csvm_node | |
| Csvm_parameter | |
| Csvm_problem | |
| CSVR_Q | |
| CSwapElementsMover1 | |
| CSwapElementsMover2 | |
| CSymFixbbMover | |
| CSymRBMover | |
| Csystem_error | |
| CT | |
| CTags | |
| CTCDock | |
| CTemplateSpecialization | |
| CTensor | |
| CTestJD2Mover | |
| CTestMMOP | |
| CTestQuickRelaxMover | |
| CTet4HMatchAligner | |
| Ctext_style | |
| CThisApplication | |
| CTNM | |
| CTorsionList | |
| CTorsionVectorMover | |
| CTriazoleCreator | |
| CTrizaolamerDockDesignMinimizeMover | |
| CTryScoreFilter | |
| Ctuple_arg_join | |
| CTwoChainInterface | |
| CTwoChainTenANeighbors | |
| Ctype_identity | |
| CTypeError | |
| CUBQ_E2Mover | |
| CUBQ_GTPase_disulfide_Mover | |
| CUniformPerturber | |
| CUserWarning | |
| CVallIndex | |
| CVallReader | |
| CVarLengthBuildKristin | |
| CVEC | |
| CVecContains | |
| CVecLen | |
| CVecMaxElement | |
| CVecMean | |
| CVecMinElement | |
| CViewMembraneProteinMover | Quick Container Mover: Visualize Membrane Protein Using the PyMOL Viewer |
| CVirtualBase | |
| CW128_T | |
| Cwformat_args | |
| CWorkDat | |
| CX | |
| CXFORM | |
| CXMLParseBenchmark | |
| CXMLprinterMover | |
| Cxtal_water_bunsat | |
| CXYZ | |
| CxyzStripeHashWithMeta | |
| CY | |
| CZF_PatchupMover | |
| Czinc1_homodimer_design | |
| Czinc1_homodimer_setup | |
| Czinc2_homodimer_design | |
| Czinc2_homodimer_setup | |
| Czinc_helix_cap | |
| CZincMatchFilter | |
| CZincMinimize | |
| CZincSiteEvaluator | |
