---

filterstreambuf.h

Go to the documentation of this file.

#ifndef DEMO_FILTERSTREAMBUF_H
#define DEMO_FILTERSTREAMBUF_H
// $Id: filterstreambuf.h,v 1.1 2001/08/07 09:15:59 dvermeir Exp $

#include        <iostream>

//  This file defines a simple streambuf specialization. A class
//  object of type FilterStreambuf delegates all I/O to a Filter
//  object.  Filter will be a template parameter for the
//  FilterStreambuf class.
//
//
// The requirements on Filter are as follows:
//
//   class Filter {
//   public:
//     int get(); // return next input char or EOF (-1 for char in C locale)
//     int put(int c); // output c if c!=EOF, return EOF if error
//     int sync(); // synchronize filter, return 0 (ok) or -1 (EOF)
//     void close(); // close filter, no obligations..
//   };

template <class Filter>
class FilterStreambuf: public std::streambuf {
public:

  // The constructor remembers the filter to which I/O will be forwarded.
  // Note that the filter is not copied, the management of the filter is
  // not the FilterStreambuf's responsibility.

  explicit FilterStreambuf(Filter& filter): filter_(filter) {
    setg(inbuf_,inbuf_+1,inbuf_+1); // very small input buffer
    setp(0,0); // no output buffer
    }

  // The destructor is already virtual in streambuf.
  virtual ~FilterStreambuf() {}

  // Return underlying Filter object, const and non-const version.
  const Filter& filter() const { return filter_; }
  Filter&       filter() { return filter_; }

  // Set underlying filter.
  FilterStreambuf& filter(Filter& filter) { filter_ = filter; return *this; }

  // Indicate the intention not to use the filter anymore.
  bool close() { int tmp=sync(); filter_.close(); return tmp; }

protected:
  // The following function simply delegate all I/O operations to the
  // underlying Filter object.
  virtual int  sync() { return filter_.sync(); }
  virtual int  underflow() { 
    if (gptr()<egptr()) // buffer not empty
      return *gptr();
    if ( (inbuf_[0] = filter_.get()) != EOF)
      setg(inbuf_,inbuf_,inbuf_+1);
    return inbuf_[0];
    }  
  virtual int  overflow(int c) { return filter_.put(c); }

private:
  char          inbuf_[1];
  Filter&       filter_;
};

#endif

---

FSM [ August, 2001]