mootCIO.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: mootCIO.h
 * Author: Bryan Jurish <moocow@cpan.org>
 * Description:
 *   + moot PoS tagger : low-level I/O abstractions for C FILE *s
 *   + these are ugly, but there appears to be no better
 *     (read "faster in the general case") way to get
 *     C FILE*s to jive with C++ streams, and I REALLY
 *     like printf() and friends...
 *--------------------------------------------------------------------------*/

#ifndef _MOOT_CIO_H
#define _MOOT_CIO_H

#include <mootIO.h>
/*#include <stdio.h>*/ //-- included by mootIO.h

namespace mootio {

  /*====================================================================
   * mcstream : FILE* i/o
   *====================================================================*/
  class mcstream
    : public mistream,
      public mostream
  {
  public:
    FILE *file;  
  public:
    /*----------------------------------------------------------
     * mcstream: constructors
     */


    mcstream(FILE *f=NULL) : file(f) {};

    ~mcstream(void) {};

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


    virtual bool valid(void) { return file && !ferror(file); };

    virtual bool eof(void) { return !file || feof(file); };

    virtual std::string errmsg(void) {
      return std::string(file && !ferror(file) ? "" : strerror(errno));
    };

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


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

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

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


    virtual ByteCount read(char *buf, size_t n) {
      return file ? fread(buf, 1, n, file) : 0;
    };

    virtual int getbyte(void) {
      return file ? fgetc(file) : EOF;
    };

    /*----------------------------------------------------------
     * mcstream: output
     */


    virtual bool flush(void) { return file && fflush(file) != EOF; };

    virtual bool write(const char *buf, size_t n) {
      return file ? (fwrite(buf,1,n,file) == n) : false;
    };

    virtual bool putbyte(unsigned char c) {
      return file ? (fputc(c,file) != EOF) : false;
    };

    virtual bool puts(const char *s) {
      return file ? (fputs(s,file) >= 0) : false;
    };
    virtual bool puts(const std::string &s) {
      return file ? (fwrite(s.data(),1,s.size(),file) == s.size()) : false;
    };

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


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


    mfstream(void)
      : mode("r"),
        default_mode("r")
    {};

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

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

    /*------------------------------------------------------------------
     * mfstream: 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) file = stdout;
        else file = stdin;
      } else {
        file = fopen(name.c_str(), mode.c_str());
      }
      return file && !ferror(file);
    };

    virtual bool close(void) {
      if (!file) return true;
      else if (file==stdin || file==stdout || file==stderr) {
        //-- don't close standard streams
        file = NULL;
        return true;
      }
      bool rc = fclose(file) == 0;
      file = NULL;
      return rc;
    };

    /*------------------------------------------------------------------
     * mfstream: params
     */


    inline void setparams(int level=0, int strategy=0) {};
  }; //-- /mfstream

  /*====================================================================
   * mifstream : named file input
   *====================================================================*/
  class mifstream : public mfstream {
  public:
    /*------------------------------------------------------------------
     * mifstream: Constructors
     */


    mifstream(void) {
      default_mode = "r";
    };

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

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

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

  /*====================================================================
   * mofstream : named file output
   *====================================================================*/
  class mofstream : public mfstream {
  public:
    /*------------------------------------------------------------------
     * mofstream: Constructors
     */


    mofstream(void) {
      default_mode = "w";
    };

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

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

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


  /*====================================================================
   * mootio : typedef aliases
   *====================================================================*/
  typedef mcstream micstream; 
  typedef mcstream mocstream; 

}; //-- /namespace mootio


#endif //_MOOT_CIO_H