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

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

Go to the documentation of this file.

/* Eighth VOS tutorial.  Creating your own MetaObjects II

    See vostut8creature.hh for the declaration of this class and the beginning
    of this tutorial.

    All of these methods will simply set or get property values, more or
    less.  They use a convenient static member of Property. The convention
    for child object contextual names is similar to type names: a
    type name or type's "group" name prefix followed by the name of
    the property.

*/

#include <string>
#include <vos/vos/vos.hh>
#include <vos/metaobjects/misc/hypercard.hh>

#include "vostut8creature.hh"

using namespace std;
using namespace VUtil;
using namespace VOS;


                    /* Creature */

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


// Return the VOS type string for the metaobject
const std::string Creature::getVOSType() {
    return "tutorial:creature";
}

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


/* Set genus */
void Creature::setGenus(const std::string& value) {
    Property::setProperty(*this, "tutorial:genus", value, "string");
}

/* Get genus */
void Creature::getGenus(std::string& value) {
    string t;
    Property::getProperty(*this, "tutorial:genus", value, t);
}

/* Set species */
void Creature::setSpecies(const std::string& value) {
    Property::setProperty(*this, "tutorial:species", value, "string");
}

/* Get species */
void Creature::getSpecies(std::string& value) {
    string t;
    Property::getProperty(*this, "tutorial:species", value, t);
}

/* Set common name */
void Creature::setCommonName(const std::string& value) {
    Property::setProperty(*this, "tutorial:common-name", value, "string");
}

/* Get common name */
void Creature::getCommonName(std::string& value) {
    string t;
    Property::getProperty(*this, "tutorial:common-name", value, t);
}

/* Set description */
void Creature::setDescription(const std::string& value, const std::string& datatype) {
    Property::setProperty(*this, "tutorial:description", value, datatype);
}

/* Get description */
void Creature::getDescription(std::string& value, std::string& datatype) {
    Property::getProperty(*this, "tutorial:description", value, datatype);
}

/* Set image data */
void Creature::setImage(const std::string& data, const std::string& datatype) {
    Property::setProperty(*this, "tutorial:image", data, datatype);
}

/* Get image data */
void Creature::getImage(std::string& value, std::string& datatype) {
    Property::getProperty(*this, "tutorial:image", value, datatype);
}

/* Add a pedator (something that eats this creature) */
void Creature::addPredator(Creature* p) {
    /* We will use a hypercard to make an indirect link to the predator.  */
    vRef<Hypercard> hc = getSite()->createVobject<Hypercard>("predator", getDefaultPolicy());
    hc->setLink(p);
    insertChild(-1, "tutorial:predator", hc);
}

void Creature::setLength(double r){
    // The are several variants of setProperty for different types
    // They will set the property's datatype appropriately.
    Property::setProperty(*this, "tutorial:length", r);
}

double Creature::getLength() {
    double l;
    Property::getProperty(*this  , "tutorial:length", l);
    return l;
}




                /* Animal */

Animal::Animal(VobjectBase* superobject)
    : Creature(superobject) {
}

// The convention for types that extend other types is to form a new type
// name by appending a tag to the old type with a ".".  VOS will also use
// this convention to "fall back" on the extended type if it sees a derived
// type string that it doesn't recognize.
const std::string Animal::getVOSType() {
    return "tutorial:creature.animal";
}


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



void Animal::setTailLength(double l) {
    Property::setProperty(*this, "tutorial:tail-length", l);
}

double Animal::getTailLength() {
    // If this property is missing, we'll return a default value.
    try {
        double l;
        Property::getProperty(*this, "tutorial:tail-length", l);
        return l;
    } catch(NoSuchObjectError&) {
        return 0.0;
    }
}

void Animal::addPrey(Creature* p) {
    /* We will use a hypercard to make an indirect link to the prey. */
    vRef<Hypercard> hc = getSite()->createVobject<Hypercard>("prey", getDefaultPolicy());
    hc->setLink(p);
    insertChild(-1, "tutorial:prey", hc);
}




                    /* Factory registration */
/* 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_LocalCreature and new_RemoteCreature factory
   methods to a global table of MetaObject types and their factories.
*/
BEGIN_REGISTER_METAOBJECT_FACTORIES(CreaturesEtc)

/* 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_LocalCreature 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 LocalCreature extension.
*/
Site::addLocalMetaObjectFactory(typeid(Creature).name(), &Creature::new_Creature);
Site::addLocalMetaObjectFactory("tutorial:creature", &Creature::new_Creature);
Site::addRemoteMetaObjectFactory(typeid(Creature).name(), "tutorial:creature", &Creature::new_Creature);
Site::addRemoteMetaObjectFactory("tutorial:creature", "tutorial:creature", &Creature::new_Creature);

Site::addLocalMetaObjectFactory(typeid(Animal).name(), &Animal::new_Animal);
Site::addLocalMetaObjectFactory("tutorial:creature.animal", &Animal::new_Animal);
Site::addRemoteMetaObjectFactory(typeid(Animal).name(), "tutorial:creature.animal", &Animal::new_Animal);
Site::addRemoteMetaObjectFactory("tutorial:creature.animal", "tutorial:creature.animal", &Animal::new_Animal);

END_REGISTER_METAOBJECT_FACTORIES(CreaturesEtc)