config-rules.hpp

Go to the documentation of this file.

/*
  CONFIG-RULES.hpp  -  interface for rule based configuration

   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 LUMIERA_CONFIG_RULES_H
#define LUMIERA_CONFIG_RULES_H

#include "lib/p.hpp"
#include "lib/symbol.hpp"
#include "lib/meta/generator.hpp"
#include "common/query.hpp"

#include <string>



namespace lumiera {
  namespace error {
    LUMIERA_ERROR_DECLARE (CAPABILITY_QUERY);  
  }
  
  using std::string;
  using lib::P;

  
  
  
  namespace query {
    
    // The intention is to support the following style of Prolog code
    //
    //  resolve(O, Cap) :- find(O), capabilities(Cap).
    //  resolve(O, Cap) :- make(O), capabilities(Cap).
    //  capabilities(Q) :- call(Q).
    //  
    //  stream(T, mpeg) :- type(T, fork), type(P, pipe), resolve(P, stream(P,mpeg)), placed_to(P, T).
    //
    // The type guard is inserted automatically, while the predicate implementations for
    // find/1, make/1, stream/2, and placed_to/2 are to be provided by the target types.
    //
    // As a example, the goal ":-retrieve(T, stream(T,mpeg))." would search a Fork object (a "track"), try to
    // retrieve a pipe object with stream-type=mpeg and associate the Fork with this Pipe. The
    // predicate "stream(P,mpeg)" needs to be implemented (natively) for the pipe object.
    
    class Resolver
      {
      };
    
    
    using lib::Symbol;
    using lib::Literal;
    using lumiera::Query;
    
#define SYMBOL uint
    
    
    template
      < SYMBOL SYM,                  // Predicate symbol
        typename SIG = bool(string) //  Signature
      >
    class Pred
      { };
      
    template<class TY>
    class TypeHandler
      {
        static const TY NIL;
        
        template<SYMBOL SYM, typename SIG>
        TY find (Pred<SYM,SIG> capability);
        
        template<SYMBOL SYM, typename SIG>
        TY make (Pred<SYM,SIG> capability, TY& refObj =NIL);
      };
    
    template<class TY>
    class QueryHandler
      {
      protected:
        virtual ~QueryHandler()  { }
      public:
        virtual bool resolve (P<TY>& solution, Query<TY> const& q) = 0;
      };
    
    // TODO: the Idea is to provide specialisations for the concrete types
    //       we want to participate in the ConfigRules system....
    //       Thus we get the possibility to create a specific return type,
    //       e.g. return a P<Pipe> but a Placement<Fork>, using the appropriate factory.
    //       Of course then the definitions need to be split up in separate headers.
      
      
      
      
      
    template<typename TYPES>
    class ConfigRules
      : public lib::meta::InstantiateForEach<TYPES, QueryHandler>
      {
      protected:
        ConfigRules ()         {}
        virtual ~ConfigRules() {} 
        
      public:
        virtual void reset()   =0;
        
        // TODO: find out what operations we need to support here for the »real solution« (using Prolog)
      };
  
  } // namespace query
  
  
  
  
  
  
  
  namespace query {
    
    void setFakeBypass(lumiera::QueryKey const& q);
    bool isFakeBypass (lumiera::QueryKey const& q);
    
  } // namespace query
  
} // namespace lumiera
#endif