context.H

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).
 */

#ifndef ARCHON_X3D_CONTEXT_H
#define ARCHON_X3D_CONTEXT_H

#include <vector>
#include <string>

#include <archon/util/ref.H>
#include <archon/util/stream.H>
#include <archon/util/uri.H>

#include <archon/x3d/server/exception.H>
#include <archon/x3d/server/node.H>

namespace Archon
{
  namespace X3D
  {
    using namespace std;
    using namespace Utilities;

    struct Server; // "server.H"

    struct FrameDrivenNode: virtual NodeBase
    {
      virtual void tick() = 0;

      ~FrameDrivenNode();

      void onRealized();
    };

    struct AbstractFileServer: virtual BackRefObjectBase
    {
      struct RequestException: Exception
      {
        RequestException(string l, string m): Exception(l, m) {}
      };

      virtual Ref<Stream::Reader> request(string path)
        throw(RequestException) = 0;

      string getFileServerId()
      {
        return id;
      }

      AbstractFileServer(): id(getNextId()) {}

    private:
      string id;

      static string getNextId();
    };

    struct ExecutionContext: virtual BackRefObjectBase
    {
      virtual ~ExecutionContext();

      struct RealizedException: Exception
      {
        RealizedException(string l): Exception(l) {}
      };

      void realize();

      bool isRealized() const;

      Uri getBaseUri() const;

      Ref<NodeBase> lookupNode(string name) const;

      void tick();

      const BackRef<Server> server;

      const BackRef<AbstractFileServer> fileServer;

    protected:
      ExecutionContext(Ref<Server>, Uri baseUri,
                       Ref<AbstractFileServer> fileServer=0);

      const Mutex contextMutex;

      bool isRealizedNoLock() const { return realized; }

    private:
      Uri baseUri;
      bool realized;

      friend struct Route;
      Mutex routesMutex;
      list<Route *> routes;
      void add(Route *);
      void remove(Route *);

      friend struct NodeBase;
      Mutex namedNodesMutex;
      map<string, NodeBase *> namedNodes;
      void changeNodeName(NodeBase *, string oldName, string newName)
        throw(NodeNameInUseException);

      friend struct FrameDrivenNode;
      Mutex frameDrivenNodesMutex;
      list<FrameDrivenNode *> frameDrivenNodes;
      void addFrameDrivenNode(FrameDrivenNode *);
      void removeFrameDrivenNode(FrameDrivenNode *);
    };
  }
}

#endif // ARCHON_X3D_CONTEXT_H

---