VariableList.cc

Go to the documentation of this file.

/*
 * VariableList.cc
 *
 * Copyright (C) 2009, 2014, 2015 Linas Vepstas
 *
 * Author: Linas Vepstas <linasvepstas@gmail.com>  January 2009
 *
 * 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.
 */

#include <opencog/atomspace/ClassServer.h>
#include <opencog/atoms/TypeNode.h>

#include "VariableList.h"

using namespace opencog;

void VariableList::validate_vardecl(const HandleSeq& oset)
{
    for (const Handle& h: oset)
    {
        Type t = h->getType();
        if (VARIABLE_NODE == t)
        {
            _varlist.varset.insert(h);    // tree (unordered)
            _varlist.varseq.push_back(h); // vector (ordered)
        }
        else if (TYPED_VARIABLE_LINK == t)
        {
            get_vartype(h);
        }
        else
            throw InvalidParamException(TRACE_INFO,
                "Expected a VariableNode or a TypedVariableLink, got: %s",
                    classserver().getTypeName(t).c_str());
    }
    build_index();
}

VariableList::VariableList(const HandleSeq& oset,
                       TruthValuePtr tv, AttentionValuePtr av)
    : Link(VARIABLE_LIST, oset, tv, av)
{
    validate_vardecl(oset);
}

VariableList::VariableList(Type t, const HandleSeq& oset,
                       TruthValuePtr tv, AttentionValuePtr av)
    : Link(t, oset, tv, av)
{
    // derived classes have a different initialization order
    if (VARIABLE_LIST != t) return;
    validate_vardecl(oset);
}

VariableList::VariableList(Link &l)
    : Link(l)
{
    // Type must be as expected
    Type tscope = l.getType();
    if (not classserver().isA(tscope, VARIABLE_LIST))
    {
        const std::string& tname = classserver().getTypeName(tscope);
        throw InvalidParamException(TRACE_INFO,
            "Expecting a VariableList, got %s", tname.c_str());
    }

    // Dervided types have a different initialization sequence
    if (VARIABLE_LIST != tscope) return;
    validate_vardecl(_outgoing);
}

/* ================================================================= */
typedef std::pair<Handle, const std::set<Type> > ATPair;

void VariableList::get_vartype(const Handle& htypelink)
{
    const std::vector<Handle>& oset = LinkCast(htypelink)->getOutgoingSet();
    if (2 != oset.size())
    {
        throw InvalidParamException(TRACE_INFO,
            "TypedVariableLink has wrong size, got %lu", oset.size());
    }

    Handle varname = oset[0];
    Handle vartype = oset[1];

    // The vartype is either a single type name, or a list of typenames.
    Type t = vartype->getType();
    if (TYPE_NODE == t)
    {
        Type vt = TypeNodeCast(vartype)->get_value();
        std::set<Type> ts = {vt};
        _varlist.typemap.insert(ATPair(varname, ts));
        _varlist.varset.insert(varname);
        _varlist.varseq.push_back(varname);
    }
    else if (TYPE_CHOICE == t)
    {
        std::set<Type> ts;

        const std::vector<Handle>& tset = LinkCast(vartype)->getOutgoingSet();
        size_t tss = tset.size();
        for (size_t i=0; i<tss; i++)
        {
            Handle h(tset[i]);
            Type var_type = h->getType();
            if (TYPE_NODE != var_type)
            {
                throw InvalidParamException(TRACE_INFO,
                    "VariableChoice has unexpected content:\n"
                              "Expected TypeNode, got %s",
                              classserver().getTypeName(h->getType()).c_str());
            }
            Type vt = TypeNodeCast(h)->get_value();
            ts.insert(vt);
        }

        _varlist.typemap.insert(ATPair(varname,ts));
        _varlist.varset.insert(varname);
        _varlist.varseq.push_back(varname);
    }
    else
    {
        throw InvalidParamException(TRACE_INFO,
            "Unexpected contents in TypedVariableLink\n"
            "Expected TypeNode or TypeChoice, got %s",
            classserver().getTypeName(t).c_str());
    }
}

