Lumiera  0.pre.03
»edityourfreedom«
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Modules Pages
fake-configrules.cpp
Go to the documentation of this file.
1 /*
2  FakeConfigRules - dummy implementation of the config rules system
3 
4  Copyright (C) Lumiera.org
5  2008, Hermann Vosseler <Ichthyostega@web.de>
6 
7  This program is free software; you can redistribute it and/or
8  modify it under the terms of the GNU General Public License as
9  published by the Free Software Foundation; either version 2 of
10  the License, or (at your option) any later version.
11 
12  This program is distributed in the hope that it will be useful,
13  but WITHOUT ANY WARRANTY; without even the implied warranty of
14  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15  GNU General Public License for more details.
16 
17  You should have received a copy of the GNU General Public License
18  along with this program; if not, write to the Free Software
19  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
20 
21 * *****************************************************/
22 
23 
40 
41 #include "proc/mobject/session.hpp"
43 #include "proc/asset/procpatt.hpp"
44 #include "proc/asset/pipe.hpp"
45 #include "lib/query-util.hpp"
46 #include "common/query.hpp"
47 
48 #include "include/logging.h"
49 #include "lib/symbol.hpp"
50 #include "lib/util.hpp"
51 
52 using lib::Literal;
53 using util::isnil;
54 
56 
57 namespace proc {
58 namespace mobject {
59 namespace session {
60 
61  namespace query {
62 
63  using asset::Struct;
64  using asset::Pipe;
65  using asset::PPipe;
66 
67  using asset::ProcPatt;
68  using asset::PProcPatt;
69 
70 // using lib::query::extractID;
71  using lib::query::extractID;
73 
74 
75  namespace {
76 
77  typedef std::pair<const QueryKey, any> AnyPair;
78 
80  template<class TY>
81  AnyPair entry (Query<TY> const& query, typename WrapReturn<TY>::Wrapper& obj)
82  {
83  return AnyPair(query, any(obj));
84  }
85 
87  template<class STRU>
88  AnyPair entry_Struct(Literal caps)
89  {
90  typedef typename WrapReturn<STRU>::Wrapper Ptr;
91 
92  string capabilities (caps);
93  Query<STRU> query (capabilities);
94  Ptr obj = Struct::retrieve (query);
95  return AnyPair(query, obj);
96  }
97  }
98 
99 
105  void
107  {
108  INFO (config, "creating mock answers for some hard wired config queries...");
109  isInit_ = true; // allow re-entrance
110 
111  typedef const ProcPatt cPP;
112 
113 
114  // for baiscpipetest.cpp ---------
115  answer_.insert (entry_Struct<cPP> ("stream(video)"));
116  answer_.insert (entry_Struct<cPP> ("stream(teststream)"));
117  item<cPP> ("stream(default)") = item<cPP> ("stream(video)"); // set up a default stream
118 
119  answer_.insert (entry_Struct<Pipe> ("pipe(master), stream(video)"));
120  item<Pipe> ("") = item<Pipe>("pipe(master), stream(video)");// use as default
121 
122  answer_.insert (entry_Struct<Pipe> ("pipe(ambiance)"));
123  }
124 
125 
129  void
131  {
132  answer_.clear();
133  isInit_ = false;
134  INFO (config, "discarded all config query mock answers.");
135  }
136 
137 
138 
139 
140 
141  /* under some circumstances we need to emulate the behaviour *
142  * of a real resolution engine in a more detailed manner. *
143  * The code below implements these cases hard wired. */
144 
146  bool
147  MockTable::fabricate_matching_new_Pipe (Query<Pipe> const& q, string const& pipeID, string const& streamID)
148  {
149  typedef WrapReturn<Pipe>::Wrapper Ptr;
150 
151  Ptr newPipe (Struct::retrieve.newPipe (pipeID, streamID));
152  answer_.insert (entry<Pipe> (q, newPipe));
153  return true; // indicates that the query will now succeed...
154  }
155 
157  bool
159  {
160  typedef WrapReturn<Pipe>::Wrapper Ptr;
161 
162  Ptr newPipe (Struct::retrieve.made4fake (q));
163  answer_.insert (entry<Pipe> (q, newPipe));
164  return true;
165  }
166 
168  bool
170  {
171  typedef const ProcPatt cPP;
172  typedef WrapReturn<cPP>::Wrapper Ptr;
173 
174  Ptr newPP (Struct::retrieve.made4fake (q));
175  answer_.insert (entry<cPP> (q, newPP));
176  return true;
177  }
178 
183  bool
185  {
186  typedef asset::Timeline aTL;
187  typedef WrapReturn<aTL>::Wrapper Ptr;
188 
189  string nameID = query.extractID("id");
190  if (isnil (nameID))
191  nameID = query.extractID("timeline");
192  if (isnil (nameID))
193  nameID = "prime";
194 
195  Query<aTL> normalisedQuery =
196  query.rebuild()
197  .removeTerm("id")
198  .removeTerm("timeline")
199  .prependConditions("id("+nameID+")");
200 
201  // try to find an existing one with the desired id
202  Ptr newTimeline;
203  size_t i=0, cnt=Session::current->timelines.size();
204  for ( ; i < cnt; ++i)
205  if (nameID == Session::current->timelines[i]->ident.name)
206  {
207  newTimeline = Session::current->timelines[i];
208  break;
209  }
210 
211  if (!newTimeline)
212  newTimeline = Struct::retrieve.made4fake (normalisedQuery); // no suitable Timeline found: create and attach new one
213  answer_.insert (entry<aTL> (normalisedQuery, newTimeline)); // "learn" the found/created Timeline as new solution
214  answer_.insert (entry<aTL> (query, newTimeline));
215  return true;
216  }
217 
219  bool
221  {
222  typedef asset::Sequence aSeq;
223  typedef WrapReturn<aSeq>::Wrapper Ptr;
224 
225  string nameID = query.extractID("id");
226  if (isnil (nameID))
227  nameID = query.extractID("sequence");
228  if (isnil (nameID))
229  nameID = "first";
230 
231  Query<aSeq> normalisedQuery =
232  query.rebuild()
233  .removeTerm("id")
234  .removeTerm("sequence")
235  .prependConditions("id("+nameID+")");
236 
237  // try to find an existing sequence with the desired id
238  Ptr newSequence;
239  size_t i=0, cnt=Session::current->sequences.size();
240  for ( ; i < cnt; ++i)
241  if (nameID == Session::current->sequences[i]->ident.name)
242  {
243  newSequence = Session::current->sequences[i];
244  break;
245  }
246 
247  if (!newSequence)
248  newSequence = Struct::retrieve.made4fake (normalisedQuery); // no suitable found: create and attach new Sequence
249  answer_.insert (entry<aSeq> (normalisedQuery, newSequence)); // "learn" the found/created new solution
250  answer_.insert (entry<aSeq> (query, newSequence));
251  return true;
252  }
253 
254 
256  template<class TY>
257  bool
259  {
260  answer_.erase (q);
261  answer_.insert (entry<TY> (q, obj));
262  return true;
263  }
264  // generate the necessary specialisations-----------------------------------
265  template bool MockTable::set_new_mock_solution (Query<Pipe> const&, PPipe&);
266 
267 
268 
269 
270 
272  {
273  WARN (config, "using a mock implementation of the ConfigQuery interface");
274  }
275 
276 
278  : answer_()
279  , isInit_(false)
280  { }
281 
282 
283 
284 
295  any const&
297  {
298  static const any NOTFOUND;
299  if (!isInit_) fill_mock_table();
300 
301  Tab::iterator i = answer_.find (query);
302  if (i == answer_.end())
303  return NOTFOUND;
304  else
305  return i->second;
306  }
307 
308 
309 
310  } // namespace query
311 }}} // namespace proc::mobject::session
bool fabricate_Timeline_on_demand(Query< asset::Timeline > const &q)
special case: fabricate new Timeline, maybe using specific sub-objects as hinted by the IDs given wit...
string extractID(Symbol sym, const string &termString)
(preliminary) helper: instead of really parsing and evaluating the terms, just do a regular expressio...
Definition: query-util.cpp:100
Utilities to support working with predicate queries.
Definition of a structural asset to express patterns of wiring or processing Processing patterns can ...
A "processing pipe" represented as Asset.
SequenceAccess sequences
collection of sequences
Definition: session.hpp:132
Customised refcounting smart pointer template, built upon std::shared_ptr, but forwarding type relati...
Definition: trait.hpp:76
Basic and generic representation of an internal query.
lib::P< const asset::ProcPatt > PProcPatt
Mock/Test/Debugging Implementation of the config rules system.
bool fabricate_just_new_Pipe(Query< Pipe > const &q)
special case: create a new pipe for a specific stream ID
inline string literal This is a marker type to indicate that
Definition: symbol.hpp:75
virtual size_t size() const =0
TimelineAccess timelines
collection of timelines (top level)
Definition: session.hpp:131
static session::SessManager & current
access point to the current Session
Definition: session.hpp:127
typename meta::Strip< CON >::TypeReferred::iterator iterator
lib::P< Pipe > PPipe
Definition: pipe.hpp:51
This header is for including and configuring NoBug.
Organisational grouping device within the Session model ("Track" / "Media Bin").
bool fabricate_ProcPatt_on_demand(Query< const ProcPatt > const &q)
special case: create/retrieve new processing pattern for given stream ID...
key abstraction: structural asset Created automatically as a sideeffect of building the structure of ...
Definition: struct.hpp:112
virtual void reset()
clear the contents of the mock solution table.
string removeTerm(Symbol sym, string &queryString)
(preliminary) helper: cut a term with the given symbol.
Definition: query-util.cpp:117
Builder rebuild() const
Definition: query.hpp:581
Marker types to indicate a literal string and a Symbol.
Tiny helper functions and shortcuts to be used everywhere Consider this header to be effectively incl...
MockConfigRules()
to be used only by the singleton factory
string extractID(Symbol predicate) const
convenience shortcut to extract a desired name-ID.
Definition: query.hpp:595
any const & fetch_from_table_for(QueryKey const &query)
this is the (preliminary/mock) implementation handling queries for objects of a specific type and wit...
Wrapper for indexing and ordering.
Definition: query.hpp:397
bool isnil(lib::time::Duration const &dur)
Definition: timevalue.hpp:642
Namespace of Session and user visible high-level objects.
bool fabricate_matching_new_Pipe(Query< Pipe > const &q, string const &pipeID, string const &streamID)
special case: create a new pipe with matching pipe and stream IDs on the fly when referred...
structural asset corresponding to the part of the model forming a processing pipe for generating medi...
Definition: pipe.hpp:79
OutputDesignation::PPipe PPipe
Primary Interface to the current Session.
Proc-Layer implementation namespace root.
Definition: id-scheme.hpp:63
"Processing Pattern" is a structural Asset representing information how to build some part of the ren...
Definition: procpatt.hpp:61
bool set_new_mock_solution(Query< TY > const &q, typename WrapReturn< TY >::Wrapper &candidate)
for entering "valid" solutions on-the-fly from tests
bool fabricate_Sequence_on_demand(Query< asset::Sequence > const &q)
special case: fabricate new Timeline, maybe using ID specs from the query...
Generic interface to express a query for specifically typed result elements exposing some capabilitie...
Definition: query.hpp:279
void fill_mock_table()
hard coded answers to configuration queries.