vos/metaobjects/property/remoteproperty.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 <vos/corelibs/vos/vos.hh>
#include "property.hh"
#include <typechain/typechain.hh>

#include <assert.h>

RemoteProperty::RemoteProperty(MetaObject* superobject)
    : MetaObject(superobject), Property(superobject), offset(-1), first_read(true)
{
    addUpdateHandler<RemoteProperty>("property:length-update", this, &RemoteProperty::lengthUpdateHandler);
    addUpdateHandler<RemoteProperty>("property:update", this, &RemoteProperty::writeUpdateHandler);
    addUpdateHandler<RemoteProperty>("property:replace-update", this, &RemoteProperty::replaceUpdateHandler);
    addUpdateHandler<RemoteProperty>("property:start-listening-reply", this, &RemoteProperty::startListeningReplyHandler);
}


/* Remote Property */


void RemoteProperty::checkDecoded() {
    if(first_read) {
        string foo;
        readRaw(foo, 0, -1);
        first_read = false;
    }
    Property::checkDecoded();
}

int RemoteProperty::getRawLength()
{
    if(propertyListeners.empty()) {
        pREF(Message*, m, new Message(),
             rREF(LocalSite&, ls, RemoteVobject::initFields(this, m, "property:get-length", true),
                  sendMessage(m);
                  rREF(RemoteSite&, site, dynamic_cast<RemoteSite&>(getSite()),
                       pREF(Message*, n, ls.waitFor(m->getNonce(), &site), );
                      );
                 );
            );
    }

    return Property::getRawLength();
}

int RemoteProperty::getLength()
{
    string foo;
    readRaw(foo, 0, -1);
    return Property::getLength();
}

const string RemoteProperty::getRawDataType() {
    if(raw_datatype == "?") { // probably have not sent a read message yet. XXX but this could be done better
        string foo;
        readRaw(foo, 0, -1);
    }
    return Property::getRawDataType();
}


/* this is the primary read() method */
void RemoteProperty::read(string& target, int start, int length)
{
    string foo;
    readRaw(foo, start, length);    // send property:read message if necesary? XXX duplicate reads ??
    Property::read(target, start, length);
}

void RemoteProperty::readRaw(string& target, int start, int length)
{
    if(propertyListeners.empty()) {
        LOG("RemoteProperty", 5, "readRaw: sending read message (no listeners).");
        pREF(Message*, m, new Message(),
             rREF(LocalSite&, ls, RemoteVobject::initFields(this, m, "property:read", true),
                  char x[16];
                  sprintf(x, "%i", start);
                  m->insertField(-1, "start", x);
                  sprintf(x, "%i", length);
                  m->insertField(-1, "length", x);

                  sendMessage(m);
                  rREF(RemoteSite&, site, dynamic_cast<RemoteSite&>(getSite()),
                       pREF(Message*, n, ls.waitFor(m->getNonce(), &site), );
                      );
                 );
            );
    }

    Property::readRaw(target, start, length);
}

void RemoteProperty::asyncRead()
{
    if(propertyListeners.empty()) {
        LOG("RemoteProperty", 5, "readRaw: sending read message (no listeners).");
        pREF(Message*, m, new Message(),
             rREF(LocalSite&, ls, RemoteVobject::initFields(this, m, "property:read", true),
                  m->insertField(-1, "start", "0");
                  m->insertField(-1, "length", "-1");

                  sendMessage(m);
                 );
            );
    } else {
        vRef<PropertyEvent> event = new PropertyEvent(
            PropertyEvent::PropertyReplace,
            *this, *this,
            data,
            getRawDataType(),
            false);
                                                      
        for(PropertyListenerMap::iterator i = propertyListeners.begin(); i != propertyListeners.end(); i++) {
            (*i).second->notifyPropertyChange(*event);
        }
    }
}

