vos/corelibs/vos/remotemetaobject.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-2003 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 "remotemetaobject.hh"
#include "remotesite.hh"
#include "message.hh"

using namespace VOS;

/** @file
    Implements RemoteMetaObject.
 */

RemoteMetaObject::RemoteMetaObject(const string& name, RemoteSite* remotesite)
    : VobjectImplementation(name, remotesite, false),
      RemoteVobject(name, remotesite),
      MetaObject(0)
{
}

RemoteMetaObject::~RemoteMetaObject() {
    LOG("remotemetaobject", 4, "deleting " << getURL().getString());
}

const string& RemoteMetaObject::getName()
{
    if(superobject != 0) return superobject->getName();
    else return RemoteVobject::getName();
}

Site& RemoteMetaObject::getSite()
{
    if(superobject != 0) return superobject->getSite();
    else return RemoteVobject::getSite();
}

const URL& RemoteMetaObject::getURL()
{
    if(superobject != 0) return superobject->getURL();
    else return RemoteVobject::getURL();
}

bool RemoteMetaObject::isLocal()
{
    if(superobject != 0) return superobject->isLocal();
    else return RemoteVobject::isLocal();
}

bool RemoteMetaObject::isRemote()
{
    if(superobject != 0) return superobject->isRemote();
    else return RemoteVobject::isRemote();
}

const set<string>& RemoteMetaObject::getTypes() throw (AccessControlError, RemoteError)
{
    if(superobject != 0) return superobject->getTypes();
    else return RemoteVobject::getTypes();
}

void RemoteMetaObject::addType(const string& s)
{
    if(superobject !=0) return superobject->addType(s);
    else return RemoteVobject::addType(s);
}

const set<Vobject::ParentChildRelation*, Vobject::ParentChildRelation::Cmp>& RemoteMetaObject::getParents()
    throw (AccessControlError, RemoteError)
{
    if(superobject != 0) return superobject->getParents();
    else return RemoteVobject::getParents();
}

const deque<Vobject::ParentChildRelation*>& RemoteMetaObject::getChildren()
    throw (AccessControlError, RemoteError)
{
    if(superobject != 0) return superobject->getChildren();
    else return RemoteVobject::getChildren();
}

void RemoteMetaObject::sendMessage(Message* m)
{
    MetaObject::sendMessage(m);

    if(superobject == 0) {
        RemoteVobject::sendMessage(m);
    }
}

void RemoteMetaObject::sendMessage(MessageBlock* m)
{
    MetaObject::sendMessage(m);

    if(superobject == 0) {
        RemoteVobject::sendMessage(m);
    }
}

Message* RemoteMetaObject::receiveMessage() throw (MessageQueueEmptyError)
{
    if(superobject != 0) return superobject->receiveMessage();
    else return RemoteVobject::receiveMessage();
}

bool RemoteMetaObject::hasMessageAvailable()
{
    if(superobject != 0) return superobject->hasMessageAvailable();
    else return RemoteVobject::hasMessageAvailable();
}

void RemoteMetaObject::handleNewType(const string& t)
{
    for(deque<MetaObject*>::const_iterator i = getTypeHandlers().begin();
        i != getTypeHandlers().end(); i++)
    {
        if((*i)->getType() == t) {
            return;
        }
    }

    RemoteSite::extendMetaObject(this, t.c_str());

    // test to see if the extension worked
    bool hastype=false;
    for(deque<MetaObject*>::const_iterator i = getTypeHandlers().begin();
        i != getTypeHandlers().end(); i++)
    {
        if((*i)->getType() == t) {
            hastype=true;
        }
    }

    string s = t;

    // don't have extension "s", so back up to
    // next supertype and try again
    for(unsigned int i = (unsigned int)s.size(); !hastype; ) {
        for(i--; i > 0 && s[i] != '.'; i--);
        if(i == 0) break;

        s = s.substr(0, i);

        RemoteSite::extendMetaObject(this, s.c_str());

        hastype=false;
        for(deque<MetaObject*>::const_iterator i = getTypeHandlers().begin();
            i != getTypeHandlers().end(); i++) {
            if((*i)->getType() == s) {
                hastype=true;
            }
        }
        if(hastype) {
            VobjectImplementation::addType(this, s);
        }
    }

}

void RemoteMetaObject::sendUpdateMessage(Message* m)
{
    LOG("refcount", 5, "before sending to MetaObject::sendUpdateMessage count on message " << m->getCount());
    MetaObject::sendUpdateMessage(m);
    LOG("refcount", 5, "after sending to MetaObject::sendUpdateMessage count on message " << m->getCount());

    if(superobject == 0) {
        LOG("refcount", 5, "before sending to RemoteVobject::sendUpdateMessage count on message " << m->getCount());
        RemoteVobject::sendUpdateMessage(m);
        LOG("refcount", 5, "after sending to RemoteVobject::sendUpdateMessage count on message " << m->getCount());

        if(m->getMethod() == "core:type-add-update") {
            for(int i=0; i < m->getNumFields(); ++i) {
                const Message::Field& t=m->getField(i);
                if(t.key == "type") {
                    handleNewType(t.value);
                }
            }
        }
    }
}

