Attribute Transformation Pseudo Parser (attr_cast)

Attribute Transformation Pseudo Parser (`attr_cast`)

Description

The attr_cast<Exposed, Transformed>() component invokes the embedded parser 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/qi/auxiliary/attr_cast.hpp>
#include <boost/spirit/include/qi_attr_cast.hpp>

Also, see Include Structure.

Namespace

Name
`boost::spirit::attr_cast // alias: boost::spirit::qi::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 parser `p`.	`unused_type`

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

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

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

Model of

UnaryParser

Notation

p: A parser object.

Expression Semantics

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

Expression	Semantics
`attr_cast(p)`	Create a component invoking the parser `p` while passing an attribute of the type as normally expected by `p`. The type of the supplied attribute will be transformed to the type `p` exposes as its attribute type (by using the attribute customization point `traits::transform_attribute`).
`attr_cast<Exposed>(p)`	Create a component invoking the parser `p` while passing an attribute of the type as normally expected by `p`. The supplied attribute is expected to be of the type `Exposed`, it will be transformed to the type `p` exposes as its attribute type (using the attribute customization point `traits::transform_attribute`).
`attr_cast<Exposed, Transformed>(p)`	Create a component invoking the parser `p` 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`).

Attributes

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

Complexity

The complexity of this component is fully defined by the complexity of the embedded parser p.

Example

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

Some using declarations:

using boost::spirit::qi::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
{
    // in this case we just expose the embedded 'int' as the attribute instance
    // to use, allowing to leave the function 'post()' empty
    template <>
    struct transform_attribute<int_data, int, qi::domain>
    {
        typedef int& type;
        static int& pre(int_data& d) { return d.i; }
        static void post(int_data& val, int const& attr) {}
        static void fail(int_data&) {}
    };
}}}

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

int_data d = { 0 };
test_parser_attr("1", boost::spirit::qi::attr_cast(int_), d);
std::cout << d.i << std::endl;