mootZIO.h

Go to the documentation of this file.

/* -*- Mode: C++ -*- */

/*
   libmoot : moocow's part-of-speech tagging library
   Copyright (C) 2004-2010 by Bryan Jurish <moocow@cpan.org>

   This library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Lesser General Public
   License as published by the Free Software Foundation; either
   version 3 of the License, or (at your option) any later version.
   
   This library is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   Lesser General Public License for more details.
   
   You should have received a copy of the GNU Lesser General Public
   License along with this library; if not, write to the Free Software
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/

/*--------------------------------------------------------------------------
 * File: mootZIO.h
 * Author: Bryan Jurish <moocow@cpan.org>
 * Description:
 *   + moot PoS tagger : low-level I/O abstractions for libz gzFile
 *--------------------------------------------------------------------------*/

#ifndef _MOOT_ZIO_H
#define _MOOT_ZIO_H

#include <mootIO.h>

#ifdef MOOT_ZLIB_ENABLED

#include <zlib.h>
#define MOOT_DEFAULT_COMPRESSION Z_DEFAULT_COMPRESSION

namespace mootio {

  /*====================================================================
   * mzstream : gzFile* i/o
   *====================================================================*/
  class mzstream
    : virtual public mistream,
      virtual public mostream
  {
  public:
    gzFile zfile;  
  public:
    /*----------------------------------------------------------
     * mzstream: constructors
     */


    mzstream(gzFile zf=NULL) : zfile(zf) {};

    ~mzstream(void) {};

    /*----------------------------------------------------------
     * mcstream: integrity
     */


    virtual bool valid(void) {
      if (!zfile) return false;
      int errnum;
      gzerror(zfile,&errnum);
      return errnum == Z_OK;
    };

    virtual bool eof(void) { return !zfile || gzeof(zfile); };

    virtual std::string errmsg(void) {
      int errnum = Z_ERRNO;
      const char *zerrmsg = zfile ? gzerror(zfile,&errnum) : "NULL gzFile";
      return std::string(errnum == Z_OK
                         ? ""
                         : (zerrmsg != NULL ? zerrmsg : "unspecified zlib error"));
    };

    /*----------------------------------------------------------
     * mcstream: open/close
     */


    virtual bool reopen(void) { return true; };

    virtual bool close(void) { zfile=NULL; return true; };

    /*----------------------------------------------------------
     * mcstream: input
     */


    virtual ByteCount read(char *buf, size_t n) {
      return zfile ? gzread(zfile, buf, n) : 0;
    };

    virtual int getbyte(void) {
      int c = zfile ? gzgetc(zfile) : -1;
      return c==-1 ? EOF : c;
    };

    /*----------------------------------------------------------
     * mzstream: output
     */


    virtual bool flush(void) {
      return zfile && gzflush(zfile, Z_SYNC_FLUSH) == Z_OK;
    };

    virtual bool write(const char *buf, size_t n) {
      return zfile ? (gzwrite(zfile,buf,n) == static_cast<int>(n)) : false;
    };

    virtual bool putbyte(unsigned char c) {
      return zfile ? (gzputc(zfile,c) != -1) : false;
    };

    virtual bool puts(const char *s) {
      return zfile ? (gzputs(zfile,s) >= 0) : false;
    };
    virtual bool puts(const std::string &s) {
      return (zfile     
              ? (gzwrite(zfile,s.data(),s.size()) == static_cast<int>(s.size()))
              : false);
    };

    /*
    virtual bool vprintf(const char *fmt, va_list &ap) {
      return zfile ? (vfprintf(file,fmt,ap) >= 0) : false;
    };
    */
  };


  /*====================================================================
   * mzfstream : named file i/o
   *====================================================================*/
  class mzfstream : virtual public mzstream {
  public:
    std::string mode;          
    std::string default_mode;  
  public:
    /*------------------------------------------------------------------
     * mfstream: Constructors
     */


    mzfstream(void)
      : mode("rb"),
        default_mode("rb")
    {};

    mzfstream(const char *filename,
              const char *open_mode=NULL)
      : default_mode("rb")
    {
      open(filename,open_mode);
    };

    virtual ~mzfstream(void) { close(); };

    /*------------------------------------------------------------------
     * mzfstream: open()
     */


    inline bool open(const char *filename, const char *open_mode=NULL) {
      name = filename;
      if (open_mode) mode = open_mode;
      return reopen();
    };
    inline bool open(const std::string &filename, const std::string &open_mode="") {
      mode = open_mode;
      name = filename;
      return reopen();
    };

    virtual bool reopen(void) {
      close();
      if (mode.empty()) mode = default_mode;
      //-- check for standard stream aliases
      if (name == "-") {
        if (mode.find('w') != mode.npos) zfile = gzdopen(fileno(stdout), mode.c_str());
        else zfile = gzdopen(fileno(stdin), mode.c_str());
      } else {
        zfile = gzopen(name.c_str(), mode.c_str());
      }
      return valid();
    };

    virtual bool close(void) {
      if (!zfile) return true;
      bool rc = gzclose(zfile) == Z_OK;
      zfile = NULL;
      return rc;
    };

    /*------------------------------------------------------------------
     * mzfstream: Utilties
     */


    inline void setparams(int level=Z_DEFAULT_COMPRESSION,
                          int strategy=Z_DEFAULT_STRATEGY)
    {
      if (level != Z_DEFAULT_COMPRESSION
          && (level > Z_BEST_COMPRESSION || level < Z_NO_COMPRESSION))
        {
          level = Z_DEFAULT_COMPRESSION;
        }
      if (zfile) gzsetparams(zfile, level, strategy);
    };

  }; //-- /mzfstream

  /*====================================================================
   * mizfstream : named file input
   *====================================================================*/
  class mizfstream : virtual public mzfstream {
  public:
    /*------------------------------------------------------------------
     * mfstream: Constructors
     */


    mizfstream(void) {
      default_mode = "rb";
    };

    mizfstream(const char *filename, const char *mode=NULL) 
    {
      default_mode = "rb";
      open(filename,mode);
    };

    mizfstream(const std::string &filename, const std::string &mode="") 
    {
      default_mode = "rb";
      open(filename,mode);
    };

    virtual ~mizfstream(void) { close(); };
  }; //-- /mizfstream

  /*====================================================================
   * mozfstream : named file output
   *====================================================================*/
  class mozfstream : virtual public mzfstream {
  public:
    /*------------------------------------------------------------------
     * mozfstream: Constructors
     */


    mozfstream(void) {
      default_mode = "wb";
    };

    mozfstream(const char *filename, const char *mode=NULL)  {
      default_mode = "wb";
      open(filename,mode);
    };

    mozfstream(const std::string &filename, const std::string &mode="") {
      default_mode = "wb";
      open(filename,mode);
    };

    virtual ~mozfstream(void) { close(); };
  }; //-- /mofstream

}; //-- /namespace mootio

#else  // _MOOT_ZLIB_ENABLED

#include <mootCIO.h>

#define MOOT_DEFAULT_COMPRESSION -1

namespace mootio {

  typedef mcstream   mzstream;
  typedef mfstream   mzfstream;
  typedef mifstream  mizfstream;
  typedef mofstream  mozfstream;

}; //-- /namespace mootio

#endif // _MOOT_ZLIB_ENABLED

namespace mootio {

  /*====================================================================
   * mootio : common typedef aliases
   *====================================================================*/
  typedef mzstream mizstream; 
  typedef mzstream mozstream; 

}; //-- /namespace mootio

#endif //_MOOT_ZIO_H