mootBufferIO.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: mootBufferIO.h
 * Author: Bryan Jurish <moocow@cpan.org>
 * Description:
 *   + moot PoS tagger : low-level I/O routines: C buffer I/O
 *--------------------------------------------------------------------------*/

#ifndef _MOOT_BUFFERIO_H
#define _MOOT_BUFFERIO_H

//#include <stdio.h>   // for EOF (via mooIO.h)
//#include <string.h>  // for memcpy() and friends (via mootIO.h)
//#include <assert.h>  // for sanity checks
#include <stdlib.h>  // for memory allocation etc.

#include <mootUtils.h> // for trimming
#include <mootArgs.h>  // for moot_va_copy()
//#include <mootIO.h>    // for everything else (via mootUtils.h)



namespace mootio {
  //using namespace std;

  /*====================================================================
   * mootio: classes
   *====================================================================*/

  class micbuffer : virtual public mistream
  {
  public:
    const char  *cb_rdata;   
    size_t       cb_offset;  
    size_t       cb_used;    

  public:
    /*----------------------------------------------------------
     * micbuffer: constructors
     */


    micbuffer(const void *data, size_t len)
      : mistream(),
        cb_rdata(reinterpret_cast<const char*>(data)),
        cb_offset(0),
        cb_used(len)
    {};

    micbuffer(const micbuffer &cb)
      : mistream(),
        cb_rdata(cb.cb_rdata),
        cb_offset(cb.cb_offset),
        cb_used(cb.cb_used)
    {};

    virtual ~micbuffer(void) {};

    inline void clear(void)
    {
      cb_offset = 0;
      cb_used = 0;
    };

    inline void release(void)
    {
      clear();
      cb_rdata = NULL;
    };

    inline void assign(const void *data, size_t len) {
      cb_rdata  = reinterpret_cast<const char *>(data);
      cb_used   = len;
      cb_offset = 0;
    };

    /*----------------------------------------------------------
     * micbuffer: Integrity
     */


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

    virtual bool eof(void) { return cb_offset >= cb_used; };

    /*----------------------------------------------------------
     * micbuffer: Input
     */


    virtual ByteCount read(char *buf, size_t n) {
      if (n==0 || cb_offset >= cb_used) return 0;
      else if (n < cb_used - cb_offset) {
        //-- normal case: copy local data to buf
        memcpy(buf, cb_rdata+cb_offset, n);
        cb_offset += n;
        return static_cast<ByteCount>(n);
      }
      else {
        //-- partial read: copy some data to buf
        memcpy(buf, cb_rdata+cb_offset, cb_used-cb_offset);
        ByteCount nread = static_cast<ByteCount>(cb_used-cb_offset);
        cb_offset = cb_used;
        return nread;
      }
    };

    virtual int getbyte(void) {
      if (cb_offset >= cb_used) return EOF;
      return cb_rdata[cb_offset++];
    };

    /*----------------------------------------------------------
     * micbuffer: Utilties
     */


    inline const char* data(void) const { return cb_rdata; };

    inline size_t size(void) const { return cb_used; };

    inline size_t capacity(void) const { return cb_used; };

    inline size_t offset(void) const { return cb_offset; };

    inline std::string as_string(bool normalize_ws=false,
                                 bool trim_left=false,
                                 bool trim_right=false)
      const
    {
      std::string str;
      str.reserve(cb_used-cb_offset);
      to_string(str, normalize_ws, trim_left, trim_right);
      return str;
    };

    inline void to_string(std::string &str,
                          bool normalize_ws =false,
                          bool trim_left    =false,
                          bool trim_right   =false)
      const
    {
      if (!cb_rdata) return;
      if (!normalize_ws)
        str.append(cb_rdata+cb_offset, cb_used-cb_offset);
      else
        moot::moot_normalize_ws(cb_rdata+cb_offset, cb_used-cb_offset,
                                str,
                                trim_left, trim_right);
    };
  }; //-- /micbuffer


  /*====================================================================
   * mootio: input/output: mcbuffer
   *====================================================================*/

