vos/corelibs/vos/metaobject.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 "metaobject.hh"
#include "log.hh"
#include "message.hh"

using namespace VOS;

/** @file
   Implements MetaObject.
 */

MetaObject::MetaObject(MetaObject* superobj)
    : superobject(superobj)
{
    if(superobject != 0) superobject->addObjectExtension(this);
}

MetaObject::~MetaObject()
{
    if(typehandlers.size() > 0) {
        for(int i = (int)typehandlers.size() - 1; i >=0; i--) {
            typehandlers.erase(typehandlers.begin()+i);
            delete typehandlers[i];
        }
    }
}

void MetaObject::addObjectExtension(MetaObject* moe)
{
    moe->superobject=this;
    typehandlers.push_back(moe);
}

MetaObject* MetaObject::getSuperObject()
{
    return superobject;
}

MetaObject* MetaObject::getTopObject()
{
    if(superobject) return superobject->getTopObject();
    else return this;
}

const deque<MetaObject*>& MetaObject::getTypeHandlers()
{
    return typehandlers;
}

void MetaObject::initializeSecurity(Vobject& requester)
{
}

const string& MetaObject::getName()
{
    return superobject->getName();
}

Site& MetaObject::getSite()
{
    return superobject->getSite();
}

const URL& MetaObject::getURL()
{
    return superobject->getURL();
}

bool MetaObject::isLocal()
{
    return superobject->isLocal();
}

bool MetaObject::isRemote()
{
    return superobject->isRemote();
}

const set<string>& MetaObject::getTypes() throw (AccessControlError, RemoteError)
{
    return superobject->getTypes();
}

const set<Vobject::ParentChildRelation*, Vobject::ParentChildRelation::Cmp>& MetaObject::getParents()
    throw (AccessControlError, RemoteError)
{
    return superobject->getParents();
}

const deque<Vobject::ParentChildRelation*>& MetaObject::getChildren()
        throw (AccessControlError, RemoteError)
{
    return superobject->getChildren();
}

void MetaObject::sendMessage(Message* m)
{
    LOG("sendMessage", 4, "metaobject saw " << m->getNonce());
    touchedNonces.insert(m->getNonce());
    if(superobject != 0 && !superobject->touchedNonces.count(m->getNonce())) {
        superobject->sendMessage(m);
    }
    for(deque<MetaObject*>::iterator i=typehandlers.begin();
        i != typehandlers.end();
        i++) {
        if(!(*i)->touchedNonces.count(m->getNonce())) {
            LOG("sendMessage", 4, getURL().getString() << " sending to type handler " << (*i)->getType());
            (*i)->sendMessage(m);
        }
    }
    touchedNonces.erase(m->getNonce());
}

void MetaObject::sendMessage(MessageBlock* m)
{
    superobject->sendMessage(m);
}

Message* MetaObject::receiveMessage() throw (MessageQueueEmptyError)
{
    // pass reference through
    return superobject->receiveMessage();
}

bool MetaObject::hasMessageAvailable()
{
    return superobject->hasMessageAvailable();
}

void MetaObject::sendUpdateMessage(Message* m)
{
    LOG("sendUpdateMessage", 4, getName() << " metaobject saw " << m->getNonce() << " (there are "
        << (unsigned int)typehandlers.size() << " handlers)");
    touchedNonces.insert(m->getNonce());
    if(superobject != 0 && !superobject->touchedNonces.count(m->getNonce())) {
        superobject->sendUpdateMessage(m);
    }
    for(deque<MetaObject*>::iterator i=typehandlers.begin();
        i != typehandlers.end();
        i++) {
        if(!(*i)->touchedNonces.count(m->getNonce())) {
            (*i)->sendUpdateMessage(m);
        }
    }
    touchedNonces.erase(m->getNonce());
}

Message* MetaObject::receiveUpdateMessage() throw (MessageQueueEmptyError)
{
    // pass reference through
    return superobject->receiveUpdateMessage();
}

bool MetaObject::hasUpdateMessageAvailable()
{
    return superobject->hasUpdateMessageAvailable();
}

Vobject& MetaObject::findObject(const string& path)  throw (NoSuchSiteError, NoSuchObjectError,
                                                           URL::BadURLError, AccessControlError, RemoteError)
{
    return superobject->findObject(path);
}

Vobject::ParentChildRelation& MetaObject::findChild(const string& path)
    throw (NoSuchObjectError, AccessControlError, RemoteError)
{
    return superobject->findChild(path);
}

Vobject::ParentChildRelation& MetaObject::findParent(Vobject& parent)
    throw (NoSuchObjectError, AccessControlError, RemoteError)
{
    return superobject->findParent(parent);
}

void MetaObject::setChild(int position, const string& contextual_name, Vobject* child)
    throw (AccessControlError, RemoteError)
{
    return superobject->setChild(position, contextual_name, child);
}

void MetaObject::insertChild(int position, const string& contextual_name, Vobject* child)
    throw (AccessControlError, RemoteError)
{
    return superobject->insertChild(position, contextual_name, child);
}

void MetaObject::removeChild(int position)
    throw (AccessControlError, RemoteError)
{
    return superobject->removeChild(position);
}

const string MetaObject::getType()
{
    return string("metaobject");
}

void MetaObject::addTypeListener(TypeChangeListener* tl, bool refresh)
{
    superobject->addTypeListener(tl, refresh);
}

void MetaObject::addParentListener(ParentChangeListener* pl, bool refresh)
{
    superobject->addParentListener(pl, refresh);
}

void MetaObject::addChildListener(ChildChangeListener* cl, bool refresh)
{
    superobject->addChildListener(cl, refresh);
}

void MetaObject::removeTypeListener(TypeChangeListener* tl)
{
    superobject->removeTypeListener(tl);
}

void MetaObject::removeParentListener(ParentChangeListener* pl)
{
    superobject->removeParentListener(pl);
}

void MetaObject::removeChildListener(ChildChangeListener* cl)
{
    superobject->removeChildListener(cl);
}

void MetaObject::addType(const string& s)
{
    superobject->addType(s);
}

void MetaObject::acquire() {
    superobject->acquire();
}

void MetaObject::release() {
    superobject->release();
}

int MetaObject::getCount() {
    return superobject->getCount();
}

void MetaObject::doExcise()
{
    RefCounted::excise();
}

void MetaObject::excise()
{
    if(superobject) {
        superobject->excise();
    } else {
        RefCounted::excise();

        if(typehandlers.size() > 0) {
            for(int i = (int)typehandlers.size() - 1; i >=0; i--) {
                typehandlers[i]->doExcise();
            }
        }
    }
}

void MetaObject::saveState(MessageBlock& output, set<string>& types, bool portable)
{
    superobject->saveState(output, types, portable);
}

void MetaObject::doSaveState(MessageBlock& output, set<string>& types, bool portable)
{
    LOG("metaobject", 4, "doSaveState called for " << getURL().getString() << " getType says " << getType());

    for(deque<MetaObject*>::iterator i=typehandlers.begin();
        i != typehandlers.end();
        i++)
    {
        (*i)->doSaveState(output, types, portable);
    }
}

void MetaObject::initialize() {
    for(deque<MetaObject*>::const_iterator i = typehandlers.begin();
        i != typehandlers.end(); i++)
    {
        (*i)->initialize();
    }
}

void MetaObject::addFlag(const string& flag)
{
    superobject->addFlag(flag);
}

void MetaObject::removeFlag(const string& flag)
{
    superobject->removeFlag(flag);
}

bool MetaObject::checkFlag(const string& flag)
{
    return superobject->checkFlag(flag);
}

---