fake-configrules.hpp

Go to the documentation of this file.

/*
  FAKE-CONFIGRULES.hpp  -  dummy implementation of the config rules system

  Copyright (C)         Lumiera.org
    2008,               Hermann Vosseler <Ichthyostega@web.de>

  This program 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.

  This program is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.

  You should have received a copy of the GNU General Public License
  along with this program; if not, write to the Free Software
  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

*/


#ifndef MOBJECT_SESSION_QUERY_FAKECONFIGRULES_H
#define MOBJECT_SESSION_QUERY_FAKECONFIGRULES_H

#include "steam/mobject/session.hpp"
#include "steam/config-resolver.hpp"
#include "lib/depend-inject.hpp"
#include "lib/query-util.hpp"
#include "lib/util.hpp"
#include "lib/p.hpp"

#include <boost/any.hpp>
#include <string>
#include <map>



namespace steam {
namespace mobject {
namespace session {
  namespace query {
    
    namespace asset = steam::asset;
    
    using asset::Pipe;
    using asset::ProcPatt;
    using asset::PProcPatt;
    using steam::mobject::Session;
    using lib::meta::InstantiateChained;
    using lib::P;
    
    using lumiera::Query;
    using lumiera::QueryKey;
    using lumiera::query::isFakeBypass;      
    
    using util::contains;
    using util::isnil;
    
    using boost::any;
    using boost::any_cast;
    
    
    
    
    
    namespace { // internal details
      
      template<class TY>
      struct WrapReturn             { typedef P<TY> Wrapper;  };
      
      template<>
      struct WrapReturn<ProcPatt>   { typedef PProcPatt Wrapper;  };
      
      
      template<typename TY>
      inline bool
      is_defaults_query (Query<TY> const& querySpec)
      {
        return querySpec.usesPredicate ("default");
      }
      
      template<typename WRA>
      inline bool
      exists(WRA const& solution)
      {
        return bool(solution);
      }
      
    } // details (end)
    
    
    
    class MockTable
      : public steam::ConfigResolver
      {
        typedef std::map<QueryKey,any> Tab;
        
        Tab  answer_;
        bool isInit_;
        
      protected:
        MockTable ();
        virtual void reset();
        any const& fetch_from_table_for (QueryKey const& query);
        
        // special cases....
        template<class TY> 
        bool detect_case (typename WrapReturn<TY>::Wrapper&, Query<TY> const&);
        bool fabricate_matching_new_Pipe  (Query<Pipe> const& q, string const& pipeID, string const& streamID);
        bool fabricate_just_new_Pipe      (Query<Pipe> const& q);
        bool fabricate_ProcPatt_on_demand (Query<const ProcPatt> const& q);
        bool fabricate_Timeline_on_demand (Query<asset::Timeline> const& q);
        bool fabricate_Sequence_on_demand (Query<asset::Sequence> const& q);
        
        template<class TY>
        bool set_new_mock_solution (Query<TY> const& q, typename WrapReturn<TY>::Wrapper& candidate);

        
      private:
        void fill_mock_table ();
        
        template<class STRU>
        any&
        item (string const& querySpec)
        {
          return answer_[Query<STRU>(querySpec)];
        }
      };
    
    
    template<class TY, class BASE>
    class LookupPreconfigured : public BASE
      {
        typedef typename WrapReturn<TY>::Wrapper Ret;
        
        
        virtual bool 
        resolve (Ret& solution, Query<TY> const& q)
          {
            any const& entry = this->fetch_from_table_for(q);
            if (!isnil (entry))
              {
                Ret const& candidate (any_cast<Ret const&> (entry));
                if (! solution
                   ||(solution &&  solution == candidate)      // simulates a real unification
                   )
                  return exists (solution = candidate);
              }
            return try_special_case(solution, q);
          }
      
      private:
        bool
        try_special_case (Ret& solution, Query<TY> const& q)
          {
            if (solution && isFakeBypass(q))        // backdoor for tests
              return exists (solution);
            
            if (is_defaults_query (q))
              {
                Query<TY> defaultsQuery = q.rebuild().removeTerm("default");
                return exists (solution = Session::current->defaults (defaultsQuery));
              }                             //  may lead to recursion
                                            
            if (this->detect_case (solution, q))
              return resolve (solution, q);
            
            return exists (solution = Ret());  // fail: return default-constructed empty smart ptr
          }
      };
    
    
    template<class TY>
    inline bool 
    MockTable::detect_case (typename WrapReturn<TY>::Wrapper&, Query<TY> const&)
    {
      return false;
    }
    template<>
    inline bool 
    MockTable::detect_case (WrapReturn<Pipe>::Wrapper& candidate, Query<Pipe> const& q)
    {
      if (q.usesPredicate ("make"))
        // used by tests to force fabrication of a new "solution"
        return fabricate_just_new_Pipe (q);
      
      const string pipeID   = q.extractID("pipe");
      const string streamID = q.extractID("stream");
      
      if (candidate && pipeID == candidate->getPipeID())
        return set_new_mock_solution (q, candidate); // "learn" this solution to be "valid"
      
      if (!isnil(pipeID) && !isnil(streamID))
        return fabricate_matching_new_Pipe (q, pipeID, streamID);

      if (!candidate && (!isnil(streamID) || !isnil(pipeID)))
        return fabricate_just_new_Pipe (q);
      
      return false;
    }
    
    template<>
    inline bool 
    MockTable::detect_case (WrapReturn<const ProcPatt>::Wrapper& candidate, Query<const ProcPatt> const& q)
    {
      const string streamID = q.extractID("stream");
      
      if (!candidate && !isnil(streamID))
          return fabricate_ProcPatt_on_demand (q);
      return false;
    }
    
    template<>
    inline bool 
    MockTable::detect_case (WrapReturn<asset::Timeline>::Wrapper& candidate, Query<asset::Timeline> const& q)
    {
      if (!candidate)
          return fabricate_Timeline_on_demand (q);
      return bool(candidate);
    }
    
    template<>
    inline bool 
    MockTable::detect_case (WrapReturn<asset::Sequence>::Wrapper& candidate, Query<asset::Sequence> const& q)
    {
      if (!candidate)
          return fabricate_Sequence_on_demand (q);
      return bool(candidate);
    }
    
    
    
    
    
    
    class MockConfigRules 
      : public InstantiateChained < steam::InterfaceTypes           
                                  , LookupPreconfigured  // building block used for each of the types
                                  , MockTable           //  for implementing the base class (interface) 
                                  >
      {
      protected:
        MockConfigRules ();                         
        friend class lib::DependencyFactory<MockConfigRules>;
        friend class lib::DependInject<ConfigResolver>::Local<MockConfigRules>;
      public:
        virtual ~MockConfigRules() {}           
        
        
        /* === implementation of additional functions on the ConfigRules interface goes here === */
      };
      
    
    
  } // namespace query
}}} // namespace steam::mobject::session
#endif