vos/metaobjects/property/property.cc

Go to the documentation of this file.

/*
    This file is part of the Virtual Object System of
    the Interreality project (http://interreality.org).

    Copyright (C) 2001, 2002 Peter Amstutz

    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
    License as published by the Free Software Foundation; either
    version 2 of the License, or (at your option) any later version.

    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Lesser General Public License for more details.

    You should have received a copy of the GNU Lesser General Public
    License along with this library; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307  USA

    Peter Amstutz <tetron@interreality.org>
*/
#include <stdio.h>
#include <iostream>
#include <fstream>
#include <stdexcept>
#include <string>
#include <vector>


#include <vos/corelibs/vos/vos.hh>
#include "property.hh"
#include <typechain/typechain.hh>

#include <assert.h>


using namespace std;

NoPropertyAccessControl NoPropertyAccessControl::static_;
ReadOnlyPropertyAccessControl ReadOnlyPropertyAccessControl::static_;
DoNothingPropertyListener DoNothingPropertyListener::static_;
DoNothingPropertySecurityInitializer DoNothingPropertySecurityInitializer::static_;
PropertySecurityInitializer* LocalProperty::securitycallback =
    &DoNothingPropertySecurityInitializer::static_;

map<string, PropertyAccessControl::AssignAC> PropertyAccessControl::policies;

void PropertyAccessControl::addPolicy(PropertyAccessControl* ac)
{
    policies[ac->getPolicyName()].ac = ac;
    policies[ac->getPolicyName()].fac = 0;
}

void PropertyAccessControl::addPolicyFactory(const string& name, PropertyAccessControlFactory ac)
{
    policies[name].ac = 0;
    policies[name].fac = ac;
}

PropertyAccessControl* PropertyAccessControl::getPolicy(const string& name, LocalProperty* lv)
{
    if(policies.count(name)) {
        if(policies[name].ac) return policies[name].ac;
        else {
            return (*policies[name].fac)(name, lv);
        }
    } else return 0;
}

void PropertyAccessControl::removePolicy(const string& name)
{
    policies.erase(name);
}


/* Constructors */



Property::Property(MetaObject* superobject)
    : MetaObject(superobject), raw_data(""), raw_datatype("?"), raw_length(-1), data(""), datatype("?"), data_length(0), decoded(false)
{
}



/* Property base class */

const string Property::getType()
{
    return string("property:property");
}

void Property::checkDecoded() {
    if(!decoded) {
        LOG("Property", 4, "Property::checkDecoded: Decoding data of type " << raw_datatype << "." );
        readRaw(data);  // XXX note: this may perform a network-read unecesarily!
        datatype = TypeChain::decode(data, raw_datatype);
        data_length = data.size();
        decoded = true;
    }
}


int Property::getLength() {
    checkDecoded();
    return data_length;
}

void Property::read(string& target) {
    read(target, 0, -1);
}

void Property::read(string& target, int start, int length) {
    checkDecoded();
    if(length == -1)
        target = data.substr(start);
    else
        target = data.substr(start, length);
}

string Property::read() {
    string s;
    read(s);
    return s;
}

string Property::read(int start, int length) {
    string s;
    read(s, start, length);
    return s;
}

int Property::getRawLength() {
    return raw_length;
}

void Property::readRaw(string& target)  {
    readRaw(target, 0, getRawLength());
}

void Property::readRaw(string& target, int start, int length)  {
    if(length == -1)
        target = raw_data.substr(start);
    else
        target = raw_data.substr(start, length);
}

string Property::readRaw() {
    string s;
    readRaw(s);
    return s;
}

string Property::readRaw(int start, int length) {
    string s;
    readRaw(s, start, length);
    return s;
}

void Property::asyncRead()
{
    string dcp;
    read(dcp);
    vRef<PropertyEvent> event = new PropertyEvent(PropertyEvent::PropertyReplace,
                                                  *this, *this,
                                                  dcp, getDataType(),
                                                  false);
    for(PropertyListenerMap::iterator i = propertyListeners.begin(); i != propertyListeners.end(); i++) {
        (*i).second->notifyPropertyChange(*event);
    }
}

