route.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/x3d/server/scene.H>

#include <archon/x3d/sai/route.H>

namespace Archon
{
  namespace X3D
  {
    namespace SAI
    {
      using namespace Utilities;
  
      void ExternalRoute::cascadeEvent(const Event *e) const
      {
        try { session->handleExternalEvent(e->value.get(), cookie); }
        catch(ForwardDestroyedException &) {}
      }

      void ExternalRoute::add(Ref<NodeBase> sourceNode, const FieldBase *sourceField,
                              Ref<Session> session, unsigned long cookie)
        throw(AccessException)
      {
        // Field input/output capabilities
        if(!sourceField->getIsEventSource()) ARCHON_THROW(AccessException);

        ExternalRoute *r =
          new ExternalRoute(sourceNode, sourceField, session, cookie);
        Ref<RouteTail> t(dynamic_cast<RouteTail *>(r));
        Ref<ExternalRouteHead> h(dynamic_cast<ExternalRouteHead *>(r));
        if(sourceField->addRoute(sourceNode.get(), t.get()))
          session->addRouteHead(h);
      }

      bool ExternalRoute::del(Ref<NodeBase> sourceNode, const FieldBase *sourceField,
                              Ref<Session> session, unsigned long cookie)
      {
        ExternalRoute r(sourceNode, sourceField, session, cookie);
        return sourceField->delRouteMatch(sourceNode.get(), &r);
      }

      void ExternalRoute::refDispose(Mutex::Lock &l)
      {
        if(getTailCountNoLock() == 0)
        {
          if(getHeadCountNoLock() == 0)
          {
            l.release();
            delete this;
            return;
          }
          Ref<ExternalRouteHead> h(this, RefNoLockTag());
          l.release();
          try
          {
            session->removeRouteHead(h);
          }
          catch(ForwardDestroyedException &) {}
          return;
        }
        Ref<RouteTail> t(this, RefNoLockTag());
        l.release();
        try
        {
          Ref<NodeBase> n = sourceNode.getRef();
          sourceField->delRoute(n.get(), t.get());
        }
        catch(ForwardDestroyedException &) {}
      }

      ExternalRoute::~ExternalRoute()
      {
      }

      ExternalRoute::ExternalRoute(Ref<NodeBase> sourceNode, const FieldBase *sourceField,
                                   Ref<Session> session, unsigned long cookie):
        RouteTail(sourceNode, sourceField),
        ExternalRouteHead(session, cookie)
      {
      }

      bool ExternalRoute::match(const RouteTail *r) const
      {
        const ExternalRoute *s = dynamic_cast<const ExternalRoute *>(r);
        return s && s->session == session &&
          s->cookie == cookie;
      }
    }
  }
}

---