apps/tutorials/vostut5server.cc

Go to the documentation of this file.

/* Fifth VOS tutorial.  Introduction to Metaobjects.

   This tutorial file covers:
   - Vobject types
   - Registering metaobject extenders
   - Creating metaobjects
   - The meta_cast<> template
   - 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/corelibs/vos/vos.hh>
#include <vos/metaobjects/property/property.hh>

void listTypes(Vobject* vob);

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

    LocalSocketSite localsite(&NoAccessControl::static_);
    localsite.setTimeoutOnSelect(-1);

    /* 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 list 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 and 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, we list the types it supports.  This
       is variable-argument method (eg it uses "...") so you must
       always have a 0 to indicate the end of the list.
     */
    vRef<Vobject> planet = localsite.createMetaObject("planet", "tutorial:sphere", 0);

    listTypes(&planet);


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


    // You can check to see if a type is present on a Vobject using
    // the count() method.  Technically this returns the number of
    // time the type shows up in the set, but because it is a set of
    // unique elements this will always be either 1 or 0.

    if(planet->getTypes().count("tutorial:class M")) {
        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 to automatically map a Vobject type to a C++ class.
       The class then implements a C++ method interface for the
       operations on that Vobject.  Using the MetaObject class called
       you can dynamically extend the capabilities of a given Vobject.
       This tutorial demonstrates how to create a vobject which
       implements functionality from the "Property" extension.
    */

    // First we must register the Property extension with VOS.  This
    // should only ever be done once, in the initialization of your
    // program.
    Property::registerExtenders();


    /* typeid() is a part of the C++ language which provides some
       information about C++ classes.  The name() method gives us a
       unique name which refers specifically to that class.  By
       calling Property::registerExtenders(), we have associated the
       C++ Property class with a certain Vobject type and type
       extension.  The createMetaObject method adds that extension to
       the newly created MetaObject.

       Here's another way of looking at it: we would like the new
       Vobject we are creating to have the C++ interface defined by
       the "Property" class, we ask createMetaObject to extend the
       Vobject appropriately to support this.
    */
    vRef<MetaObject> position = localsite.createMetaObject("position", typeid(Property).name(), 0);

    listTypes(&position);

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


    /* To extract the Property class interface from the position
       vobject, we use the template method MetaObject::meta_cast<>.
       Given a Vobject or MetaObject, meta_cast<> returns the desired
       c++ interface to that vobject if available, or NULL if not.
       Think of it as an elaborate typecast.
    */
    Property* positionproperty = MetaObject::meta_cast<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. */

    /* Perhaps you have been 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 else as a
       common way of storing 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", "text/x-vector-float");


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

    cout << "vostut5server: The property value of " << positionproperty->getURL().getString()
         << " is " << positionproperty->read() << 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");

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


    /* "LocalProperty" is a subclass of "Property" which implements
       the property type as a local vobject, answering queries from
       remote vobjects.  Because "Property" is an abstract class which
       can represent both local and remote properties, we must
       meta_cast to LocalProperty to set the access control.
    */
    LocalProperty* localproperty = MetaObject::meta_cast<LocalProperty*>(&position);

    /* We must set an access control policy for remote users.  This
       policy is used to control what actions are permitted on this
       object.  There can actually be a "chain" of access control
       policies; the first parameter indicates that the new policy
       should be added to the end of the chain.  We are using a
       read-only policy, so remote users will be able to read but not
       change the value of this property.
    */
    localproperty->insertPropertyAccessControl(-1, &ReadOnlyPropertyAccessControl::static_);


    cout << "Going into runloop now.\n";

    while(true) {
        localsite.flushIncomingBuffers();
    }
}

void listTypes(Vobject* vob)
{
    // The type set is returned as an STL set<string>.  Simply use
    // standard iterators to iterate over the set.

    const Vobject::TypeSet& types = vob->getTypes();

    cout << "Types for " << vob->getURL().getString() << ": ";
    for(Vobject::TypeSet::const_iterator i = types.begin(); i != types.end(); i++)
    {
        if(i != types.begin()) cout << ", ";
        cout << (*i);
    }
    cout << "\n";
}

---