vos/metaobjects/misc/services.hh

Go to the documentation of this file.

/* $Id: services.hh,v 1.15 2003/07/24 05:18:20 tetron Exp $ */


/* This file was generated by otd2cpp.pl.

    Copyright (C) 2002 Peter Amstutz <tetron@interreality.org>

    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
    License as published by the Free Software Foundation; either
    version 2 of the License, or (at your option) any later version.

    This library 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
    Lesser General Public License for more details.

    You should have received a copy of the GNU Lesser General Public
    License along with this library; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307  USA
*/

#ifndef _MISC_SERVICES_HH_
#define _MISC_SERVICES_HH_

#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

#include <vos/corelibs/vos/vos.hh>
#include <vos/metaobjects/property/property.hh>
#include <servicediscovery/servicedirectory.hh>

/** MetaObject implementing the Services object type: make a service
    discovery system available through VOS.

    A services object contains a list of hypercards to services.  It
    is intended to be used as a registry of interesting VOS
    application running on a host, such as virtual
    worlds, GUI clients, chat clients, mp3 jukeboxes, print servers,
    etc to make it easy to discover these services.  

    The LocalServices object will typically be used by a service list
    daemon to hold a list of services for one host.  When queried,
    the daemon will search its local list as well as perform a 
    broadcast query to the local network, or into some other service
    discovery system such as SSDP or MDNS.  An application searching
    for services can simply connect to this default Services for
    its local host (the default URL is vop://localhost:4231/services)
    and perform the query via the query() method in the RemoteServices 
    interface.  An application wishing to register a service does the same, 
    using the registerService() method. As a shortcut, the static method
    registerServiceWithDefault() can be used as well.

    The hypercards in a services list will have, as co-types, a list of the 
    types of the objects that the hypercard links to prefixed with "linktype=".
    For example, a hypercard in a services directory points to a A3DL 
    virtual world.  The hypercard itself will have as types both
    "misc:hypercard" and "linktype=a3dl:world".  Note that the latter
    is a perfectly legal type!  This enables the user to do searches on
    a particular type string to look for particular services, but
    doesn't actually cause an application to try to load the hypercard as
    that type.

    @note This metaobject uses Hypercard and Property, so be sure to register
    those metaobject extenders as well.
*/
class MISC_API Services : public virtual MetaObject
{


protected:
    PropertyAccessControl* accessControl;
    static Services* defaultServiceDir;
    static std::string serviceDirURL;
    std::map<int, LSD::ServiceAdvertismentListener*> queries;

public:

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

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

    /** Return type string ("misc:services") */
    virtual const std::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();

    /** @throw NoSuchObjectError (or possibly other exception) if services
        directory cannot be accessed */
    static Services* getDefaultServicesDir();
    static void setDefaultServiceDir(const std::string& url);
    static void registerServiceWithDefault(Vobject* service, const std::string& title, const std::string& desc = "");

    virtual void registerService(Vobject* service, const std::string& title, const std::string& desc = "");

    virtual int query(const std::string& typepattern,
                      const std::string& titlepattern,
                      const std::string& descpattern,
                      const std::string& urlpattern,
                      LSD::ServiceAdvertismentListener* cb) = 0;
    virtual void endQuery(int q) = 0;
};

class ServiceListenerSiteWrapper;

/** Local version of Services. */
class LocalServices : public virtual Services,
                      public virtual ChildChangeListener
{
public:

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

    /** Destructor */
    ~LocalServices();

    /** 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_LocalServices(MetaObject* superobject, const std::string& type);

    virtual void notifyChildInserted(VobjectEvent& event);

    virtual void notifyChildReplaced(VobjectEvent& event);

    virtual void notifyChildRemoved(VobjectEvent& event);

    /* override me */
    virtual int query(const std::string& typepattern,
                      const std::string& titlepattern,
                      const std::string& descpattern,
                      const std::string& urlpattern,
                      LSD::ServiceAdvertismentListener* cb);

    /* override me */
    virtual void endQuery(int q);

    virtual void handleQuery(Message* m);
    virtual void handleEndQuery(Message* m);

    friend class ServiceListenerSiteWrapper;
};

/** Remote version of Services. */
class RemoteServices : public virtual Services
{
public:

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

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

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

    virtual int query(const std::string& typepattern,
                      const std::string& titlepattern,
                      const std::string& descpattern,
                      const std::string& urlpattern,
                      LSD::ServiceAdvertismentListener* cb);

    virtual void endQuery(int q);

    virtual void handleAdvertisement(Message* m);
};

class ServiceListenerSiteWrapper : public LSD::ServiceAdvertismentListener,
                                   public virtual ObjectExciseListener
{
private:
    LocalServices* services;
    Site* site;
    std::string nonce;
    int queryID;
public:
    ServiceListenerSiteWrapper(LocalServices* sv, Site* st, const std::string& n);
    virtual ~ServiceListenerSiteWrapper();
    virtual void notifyNewService(int id, const LSD::Service& s);
    virtual void notifyObjectExcise(RefCounted* rc);
    virtual void setQueryID(int r) { queryID = r; }
};

#endif // #ifdef _SERVICES_HH_

---