stream.C

/*
 * 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 <errno.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>

#include <archon/util/stream.H>

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

      struct StringReader: ReaderBase<char>
      {
        string s;
        int pos;

        int read(char *buffer, int size)
          throw(ReadException, UnexpectedException)
        {
          Mutex::Lock l(*this);
          int n = min(unsigned(size), s.size()-pos);
          s.copy(buffer, n, pos);
          pos += n;
          return n;
        }

        StringReader(string s): s(s), pos(0) {}
      };

      struct FileReader: ReaderBase<char>
      {
        int fildes;

        int read(char *buffer, int size)
          throw(ReadException, UnexpectedException)
        {
          int n = static_cast<int>(::read(fildes, buffer, size));
          if(n < 0) ARCHON_THROW1(ReadException, strerror(errno));
          return n;
        }

        FileReader(int fildes): fildes(fildes) {}

        virtual ~FileReader()
        {{ // The extra scope is needed to work around gcc3.2 bug #8287
          ::close(fildes);
        }}
      };

      struct FileWriter: WriterBase<char>
      {
        int fildes;

        int write(const char *buffer, int size)
          throw(WriteException, UnexpectedException)
        {
          int n = static_cast<int>(::write(fildes, buffer, size));
          if(n < 0) ARCHON_THROW1(WriteException, strerror(errno));
          return n;
        }

        FileWriter(int fildes): fildes(fildes) {}

        virtual ~FileWriter()
        {{ // The extra scope is needed to work around gcc3.2 bug #8287
          ::close(fildes);
        }}
      };

      struct Utf8StreamReader: ReaderBase<uchar>
      {
        Ref<Reader> subReader;
        static const int utf8BufferSize = 1024;
        char utf8Buffer[utf8BufferSize];
        int utf8BufferOffset;

        int read(uchar *buffer, int size)
          throw(ReadException, UnexpectedException)
        {
          Mutex::Lock l(*this);
          const int n = subReader->read(utf8Buffer+utf8BufferOffset,
                                        utf8BufferSize-utf8BufferOffset);

          const int m = Unicode::decodeUtf8(utf8Buffer, utf8BufferOffset+n,
                                            buffer, size);

          if(m) copy(utf8Buffer+m, utf8Buffer+utf8BufferOffset+n, utf8Buffer);
          utf8BufferOffset += n-m;

          return size;
        }

        Utf8StreamReader(Ref<Reader> subReader):
          subReader(subReader), utf8BufferOffset(0) {}
      };

      struct Utf8FileReader: ReaderBase<uchar>
      {
        int fildes;
        static const int utf8BufferSize = 1024;
        char utf8Buffer[utf8BufferSize];
        int utf8BufferOffset;

        int read(uchar *buffer, int size)
          throw(ReadException, UnexpectedException)
        {
          Mutex::Lock l(*this);
          const int n = static_cast<int>(::read(fildes, utf8Buffer+utf8BufferOffset,
                                    utf8BufferSize-utf8BufferOffset));

          if(n < 0) ARCHON_THROW1(ReadException, strerror(errno));

          const int m = Unicode::decodeUtf8(utf8Buffer, utf8BufferOffset+n,
                                            buffer, size);

          if(m) copy(utf8Buffer+m, utf8Buffer+utf8BufferOffset+n, utf8Buffer);
          utf8BufferOffset += n-m;

          return size;
        }

        Utf8FileReader(int fildes):
          fildes(fildes), utf8BufferOffset(0) {}
        virtual ~Utf8FileReader()
        {{
          ::close(fildes);
        }}
      };


      Ref<Reader> makeStringReader(string s)
      {
        return new StringReader(s);
      }


      Ref<Reader> makeFileReader(string fileName) throw(FileOpenException)
      {
        const int fildes = open(fileName.c_str(), O_RDONLY);
        if(fildes<0)
          ARCHON_THROW1(FileOpenException,
                        "Could not open \"" + fileName + "\" for reding: " +
                        strerror(errno));
        return new FileReader(fildes);
      }

      Ref<Reader> makeFileReader(int fildes)
      {
        return new FileReader(fildes);
      }


      Ref<Writer> makeFileWriter(string fileName) throw(FileOpenException)
      {
        const int fildes =
          creat(fileName.c_str(),
                S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP|S_IROTH|S_IWOTH);
        if(fildes<0)
          ARCHON_THROW1(FileOpenException,
                        "Could not open \"" + fileName + "\" for writing: " +
                        strerror(errno));
        return new FileWriter(fildes);
      }

      Ref<Writer> makeFileWriter(int fildes)
      {
        return new FileWriter(fildes);
      }


      Ref<UReader> makeUtf8StreamReader(Ref<Reader> r)
      {
        return new Utf8StreamReader(r);
      }

      Ref<UReader> makeUtf8FileReader(string fileName)
        throw(FileOpenException)
      {
        const int fildes = open(fileName.c_str(), O_RDONLY);
        if(fildes<0)
          ARCHON_THROW1(FileOpenException,
                        "Could not open \"" + fileName + "\" for reading: " +
                        strerror(errno));
        return new Utf8FileReader(fildes);
      }

      Ref<UReader> makeUtf8FileReader(int fildes)
      {
        return new Utf8FileReader(fildes);
      }

      string readIntoString(Ref<Reader> r)
        throw(ReadException, UnexpectedException)
      {
        string s;
        char b[4096];
        for(;;)
        {
          int n = r->read(b, 4096);
          if(!n) break;
          s.append(b, n);
        }
        return s;
      }
    }
  }
}

---