common/advice/binding.hpp

Go to the documentation of this file.

/*
  BINDING.hpp  -  pattern defining a specific attachment to the Advice system

  Copyright (C)         Lumiera.org
    2010,               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 LUMIERA_ADVICE_BINDING_H
#define LUMIERA_ADVICE_BINDING_H


#include "lib/error.hpp"
#include "lib/symbol.hpp"
#include "lib/hash-value.h"
#include "lib/query-util.hpp"

#include <string>
#include <set>


namespace lumiera{
namespace advice {
  
  using lib::Literal;
  using std::string;
  using lib::HashVal;
  
  LUMIERA_ERROR_DECLARE (BINDING_PATTERN_SYNTAX); 
  
  
  
  class Binding
    {
      
      class Atom
        {
          uint   ari_;
          string sym_;
          string arg_;
          
        public:
          explicit
          Atom (string const& symbol ="nil", uint arity =0, string const& arg ="")
            : ari_(arity), sym_(symbol), arg_(arg)
            { }
          
          string const& sym()  const { return sym_; }
          string const& arg()  const { return arg_; }
          uint        arity()  const { return ari_; }
          
          operator string()  const;
          
          bool
          identical (Atom const& oa)  const
            {
              return ari_ == oa.ari_
                  && sym_ == oa.sym_
                  && arg_ == oa.arg_;
            }
          
          int
          compare (Atom const& oa)  const               
            {
              int res;
              if (0 != (res=sym().compare (oa.sym())))  return res;
              if (0 != (res=arity() - (oa.arity())))    return res;
              return arg().compare (oa.arg());                        
            }                                                         
          friend bool
          operator< (Atom const& a1, Atom const& a2)
          {
            return a1.compare(a2) < 0; 
          }
        };
      
      
      typedef std::set<Atom> NormalisedAtoms;
      
      NormalisedAtoms atoms_;
      
      
    public:
      class Matcher
        {
          HashVal bindingHash_;
          
          
          Matcher (HashVal ha)
            : bindingHash_(ha)
            { }
          
          friend class Binding;
          
          
        public:
          bool matches (Binding const& obi)  const;
          bool matches (Binding::Matcher const& oma)  const;
          
          friend HashVal hash_value (Matcher const&);
        };
      
      
      
      
      Binding();
      
      Binding (Literal spec);
      
      /*-- Binding is default copyable --*/
      
      void addPredicate (Literal spec);
      
      template<typename TY>
      Binding const& addTypeGuard();
      
      
      Matcher buildMatcher()  const;
      HashVal calculateHash() const;
      
      operator string()  const;
      
      friend bool operator== (Binding const&, Binding const&);
      
      
    private:
      void parse_and_append (Literal def);
    };
  
  
  template<typename TY>
  inline Binding const&
  Binding::addTypeGuard()
  {
    atoms_.insert (Atom ("advice.type."+lib::query::buildTypeID<TY>()));
    return *this;
  }
  
  
  
  
  /* === equality comparison and matching === */
  
  
  inline bool
  operator!= (Binding const& b1, Binding const& b2)
  {
    return not (b1 == b2);
  }
  
  
  inline bool
  matches (Binding const& b1, Binding const& b2)
  {
    return b1.buildMatcher().matches (b2);
  }
  
  inline bool
  matches (Binding::Matcher const& m1, Binding::Matcher const& m2)
  {
    return m1.matches (m2);
  }
  
  
  inline Binding::Matcher
  Binding::buildMatcher()  const
  {
    return Matcher (this->calculateHash());
  }
  
  
  
  /* == access hash values used for matching == */
  
  inline bool
  Binding::Matcher::matches (Binding const& obi)  const
  {
    return bindingHash_ == obi.calculateHash();
  }
          
  inline bool
  Binding::Matcher::matches (Binding::Matcher const& oma)  const
  {
    return bindingHash_ == hash_value(oma);
  }
          
  inline HashVal
  hash_value (Binding::Matcher const& bm)
  {
    return bm.bindingHash_;
  }
  
  inline HashVal
  hash_value (Binding const& bi)
  {
    return bi.calculateHash();
  }
  
  
  
  
  
  
}} // namespace lumiera::advice
#endif