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

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

Go to the documentation of this file.

/* Fifth VOS tutorial.  Introduction to Metaobjects.

   This tutorial file covers:
   - Vobject types
   - Creating metaobjects
   - How to use the property metaobject

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

// You must run this program before running vostut5client.

#include <vos/vos/vos.hh>

using namespace VUtil;
using namespace VOS;

#ifdef WIN32
#define sleep _sleep
#endif

void listTypes(Vobject* vob);

int main(int argc, char** argv)
{
    std::cout << "VOS Tutorial 5 Server\n\n";

    Site localsite;
    localsite.addSiteExtension(new LocalVipSiteExtension());
    localsite.setDefaultPolicy("core:accept-all");

    /* When you create a data structure out of several Vobjects as we
       did in the previous tutorial, the various objects will take on
       different tasks.  The "sphere" object acts as a container for
       the other objects, the "position" stores the position value,
       the "radius" stores the radius and so forth.  It is not
       sufficient to differentiate vobjects by their parent-child
       relationships, however.  It may obvious be that the object
       named "sphere" describes a sphere, but what if we want to name
       it "ball" or "planet"?

       A Vobject may have a set of "types" associated with it.  A
       type is simply an agreed-upon string which indicates to the
       application that this Vobject adheres to a certain interface.
       This interface may be that the Vobject has certain children
       with specific meanings (a child named "position" describes its
       position, for example) or it may indicate that the Vobject
       accepts or generates certain types of messages.  A Vobject can
       have several type strings, indicating that it adheres to
       multiple standands simultaneously (it is up to the user to
       avoid conflicts).

       When creating an object, list the types it supports. You can
       list up to five type strings.
     */
    vRef<Vobject> planet = localsite.createVobjectA("planet", "tutorial:sphere");
    planet->setDefaultPolicy("core:accept-all");

    listTypes(planet);


    // We can also add types:
    planet->addType("tutorial:class-M");
    listTypes(planet);


    /* Use getTypes() to get the type set.  The hasItem() method scans
       the type set for the desired item.
    */
    if(planet->getTypes().hasItem("tutorial:class-M")) {
        std::cout << "vostut5server: It it a habitable planet.\n";
    }

    /* If it occured to you that the type of a Vobject could be
       similar to class of a C++ object, you're right on track.  VOS
       allows you set up a mapping between Vobject types and C++
       classes.  This allows you to implement a C++ interface for the
       operations on that Vobject corresponding to a particular object
       type.  This is acomplished by using the MetaObject class to
       dynamically extend the capabilities of a given Vobject.  This
       tutorial demonstrates how to create a vobject with the
       "Property" extension.

       The easiest way to add an extension is to specify it when you
       create a Vobject.  This is done using a template, and the
       return type will be the first templated type:
    */
    vRef<Property> positionproperty = localsite.createVobject<Property>("position");

    /* The "positionproperty" object allows us to access methods
       specific to the property extension.  We can access the usual
       Vobject API (insertChild, getTypes, etc) through
       "positionproperty" well.
    */
    listTypes(positionproperty);

    planet->insertChild(-1, "position", positionproperty);

    /* Perhaps you are wondering what the Property extension actually
       does!  This extension defines a standard way for storing and
       accessing a block of data in a Vobject.  It is very much like a
       file, with read() and write() methods.  The property metaobject
       is used by nearly everything as the common way of storing
       simple data in a Vobject.
    */

    /* To set a property's value, use replace().  The first parameter
       is the new contents of the property, the second parameter is
       the datatype of the property's value (such as a MIME type).
    */
    positionproperty->replace("1 2 3", "list: float");


    // To read a property value, use read()

    std::cout << "vostut5server: The property value of " << positionproperty->getURL().getString()
              << " is " << positionproperty->read() << std::endl;


    /* You can selectively change a part of a property using write().
       The first argument is the offset, the second is the new section.
    */
    positionproperty->write(2, "4");

    std::cout << "vostut5server: The property value of " << positionproperty->getURLstr()
              << " is now " << positionproperty->read() << std::endl;


    /* We must set an access control policy for remote users.  This
       policy is used to control what actions are permitted on this
       object.  Here we are using a read-only policy, so remote users
       will be able to read but not change the value of this property.
    */
    positionproperty->setDefaultPolicy("property:read-only");

    std::cout << "Going into runloop now.\n";
    while(true) sleep(1000);
}

void listTypes(Vobject* vob)
{
    std::cout << "Types for " << vob->getURL().getString() << ": ";
    for(TypeSetIterator types = vob->getTypes(); types.hasMore(); types++)
    {
        if(!types.atStart()) std::cout << ", ";
        std::cout << (*types);
    }
    std::cout << "\n";
}