void Property::asyncRead(int start, int length)
{
    string dcp;
    read(dcp, start, length);
    vRef<PropertyEvent> event = new PropertyEvent(PropertyEvent::PropertyWrite,
                                                  *this, *this,
                                                  start, length,
                                                  dcp, getDataType(),
                                                  false);
    for(PropertyListenerMap::iterator i = propertyListeners.begin(); i != propertyListeners.end(); i++) {
        (*i).second->notifyPropertyChange(*event);
    }
}


void Property::write(int start, const string& newdata) {
    if(start < 0)
        start = raw_data.size() + start;
    raw_data.replace(start, newdata.size(), newdata);
    raw_length = raw_data.size();
    decoded = false;
}


void Property::replace(const string& newdata, const string& newtype) {
    raw_data = newdata;
    // if no type identifier was supplied, we assume that it should be the same as the old one.
    if(newtype != "?")
        raw_datatype = newtype;
    raw_length = raw_data.size();
    decoded = false;
}

const string Property::getDataType() {
    checkDecoded();
    return datatype;
}


const string Property::getRawDataType() {
    return raw_datatype;
}

void Property::registerExtenders()
{
    static bool done = false;
    if(! done) {
    LocalSite::addLocalObjectExtension(typeid(LocalProperty).name(),
                                         &LocalProperty::new_LocalProperty);
    LocalSite::addLocalObjectExtension(typeid(Property).name(),
                                         &LocalProperty::new_LocalProperty);
    LocalSite::addLocalObjectExtension("property:property",
                                         &LocalProperty::new_LocalProperty);

    RemoteSite::addRemoteObjectExtension(typeid(RemoteProperty).name(),
                                          &RemoteProperty::new_RemoteProperty);
    RemoteSite::addRemoteObjectExtension(typeid(Property).name(),
                                          &RemoteProperty::new_RemoteProperty);
    RemoteSite::addRemoteObjectExtension("property:property",
                                          &RemoteProperty::new_RemoteProperty);
    done = true;
    }
}

void Property::setProperty(Vobject& on,
                           const string& propname,
                           const string& propval,
                           const string& valtype,
                           PropertyAccessControl* pac)
    throw (AccessControlError, TypeChain::DecodeError, RemoteError)
{
    rREF(Vobject::ParentChildRelation&, r, setPropertyWithReturn(on, propname, propval, valtype, pac), );
}

Vobject::ParentChildRelation& Property::setPropertyWithReturn(Vobject& on,
                                                              const string& propname,
                                                              const string& propval,
                                                              const string& valtype,
                                                              PropertyAccessControl* pac,
                                                              bool letErrorThrough)
    throw (AccessControlError, TypeChain::DecodeError, RemoteError)
{
    int i;
    for(i = propname.size()-1; i >= 0  && propname[i] != '/'; i--);
    string path = (i > 0 ? propname.substr(0, i) : "");
    string name = propname.substr(i+1);
    try {
        vRef<Vobject> parent = on.findObject(path);
        vRef<ParentChildRelation> c = parent->findChild(name);
        if(Property* p = meta_cast<Property*>(c->child)) {
            p->replace(propval, valtype);
        }
        c->acquire();
        return *c; // released by: the caller of this method
    } catch(Vobject::NoSuchObjectError x) {
        if(letErrorThrough) throw x;
        vRef<Vobject> parent = on.findObject(path);
        //pREF(MetaObject*, m, Site::getDefaultPeer()->createMetaObject(propname.c_str(), typeid(Property).name(), 0),
        vRef<LocalSite> ls = Site::getDefaultPeer();
        vRef<MetaObject> m = ls->createMetaObject(propname.c_str(),
                                                  "property:property", 0);
        LocalProperty* lp = MetaObject::meta_cast<LocalProperty*>(&m);
        if(pac)
            lp->insertPropertyAccessControl(-1, pac);
        lp->addParentListener(&DoNothingListener::static_);
        parent->insertChild(-1, name, lp);
        return setPropertyWithReturn(on, propname, propval, valtype, pac, true);
    }
}

void Property::setProperty(Vobject& on,
                           const string& propname,
                           double propval,
                           PropertyAccessControl* pac)
    throw (AccessControlError, TypeChain::DecodeError, RemoteError)
{
    rREF(Vobject::ParentChildRelation&, r, setPropertyWithReturn(on, propname, propval, pac), );
}

