struct.cpp

Go to the documentation of this file.

/*
  Struct(Asset)  -  key abstraction: structural asset
 
   Copyright (C)
     2008,            Hermann Vosseler <Ichthyostega@web.de>
 
 **Lumiera** is free software; you can redistribute it and/or modify it
 under the terms of the GNU General Public License as published by the
 Free Software Foundation; either version 2 of the License, or (at your
 option) any later version. See the file COPYING for further details.
 
* *****************************************************************/
 
 
#include "steam/asset/struct.hpp"
#include "steam/assetmanager.hpp"
#include "steam/config-resolver.hpp"
 
#include "steam/asset/struct-factory-impl.hpp"
 
#include "lib/util.hpp"
#include "lib/symbol.hpp"
#include "lib/query-util.hpp"
#include "lib/format-string.hpp"
#include "include/logging.h"
#include "common/query.hpp"
 
using util::_Fmt;
using lib::Symbol;
using lib::query::normaliseID;
using lumiera::query::QueryHandler;
using steam::ConfigResolver;
 
using util::contains;
 
 
namespace steam {
namespace asset {
  
  /****** NOTE: not fully implemented yet. What follows is partially a hack to build simple tests *******/
  
  
  
  
  
  StructFactory Struct::retrieve;
  
  
  StructFactory::StructFactory ()
    : impl_(new StructFactoryImpl(*this)) 
  { }
  
  
  template<class STRU>
  lib::P<STRU>
  StructFactory::newInstance (Symbol nameID)
  {
    Query<STRU> desired_name (isnil(nameID)? "" : "id("+nameID+")");
    STRU* pS = impl_->fabricate (desired_name);
    return AssetManager::instance().wrap (*pS);
  }
  
  
  
  template<class STRU>
  lib::P<STRU>
  StructFactory::operator() (Query<STRU> const& capabilities)
  {
    lib::P<STRU> res;
    QueryHandler<STRU>& typeHandler = ConfigResolver::instance();
    typeHandler.resolve (res, capabilities);
    
    if (res)
      return res;
    
    // create new one, since the
    // ConfigQuery didn't yield any result
    STRU* pS = impl_->fabricate(capabilities);
    return AssetManager::instance().wrap (*pS);
  }
  
  
 
  template<class STRU>
  lib::P<STRU>
  StructFactory::made4fake (Query<STRU> const& query)
  {
    STRU* pS = impl_->fabricate(query);
    return AssetManager::instance().wrap (*pS);
  }
  
  
  lib::P<Pipe> 
  StructFactory::newPipe (string pipeID, string streamID)
  {
    normaliseID (pipeID);
    normaliseID (streamID);
    _Fmt descriptor("pipe(%s), stream(%s).");
    Pipe* pP = impl_->fabricate (Query<Pipe> (descriptor % pipeID % streamID));
    return AssetManager::instance().wrap (*pP);
  }
  
  
  
}} // namespace asset
 
 
 
 
   /**************************************************/
   /* explicit instantiations of the factory methods */
   /**************************************************/
 
#include "steam/asset/pipe.hpp"
#include "steam/asset/procpatt.hpp"
#include "steam/asset/timeline.hpp"
#include "steam/asset/sequence.hpp"
 
 
namespace steam {
namespace asset {
  using PPipe = lib::P<Pipe>;
  
  template PPipe       StructFactory::operator() (Query<Pipe> const&);
  template PProcPatt   StructFactory::operator() (Query<const ProcPatt> const&);
  template PTimeline   StructFactory::operator() (Query<Timeline> const&);
  template PSequence   StructFactory::operator() (Query<Sequence>const&);
  
  template PPipe       StructFactory::newInstance (Symbol);
  template PProcPatt   StructFactory::newInstance (Symbol);
  template PTimeline   StructFactory::newInstance (Symbol);
  template PSequence   StructFactory::newInstance (Symbol);
  
  template PPipe       StructFactory::made4fake   (Query<Pipe> const&);          
  template PProcPatt   StructFactory::made4fake   (Query<const ProcPatt> const&);
  template PTimeline   StructFactory::made4fake   (Query<Timeline> const&);      
  template PSequence   StructFactory::made4fake   (Query<Sequence>const&);       
  
}} // namespace asset