Attribute Transformation Pseudo Generator (attr_cast)

Attribute Transformation Pseudo Generator (`attr_cast`)

Description

The attr_cast<Exposed, Transformed>() component invokes the embedded generator while supplying an attribute of type Transformed. The supplied attribute gets created from the original attribute (of type Exposed) passed to this component using the customization point traits::transform_attribute.

Header

// forwards to <boost/spirit/home/karma/auxiliary/attr_cast.hpp>
#include <boost/spirit/include/karma_attr_cast.hpp>

Also, see Include Structure.

Namespace

Name
`boost::spirit::attr_cast // alias: boost::spirit::karma::attr_cast`

Synopsis

template <Exposed, Transformed>
<unspecified> attr_cast(<unspecified>);

Template parameters

Parameter	Description	Default
`Exposed`	The type of the attribute supplied to the `attr_cast`.	`unused_type`
`Transformed`	The type of the attribute expected by the embedded generator `g`.	`unused_type`

The attr_cast is a function template. It is possible to invoke it using the following schemes:

attr_cast(g)
attr_cast<Exposed>(g)
attr_cast<Exposed, Transformed>(g)

depending on which of the attribute types can be deduced properly if not explicitly specified.

Model of

UnaryGenerator

Notation

g: A generator object.

Expression Semantics

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

Expression	Semantics
`attr_cast(g)`	Create a component invoking the generator `g` while passing an attribute of the type as normally expected by `g`. The type of the supplied attribute will be transformed to the type `g` exposes as its attribute type (by using the attribute customization point `traits::transform_attribute`). This generator does not fail unless `g` fails.
`attr_cast<Exposed>(g)`	Create a component invoking the generator `g` while passing an attribute of the type as normally expected by `g`. The supplied attribute is expected to be of the type `Exposed`, it will be transformed to the type `g` exposes as its attribute type (using the attribute customization point `traits::transform_attribute`). This generator does not fail unless `g` fails.
`attr_cast<Exposed, Transformed>(g)`	Create a component invoking the generator `g` while passing an attribute of type `Transformed`. The supplied attribute is expected to be of the type `Exposed`, it will be transformed to the type `Transformed` (using the attribute customization point `traits::transform_attribute`). This generator does not fail unless `g` fails.

Attributes

Expression	Attribute
`attr_cast(g)`	`g: A --> attr_cast(g): A`
`attr_cast<Exposed>(g)`	`g: A --> attr_cast<Exposed>(g): Exposed`
`attr_cast<Exposed, Transformed>(g)`	`g: A --> attr_cast<Exposed, Transformed>(g): Exposed`

Complexity

The complexity of this component is fully defined by the complexity of the embedded generator g.

Example

	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/phoenix/core.hpp>
#include <boost/phoenix/operator.hpp>
#include <boost/fusion/include/std_pair.hpp>
#include <boost/proto/deep_copy.hpp>
#include <iostream>
#include <string>

Some using declarations:

using boost::spirit::karma::int_;

The example references data structure int_data which needs a specialization of the customization point traits::transform_attribute:

// this is just a test structure we want to use in place of an int
struct int_data
{
    int i;
};

// we provide a custom attribute transformation to allow its use as an int
namespace boost { namespace spirit { namespace traits
{
    template <>
    struct transform_attribute<int_data const, int, karma::domain>
    {
        typedef int type;
        static int pre(int_data const& d) { return d.i; }
    };
}}}

Now we use the attr_cast pseudo generator to invoke the attribute transformation:

int_data d = { 1 };
test_generator_attr("1", boost::spirit::karma::attr_cast(int_), d);