vos/metaobjects/misc/search.hh

Go to the documentation of this file.

/* $Id: search.hh,v 1.22 2003/08/05 21:13:52 tetron Exp $ */


/* This file was generated by otd2cpp.pl, a script for VOS by Reed Hedges <reed@zerohour.net>
   and Peter Amstutz <tetron@interreality.org>

   Search for TODO for stuff that needs editing. You will want to especially fill in constructors,
   destructors, message handlers, non-property subobjects...

   I can make no guarantee that this code will work, or even that it even is safe to run.
   Use it at your own risk.
*/

/** @file search.hh Defines MetaObject class for Search type (revision 0).

*/

#ifndef _SEARCH_HH_
#define _SEARCH_HH_

#include <vos/corelibs/vos/vos.hh>
#include <vos/metaobjects/property/property.hh>
#include <vos/metaobjects/misc/cod.hh>

#if defined(HAVE_BOOST_REGEX_H) && defined(HAVE_LIBBOOST_REGEX)
# define BOOST_REGEX_NO_LIB 1
# include <boost/regex.h>
#else
extern "C" {
# include <regex.h>
}
#endif

#if defined(_WIN32) && defined(_MSC_VER)
# ifdef MISC_EXPORTS
#  define MISC_API __declspec(dllexport)
# else
#  define MISC_API __declspec(dllimport)
# endif
#else
# define MISC_API
#endif

class MISC_API CatchUpdatesFilter : public MessageFilter
{
public:
    string nonce;
    MessageBlock* mb;
    bool savechildren;

    CatchUpdatesFilter(const string& n) : nonce(n), mb(new MessageBlock()), savechildren(false) { }
    ~CatchUpdatesFilter() { mb->release(); }
    virtual bool checkMessage(Message* m) {
        if(m->getNonce().substr(0, nonce.size()) == nonce) {
            if(m->getMethod() != "core:set-child-update"
               && m->getMethod() != "core:insert-child-update")
            {
                mb->insertMessage(-1, m);
            } else savechildren = true;
            return false;
        } else return true;
    }
};

/** MetaObject implementing Search Object Type.

      Apply a rule-based, recursive filter to a set of Vobjects on a site.

*/
class MISC_API Search : public virtual MetaObject
{


protected:
    PropertyAccessControl* accessControl;


public:

    /** Constructor */
    Search(MetaObject* superobject);

    /** Destructor */
    virtual ~Search();

    /** Return type string ("search:search") */
    virtual const string getType();

    /** Register Extenders */
    static void registerExtenders();

    /** Set default access control policy */
    virtual void setPropertyAccessControl(PropertyAccessControl* ac);

    /** Get default access control policy */
    virtual PropertyAccessControl* getPropertyAccessControl();

    /** @name Access Subobjects */
    //@{

    //@}


    /** @name Actuators. User-functions that correspond to message actions. */
//@{


    //@}

};



/** Local version of Search. */
class MISC_API LocalSearch : public virtual Search
{
public:

    struct PatternRule
    {
        regex_t typepattern;
    bool typePatternEmpty;
        bool negateChild;
        vector<regex_t> childpattern;
        vector<string> actions;
        string plaintext;
    };

    /** Constructor */
    LocalSearch(MetaObject* superobject);

    /** Destructor */
    virtual ~LocalSearch();

    /** Initialize required subproperties with given access control. */
    virtual void initialize(PropertyAccessControl* ac);

    /** Initialize required subproperties. If access control has been
    previously set with initialize(PropertyAccessControl*) or
    setPropertyAccessControl(), then that policy will be used. Otherwise,
    NoPropertyAccessControl will be used.
    */
    virtual void initialize();

    /** Static generator, for factory. */
    static MetaObject* new_LocalSearch(MetaObject* superobject, const string& type);

    deque<PatternRule*> makeRules(Message* rules);