Vobject::ParentChildRelation& Property::setPropertyWithReturn(Vobject& on,
                                                              const string& propname,
                                                              double propval,
                                                              PropertyAccessControl* pac)
    throw (AccessControlError, TypeChain::DecodeError, RemoteError)
{


    try {
        Vobject::ParentChildRelation& c = on.findChild(propname);
        if(Property* p = meta_cast<Property*>(c.child)) {
            char num[32];
            snprintf(num, sizeof(num), "%f", propval);
            p->replace(num, "text/x-float");
        }
        return c; // released by: the caller of this method
    } catch(Vobject::NoSuchObjectError) {
        vRef<MetaObject> m = Site::getDefaultPeer()->createMetaObject( propname.c_str(), typeid(Property).name(), 0);
        LocalProperty* lp = MetaObject::meta_cast<LocalProperty*>(&m);
        if(pac)
            lp->insertPropertyAccessControl(-1, pac);
        lp->addParentListener(&DoNothingListener::static_);
        on.insertChild(-1, propname, lp);
        return setPropertyWithReturn(on, propname, propval, pac);
    }
}

string Property::getProperty(Vobject& on, const string& name) {
    vRef<Vobject> v = on.findObject(name);
    Property* p = meta_cast<Property*>(&v);
    if(!p) throw bad_cast();
    return p->read();
}

string Property::getProperty(Vobject& on, const string& name, const string& defVal) {
    try {
        return Property::getProperty(on, name);
    } catch(Vobject::NoSuchObjectError) {
        return defVal;
    } catch(bad_cast) {
        return defVal;
    }
}


int Property::getIntProperty(Vobject& on, const string& name) {
    int v;
    string s;
    vRef<Property> p = meta_cast<Property*>(&(on.findObject(name)));
    if(!&p)
        throw bad_cast();
    p->read(s);
    sscanf(s.c_str(), "%d", &v);
    return v;
}

int Property::getIntProperty(Vobject& on, const string& name, int defaultVal) {
    try {
        return Property::getIntProperty(on, name);
    } catch(NoSuchObjectError) {
        return defaultVal;
    } catch(bad_cast) {
        return defaultVal;
    }
}

int Property::getIntProperty(Vobject& on, const string& name, int lowerLimit,
    int upperLimit)
{
    int v;
    v = Property::getIntProperty(on, name);
    if(v < lowerLimit) return lowerLimit;
    if(v > upperLimit) return upperLimit;
    return v;
}

int Property::getIntProperty(Vobject& on, const string& name, int defaultVal,
    int lowerLimit, int upperLimit)
{
    int v;
    v = Property::getIntProperty(on, name, defaultVal);
    if(v < lowerLimit) return lowerLimit;
    if(v > upperLimit) return upperLimit;
    return v;
}


void Property::setIntProperty(Vobject& on, const string& name, int val,
        PropertyAccessControl* ac)
{
    char num[64];
    snprintf(num, sizeof(num), "%d", val);
    Property::setProperty(on, name, num, "text/x-int", ac);
}

void Property::setIntProperty(Vobject& on, const string& name, int val,
        int lowerLimit, int upperLimit, PropertyAccessControl* ac)
{
    if(val < lowerLimit) val = lowerLimit;
    if(val > upperLimit) val = upperLimit;
    Property::setIntProperty(on, name, val, ac);
}



double Property::getFloatProperty(Vobject& on, const string& name) {
    double v;
    string s;
    vRef<Property> p = meta_cast<Property*>(&(on.findObject(name)));
    if(!&p) throw bad_cast();
    p->read(s);
    sscanf(s.c_str(), "%lg", &v);
    return v;
}

bool Property::getBoolProperty(Vobject& on, const string& name) {
    string s;
    vRef<Property> p = meta_cast<Property*>(&(on.findObject(name)));
    if(!&p) throw bad_cast();
    p->read(s);
    if(s == "yes")
        return true;
    else
        return false;
}


double Property::getFloatProperty(Vobject& on, const string& name, double defaultVal) {
    double v = defaultVal;
    try {
        v = getFloatProperty(on, name);
    } catch(Vobject::NoSuchObjectError) {
        v = defaultVal;
    } catch(bad_cast) {
        v = defaultVal;
    }
    return v;
}

