vos/metaobjects/property/bufferedproperty.cc

Go to the documentation of this file.

/*
    This file is part of the Virtual Object System of
    the Interreality project.

    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>
    Additions by Reed Hedges <reed@zerohour.net> marked with initials "rh" and date.
*/

#include "bufferedproperty.hh"

set<BufferedLocalProperty*> BufferedLocalProperty::allblps;
set<BufferedRemoteProperty*> BufferedRemoteProperty::allbrps;

/* BufferedLocalProperty definition */

BufferedLocalProperty::BufferedLocalProperty(MetaObject* superobject)
    : MetaObject(superobject), Property(superobject), LocalProperty(superobject), changed(false)
{
    allblps.insert(this);
}

BufferedLocalProperty::BufferedLocalProperty(MetaObject* superobject, const string& d, const string& dt)
    : MetaObject(superobject), Property(superobject), LocalProperty(superobject, d, dt), changed(false)
{
    allblps.insert(this);
}

BufferedLocalProperty::~BufferedLocalProperty()
{
    allblps.erase(this);
}

MetaObject* BufferedLocalProperty::new_BufferedLocalProperty(MetaObject* superobject, const string& type)
{
    return new BufferedLocalProperty(superobject);
}

void BufferedLocalProperty::write(int start, const string& newdata)
{
    string oldvalue;
    read(oldvalue);

    Property::write(start, newdata);

    vRef<PropertyEvent> event = new PropertyEvent(PropertyEvent::PropertyWrite,
                                                  *this, *this,
                                                  start, newdata.size(),
                                                  read(), getDataType(),
                                                  oldvalue, getDataType(),
                                                  false);

    for(PropertyListenerMap::iterator i = propertyListeners.begin(); i != propertyListeners.end(); i++) {
        if(! dynamic_cast<PropertyListenerSiteWrapper*>((*i).second))
            (*i).second->notifyPropertyChange(*event);
    }
    changed = true;
    changestart = start;
    changelen = newdata.length();
}

void BufferedLocalProperty::replace(const string& newdata, const string& newtype)
{
    string oldvalue;
    read(oldvalue);

    Property::replace(newdata, newtype);
    string r;
    read(r);

    vRef<PropertyEvent> event = new PropertyEvent(PropertyEvent::PropertyReplace,
                                                  *this, *this,
                                                  read(), getDataType(),
                                                  oldvalue, getDataType(),
                                                  false);


    for(PropertyListenerMap::iterator i = propertyListeners.begin(); i != propertyListeners.end(); i++) {
        if(! dynamic_cast<PropertyListenerSiteWrapper*>((*i).second))
            (*i).second->notifyPropertyChange(*event);
    }
    changed = true;
    changestart = 0;
    changelen = getLength();
}

void BufferedLocalProperty::flush()
{
        if(changed) {

            vRef<PropertyEvent> event;
            if(changestart == 0 && changelen == getLength()) {
                event = new PropertyEvent(PropertyEvent::PropertyReplace,
                                      *this, *this,
                                      read(), getDataType(),
                                      false);
            } else {
                event = 
                    new PropertyEvent(PropertyEvent::PropertyWrite,
                                      *this, *this,
                                      changestart, changelen,
                                      read(), getDataType(),
                                      false);

            }

            for(PropertyListenerMap::iterator n = propertyListeners.begin();
                n != propertyListeners.end(); n++) {
                string s;
                readRaw(s, changestart, changelen);
                if(dynamic_cast<PropertyListenerSiteWrapper*>((*n).second)) {
                    (*n).second->notifyPropertyChange(*event);
                }
            }
            changed = false;
        }
}

void BufferedLocalProperty::flushAll()
{
    for(set<BufferedLocalProperty*>::iterator i = allblps.begin(); i != allblps.end(); i++) {
        try {
            (*i)->flush();
        } catch(runtime_error e) {
            LOG("bufferedproperty", 2, "flushAll caught exception: " << e.what());
        }
    }
}

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

/* BufferedRemoteProperty definition */

BufferedRemoteProperty::BufferedRemoteProperty(MetaObject* superobject)
    : MetaObject(superobject), Property(superobject), RemoteProperty(superobject), changed(false), lastmsgsuccess(false)
{
    allbrps.insert(this);
}

MetaObject* BufferedRemoteProperty::new_BufferedRemoteProperty(MetaObject* superobject, const string& type)
{
    return new BufferedRemoteProperty(superobject);
}

