FindUtils.h

Go to the documentation of this file.

#ifndef _OPENCOG_FIND_UTILS_H
#define _OPENCOG_FIND_UTILS_H

#include <set>
#include <vector>

#include <opencog/util/functional.h>
#include <opencog/atomspace/Atom.h>
#include <opencog/atomspace/ClassServer.h>
#include <opencog/atomspace/Handle.h>
#include <opencog/atomspace/Link.h>
#include <opencog/atomspace/types.h>

namespace opencog {


//================================================================
class FindAtoms
{
    public:
        bool stop_at_quote;
        std::set<Handle> varset;
        std::set<Handle> holders;
        std::set<Handle> least_holders;

        inline FindAtoms(Type t, bool subclass = false)
            : stop_at_quote(true), _target_types({t})
        {
            if (subclass)
            {
                classserver().getChildrenRecursive(t, inserter(_target_types));
            }
        }

        inline FindAtoms(Type ta, Type tb, bool subclass = false)
            : stop_at_quote(true), _target_types({ta, tb})
        {
            if (subclass)
            {
                classserver().getChildrenRecursive(ta, inserter(_target_types));
                classserver().getChildrenRecursive(tb, inserter(_target_types));
            }
        }

        inline FindAtoms(const Handle& atom)
            : stop_at_quote(true),
              _target_types(),
              _target_atoms()
        { _target_atoms.insert(atom); }

        inline FindAtoms(const std::set<Handle>& selection)
            : stop_at_quote(true),
              _target_types(),
              _target_atoms(selection)
            {}

        inline void search_set(const Handle& h)
        {
            find_rec(h);
        }

        inline void search_set(const std::vector<Handle>& hlist)
        {
            for (const Handle& h : hlist) find_rec(h);
        }
    private:
        typedef enum
        {
            NOPE,  // Does not contain.
            YEP,   // Contains, but not immediately so.
            IMM    // Contains immediately below.
        } Loco;

        inline Loco find_rec(const Handle& h)
        {
            Type t = h->getType();
            if (1 == _target_types.count(t) or _target_atoms.count(h) == 1)
            {
                varset.insert(h);
                return IMM; 
            }

            if (stop_at_quote and QUOTE_LINK == t) return NOPE;

            LinkPtr l(LinkCast(h));
            if (l)
            {
                bool held = false;
                bool imm = false;
                for (const Handle& oh : l->getOutgoingSet())
                {
                    Loco where = find_rec(oh);
                    if (NOPE != where) held = true;
                    if (IMM == where) imm = true;
                }
                if (imm) least_holders.insert(h);
                if (held)
                {
                    holders.insert(h);
                    return YEP;
                }
            }
            return NOPE;
        }

    private:
        std::set<Type> _target_types;
        std::set<Handle> _target_atoms;
};

static inline bool is_atom_in_tree(const Handle& tree, const Handle& atom)
{
    if (tree == Handle::UNDEFINED) return false;
    if (tree == atom) return true;
    LinkPtr ltree(LinkCast(tree));
    if (NULL == ltree) return false;

    // Recurse downwards...
    for (const Handle h: ltree->getOutgoingSet()) {
        if (is_atom_in_tree(h, atom)) return true;
    }
    return false;
}

static inline bool is_quoted_in_tree(const Handle& tree, const Handle& atom)
{
    if (tree == Handle::UNDEFINED) return false;
    if (tree == atom) return false;  // not quoted, so false.
    LinkPtr ltree(LinkCast(tree));
    if (NULL == ltree) return false;

    if (tree->getType() == QUOTE_LINK)
    {
        if (is_atom_in_tree(tree, atom)) return true;
        return false;
    }

    // Recurse downwards...
    for (const Handle& h: ltree->getOutgoingSet()) {
        if (is_quoted_in_tree(h, atom)) return true;
    }
    return false;
}

static inline bool is_unquoted_in_tree(const Handle& tree, const Handle& atom)
{
    if (tree == Handle::UNDEFINED) return false;
    if (tree == atom) return true;
    LinkPtr ltree(LinkCast(tree));
    if (NULL == ltree) return false;

    if (tree->getType() == QUOTE_LINK) return false;

    // Recurse downwards...
    for (const Handle& h : ltree->getOutgoingSet()) {
        if (is_unquoted_in_tree(h, atom)) return true;
    }
    return false;
}

static inline bool any_atom_in_tree(const Handle& tree,
                                    const std::set<Handle>& atoms)
{
    for (const Handle& n: atoms)
    {
        if (is_atom_in_tree(tree, n)) return true;
    }
    return false;
}

static inline bool any_unquoted_in_tree(const Handle& tree,
                                        const std::set<Handle>& atoms)
{
    for (const Handle& n: atoms)
    {
        if (is_unquoted_in_tree(tree, n)) return true;
    }
    return false;
}

static inline unsigned int num_unquoted_in_tree(const Handle& tree,
                                        const std::set<Handle>& atoms)
{
    unsigned int count = 0;
    for (const Handle& n: atoms)
    {
        if (is_unquoted_in_tree(tree, n)) count++;
    }
    return count;
}

static inline bool is_atom_in_any_tree(const std::vector<Handle>& trees,
                                       const Handle& atom)
{
    for (const Handle& tree: trees)
    {
        if (is_atom_in_tree(tree, atom)) return true;
    }
    return false;
}

static inline bool is_unquoted_in_any_tree(const std::vector<Handle>& trees,
                                           const Handle& atom)
{
    for (const Handle& tree: trees)
    {
        if (is_unquoted_in_tree(tree, atom)) return true;
    }
    return false;
}

static inline bool contains_atomtype(const Handle& clause, Type atom_type)
{
    Type clause_type = clause->getType();
    if (QUOTE_LINK == clause_type) return false;
    if (classserver().isA(clause_type, atom_type)) return true;

    LinkPtr lc(LinkCast(clause));
    if (not lc) return false;

    for (const Handle& subclause: lc->getOutgoingSet())
    {
        if (contains_atomtype(subclause, atom_type)) return true;
    }
    return false;
}

} // namespace opencog

#endif // _OPENCOG_FIND_UTILS_H