В предыдущем разделе мы показали, как форматировать сложное число (т.е. пару дублей). В этом разделе мы будем опираться на этот пример с целью избежать использования семантических действий в спецификации формата. Давайте сначала рассмотрим полученный код, пытаясь понять его позже (полный исходный файл для этого примера можно найти здесь:complex_number_easier.cpp):

template <typename OutputIterator>
bool generate_complex(OutputIterator sink, std::complex<double> const& c)
{
    using boost::spirit::karma::double_;
    using boost::spirit::karma::omit;
    using boost::spirit::karma::generate;
    return generate(sink,
        //  Begin grammar
        (
           !double_(0.0) << '(' << double_ << ", " << double_ << ')'
        |   omit[double_] << double_
        ),
        //  End grammar
        c.imag(), c.real(), c.imag()     //  Data to output
    );
}

Давайте сначала рассмотрим некоторые основные функции библиотеки.

Making Numeric Generators Fail

Всечисленные генераторы(такие как<double_>, и т.д.) принимают значение для выделения из прикрепленного атрибута.

double d = 1.5;
generate(out, double_, d);       // will emit '1.5' (without the quotes)

В качестве альтернативы они могут быть инициализированы из буквального значения. Например, чтобы излучать постоянную<1.5>, вы можете написать:

generate(out, double_(1.5));     // will emit '1.5' as well (without the quotes)

Отличие от простого<1.5>или<lit(1.5)>заключается в том, что<double_(1.5)>потребляет атрибут, если он доступен. Кроме того, он сравнивает свою непосредственную стоимость со стоимостью поставляемого атрибута и терпит неудачу, если они не равны.

double d = 1.5;
generate(out, double_(1.5), d);  // will emit '1.5' as long as d == 1.5

Эта особенность, а именно успешное генерирование только в том случае, если атрибут соответствует непосредственному значению, позволяет использовать численные генераторы для динамического управления способом генерации вывода.

	Note
	Несколько генераторов потерпят неудачу, если их непосредственное значение не будет равно поставляемому атрибуту. Среди них всегенераторы символови всегенераторы струн. Как правило, все генераторы, имеющие родного брата, созданного вариантом<lit()>, относятся к этой категории.

Predicates - The Conditionals for Output Generators

В дополнение к<eps>генератор, упомянутый ранееДух. Кармапредоставляет два специальных оператора, обеспечивающих динамическое управление потоком:И предикат<&>иНе предикат<!>. Основное свойство обоих предикатов — отбрасывать весь выход, испускаемый прикрепленным генератором. Это эквивалентно поведению предикатов, используемых для разбора. Там предикаты не потребляют никаких входных данных, позволяющих заглянуть вперед во входной поток. В Карме предикат и предикат преуспевают до тех пор, пока преуспевает его ассоциированный генератор, в то время как не предикат преуспевает, только если ассоциированный генератор терпит неудачу.

Note

Генератор предикатов вДух. Кармапотребляет атрибут, если таковой имеется. Это заставляет их вести себя иначе, чем предикаты вДухе.Qi, где они не выставляют никакого атрибута. Это связано с тем, что предикаты позволяют принимать решения на основе данных, доступных только во время выполнения. При этом вSpirit.Qiпри разборе решения принимается на основе взгляда вперед еще несколько входных токенов, вДух.Критерии должны быть предоставлены пользователем. Самый простой способ сделать это — предоставить атрибут.

В качестве примера, следующий генератор успешно генерирует:

double d = 1.0;
BOOST_ASSERT(generate(out, &double_(1.0), d));    // succeeds as d == 1.0

А вот этот провалится:

double d = 1.0;
BOOST_ASSERT(!generate(out, !double_(1.0), d));   // fails as d == 1.0

Ни один из них не будет выделять какой-либо выход. Предикаты отбрасывают все излучаемое генераторами, к которым они применяются.

Ignoring Supplied Attributes

Иногда желательно «пропустить» (т.е. игнорировать) предоставленный атрибут. Это происходит, например, в альтернативных генераторах, где некоторые из альтернатив должны извлечь только часть общего атрибута, переданного альтернативному генератору.Дух.Кармаимеет для этого специальный псевдогенератор: директива<omit><[]>. Эта директива потребляет атрибут типа, определенного встроенным генератором, но не испускает никакого вывода.

	Note
	Дух. Карма<omit>директива делает "противоположность" директивы того же самого имени вДух.Qi.<omit>в.Дух.Qiпотребляет вход без раскрытия атрибута, егоДух. Кармапотребляет атрибут, не испуская никакого выхода.

Putting everything together

Очень похожий на наш первый пример, мы используем две альтернативы, чтобы разрешить два различных формата вывода в зависимости от того, равна ли мнимая часть комплексного числа нулю или нет. Первая альтернатива выполняется, если мнимая часть не равна нулю, вторая альтернатива — иначе. На этот раз мы принимаем решение во время выполнения с использованиемНе предиката<!>в сочетании с особенностью многих примитивных генераторов кармы, чтобыне работалипри определенных условиях. Вот первая альтернатива для вашей ссылки:

!double_(0.0) << '(' << double_ << ", " << double_ << ')'

Генератор<!double_(0.0)>делает несколько вещей. Во-первых, из-заНе предиката<!>, он преуспевает только в том случае, если<double_(0.0)>генераторвыходит из строя, в результате чего вся первая альтернатива выходит из строя иначе. Во-вторых, генератор<double_(0.0)>преуспевает только в том случае, если значение его атрибута равно его непосредственному параметру (т.е. в данном случае<0.0>). И в-третьих, не предикат не испускает никакого выхода (независимо от того, преуспевает он или терпит неудачу), отбрасывая любой возможно испущенный выход из<double_(0.0)>.

Когда мы передаем мнимую часть комплексного числа в качестве значения атрибута для<!double_(0.0)>, общая первая альтернатива будет выбрана только в том случае, если она не равна нулю (<!double_(0.0)>не терпит неудачу). Это именно то, что нам нужно!

Теперь второй вариант должен излучать только реальную часть комплексного числа. Чтобы упростить общую грамматику, мы стремимся объединить типы атрибутов всех альтернатив. Так как тип атрибута, раскрытый первой альтернативой<tuple<double,double,double>>, нам нужно пропустить первый и последний элемент атрибута (помните, мы передаем реальную часть как второй элемент атрибута). Для этого мы используем директиву<omit[]>:

omit[double_] << double_ << omit[double_]

Общий атрибут этого выражения<tuple<double,double,double>>, но<omit[]>«съедает» первый и последний элемент. Выход, испускаемый этим выражением, состоит из одного сгенерированного двойника, представляющего второй элемент кортежа, т.е. реальную часть нашего комплексного числа.

Important

Обычно предпочтительнее использовать генераторные конструкции, не требующие семантических действий. Причина в том, что семантические действия часто используют конструкции типа:<double_[_1=c.real()]>. Но это задание настоящее! Данные фактическископированына значение атрибута генератора, прикрепленного к действию. С другой стороны, грамматика без каких-либо семантических действий обычно не должна копировать атрибуты, делая их более эффективными.