#include <TemplateManager.h>

Inheritance diagram for Audio::TemplateManager:

Public Member Functions
	TemplateManager () throw ()

	~TemplateManager ()

void	addDefinitionFile (const std::string &path, bool persistent) throw (Exception)

void	addDefinitionFile (const std::string &path, SharedPtr< XMLDOM::XMLDocument > definition) throw (Exception)

SharedPtr< XMLDOM::XMLDocument >	getDefinitionFile (const std::string &path) const throw (ResourceNotLoadedException)

SharedPtr< XMLDOM::XMLDocument >	getDefinitionFile (const std::string &path) throw (Exception)

void	setDefaultDefinitionFile (const std::string &x) throw ()

const std::string &	getDefaultDefinitionFile () const throw ()

SharedPtr< SourceTemplate >	getSourceTemplate (const std::string &name) throw (Exception)

void	addSourceTemplate (const std::string &name, SharedPtr< SourceTemplate > tpl, bool perm=true) throw (ResourceAlreadyLoadedException)

void	addSourceTemplate (const std::string &path, const std::string &name, SharedPtr< SourceTemplate > tpl, bool perm=true) throw (ResourceAlreadyLoadedException)

Protected Member Functions
SharedPtr< SourceTemplate >	loadSourceTemplate (const std::string &name) throw (Exception)

Protected Member Functions inherited from Singleton< TemplateManager >
	~Singleton ()

Additional Inherited Members
Static Public Member Functions inherited from Singleton< TemplateManager >
static TemplateManager *	getSingleton ()

Static Protected Member Functions inherited from Singleton< TemplateManager >
static void	initializeSingleton ()

static void	deinitializeSingleton ()

Static Protected Attributes inherited from Singleton< TemplateManager >
static TemplateManager *	_singletonInstance

Detailed Description

Template manager class.

Remarks: Use it to create and manage source templates.

Instead of storing source templates themselves, since they may be shared,: you should store shared pointers to them. The manager will automatically detect and unload unreferenced templates.

Templates are addressed by key - keys are composed in a very specific way.: They are all of the form [path]:[name], where [path] is a source definition xml file and [name] is a source name within the xml file.

Usually xml files are loaded on-demand, and unloaded shortly after. Some: definition files, however, may contain heavily used sources and those are useful to keep laying around, preparsed. You can instruct the manager to do so with addDefinitionFile().

See Also: SourceTemplate

Definition at line 49 of file TemplateManager.h.

Constructor & Destructor Documentation

Audio::TemplateManager::TemplateManager	(	)
throw	(
	)

Construct a new manager

Remarks: End-users of the class shouldn't be using this. Singletons need it.

Definition at line 154 of file TemplateManager.cpp.

                                              :
         data(new TemplateManagerData)
     {
     }

Audio::TemplateManager::~TemplateManager ( )

Definition at line 159 of file TemplateManager.cpp.

160 {

161 }

Member Function Documentation

void Audio::TemplateManager::addDefinitionFile	(	const std::string &	path,
		bool	persistent
	)
throw	(	Exception
	)

Add a definition file, persistent or not

void Audio::TemplateManager::addDefinitionFile	(	const std::string &	path,
		SharedPtr< XMLDOM::XMLDocument >	definition
	)
throw	(	Exception
	)

Add a definition document under a specified path, always persistent (as there is no way to reload)

void Audio::TemplateManager::addSourceTemplate	(	const std::string &	name,
		SharedPtr< SourceTemplate >	tpl,
		bool	perm = `true`
	)
throw	(	ResourceAlreadyLoadedException
	)

Add a manually-created template

Parameters

name	the name portion of the template's key
tpl	the template to be added
perm	if true, a strong reference will be held and the template will become permanently loaded.

Remarks: The key to the newly added template will always be :[name] (empty path), denoting dynamically-created templates.

Note: Since the manager only holds weak references to templates if perm is not given, you must hold onto a reference at least, or the manager will "forget" you added this resource.

Exceptions

ResourceAlreadyLoadedException,when the key already has an associated template.

void Audio::TemplateManager::addSourceTemplate	(	const std::string &	path,
		const std::string &	name,
		SharedPtr< SourceTemplate >	tpl,
		bool	perm = `true`
	)
throw	(	ResourceAlreadyLoadedException
	)

Add a manually-created template

Parameters

path	the path portion of the template's key
name	the name portion of the template's key
tpl	the template to be added
perm	if true, a strong reference will be held and the template will become permanently loaded.

