context.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/context.H>
#include <archon/x3d/server/server.H>

namespace Archon
{
  namespace X3D
  {
    FrameDrivenNode::~FrameDrivenNode()
    {
      if(!isRealized()) return;
      try{ context->removeFrameDrivenNode(this); }
      catch(ForwardDestroyedException &) {}
    }

    void FrameDrivenNode::onRealized()
    {
      context->addFrameDrivenNode(this);
    }

    string AbstractFileServer::getNextId()
    {
      static Mutex m;
      static unsigned long n = 0;
      unsigned long v;
      {
        Mutex::Lock l(m);
        v = n++;
      }
      string s;
      for(unsigned i=0; i<8; ++i)
      {
        int d = int(v % 36ul);
        s = (d < 10 ? char('0'+d) : char('A'+(d-10))) + s;
        v /= 36ul;
      }
      return s;
    }

    ExecutionContext::ExecutionContext(Ref<Server> server, Uri baseUri,
                                       Ref<AbstractFileServer> fileServer):
      server(server), fileServer(fileServer),
      baseUri(baseUri), realized(false)
    {
    }
    
    ExecutionContext::~ExecutionContext()
    {
      if(!isRealized()) return;
      try { server->remove(this); }
      catch(ForwardDestroyedException &) {}
    }

    void ExecutionContext::realize()
    {
      Mutex::Lock l(contextMutex);
      if(realized) return;
      realized = true;
      server->add(this);
    }

    bool ExecutionContext::isRealized() const
    {
      Mutex::Lock l(contextMutex);
      return realized;
    }

    Uri ExecutionContext::getBaseUri() const
    {
      Mutex::Lock l(contextMutex);
      return baseUri;
    }

    Ref<NodeBase> ExecutionContext::lookupNode(string name) const
    {
      Mutex::Lock l(namedNodesMutex);
      map<string, NodeBase *>::const_iterator i=namedNodes.find(name);
      if(i==namedNodes.end()) return 0;
      return Ref<NodeBase>(i->second, RefSafeIncTag());
    }

    void ExecutionContext::add(Route *r)
    {
      Mutex::Lock l(routesMutex);
      routes.push_back(r);
    }

    void ExecutionContext::remove(Route *r)
    {
      Mutex::Lock l(routesMutex);
      routes.remove(r);
    }

    void ExecutionContext::changeNodeName(NodeBase *n, string oldName, string newName)
      throw(NodeNameInUseException)
    {
      if(newName == oldName) return;
      Mutex::Lock l(namedNodesMutex);
      if(!newName.empty())
      {
        pair<string, NodeBase *> p(newName, n);
        if(!namedNodes.insert(p).second) ARCHON_THROW(NodeNameInUseException);
      }
      if(!oldName.empty()) namedNodes.erase(oldName);
    }

    void ExecutionContext::addFrameDrivenNode(FrameDrivenNode *n)
    {
      Mutex::Lock l(frameDrivenNodesMutex);
      frameDrivenNodes.push_back(n);
    }

    void ExecutionContext::removeFrameDrivenNode(FrameDrivenNode *n)
    {
      Mutex::Lock l(frameDrivenNodesMutex);
      frameDrivenNodes.remove(n);
    }

    void ExecutionContext::tick()
    {
      list<Ref<FrameDrivenNode> > t;
      {
        Mutex::Lock l(frameDrivenNodesMutex);
        list<FrameDrivenNode *>::iterator i = frameDrivenNodes.begin();
        while(i != frameDrivenNodes.end())
        {
          Ref<FrameDrivenNode> r(*i, RefSafeIncTag());
          if(r) t.push_back(r);
          ++i;
        }
      }
      {
        list<Ref<FrameDrivenNode> >::iterator i = t.begin();
        while(i != t.end())
        {
          (*i)->tick();
          ++i;
        }
      }
    }
  }
}

---