node.C

Go to the documentation of this file.

/*
 * This file is part of the "Archon" framework.
 * (http://files3d.sourceforge.net)
 *
 * Copyright © 2002 by Kristian Spangsege and Brian Kristiansen.
 *
 * Permission to use, copy, modify, and distribute this software and
 * its documentation under the terms of the GNU General Public License is
 * hereby granted. No representations are made about the suitability of
 * this software for any purpose. It is provided "as is" without express
 * or implied warranty. See the GNU General Public License
 * (http://www.gnu.org/copyleft/gpl.html) for more details.
 *
 * The characters in this file are ISO8859-1 encoded.
 *
 * The documentation in this file is in "Doxygen" style
 * (http://www.doxygen.org).
 */

#include <archon/x3d/server/field_type.H>
#include <archon/x3d/server/field.H>
#include <archon/x3d/server/node.H>
#include <archon/x3d/server/scene.H>
#include <archon/x3d/server/server.H>

namespace Archon
{
  namespace X3D
  {
    NodeBase::NodeBase(BackRef<ExecutionContext> context):
      context(context), realized(false)
    {
      if(!context)
        ARCHON_THROW1(ArgumentException,
                      "ExecutionContext required to construct node");
    }

    NodeBase::NodeBase()
    {
      ARCHON_THROW1(InternalException,
                    "Construction of abstract node type");
    }

    NodeBase::~NodeBase()
    {
      try { context->changeNodeName(this, name, ""); } // Erase the mapping
      catch(ForwardDestroyedException &) {}
    }    

    void NodeBase::refForwardDestroy()
    {
      getType()->forwardClear(this);
      routeTargets.clear();
    }

    void NodeBase::realize()
    {
      {
        Mutex::Lock l(mutex);
        if(realized) return;
        realized = true;
      }
      onRealized();
    }

    bool NodeBase::isRealized() const
    {
      Mutex::Lock l(mutex);
      return realized;
    }

    string NodeBase::getName() const
    {
      Mutex::Lock l(mutex);
      return name;
    }

    void NodeBase::setName(string newName)
      throw(NodeNameInUseException)
    {
      Mutex::Lock l(mutex);
      context->changeNodeName(this, name, newName);
      name = newName;
    }

    const FieldBase *NodeBase::lookupField(string name) const
    {
      return getType()->lookupField(name);
    }

    Ref<ValueBase> NodeBase::get(const FieldBase *f) const
      throw(AccessException, UnexpectedException)
    {
      {
        Mutex::Lock l(mutex);
        if(!realized)
        {
          if(f->getIsEventTarget() != f->getIsEventSource())
            ARCHON_THROW(AccessException);
          return f->get(this);
        }
      }
      try
      {
        if(!f->getIsEventSource()) ARCHON_THROW(AccessException);
        Mutex::Lock l(context->server->scenegraphMutex);
        return f->get(this);
      }
      catch(ForwardDestroyedException &)
      {
        ARCHON_THROW(AccessException);
      }
    }

    unsigned NodeBase::getSize(const SequenceFieldBase *f) const
      throw(AccessException, UnexpectedException)
    {
      {
        Mutex::Lock l(mutex);
        if(!realized)
        {
          if(f->getIsEventTarget() != f->getIsEventSource())
            ARCHON_THROW(AccessException);
          return f->getSize(this);
        }
      }
      try
      {
        if(!f->getIsEventSource()) ARCHON_THROW(AccessException);
        Mutex::Lock l(context->server->scenegraphMutex);
        return f->getSize(this);
      }
      catch(ForwardDestroyedException &)
      {
        ARCHON_THROW(AccessException);
      }
    }

    Ref<ValueBase> NodeBase::getAt(const SequenceFieldBase *f, unsigned i) const
      throw(AccessException, RangeException, UnexpectedException)
    {
      {
        Mutex::Lock l(mutex);
        if(!realized)
        {
          if(f->getIsEventTarget() != f->getIsEventSource())
            ARCHON_THROW(AccessException);
          if(i >= f->getSize(this)) ARCHON_THROW(RangeException);
          return f->getAt(this, i);
        }
      }
      try
      {
        if(!f->getIsEventSource()) ARCHON_THROW(AccessException);
        Mutex::Lock l(context->server->scenegraphMutex);
        if(i >= f->getSize(this)) ARCHON_THROW(RangeException);
        return f->getAt(this, i);
      }
      catch(ForwardDestroyedException &)
      {
        ARCHON_THROW(AccessException);
      }
    }

