FBB::Table - Generates row- or column-wise filled tables
#include <bobcat/table>
Linking option: -lbobcat
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.
FBB
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 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.
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),
- 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.
- 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.
- 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. )
- 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;
Note that def() will reshuffle elements over the
table’s columns when new elements are added to the table subsequent
to calling def()
- o
- https://fbb-git.gitlab.io/bobcat/: gitlab project page;
- o
- bobcat_6.02.02-x.dsc: detached signature;
- o
- bobcat_6.02.02-x.tar.gz: source archive;
- o
- bobcat_6.02.02-x_i386.changes: change log;
- o
- libbobcat1_6.02.02-x_*.deb: debian package containing the
libraries;
- o
- libbobcat1-dev_6.02.02-x_*.deb: debian package containing the
libraries, headers and manual pages;
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 (GPL).
Frank B. Brokken (f.b.brokken@rug.nl).