Provided by: libbobcat-dev_5.02.00-1build1_amd64 bug


       FBB::Table - Generates row- or column-wise filled tables


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


       FBB::Table  objects can be used to create tables. The tables are filled either column-wise
       or row-wise. Many of the table’s  characteristics  may  be  fine-tuned  using  a  separate
       FBB::TableSupport  object,  described in a separate man-page (TableSupport(3bobcat)). When
       no FBB::TableSupport object is used, a plain row-wise or column-wise table is  constructed
       which can be inserted into a std::ostream.

       Tables  defined  by  Table consist of a (number of element dependent) number of rows and a
       fixed number of columns, the latter value is specified at construction time.  Columns  and
       rows  are  normally  addressed  using  index  values  (starting at 0). Before the leftmost
       column, between the columns and beyond the last column separators are defined. By  default
       the  separators are empty, but each separator may be given a (fixed) width or content. The
       separator before column col is addressed as separator  col,  the  rightmost  separator  is
       addressed as separator nColummns.

       Likewise,  rows  can  be separated from each other using separators. These separating rows
       are also empty by default. The row-separator before row row is addressed as  row-separator
       row.  The row-separator following the final row is addressed as row-separator nRows, where
       nRows is the value returned by the nRows member function.

       Non-default (i.e., non-empty) separators are defined using FBB::TableSupport objects  (cf.

       Table  objects  look a lot like ostream objects, but they also adopt a fairly rigid way to
       define new elements: each new insertion defines another table element, and it is difficult
       to  end a row before it has received its nColumn number of elements. Table’s sister-class,
       TableBuf, is a std::streambuf type of class, offering additional control through  the  use
       of a wrapping ostream class object.


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


       std::ostringstream - Table inherits from std::ostringstream, allowing  insertions  into  a
       Table object. Each separate insertion adds another element to the Table object.

       FBB::TableBase  -  This  class implements common elements of the table implementation (the
       FBB::TableBuf class is also derived from TableBase. The TableBase class is not intended to
       be  used otherwise, and no separate man-page is provided. All facilities provided by Table
       inherited from TableBase are described in this man-page.


       The following enumerations are defined by the class FBB::Table: enum FillDirection
       This enumeration defines two values:

       o      ROWWISE:
              When this value is specified at construction time, elements are added  row-wise  to
              the  table.  I.e.,  the second element inserted into the Table will be found in the
              second column of the first row.

       o      COLUMNWISE:
              When this value is specified at construction time, elements are  added  column-wise
              to the table. I.e., the second element will be found in the second row of the first

       enum WidthType
       This enumeration defines two values:

       o      COLUMNWIDTH:
              This value may be specified when the columns should be allowed variable widths.  In
              this  case  each  column will be as wide as its widest element. This is the default
              WidthType used by Table objects.

       o      EQUALWIDTH:
              This value may be specified when all the table’s columns should  have  equal  width
              (i.e., equal to the width of the widest table element),


       o      Table(size_t nColumns, Table::FillDirection direction, Table::WidthType widthType =
              The table’s number of columns, the fill directions and the column  width-type  must
              be  provided.   The  number of rows is implied by the combination of this parameter
              and the number of elements that is actually inserted into the  Table  object.   The
              direction  parameter  specifies the way new elements are added to the Table object:
              row-wise or column-wise. Finally, the widthType parameter is used  to  specify  the
              way  the width of the table’s columns is determined. Each column either defines its
              own width or all columns have equal widths.

       o      Table(TableSupport &tableSupport, size_t nColumns, Table::FillDirection  direction,
              Table::WidthType widthType = Table::COLUMNWIDTH):
              This  constructor  operates identically to the previous constructor, but expects an
              additional reference  to  a  TableSupport  object.  A  TableSupport  object  offers
              additional  formatting features used by the table defining elements like horizontal
              lines between rows, additional separators, etc, etc.  The  TableSupport  object  is
              passed  as a non-const reference as the Table object must be able to manipulate its
              data. See tablesuppport(3bobcat) for more information about TableSupport.

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


       o      std::ostream &operator<<(std::ostream &str, Table &table):
              This operator inserts a Table into a std::ostream object.  This operator requires a
              non-const  table  as  it  may  have  to complete the table by adding empty elements
              (i.e., empty strings) to obtain a completely filled rectangular table.

       o      Table &operator<<(Table &obj, Align const &align):
              This operator is used to change the default alignment of  either  a  column  or  an
              element.  It  is  a  wrapper  around  the  member  setAlign()  (see  below  for its
              description). By default, all elements are right-aligned.  See  align(3bobcat)  for
              more information about the Align class.

       o      Table &operator<<(Table &obj, Type const &x):
              This overloaded operator is defined as a function template: Type is a template type
              parameter instantiated to  a  type  for  which  std::ostringstream  insertions  are
              possible.   It  inserts the value/object x into the Table’s std::ostringstream base
              class object as the next element of the table.


       o      Table &append(std::string const &text char const *sep =  "  \t",  bool  addEmpty  =
              Fields  in  text  separated by one of the characters in sep are added as additional
              elements to the Table  object.  Empty  fields  are  ignored  unless  the  parameter
              addEmpty is initialized to true.

       o      void clear():
              The  contents  of  the table are erased. All existing elements are removed, and the
              table will be empty.

       o      void clearStr():
              The contents of its std::ostringstream base class buffer are erased.

       o      void fill(InputIterator begin, InputIterator end):
              This member is defined as a member  template;  InputIterator  is  a  template  type
              parameter  representing  any  input iterator. It can also be, e.g., a pointer to an
              insertable type. The iterators must point to data elements which  can  be  inserted
              into an std::ostream. The range of values implied by the member’s iterator pair are
              inserted into the table as new elements.

       o      void push_back(std::string const &element):
              New elements can be added to the table using push_back. It is, e.g., called from  a
              back_inserter adaptor.

       o      size_t nRows():
              The  currently available number of rows in the table is returned. Its value is only
              defined after calling def().

       o      Table &setAlign(Align const &align):
              The alignment type of either a column or an element of the Table object is  defined
              using setAlign. The standard alignments std::left, std::right and std::internal may
              be specified, but in addition the alignment FBB::center may  be  used  if  elements
              should be centered into their column. A construction like
              tab << Align(2, FBB::center)
              requests  centering  of  all  elements  in  the table’s column having index value 2
              (i.e., the table’s 3rd column), whereas a construction like
              tab << Align(2, 3, FBB::center)
              requests centering of element [2][3]. It is the responsibility of the programmer to
              ensure that such elements exist. By default, all elements are right-aligned.

       o      Table &def():
              After  inserting elements into a Table object its number of elements may or may not
              be an integral multiple of the number of columns specified at construction time. To
              `complete’  a Table object to a rectangular object, for which all column widths and
              alignments have been determined def may be called. It is  automatically  called  by
              operator<<(ostream,  Table).  In  other  situations  it may be called explicitly to
              force the insertion of another row  in  a  table  using  ROWWISE  insertions.  With
              COLUMNWISE  insertions  its  working  is  complex,  since  new  elements added to a
              COLUMNWISE filled table will reshuffle its elements over the table’s columns.  )


       o      Table &def(Table &table):
              This manipulator can be inserted into a table to call the table’s def() member.


       #include <iostream>

       #include <bobcat/table>
       #include <bobcat/tablelines>

       using namespace std;
       using namespace FBB;

       int main(int argc, char **argv)
           TableLines tablelines;
                                       // width/separators of cols 0, 1 and 2
           tablelines << 0 << " | " << " | ";

                                       // hline over cols 1 and 2 of row 1
           tablelines << TableLines::HLine(1, 1, 3);

           Table tab(tablelines, 3, Table::ROWWISE, Table::EQUALWIDTH);
           // or: Table tab(tablelines, 3, Table::ROWWISE);

           tab << Align(0, std::left);     // set column non-default alignment
           tab.fill(argv + 1, argv + argc);// fill range of values
           cout << tab << ’\n’;            // complete the table and insert

           tab << "hello" << "" << "wo";   // add additional elements.
           if (tab.nRows() > 2)
               tab << Align(2, 2, center); // set the layout of a specific element

           cout << tab << ’\n’;


       bobcat/table - defines the class interface;


       bobcat(7), align(3bobcat), manipulator(3bobcat),  tablebuf(3bobcat),  tablelines(3bobcat),


       Note  that  def()  will  reshuffle elements over the table’s columns when new elements are
       added to the table subsequent to calling def()


       o      bobcat_5.02.00-x.dsc: detached signature;

       o      bobcat_5.02.00-x.tar.gz: source archive;

       o      bobcat_5.02.00-x_i386.changes: change log;

       o      libbobcat1_5.02.00-x_*.deb: debian package holding the libraries;

       o      libbobcat1-dev_5.02.00-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 (