Provided by: libbobcat-dev_4.08.02-2build1_amd64 bug

NAME

       FBB::OFilterStreambuf - Base class for std::ostream filtering

SYNOPSIS

       #include <bobcat/ofilterstreambuf>
       Linking option: -lbobcat

DESCRIPTION

       The FBB::OFilterStreambuf class is a specialization of the std::streambuf class and can be
       used as a base class for classes implementing ostream-filtering.

       Ostream filtering is defined here as the process by which inserted characters are  subject
       to  processing before they are passed on to another (filtered) ostream object (or they may
       be rejected). The filtering may also result in inserting additional information  into  the
       filtered ostream.

       Chaining   of   filters  is  also  possible:  the  filtered  ostream  may  itself  use  an
       OFilterStreambuf to filter its received information before passing it on  to  yet  another
       ostream.

       As OFilterStreambuf inherits from std::streambuf an OFilterStreambuf object can be used to
       provide an ostream object with a std::streambuf. Information inserted into such  a  stream
       travels the following route:

       o      The information is converted to characters using the standard conversion facilities
              implemented by std::ostream objects. E.g., when inserting the value 123 this  value
              is converted to the characters ’1’, ’2’ and ’3’, respectively.

       o      Each  of  the  characters  is  then offered (in turn) to the std::streambuf that is
              associated with the ostream object. In particular, the std::streambuf’s  overflow()
              member is called.

       o      OFstreamBuf’s  default  overflow() function ignores characters, but specializations
              can override overflow() to process the received characters ad lib.

       o      A overriding overflow() function has access to the member OFstreambuf::out()  which
              is  a  reference  to  the  std::ostream  receiving  the  filtered  information.  To
              implement a simple copy-filter (i.e., all characters are accepted  as-is)  a  class
              must  be  derived  from  OFilterStreambuf providing an overriding implementation of
              overflow(), e.g., as follows:

                  int DerivedClass::overflow(int ch)
                  {
                      out().put(ch);
                  }

              Next this std::streambuf specialization can be  associated  with  an  ostream  into
              which  information  to  be `copy filtered’ can be inserted (cf. the EXAMPLE section
              below).

NAMESPACE

       FBB
       All constructors, members, operators and manipulators, mentioned  in  this  man-page,  are
       defined in the namespace FBB.

INHERITS FROM

       std::streambuf

CONSTRUCTORS

       o      OFilterStreambuf():
              This  constructor  creates  a OFilterStreambuf object without associating it with a
              destination (filtered) ostream.

       o      OFilterStreambuf(std::string const &fname, openmode mode = std::ios::out):
              This  constructor  creates  a  OFilterStreambuf  object   and   opens   a   private
              std::ofstream  object  whose  filename  is  provided  and  that  should receive the
              filtered information.

       o      OFilterStreambuf(char const *fname, openmode mode = std::ios::out):
              Same as the previous constructor, expecting a char const * defining the name of the
              private std::ofstream object.

       o      OFilterStreambuf(std::ostream &out):
              This  constructor  creates  a  OFilterStreambuf object and will insert any filtered
              information into the provided  ostream object.  The class’s destructor  closes  the
              destination (filtered) stream (cf. the description of close() below).

MEMBER FUNCTIONS

       All  members of std::ostreambuf are available, as FBB::OFilterStreambuf inherits from that
       class. In particular, derived classes should  provide  their  own  implementation  of  int
       underflow(int ch) to implement any non-trivial filtering.

       o      void close():
              This  member calls the streambuf::sync() member to flush any pending information to
              the destination (filtered) stream and then closes the destination stream. Note that
              the  default  sync() member performs no special actions but it can be overridden by
              derived classes to flush the destination stream just prior to its closing.

       o      void open(std::string const &fname, openmode mode = std::ios::out):
              This member closes the  current  destination  (filtered)  std::ostream  object  and
              associates  the  OFilterStreambuf  object with a private std::ofstream object whose
              filename is provided and that should receive subsequently filtered information.

       o      void open(char const *fname, openmode mode = std::ios::out):
              Same as the previous member, but using a char const * to specify the  name  of  the
              private std::ofstream object to receive the filtered information.

       o      void open(std::ostream &out):
              This  member  closes  the  current  destination  (filtered) std::ostream object and
              associates the OFilterStreambuf object with the provided ostream object.

PROTECTED MEMBER FUNCTION

       o      std::ostream &out() const:
              This member is  available  to  derived  classes  to  insert  information  into  the
              destination (filtered) stream.

EXAMPLE

           #include <iostream>
           #include <cctype>
           #include <bobcat/ofilterstreambuf>

           class NoDigits: public FBB::OFilterStreambuf
           {
               private:
                   int overflow(int ch) override
                   {
                       if (not isdigit(ch))
                           out().put(ch);
                       return ch;
                   }
                   int sync() override
                   {
                       out() << flush;
                       return 0;
                   }
           };

           using namespace FBB;
           using namespace std;

           int main()
           {
               NoDigits nod(cout);     // no digits to cout
               ostream out(&nod);

               out << in.rdbuf();      // rm digits from cin
               return 0;
           }

FILES

       bobcat/ofilterstreambuf - defines the class interface

SEE ALSO

       bobcat(7), ifilterstreambuf(3bobcat)

BUGS

       None Reported.

DISTRIBUTION FILES

       o      bobcat_4.08.02-x.dsc: detached signature;

       o      bobcat_4.08.02-x.tar.gz: source archive;

       o      bobcat_4.08.02-x_i386.changes: change log;

       o      libbobcat1_4.08.02-x_*.deb: debian package holding the libraries;

       o      libbobcat1-dev_4.08.02-x_*.deb:  debian  package holding the libraries, headers and
              manual pages;

       o      http://sourceforge.net/projects/bobcat: public archive location;

BOBCAT

       Bobcat is an acronym of `Brokken’s Own Base Classes And Templates’.

COPYRIGHT

       This is free software, distributed under the terms  of  the  GNU  General  Public  License
       (GPL).

AUTHOR

       Frank B. Brokken (f.b.brokken@rug.nl).