vos/metaobjects/hello/hello.hh

Go to the documentation of this file.

/* <![CDATA[ 
    Copyright (C) 2002 Peter Amstutz <tetron@interreality.org>

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

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

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

#ifndef _HELLO_HH_
#define _HELLO_HH_

// this stuff makes DLL's work on windows
#if defined(_WIN32) && defined(_MSC_VER)
# ifdef HELLO_EXPORTS
#  define HELLO_API __declspec(dllexport)
# else
#  define HELLO_API __declspec(dllimport)
# endif
#else
# define HELLO_API
#endif


// First of all, bring in all the VOS class definitions.
#include <vos/corelibs/vos/vos.hh>

/** Example MetaObject class.  This is a metaobject extension, which means
    that it can be used to extend (on the fly) the API and
    capabilities of a Vobject.

    This class is abstract.  It provides a abstract interface for the
    methods we want to virtualize, the implementation is left to the
    subclasses.

    For starters, all extensions must inherit
    from "MetaObject".  Also note that they must inherit as "virtual"
    (a virtual base class) because of the way VOS uses multiple
    inheritance internally.

    The HELLO_API tag makes DLL's work on Windoze.
 */
class HELLO_API Hello : public virtual MetaObject
{
protected:
    /** Construtor.  Never called directly (this is an abstract class
        anyhow.) */
    Hello(MetaObject* superobject);
public:
    /** The method we are virtualizing.  Here we simply supply the
        interface.  This allows the application to simply interact
        with objects of type "Hello" and not care at all whether the
        object is local or remote.
    */
    virtual string hello(const string& s) = 0;

    /* This returns the VOS type string for this specific extension, in
       this case "example:hello".  This is the object type at the VOS
       level (in the Vobject::getTypes() set) NOT the C++ class name.
       Note: this is prepended with "example:" because the hello is part
       of the "example" group of object types.  Other object
       types may be prepended with other group names, for example
       types part of Abstract 3D Layer are prepended with "a3dl:"
       instead.  This avoids name conflicts and make may make it
       easier to determine what unfamiliar object types do.  (Note that
       in the local and remote subclasses, the hello method's name (at 
       the VOS protocol level) is also prepended with "example:".)
     */
    virtual const string getType();

    /** Standard method to be called by an application to request
       that this type extension be registered with VOS.
     */
    static void registerExtenders();
};

/** This class implements the local Hello object.  It also
    contains the code to respond to requests from its remote peer.
*/
class HELLO_API LocalHello : public virtual Hello
{
protected:
    /** Constructor.  You don't call this directly; the Site::createMetaObject
        methods are used instead.   */
    LocalHello(MetaObject* superobject);
public:

    /** The hello method declared pure virtual above. This method is called
        directly from the local application, or by handleHello() in response to a
        message from this object's remote peer. */
    virtual string hello(const string& s);

    /** Callback for a "hello" message from the remote peer: extracts fields
        from the Message and then calls hello. */
    void handleHello(Message* m);

    /** Since constructors are not quite normal functions, we have a wrapper
        around the constructor which can be stored by VOS, and called when
        you ask for an object with this type extension by calling 
        Site::createMetaObject().
    */
    static MetaObject* new_LocalHello(MetaObject* superobject, const string& type);
};



/** This class defines the remote proxy for the local Hello object.  */
class HELLO_API RemoteHello : public virtual Hello
{
protected:
    /** Constructor.  You don't call this directly. Usually you won't be
        creating Vobjects remotely, but finding them with Vobject::findObject(),
        Vobject::findObjectFromRoot(), etc.  */
    RemoteHello(MetaObject* superobject);

public:
    /** This will dispatch a request message to this remote object's local 
        peer object, and wait for a response. */
    virtual string hello(const string& s);

    /** Since constructors are not quite normal functions, we have a wrapper
        around the constructor which VOS can store and call to create an
        object with this type extension.
    */
    static MetaObject* new_RemoteHello(MetaObject* superobject, const string& type);
};

#endif

// end of hello.hh ]]>

---