Boost C++ Libraries of the most highly regarded and expertly designed C++ library projects in the world. Herb Sutter and Andrei Alexandrescu, C++ Coding Standards

This is the documentation for an old version of Boost. Click here to view this page for the latest version.
Generator Directive for Temporary Output Buffering (buffer[])

All generator components (except the Alternative (|) generator) pass their generated output directly to the underlying output stream. If a generator fails halfway through, the output generated so far is not 'rolled back'. The buffering generator directive allows to avoid this unwanted output to be generated. It temporarily redirects the output produced by the embedded generator into a buffer. This buffer is flushed to the underlying stream only after the embedded generator succeeded, but is discarded otherwise.

// forwards to <boost/spirit/home/karma/directive/buffer.hpp>
#include <boost/spirit/include/karma_buffer.hpp>

Also, see Include Structure.


boost::spirit::buffer // alias: boost::spirit::karma::buffer

Model of




A generator object


Attribute type of generator a

Expression Semantics

Semantics of an expression is defined only where it differs from, or is not defined in UnaryGenerator.




The embedded generator a is invoked but its output is temporarily intercepted and stored in an internal buffer. If a succeeds the buffer content is flushed to the underlying output stream, otherwise the buffer content is discarded. The buffer directive succeeds as long as the embedded generator succeeded (unless the underlying output stream reports an error).

[Tip] Tip

If you want to make the buffered generator succeed regardless of the outcome of the embedded generator, simply wrap the buffer[a] into an additional optional: -buffer[a] (see Optional (unary -)).


See Compound Attribute Notation.




a: A --> buffer[a]: A
a: Unused --> buffer[a]: Unused


The overall complexity of the buffering generator directive is defined by the complexity of its embedded generator. The complexity of the buffering directive generator itself is O(N), where N is the number of characters buffered.

[Note] Note

The test harness for the example(s) below is presented in the Basics Examples section.

Some includes:

#include <boost/spirit/include/karma.hpp>
#include <boost/spirit/include/support_utree.hpp>
#include <boost/spirit/include/phoenix_core.hpp>
#include <boost/spirit/include/phoenix_operator.hpp>
#include <boost/fusion/include/std_pair.hpp>
#include <iostream>
#include <string>

Some using declarations:

using boost::spirit::karma::double_;
using boost::spirit::karma::buffer;

Basic usage of a buffering generator directive. It shows how the partial output generated in the first example does not show up in the generated output as the plus generator fails (no data is available, see Plus (unary +)).

std::vector<double> v;                // empty container
test_generator_attr("", -buffer['[' << +double_ << ']'], v);

v.push_back(1.0);                     // now, fill the container
test_generator_attr("[1.02.0]", buffer['[' << +double_ << ']'], v);