[Home]	[About]
[Screenshots]	[Download]
[News]	[Community]
[Documentation]	[Manual]
[Bugs & Requests]	[Wiki]

/home/tetron/hack/vos/apps/tutorials/vostut7hello.hh

Go to the documentation of this file.

/* Seventh VOS tutorial.  Creating your own MetaObjects

   This tutorial file covers:
   - Subclassing from MetaObject
   - Essential methods to override
   - Defining specialized Local and Remote MetaObjects

   This file (vostut7hello.hh) is released into the public domain.  No
   restrictions are placed on its use, distribution or inclusion into
   other works.
*/

#ifndef _VOSTUT7_HH_
#define _VOSTUT7_HH_

#include <vos/vos/vos.hh>

/* In this tutorial we demonstrate how to create a metaobject which
   implements an API for saying hello to things.  The method that we
   will implement will be simple:

   std::string hello(const std::string& s)

   This method will accept a greeting and return a string with the
   Vobject's reply.
*/

// XXX
//IMPORT_METAOBJECT_FACTORIES(Hello)

/* First define the "Hello" class.  As a MetaObject extension, it must
   inherit from the "MetaObject" class.  This class will provides an
   abstract interface for the "hello" method we want to support.
   Because the action of this method depends on whether we are
   accessing a local or remote object. the actual implementation of
   this method will be done in further subclasses.
 */
class Hello : public VOS::MetaObject
{
protected:

    // There should only ever be one constructor, and it should take
    // one parameter.

    Hello(VOS::VobjectBase* superobject);


public:
    // The hello method.  By having "Hello" be an abstract class an
    // application do not need to know whether the vobject is local or
    // remote, simply that it has the "Hello" interface.

    virtual std::string hello(const std::string& s) = 0;


    // This returns the VOS type string for this specific extension,
    // in this case "tutorial:hello".  This is a vobject type, not the
    // C++ class name.

    virtual const std::string getVOSType();
};


// This class implements Hello for remote Vobjects.  It is essentially
// a "stand in" or "stub" and its purpose is to translate C++ method
// calls into the actual network commands that acomplish the desired
// task, in this case to say hello to the Vobject in question.

class RemoteHello : public Hello
{
protected:

    // There should only ever be one constructor, and it should take
    // one parameter.  An application never calls the constructor
    // directly, instead remote metaobjects are instantiated by VOS
    // automatically when new vobjects are encountered.

    RemoteHello(VOS::VobjectBase* superobject);

public:

    // This won't implement the "hello" logic, but rather will create
    // and send a "tutorial:hello" message to the remote site.

    virtual std::string hello(const std::string& s);


    // This method will be used to instantiate a new Hello metaobject
    // when needed.  We can't use the constructor directly because
    // constructors are not normal functions or methods.

    static VOS::MetaObject* new_RemoteHello(VOS::VobjectBase* superobject, const std::string& type);
};


// This class implements Hello for local Vobjects.  This means that it
// implements the hello() method and responds to incoming
// "tutorial:hello" messages

class LocalHello : public virtual Hello
{
protected:

    // There should only ever be one constructor, and it should take
    // one parameter.  An application never calls the constructor
    // directly, but rather will use Site::creatMetaObject().

    LocalHello(VOS::VobjectBase* superobject);

public:

    // This implements the actual logic for answering a "hello".

    virtual std::string hello(const std::string& s);


    // This method is called when a "tutorial:hello" message is
    // delivered to this Vobject.  See vostut7hello.cc for details.

    void handleHello(VOS::Message* m);

    /* This method will be used to instantiate a new Hello metaobject
       when needed.  We can't use the constructor directly because
       constructors are not normal functions or methods.
    */
    static VOS::MetaObject* new_LocalHello(VOS::VobjectBase* superobject, const std::string& type);
};

#endif