Lines Matching full:generator
9 [section:directive Generator Directives]
11 This module includes different generator directives. It includes alignment
27 [section:alignment Alignment Generator Directives (`left_align[]`, `center[]`, `right_align[]`)]
33 an arbitrary generator to create the padding.
68 [[`a`] [A generator object]]
69 [[`pad`] [A generator object, or a __karma_lazy_argument__ that
70 evaluates to a generator object]]
87 the necessary padding. This generator succeeds as
88 long as its embedded generator `a` does not
93 the necessary padding. This generator succeeds as
94 long as its embedded generator `a` does not
100 (default: 10), while using the generator `pad`
101 to emit the necessary padding. This generator
107 the given `width`, while using the generator
109 generator succeeds as long as its embedded
118 the necessary padding. This generator succeeds as
119 long as its embedded generator `a` does not
124 the necessary padding. This generator succeeds as
125 long as its embedded generator `a` does not
131 (default: 10), while using the generator `pad`
132 to emit the necessary padding. This generator
138 the given `width`, while using the generator
140 generator succeeds as long as its embedded
149 the necessary padding. This generator succeeds as
150 long as its embedded generator `a` does not
155 the necessary padding. This generator succeeds as
156 long as its embedded generator `a` does not
162 (default: 10), while using the generator `pad`
163 to emit the necessary padding. This generator
169 the given `width`, while using the generator
171 generator succeeds as long as its embedded
177 [note None of the generator directives listed above limits the emitted output
238 [:The overall complexity of an alignment generator directive is defined by
239 the complexity of its embedded and padding generator. The complexity of the
240 left alignment directive generator itself is O(1). The complexity of the
264 [section:repeat Repetition Generator Directive (`repeat[]`)]
268 The repetition directive allows to repeat an arbitrary generator expression
270 a more powerful and flexible mechanism for repeating a generator. There are
299 [[`a`] [A generator object]]
314 [[`repeat[a]`] [Repeat the generator `a` zero or more times.
315 This generator succeeds as long as its
316 embedded generator `a` does not fail (except
321 [[`repeat(num)[a]`] [Repeat the generator `a` exactly `num`
322 times. This generator succeeds as long as its
323 embedded generator `a` does not fail and
328 [[`repeat(num1, num2)[a]`] [Repeat the generator `a` at least `num1`
330 generator succeeds as long as its
331 embedded generator `a` does not fail and
339 [[`repeat(num, inf)[a]`] [Repeat the generator `a` at least `num1`
341 is set. This generator succeeds as long as
342 its embedded generator `a` does not fail
349 [note All failing iterations of the embedded generator will consume one element
352 embedded generator) is fulfilled (unless the underlying output stream
382 any failing element generator might have already generated some output, which
391 which will /not/ generate any output in case of a failing generator
396 will not generate any partial output from a generator `a` if it fails
399 the generator `a`.]
403 [:The overall complexity of the repetition generator is defined by the
404 complexity of its embedded generator. The complexity of the repeat itself is
420 Basic usage of `repeat` generator directive:
427 [section:delimit Generator Directives Controlling Automatic Delimiting (`verbatim[]`, `no_delimit[]…
469 [[`a`] [A generator object]]
470 [[`d`] [A generator object, or a __karma_lazy_argument__ that
471 evaluates to a generator object]]
481 [[`delimit[a]`] [Enable automatic delimiting for the embedded generator
482 `a` while using the `space` generator as the
483 delimiting generator. If used inside a `verbatim[]`
484 directive it re-enables the delimiter generator as used
486 as long as the embedded generator succeeded (unless
488 [[`delimit(d)[a]`] [Enable automatic delimiting for the embedded generator
489 `a` while using the generator `d` as the
490 delimiting generator. The directive succeeds
491 as long as the embedded generator succeeded (unless
493 [[`verbatim[a]`] [Disable automatic delimiting for the embedded generator
495 as long as the embedded generator succeeded (unless
501 [[`no_delimit[a]`] [Disable automatic delimiting for the embedded generator
503 as long as the embedded generator succeeded (unless
533 [:The overall complexity of the generator directives `delimit[]`, `verbatim[]`,
550 Basic usage of `delimit` generator directive:
557 [section:upperlower Generator Directives Controlling Case Sensitivity (`upper[]`, `lower[]`)]
561 The generator directives `ns::lower[]` and `ns::upper[]` force their embedded
585 [:The model of `lower[]` and `upper[]` is the model of its subject generator.]
588 [[`a`] [A generator object]]
589 [[`A`] [Attribute type of the generator `a`]]
594 The `lower[]` and `upper[]` directives have no special generator semantics.
598 into the corresponding generator expression. This is achieved by the
618 __boost_proto__ expression into the corresponding generator expressions).
624 as long as the embedded generator succeeded (unless
628 as long as the embedded generator succeeded (unless
632 [note If both directives are 'active' with regard to a generator, the
660 [:The overall complexity of the generator directives `ns::lower[]` and `ns::upper[]`
678 Basic usage of the `upper` and `lower` generator directives:
685 [section:maxwidth Generator Directives Controlling the Maximum Field Width (`maxwidth[]`)]
690 output generated by the embedded generator.
709 [[`a`] [A generator object]]
710 [[`A`] [Attribute type of the generator `a`]]
723 the embedded generator (including characters
728 as the embedded generator succeeded (unless
731 the embedded generator (including characters
735 as the embedded generator succeeded (unless the
739 [note The `maxwidth[]` generator directive does not pad the generated output
769 [:The overall complexity of the generator directive `maxwidth[]`
770 is defined by the complexity of its embedded generator. The complexity of the
787 Basic usage of `maxwidth` generator directive:
794 [section:buffer Generator Directive for Temporary Output Buffering (`buffer[]`)]
798 All generator components (except the __karma_alternative__ generator) pass
799 their generated output directly to the underlying output stream. If a generator
801 buffering generator directive allows to avoid this unwanted output to be
803 generator into a buffer. This buffer is flushed to the underlying stream only
804 after the embedded generator succeeded, but is discarded otherwise.
823 [[`a`] [A generator object]]
824 [[`A`] [Attribute type of generator `a`]]]
833 [[`buffer[a]`] [The embedded generator `a` is invoked but its output
838 as long as the embedded generator succeeded (unless
842 [tip If you want to make the buffered generator succeed regardless of the
843 outcome of the embedded generator, simply wrap the `buffer[a]` into an
859 [:The overall complexity of the buffering generator directive is defined by the
860 complexity of its embedded generator. The complexity of the buffering
861 directive generator itself is O(N), where N is the number of characters
877 Basic usage of a buffering generator directive. It shows how the partial
879 as the plus generator fails (no data is available, see __karma_plus__).
886 [section:omit Generator Directives Consuming Attributes (`omit[]` and `skip[]`)]
891 embedded generator without generating any output. The `omit[]` directive
892 will still execute the embedded generator while discarding the generated output
893 afterwards. The `skip[]` directive will not execute the embedded generator, but
914 [[`a`] [A generator object]]
915 [[`A`] [Attribute type of generator `a`]]]
925 embedded generator `A` without generating any output.
926 It succeeds always. The embedded generator is executed
929 embedded generator `A` without generating any output.
930 It succeeds always. The embedded generator is not
951 of the embedded generator. The overall complexity of the `skip[]` generator
967 Basic usage of a `omit` generator directive. It shows how it consumes the first
969 second element of the attribute to the non-wrapped `double_` generator.
1004 directive, except that it does not actually execute the embedded generator.
1007 is very useful whenever the embedded generator produces side effects (has
1013 [section:duplicate Generator Directive Duplicating Attributes (`duplicate[]`)]
1018 embedded generator if this is a sequence generator. Otherwise it does nothing.
1037 [[`a`] [A generator object]]
1038 [[`A`] [Attribute type of generator `a`]]]
1049 generator. For all other types of embedded generators
1051 generator does not fail.]]
1066 If the embedded generator of the `duplicate[]` directive is a sequence it is
1077 of the embedded generator.]
1099 [section:columns Generator Directive Separating Output Into Columns (`columns[]`)]
1104 generator by inserting special column separators.
1123 [[`a`] [A generator object]]
1124 [[`g`] [A generator object, or a __karma_lazy_argument__ that
1125 evaluates to a generator object, will be used to emit column
1127 [[`A`] [Attribute type of generator `a`]
1140 [[`columns[a]`] [The `columns` directive invokes a generator after
1141 each N-th element of the embedded generator has been
1145 [[`columns(num)[a]`][The `columns` directive invokes a generator after
1146 each N-th element of the embedded generator has been
1150 [[`columns(g)[a]`] [The `columns` directive invokes a generator after
1151 each N-th element of the embedded generator has been
1155 [[`columns(num, g)[a]`] [The `columns` directive invokes a generator after
1156 each N-th element of the embedded generator has been
1184 [:The overall complexity of the `columns` generator directive depends on the
1185 complexity of the embedded generator. The complexity of the `columns` generator
1209 [section:as Generator Directives Forcing Atomic Extraction (`as<T>, as_string[], as_wstring[]`)]
1221 determine validity; if it returns false, the generator fails. Subsequent
1271 invoke the subject generator `a`, supplying
1288 [:The complexity is defined by the complexity of the subject generator, `a`, and