Message* RemoteMetaObject::receiveUpdateMessage() throw (MessageQueueEmptyError)
{
    if(superobject != 0) return superobject->receiveUpdateMessage();
    else return RemoteVobject::receiveUpdateMessage();
}

bool RemoteMetaObject::hasUpdateMessageAvailable()
{
    if(superobject != 0) return superobject->hasUpdateMessageAvailable();
    else return RemoteVobject::hasUpdateMessageAvailable();
}

Vobject& RemoteMetaObject::findObject(const string& path)
    throw (NoSuchSiteError, NoSuchObjectError, URL::BadURLError, AccessControlError, RemoteError)
{
    if(superobject != 0) return superobject->findObject(path);
    else return RemoteVobject::findObject(path);
}

Vobject::ParentChildRelation& RemoteMetaObject::findChild(const string& path)
    throw (NoSuchObjectError, AccessControlError, RemoteError)
{
    if(superobject != 0) return superobject->findChild(path);
    else return RemoteVobject::findChild(path);
}

Vobject::ParentChildRelation& RemoteMetaObject::findParent(Vobject& parent)
    throw (NoSuchObjectError, AccessControlError, RemoteError)
{
    if(superobject != 0) return superobject->findParent(parent);
    else return RemoteVobject::findParent(parent);
}

void RemoteMetaObject::setChild(int position, const string& contextual_name, Vobject* child)
    throw (AccessControlError, RemoteError)
{
    if(superobject != 0) return superobject->setChild(position, contextual_name, child);
    else return RemoteVobject::setChild(position, contextual_name, child);
}

void RemoteMetaObject::insertChild(int position, const string& contextual_name, Vobject* child)
    throw (AccessControlError, RemoteError)
{
    if(superobject != 0) return superobject->insertChild(position, contextual_name, child);
    else return RemoteVobject::insertChild(position, contextual_name, child);
}

void RemoteMetaObject::removeChild(int position)
    throw (AccessControlError, RemoteError)
{
    if(superobject != 0) return superobject->removeChild(position);
    else return RemoteVobject::removeChild(position);
}

void RemoteMetaObject::addTypeListener(TypeChangeListener* tl, bool refresh)
{
    if(superobject != 0) superobject->addTypeListener(tl, refresh);
    else RemoteVobject::addTypeListener(tl, refresh);
}

void RemoteMetaObject::addParentListener(ParentChangeListener* pl, bool refresh)
{
    if(superobject != 0) superobject->addParentListener(pl, refresh);
    else RemoteVobject::addParentListener(pl, refresh);
}

void RemoteMetaObject::addChildListener(ChildChangeListener* cl, bool refresh)
{
    if(superobject != 0) superobject->addChildListener(cl, refresh);
    else RemoteVobject::addChildListener(cl, refresh);
}

void RemoteMetaObject::removeTypeListener(TypeChangeListener* tl)
{
    if(superobject != 0) superobject->removeTypeListener(tl);
    else RemoteVobject::removeTypeListener(tl);
}

void RemoteMetaObject::removeParentListener(ParentChangeListener* pl)
{
    if(superobject != 0) superobject->removeParentListener(pl);
    else RemoteVobject::removeParentListener(pl);
}

void RemoteMetaObject::removeChildListener(ChildChangeListener* cl)
{
    if(superobject != 0) superobject->removeChildListener(cl);
    else RemoteVobject::removeChildListener(cl);
}

void RemoteMetaObject::excise()
{
    MetaObject::excise();
    RemoteVobject::excise();
}

void RemoteMetaObject::acquire() {
    if(superobject != 0) superobject->acquire();
    else RemoteVobject::acquire();
}

void RemoteMetaObject::release() {
    if(superobject != 0) superobject->release();
    else RemoteVobject::release();
}

int RemoteMetaObject::getCount() {
    if(superobject != 0) return superobject->getCount();
    else return RemoteVobject::getCount();
}

void RemoteMetaObject::saveState(MessageBlock& output, set<string>& types, bool portable)
{
    if(superobject !=0) return superobject->saveState(output, types, portable);
    else {
        RemoteVobject::saveState(output, types, portable);
        doSaveState(output, types, portable);
    }
}

void RemoteMetaObject::addFlag(const string& flag)
{
    if(superobject) superobject->addFlag(flag);
    else RemoteVobject::addFlag(flag);
}

void RemoteMetaObject::removeFlag(const string& flag)
{
    if(superobject) superobject->removeFlag(flag);
    else RemoteVobject::removeFlag(flag);
}

bool RemoteMetaObject::checkFlag(const string& flag)
{
    if(superobject) return superobject->checkFlag(flag);
    else return RemoteVobject::checkFlag(flag);
}

---