ForeachChaseLink.h

Go to the documentation of this file.

#ifndef _OPENCOG_LINK_CHASE_H
#define _OPENCOG_LINK_CHASE_H

#include <opencog/atomspace/Link.h>

namespace opencog
{
template <typename T>
class PrivateUseOnlyChaseLink
{
public:

    inline bool follow_link(const Handle& h, Type ltype,
                  int from, int to, bool (T::*cb)(const Handle&), T *data)
    {
        user_callback = cb;
        user_callback_lh = NULL;
        return do_follow_link (h, ltype, from, to, data);
    }

    inline bool follow_link_lh(const Handle& h, Type ltype, int from, int to,
                               bool (T::*cb)(const Handle&, const Handle&), T *data)
    {
        user_callback = NULL;
        user_callback_lh = cb;
        return do_follow_link (h, ltype, from, to, data);
    }

    inline bool follow_unordered_binary_link(const Handle& h, Type ltype,
                                             bool (T::*cb)(const Handle&), T *data)
    {
        user_callback = cb;
        user_callback_lh = NULL;
        return do_follow_unordered_binary_link(h, ltype, data);
    }

    inline bool follow_unordered_binary_link(const Handle& h, Type ltype,
                            bool (T::*cb)(const Handle&, const Handle&), T *data)
    {
        user_callback = NULL;
        user_callback_lh = cb;
        return do_follow_unordered_binary_link(h, ltype, data);
    }

private:
    Type link_type;
    Handle from_atom;
    Handle to_atom;
    int position_from;
    int position_to;
    int cnt;
    bool (PrivateUseOnlyChaseLink::*endpoint_matcher)(const Handle&);
    bool (T::*user_callback)(const Handle&);
    bool (T::*user_callback_lh)(const Handle&, const Handle&);
    T *user_data;

    inline bool do_follow_link(const Handle& h, Type ltype, int from, int to, T *data)
    {
        // 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;
        user_data = data;
        endpoint_matcher = &PrivateUseOnlyChaseLink::pursue_link;
        bool rc = h->foreach_incoming(&PrivateUseOnlyChaseLink::find_link_type, this);
        return rc;
    }

    inline bool do_follow_unordered_binary_link(const Handle& h, Type ltype, T *data)
    {
        // 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;
        user_data = data;
        endpoint_matcher = &PrivateUseOnlyChaseLink::pursue_unordered_link;
        bool rc = h->foreach_incoming(&PrivateUseOnlyChaseLink::find_link_type, this);
        return rc;
    }

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

        cnt = -1;
        to_atom = Handle::UNDEFINED;
        // foreach_outgoing_handle(link_h, PrivateUseOnlyChaseLink::endpoint_matcher, this);
        LinkCast(link_h)->foreach_outgoing(endpoint_matcher, this);

        bool rc = false;
        if (Handle::UNDEFINED != to_atom)
        {
            if (user_callback)
                rc = (user_data->*user_callback)(to_atom);
            else
                rc = (user_data->*user_callback_lh)(to_atom, link_h);
        }
        return rc;
    }

    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;
    }

    inline bool pursue_unordered_link(const Handle& h)
    {
        // There are only two atoms in a binary link. The one that is
        // not the from_atom is the one we are looking for.
        if (from_atom != h)
        {
            to_atom = h; // found it!
            return true;
        }
        return false;
    }
};

template <typename T>
inline bool foreach_binary_link(const Handle& h, Type ltype,
                                bool (T::*cb)(const Handle&), T *data)
{
    PrivateUseOnlyChaseLink<T> cl;
    return cl.follow_link(h, ltype, 0, 1, cb, data);
}

template <typename T>
inline bool foreach_binary_link(const Handle& h, Type ltype,
              bool (T::*cb)(const Handle&, const Handle&), T *data)
{
    PrivateUseOnlyChaseLink<T> cl;
    return cl.follow_link_lh(h, ltype, 0, 1, cb, data);
}

template <typename T>
inline bool foreach_reverse_binary_link(const Handle& h, Type ltype,
                             bool (T::*cb)(const Handle&), T *data)
{
    PrivateUseOnlyChaseLink<T> cl;
    return cl.follow_link(h, ltype, 1, 0, cb, data);
}

template <typename T>
inline bool foreach_reverse_binary_link(const Handle& h, Type ltype,
                  bool (T::*cb)(const Handle&, const Handle&), T *data)
{
    PrivateUseOnlyChaseLink<T> cl;
    return cl.follow_link_lh(h, ltype, 1, 0, cb, data);
}

template <typename T>
inline bool foreach_link(const Handle& h, Type ltype, int from, int to,
                         bool (T::*cb)(const Handle&), T *data)
{
    PrivateUseOnlyChaseLink<T> cl;
    return cl.follow_link(h, ltype, from, to, cb, data);
}

template <typename T>
inline bool foreach_link(const Handle& h, Type ltype, int from, int to,
                         bool (T::*cb)(const Handle&, const Handle&), T *data)
{
    PrivateUseOnlyChaseLink<T> cl;
    return cl.follow_link_lh(h, ltype, from, to, cb, data);
}

template <typename T>
inline bool foreach_unordered_binary_link(const Handle& h, Type ltype,
                                     bool (T::*cb)(const Handle&), T *data)
{
    PrivateUseOnlyChaseLink<T> cl;
    return cl.follow_unordered_binary_link(h, ltype, cb, data);
}

template <typename T>
inline bool foreach_unordered_binary_link(const Handle& h, Type ltype,
                      bool (T::*cb)(const Handle&, const Handle&), T *data)
{
    PrivateUseOnlyChaseLink<T> cl;
    return cl.follow_unordered_binary_link(h, ltype, cb, data);
}

} // namespace opencog

#endif // _OPENCOG_LINK_CHASE_H