PatternMatchCallback.h

Go to the documentation of this file.

/*
 * PatternMatchCallback.h
 *
 * Author: Linas Vepstas February 2008
 *
 * Copyright (C) 2008,2009,2014 Linas Vepstas <linasvepstas@gmail.com>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License v3 as
 * published by the Free Software Foundation and including the exceptions
 * at http://opencog.org/wiki/Licenses
 *
 * 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 Affero General Public License
 * along with this program; if not, write to:
 * Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */

#ifndef _OPENCOG_PATTERN_MATCH_CALLBACK_H
#define _OPENCOG_PATTERN_MATCH_CALLBACK_H

#include <map>
#include <set>
#include <opencog/atomspace/Handle.h>
#include <opencog/atomspace/Link.h>
#include <opencog/atoms/bind/VariableList.h> // for VariableTypeMap

// #define DEBUG 1

namespace opencog {
class PatternMatchEngine;

class PatternMatchCallback
{
    public:
        virtual ~PatternMatchCallback() {};

        virtual bool node_match(const Handle& patt_node,
                                const Handle& grnd_node) = 0;

        virtual bool variable_match(const Handle& patt_node,
                                    const Handle& grnd_node) = 0;

        virtual bool link_match(const LinkPtr& patt_link,
                                const LinkPtr& grnd_link) = 0;

        virtual bool post_link_match(const LinkPtr& patt_link,
                                     const LinkPtr& grnd_link)
        {
            return true; // Accept the match, by default.
        }

        virtual bool fuzzy_match(const Handle& ph, const Handle& gh)
        {
            return false;
        }

        virtual bool evaluate_sentence(const Handle& eval,
                              const std::map<Handle,Handle>& gnds) = 0;

        virtual bool clause_match(const Handle& pattrn_link_h,
                                  const Handle& grnd_link_h)
        {
            // By default, reject a clause that is grounded by itself.
            // XXX someone commented this out... why??? Do you really
            // want self-grounding???
            //  if (pattrn_link_h == grnd_link_h) return false;
            return true;
        }

        virtual bool optional_clause_match(const Handle& pattrn,
                                           const Handle& grnd) = 0;

        virtual bool grounding(const std::map<Handle, Handle> &var_soln,
                               const std::map<Handle, Handle> &term_soln) = 0;

        virtual IncomingSet get_incoming_set(const Handle& h)
        {
            return h->getIncomingSet();
        }

        virtual void push(void) {}

        virtual void pop(void) {}

        virtual const std::set<Type>& get_connectives(void)
        { static const std::set<Type> _empty; return _empty; }

        virtual bool initiate_search(PatternMatchEngine *) = 0;

        virtual void set_pattern(const Variables& vars,
                                 const Pattern& pat) = 0;
};

} // namespace opencog

#endif // _OPENCOG_PATTERN_MATCH_CALLBACK_H