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

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

Go to the documentation of this file.

/* Seventh VOS tutorial.  Creating your own MetaObjects

   This tutorial covers:

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

#include "vostut7hello.hh"

using namespace VUtil;
using namespace VOS;

// The hello constructor.  Nice and simple :-)

Hello::Hello(VobjectBase* superobject)
    : MetaObject(superobject)
{
}

// Return the VOS type

const std::string Hello::getVOSType()
{
    return "tutorial:hello";
}

// That's it for the "Hello" base class!


// Now for RemoteHello.

// The constructor for LocalHello.

RemoteHello::RemoteHello(VobjectBase* superobject)
    : Hello(superobject)
{ }


// The client stub implementation of hello.

std::string RemoteHello::hello(const std::string& s)
{
    // will hold return value
    std::string ret;

    /* We can supply some parameters to the message constructor to
       initialize some of the fields on the message, including
       generating a nonce.  A "nonce" is a unique identifier
       associated with this message that will be used to match the
       reply message (which will bear the same nonce).
    */
    vRef<Message> m(new Message(this, "tutorial:hello", true), false);

    m->appendField("word", s);

    /* Send it off.  Note: since 'this' is a remote object, by sending
       a message to 'this' we are actualy causing the message to be
       delivered to the actual vobject over the network.
    */
    vRef<Message> n = ProcessMessage::sendMsgAndWaitForReply(this, m);

    try {

        // We got a reply back.  Extract the answer from the "text" field.
        ret = n->getField("word")->value;

    } catch(NoSuchFieldError) {

        // Whoops.  There wasn't a "word" field.
        // We could perhaps throw an exception here.

        ret = "***site did not return a word field***";
    }

    // return our results.
    return ret;
}


// Constructs a RemoteHello object and returns it.  This is necessary
// since you can't take the address of a constructor and call it like
// a normal function or method pointer.

MetaObject* RemoteHello::new_RemoteHello(VobjectBase* superobject, const std::string& type)
{
    return new RemoteHello(superobject);
}


// All done with RemoteHello!


// Now the constructor for LocalHello.

LocalHello::LocalHello(VobjectBase* superobject)
    : Hello(superobject)
{
    // only do this once
    static bool init = true;
    if(init) {
        init = false;

        /* Here we add a method to be called when this Vobject receives a
           message with specific method field.  The addMessageHandler
           method associates the message method ("tutorial:hello") with a
           C++ method to call (&LocalHello::handleHello) and a particular
           object to call in on (this).
        */
        VobjectBase::addMessageHandler("tutorial:hello", &LocalHello::handleHello);
    }
}


// The actual hello method.  Yes, all the trouble just to access this
// method over a network :-)

std::string LocalHello::hello(const std::string& s)
{
    return ("Hello there!  You said \"" + s + "\"");
}



// This is the handler method registered with addMessageHandler() and
// called by VOS when a message bearing the method "tutorial:hello" is
// received by this object.

void LocalHello::handleHello(Message* m)
{
    // Somebody has said hello to us.  We will act upon the message
    // and send a reply.

    vRef<Message> reply(new Message(this, m, "tutorial:hello-reply"), false);

    try {
        // Now call hello() with the field called "word".

        std::string s = hello(m->getField("word")->value);


        // The result goes into a field called "word" in the reply.

        reply->appendField("word", s);

    } catch(NoSuchFieldError) {

        // oops!  The message we got didn't have the field we were looking for.
        reply->appendField("error", "need a field \"word\"");

    }

    try {
        // Get a handle on the object that sent this message to us
        // and send it the reply.

        vRef<Vobject> v = findObject(m->getFrom());

        v->sendMessage(reply);

    } catch(NoSuchSiteError) {
    } catch(NoSuchObjectError) {
    } catch(AccessControlError) {
    } catch(RemoteError) {
    } catch(BadURLError) {
    }
}


// Constructs a LocalHello object and returns it.  This is necessary
// since you can't take the address of a constructor and call it like
// a normal function or method pointer.

MetaObject* LocalHello::new_LocalHello(VobjectBase* superobject, const std::string& type)
{
    return new LocalHello(superobject);
}


/* The following code between BEGIN_ and END_ will be executed
   _before_ the program main().  We want to register our MetaObject extension
   with Site, so we add our new_LocalHello and new_RemoteHello factory
   methods to a global table of MetaObject types and their factories.
*/
BEGIN_REGISTER_METAOBJECT_FACTORIES(Hello)

/* Registering an extension consists of supplying a type string
   and a function to call to construct a new metaobject for that
   type.  Here we associate the new_LocalHello function for the
   abstract class, the local class, and the VOS type name, meaning
   the user can call Site::createVobject() with any of
   these three strings and get an object with the LocalHello extension.
*/
Site::addLocalMetaObjectFactory(typeid(Hello).name(), &LocalHello::new_LocalHello);
Site::addLocalMetaObjectFactory(typeid(LocalHello).name(), &LocalHello::new_LocalHello);
Site::addLocalMetaObjectFactory("tutorial:hello", &LocalHello::new_LocalHello);

/* Note that for remote objects the VOS type name is extremely
   important: it is the VOS type name we get from the network, and
   we use it to automatically instantiate the correct extensions
   for the newly discovered object.
*/
Site::addRemoteMetaObjectFactory(typeid(Hello).name(), "tutorial:hello", &RemoteHello::new_RemoteHello);
Site::addRemoteMetaObjectFactory(typeid(RemoteHello).name(), "tutorial:hello", &RemoteHello::new_RemoteHello);
Site::addRemoteMetaObjectFactory("tutorial:hello", "tutorial:hello", &RemoteHello::new_RemoteHello);
END_REGISTER_METAOBJECT_FACTORIES(Hello)