bool Property::getBoolProperty(Vobject& on, const string& name, bool defaultVal)
{
    try {
        return getBoolProperty(on, name);
    } catch(NoSuchObjectError) {
        return defaultVal;
    } catch(bad_cast) {
        return defaultVal;
    }
    return defaultVal;
}


double Property::getFloatProperty(Vobject& on, const string& name, double defaultVal, double lowerLimit, double upperLimit) {
    double v = getFloatProperty(on, name, defaultVal);
    if(v < lowerLimit) return lowerLimit;
    if(v > upperLimit) return upperLimit;
    return v;
}

double Property::getFloatProperty(Vobject& on, const string& name, double lowLim, double upLim) {
    double v = getFloatProperty(on, name);
    if(v < lowLim) return lowLim;
    if(v > upLim) return upLim;
    return v;
}



void Property::setFloatProperty(Vobject& on, const string& name, double val,
        double lowerLimit, double upperLimit, PropertyAccessControl* ac) {
    if(val < lowerLimit) val = lowerLimit;
    if(val > upperLimit) val = upperLimit;
    setProperty(on, name, val, ac);
}

void Property::setFloatProperty(Vobject& on, const string& name, double val,
        PropertyAccessControl* ac) {
    setProperty(on, name, val, ac);
}


void Property::setBoolProperty(Vobject& on, const string& name, bool val,
        PropertyAccessControl* ac) {
    string s;
    if(val)
        s = "yes";
    else
        s = "no";
    setProperty(on, name, s, "text/x-yes-no", ac);
}

void Property::setFloatVectorProperty(Vobject& on, const string& name, vector<double> v, PropertyAccessControl* ac) {
    string s = "";  // TODO: reserve enough space for (v.size() * typical size of a double) chars.
    char c[256]; // TODO: find out max. number of digits in a double with 15 decimals.
    for(vector<double>::const_iterator i = v.begin(); i != v.end(); i++) {
        snprintf(c, sizeof(c), "%.15g", *i);
        s += c;
        if(i != v.end())
            s += " ";
    }
    setProperty(on, name, s, "text/x-vector/float", ac);
}


vector<double> Property::getFloatVectorProperty(Vobject& on, const string& name) {
    string::size_type start, end;
    start = end = 0;
    string s = getProperty(on, name);
    vector<double> v;
    const char* SEP = " \t,";
    while( ( start = s.find_first_not_of(SEP, start) ) != s.npos) {
        end = s.find_first_of(SEP, start);
        v.push_back( strtod( s.substr(start, end - start).c_str(), NULL ) );
        start = end + 1;
    }
    return v;
}

void Property::readFromFile(const string& filename, const string& type) {
    ifstream f(filename.c_str(), ios::in|ios::binary);
    if(!f.is_open() || f.bad())
        throw runtime_error(string("Error opening file \"") + filename + "\" for reading.");
    f.seekg(0, ios::end);
    unsigned long size = f.tellg();
    f.seekg(0, ios::beg);
    char* buffer = new char[size+1];
    f.read(buffer, size);
    f.close();
    string val(buffer, size);
    if(type == "")
        replace(val, getDataType());
    else
        replace(val, type);
    free(buffer);
}

void Property::writeStringToFile(const string& s, const string& filename) {
    ofstream f(filename.c_str(), ios::out|ios::binary);
    if(!f.is_open() || f.bad())
        throw runtime_error(string("Error opening file \"") + filename + "\" for writing.");
    f.write(s.c_str(), s.length());
    if(f.bad())
        throw runtime_error(string("Error writing to file \"")+filename+"\"");
}


void Property::writeToFile(const string& filename, int offset, int length)
{
    string s;
    read(s, offset, length);
    writeStringToFile(s, filename);
}

void Property::writeRawToFile(const string& filename, int offset, int length)
{
    string s;
    readRaw(s, offset, length);
    writeStringToFile(s, filename);
}


void DoNothingPropertySecurityInitializer::initializePropertyAccessControl(LocalProperty* p, Vobject& requester)
{
    p->insertPropertyAccessControl(-1, &NoPropertyAccessControl::static_);
}