Remarks: The key to the newly added template will always be [path]:[name]. Using this method is discouraged if collission with filesystem-based templates would be possible (pick paths that don't map to file system paths)

Note: Since the manager only holds weak references to templates if perm is not given, you must hold onto a reference at least, or the manager will "forget" you added this resource.

Exceptions

ResourceAlreadyLoadedException,when the key already has an associated template.

const std::string & Audio::TemplateManager::getDefaultDefinitionFile	(	)	const
throw	(
	)

Get the default definition file

See Also: setDefaultDefinitionFile

Definition at line 205 of file TemplateManager.cpp.

     {
         return data->defaultDefinitionFile;
     }

SharedPtr< XMLDOM::XMLDocument > Audio::TemplateManager::getDefinitionFile	(	const std::string &	path)	const
throw	(	ResourceNotLoadedException
	)

Get an already loaded definition file, fail if not found or not loaded

Definition at line 182 of file TemplateManager.cpp.

     {
         return ((const TemplateManagerData &)*data).getDefinitionFile(path);
     }

SharedPtr< XMLDOM::XMLDocument > Audio::TemplateManager::getDefinitionFile	(	const std::string &	path)
throw	(	Exception
	)

Get an already loaded definition file, load if not loaded

Definition at line 188 of file TemplateManager.cpp.

References e.

     {
         try {
             return data->getDefinitionFile(path);
         } catch(NotFoundException e) {
             addDefinitionFile(path, false);
             return data->getDefinitionFile(path);
         }
     }

SharedPtr< SourceTemplate > Audio::TemplateManager::getSourceTemplate	(	const std::string &	name)
throw	(	Exception
	)

Get a source template by its key

Definition at line 211 of file TemplateManager.cpp.

     {
         SharedPtr<SourceTemplate> rv;
         
         TemplateManagerData::TemplateMap::const_iterator it = data->loadedTemplates.find(name);
         if (it != data->loadedTemplates.end())
             rv = it->second.lock();
         
         if (!rv.get()) {
             rv = loadSourceTemplate(name);
             data->loadedTemplates[name] = rv;
         }
         
         return rv;
     }

SharedPtr< SourceTemplate > Audio::TemplateManager::loadSourceTemplate	(	const std::string &	name)
throw	(	Exception
	)

protected

Get a source template by its key

Definition at line 228 of file TemplateManager.cpp.

References f, XMLDOM::XMLElement::getAttributeValue(), M_PI, Audio::__impl::parseBool(), Audio::__impl::parseFloat(), and Audio::__impl::parseVSFileType().

     {
         string::size_type sep = name.find_first_of(':');
         SharedPtr<XMLDOM::XMLDocument> def;
         
         if (sep != string::npos) 
             def = getDefinitionFile(name.substr(0,sep)); else
             def = getDefinitionFile(getDefaultDefinitionFile());
         
         const XMLDOM::XMLElement *tdef = 0;
         if (sep != string::npos)
             tdef = def->getElementByName(name.substr(sep+1, string::npos)); else
             tdef = def->getElementByName(name);
         
         if (!tdef)
             throw NotFoundException(name);
         
         string src = 
             tdef->getAttributeValue("src","");
         
         if ( src.empty() )
             throw InvalidParametersException("Invalid source template: no sound specified");
         
         VSFileSystem::VSFileType type = 
             parseVSFileType( tdef->getAttributeValue("type", "unknown") );
         bool looping =
             parseBool( tdef->getAttributeValue("looping", "false") );
         
         SharedPtr<SourceTemplate> rv(
             new SourceTemplate(src, type, looping) );
         
         rv->setAngleRange( Range<Scalar>(
             parseFloat( tdef->getAttributeValue("minAngle", "180") ) * M_PI / 180.f,
             parseFloat( tdef->getAttributeValue("maxAngle", "180") ) * M_PI / 180.f
         ) );
         
         rv->setPerFrequencyRadiusRatios( PerFrequency<Scalar>(
             parseFloat( tdef->getAttributeValue("lfRadiusRatio", "1") ),
             parseFloat( tdef->getAttributeValue("hfRadiusRatio", "1") )
         ) );
         
         rv->setPerFrequencyRadiusRatios( PerFrequency<Scalar>(
             parseFloat( tdef->getAttributeValue("lfReferenceFreq", "250") ),
             parseFloat( tdef->getAttributeValue("hfReferenceFreq", "5000") )
         ) );
         
         rv->setGain( 
             parseFloat( tdef->getAttributeValue("gain", "1") )
         );
         
         rv->setStreaming( 
             parseBool( tdef->getAttributeValue("streaming", "false") )
         );
         
         return rv;
     }

void Audio::TemplateManager::setDefaultDefinitionFile	(	const std::string &	x)
throw	(
	)

Set default definition file

Remarks: when a template named without its source definition file is requested, it is assumed to come from this definition file.

Definition at line 199 of file TemplateManager.cpp.

References x.

     {
         data->defaultDefinitionFile = x;
     }

The documentation for this class was generated from the following files:

src/audio/TemplateManager.h
src/audio/TemplateManager.cpp

Public Member Functions

Protected Member Functions

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation