benn/lumiera_documentation
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Template instantiations for the new asset types Timeline and Sequence

Browse source
This commit is contained in:
Fischlurch 2010-03-12 01:49:30 +01:00
parent 55df5205a4
commit cdaff1566f
5 changed files with 139 additions and 122 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

12
src/common/configrules.hpp
View file

@ -58,21 +58,23 @@
#include "proc/asset/procpatt.hpp"
#include "proc/asset/pipe.hpp"
#include "proc/asset/track.hpp"
#include "proc/asset/timeline.hpp"
#include "proc/asset/sequence.hpp"
#include <string>
namespace lumiera
{
namespace lumiera {
using std::string;
using lumiera::P;
namespace query
{
namespace query {
// The intention is to support the following style of Prolog code
//
// resolve(O, Cap) :- find(O), capabilities(Cap).
@ -216,6 +218,8 @@ namespace lumiera
, asset::Track
, asset::Pipe
, const asset::ProcPatt
, asset::Timeline
, asset::Sequence
> ::List
InterfaceTypes;

2
src/proc/asset/sequence.cpp
View file

@ -21,7 +21,7 @@
* *****************************************************/
#include "asset/sequence.hpp"
#include "proc/asset/sequence.hpp"
//#include "proc/mobject/session/track.hpp"
//#include "proc/mobject/placement.hpp"
//#include "proc/mobject/session/mobjectfactory.hpp"

4
src/proc/asset/struct.cpp
View file

@ -144,6 +144,8 @@ namespace asset {
#include "proc/asset/procpatt.hpp"
#include "proc/asset/track.hpp"
#include "proc/asset/pipe.hpp"
#include "proc/asset/timeline.hpp"
#include "proc/asset/sequence.hpp"
namespace asset {
@ -151,6 +153,8 @@ namespace asset {
template P<Pipe> StructFactory::operator() (const Query<Pipe>& query);
template P<Track> StructFactory::operator() (const Query<Track>& query);
template PProcPatt StructFactory::operator() (const Query<const ProcPatt>& query);
template PTimeline StructFactory::operator() (const Query<Timeline>& query);
template PSequence StructFactory::operator() (const Query<Sequence>& query);
} // namespace asset

9
src/proc/assetmanager.cpp
View file

@ -238,10 +238,11 @@ namespace asset {
#include "proc/asset/pipe.hpp"
#include "proc/asset/meta.hpp"
#include "proc/asset/procpatt.hpp"
#include "proc/asset/timeline.hpp"
#include "proc/asset/sequence.hpp"
namespace asset
{
namespace asset {
template ID<Asset> AssetManager::reg (Asset* obj, const Asset::Ident& idi);
@ -258,6 +259,8 @@ namespace asset
template P<Track> AssetManager::wrap (const Track& asset);
template P<Pipe> AssetManager::wrap (const Pipe& asset);
template P<ProcPatt> AssetManager::wrap (const ProcPatt& asset);
template P<Timeline> AssetManager::wrap (const Timeline& asset);
template P<Sequence> AssetManager::wrap (const Sequence& asset);
} // namespace asset

234
src/proc/mobject/session/defsmanager.cpp
View file

@ -36,100 +36,101 @@ using lumiera::query::LUMIERA_ERROR_CAPABILITY_QUERY;
namespace mobject {
namespace session {
namespace session {
using lumiera::P;
/** initialise the most basic internal defaults. */
DefsManager::DefsManager () throw()
: defsRegistry(new DefsRegistry)
{
TODO ("setup basic defaults of the session");
}
/** @internal causes boost::checked_delete from \c scoped_ptr<DefsRegistry>
* to be placed here, where the declaration of DefsRegistry is available.*/
DefsManager::~DefsManager() {}
template<class TAR>
P<TAR>
DefsManager::search (const Query<TAR>& capabilities)
{
P<TAR> res;
QueryHandler<TAR>& typeHandler = ConfigRules::instance();
for (DefsRegistry::Iter<TAR> i = defsRegistry->candidates(capabilities);
res = *i ; ++i )
{
typeHandler.resolve (res, capabilities);
if (res)
return res;
}
return res; // "no solution found"
}
template<class TAR>
P<TAR>
DefsManager::create (const Query<TAR>& capabilities)
{
P<TAR> res;
QueryHandler<TAR>& typeHandler = ConfigRules::instance();
typeHandler.resolve (res, capabilities);
if (res)
defsRegistry->put (res, capabilities);
using lumiera::P;
/** initialise the most basic internal defaults. */
DefsManager::DefsManager () throw()
: defsRegistry(new DefsRegistry)
{
TODO ("setup basic defaults of the session");
}
/** @internal causes boost::checked_delete from \c scoped_ptr<DefsRegistry>
* to be placed here, where the declaration of DefsRegistry is available.*/
DefsManager::~DefsManager() {}
template<class TAR>
P<TAR>
DefsManager::search (const Query<TAR>& capabilities)
{
P<TAR> res;
QueryHandler<TAR>& typeHandler = ConfigRules::instance();
for (DefsRegistry::Iter<TAR> i = defsRegistry->candidates(capabilities);
res = *i ; ++i )
{
typeHandler.resolve (res, capabilities);
if (res)
return res;
}
return res; // "no solution found"
}
template<class TAR>
P<TAR>
DefsManager::create (const Query<TAR>& capabilities)
{
P<TAR> res;
QueryHandler<TAR>& typeHandler = ConfigRules::instance();
typeHandler.resolve (res, capabilities);
if (res)
defsRegistry->put (res, capabilities);
return res;
}
template<class TAR>
bool
DefsManager::define (const P<TAR>& defaultObj, const Query<TAR>& capabilities)
{
P<TAR> candidate (defaultObj);
QueryHandler<TAR>& typeHandler = ConfigRules::instance();
typeHandler.resolve (candidate, capabilities);
if (!candidate)
return false;
else
return defsRegistry->put (candidate, capabilities);
}
template<class TAR>
bool
DefsManager::forget (const P<TAR>& defaultObj)
{
return defsRegistry->forget (defaultObj);
}
template<class TAR>
P<TAR>
DefsManager::operator() (const Query<TAR>& capabilities)
{
P<TAR> res (search (capabilities));
if (res)
return res;
}
else
res = create (capabilities); // not yet known as default, create new
template<class TAR>
bool
DefsManager::define (const P<TAR>& defaultObj, const Query<TAR>& capabilities)
{
P<TAR> candidate (defaultObj);
QueryHandler<TAR>& typeHandler = ConfigRules::instance();
typeHandler.resolve (candidate, capabilities);
if (!candidate)
return false;
else
return defsRegistry->put (candidate, capabilities);
}
template<class TAR>
bool
DefsManager::forget (const P<TAR>& defaultObj)
{
return defsRegistry->forget (defaultObj);
}
if (!res)
throw lumiera::error::Config ( str(format("The following Query could not be resolved: %s.")
% capabilities.asKey())
, LUMIERA_ERROR_CAPABILITY_QUERY );
else
return res;
}
}} // namespace mobject::session
template<class TAR>
P<TAR>
DefsManager::operator() (const Query<TAR>& capabilities)
{
P<TAR> res (search (capabilities));
if (res)
return res;
else
res = create (capabilities); // not yet known as default, create new
if (!res)
throw lumiera::error::Config ( str(format("The following Query could not be resolved: %s.")
% capabilities.asKey())
, LUMIERA_ERROR_CAPABILITY_QUERY );
else
return res;
}
} // namespace mobject::session
} // namespace mobject
@ -140,32 +141,37 @@ namespace mobject {
#include "proc/asset/procpatt.hpp"
#include "proc/asset/pipe.hpp"
#include "proc/asset/track.hpp"
#include "proc/asset/timeline.hpp"
#include "proc/asset/sequence.hpp"
#include "proc/mobject/session/track.hpp"
namespace mobject {
namespace session {
using asset::Pipe;
using asset::PPipe;
using asset::ProcPatt;
using asset::PProcPatt;
using mobject::session::Track;
using mobject::session::TrackAsset;
using mobject::session::PTrack;
using mobject::session::PTrackAsset;
template PPipe DefsManager::operator() (const Query<Pipe>&);
template PProcPatt DefsManager::operator() (const Query<const ProcPatt>&);
template PTrack DefsManager::operator() (const Query<Track>&);
template PTrackAsset DefsManager::operator() (const Query<TrackAsset>&);
template bool DefsManager::define (const PPipe&, const Query<Pipe>&);
template bool DefsManager::forget (const PPipe&);
} // namespace mobject::session
} // namespace mobject
namespace session {
using asset::Pipe;
using asset::PPipe;
using asset::ProcPatt;
using asset::PProcPatt;
using asset::Timeline;
using asset::PTimeline;
using asset::Sequence;
using asset::PSequence;
using mobject::session::Track;
using mobject::session::TrackAsset;
using mobject::session::PTrack;
using mobject::session::PTrackAsset;
template PPipe DefsManager::operator() (const Query<Pipe>&);
template PProcPatt DefsManager::operator() (const Query<const ProcPatt>&);
template PTrack DefsManager::operator() (const Query<Track>&);
template PTrackAsset DefsManager::operator() (const Query<TrackAsset>&);
template PTimeline DefsManager::operator() (const Query<Timeline>&);
template PSequence DefsManager::operator() (const Query<Sequence>&);
template bool DefsManager::define (const PPipe&, const Query<Pipe>&);
template bool DefsManager::forget (const PPipe&);
}} // namespace mobject::session