Provided by: libbobcat-dev_6.04.00-1ubuntu3_amd64 
NAME
FBB::Table - Generates row- or column-wise filled tables
SYNOPSIS
#include <bobcat/table>
Linking option: -lbobcat
DESCRIPTION
FBB::Table objects can be used to create tables. Tables are filled either column- or
row-wise. Many of the table’s characteristics may be fine-tuned using a separate
FBB::TableSupport object (cf. tablesupport(3bobcat)). When no FBB::TableSupport object is
used, a plain table, filled row-wise or column-wise, is constructed which can be inserted
into a std::ostream.
Tables defined by Table consist of rows and a fixed number of columns. The number of
columns is specified at construction time, the number of rows also depends on the number
of inserted elements. Columns and rows are addressed using indices (starting at 0). Before
the leftmost column, between the columns and beyond the last column separators are
defined. By default these 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.
Rows can also be separated from each other using separators. These separating rows are
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.
tablesupport(3bobcat)).
Table objects look a lot like ostream objects, using a simple 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.
NAMESPACE
FBB
All constructors, members, operators and manipulators, mentioned in this man-page, are
defined in the namespace FBB.
INHERITS FROM
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
TableBase class is not intended to be used by itself, and no separate man-page is
provided. Facilities provided by Table which were inherited from TableBase are described
in this man-page.
ENUMERATIONS
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 is found in the second row of the first
column.
enum WidthType
This enumeration defines two values:
o COLUMNWIDTH:
Specify this value when the columns may have 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:
Specify this value when all of the table’s columns must have equal widths (i.e.,
equal to the width of the widest table element),
CONSTRUCTORS
o Table(size_t nColumns, Table::FillDirection direction, Table::WidthType widthType =
Table::COLUMNWIDTH):
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.
OVERLOADED OPERATORS
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 changes 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 also align(3bobcat));
o Table &operator<<(Table &obj, Type const &item):
This 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 item into the Table’s std::ostringstream base class object
as the table’s next element.
MEMBER FUNCTIONS
o Table &append(std::string const &text char const *sep = " \t", bool addEmpty =
false):
Fields in text separated by one of the characters in sep are added as elements to
the Table object. Empty fields are ignored unless the parameter addEmpty is true;
o void clear():
The content of the table is erased;
o void clearStr():
The content of its std::ostringstream base class buffer is erased;
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 can 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 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 could e.g., be called
from a back_inserter adaptor;
o size_t nRows():
The table’s current number of rows is returned. It is initialized to 0, and after
that updated when def has been called;
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. )
MANPULATORS
o Table &def(Table &table):
This manipulator can be inserted into a table to call the table’s def member.
EXAMPLE
#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’;
}
FILES
bobcat/table - defines the class interface;
SEE ALSO
bobcat(7), align(3bobcat), csvtable(3bobcat), manipulator(3bobcat), tablebuf(3bobcat),
tablelines(3bobcat), tablesupport(3bobcat)
BUGS
Note that def() will reshuffle elements over the table’s columns when new elements are
added to the table subsequent to calling def()
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).