VariableList.h

Go to the documentation of this file.

/*
 * opencog/atoms/VariableList.h
 *
 * Copyright (C) 2015 Linas Vepstas
 * All Rights Reserved
 *
 * 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_VARIABLE_LIST_H
#define _OPENCOG_VARIABLE_LIST_H

#include <map>

#include <opencog/atomspace/Handle.h>
#include <opencog/atomspace/Link.h>
#include <opencog/query/Pattern.h>

namespace opencog
{
class VariableList : public Link
{
protected:
    Variables _varlist;

    // See VariableList.cc for comments
    void get_vartype(const Handle&);

    // Validate the variable decls
    void validate_vardecl(const Handle&);
    void validate_vardecl(const HandleSeq&);

    VariableList(Type, const HandleSeq&,
               TruthValuePtr tv = TruthValue::DEFAULT_TV(),
               AttentionValuePtr av = AttentionValue::DEFAULT_AV());

    void build_index(void);
    Handle substitute_nocheck(const Handle&, const HandleSeq&) const;
public:
    VariableList(const HandleSeq& vardecls,
               TruthValuePtr tv = TruthValue::DEFAULT_TV(),
               AttentionValuePtr av = AttentionValue::DEFAULT_AV());

    VariableList(Link&);

    // Return the list of variables we are holding.
    const Variables& get_variables(void) const { return _varlist; }

    // Return true if we are holding a single variable, and the handle
    // given as the argument satisfies the type restrictions (if any).
    // Else return false.
    bool is_type(const Handle&) const;

    // Return true if the sequence is of the same length as the variable
    // declarations we are holding, and if they satisfy all of the type
    // restrictions (if any).
    bool is_type(const HandleSeq&) const;

    // Given the tree `tree` containing variables in it, create and
    // return a new tree with the indicated values `vals` substituted
    // for the variables. The vals must pass the typecheck, else an
    // exception is thrown.
    Handle substitute(const Handle& tree, const HandleSeq& vals) const;
};

typedef std::shared_ptr<VariableList> VariableListPtr;
static inline VariableListPtr VariableListCast(const Handle& h)
    { AtomPtr a(h); return std::dynamic_pointer_cast<VariableList>(a); }
static inline VariableListPtr VariableListCast(AtomPtr a)
    { return std::dynamic_pointer_cast<VariableList>(a); }

// XXX temporary hack ...
#define createVariableList std::make_shared<VariableList>

}

#endif // _OPENCOG_VARIABLE_LIST_H