vos/corelibs/vos/typingtweaks/localmetaobject.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 "vos.hh"

/** @file
    Implements LocalMetaObject.
*/

LocalMetaObject::LocalMetaObject(const string& name, LocalSite* localsite, VobjectAccessControl* ac)
    : VobjectImplementation(name, localsite, true), LocalVobject(name, localsite, ac),
      MetaObject(0)
{
}

LocalMetaObject::~LocalMetaObject()
{
}

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

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

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

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

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

const set<string>& LocalMetaObject::getTypes() throw (AccessControlError)
{
    if(superobject != 0) return superobject->getTypes();
    else return LocalVobject::getTypes();
}

void LocalMetaObject::addType(const string& s, MetaObject* add_requester)
{
    if(getTypes().count(s)) return;
    if(superobject !=0) superobject->addType(s);
    else LocalVobject::addType(s);

    for(deque<MetaObject*>::const_iterator i = getTypeHandlers().begin(); i != getTypeHandlers().end(); i++) {
        if((*i)->getType() == s) {
            return;
        }
    }
    string t = s;
    if(LocalSite::hasLocalObjectExtension(t.c_str()))
    {
        LocalSite::extendMetaObject(this, t.c_str());
    } else {
        // don't have extension "s", so back up to
        // next supertype and try again
        int i = t.size();
        for(;;) {
            for(i--; i > 0 && s[i] != '.'; i--);
            if(i == 0) break;

            t = t.substr(0, i);

            if(LocalSite::hasLocalObjectExtension(t.c_str())) {
                LocalSite::extendMetaObject(this, t.c_str());
                if(superobject !=0) superobject->addType(t);
                else LocalVobject::addType(t);
                break;
            }
        }
    }
    if(add_requester) {
        for(deque<MetaObject*>::const_iterator i = getTypeHandlers().begin(); i != getTypeHandlers().end(); i++) {
            if((*i)->getType() == t) {
                (*i)->initializeSecurity(*add_requester);
            }
        }
    }
}

void LocalMetaObject::addType(const string& s)
{
    addType(s, 0);
}

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

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

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

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

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

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

Message* LocalMetaObject::receiveMessage() throw (MessageQueueEmptyError)
{
    rREF(Site&, site, getSite(),
         site.flushIncomingBuffers());
    if(superobject != 0) return superobject->receiveMessage();
    else return LocalVobject::receiveMessage();
}

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

void LocalMetaObject::sendUpdateMessage(Message* m)
{
    if(superobject != 0) sendUpdateMessage(m);
    else LocalVobject::sendUpdateMessage(m);
}

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

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

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

Vobject::ParentChildRelation& LocalMetaObject::findChild(const string& path) throw (NoSuchObjectError, AccessControlError, RemoteError)
{
    // pass reference through
    if(superobject != 0) return superobject->findChild(path);
    else return LocalVobject::findChild(path);
}

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

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

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

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

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

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

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

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

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

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

void LocalMetaObject::excise()
{
    MetaObject::excise();
    VobjectImplementation::excise();
}

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

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

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

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

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

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

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

---