vos/metaobjects/hello/hello.cc

Go to the documentation of this file.

// <![CDATA[ 
// Bring in all the various class definitions
#include "hello.hh"

/* Hello constructor, does nothing except passing the argument up.
   Without getting too deep into metaobject's implementation, the
   "superobject" is the _actual_ Vobject which this MetaObject is 
   attached to. 
*/
Hello::Hello(MetaObject* superobject) : MetaObject(superobject)
{ }

/* Return the VOS type, as explained in hello.hh */
const string Hello::getType() { 
    return "example:hello"; 
}

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
       register functions 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 Hello
       extension.
    */
    LocalSite::addLocalObjectExtension(typeid(Hello).name(), &LocalHello::new_LocalHello);
    LocalSite::addLocalObjectExtension(typeid(LocalHello).name(), &LocalHello::new_LocalHello);
    LocalSite::addLocalObjectExtension("example: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("example:hello", &RemoteHello::new_RemoteHello);
}

/* Constructor.  Note that because we have to
   inherit using virtual base classes --
        class LocalHello : public virtual Hello { ... };
   -- we must explicitly specify which constructors get called.
 */
LocalHello::LocalHello(MetaObject* superobject)
    : Hello(superobject), MetaObject(superobject)
{
    /* This might look like a scary function call, but it's actually
       very simple.  What we are doing here is telling the system that
       when this object receives a message with the method
       "example:hello", it should call the method LocalHello::handleHello
       on this object.  The template is merely necessary to keep C++'s 
       static type checking happy.
    */
    addMessageHandler<LocalHello>("example:hello", this, &LocalHello::handleHello);
}

/* The ACTUAL hello method!  All this extra stuff exists solely to
   enable us to be able to call this incredibly amazing function over
   a network.
*/
string LocalHello::hello(const string& s)
{
    return ("Hello there!  You said \"" + s + "\"");
}

/* This method is called by VOS when a message bearing the method 
    "example:hello" is received by this object.
*/
void LocalHello::handleHello(Message* m)
{
    /* Construct a new message.  (See an explanation of the
       meaning of vRef<>  in the online API documentation,
       or the comments of helloclient.cc).
    */
    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, "example:hello-reply");
     try {
         // Now call hello() with the field called "text".
         string s = hello(m->getField("text").value);
         // The result goes into a field called "text" in the reply.
         reply->insertField(-1, "text", 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 \"text\"");
     }
     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) {
     }
}

// Return a new hello object . See hello.hh for more details.
MetaObject* LocalHello::new_LocalHello(MetaObject* superobject, const string& type)
{ 
    return new LocalHello(superobject); 
}


/* Constructor.  Same note about virtual base classes in LocalHello
   goes for this as well.
 */
RemoteHello::RemoteHello(MetaObject* superobject)
    : Hello(superobject), MetaObject(superobject)
{ }

/* The client stub implementation of hello. */
string RemoteHello::hello(const string& s)
{
    string ret;  // will hold return value

    // Create a new message.  Hopefully you know about vRef by now.
    vRef<Message> m = new Message();

    /* RemoteVobject::initFields is a convenience funtion to
       initialize some of the fields on the message, including
       generating a nonce..  It 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, "example:hello", true);

    // Now add a field, tagged "text"
    m->insertField(-1, "text", s);

    /* Send it off.  Note that what we are actually doing
       here is calling sendMessage on the superobject, which
       will do the actual sending to the remote site (via
       some underlying transport) for us.
    */
    sendMessage(&m);

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

    /* Wait until either a message is received on our
       local site from the supplied remote site bearing
       the given nonce, or time runs out.  Returns the
       message that matches the nonce, or throws a
       TimeoutError if we ran out of time.
    */
    vRef<Message> n = ls->waitFor(m->getNonce(), &site);
    try {
        // We got a reply back.  Extract the answer from the "text" field.
        ret = n->getField("text").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;
}

// Return a new hello object . See hello.hh for more details.
MetaObject* RemoteHello::new_RemoteHello(MetaObject* superobject, const string& type)
{ 
    return new RemoteHello(superobject); 
}

// end of hello.cc ]]>

---