stream.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_UTILITIES_STREAM_H
#define ARCHON_UTILITIES_STREAM_H

#include <stdio.h>

#include <string>

#include <archon/util/memory.H>
#include <archon/util/text.H>
#include <archon/util/unicode.H>
#include <archon/util/thread.H>

namespace Archon
{
  namespace Utilities
  {
    namespace Stream
    {
      using namespace std;

      struct ReadException: IOException
      {
        ReadException(string l, string m): IOException(l, m) {}
      };

      struct WriteException: IOException
      {
        WriteException(string l, string m): IOException(l, m) {}
      };

      struct FileOpenException: IOException
      {
        FileOpenException(string l, string m): IOException(l, m) {}
      };


      template<class C>
      struct ReaderBase: RefObjectBase
      {
        typedef C CharType;

        virtual int read(C *buffer, int size)
          throw(ReadException, UnexpectedException) = 0;

        int readAll(C *buffer, int size)
          throw(ReadException, UnexpectedException)
        {
          int n = 0;
          while(n < size)
          {
            const int m = read(buffer + n, size - n);
            if(!m) break;
            n += m;
          }
          return n;
        }

        unsigned long getReadCount() const
        {
          return getUseCount();
        }

      protected:
        unsigned long getReadCountNoLock() const
        {
          return getUseCountNoLock();
        }
      };


      template<class C>
      struct WriterBase: RefObjectBase
      {
        typedef C CharType;

        virtual int write(const C *buffer, int size)
          throw(WriteException, UnexpectedException) = 0;

        void writeAll(const C *buffer, int size)
          throw(WriteException, UnexpectedException)
        {
          int n = 0;
          while(n < size) n += write(buffer + n, size - n);
        }

        void writeAll(string s)
        {
          writeAll(s.c_str(), s.size());
        }

        unsigned long getWriteCount() const
        {
          return getUseCount();
        }

      protected:
        unsigned long getWriteCountNoLock() const
        {
          return getUseCountNoLock();
        }
      };


      template<typename C>
      struct BasicRewindReader: ReaderBase<C>
      {
        static Ref<BasicRewindReader> get(Ref<ReaderBase<C> > r)
        {
          return new BasicRewindReader(r);
        }

        int read(C *buffer, int size)
          throw(ReadException, UnexpectedException);

        void rewind() { bufferStart = 0; }

        void release() { released = true; }

      private:
        BasicRewindReader(Ref<ReaderBase<C> > r):
          reader(r), bufferStart(0), released(false) {}

        Ref<ReaderBase<C> > reader;
        basic_string<C> buffer;
        unsigned bufferStart;
        bool released;
      };


      /*
       * Shorthand names
       */
      typedef ReaderBase<char> Reader;
      typedef WriterBase<char> Writer;
      typedef ReaderBase<uchar> UReader; // Unicode
      typedef WriterBase<uchar> UWriter; // Unicode
      typedef BasicRewindReader<char> RewindReader;

      Ref<Reader> makeStringReader(string);

      Ref<Reader> makeFileReader(int fildes);

      Ref<Reader> makeFileReader(string fileName)
        throw(FileOpenException);

      Ref<Writer> makeFileWriter(int fildes);

      Ref<Writer> makeFileWriter(string fileName)
        throw(FileOpenException);

      Ref<UReader> makeUtf8StreamReader(Ref<Reader>);

      Ref<UReader> makeUtf8FileReader(int fildes);

      Ref<UReader> makeUtf8FileReader(string fileName)
        throw(FileOpenException);

      string readIntoString(Ref<Reader>)
        throw(ReadException, UnexpectedException);

      template<typename C>
      struct Connector: Thread
      {
        Connector(Ref<ReaderBase<C> > r,
                  Ref<WriterBase<C> > w,
                  int bufferSize = 4096):
          r(r), w(w), buffer(bufferSize), bufferSize(bufferSize) {}

        void main()
        {
          for(;;)
          {
            const int n = r->read(buffer.get(), bufferSize);
            if(!n) break;
            w->write(buffer.get(), n);
          }

          r.reset();
          w.reset();
        }

      private:
        Ref<ReaderBase<C> > r;
        Ref<WriterBase<C> > w;
        Array<C> buffer;
        int bufferSize;
      };



      /*
       * Template implementations
       */

      template<typename C>
      int BasicRewindReader<C>::read(C *b, int size)
        throw(ReadException, UnexpectedException)
      {
        if(bufferStart == buffer.size())
        {
          int n = reader->read(b, size);
          if(!released) buffer.append(b, n);
          return n;
        }

        int left = buffer.size() - bufferStart;
        if(size < left)
        {
          buffer.copy(b, size, bufferStart);
          bufferStart += size;
          return size;
        }

        buffer.copy(b, left, bufferStart);
        if(released)
        {
          buffer.erase();
          bufferStart = 0;
        }
        else bufferStart += left;
        return left;
      }
    }
  }
}

#endif // ARCHON_UTILITIES_STREAM_H

---