mootCxxIO.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: mootCxxIO.h
 * Author: Bryan Jurish <moocow@cpan.org>
 * Description:
 *   + moot PoS tagger : low-level I/O abstractions for C++ streams
 *   + 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_CXXIO_H
#define _MOOT_CXXIO_H

#include <iostream>
#include <fstream>

#include <mootIO.h>
#include <mootArgs.h>

namespace mootio {
  using namespace std;

  /*====================================================================
   * mcxxstream : std::(i|o)stream i/o
   *====================================================================*/
  template <class _StreamClass>
  class mcxxstream : virtual public mstream {
  public:
    _StreamClass *streamp;  
  public:
    /*----------------------------------------------------------
     * mcxxstream: constructors
     */


    mcxxstream(_StreamClass *streamptr=NULL) : streamp(streamptr) {};

    mcxxstream(_StreamClass &stream) : streamp(&stream) {};

    virtual ~mcxxstream(void) {};

    /*----------------------------------------------------------
     * mcxxstream: integrity
     */


    virtual bool valid(void) { return streamp && streamp->good(); };

    virtual bool eof(void) { return !streamp || streamp->eof(); };
  }; //-- /mcxxstream


  /*====================================================================
   * micxxstream : std::istream input
   *====================================================================*/
  class micxxstream
    : public mcxxstream<std::istream>,
      public mistream
  {
  public:
    /*----------------------------------------------------------
     * micxxstream: constructors
     */


    micxxstream(std::istream *streamptr=NULL)
      : mcxxstream<std::istream>(streamptr)
    {};

    micxxstream(std::istream &istream)
      : mcxxstream<std::istream>(istream)
    {};

    ~micxxstream(void) {};

    /*----------------------------------------------------------
     * micxxstream: input
     */


    virtual ByteCount read(char *buf, size_t n) {
      return streamp ? streamp->read(buf,n).gcount() : 0;
    };

    virtual int getbyte(void) {
      return streamp ? streamp->get() : EOF;
    };
  }; //-- /micxxstream


  /*====================================================================
   * mocxxstream : std::ostream output
   *====================================================================*/
  class mocxxstream
    : public mcxxstream<std::ostream>,
      public mostream
  {
  public:
    char      *_printf_buffer; 
    ByteCount  _printf_buflen; 

  public:
    /*----------------------------------------------------------
     * mocxxstream: output
     */


    mocxxstream(std::ostream *ostreamptr)
      : mcxxstream<std::ostream>(ostreamptr),
        _printf_buffer(NULL),
        _printf_buflen(0)
    {};

    mocxxstream(std::ostream &ostream)
      : mcxxstream<std::ostream>(ostream),
        _printf_buffer(NULL),
        _printf_buflen(0)
    {};

    virtual ~mocxxstream(void)
    {
      if (_printf_buffer) free(_printf_buffer);
    };

    /*----------------------------------------------------------
     * mocxxstream: output
     */


    virtual bool mflush(void) { return streamp->flush().good(); };

    virtual bool write(const char *buf, size_t n) {
      return streamp ? streamp->write(buf,n).good() : false;
    };

    virtual bool putbyte(unsigned char c) {
      return streamp ? streamp->put(c).good() : false;
    };

    virtual bool puts(const char *s) {
      return streamp ? ((*streamp) << s).good() : false;
    };
    virtual bool puts(const std::string &s) {
      return streamp ? ((*streamp) << s).good() : false;
    };

    virtual bool vprintf(const char *fmt, va_list &ap) {
      if (!streamp) return false;
      va_list ap_tmp;
      moot_va_copy(ap_tmp,ap);
      ByteCount nchars = vsnprintf(_printf_buffer, _printf_buflen, fmt, ap);
      if (nchars >= _printf_buflen) {
        //-- oops: reallocate!
        _printf_buffer = reinterpret_cast<char *>(realloc(_printf_buffer, nchars+1));
        assert(_printf_buffer != NULL);
        _printf_buflen = nchars+1;
        //-- ... and try again
        moot_va_copy(ap,ap_tmp);
        nchars = vsnprintf(_printf_buffer, _printf_buflen, fmt, ap);
      }
      //-- we now have a full string buffer: write it
      return streamp->write(_printf_buffer, nchars).good();
    };
  }; //-- /mocxxstream

}; //-- /namespace mootio


#endif //_MOOT_CXXIO_H