FollowLink.h

Go to the documentation of this file.

#ifndef _OPENCOG_FOLLOW_LINK_H
#define _OPENCOG_FOLLOW_LINK_H

#include <opencog/atomspace/Link.h>

namespace opencog
{
class FollowLink
{
public:

    inline Handle follow_binary_link(const Handle& h, Type ltype)
    {
        return follow_link(h, ltype, 0, 1);
    }

    inline Handle backtrack_binary_link(const Handle& h, Type ltype)
    {
        return follow_link(h, ltype, 1, 0);
    }

    inline Handle follow_link(const Handle& h, Type ltype, int from, int to)
    {
        // Look for incoming links that are of the given type.
        // Then grab the thing that they link to.
        link_type = ltype;
        from_atom = h;
        to_atom = Handle::UNDEFINED;
        position_from = from;
        position_to = to;
        h->foreach_incoming(&FollowLink::find_link_type, this);
        return to_atom;
    }

private:
    Type link_type;
    Handle from_atom;
    Handle to_atom;
    int position_from;
    int position_to;
    int cnt;

    inline bool find_link_type(const Handle& h)
    {
        // Make sure that the link is of the desired type.
        if (link_type != h->getType()) return false;

        cnt = -1;
        to_atom = Handle::UNDEFINED;
        LinkPtr l(LinkCast(h));
        if (l) l->foreach_outgoing(&FollowLink::pursue_link, this);
        if (to_atom != Handle::UNDEFINED) return true;
        return false;
    }

    inline bool pursue_link(const Handle& h)
    {
        cnt ++;

        // The from-slot should be occupied by the node itself.
        if (position_from == cnt) {
            if (from_atom != h) {
                to_atom = Handle::UNDEFINED;
                return true; // Bad match, stop now.
            }
            return false;
        }

        // The to-slot is the one we're looking for.
        if (position_to == cnt) {
            to_atom = h;
        }

        return false;
    }
};

} // namespace opencog

#endif // _OPENCOG_FOLLOW_LINK_H