void RemoteProperty::asyncRead(int start, int length)
{
    if(propertyListeners.empty()) {
        LOG("RemoteProperty", 5, "readRaw: sending read message (no listeners).");
        pREF(Message*, m, new Message(),
             rREF(LocalSite&, ls, RemoteVobject::initFields(this, m, "property:read", true),
                  char x[16];
                  snprintf(x, sizeof(x), "%i", start);
                  m->insertField(-1, "start", x);
                  snprintf(x, sizeof(x), "%i", length);
                  m->insertField(-1, "length", x);

                  sendMessage(m);
                 );
            );
    } else {
        vRef<PropertyEvent> event = new PropertyEvent(
            PropertyEvent::PropertyWrite,
            *this, *this,
            start, data.size(),
            data,
            getRawDataType(),
            false);                                                   

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


void RemoteProperty::write(int start, const string& newdata)
{
    vRef<Message> m = new Message();
    vRef<LocalSite> ls = RemoteVobject::initFields(this, &m, "property:write", true);
    char x[16];
    snprintf(x, sizeof(x), "%i", start);
    m->insertField(-1, "start", x);
    m->insertField(-1, "data", newdata);
    sendMessage(&m);
    vRef<RemoteSite> site = dynamic_cast<RemoteSite&>(getSite());
    vRef<Message> n = ls->waitFor(m->getNonce(), &site);
}

void RemoteProperty::replace(const string& newdata, const string& newtype)
{
    vRef<Message> m = new Message();
    vRef<LocalSite> ls = RemoteVobject::initFields(this, &m, "property:replace", true);
    m->insertField(-1, "data", newdata);

    // if no type was supplied, assume the old cached one still is correct
    if(newtype == "?")
        m->insertField(-1, "datatype", getRawDataType());
    else
        m->insertField(-1, "datatype", newtype);
    
    sendMessage(&m);
    vRef<RemoteSite> site = dynamic_cast<RemoteSite&>(getSite());
    vRef<Message> n = ls->waitFor(m->getNonce(), &site);
}



void RemoteProperty::lengthUpdateHandler(Message* m)
{
    if(m->getNumFields() > 0) {
        raw_length = atoi(m->getField(0).value.c_str());
        decoded = false;
    }
}

void RemoteProperty::writeUpdateHandler(Message* m)
{
    try {
        int off = atoi(m->getField("start").value.c_str());
        string oldvalue = raw_data;
        raw_data.replace(off, m->getField("data").value.size(), m->getField("data").value);
        raw_datatype = m->getField("datatype").value;
        raw_length = raw_data.size();
        decoded = false;        

        vRef<PropertyEvent> event = 
            new PropertyEvent(PropertyEvent::PropertyWrite,
                              *this, *this, 
                              off, raw_length,
                              raw_data, raw_datatype,
                              oldvalue, raw_datatype,
                              false);

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

void RemoteProperty::replaceUpdateHandler(Message* m)
{
        try {
            string oldvalue = raw_data;
            string olddatatype = raw_datatype;
            raw_data = m->getField("data").value;
            raw_datatype = m->getField("datatype").value;
            raw_length = raw_data.size();
            decoded = false;

        vRef<PropertyEvent> event = 
            new PropertyEvent(PropertyEvent::PropertyReplace,
                              *this, *this,
                              raw_data, raw_datatype,
                              oldvalue, olddatatype,
                              false);

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

void RemoteProperty::startListeningReplyHandler(Message* m)
{
    const Message::Field& f = m->getField("listen");
    if(f.value == "property") {
        Property::addPropertyListener(&DoNothingPropertyListener::static_);
    }
}

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

void RemoteProperty::addPropertyListener(PropertyListener* pl, bool refresh)
{
    if(propertyListeners.empty()) {
//      clearCache();   // correct? XXX

        if(refresh) {
            vRef<Message> m = new Message();
            vRef<LocalSite> ls = RemoteVobject::initFields(this, &m, "property:start-listening", true);
            m->insertField(-1, "listen", "property");

            sendMessage(&m);

            vRef<Site> site = getSite();
            vRef<Message> r = ls->waitFor(m->getNonce(), dynamic_cast<RemoteSite*>(&site));
        }
        Property::addPropertyListener(pl, refresh);
        string d;
        readRaw(d, 0, getRawLength());

        vRef<PropertyEvent> event = 
            new PropertyEvent(PropertyEvent::PropertyReplace,
                              *this, *this,
                              d, getRawDataType(),
                              false);

        pl->notifyPropertyChange(*event);
    } else {
        Property::addPropertyListener(pl, refresh);
        string d;
        readRaw(d, 0, getRawLength());

        if(refresh) {
            vRef<PropertyEvent> event = 
                new PropertyEvent(PropertyEvent::PropertyReplace,
                                  *this, *this,
                                  d, getRawDataType(),
                                  false);
            pl->notifyPropertyChange(*event);
        }
    }
}

void RemoteProperty::removePropertyListener(PropertyListener* pl)
{
    Property::removePropertyListener(pl);

    if(propertyListeners.size() == 1 && propertyListeners.count(&DoNothingPropertyListener::static_) == 1)
        propertyListeners.erase(&DoNothingPropertyListener::static_);

    if(propertyListeners.empty()) {
        vRef<Message> m = new Message();
        vRef<LocalSite> ls = RemoteVobject::initFields(this, &m, "property:stop-listening", false);
             
        m->insertField(-1, "listen", "property");
        
        sendMessage(&m);
    }
}

void RemoteProperty::clearCache()
{
    data="";
    raw_data = "";
    datatype="?";
    raw_datatype = "?";
    offset=-1;
    raw_length=-1;
    data_length = 0;
    decoded = false;
}

---