fake-configrules.hpp

Go to the documentation of this file.

/*
  FAKE-CONFIGRULES.hpp  -  dummy implementation of the config rules system
 
   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.
 
*/
 
 
#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             { using Wrapper = P<TY>;  };
      
      template<>
      struct WrapReturn<ProcPatt>   { using Wrapper = PProcPatt;  };
      
      
      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
      {
        using Tab = std::map<QueryKey,any>;
        
        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)];
        }
      };
    
    
    // GCC > 13 warns at class definition when a new overload shadows an inherited virtual function.
    // While theoretically correct, in practice any call will be dispatched through the base interface
    // and it is not even possible to reach the concrete classes (and the implementation function is private).
    // The workaround with a `using` clause is not applicable, since the name is ambiguous (by design)
    // See https://gcc.gnu.org/bugzilla/show_bug.cgi?id=109740
    _Pragma("GCC diagnostic push") \
    _Pragma("GCC diagnostic ignored \"-Woverloaded-virtual\"")
    
    
    
    template<class TY, class BASE>
    class LookupPreconfigured : public BASE
      {
        using Ret = WrapReturn<TY>::Wrapper;
        
        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
                   or(solution and solution == candidate)      // simulates a real unification
                   )
                  return exists (solution = candidate);
              }
            return try_special_case(solution, q);
          }
        
        bool
        try_special_case (Ret& solution, Query<TY> const& q)
          {
            if (solution and 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 and pipeID == candidate->getPipeID())
        return set_new_mock_solution (q, candidate); // "learn" this solution to be "valid"
      
      if (!isnil(pipeID) and not isnil(streamID))
        return fabricate_matching_new_Pipe (q, pipeID, streamID);
 
      if (not candidate and (not isnil(streamID) or not 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 (not candidate and not 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