BufferedRemoteProperty::~BufferedRemoteProperty()
{
    allbrps.erase(this);
}

void BufferedRemoteProperty::write(int start, const string& newdata)
{
    string oldvalue;
    Property::read(oldvalue);

    Property::write(start, newdata);
    changed = true;
    changestart = start;
    changelen = newdata.length();

    if(lastmsgsuccess) {
        vRef<PropertyEvent> event = new PropertyEvent(PropertyEvent::PropertyWrite,
                                                      *this, *this,
                                                      start, newdata.size(),
                                                      Property::read(), getDataType(),
                                                      oldvalue, getDataType(),
                                                      false);


        for(PropertyListenerMap::iterator i = propertyListeners.begin(); i != propertyListeners.end(); i++) {
            (*i).second->notifyPropertyChange(*event);
        }
    }
}

void BufferedRemoteProperty::replace(const string& newdata, const string& newtype)
{
    string olddatatype = Property::getDataType();
    string oldvalue;
    Property::read(oldvalue);

    Property::replace(newdata, newtype);
    changed = true;
    changestart = 0;
    changelen = getLength();

    if(lastmsgsuccess) {
        vRef<PropertyEvent> event = new PropertyEvent(PropertyEvent::PropertyReplace,
                                                      *this, *this,
                                                      newdata, newtype,
                                                      oldvalue, olddatatype,
                                                      false);

        for(PropertyListenerMap::iterator i = propertyListeners.begin(); i != propertyListeners.end(); i++) {
            (*i).second->notifyPropertyChange(*event);
        }
    }
}

void BufferedRemoteProperty::flush()
{
    if(changed) {
        LOG("BufferedRemoteProperty", 3, "flushing " << getURL().getString());
        if(changestart == 0 && changelen == getRawLength()) {
            pREF(Message*, m, new Message(),
                 rREF(LocalSite&, ls, RemoteVobject::initFields(this, m, "property:replace", true),
                      lastnonce = m->getNonce();
                      string s;
                      readRaw(s, 0, getRawLength());
                      m->insertField(-1, "data", s);
                      // if no type was supplied, assume the old cached one still is correct
                      m->insertField(-1, "datatype", getRawDataType());
                      sendMessage(m);
                     );
                );
        } else {
            pREF(Message*, m, new Message(),
                 rREF(LocalSite&, ls, RemoteVobject::initFields(this, m, "property:write", true),
                      lastnonce = m->getNonce();
                      char x[16];
                      sprintf(x, "%i", changestart);
                      string s;
                      readRaw(s, changestart, changelen);
                      m->insertField(-1, "start", x);
                      m->insertField(-1, "data", s);
                      sendMessage(m);
                     );
                );
        }
        changed = false;
    }
}

void BufferedRemoteProperty::flushAll()
{
    for(set<BufferedRemoteProperty*>::iterator i = allbrps.begin(); i != allbrps.end(); i++) {
        (*i)->flush();
    }
}

void BufferedRemoteProperty::sendUpdateMessage(Message* m)
{
    if(!(changed && lastmsgsuccess)) RemoteProperty::sendUpdateMessage(m);

    if(m->getNonce() == lastnonce
       && (m->getMethod() == "property:update"
           || m->getMethod() == "property:replace-update"))
    {
        try {
            m->getField("data");
            lastmsgsuccess = true;
        } catch(Message::NoSuchFieldError) {
            try {
                m->getField("error");
                lastmsgsuccess = false;
            } catch(Message::NoSuchFieldError) { }
        }
    }
}

void BufferedRemoteProperty::registerExtenders()
{
    static bool done = false;
    if(! done) {
    RemoteSite::addRemoteObjectExtension(typeid(BufferedRemoteProperty).name(),
                                          &BufferedRemoteProperty::new_BufferedRemoteProperty);
    RemoteSite::addRemoteObjectExtension(typeid(RemoteProperty).name(),
                                          &BufferedRemoteProperty::new_BufferedRemoteProperty);
    RemoteSite::addRemoteObjectExtension(typeid(Property).name(),
                                          &BufferedRemoteProperty::new_BufferedRemoteProperty);
    RemoteSite::addRemoteObjectExtension("property:property",
                                          &BufferedRemoteProperty::new_BufferedRemoteProperty);
    done = true;
    }
}

---