FBB::Table - Generates row- or column-wise filled tables
SYNOPSIS
#include <bobcat/table>
Linking option: -lbobcat
DESCRIPTION
FBB::Table objects may 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 by 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 will be constructed which can be
inserted into a std::ostream.
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.
ENUMERATIONS
The following enumerations are defined in the class FBB::TableSpec,
allowing the programmer to specifiy values like FBB::TableSpec::Vertical
rather than FBB::Table<std::istream_const_iterator>::Vertical.
enum FillDirection
This enumeration holds two values:
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.
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 column.
enum WidthType
This enumeration holds two values:
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.
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),
CONSTRUCTORS
Table(size_t nColumns, Table::FillDirection direction,
Table::WidthType widthType = Table::COLUMNWIDTH):
This constructor expects the table's number of columns. The number of
rows are implied by the combination of this parameter and the number of
elements that will be inserted into the Table object. The direction
parameter specifies the way new elements will be 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
may either have its own width or all columns will have equal widths.
Table(TableSupport &tableSupport, 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 to define elements like horizontal lines between rows, additional
separators between elements etc. Note that the TableSupport object is
passed as a non-const reference as the Table object must be able to
manipulate its data.
The copy constructor is not available.
OVERLOADED OPERATORS
std::ostream &operator<<(std::ostream &str, Table &table):
This operator inserts a Table into a std::ostream object. Note
that this operator requires a non-const table as it may have to fill out a
table with empty elements (i.e., empty strings) to obtain a fully rectangular
table.
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.
Table &operator<<(Table &obj, Type const &x):
This overloaded operator is defined as a 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.
The overloaded assignment operator is not available.
MEMBER FUNCTIONS
Table &append(std::string const &text
char const *sep = " \t", bool addEmpty = false):
This member adds all fields in text separated by one of the
characters in sep as additional elements to the Table object. Empty
fields are ignored unless the parameter addEmpty is initialized to
true.
void clear():
This member clears the table. All existing elements are removed, and
the table will be empty.
void fill(InputIterator begin, InputIterator end):
This member is defined as a 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.
void push_back(std::string const &element):
This member can be used to add another element to the table (it is
also called from a back_inserter adaptor).
size_t nRows():
This member returns the currently available number of rows in the
table. Its value is only defined after calling def().
Table &setAlign(Align const &align):
This member is used to specify the alignment of either a column or an
element of the Table object. 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 table 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.
Table &def():
This member may be used to `complete' a Table object to a full
rectangular object, for which all column widths and alignments have been
determined. It is implied 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.
MANPULATORS
Table &def(Table &table):
This manipulator can be inserted into a table to call the table's
def() member.
EXAMPLE
#include <iostream>
#include <iomanip>
#include <string>
#include <algorithm>
#include <bobcat/fnwrap1c>
#include <bobcat/table>
using namespace std;
using namespace FBB;
class Support: public TableSupport
{
public:
// virtual void hline(size_t row) const;
virtual void vline(size_t col) const;
virtual void vline() const;
private:
// static void outLine(Element const &element, ostream &out);
};
//void Support::hline(size_t row) const
//{
// if (row == 0 || row == nRows())
// out() << setfill('-') << setw(width()) << "-" << setfill(' ');
// else
// {
// const_iterator fieldIt = begin(row);
//
// if (fieldIt == end())
// return;
//
// for_each(fieldIt, end(),
// FnWrap1c<Element const &, ostream &>(outLine, out()));
// }
// out() << endl;
//}
//
//void Support::outLine(Element const &element, ostream &out)
//{
// if (element.width == 0)
// return;
//
// if (element.type == SKIP)
// out << setw(element.width) << " ";
// else
// out << setfill('-') << setw(element.width) << "-" << setfill(' ');
//}
//
void Support::vline(size_t col) const
{
if (col < sep().size())
out() << sep()[col];
}
void Support::vline() const
{
vline(nColumns());
out() << "\n";
}
int main(int argc, char **argv)
{
Support support;
support << 0 << " | " << " | ";
support << Support::HLine(1, 1, 3); // row[1] separator for cols 1 and 2
Table tab(support, 3, Table::ROWWISE, Table::EQUALWIDTH);
// Table tab(support, 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 << endl; // 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 << endl;
return 0;
}