NAME

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

SYNOPSIS

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

DESCRIPTION

       The FBB::OFilterBuf 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  OFilterBuf  to  filter  its
       received information before passing it on to yet another ostream.

       As  OFilterBuf inherits from std::streambuf an OFilterBuf 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 OFilterBuf 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

       As OFilterBuf should be used as a base class all its constructors are protected.

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

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

       o      OFilterBuf(std::ostream &out):
              This  constructor  creates  a  OFilterBuf object and will insert any filtered information into the
              provided  ostream object.

       Copy and move constructors (and assignment operators) are not available.

PROTECTED MEMBER FUNCTIONS

       Except for the public members inherited from std::ostreambuf all of OFilterBuf’s members are protected.

       Derived classes should provide their own implementation of int underflow(int ch) to implement filtering.

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

       o      void reset(std::ostream &out):
              This member flushes the current destination (filtered)  std::ostream  object  and  associates  the
              OFilterBuf object with the provided ostream object.

       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/ofilterbuf>

           struct NoDigits: public FBB::OFilterBuf
           {
               NoDigits(std::ostream &out)
               :
                   OFilterBuf(out)
               {}

               private:
                   int overflow(int ch) override
                   {
                       if (not isdigit(ch))
                           out().put(ch);
                       return ch;
                   }
           };

           using namespace FBB;
           using namespace std;

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

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

FILES

       bobcat/ofilterbuf - defines the class interface

SEE ALSO

       bobcat(7), ifilterbuf(3bobcat)

BUGS

       None Reported.

BOBCAT PROJECT FILES

       o      https://fbb-git.gitlab.io/bobcat/: gitlab project page;

       o      bobcat_6.04.00-x.dsc: detached signature;

       o      bobcat_6.04.00-x.tar.gz: source archive;

       o      bobcat_6.04.00-x_i386.changes: change log;

       o      libbobcat1_6.04.00-x_*.deb: debian package containing the libraries;

       o      libbobcat1-dev_6.04.00-x_*.deb: debian package containing the libraries, headers and manual pages;

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).