    void NodeBase::set(const FieldBase *f, const Event *e)
      throw(AccessException, UnexpectedException)
    {
      // If the event value consists of one or more nodes then verify
      // and realize them
      if(const NodeValue *v = dynamic_cast<const NodeValue *>(e->value.get()))
      {
        if(v->value)
        {
          if(v->value->context != context)
            ARCHON_THROW1(ArgumentException,
                          "set: Node has wrong context");
          v->value->realize();
        }
      }
      else if(const NodeSequenceValue *v =
              dynamic_cast<const NodeSequenceValue *>(e->value.get()))
        for(NodeSequenceValue::ConstIterator i=v->begin(); i!=v->end(); ++i)
        {
          if(!*i)
            ARCHON_THROW1(ArgumentException,
                          "set: null found in node vector");
          if((*i)->context != context)
            ARCHON_THROW1(ArgumentException,
                          "set: Node has wrong context");
          (*i)->realize();
        }
      
      {
        Mutex::Lock l(mutex);
        if(!realized)
        {
          if(f->getIsEventTarget() != f->getIsEventSource())
            ARCHON_THROW(AccessException);
          f->set(this, e, false);
          return;
        }
      }
      try
      {
        if(!f->getIsEventTarget()) ARCHON_THROW(AccessException);
        Mutex::Lock l(context->server->scenegraphMutex);
        f->set(this, e, true);
      }
      catch(ForwardDestroyedException &)
      {
        ARCHON_THROW(AccessException);
      }
    }

    void NodeBase::setAt(const SequenceFieldBase *f, Ref<const ValueBase> v,
                     unsigned i, Time t)
      throw(AccessException, RangeException, UnexpectedException)
    {
      if(const NodeValue *w = dynamic_cast<const NodeValue *>(v.get()))
      {
        if(!w->value)
          ARCHON_THROW1(ArgumentException, "setAt: Node was null");
        if(w->value->context != context)
          ARCHON_THROW1(ArgumentException, "setAt: Node has wrong context");
        w->value->realize();
      }

      {
        Mutex::Lock l(mutex);
        if(!realized)
        {
          if(f->getIsEventTarget() != f->getIsEventSource())
            ARCHON_THROW(AccessException);
          if(i >= f->getSize(this)) ARCHON_THROW(RangeException);
          f->setAt(this, v.get(), i, t, false);
          return;
        }
      }
      try
      {
        if(!f->getIsEventTarget() || !f->getIsEventSource())
          ARCHON_THROW(AccessException);
        Mutex::Lock l(context->server->scenegraphMutex);
        if(i >= f->getSize(this)) ARCHON_THROW(RangeException);
        f->setAt(this, v.get(), i, t, true);
      }
      catch(ForwardDestroyedException &)
      {
        ARCHON_THROW(AccessException);
      }
    }

    void NodeBase::add(const SequenceFieldBase *f, Ref<const ValueBase> v, Time t)
      throw(AccessException, UnexpectedException)
    {
      if(const NodeValue *w = dynamic_cast<const NodeValue *>(v.get()))
      {
        if(!w->value)
          ARCHON_THROW1(ArgumentException, "add: Node was null");
        if(w->value->context != context)
          ARCHON_THROW1(ArgumentException, "add: Node has wrong context");
        w->value->realize();
      }

      {
        Mutex::Lock l(mutex);
        if(!realized)
        {
          if(f->getIsEventTarget() != f->getIsEventSource())
            ARCHON_THROW(AccessException);
          f->add(this, v.get(), t, false);
          return;
        }
      }
      try
      {
        if(!f->getIsEventTarget() || !f->getIsEventSource())
          ARCHON_THROW(AccessException);
        Mutex::Lock l(context->server->scenegraphMutex);
        f->add(this, v.get(), t, true);
      }
      catch(ForwardDestroyedException &)
      {
        ARCHON_THROW(AccessException);
      }
    }

