load.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_LOAD_H
#define ARCHON_X3D_LOAD_H

#include <string>

#include <archon/util/logger.H>
#include <archon/util/web_client.H>
#include <archon/util/job.H>
#include <archon/util/image.H>

#include <archon/x3d/server/core.H>
#include <archon/x3d/server/group.H>

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

    struct Server; // defined in "server.H"
    struct Scene;  // defined in "scene.H"

    struct Loader: virtual RefObjectBase
    {
      enum UriType
      {
        uriType_X3D,
        uriType_Image,
        uriType_Movie,
        uriType_Script
      };

      struct Contents: virtual RefObjectBase
      {
        struct Id
        {
          Id(): id(0) {}

          static Id next()
          {
            static unsigned long counter = 0;
            return Id(++counter);
          }

          operator bool() { return id; }
          bool operator<(const Id &i) const { return id<i.id; }

        private:
          Id(unsigned long id): id(id) {}       
          unsigned long id;
        };

        Contents(): id(Id::next()) {}

        Id getId() const { return id; }

      private:
        Id id;
      };

      struct X3DContents: Contents
      {
        Ref<Scene> rootScene;
        X3DContents(Ref<Scene> rootScene): rootScene(rootScene) {}
      };

      struct ImageContents: Contents
      {
        Image image;
      };

      struct MovieContents: Contents
      {
      };

      struct ScriptContents: Contents
      {
        string language;
        string sourceCode;
        string sourceName; // File name
        int sourceLine;    // line number in file name or -1 if unknown
        ScriptContents(string language, string sourceCode,
                       string sourceName, int sourceLine):
          language(language), sourceCode(sourceCode),
          sourceName(sourceName), sourceLine(sourceLine) {}
      };

      struct Job: Utilities::Job
      {
        Job(Ref<Loader>, Uri baseUri,
            const vector<string> &uriList, UriType uriType,
            Ref<AbstractFileServer> fileServer=0);

        virtual ~Job();

        bool isCompleted() { return completed; }

        void wait();

        void kill();

        Ref<const Contents> getContents();

      protected:
        virtual void onCompletion() {}

      private:
        friend struct Loader;

        Ref<const Contents> loadX3D(Ref<Stream::Reader>, string contentType,
                                    Uri sourceUri, int sourceLine, Logger *);
        Ref<const Contents> loadImage(Ref<Stream::Reader>, string contentType,
                                      Uri sourceUri, Logger *);
        Ref<const Contents> loadMovie(Ref<Stream::Reader>, string contentType,
                                      Uri sourceUri, Logger *);
        Ref<const Contents> loadScript(Ref<Stream::Reader>, string contentType,
                                       Uri sourceUri, int sourceLine, Logger *);
        Ref<const Contents> load(Ref<Stream::Reader>, string contentType,
                                 Uri sourceUri, int sourceLine, Logger *);
        void main();

        Ref<Loader> loader;
        Ref<Web::Client> webClient;
        Uri baseUri;
        vector<string> uriList;
        UriType uriType;
        Ref<const Contents> contents;
        bool completed;
        Ref<AbstractFileServer> fileServer;
      };

      ~Loader();

      Loader(Ref<Server>, Ref<Web::Client>);

      void submitJob(Ref<Job>);

      const BackRef<Server> server;

      Ref<Web::Client> getWebClient() const { return webClient; }

    private:
      Logger *logger;
      Ref<Web::Client> webClient;
      Utilities::Job::Queue jobQueue;

      map<string, Ref<const Contents> > cache; // URIs are the keys

      Mutex mutex;
      Condition cacheChange;
      Condition jobCompletion;
    };
  }
}

#endif // ARCHON_X3D_LOAD_H

---