/* ================================================================= */
void VariableList::validate_vardecl(const Handle& hdecls)
{
    // Expecting the declaration list to be either a single
    // variable, or a list of variable declarations
    Type tdecls = hdecls->getType();
    if ((VARIABLE_NODE == tdecls) or
        NodeCast(hdecls)) // allow *any* node as a variable
    {
        _varlist.varset.insert(hdecls);
        _varlist.varseq.push_back(hdecls);
    }
    else if (TYPED_VARIABLE_LINK == tdecls)
    {
        get_vartype(hdecls);
    }
    else if (VARIABLE_LIST == tdecls or LIST_LINK == tdecls)
    {
        // The list of variable declarations should be .. a list of
        // variables! Make sure its as expected.
        const std::vector<Handle>& dset = LinkCast(hdecls)->getOutgoingSet();
        validate_vardecl(dset);
    }
    else
    {
        throw InvalidParamException(TRACE_INFO,
            "Expected a VariableList holding variable declarations");
    }
    build_index();
}

/* ================================================================= */
bool VariableList::is_type(const Handle& h) const
{
    // The arity must be one for there to be a match.
    if (1 != _varlist.varset.size()) return false;

    // No type restrictions.
    if (0 == _varlist.typemap.size()) return true;

    // Check the type restrictions.
    VariableTypeMap::const_iterator it =
        _varlist.typemap.find(_varlist.varseq[0]);
    const std::set<Type> &tchoice = it->second;

    Type htype = h->getType();
    std::set<Type>::const_iterator allow = tchoice.find(htype);
    return allow != tchoice.end();
}

/* ================================================================= */
bool VariableList::is_type(const HandleSeq& hseq) const
{
    // The arity must be one for there to be a match.
    size_t len = hseq.size();
    if (_varlist.varset.size() != len) return false;
    // No type restrictions.
    if (0 == _varlist.typemap.size()) return true;

    // Check the type restrictions.
    for (size_t i=0; i<len; i++)
    {
        VariableTypeMap::const_iterator it =
            _varlist.typemap.find(_varlist.varseq[i]);
        if (it == _varlist.typemap.end()) continue;  // no restriction

        const std::set<Type> &tchoice = it->second;
        Type htype = hseq[i]->getType();
        std::set<Type>::const_iterator allow = tchoice.find(htype);
        if (allow == tchoice.end()) return false;
    }
    return true;
}

/* ================================================================= */
void VariableList::build_index(void)
{
    if (0 < _varlist.index.size()) return;
    size_t sz = _varlist.varseq.size();
    for (size_t i=0; i<sz; i++)
    {
        _varlist.index.insert(std::pair<Handle, unsigned int>(_varlist.varseq[i], i));
    }
}

/* ================================================================= */
Handle VariableList::substitute(const Handle& fun,
                                const HandleSeq& args) const
{
    if (args.size() != _varlist.varseq.size())
        throw InvalidParamException(TRACE_INFO,
            "Incorrect numer of arguments specified, expecting %lu got %lu",
            _varlist.varseq.size(), args.size());

    if (not is_type(args))
        throw InvalidParamException(TRACE_INFO,
            "Arguments fail to match variable declarations");

    return substitute_nocheck(fun, args);
}

Handle VariableList::substitute_nocheck(const Handle& term,
                                        const HandleSeq& args) const
{
    // If it is a singleton, just return that singleton.
    std::map<Handle, unsigned int>::const_iterator idx;
    idx = _varlist.index.find(term);
    if (idx != _varlist.index.end())
        return args.at(idx->second);

    // If its a node, and its not a variable, then it is a constant,
    // and just return that.
    LinkPtr lterm(LinkCast(term));
    if (NULL == lterm) return term;

    // QuoteLinks halt the reursion
    if (QUOTE_LINK == term->getType()) return term;

    // Recursively fill out the subtrees.
    HandleSeq oset;
    for (const Handle& h : lterm->getOutgoingSet())
    {
        oset.push_back(substitute_nocheck(h, args));
    }
    return Handle(createLink(term->getType(), oset));
}

/* ===================== END OF FILE ===================== */