session.C

/*
 * 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/util/cxx_demangle.H>
#include <archon/util/uri.H>

#include <archon/x3d/server/network.H>
#include <archon/x3d/server/parse_xml.H>

#include <archon/x3d/sai/exception.H>
#include <archon/x3d/sai/sai.H>
#include <archon/x3d/sai/session.H>
#include <archon/x3d/sai/listener.H>
#include <archon/x3d/sai/route.H>

#define CORBA_ENTRY_D(x) try { session->x; } \
catch(CORBA::UserException &) { throw; } \
catch(ForwardDestroyedException &) {} \
catch(...) { string m = SAI::exceptionCatchShortExplanation(); \
throw x3d::sai::ServerErrorException(m.c_str()); }

#define CORBA_ENTRY_V(x) try { session->x; } \
catch(CORBA::UserException &) { throw; } \
catch(ForwardDestroyedException &) \
{ throw x3d::sai::InvalidSessionException(); } \
catch(...) { string m = SAI::exceptionCatchShortExplanation(); \
throw x3d::sai::ServerErrorException(m.c_str()); }

#define CORBA_ENTRY_R(x) try { return session->x; } \
catch(CORBA::UserException &) { throw; } \
catch(ForwardDestroyedException &) \
{ throw x3d::sai::InvalidSessionException(); } \
catch(...) { string m = SAI::exceptionCatchShortExplanation(); \
throw x3d::sai::ServerErrorException(m.c_str()); }

namespace Archon
{
  namespace X3D
  {
    namespace SAI
    {
      using namespace Utilities;
  
      struct Session::Servant:
        POA_x3d::sai::Session, PortableServer::RefCountServantBase
      {
        const BackRef<SAI::Session> session;

        Servant(Ref<SAI::Session> session): session(session) {}

        ~Servant()
        {
        }

        // Session (or Browser) services

        char *getServerName()
        {
          CORBA_ENTRY_R(getServerName());
        }

        CORBA::Double getCurrentFrameRate()
        {
          CORBA_ENTRY_R(getCurrentFrameRate());
        }

        CORBA::ULong createApplicationScene(const char *baseUri,
                                            CORBA::Boolean localFileUri)
        {
          CORBA_ENTRY_R(createApplicationScene(baseUri, localFileUri));
        }

        CORBA::ULong loadApplicationScene(const char *uri,
                                          CORBA::Boolean localFileUri)
        {
          CORBA_ENTRY_R(loadApplicationScene(uri, localFileUri));
        }

        void launchApplicationScene(CORBA::ULong contextId)
        {
          CORBA_ENTRY_V(launchApplicationScene(contextId));
        }

        void withdrawApplicationScene(CORBA::ULong contextId)
        {
          CORBA_ENTRY_V(withdrawApplicationScene(contextId));
        }

        void beginUpdate()
        {
          CORBA_ENTRY_V(beginUpdate());
        }

        void endUpdate()
        {
          CORBA_ENTRY_V(endUpdate());
        }

        void print(const char *s)
        {
          CORBA_ENTRY_V(print(s));
        }

        void setSynchronizedChangesEnabled(CORBA::Boolean enabled)
        {
          CORBA_ENTRY_V(setSynchronizedChangesEnabled(enabled));
        }

        void disposeBatch(const x3d::sai::DisposeSeq &contexts,
                          const x3d::sai::DisposeSeq &nodes)
        {
          CORBA_ENTRY_V(disposeBatch(contexts, nodes));
        }

        void disposeSession()
        {
          CORBA_ENTRY_D(disposeSession());
        }


        // ExecutionContext services

        char *getBaseUri(CORBA::ULong contextId)
        {
          CORBA_ENTRY_R(getBaseUri(contextId));
        }

        CORBA::ULong getRootGroup(CORBA::ULong contextId)
        {
          CORBA_ENTRY_R(getRootGroup(contextId));
        }

        void setRootGroup(CORBA::ULong contextId, CORBA::ULong nodeId)
        {
          CORBA_ENTRY_V(setRootGroup(contextId, nodeId));
        }

        CORBA::ULong createNode(CORBA::ULong contextId, const char *typeName)
        {
          CORBA_ENTRY_R(createNode(contextId, typeName));
        }

        CORBA::ULong createNodeFast(CORBA::ULong contextId, CORBA::ULong typeId)
        {
          CORBA_ENTRY_R(createNode(contextId, typeId));
        }

        CORBA::ULong getNode(CORBA::ULong contextId, const char *nodeName)
        {
          CORBA_ENTRY_R(getNode(contextId, nodeName));
        }

        void addRoute(CORBA::ULong contextId,
                      CORBA::ULong fromNodeId, CORBA::ULong fromFieldId,
                      CORBA::ULong toNodeId, CORBA::ULong toFieldId)
        {
          CORBA_ENTRY_V(addRoute(contextId, fromNodeId, fromFieldId,
                           toNodeId, toFieldId));
        }

        void delRoute(CORBA::ULong contextId,
                      CORBA::ULong fromNodeId, CORBA::ULong fromFieldId,
                      CORBA::ULong toNodeId, CORBA::ULong toFieldId)
        {
          CORBA_ENTRY_V(delRoute(contextId, fromNodeId, fromFieldId,
                           toNodeId, toFieldId));
        }

        CORBA::ULong createGroupFromStream(CORBA::ULong contextId,
                                           x3d::sai::StreamReader_ptr r)
        {
          CORBA_ENTRY_R(createGroupFromStream(contextId, r));
        }

        void disposeContext(CORBA::ULong contextId)
        {
          CORBA_ENTRY_V(disposeContext(contextId));
        }


        // Node services

        char *getNodeType(CORBA::ULong nodeId)
        {
          CORBA_ENTRY_R(getNodeType(nodeId));
        }

        CORBA::ULong getField(CORBA::ULong nodeId, const char *name)
        {
          CORBA_ENTRY_R(getField(nodeId, name));
        }

        void disposeNode(CORBA::ULong nodeId)
        {
          CORBA_ENTRY_V(disposeNode(nodeId));
        }


        // Field services

        CORBA::ULong getFieldType(CORBA::ULong nodeId, CORBA::ULong fieldId)
        {
          CORBA_ENTRY_R(getFieldType(nodeId, fieldId));
        }

        char *getFieldName(CORBA::ULong nodeId, CORBA::ULong fieldId)
        {
          CORBA_ENTRY_R(getFieldName(nodeId, fieldId));
        }

        CORBA::ULong getFieldAccessType(CORBA::ULong nodeId,
                                        CORBA::ULong fieldId)
        {
          CORBA_ENTRY_R(getFieldAccessType(nodeId, fieldId));
        }

        void registerFieldInterest(CORBA::ULong nodeId, CORBA::ULong fieldId,
                                   CORBA::ULong cookie)
        {
          CORBA_ENTRY_V(registerFieldInterest(nodeId, fieldId, cookie));
        }

        void unRegisterFieldInterest(CORBA::ULong nodeId,
                                     CORBA::ULong fieldId,
                                     CORBA::ULong cookie)
        {
          CORBA_ENTRY_V(unRegisterFieldInterest(nodeId, fieldId, cookie));
        }

        x3d::sai::Value *getFieldValue(CORBA::ULong nodeId,
                                       CORBA::ULong fieldId)
        {
          CORBA_ENTRY_R(getFieldValue(nodeId, fieldId));
        }

        void setFieldValue(CORBA::ULong nodeId, CORBA::ULong fieldId,
                           const x3d::sai::Value &value)
        {
          CORBA_ENTRY_V(setFieldValue(nodeId, fieldId, value));
        }

        x3d::sai::Value *getFieldValueAt(CORBA::ULong nodeId,
                                         CORBA::ULong fieldId,
                                         CORBA::ULong index)
        {
          CORBA_ENTRY_R(getFieldValueAt(nodeId, fieldId, index));
        }

        void setFieldValueAt(CORBA::ULong nodeId, CORBA::ULong fieldId,
                             CORBA::ULong index, const x3d::sai::Value &value)
        {
          CORBA_ENTRY_V(setFieldValueAt(nodeId, fieldId, index, value));
        }

        void setFieldValueAdd(CORBA::ULong nodeId, CORBA::ULong fieldId,
                              const x3d::sai::Value &value)
        {
          CORBA_ENTRY_V(setFieldValueAdd(nodeId, fieldId, value));
        }

        void setFieldValueDel(CORBA::ULong nodeId, CORBA::ULong fieldId,
                              const x3d::sai::Value &value)
        {
          CORBA_ENTRY_V(setFieldValueDel(nodeId, fieldId, value));
        }

        void disposeField(CORBA::ULong fieldId)
        {
          CORBA_ENTRY_V(disposeField(fieldId));
        }
      };


      struct Reader: Stream::ReaderBase<char>
      {
        x3d::sai::StreamReader_var reader;

        bool eoi;

        Reader(x3d::sai::StreamReader_ptr r): eoi(false)
        {
          reader = x3d::sai::StreamReader::_duplicate(r);
        }

        ~Reader()
        {{
          try { reader->dispose(); }
          catch(...) {}
        }}

        int read(char *buffer, int size)
          throw(Stream::ReadException, UnexpectedException)
        {
          if(eoi) return 0;
          x3d::sai::chararray_var a;
          try { a = reader->read(size); }
          catch(x3d::sai::StreamReadException &e)
          {
            ARCHON_THROW1(Stream::ReadException, string(e.message));
          }
          catch(...)
          {
            ARCHON_THROW1(Stream::ReadException, "Caught unknown exception");
          }
          if(a->length()>(unsigned)size)
            ARCHON_THROW1(Stream::ReadException, "Too much data");
          if(a->length()<(unsigned)size) eoi = true;
          for(unsigned i=0; i<a->length(); ++i) buffer[i] = a[i];
          return a->length();
        }
      };

      struct ApplicationSceneReaper: Thread
      {
        void main()
        {
          list<Ref<ApplicationScene> >::iterator i = launchedScenes.begin();
          while(i != launchedScenes.end())(*i++)->withdraw();
        }

        list<Ref<ApplicationScene> > launchedScenes;
      };

      struct Session::ExternalEvent
      {
        const Ref<const ValueBase> value;
        const unsigned long cookie;
        
        ExternalEvent(const ValueBase *value, unsigned long cookie):
          value(value), cookie(cookie) {}
      };

      struct Session::ExternalEventQueue: Thread
      {
        ExternalEventQueue(Ref<Session>, Time heartbeat);

        ~ExternalEventQueue()
        {
        }

        const BackRef<Session> session;
        Time heartbeat;

        Mutex mutex;
        Condition nonEmpty;
        list<ExternalEvent> eventQueue;
        bool hasTerminated;
        bool flushRequest;
        bool flushing;
        Condition flushed;

        void main();

        void addEvent(const ValueBase *, unsigned long cookie);

        void flush();
      };


      Session::Session(Ref<Listener> listener,
                       x3d::sai::Application_ptr a):
        listener(listener),
        orb(listener->getOrb()),
        application(x3d::sai::Application::_duplicate(a)),
        active(false),
        buffered(false),
        synchronizedChanges(true)
      {
      }

      Session::~Session() 
      {
      }


      void Session::refForwardDestroy()
      {
        /*
        try { listener->server->getLogger()->log(nodeMap.disp()); }
        catch(...) {}
        */

        // Stop and destroy the ExternalEventQueue object. This breaks
        // a reference loop which includes one backward reference to
        // ourself.
        externalEventQueue->terminate(); // Stop async activity
        externalEventQueue.reset();

        deactivate();
        nodeMap.clear();
        contextMap.clear();
        routeHeads.clear();

        // Withdraw application scenes from scene graph (No more
        // scenes will ever be added since at this point no further
        // access to this object can be attempted except for that
        // caused by this very call.)
        if(launchedScenes.empty()) return;
        Ref<ApplicationSceneReaper> r = new ApplicationSceneReaper();
        swap(launchedScenes, r->launchedScenes);
        Thread::start(r);
      }

      x3d::sai::Session_ptr Session::createServant(Time heartbeat)
      {
        Mutex::Lock lock(mutex);
        return activate(heartbeat);
      }

      x3d::sai::Session_ptr Session::activate(Time heartbeat)
      {
        if(active) deactivate();
        externalEventQueue = new ExternalEventQueue(this, heartbeat);
        Thread::start(externalEventQueue);
        ServantRef<Servant> servant = new Servant(this);
        servantId = orb.getPoa()->activate_object(servant.get());
        x3d::sai::Session_var ref = servant->_this();
        active = true;
        return ref._retn();
      }

      void Session::deactivate()
      {
        if(!active) return;
        orb.getPoa()->deactivate_object(servantId);
        active = false;
      }

      void Session::executeChanges()
      {
        Time time = listener->server->getNextTimeStamp();
        while(!changeQueue.empty())
        {
          try
          {
            changeQueue.front()->apply(time);
          }
          catch(NodeBase::AccessException &) {}
          catch(NodeBase::RangeException &) {}
          changeQueue.pop();
        }
      }


      unsigned long Session::node2id(Ref<NodeBase> n)
      {
        if(!n) return 0;
        long t = n->getType()->getIndex();
        // if(n>255) ARCHON_THROW1(InternalException, "Node index overflow");
        return static_cast<unsigned long>(nodeMap.get(n)) <<
          NodeType::maxIndexBits | t;
      }

      Ref<NodeBase> Session::id2node(unsigned long i)
        throw(IllegalNodeIdException)
      {
        if(!i) return 0;
        Ref<NodeBase> n = nodeMap(i >> NodeType::maxIndexBits);
        if(!n) ARCHON_THROW(Porter::IllegalNodeIdException);
        return n;
      }


      // Session (or Browser) services

      char *Session::getServerName()
      {
        string n = listener->server->getName();
        return CORBA::string_dup(n.c_str());
      }

      CORBA::Double Session::getCurrentFrameRate()
      {
        return listener->server->getFrameRate();
      }

      CORBA::ULong
      Session::createApplicationScene(const char *u,
                                      CORBA::Boolean localFileUri)
      {
        Uri baseUri(u);

        Ref<ApplicationScene> context =
          new ApplicationScene(listener->server.getRef(),
                                 baseUri, localFileUri ? this : 0);
        CORBA::ULong v = contextMap.get(context, true);
        return v;
      }

      CORBA::ULong
      Session::loadApplicationScene(const char *u,
                                    CORBA::Boolean localFileUri)
      {
        Uri uri(u);

        Ref<ApplicationScene> context =
          new ApplicationScene(listener->server.getRef(),
                                 uri, localFileUri ? this : 0);

        Ref<Loader> loader = listener->server->getLoader();
        if(loader) try
        {
          Ref<Web::Client::Response> response = loader->getWebClient()->
            request(Web::Client::Request::get(uri));
          Ref<Group> rootGroup = new Group(Ref<ExecutionContext>(context));
          XML::parse(context, rootGroup, response,
                     false, this, uri.getFile());
          context->setRootGroup(rootGroup);
        }
        catch(Web::RequestException &e)
        {
          string message = e.getMessage();
          throw x3d::sai::FileRequestException(message.c_str());
        }
        catch(ParseException &)
        {
          throw x3d::sai::InvalidX3DException();
        }

        return contextMap.get(context, true);
      }

      void Session::launchApplicationScene(CORBA::ULong ci)
      {
        Ref<ExecutionContext> c = contextMap(ci);
        if(!c) throw x3d::sai::InvalidExecutionContextException();
        ApplicationScene *applicationScene =
          dynamic_cast<ApplicationScene *>(c.get());
        if(!applicationScene)
          throw x3d::sai::InvalidExecutionContextException();

        applicationScene->launch(listener->getApplicationContainer());
        
        Mutex::Lock lock(mutex);
        launchedScenes.push_back(Ref<ApplicationScene>(applicationScene));
      }

      void Session::withdrawApplicationScene(CORBA::ULong ci)
      {
        Ref<ExecutionContext> c = contextMap(ci);
        if(!c) throw x3d::sai::InvalidExecutionContextException();
        ApplicationScene *applicationScene =
          dynamic_cast<ApplicationScene *>(c.get());
        if(!applicationScene)
          throw x3d::sai::InvalidExecutionContextException();

        {
          Mutex::Lock lock(mutex);
          list<Ref<ApplicationScene> >::iterator i =
            find(launchedScenes.begin(), launchedScenes.end(), Ref<ApplicationScene>(applicationScene));
          if(i == launchedScenes.end()) throw x3d::sai::NotLaunchedException();
          launchedScenes.erase(i);
        }

        applicationScene->withdraw();
      }

      void Session::beginUpdate()
      {
        Mutex::Lock lock(mutex);
        buffered = true;
      }

      void Session::endUpdate()
      {
        Mutex::Lock lock(mutex);
        executeChanges();
        buffered = false;
      }

      void Session::print(const char *s)
      {
        listener->server->print(s);
      }

      void Session::setSynchronizedChangesEnabled(CORBA::Boolean enabled)
      {
        Mutex::Lock lock(mutex);
        synchronizedChanges = enabled;
      }

      void Session::disposeBatch(const x3d::sai::DisposeSeq &c,
                                 const x3d::sai::DisposeSeq &n)
      {
        for(unsigned i=0; i<c.length(); ++i)
        {
          const x3d::sai::DisposeEntry &e = c[i];
          contextMap.remove(e.id, e.transCount);
        }

        for(unsigned i=0; i<n.length(); ++i)
        {
          const x3d::sai::DisposeEntry &e = n[i];
          nodeMap.remove(e.id >> NodeType::maxIndexBits, e.transCount);
        }
      }

      void Session::disposeSession()
      {
        // Deactivate CORBA servant if activated
        deactivate();

        // Destroy the only reference to this object that would have
        // remained after this service call withdraws. This must lead
        // to a destruction of this Session object.
        try { listener->removeSession(this); }
        catch(ForwardDestroyedException &) {}
      }


      // ExecutionContext services

      char *Session::getBaseUri(CORBA::ULong ci)
      {
        Ref<ExecutionContext> c = contextMap(ci);
        if(!c) throw x3d::sai::InvalidExecutionContextException();
        return CORBA::string_dup(c->getBaseUri().toString().c_str());
      }

      CORBA::ULong Session::getRootGroup(CORBA::ULong ci)
      {
        Ref<ExecutionContext> c = contextMap(ci);
        SceneBase *s = dynamic_cast<SceneBase *>(c.get());
        if(!s) throw x3d::sai::InvalidExecutionContextException();
        return node2id(s->getRootGroup());
      }

      void Session::setRootGroup(CORBA::ULong ci, CORBA::ULong ni)
      {
        Ref<ExecutionContext> c = contextMap(ci);
        SceneBase *s = dynamic_cast<SceneBase *>(c.get());
        if(!s) throw x3d::sai::InvalidExecutionContextException();
        try
        {
          Ref<NodeBase> n = id2node(ni);
          Ref<Group> g = dynamic_cast<Group *>(n.get());
          if(!g && n) throw x3d::sai::InvalidNodeException();
          s->setRootGroup(g);
        }
        catch(IllegalNodeIdException &)
        {
          throw x3d::sai::InvalidNodeException();
        }
      }

      CORBA::ULong Session::createNode(CORBA::ULong ci, const char *n)
      {
        Ref<ExecutionContext> c = contextMap(ci);
        if(!c) throw x3d::sai::InvalidExecutionContextException();
        const NodeType *t = NodeType::lookup(n);
        if(!t || !t->isUserInstantiable())
          throw x3d::sai::InvalidNameException();
        return node2id(t->instantiate(c));
      }

      CORBA::ULong Session::createNode(CORBA::ULong ci, CORBA::ULong ti)
      {
        Ref<ExecutionContext> c = contextMap(ci);
        if(!c) throw x3d::sai::InvalidExecutionContextException();
        if(ti >= NodeType::getTotalNumber())
          throw x3d::sai::InvalidTypeException();
        const NodeType *t = NodeType::get(ti);
        if(!t->isUserInstantiable())
          throw x3d::sai::InvalidTypeException();
        return node2id(t->instantiate(c));
      }

      CORBA::ULong Session::getNode(CORBA::ULong ci, const char *n)
      {
        Ref<ExecutionContext> c = contextMap(ci);
        if(!c) throw x3d::sai::InvalidExecutionContextException();
        Ref<NodeBase> node = c->lookupNode(n);
        if(!node) throw x3d::sai::InvalidNameException();
        return node2id(node);
      }

      void Session::addRoute(CORBA::ULong ci,
                             CORBA::ULong fni, CORBA::ULong ffi,
                             CORBA::ULong tni, CORBA::ULong tfi)
      {
        Ref<ExecutionContext> c = contextMap(ci);
        if(!c) throw x3d::sai::InvalidExecutionContextException();
        try
        {
          Ref<NodeBase> sourceNode = id2node(fni);
          const FieldBase *sourceField =
            FieldBase::fetch(ffi, sourceNode.get());
          Ref<NodeBase> targetNode = id2node(tni);
          const FieldBase *targetField =
            FieldBase::fetch(tfi, targetNode.get());
          if(!sourceField || !targetField)
            throw x3d::sai::InvalidFieldException();
          if(sourceNode->context != c || targetNode->context != c)
            throw x3d::sai::InvalidNodeException();

          // Field input/output capabilities
          if(!sourceField->getIsEventSource() ||
             !targetField->getIsEventTarget())
            throw x3d::sai::InvalidAccessTypeException();

          // Type conformance
          if(sourceField->getType() != targetField->getType())
            throw x3d::sai::InvalidAccessTypeException();

          // Injective node type restriction
          if(const NodeFieldBase *s =
             dynamic_cast<const NodeFieldBase *>(sourceField))
          {
            const NodeFieldBase *t =
              dynamic_cast<const NodeFieldBase *>(targetField);
            if(!s->getNodeType()->isDerivedFrom(t->getNodeType()))
              throw x3d::sai::InvalidAccessTypeException();
          }

          handleChange(new RouteChange(sourceNode, sourceField,
                                       targetNode, targetField));
        }
        catch(IllegalNodeIdException &)
        {
          throw x3d::sai::InvalidNodeException();
        }
      }

      void Session::delRoute(CORBA::ULong ci,
                             CORBA::ULong fni, CORBA::ULong ffi,
                             CORBA::ULong tni, CORBA::ULong tfi)
      {
        Ref<ExecutionContext> c = contextMap(ci);
        if(!c) throw x3d::sai::InvalidExecutionContextException();
        try
        {
          Ref<NodeBase> sourceNode = id2node(fni);
          const FieldBase *sourceField =
            FieldBase::fetch(ffi, sourceNode.get());
          Ref<NodeBase> targetNode = id2node(tni);
          const FieldBase *targetField =
            FieldBase::fetch(tfi, targetNode.get());
          if(!sourceField || !targetField)
            throw x3d::sai::InvalidFieldException();
          if(sourceNode->context != c || targetNode->context != c)
            throw x3d::sai::InvalidNodeException();

          // Field input/output capabilities
          if(!sourceField->getIsEventSource() ||
             !targetField->getIsEventTarget())
            throw x3d::sai::InvalidAccessTypeException();

          // Type conformance
          if(sourceField->getType() != targetField->getType())
            throw x3d::sai::InvalidAccessTypeException();

          // Injective node type restriction
          if(const NodeFieldBase *s =
             dynamic_cast<const NodeFieldBase *>(sourceField))
          {
            const NodeFieldBase *t =
              dynamic_cast<const NodeFieldBase *>(targetField);
            if(!s->getNodeType()->isDerivedFrom(t->getNodeType()))
              throw x3d::sai::InvalidAccessTypeException();
          }

          handleChange(new RouteChange(sourceNode, sourceField,
                                       targetNode, targetField, true));
        }
        catch(IllegalNodeIdException &)
        {
          throw x3d::sai::InvalidNodeException();
        }
      }

      CORBA::ULong Session::createGroupFromStream(CORBA::ULong ci,
                                                  x3d::sai::StreamReader_ptr r)
      {
        Ref<ExecutionContext> c = contextMap(ci);
        if(!c) throw x3d::sai::InvalidExecutionContextException();
        Ref<GroupingNode> g = new Group(c);
        try
        {
          XML::parse(c, g, new Reader(r), false, this, "<SAI parse request>");
        }
        catch(ParseException &)
        {
          throw x3d::sai::InvalidX3DException();
        }
        return node2id(g);
      }

      void Session::disposeContext(CORBA::ULong ci)
      {
        contextMap.remove(ci);
      }


      // Node services

      char *Session::getNodeType(CORBA::ULong ni)
      {
        if(!ni) throw x3d::sai::InvalidNodeException();
        try
        {
          return CORBA::string_dup(id2node(ni)->getType()->getName().c_str());
        }
        catch(IllegalNodeIdException &)
        {
          throw x3d::sai::InvalidNodeException();
        }
      }

      CORBA::ULong Session::getField(CORBA::ULong ni, const char *n)
      {
        if(!ni) throw x3d::sai::InvalidNodeException();
        try
        {
          const FieldBase *f = id2node(ni)->lookupField(n);
          if(!f) throw x3d::sai::InvalidNameException();
          return f->getId();
        }
        catch(IllegalNodeIdException &)
        {
          throw x3d::sai::InvalidNodeException();
        }
      }

      void Session::disposeNode(CORBA::ULong ni)
      {
        nodeMap.remove(ni);
      }


      // Field services

      CORBA::ULong Session::getFieldType(CORBA::ULong ni, CORBA::ULong fi)
      {
        try
        {
          Ref<NodeBase> n = id2node(ni);
          if(!n) throw x3d::sai::InvalidNodeException();
          const FieldBase *f = FieldBase::fetch(fi, n.get());
          if(!f) throw x3d::sai::InvalidFieldException();
          return f->getType()->getIndex();
        }
        catch(IllegalNodeIdException &)
        {
          throw x3d::sai::InvalidNodeException();
        }
      }

      char *Session::getFieldName(CORBA::ULong ni, CORBA::ULong fi)
      {
        try
        {
          Ref<NodeBase> n = id2node(ni);
          if(!n) throw x3d::sai::InvalidNodeException();
          const FieldBase *f = FieldBase::fetch(fi, n.get());
          if(!f) throw x3d::sai::InvalidFieldException();
          return CORBA::string_dup(f->getName().c_str());
        }
        catch(IllegalNodeIdException &)
        {
          throw x3d::sai::InvalidNodeException();
        }
      }

      CORBA::ULong Session::getFieldAccessType(CORBA::ULong ni, CORBA::ULong fi)
      {
        try
        {
          Ref<NodeBase> n = id2node(ni);
          if(!n) throw x3d::sai::InvalidNodeException();
          const FieldBase *f = FieldBase::fetch(fi, n.get());
          if(!f) throw x3d::sai::InvalidFieldException();
          return
            f->getIsEventSource() ?
            f->getIsEventTarget() ? 3 : 2 :
            f->getIsEventTarget() ? 1 : 0;
        }
        catch(IllegalNodeIdException &)
        {
          throw x3d::sai::InvalidNodeException();
        }
      }

      void Session::registerFieldInterest(CORBA::ULong ni, CORBA::ULong fi,
                                          CORBA::ULong c)
      {
        try
        {
          Ref<NodeBase> n = id2node(ni);
          if(!n) throw x3d::sai::InvalidNodeException();
          const FieldBase *f = FieldBase::fetch(fi, n.get());
          if(!f) throw x3d::sai::InvalidFieldException();

          // Field input/output capabilities
          if(!f->getIsEventSource())
            throw x3d::sai::InvalidAccessTypeException();

          ExternalRoute::add(n, f, this, c);
        }
        catch(IllegalNodeIdException &)
        {
          throw x3d::sai::InvalidNodeException();
        }
      }

      void Session::unRegisterFieldInterest(CORBA::ULong ni, CORBA::ULong fi,
                                            CORBA::ULong c)
      {
        try
        {
          Ref<NodeBase> n = id2node(ni);
          if(!n) throw x3d::sai::InvalidNodeException();
          const FieldBase *f = FieldBase::fetch(fi, n.get());
          if(!f) throw x3d::sai::InvalidFieldException();

          // Field input/output capabilities
          if(!f->getIsEventSource())
            throw x3d::sai::InvalidAccessTypeException();

          ExternalRoute::del(n, f, this, c);
          externalEventQueue->flush();
        }
        catch(IllegalNodeIdException &)
        {
          throw x3d::sai::InvalidNodeException();
        }
      }

      x3d::sai::Value *Session::getFieldValue(CORBA::ULong ni, CORBA::ULong fi)
      {
        try
        {
          Ref<NodeBase> n = id2node(ni);
          if(!n) throw x3d::sai::InvalidNodeException();
          const FieldBase *f = FieldBase::fetch(fi, n.get());
          if(!f) throw x3d::sai::InvalidFieldException();
          if(!f->getIsEventSource() && f->getIsEventTarget())
            throw x3d::sai::InvalidAccessTypeException();
          Ref<ValueBase> v = n->get(f);
          x3d::sai::Value_var w = new x3d::sai::Value();
          ex(v.get(), w.inout());
          return w._retn();
        }
        catch(IllegalNodeIdException &)
        {
          throw x3d::sai::InvalidNodeException();
        }
        catch(NodeBase::AccessException &)
        {
          throw x3d::sai::InvalidOperationTimingException();
        }
      }

      void Session::setFieldValue(CORBA::ULong ni, CORBA::ULong fi,
                                  const x3d::sai::Value &v)
      {
        try
        {
          Ref<NodeBase> n = id2node(ni);
          if(!n) throw x3d::sai::InvalidNodeException();
          const FieldBase *f = FieldBase::fetch(fi, n.get());
          if(!f) throw x3d::sai::InvalidFieldException();
          if(f->getIsEventSource() && !f->getIsEventTarget())
            throw x3d::sai::InvalidAccessTypeException();
          Ref<ValueBase> w = im(v);
          if(w->getFieldType() != f->getType())
            throw x3d::sai::InvalidValueException();

          // If the value consists of one or more nodes then verify them
          if(const NodeValue *nv = dynamic_cast<const NodeValue *>(w.get()))
          {
            if(nv->value && nv->value->context != n->context)
              throw x3d::sai::InvalidValueException();
          }
          else if(const NodeSequenceValue *nv =
                  dynamic_cast<const NodeSequenceValue *>(w.get()))
            for(NodeSequenceValue::ConstIterator i=nv->begin(); i!=nv->end(); ++i)
            {
              if(!*i || (*i)->context != n->context)
                throw x3d::sai::InvalidValueException();
            }

          handleChange(new FieldSetChange(n, f, w));
        }
        catch(TypeMismatchException &)
        {
          throw x3d::sai::InvalidValueException();
        }
        catch(IllegalNodeIdException &)
        {
          throw x3d::sai::InvalidNodeException();
        }
        catch(NodeBase::AccessException &)
        {
          throw x3d::sai::InvalidOperationTimingException();
        }
      }


      // SequenceField services

      x3d::sai::Value *Session::getFieldValueAt(CORBA::ULong ni,
                                                CORBA::ULong fi,
                                                CORBA::ULong i)
      {
        try
        {
          Ref<NodeBase> n = id2node(ni);
          if(!n) throw x3d::sai::InvalidNodeException();
          const FieldBase *f = FieldBase::fetch(fi, n.get());
          if(!f) throw x3d::sai::InvalidFieldException();
          if(!f->getIsEventSource() && f->getIsEventTarget())
            throw x3d::sai::InvalidAccessTypeException();
          const SequenceFieldBase *s =
            dynamic_cast<const SequenceFieldBase *>(f);
          if(!s) throw x3d::sai::InvalidAccessTypeException();
          Ref<ValueBase> v = n->getAt(s, i);
          x3d::sai::Value_var w = new x3d::sai::Value();
          ex(v.get(), w.inout());
          return w._retn();
        }
        catch(IllegalNodeIdException &)
        {
          throw x3d::sai::InvalidNodeException();
        }
        catch(NodeBase::AccessException &)
        {
          throw x3d::sai::InvalidOperationTimingException();
        }
        catch(NodeBase::RangeException &)
        {
          throw x3d::sai::InvalidIndexException();
        }
      }

      void Session::setFieldValueAt(CORBA::ULong ni, CORBA::ULong fi,
                                    CORBA::ULong i, const x3d::sai::Value &v)
      {
        try
        {
          Ref<NodeBase> n = id2node(ni);
          if(!n) throw x3d::sai::InvalidNodeException();
          const FieldBase *f = FieldBase::fetch(fi, n.get());
          if(!f) throw x3d::sai::InvalidFieldException();
          if(f->getIsEventSource() != f->getIsEventTarget())
            throw x3d::sai::InvalidAccessTypeException();
          const SequenceFieldBase *s =
            dynamic_cast<const SequenceFieldBase *>(f);
          if(!s) throw x3d::sai::InvalidAccessTypeException();
          Ref<ValueBase> w = im(v);
          if(w->getFieldType() != f->getType()->getSingleType())
            throw x3d::sai::InvalidValueException();

          // If the value is a node then verify it
          if(const NodeValue *nv = dynamic_cast<const NodeValue *>(w.get()))
          {
            if(!nv->value || nv->value->context != n->context)
              throw x3d::sai::InvalidValueException();
          }

          handleChange(new FieldSetAtChange(n, s, w, i));
        }
        catch(TypeMismatchException &)
        {
          throw x3d::sai::InvalidValueException();
        }
        catch(IllegalNodeIdException &)
        {
          throw x3d::sai::InvalidNodeException();
        }
        catch(NodeBase::AccessException &)
        {
          throw x3d::sai::InvalidOperationTimingException();
        }
        catch(NodeBase::RangeException &)
        {
          throw x3d::sai::InvalidIndexException();
        }
      }

      void Session::setFieldValueAdd(CORBA::ULong ni, CORBA::ULong fi,
                                     const x3d::sai::Value &v)
      {
        try
        {
          Ref<NodeBase> n = id2node(ni);
          if(!n) throw x3d::sai::InvalidNodeException();
          const FieldBase *f = FieldBase::fetch(fi, n.get());
          if(!f) throw x3d::sai::InvalidFieldException();
          if(f->getIsEventSource() != f->getIsEventTarget())
            throw x3d::sai::InvalidAccessTypeException();
          const SequenceFieldBase *s =
            dynamic_cast<const SequenceFieldBase *>(f);
          if(!s) throw x3d::sai::InvalidAccessTypeException();
          Ref<ValueBase> w = im(v);
          if(w->getFieldType() != f->getType()->getSingleType())
            throw x3d::sai::InvalidValueException();

          // If the value is a node then verify it
          if(const NodeValue *nv = dynamic_cast<const NodeValue *>(w.get()))
          {
            if(!nv->value || nv->value->context != n->context)
              throw x3d::sai::InvalidValueException();
          }

          handleChange(new FieldListChange(n, s, w));
        }
        catch(TypeMismatchException &)
        {
          throw x3d::sai::InvalidValueException();
        }
        catch(IllegalNodeIdException &)
        {
          throw x3d::sai::InvalidNodeException();
        }
        catch(NodeBase::AccessException &)
        {
          throw x3d::sai::InvalidOperationTimingException();
        }
      }

      void Session::setFieldValueDel(CORBA::ULong ni, CORBA::ULong fi,
                                     const x3d::sai::Value &v)
      {
        try
        {
          Ref<NodeBase> n = id2node(ni);
          if(!n) throw x3d::sai::InvalidNodeException();
          const FieldBase *f = FieldBase::fetch(fi, n.get());
          if(!f) throw x3d::sai::InvalidFieldException();
          if(f->getIsEventSource() != f->getIsEventTarget())
            throw x3d::sai::InvalidAccessTypeException();
          const SequenceFieldBase *s =
            dynamic_cast<const SequenceFieldBase *>(f);
          if(!s) throw x3d::sai::InvalidAccessTypeException();
          Ref<ValueBase> w = im(v);
          if(w->getFieldType() != f->getType()->getSingleType())
            throw x3d::sai::InvalidValueException();

          // If the value is a node then verify it
          if(const NodeValue *nv = dynamic_cast<const NodeValue *>(w.get()))
          {
            if(!nv->value || nv->value->context != n->context)
              throw x3d::sai::InvalidValueException();
          }

          handleChange(new FieldListChange(n, s, w, true));
        }
        catch(TypeMismatchException &)
        {
          throw x3d::sai::InvalidValueException();
        }
        catch(IllegalNodeIdException &)
        {
          throw x3d::sai::InvalidNodeException();
        }
        catch(NodeBase::AccessException &)
        {
          throw x3d::sai::InvalidOperationTimingException();
        }
      }


      void Session::handleChange(Ref<const ChangeBase> c)
      {
        Mutex::Lock lock(mutex);
        if(buffered || !synchronizedChanges)
        {
          changeQueue.push(c);
          if(!buffered) executeChanges();
          return;
        }
        Time time = listener->server->getNextTimeStamp();
        c->apply(time);
      }

      void Session::handleExternalEvent(const ValueBase *v,
                                        unsigned long cookie)
      {
        externalEventQueue->addEvent(v, cookie);
      }

      void Session::addRouteHead(Ref<const ExternalRouteHead> r)
      {
        Mutex::Lock l(routeHeadsMutex);
        routeHeads.push_back(r);
      }

      void Session::removeRouteHead(Ref<const ExternalRouteHead> r)
      {
        Mutex::Lock l(routeHeadsMutex);
        routeHeads.remove(r);
      }



      Session::ExternalEventQueue::ExternalEventQueue
      (Ref<Session> session, Time heartbeat):
        session(session), heartbeat(heartbeat), nonEmpty(mutex),
        hasTerminated(false), flushRequest(false), flushing(false),
        flushed(mutex)
      {
      }
        
      void Session::ExternalEventQueue::main()
      {
        for(;;)
        {
          list<ExternalEvent> q;

          try
          {
            Mutex::Lock l(mutex);
            flushing = false;
            if(!flushRequest)
            {
              l.release();
              flushed.notifyAll();
              l.aquire(mutex);
            }
            while(eventQueue.empty())
              if(nonEmpty.timedWait(Time::now()+heartbeat)) break;
            std::swap(q, eventQueue);
            flushing = flushRequest;
            flushRequest = false;
          }
          catch(ThreadTerminatedException &) { break; }

          try { session->pushEvents(&q); }
          catch(ForwardDestroyedException &) { break; }
        }

        {
          Mutex::Lock l(mutex);
          hasTerminated = true;
          flushRequest = flushing = false;
        }
        flushed.notifyAll();
      }

      void Session::ExternalEventQueue::addEvent(const ValueBase *v,
                                                 unsigned long cookie)
      {
        Mutex::Lock l(mutex);
        if(hasTerminated) return;
        eventQueue.push_back(ExternalEvent(v, cookie));
        nonEmpty.notifyAll();
      }

      void Session::ExternalEventQueue::flush()
      {
        Mutex::Lock l(mutex);
        if(hasTerminated) return;
        flushRequest = true;
        while(flushRequest || flushing) flushed.wait();
      }


      void Session::pushEvents(const list<ExternalEvent> *q)
      {
        unsigned long n = q->size();
        x3d::sai::EventSeq s(n);
        s.length(n);
        unsigned j = 0;
        list<ExternalEvent>::const_iterator i = q->begin();
        while(i != q->end())
        {
          x3d::sai::Event &e = s[j++];
          e.cookie = i->cookie;
          ex(i->value.get(), e.val);
          ++i;
        }
        try { application->handleEvent(s); }
        catch(...)
        {
          disposeSession();
          return;
        }
      }


      Ref<Stream::Reader> Session::request(string p)
        throw(AbstractFileServer::RequestException)
      {
        x3d::sai::StreamReader_var r;
        try { r = application->requestFile(p.c_str()); }
        catch(x3d::sai::FileRequestException &e)
        {
          ARCHON_THROW1(AbstractFileServer::RequestException, string(e.message));
        }
        catch(...)
        {
          ARCHON_THROW1(AbstractFileServer::RequestException,
                        "Caught unknown exception");
        }
        if(CORBA::is_nil(r))
          ARCHON_THROW1(AbstractFileServer::RequestException,
                        "Got nil reader");
        return new Reader(r);
      }

      void Session::log(string s) throw()
      {
        try { application->log(s.c_str()); }
        catch(...) {}
      }
    }
  }
}

---