session.H

/*
 * 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_PROXY_SESSION_H
#define ARCHON_X3D_PROXY_SESSION_H

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

#include <archon/x3d/proxy/config.autogen.H>
#include <archon/x3d/proxy/exception.H>
#include <archon/x3d/proxy/orb.H>
#include <archon/x3d/proxy/disposer.H>
#include <archon/x3d/proxy/type.H>
#include <archon/x3d/proxy/value.H>

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

      struct Application;
      struct ExecutionContext;
      struct NodeBase;
      struct EventHandlerBase;

      struct Session: virtual BackRefObjectBase, private Porter
      {
        struct ConnectionException: Exception
        {
          ConnectionException(string l, string m): Exception(l, m) {}
        };

        static Ref<Session> create(string serverName,
                                   int corbaEndpointPort = -1,
                                   Logger * = Logger::get())
          throw(ConnectionException);

        void beginUpdate();
        void endUpdate();

        struct SupportException: UnexpectedException
        {
          SupportException(string l, string m): UnexpectedException(l, m) {}
        };

        struct ProtocolException: UnexpectedException
        {
          ProtocolException(string l, string m): UnexpectedException(l, m) {}
        };

      private:
        Session(string serverName, int corbaEndpointPort, Logger *)
          throw(ConnectionException);

        void refForwardDestroy();

        Logger *logger;

        x3d::sai::Server_var server;
        x3d::sai::Session_var session;


        template<typename F> friend struct EventHandler;

        friend struct ExecutionContext;
        void destroyContext(ExecutionContext *);

        Mutex contextMapMutex;
        vector<ExecutionContext *> contextMap;
        Ref<ExecutionContext> id2context(unsigned long, bool isApplication);
        unsigned long context2id(Ref<ExecutionContext>);


        friend struct NodeBase;
        Ref<NodeBase> createNode(ExecutionContext *, unsigned long nodeTypeIndex);
        void destroyNode(NodeBase *);

        Mutex nodeMapMutex;
        vector<NodeBase *> nodeMap;
        Ref<NodeBase> id2node(unsigned long) throw(IllegalNodeIdException);
        unsigned long node2id(Ref<NodeBase>);

        void registerFieldInterest(unsigned long ni, unsigned long fi,
                                   EventHandlerBase *, bool destroy);

        friend struct Application;
        Ref<Application> createApplication(const Uri &baseUri);
        Ref<Application> loadApplication(const Uri &uri);


        NodeLink nodeLinks[numberOfNodeTypes];
        Array<unsigned long> nodeTypeMap;

        unsigned long nodeTypeIdBits;
        unsigned long nodeTypeIdMask;
        unsigned long nodeTypeIdRoof; // 1 + the largets node type ID
                                      // received from the server
                                      // during config.

        Mutex eventHandlersMutex;
        vector<Ref<EventHandlerBase> > eventHandlers;

        Orb orb;

        bool active;
        void activate();

        struct Servant;
        PortableServer::ObjectId_var servantId;

        // Application services
        void handleEvent(const x3d::sai::EventSeq &);
        x3d::sai::StreamReader_ptr requestFile(const char *);
        void log(const char *);

        x3d::sai::Server_ptr getServerReference(string name)
          throw(ConnectionException);

        struct StreamReaderServant;

        Ref<Disposer> disposer;
      };
    }
  }
}

#endif // ARCHON_X3D_PROXY_SESSION_H

---