---
name: "tablebuf"
section: "3bobcat"
platform: "linux"
package: "libbobcat-dev"
version: "6.07.01-2"
release: "Debian 13 (Trixie)"
platforms: ["linux"]
url: "https://new.carta.tech/tablebuf"
---

# tablebuf(3bobcat)

Generates row- or column-wise filled tables from information inserted into a std::ostream

## NAME

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

## SYNOPSIS

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

## DESCRIPTION

**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 (**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**. 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* object);

- 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 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. [**tablesupport**(3bobcat)](/tablesupport/3bobcat.md)).

*TableBuf*’s sister-class *Table* can be used to insert elements into a table 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 partially defined. Instead, with *Table* objects each new insertion defines another table element, and no wrapping *std::ostream* object is required.

## NAMESPACE

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

## INHERITS FROM

**std::streambuf** - allowing *TableBuf* objects to be wrapped in *std::ostream* objects.

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

## ENUMERATIONS

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 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 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** 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),

## CONSTRUCTORS

- o

  **Tablebuf(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

  **TableBuf(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 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 &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* object.

- 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 *setAlign()* (see below for its description). By default, all elements are right-aligned. See [**align**(3bobcat)](/align/3bobcat.md) 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.

## MEMBER FUNCTIONS

- o

  **void clear()**:\
   The content 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 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

  **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 automatically called by *operator\<\<(ostream, TableBuf)*. 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

  **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* manipulator 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 table 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 separator character, and only leaves the use of the *rs* manipulator to switch to the next field.

## MANPULATORS

- 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 *ostream* to switch to the next field of the table. It is an alternative to using the field separator character.

- o

  **FBB::rs**:\
   This manipulator can be inserted into a *TableBuf*’s wrapping *ostream* to switch to the next row of the table. It is an alternative to using the row separator character.

## EXAMPLE

```
#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
}
```

## FILES

*bobcat/tablebuf* - defines the class interface;\

## SEE ALSO

[**bobcat**(7)](/bobcat/7.md), [**align**(3bobcat)](/align/3bobcat.md), [**csvtable**(3bobcat)](/csvtable/3bobcat.md), **manipulator**(3bobcat), [**tablelines**(3bobcat)](/tablelines/3bobcat.md), [**tablesupport**(3bobcat)](/tablesupport/3bobcat.md), [**table**(3bobcat)](/table/3bobcat.md)

## 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;

Debian Bobcat project files:

- o

  *libbobcat6*: debian package containing the shared library, changelog and copyright note;

- o

  *libbobcat-dev*: debian package containing the static library, headers, manual pages, and developer info;

## 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**).