    bool doActions(Vobject* currentobject,
                   const deque<PatternRule*>& rules,
                   const PatternRule& thisrule,
                   RemoteCOD* cod,
                   list<Vobject*>& touchedObjects);

    bool actOnChildren(Vobject* currentobject,
                       const deque<PatternRule*>& rules,
                       const PatternRule& thisrule,
                       int patternpart,
                       RemoteCOD* cod,
                       list<Vobject*>& touchedObjects);

    void search(Vobject* currentobject,
                const deque<PatternRule*>& rules,
                RemoteCOD* cod,
                list<Vobject*>& touchedObjects);

protected:

    /** @name Message Handlers */
    //@{

    /** Handle message search (  Initiate a search.  Starting from each vobject listed in  "start", apply a type and child name based filter to determine  which vobjects to select, then apply a list of actions to each  selected vobject.) */
    virtual void handleSearch(Message* m);

    //@}

    int calledregex;

};


class MISC_API SearchListener {
public:
    virtual ~SearchListener() {}
    virtual void notifySearchDone() = 0;
};

/** Remote version of Search. */
class MISC_API RemoteSearch : public virtual Search
{
private:
    set<string> searches;
    map<string, SearchListener*> listeners;

public:

    /** Constructor */
    RemoteSearch(MetaObject* superobject);

    /** Destructor */
    virtual ~RemoteSearch();

    /** Static generator, for factory. */
    static MetaObject* new_RemoteSearch(MetaObject* superobject, const string& type);

    /** Called when this object gets an update message from its Local master across the network. */
    void sendUpdateMessage(Message *m);

    /** @name Actuators.
        These are user-functions corresponding to messages. The remote actuators marshal arguments and send a message to the Local object. */
    //@{

    /** Send a search messsage to the local object.

        @param objects  Objects under this one to search.
        @param rules    Every three items in this list form a
            TypeExpression-ChildExpression-Actions triplet. Expressions are
            regular expressions that are matched against type strings and
            children respectively. Actions are comma seperated, and be any
            message or messageblock method, or the special actions "acquire"
            (a child inserted notification is sent back) or "recurse" (search
            children as well).

            If you want, you can also use the SearchRules class for your
            convenience.
        @param async    If true, this method will return immediately. If false,
            will return when search is complete.

        Example usage:
        @code
            deque<string> objects;
            deque<rules> rules;

            // send the search to these two children of the searchable
            // object.
            objects.push_back("someChildObject");
            objects.push_back("someOtherObject");

            // if either object has type "foo", then request an insert child
            // notification, and do this recursively to children.
            rules.push_back("foo");
            rules.push_back("");
            rules.push_back("acquire,recurse");

            // if object has a type that begins with "bar" ar "baz", then
            // send a "shazzam" message to all children named "fred".
            rules.push_back("((bar)|(baz)).*");
            rules.push_back("/fred");
            rules.push_back("shazzam");

            // send search and wait for it to finish
            search.doSearch(objects, rules, false);
        @endcode

     */
    string doSearch(const deque<string>& objects, const deque<string>& rules, bool async = false, RemoteCOD** cod = 0);

    /** Like the other doSearch, except registers a SearchListener which is
     * notified when search finishes.
     * @param listener  Pointer to listener to notify when search finishes
     * (ie, search-done message is recieved in reply to this search).
     */
    string doSearch(const deque<string>& objects, const deque<string>& rules, SearchListener* listener);

    //@}


protected:

    /** @name Update Handlers. Handlers for remote update messages */
    //@{

    /** Handle a search-done messsage from the local object. */
    virtual void handleSearchDone(Message* m);

    //@}

};

/** Convenience wrapper around deque<string> for use with
 * RemoteSearch::doSearch.
 * @see RemoteSearch::doSearch().
 */
class SearchRules : public deque<string> {
public:
    inline void addRule(string type, string name, string actions) {
        this->push_back(type);
        this->push_back(name);
        this->push_back(actions);
    }
};

#endif // #ifdef _SEARCH_HH_

---