Rosetta  2019.35
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
Namespaces | Classes | Typedefs | Functions | Variables
basic::resource_manager Namespace Reference

Namespaces

 fallback_configuration
 
 locator
 

Classes

class  ResourceLoader
 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. More...
 
class  ResourceLoaderCreator
 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. More...
 
class  ResourceLoaderFactory
 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. More...
 
class  ResourceLoaderRegistrator
 The ResourceLoaderRegistrator class is a simple templated registration class that will, at construction, create a ResourceLoader and register it with the ResouceLoaderFactory. More...
 
class  ResourceLocator
 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. More...
 
class  ResourceLocatorCreator
 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. More...
 
class  ResourceLocatorFactory
 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) More...
 
class  ResourceLocatorRegistrator
 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). More...
 
class  ResourceManager
 
class  ResourceManagerCreator
 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. More...
 
class  ResourceManagerFactory
 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. More...
 
class  ResourceManagerRegistrator
 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. More...
 
class  ResourceStream
 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). More...
 

Typedefs

typedef
utility::pointer::shared_ptr
< ResourceLoader
ResourceLoaderOP
 
typedef
utility::pointer::shared_ptr
< ResourceLoader const > 
ResourceLoaderCOP
 
typedef
utility::pointer::shared_ptr
< ResourceLoaderCreator
ResourceLoaderCreatorOP
 
typedef
utility::pointer::shared_ptr
< ResourceLoaderCreator const > 
ResourceLoaderCreatorCOP
 
typedef
utility::pointer::shared_ptr
< ResourceStream
ResourceStreamOP
 
typedef
utility::pointer::shared_ptr
< ResourceStream const > 
ResourceStreamCOP
 
typedef
utility::pointer::shared_ptr
< ResourceLocator
ResourceLocatorOP
 
typedef
utility::pointer::shared_ptr
< ResourceLocator const > 
ResourceLocatorCOP
 
typedef
utility::pointer::shared_ptr
< ResourceLocatorCreator
ResourceLocatorCreatorOP
 
typedef
utility::pointer::shared_ptr
< ResourceLocatorCreator const > 
ResourceLocatorCreatorCOP
 
typedef
utility::pointer::shared_ptr
< ResourceManager
ResourceManagerOP
 
typedef
utility::pointer::shared_ptr
< ResourceManager const > 
ResourceManagerCOP
 
typedef
utility::pointer::shared_ptr
< ResourceManagerCreator
ResourceManagerCreatorOP
 
typedef
utility::pointer::shared_ptr
< ResourceManagerCreator const > 
ResourceManagerCreatorCOP
 
typedef
utility::pointer::ReferenceCount 
Resource
 
typedef
utility::pointer::ReferenceCountCOP 
ResourceCOP
 

Functions

template<class S >
void write_type (std::ostream &out, S val)
 simple enough function that calls the bit-shift operator in the input stream; why bother? For the sake of writing out boolean values as "true" or "false" More...
 
template<>
void write_type< bool > (std::ostream &out, bool val)
 Template specialization to write boolean values as "true" or "false". More...
 
template<class T , class S >
void show_option_map (std::map< T, S > const &option_map, std::ostream &out, char const *option_name)
 
template<class T , class S >
void show_option_vector_map (std::map< T, vector1< S > > const &option_map, std::ostream &out, char const *option_name)
 
std::ostream & operator<< (std::ostream &out, const JobOptions &job_options)
 
template<class T , class S >
void add_option_to_map (std::map< T, S > &option_map, T const &key, S const &val)
 
template<class T , class S >
void remove_option_from_map (std::map< T, S > &option_map, T const &key)
 
template<class T , class S >
bool option_map_contains_key (std::map< T, S > const &option_map, T const &key)
 
template<class T , class S >
S const & get_option_from_map (std::map< T, S > const &option_map, T const &key, char const *option_class_name)
 
void resource_loader_xsd_type_definition_w_attributes (utility::tag::XMLSchemaDefinition &xsd, std::string const &loader_type, std::string const &description, utility::tag::AttributeList const &attributes)
 Define the XML schema definition for a ResourceLoader that contains no subtags but may contain any number of attributes (aka options). More...
 
void resource_loader_xsd_type_definition_w_attributes_and_repeatable_subelements (utility::tag::XMLSchemaDefinition &xsd, std::string const &loader_type, std::string const &description, utility::tag::AttributeList const &attributes, utility::tag::XMLSchemaSimpleSubelementList const &subelements)
 Define the XML schema definition for a ResourceLoader that contains subtags and attributes (aka options). More...
 

Variables

static Tracer TR ("basic.resource_manager.ResourceManager")
 

Typedef Documentation

typedef utility::pointer::shared_ptr< ResourceLoader const > basic::resource_manager::ResourceLoaderCOP
typedef utility::pointer::shared_ptr< ResourceStream const > basic::resource_manager::ResourceStreamCOP

Function Documentation

template<class T , class S >
void basic::resource_manager::add_option_to_map ( std::map< T, S > &  option_map,
T const &  key,
S const &  val 
)
template<class T , class S >
S const& basic::resource_manager::get_option_from_map ( std::map< T, S > const &  option_map,
T const &  key,
char const *  option_class_name 
)

References CREATE_EXCEPTION.

std::ostream& basic::resource_manager::operator<< ( std::ostream &  out,
const JobOptions &  job_options 
)
template<class T , class S >
bool basic::resource_manager::option_map_contains_key ( std::map< T, S > const &  option_map,
T const &  key 
)
template<class T , class S >
void basic::resource_manager::remove_option_from_map ( std::map< T, S > &  option_map,
T const &  key 
)
void basic::resource_manager::resource_loader_xsd_type_definition_w_attributes ( utility::tag::XMLSchemaDefinition xsd,
std::string const &  loader_type,
std::string const &  description,
utility::tag::AttributeList const &  attributes 
)
void basic::resource_manager::resource_loader_xsd_type_definition_w_attributes_and_repeatable_subelements ( utility::tag::XMLSchemaDefinition xsd,
std::string const &  loader_type,
std::string const &  description,
utility::tag::AttributeList const &  attributes,
utility::tag::XMLSchemaSimpleSubelementList const &  subelements 
)
template<class T , class S >
void basic::resource_manager::show_option_map ( std::map< T, S > const &  option_map,
std::ostream &  out,
char const *  option_name 
)
template<class T , class S >
void basic::resource_manager::show_option_vector_map ( std::map< T, vector1< S > > const &  option_map,
std::ostream &  out,
char const *  option_name 
)
template<class S >
void basic::resource_manager::write_type ( std::ostream &  out,
S  val 
)

simple enough function that calls the bit-shift operator in the input stream; why bother? For the sake of writing out boolean values as "true" or "false"

Referenced by show_option_map(), and show_option_vector_map().

template<>
void basic::resource_manager::write_type< bool > ( std::ostream &  out,
bool  val 
)

Template specialization to write boolean values as "true" or "false".

References erraser_single_res_analysis::out.

Variable Documentation

Tracer basic::resource_manager::TR("basic.resource_manager.ResourceManager")
static