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"


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

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


// Return the VOS type

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


// This will be called by applications wishing to use the "Hello" extension.

void Hello::registerExtenders()
{
    /* 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 LocalSite::createMetaObject() with any of
       these three strings and get an object with the LocalHello extension.
    */
    LocalSite::addLocalObjectExtension(typeid(Hello).name(), &LocalHello::new_LocalHello);
    LocalSite::addLocalObjectExtension(typeid(LocalHello).name(), &LocalHello::new_LocalHello);
    LocalSite::addLocalObjectExtension("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.
     */
    RemoteSite::addRemoteObjectExtension(typeid(Hello).name(), &RemoteHello::new_RemoteHello);
    RemoteSite::addRemoteObjectExtension(typeid(RemoteHello).name(), &RemoteHello::new_RemoteHello);
    RemoteSite::addRemoteObjectExtension("tutorial:hello", &RemoteHello::new_RemoteHello);
}


// That's it for the base class!


// Now for RemoteHello.

// Now the constructor for LocalHello.

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


// The client stub implementation of hello.

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

    vRef<Message> m = new Message();

    /* RemoteVobject::initFields is a convenience function 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).  This function
       also returns the local site which is peered to this remote
       site, which we need if we want to wait for a reply.
    */
    vRef<LocalSite> ls = RemoteVobject::initFields(this, &m, "tutorial:hello", true);

    m->insertField(-1, "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.
    */
    sendMessage(&m);


    // get our (remote) site
    vRef<RemoteSite> site = dynamic_cast<RemoteSite&>(getSite());

    /* The waitFor() method will wait until either a message is
       received on our local site from the supplied remote site
       bearing the given nonce, or time runs out.  It returns the
       message that matches the nonce, or throws a TimeoutError if we
       ran out of time.  In other words, the purpose of this method is
       for "waiting for" a reply to a message which we have just sent.
    */
    vRef<Message> n = ls->waitFor(m->getNonce(), &site);

    try {

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

    } catch(Message::NoSuchFieldError) {

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

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

    // return our results.
    return ret;
}


// Constructs a RemoteHello object and returns it.  This is a hack
// 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(MetaObject* superobject, const string& type)
{
    return new RemoteHello(superobject);
}


// All done with RemoteHello!


// Now the constructor for LocalHello.

LocalHello::LocalHello(MetaObject* superobject)
    : Hello(superobject)
{
    /* 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).  It is a template method to keep
       C++'s type checking happy.
    */
    addMessageHandler<LocalHello>("tutorial:hello", this, &LocalHello::handleHello);
}


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

string LocalHello::hello(const 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();

    // LocalVobject has a convenience method which will set
    // up the reply for us, such as initializing with the
    // correct nonce. See API documentation for details.

    LocalVobject::initReply(this, &reply, m, "tutorial:hello-reply");


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

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


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

        reply->insertField(-1, "word", s);

    } catch(Message::NoSuchFieldError) {

        // oops!  The message we got didn't have the field we were looking for.
        reply->insertField(-1, "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(URL::BadURLError) {
    }
}


// Constructs a LocalHello object and returns it.  This is a hack
// 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(MetaObject* superobject, const string& type)
{
    return new LocalHello(superobject);
}

---