Provided by: libbobcat-dev_3.19.01-1ubuntu1_amd64 bug


       FBB::IFilterStreambuf - Filtering stream buffer initialized by a std::istream object


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


       FBB::IFilterStreambuf  objects  may  be used as a std::streambuf for std::istream objects,
       filtering the information produced by those objects.

       The class IFilterStreambuf was designed with the openSSL  BIO  (cf.  bio(3ssl))  in  mind.
       Since  the BIO concept was developed in the context of the C programming language, BIOs do
       not support C++ streams. Nonetheless, the concept of a filtering device is  an  attractive
       one, and is offered by the FBB::IFilterStreambuf class.

       In  addition to filtering, IFilterStreambuf objects use split buffers, and thus, depending
       on the (configurable) size of buffer  that  is  maintained  by  IFilterStreambuf  objects,
       usually multiple characters read from the IFilterStreambuf can be pushed back again.

       The  class  IFilterStreambuf  is  an  abstract base class. It is used via classes that are
       derived from IFilterStreambuf, implementing its pure virtual load  member  (see  below  at


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




       All members of std::streambuf are available, as IFilterStreambuf inherits from this class.
       Some  of  the  std::streambuf’s  member  are  overridden by IFilterStreambuf, see the next

       Overloaded move and/or copy assignment operators are not available.


       o      IFilterStreambuf(size_t bufSize = 1000):
              This constructor initializes the streambuf, using a buffer of the  indicated  size.
              While the streambuf is being used, its buffer is gradually filled. Eventually, when
              it is full the oldest characters are removed from the buffer, making room for  more
              recent  characters.  At  most half the bufSize number of characters will be removed
              during a single refill. The constructor ensures that the size of  the  buffer  will
              always be at least 100.  Copy- and move constructors are not available.


       o      void setBuffer():
              This  member  initializes  the base class’s buffer pointers (i.e., eback, gptr, and
              egptr) with the initial range of characters retrieved by filter (see below).

              The  member  setBuffer  should  only  once  be  called  from  the  derived  class’s
              constructor.  Once  it has been called, the peek member of the std::istream that is
              initialized with the IFilterStreambuf will return  the  next  available  character,
              even if no other stream operation has as yet been performed. If it is not called by
              the derived class’s constructor, then peek returns 0 until at least  one  character
              has been retrieved from the istream object.


       o      virtual bool filter(char const **srcBegin, char const **srcEnd) = 0:
              The  filter  member  is  declared  as  a  pure virtual member: derived classes must
              override filter with their own implementation.

              Derived class objects are responsible for obtaining  information  (in  any  amount)
              from the device with which they interact. This information is then passed on to the
              IFilterStreambuf via two pointers, pointing, respectively, to the  first  available
              character and beyond the last available character. The characters indicated by this
              range are subsequently transferred  by  the  IFilterStreambuf  object  to  its  own
              buffer, from where they are then retrieved (or to where they can be pushed back) by
              the application.

              The filter member allows implementations to filter and/or  modify  the  information
              that  is  obtained  by  this  member. The EXAMPLE section below provides an example
              filtering out a configurable  set  of  characters  from  a  provided  std::istream.
              Bobcat’s  classes ISymCryptStreambuf(3bobcat) and IBase64Streambuf(3bobcat) provide
              additional examples of classes derived from  IFilterStreambuf.

              The filter member should return false if no (more)  information  is  available.  It
              should return true if information is available, in which case *srcBegin and *srcEnd
              should be pointing to, respectively,  the  first  character  and  beyond  the  last
              character made available by filter;

       o      int pbackfail() final override:
              The  pbackfail  member  is  final; derived classes cannot override it. Currently it
              merely returns EOF. This may change in future implementations.

       o      std::streamsize showmanyc() final override:
              The showmanyc member is final; derived classes cannot override it. It  returns  the
              current  number of characters that are (still) waiting to be processed in the range
              of characters returned by the latest filter call.

       o      int underflow() final override:
              The underflow member is final; derived classes cannot override it. It calls filter,
              and refreshes at most half the size of its internal buffer with characters from the
              range of characters that was returned by the most recent call of filter.  The final
              attribute  was  added  to  the above three members to give IFilterStreambuf objects
              full control over their own buffers.


       Here is a class,  derived  from  IFilterStreambuf,  filtering  out  a  predefined  set  of
       characters.  It  is  used  twice  to  filter  digits and vowels, to illustrate chaining of
       IFilterStreambuf objects.

       #include <iostream>
       #include <istream>
       #include <string>

       #include <bobcat/ifilterstreambuf>

       class CharFilterStreambuf: public FBB::IFilterStreambuf
           std::istream &d_in;         // stream to read from
           std::string d_rmChars;      // chars to rm
           std::string d_buffer;       // locally buffered chars
           size_t const d_maxSize = 100;

               CharFilterStreambuf(std::istream &in, std::string const &rmChars);

               bool filter(char const **srcBegin,
                           char const **srcEnd) override;

       CharFilterStreambuf::CharFilterStreambuf(std::istream &in,
                                                std::string const &rmChars)
           setBuffer();        // required if peek() must return the 1st
       }                       // available character right from the start

       bool CharFilterStreambuf::filter(char const **srcBegin,
                                        char const **srcEnd)

           while (d_buffer.size() != d_maxSize)
               char ch;
               if (not d_in.get(ch))
               if (d_rmChars.find(ch) != std::string::npos) // found char to rm

           if (d_buffer.empty())
               return false;

           *srcBegin =;
           *srcEnd = + d_buffer.size();

           return true;

       int main()
           CharFilterStreambuf buf1(std::cin, "1234567890");
           std::istream in1(&buf1);

           CharFilterStreambuf buf2(in1, "AEIOUaeiou");
           std::istream in2(&buf2);

           std::cout << in2.rdbuf();


       bobcat/ifdstreambuf - defines the class interface


       bobcat(7),             isymcryptstreambuf(3bobcat),             ibase64streambuf(3bobcat),
       ofilterstreambuf(3bobcat). std::streambuf


       None reported.


       o      bobcat_3.19.01-x.dsc: detached signature;

       o      bobcat_3.19.01-x.tar.gz: source archive;

       o      bobcat_3.19.01-x_i386.changes: change log;

       o      libbobcat1_3.19.01-x_*.deb: debian package holding the libraries;

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

       o public archive location;


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


       This is free software, distributed under the terms  of  the  GNU  General  Public  License


       Frank B. Brokken (