Boost C++ Libraries

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

Click here to view the latest version of this page.
PrevUpHomeNext
Lazy (lazy)
Description

The familiy of lazy components allows to use a dynamically returned generator component for output generation. It calls the provided function or function object at generate time using its return value as the actual generator to produce the output.

Header
// forwards to <boost/spirit/home/karma/auxiliary/lazy.hpp>
#include <boost/spirit/include/karma_lazy.hpp>

Also, see Include Structure.

Namespace

Name

boost::spirit::lazy // alias: boost::spirit::karma::lazy

Model of

Generator

Notation

fg

A function or function object that evaluates to a generator object (an object exposing the Generator). This function will be invoked at generate time.

The signature of fg is expected to be

G f(Unused, Context)

where G, the function's return value, is the type of the generator to be invoked, and Context is the generators's Context type (The first argument is unused to make the Context the second argument. This is done for uniformity with Semantic Actions).

Expression Semantics

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

Expression

Semantics

fg

The Boost.Phoenix function object fg will be invoked at generate time. It is expected to return a generator instance. This generator is then invoked in order to generate the output. This generator will succeed as long as the invoked generated succeeds as well (unless the underlying output stream reports an error).

lazy(fg)

The function or function object will be invoked at generate time. It is expected to return a generator instance (note this version of lazy does not require fg to be a Boost.Phoenix function object). This generator is then invoked in order to generate the output. This generator will succeed as long as the invoked generated succeeds as well (except if the underlying output stream reports an error).

Attributes

Expression

Attribute

fg

The attribute type G as exposed by the generator g returned from fg.

lazy(fg)

The attribute type G as exposed by the generator g returned from fg.

Complexity

The complexity of the lazy component is determined by the complexity of the generator returned from fg.

Example
[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/phoenix_core.hpp>
#include <boost/spirit/include/phoenix_operator.hpp>
#include <boost/fusion/include/std_pair.hpp>
#include <iostream>
#include <string>

Some using declarations:

namespace karma = boost::spirit::karma;
using boost::spirit::karma::_1;
using boost::spirit::ascii::string;
using boost::phoenix::val;

Basic usage of the lazy generator:

test_generator_attr("abc", karma::lazy(val(string)), "abc");
test_generator("abc", karma::lazy(val(string))[_1 = "abc"]);


PrevUpHomeNext