  class mcbuffer
    : virtual public micbuffer,
      virtual public mostream
  {
  public:
    static const size_t CB_DEFAULT_SIZE = 32;

    static const size_t CB_DEFAULT_GET = 32;

  public:
    char   *cb_wdata;   
    size_t  cb_alloc;   
    size_t  cb_get;     
    bool    cb_created; 

  public:
    /*----------------------------------------------------------
     * mcbuffer: constructors
     */


    mcbuffer(size_t size=CB_DEFAULT_SIZE)
      : micbuffer(NULL,0),
        cb_wdata(NULL),
        cb_alloc(0),
        cb_get(CB_DEFAULT_GET),
        cb_created(true)
    {
      if (size) reserve(size);
    };

    mcbuffer(void *data,
            size_t used,
            size_t alloc=0,
            size_t get=CB_DEFAULT_GET)
      : micbuffer(reinterpret_cast<const char *>(data),used),
        cb_wdata(reinterpret_cast<char*>(data)),
        cb_alloc(alloc),
        cb_get(get),
        cb_created(false)
    {
      if (!alloc) cb_alloc = cb_used;
      cb_rdata = cb_wdata;
    };

    mcbuffer(const micbuffer &cb)
      : micbuffer(NULL,0),
        cb_wdata(NULL),
        cb_created(true)
    {
      reserve(cb.cb_used);
      memcpy(cb_wdata, cb.cb_rdata, cb.cb_used);
      cb_offset = cb.cb_offset;
      cb_used   = cb.cb_used;
      cb_rdata  = cb_wdata;
    };

    inline void assign(const void *data, size_t len) {
      reserve(len);
      memcpy(cb_wdata, data, len);
      cb_rdata   = cb_wdata;
      cb_offset  = 0;
      cb_used    = len;
      cb_created = true;
    };

    virtual ~mcbuffer(void) { release(); };

    inline void clear(void)
    {
      cb_offset = 0;
      cb_used = 0;
    };

    inline void release(void)
    {
      clear();
      if (cb_created && cb_wdata) free(cb_wdata);
      cb_wdata = NULL;
      cb_rdata = NULL;
      cb_alloc = 0;
    };

    /*----------------------------------------------------------
     * mcbuffer: Output
     */


    virtual bool flush(void) {
      if (!cb_offset || !cb_wdata) return true;
      memmove(cb_wdata, cb_wdata+cb_offset, cb_used-cb_offset);
      cb_used -= cb_offset;
      cb_offset = 0;
      return true;
    };

    virtual bool write(const char *buf, size_t n) {
      if (!reserve(n+cb_used, cb_get)) return false;
      memcpy(cb_wdata+cb_used, buf, n);
      cb_used += n;
      return true;
    };

    virtual bool putbyte(unsigned char c) {
      if (!reserve(1+cb_used, cb_get)) return false;
      cb_wdata[cb_used++] = c;
      return true;
    };

    virtual bool puts(const char *s) {
      return write(s,strlen(s));
    };
    virtual bool puts(const std::string &s) {
      return write(s.data(),s.size());
    };

    virtual bool vprintf(const char *fmt, va_list &ap)
    {
      va_list ap_tmp;
      moot_va_copy(ap_tmp,ap);
      size_t nchars = vsnprintf(cb_wdata+cb_used, cb_alloc-cb_used, fmt, ap);
      if (nchars >= cb_alloc-cb_used) {
        if (!reserve(1+nchars+cb_used, cb_get)) return false;
        moot_va_copy(ap,ap_tmp);
        vsnprintf(cb_wdata+cb_used, cb_alloc-cb_used, fmt, ap);
      }
      cb_used += nchars;
      return true;
    };

    /*----------------------------------------------------------
     * mcbuffer: Utilties
     */


    inline bool reserve(size_t size, size_t pad=0) {
      if (size > cb_alloc) {
        size_t newalloc = size+pad;
        if (cb_created) {
          //-- local buffer: we can just realloc()
          if (cb_wdata) cb_wdata = reinterpret_cast<char *>(realloc(cb_wdata, newalloc));
          else cb_wdata = reinterpret_cast<char *>(malloc(newalloc));
        } else {
          //-- user buffer: we need to slurp it
          char *newdata = reinterpret_cast<char *>(malloc(newalloc));
          memcpy(newdata, cb_wdata, cb_used);
          cb_wdata = newdata;
          cb_created = true;
        }
        assert(cb_wdata != NULL);
        cb_rdata = cb_wdata;
        cb_alloc = newalloc;
      }
      return true;
    };

  }; //-- /mcbuffer

  /*====================================================================
   * mootio: c-buffers: aliases
   *====================================================================*/
  typedef micbuffer mibuffer;   
  typedef mcbuffer  mobuffer;   
  typedef mcbuffer  mocbuffer;  
  typedef mcbuffer  miocbuffer; 
  typedef mcbuffer  miobuffer;  
  typedef mcbuffer  mbuffer;    

}; //-- /namespace mootio


#endif //_MOOT_BUFFERIO_H