    void NodeBase::remove(const SequenceFieldBase *f, Ref<const ValueBase> v,
                      Time t)
      throw(AccessException, UnexpectedException)
    {
      if(const NodeValue *w = dynamic_cast<const NodeValue *>(v.get()))
      {
        if(!w->value)
          ARCHON_THROW1(ArgumentException, "remove: Node was null");
        if(w->value->context != context)
          ARCHON_THROW1(ArgumentException, "remove: Node has wrong context");
      }

      {
        Mutex::Lock l(mutex);
        if(!realized)
        {
          if(f->getIsEventTarget() != f->getIsEventSource())
            ARCHON_THROW(AccessException);
          f->remove(this, v.get(), t, false);
          return;
        }
      }
      try
      {
        if(!f->getIsEventTarget() || !f->getIsEventSource())
          ARCHON_THROW(AccessException);
        Mutex::Lock l(context->server->scenegraphMutex);
        f->remove(this, v.get(), t, true);
      }
      catch(ForwardDestroyedException &)
      {
        ARCHON_THROW(AccessException);
      }
    }

    void NodeBase::add(const NodeSequenceFieldBase *f, Ref<NodeBase> n, Time t)
      throw(AccessException, UnexpectedException)
    {
      add(f, new NodeValue(SFNode::type, n.get()), t);
    }

    void NodeBase::remove(const NodeSequenceFieldBase *f, Ref<NodeBase> n, Time t)
      throw(AccessException, UnexpectedException)
    {
      remove(f, new NodeValue(SFNode::type, n.get()), t);
    }


    bool NodeBase::inject(const NodeFieldBase *f, Ref<NodeBase> n, Time stamp)
      throw(AccessException, UnexpectedException)
    {
      if(!n) ARCHON_THROW1(ArgumentException,
                           "inject: Node was null");
      if(n->context != context)
        ARCHON_THROW1(ArgumentException,
                      "inject: Node has wrong context");

      n->realize();

      {
        Mutex::Lock l(mutex);
        if(!realized)
        {
          if(f->getIsEventTarget() != f->getIsEventSource())
            ARCHON_THROW(AccessException);
          return f->inject(this, n.get(), stamp, false);
        }
      }
      try
      {
        if(!f->getIsEventTarget()) ARCHON_THROW(AccessException);
        Mutex::Lock l(context->server->scenegraphMutex);
        return f->inject(this, n.get(), stamp, true);
      }
      catch(ForwardDestroyedException &)
      {
        ARCHON_THROW(AccessException);
      }
    }

    bool NodeBase::changedSince(const Time &t) const
    {
      return getType()->changedSince(this, t);
    }

    /*
    string NodeBase::dumpFields(int level) const
    {
      return getType()->dumpFields(this, level);
    }
    */

    /*
    string NodeBase::dump(set<const NodeBase *> processedNodes, int level, bool indentFirstLine) const
    {
      string indent(2*level, ' ');
      string s;
      if(indentFirstLine) s += indent;
      string name = getName();

      if(!processedNodes.insert(this).second)
      {
        if(name.empty()) cerr << "Found recurring node with no name (skipping)" << endl;
        s += "USE \"" + name + "\"\n";
        return s;
      }

      if(!name.empty()) s += "DEF \"" + name + "\" ";
      s += getType()->getName() + " # [" +
        Text::toString(getUseCount()) + "]\n";
      s += indent + "{\n";
      s += dumpFields(level+1);
      s += indent + "}\n";
      return s;
    }
    */

    void NodeBase::addRouteTarget(Ref<const RouteHead> r)
    {
      Mutex::Lock l(routeTargetsMutex);
      routeTargets.push_back(r);
    }

    void NodeBase::removeRouteTarget(Ref<const RouteHead> r)
    {
      Mutex::Lock l(routeTargetsMutex);
      routeTargets.remove(r);
    }
  }
}

---