void Property::addPropertyListener(PropertyListener* pl, bool refresh)
{
    propertyListeners[pl] = pl;
    if(RefCounted* rc = dynamic_cast<RefCounted*>(pl)) {
        rc->acquire(); // released by: removePropertyListener(), doExcise() or notifyObjectExcise()
        rc->addExciseListener(this);
    }
}

void Property::removePropertyListener(PropertyListener* pl)
{
    if(propertyListeners.count(pl)) {
        propertyListeners.erase(pl);
        if(RefCounted* rc = dynamic_cast<RefCounted*>(pl)) {
            rc->removeExciseListener(this);
            rc->release(); // acquired by: addPropertyListener()
        }
    }
}

void Property::notifyObjectExcise(RefCounted* object)
{
    if(Site* st = dynamic_cast<Site*>(object)) {
        PropertyListenerSiteWrapper plsw(st);
        PropertyListenerMap::iterator i = propertyListeners.find(&plsw);
        if(i != propertyListeners.end()) {
            removePropertyListener((*i).second);
            // st->removeExciseListener(this); -> redundant, since this object is being excised
            LOG("Property", 5, "going to delete plsw at " << (*i).second);
            PropertyListener* pl = (*i).second;
            delete pl;
        }
    }
    if(PropertyListener* pl = dynamic_cast<PropertyListener*>(object)) {
        removePropertyListener(pl);
    }
}

void Property::doExcise()
{
    LOG("refcount", 3, "Begun excising property for " << getURL().getString() << " count is " << getCount());
    MetaObject::doExcise();

    for(PropertyListenerMap::iterator i = propertyListeners.begin();
        i != propertyListeners.end(); i++)
    {
        if(RefCounted* rc = dynamic_cast<RefCounted*>((*i).second)) {
            rc->removeExciseListener(this);
            rc->release(); // acquired by: addPropertyListener()
        }
        if(PropertyListenerSiteWrapper* plsw = dynamic_cast<PropertyListenerSiteWrapper*>((*i).second)) {
            delete plsw;
        }
    }
    propertyListeners.clear();
    LOG("refcount", 3, "Done excising property for " << getURL().getString());
    LOG("refcount", 3, "Count on this is " << getCount());
}

void Property::doSaveState(MessageBlock& output, set<string>& types, bool portable)
{
    vRef<Message> m = new Message();
    m->setMethod("property:replace");
    m->insertField(-1, "data", readRaw(), true);
    m->insertField(-1, "datatype", getDataType(), true);
    output.insertMessage(-1, &m);
}

PropertyListener::~PropertyListener()
{
}

PropertyListenerSiteWrapper::PropertyListenerSiteWrapper(Site* s)
    : site(s)
{
    site->acquire(); // released by: destructor
}

PropertyListenerSiteWrapper::PropertyListenerSiteWrapper(Site* s, const string& fn)
    :  firstnonce(fn), site(s)
{
    site->acquire(); // released by: destructor
}

PropertyListenerSiteWrapper::~PropertyListenerSiteWrapper()
{
    LOG("plsw", 5, "deleting plsw " << site << " which wraps " << site->getURL().getString());
    site->release(); // acquired by: contructor
}

/*void PropertyListenerSiteWrapper::notifyPropertyWrite(Property& p, int start, const string& newpiece, const string& dtype)
{
    vRef<Message> m = new Message();
    m->setType("update");
    m->setFrom(p.getURL().getString());
    m->setTo(site->getURL().getString());
    m->setMethod("property:update");

    char x[16];                // convert length (integer) to a string x...
    sprintf(x, "%i", start);
    m->insertField(-1, "start", string(x));
    m->insertField(-1, "data", newpiece);
    m->insertField(-1, "datatype", dtype);

    site->sendMessage(&m);
    }*/

void PropertyListenerSiteWrapper::notifyPropertyChange(const PropertyEvent& event)
{
    vRef<Message> m = new Message();
    m->setType("update");
    m->setFrom(event.getProperty()->getURL().getString());
    m->setTo(site->getURL().getString());
    m->setMethod("property:replace-update");
    if(firstnonce.size() > 0) {
        m->setNonce(firstnonce);
        firstnonce="";
    }
    m->insertField(-1, "data", event.getNewValue());
    m->insertField(-1, "datatype", event.getNewDataType());
    site->sendMessage(&m);
}

---