Skip site navigation (1)Skip section navigation (2)

FreeBSD Manual Pages


home | help
FBB::Table(3bobcat)	     Construct text tables	   FBB::Table(3bobcat)

       FBB::Table  - Generates row- or column-wise filled tables from informa-
       tion inserted into a std::ostream

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

       FBB::Tablebuf objects are std::streambuf	objects	that 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  by  a  separate
       FBB::TableSupport  object,  described in	a separate man-page (TableSup-
       port(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. Displaying  a  table  (e.g.,  at	 the  standard	output
       stream) involves	the following steps:

       o      Optionally, a  TableSupport object is created;

       o      A	 Tablebuf  object  is created (maybe passing it	a TableSupport

       o      The Tablebuf object is used to initialize	a std::ostream

       o      The elements of the table	are filled  by	inserting  information
	      into that	std::ostream

       o      The  Tablebuf itself contains the	formatted table	and may	itself
	      be inserted into a std::ostream like std::cout.

       Tables defined by TableBuf consist of a (number of  element  dependent)
       number of rows and a fixed number of columns, the latter	value is spec-
       ified at	construction time. Columns and rows are	normally addressed us-
       ing  index  values (starting at 0). Before the leftmost column, between
       the columns and beyond the last column separators are defined.  By  de-
       fault  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

       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::Table-
       Support objects (cf. tablesupport(3bobcat)).

       TableBuf's sister-class Table can be used to insert elements into a ta-
       ble in a	more direct way. With TableBuf field separators	 are  used  to
       switch  to  the next table-element, and (with row-wise filled tables) a
       row separator can be used to switch to the next row when	it's only par-
       tially  defined.	Instead, with Table objects each new insertion defines
       another table element, and no wrapping std::ostream object is required.

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

       std::streambuf  -  allowing  TableBuf objects to	be wrapped in std::os-
       tream objects.

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

       The following enumerations are defined in the class FBB::Tablebuf.

       enum FillDirection
       This enumeration	has 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

       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 column.

       enum WidthType
       This enumeration	holds 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 ob-

       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

       o      Tablebuf(size_t nColumns,	 Table::FillDirection  direction,  Ta-
	      ble::WidthType widthType = Table::COLUMNWIDTH):
	      The  table's number of columns, the fill directions and the col-
	      umn 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  parame-
	      ter  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      TableBuf(TableSupport &tableSupport, Table::FillDirection	direc-
	      tion, Table::WidthType widthType = Table::COLUMNWIDTH):
	      This constructor operates	identically to the previous  construc-
	      tor,  but	 expects an additional reference to a TableSupport ob-
	      ject. A TableSupport object offers  additional  formatting  fea-
	      tures  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.

       o      std::ostream &operator<<(std::ostream &out, TableBuf &tablebuf):
	      This  operator  inserts  a  TableBuf into	a std::ostream object.
	      Note that	the TableBuf object inserted into out is  a  non-const
	      object,  as  the	table may have to be completed by adding empty
	      elements for missing ones. The out stream	should not be equal to
	      the  std::ostream	 object	that is	used to	wrap in	a TableBuf ob-

       o      TableBuf &operator<<(TableBuf &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	setAl-
	      ign() (see below for its description). By	default, all  elements
	      are right-aligned. See align(3bobcat) for	more information about
	      the Align	class. Unlike the insertion  operators	available  for
	      Table  type objects, the insertion operator for TableBuf objects
	      is only used to define column or cell-alignment.	The overloaded
	      assignment operator is not available.

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

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

       o      TableBuf &setAlign(Align const &align):
	      The  alignment  type  of	either	a  column or an	element	of the
	      TableBuf object is defined using setAlign. The  standard	align-
	      ments  std::left,	std::right and std::internal may be specified,
	      but in addition the alignment FBB::center	may be	used  if  ele-
	      ments 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  con-
	      struction	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  de-
	      fault, all elements are right-aligned.

       o      TableBuf &def():
	      After  inserting	elements  into a TableBuf 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 TableBuf
	      object to	a rectangular object, for which	all column widths  and
	      alignments  have	been determined	def may	be called. It is auto-
	      matically	called by operator__(ostream, TableBuf). In other sit-
	      uations  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 ta-
	      ble's columns.

       o      setFieldSeparator(char fs):
	      The  default  field separator is the `backspace' (\b) character.
	      After inserting a	field separator	the next table element will be
	      defined.	Inserting  two field separators	inserts	an table empty
	      element and starts the definition	 of  the  next	element.  This
	      field  separator	character  can	be redefined by	this function.
	      Calling setFieldSeparator	without	argument disables the use of a
	      field separator character, and only leaves the use of the	fs ma-
	      nipulator	to switch to the next field.

       o      setRowSeparator(char rs):
	      The default row separator	is the newline character (\n).	 After
	      inserting	a row separator	the next element to enter into the ta-
	      ble will be the leftmost element of the next row.	 Inserting two
	      row  separators  adds  an	 empty	row  to	 the  table.   Calling
	      setRowSeparator without argument disables	the use	of a row sepa-
	      rator  character,	 and only leaves the use of the	rs manipulator
	      to switch	to the next field.

       The member listed in this section implements the	tasks of the  compara-
       bly named virtual function in the class's private interface. This sepa-
       rates the redefinable interface	from  the  user-interface.  The	 class
       Tablebuf	 can,  in  accordance with Liskov's Substitution Principle, be
       used as a std:streambuf;	but it also offers a facility for classes  de-
       riving from Tablebuf. This facility is listed here.

       o      int pSync():
	      The contents of the Tablebuf's internal buffer is	flushed.

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

       o      FBB::fs:
	      This manipulator can be inserted into a TableBuf's wrapping  os-
	      tream  to	switch to the next field of the	table. It is an	alter-
	      native to	using the field	separator character.

       o      FBB::rs:
	      This manipulator can be inserted into a TableBuf's wrapping  os-
	      tream  to	switch to the next row of the table. It	is an alterna-
	      tive to using the	row separator character.

       #include	<iostream>
       #include	<ostream>
       #include	<string>
       #include	<algorithm>
       #include	<iterator>

       #include	<bobcat/tablebuf>
       #include	<bobcat/tablelines>

       using namespace std;
       using namespace FBB;

       int main()
	   TableLines tablelines;

	   tablelines << 0;	       // set separator	widths
	   for (size_t sep = 0;	sep != 8; ++sep)
	       tablelines << 3;

	   TableBuf tab(tablelines, 8, TableBuf::ROWWISE);

	   ostream out(&tab);

	   copy(istream_iterator<string>(cin), istream_iterator<string>(),
		   ostream_iterator<string>(out, "\b"));

	   cout	<< tab << '\n';		   // complete the table and insert

       bobcat/tablebuf - defines the class interface;

       bobcat(7), align(3bobcat),  manipulator(3bobcat),  tablelines(3bobcat),
       tablesupport(3bobcat), table(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_3.25.01-x.dsc: detached signature;

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

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

       o      libbobcat1_3.25.01-x_*.deb:  debian  package  holding  the   li-

       o      libbobcat1-dev_3.25.01-x_*.deb:  debian  package holding the li-
	      braries, 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 (GPL).

       Frank B.	Brokken	(

libbobcat-dev_3.25.01-x.tar.gz	   2005-2015		   FBB::Table(3bobcat)


Want to link to this manual page? Use this URL:

home | help