as_expr.g.cc

Go to the documentation of this file.

// This file is automatically generated, do not edit.

#include <lestes/lang/cplus/sem/as_visitor.v.g.hh>
#include <lestes/lang/cplus/sem/as_decl.g.hh>
#include <lestes/lang/cplus/sem/as_statements.g.hh>
#include <lestes/lang/cplus/lex/cpp_token.hh>

#include <lestes/std/list.hh>
#include <lestes/std/pair.hh>
#include <lestes/std/reflect.hh>

#include <lestes/lang/cplus/sem/as_expr.g.hh>

package(lestes);
package(lang);
package(cplus);
package(sem);


// ------------- Class as_expression follows. -------------

/*!
   Generated constructor for class as_expression.
   \author lsg
 */
as_expression::as_expression (ptr< ::lestes::std::source_location > a__as_base__location)
        : as_base(a__as_base__location)
{}

ptr< object::reflection_list > as_expression::reflection_get() const
{
        if (!reflection) {
                typedef class_reflection::field_metadata md;
                typedef class_reflection::field_metadata_list mdlist;
                ptr<mdlist> mdl = mdlist::create();
                reflection = reflection_list::create( ::lestes::intercode::as_base::reflection_get() );
                reflection->push_back( class_reflection::create( "as_expression", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_expression::field_values_get() const
{
        ptr < field_list_list > result = ::lestes::intercode::as_base::field_values_get();
        return result;
}


/*!
   Marking routine is used for garbage collection.
   \author lsg
 */
void as_expression::gc_mark()
{
	::lestes::intercode::as_base::gc_mark();
}

// End of class as_expression.

// ------------- Class as_empty_expression follows. -------------

void as_empty_expression::accept_as_expr_visitor( ptr< as_expr_visitor > v )
{
        return v->visit_as_empty_expression( this );
}

/*!
   This factory method for class as_empty_expression takes values of all fields as arguments.
   \author lsg
 */
ptr< as_empty_expression > as_empty_expression::create(ptr< ::lestes::std::source_location > a__as_base__location)
{
        return ptr< as_empty_expression > ( new as_empty_expression(a__as_base__location) );
}

/*!
   Generated constructor for class as_empty_expression.
   \author lsg
 */
as_empty_expression::as_empty_expression (ptr< ::lestes::std::source_location > a__as_base__location)
        : as_expression(a__as_base__location)
{}

ptr< object::reflection_list > as_empty_expression::reflection_get() const
{
        if (!reflection) {
                typedef class_reflection::field_metadata md;
                typedef class_reflection::field_metadata_list mdlist;
                ptr<mdlist> mdl = mdlist::create();
                reflection = reflection_list::create( as_expression::reflection_get() );
                reflection->push_back( class_reflection::create( "as_empty_expression", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_empty_expression::field_values_get() const
{
        ptr < field_list_list > result = as_expression::field_values_get();
        return result;
}


/*!
   Marking routine is used for garbage collection.
   \author lsg
 */
void as_empty_expression::gc_mark()
{
        as_expression::gc_mark();
}

// End of class as_empty_expression.

// ------------- Class as_binary_expression follows. -------------

/*!
   \returns The value of as_binary_expression::left.
   \author lsg
 */
ptr< as_expression > as_binary_expression::left_get() const
{
        return left;
}

/*!
   \param[in] x The new value to set as_binary_expression::left to.
   \author lsg
 */
void as_binary_expression::left_set(const ptr< as_expression > & x)
{
        as_binary_expression::left = x;
}

/*!
   \returns The value of as_binary_expression::right.
   \author lsg
 */
ptr< as_expression > as_binary_expression::right_get() const
{
        return right;
}

/*!
   \param[in] x The new value to set as_binary_expression::right to.
   \author lsg
 */
void as_binary_expression::right_set(const ptr< as_expression > & x)
{
        as_binary_expression::right = x;
}

/*!
   Generated constructor for class as_binary_expression.
   \author lsg
 */
as_binary_expression::as_binary_expression (ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_expression > a__as_binary_expression__left,
                ptr< as_expression > a__as_binary_expression__right)
        : as_expression(a__as_base__location), left(checked(a__as_binary_expression__left)), right(checked(a__as_binary_expression__right))
{}

ptr< object::reflection_list > as_binary_expression::reflection_get() const
{
        if (!reflection) {
                typedef class_reflection::field_metadata md;
                typedef class_reflection::field_metadata_list mdlist;
                ptr<mdlist> mdl = mdlist::create();
                mdl->push_back( md::create( "left", "as_expression" ) );
                mdl->push_back( md::create( "right", "as_expression" ) );
                reflection = reflection_list::create( as_expression::reflection_get() );
                reflection->push_back( class_reflection::create( "as_binary_expression", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_binary_expression::field_values_get() const
{
        ptr < field_list_list > result = as_expression::field_values_get();
        result->push_back( value_list::create() );
        result->back()->push_back( this->left );
        result->push_back( value_list::create() );
        result->back()->push_back( this->right );
        return result;
}


/*!
   Marking routine is used for garbage collection.
   \author lsg
 */
void as_binary_expression::gc_mark()
{
        as_expression::gc_mark();
}

// End of class as_binary_expression.

// ------------- Class as_unary_expression follows. -------------

/*!
   \returns The value of as_unary_expression::expr.
   \author lsg
 */
ptr< as_expression > as_unary_expression::expr_get() const
{
        return expr;
}

/*!
   \param[in] x The new value to set as_unary_expression::expr to.
   \author lsg
 */
void as_unary_expression::expr_set(const ptr< as_expression > & x)
{
        as_unary_expression::expr = x;
}

/*!
   Generated constructor for class as_unary_expression.
   \author lsg
 */
as_unary_expression::as_unary_expression (ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_expression > a__as_unary_expression__expr)
        : as_expression(a__as_base__location), expr(checked(a__as_unary_expression__expr))
{}

ptr< object::reflection_list > as_unary_expression::reflection_get() const
{
        if (!reflection) {
                typedef class_reflection::field_metadata md;
                typedef class_reflection::field_metadata_list mdlist;
                ptr<mdlist> mdl = mdlist::create();
                mdl->push_back( md::create( "expr", "as_expression" ) );
                reflection = reflection_list::create( as_expression::reflection_get() );
                reflection->push_back( class_reflection::create( "as_unary_expression", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_unary_expression::field_values_get() const
{
        ptr < field_list_list > result = as_expression::field_values_get();
        result->push_back( value_list::create() );
        result->back()->push_back( this->expr );
        return result;
}


/*!
   Marking routine is used for garbage collection.
   \author lsg
 */
void as_unary_expression::gc_mark()
{
        as_expression::gc_mark();
}

// End of class as_unary_expression.

// ------------- Class as_ternary_expression follows. -------------

/*!
   \returns The value of as_ternary_expression::first.
   \author lsg
 */
ptr< as_expression > as_ternary_expression::first_get() const
{
        return first;
}

/*!
   \param[in] x The new value to set as_ternary_expression::first to.
   \author lsg
 */
void as_ternary_expression::first_set(const ptr< as_expression > & x)
{
        as_ternary_expression::first = x;
}

/*!
   \returns The value of as_ternary_expression::second.
   \author lsg
 */
ptr< as_expression > as_ternary_expression::second_get() const
{
        return second;
}

/*!
   \param[in] x The new value to set as_ternary_expression::second to.
   \author lsg
 */
void as_ternary_expression::second_set(const ptr< as_expression > & x)
{
        as_ternary_expression::second = x;
}

/*!
   \returns The value of as_ternary_expression::third.
   \author lsg
 */
ptr< as_expression > as_ternary_expression::third_get() const
{
        return third;
}

/*!
   \param[in] x The new value to set as_ternary_expression::third to.
   \author lsg
 */
void as_ternary_expression::third_set(const ptr< as_expression > & x)
{
        as_ternary_expression::third = x;
}

/*!
   Generated constructor for class as_ternary_expression.
   \author lsg
 */
as_ternary_expression::as_ternary_expression (ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_expression > a__as_ternary_expression__first,
                ptr< as_expression > a__as_ternary_expression__second,
                ptr< as_expression > a__as_ternary_expression__third)
        : as_expression(a__as_base__location), first(checked(a__as_ternary_expression__first)), second(checked(a__as_ternary_expression__second)), third(checked(a__as_ternary_expression__third))
{}

ptr< object::reflection_list > as_ternary_expression::reflection_get() const
{
        if (!reflection) {
                typedef class_reflection::field_metadata md;
                typedef class_reflection::field_metadata_list mdlist;
                ptr<mdlist> mdl = mdlist::create();
                mdl->push_back( md::create( "first", "as_expression" ) );
                mdl->push_back( md::create( "second", "as_expression" ) );
                mdl->push_back( md::create( "third", "as_expression" ) );
                reflection = reflection_list::create( as_expression::reflection_get() );
                reflection->push_back( class_reflection::create( "as_ternary_expression", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_ternary_expression::field_values_get() const
{
        ptr < field_list_list > result = as_expression::field_values_get();
        result->push_back( value_list::create() );
        result->back()->push_back( this->first );
        result->push_back( value_list::create() );
        result->back()->push_back( this->second );
        result->push_back( value_list::create() );
        result->back()->push_back( this->third );
        return result;
}


/*!
   Marking routine is used for garbage collection.
   \author lsg
 */
void as_ternary_expression::gc_mark()
{
        as_expression::gc_mark();
}

// End of class as_ternary_expression.

// ------------- Class as_expression_qmark follows. -------------

void as_expression_qmark::accept_as_expr_visitor( ptr< as_expr_visitor > v )
{
        return v->visit_as_expression_qmark( this );
}

/*!
   This factory method for class as_expression_qmark takes values of all fields as arguments.
   \author lsg
 */
ptr< as_expression_qmark > as_expression_qmark::create(ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_expression > a__as_ternary_expression__first,
                ptr< as_expression > a__as_ternary_expression__second,
                ptr< as_expression > a__as_ternary_expression__third)
{
        return ptr< as_expression_qmark > ( new as_expression_qmark(a__as_base__location,
                a__as_ternary_expression__first,
                a__as_ternary_expression__second,
                a__as_ternary_expression__third) );
}

/*!
   Generated constructor for class as_expression_qmark.
   \author lsg
 */
as_expression_qmark::as_expression_qmark (ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_expression > a__as_ternary_expression__first,
                ptr< as_expression > a__as_ternary_expression__second,
                ptr< as_expression > a__as_ternary_expression__third)
        : as_ternary_expression(a__as_base__location,
                a__as_ternary_expression__first,
                a__as_ternary_expression__second,
                a__as_ternary_expression__third)
{}

ptr< object::reflection_list > as_expression_qmark::reflection_get() const
{
        if (!reflection) {
                typedef class_reflection::field_metadata md;
                typedef class_reflection::field_metadata_list mdlist;
                ptr<mdlist> mdl = mdlist::create();
                reflection = reflection_list::create( as_ternary_expression::reflection_get() );
                reflection->push_back( class_reflection::create( "as_expression_qmark", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_expression_qmark::field_values_get() const
{
        ptr < field_list_list > result = as_ternary_expression::field_values_get();
        return result;
}


/*!
   Marking routine is used for garbage collection.
   \author lsg
 */
void as_expression_qmark::gc_mark()
{
        as_ternary_expression::gc_mark();
}

// End of class as_expression_qmark.

// ------------- Class as_expression_comma follows. -------------

void as_expression_comma::accept_as_expr_visitor( ptr< as_expr_visitor > v )
{
        return v->visit_as_expression_comma( this );
}

/*!
   This factory method for class as_expression_comma takes values of all fields as arguments.
   \author lsg
 */
ptr< as_expression_comma > as_expression_comma::create(ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_expression > a__as_binary_expression__left,
                ptr< as_expression > a__as_binary_expression__right)
{
        return ptr< as_expression_comma > ( new as_expression_comma(a__as_base__location,
                a__as_binary_expression__left,
                a__as_binary_expression__right) );
}

/*!
   Generated constructor for class as_expression_comma.
   \author lsg
 */
as_expression_comma::as_expression_comma (ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_expression > a__as_binary_expression__left,
                ptr< as_expression > a__as_binary_expression__right)
        : as_binary_expression(a__as_base__location,
                a__as_binary_expression__left,
                a__as_binary_expression__right)
{}

ptr< object::reflection_list > as_expression_comma::reflection_get() const
{
        if (!reflection) {
                typedef class_reflection::field_metadata md;
                typedef class_reflection::field_metadata_list mdlist;
                ptr<mdlist> mdl = mdlist::create();
                reflection = reflection_list::create( as_binary_expression::reflection_get() );
                reflection->push_back( class_reflection::create( "as_expression_comma", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_expression_comma::field_values_get() const
{
        ptr < field_list_list > result = as_binary_expression::field_values_get();
        return result;
}


/*!
   Marking routine is used for garbage collection.
   \author lsg
 */
void as_expression_comma::gc_mark()
{
        as_binary_expression::gc_mark();
}

// End of class as_expression_comma.

// ------------- Class as_expression_equal follows. -------------

void as_expression_equal::accept_as_expr_visitor( ptr< as_expr_visitor > v )
{
        return v->visit_as_expression_equal( this );
}

/*!
   This factory method for class as_expression_equal takes values of all fields as arguments.
   \author lsg
 */
ptr< as_expression_equal > as_expression_equal::create(ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_expression > a__as_binary_expression__left,
                ptr< as_expression > a__as_binary_expression__right)
{
        return ptr< as_expression_equal > ( new as_expression_equal(a__as_base__location,
                a__as_binary_expression__left,
                a__as_binary_expression__right) );
}

/*!
   Generated constructor for class as_expression_equal.
   \author lsg
 */
as_expression_equal::as_expression_equal (ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_expression > a__as_binary_expression__left,
                ptr< as_expression > a__as_binary_expression__right)
        : as_binary_expression(a__as_base__location,
                a__as_binary_expression__left,
                a__as_binary_expression__right)
{}

ptr< object::reflection_list > as_expression_equal::reflection_get() const
{
        if (!reflection) {
                typedef class_reflection::field_metadata md;
                typedef class_reflection::field_metadata_list mdlist;
                ptr<mdlist> mdl = mdlist::create();
                reflection = reflection_list::create( as_binary_expression::reflection_get() );
                reflection->push_back( class_reflection::create( "as_expression_equal", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_expression_equal::field_values_get() const
{
        ptr < field_list_list > result = as_binary_expression::field_values_get();
        return result;
}


/*!
   Marking routine is used for garbage collection.
   \author lsg
 */
void as_expression_equal::gc_mark()
{
        as_binary_expression::gc_mark();
}

// End of class as_expression_equal.

// ------------- Class as_expression_plus_equal follows. -------------

void as_expression_plus_equal::accept_as_expr_visitor( ptr< as_expr_visitor > v )
{
        return v->visit_as_expression_plus_equal( this );
}

/*!
   This factory method for class as_expression_plus_equal takes values of all fields as arguments.
   \author lsg
 */
ptr< as_expression_plus_equal > as_expression_plus_equal::create(ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_expression > a__as_binary_expression__left,
                ptr< as_expression > a__as_binary_expression__right)
{
        return ptr< as_expression_plus_equal > ( new as_expression_plus_equal(a__as_base__location,
                a__as_binary_expression__left,
                a__as_binary_expression__right) );
}

/*!
   Generated constructor for class as_expression_plus_equal.
   \author lsg
 */
as_expression_plus_equal::as_expression_plus_equal (ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_expression > a__as_binary_expression__left,
                ptr< as_expression > a__as_binary_expression__right)
        : as_binary_expression(a__as_base__location,
                a__as_binary_expression__left,
                a__as_binary_expression__right)
{}

ptr< object::reflection_list > as_expression_plus_equal::reflection_get() const
{
        if (!reflection) {
                typedef class_reflection::field_metadata md;
                typedef class_reflection::field_metadata_list mdlist;
                ptr<mdlist> mdl = mdlist::create();
                reflection = reflection_list::create( as_binary_expression::reflection_get() );
                reflection->push_back( class_reflection::create( "as_expression_plus_equal", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_expression_plus_equal::field_values_get() const
{
        ptr < field_list_list > result = as_binary_expression::field_values_get();
        return result;
}


/*!
   Marking routine is used for garbage collection.
   \author lsg
 */
void as_expression_plus_equal::gc_mark()
{
        as_binary_expression::gc_mark();
}

// End of class as_expression_plus_equal.

// ------------- Class as_expression_minus_equal follows. -------------

void as_expression_minus_equal::accept_as_expr_visitor( ptr< as_expr_visitor > v )
{
        return v->visit_as_expression_minus_equal( this );
}

/*!
   This factory method for class as_expression_minus_equal takes values of all fields as arguments.
   \author lsg
 */
ptr< as_expression_minus_equal > as_expression_minus_equal::create(ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_expression > a__as_binary_expression__left,
                ptr< as_expression > a__as_binary_expression__right)
{
        return ptr< as_expression_minus_equal > ( new as_expression_minus_equal(a__as_base__location,
                a__as_binary_expression__left,
                a__as_binary_expression__right) );
}

/*!
   Generated constructor for class as_expression_minus_equal.
   \author lsg
 */
as_expression_minus_equal::as_expression_minus_equal (ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_expression > a__as_binary_expression__left,
                ptr< as_expression > a__as_binary_expression__right)
        : as_binary_expression(a__as_base__location,
                a__as_binary_expression__left,
                a__as_binary_expression__right)
{}

ptr< object::reflection_list > as_expression_minus_equal::reflection_get() const
{
        if (!reflection) {
                typedef class_reflection::field_metadata md;
                typedef class_reflection::field_metadata_list mdlist;
                ptr<mdlist> mdl = mdlist::create();
                reflection = reflection_list::create( as_binary_expression::reflection_get() );
                reflection->push_back( class_reflection::create( "as_expression_minus_equal", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_expression_minus_equal::field_values_get() const
{
        ptr < field_list_list > result = as_binary_expression::field_values_get();
        return result;
}


/*!
   Marking routine is used for garbage collection.
   \author lsg
 */
void as_expression_minus_equal::gc_mark()
{
        as_binary_expression::gc_mark();
}

// End of class as_expression_minus_equal.

// ------------- Class as_expression_star_equal follows. -------------

void as_expression_star_equal::accept_as_expr_visitor( ptr< as_expr_visitor > v )
{
        return v->visit_as_expression_star_equal( this );
}

/*!
   This factory method for class as_expression_star_equal takes values of all fields as arguments.
   \author lsg
 */
ptr< as_expression_star_equal > as_expression_star_equal::create(ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_expression > a__as_binary_expression__left,
                ptr< as_expression > a__as_binary_expression__right)
{
        return ptr< as_expression_star_equal > ( new as_expression_star_equal(a__as_base__location,
                a__as_binary_expression__left,
                a__as_binary_expression__right) );
}

/*!
   Generated constructor for class as_expression_star_equal.
   \author lsg
 */
as_expression_star_equal::as_expression_star_equal (ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_expression > a__as_binary_expression__left,
                ptr< as_expression > a__as_binary_expression__right)
        : as_binary_expression(a__as_base__location,
                a__as_binary_expression__left,
                a__as_binary_expression__right)
{}

ptr< object::reflection_list > as_expression_star_equal::reflection_get() const
{
        if (!reflection) {
                typedef class_reflection::field_metadata md;
                typedef class_reflection::field_metadata_list mdlist;
                ptr<mdlist> mdl = mdlist::create();
                reflection = reflection_list::create( as_binary_expression::reflection_get() );
                reflection->push_back( class_reflection::create( "as_expression_star_equal", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_expression_star_equal::field_values_get() const
{
        ptr < field_list_list > result = as_binary_expression::field_values_get();
        return result;
}


/*!
   Marking routine is used for garbage collection.
   \author lsg
 */
void as_expression_star_equal::gc_mark()
{
        as_binary_expression::gc_mark();
}

// End of class as_expression_star_equal.

// ------------- Class as_expression_slash_equal follows. -------------

void as_expression_slash_equal::accept_as_expr_visitor( ptr< as_expr_visitor > v )
{
        return v->visit_as_expression_slash_equal( this );
}

/*!
   This factory method for class as_expression_slash_equal takes values of all fields as arguments.
   \author lsg
 */
ptr< as_expression_slash_equal > as_expression_slash_equal::create(ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_expression > a__as_binary_expression__left,
                ptr< as_expression > a__as_binary_expression__right)
{
        return ptr< as_expression_slash_equal > ( new as_expression_slash_equal(a__as_base__location,
                a__as_binary_expression__left,
                a__as_binary_expression__right) );
}

/*!
   Generated constructor for class as_expression_slash_equal.
   \author lsg
 */
as_expression_slash_equal::as_expression_slash_equal (ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_expression > a__as_binary_expression__left,
                ptr< as_expression > a__as_binary_expression__right)
        : as_binary_expression(a__as_base__location,
                a__as_binary_expression__left,
                a__as_binary_expression__right)
{}

ptr< object::reflection_list > as_expression_slash_equal::reflection_get() const
{
        if (!reflection) {
                typedef class_reflection::field_metadata md;
                typedef class_reflection::field_metadata_list mdlist;
                ptr<mdlist> mdl = mdlist::create();
                reflection = reflection_list::create( as_binary_expression::reflection_get() );
                reflection->push_back( class_reflection::create( "as_expression_slash_equal", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_expression_slash_equal::field_values_get() const
{
        ptr < field_list_list > result = as_binary_expression::field_values_get();
        return result;
}


/*!
   Marking routine is used for garbage collection.
   \author lsg
 */
void as_expression_slash_equal::gc_mark()
{
        as_binary_expression::gc_mark();
}

// End of class as_expression_slash_equal.

// ------------- Class as_expression_percent_equal follows. -------------

void as_expression_percent_equal::accept_as_expr_visitor( ptr< as_expr_visitor > v )
{
        return v->visit_as_expression_percent_equal( this );
}

/*!
   This factory method for class as_expression_percent_equal takes values of all fields as arguments.
   \author lsg
 */
ptr< as_expression_percent_equal > as_expression_percent_equal::create(ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_expression > a__as_binary_expression__left,
                ptr< as_expression > a__as_binary_expression__right)
{
        return ptr< as_expression_percent_equal > ( new as_expression_percent_equal(a__as_base__location,
                a__as_binary_expression__left,
                a__as_binary_expression__right) );
}

/*!
   Generated constructor for class as_expression_percent_equal.
   \author lsg
 */
as_expression_percent_equal::as_expression_percent_equal (ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_expression > a__as_binary_expression__left,
                ptr< as_expression > a__as_binary_expression__right)
        : as_binary_expression(a__as_base__location,
                a__as_binary_expression__left,
                a__as_binary_expression__right)
{}

ptr< object::reflection_list > as_expression_percent_equal::reflection_get() const
{
        if (!reflection) {
                typedef class_reflection::field_metadata md;
                typedef class_reflection::field_metadata_list mdlist;
                ptr<mdlist> mdl = mdlist::create();
                reflection = reflection_list::create( as_binary_expression::reflection_get() );
                reflection->push_back( class_reflection::create( "as_expression_percent_equal", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_expression_percent_equal::field_values_get() const
{
        ptr < field_list_list > result = as_binary_expression::field_values_get();
        return result;
}


/*!
   Marking routine is used for garbage collection.
   \author lsg
 */
void as_expression_percent_equal::gc_mark()
{
        as_binary_expression::gc_mark();
}

// End of class as_expression_percent_equal.

// ------------- Class as_expression_hat_equal follows. -------------

void as_expression_hat_equal::accept_as_expr_visitor( ptr< as_expr_visitor > v )
{
        return v->visit_as_expression_hat_equal( this );
}

/*!
   This factory method for class as_expression_hat_equal takes values of all fields as arguments.
   \author lsg
 */
ptr< as_expression_hat_equal > as_expression_hat_equal::create(ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_expression > a__as_binary_expression__left,
                ptr< as_expression > a__as_binary_expression__right)
{
        return ptr< as_expression_hat_equal > ( new as_expression_hat_equal(a__as_base__location,
                a__as_binary_expression__left,
                a__as_binary_expression__right) );
}

/*!
   Generated constructor for class as_expression_hat_equal.
   \author lsg
 */
as_expression_hat_equal::as_expression_hat_equal (ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_expression > a__as_binary_expression__left,
                ptr< as_expression > a__as_binary_expression__right)
        : as_binary_expression(a__as_base__location,
                a__as_binary_expression__left,
                a__as_binary_expression__right)
{}

ptr< object::reflection_list > as_expression_hat_equal::reflection_get() const
{
        if (!reflection) {
                typedef class_reflection::field_metadata md;
                typedef class_reflection::field_metadata_list mdlist;
                ptr<mdlist> mdl = mdlist::create();
                reflection = reflection_list::create( as_binary_expression::reflection_get() );
                reflection->push_back( class_reflection::create( "as_expression_hat_equal", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_expression_hat_equal::field_values_get() const
{
        ptr < field_list_list > result = as_binary_expression::field_values_get();
        return result;
}


/*!
   Marking routine is used for garbage collection.
   \author lsg
 */
void as_expression_hat_equal::gc_mark()
{
        as_binary_expression::gc_mark();
}

// End of class as_expression_hat_equal.

// ------------- Class as_expression_amp_equal follows. -------------

void as_expression_amp_equal::accept_as_expr_visitor( ptr< as_expr_visitor > v )
{
        return v->visit_as_expression_amp_equal( this );
}

/*!
   This factory method for class as_expression_amp_equal takes values of all fields as arguments.
   \author lsg
 */
ptr< as_expression_amp_equal > as_expression_amp_equal::create(ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_expression > a__as_binary_expression__left,
                ptr< as_expression > a__as_binary_expression__right)
{
        return ptr< as_expression_amp_equal > ( new as_expression_amp_equal(a__as_base__location,
                a__as_binary_expression__left,
                a__as_binary_expression__right) );
}

/*!
   Generated constructor for class as_expression_amp_equal.
   \author lsg
 */
as_expression_amp_equal::as_expression_amp_equal (ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_expression > a__as_binary_expression__left,
                ptr< as_expression > a__as_binary_expression__right)
        : as_binary_expression(a__as_base__location,
                a__as_binary_expression__left,
                a__as_binary_expression__right)
{}

ptr< object::reflection_list > as_expression_amp_equal::reflection_get() const
{
        if (!reflection) {
                typedef class_reflection::field_metadata md;
                typedef class_reflection::field_metadata_list mdlist;
                ptr<mdlist> mdl = mdlist::create();
                reflection = reflection_list::create( as_binary_expression::reflection_get() );
                reflection->push_back( class_reflection::create( "as_expression_amp_equal", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_expression_amp_equal::field_values_get() const
{
        ptr < field_list_list > result = as_binary_expression::field_values_get();
        return result;
}


/*!
   Marking routine is used for garbage collection.
   \author lsg
 */
void as_expression_amp_equal::gc_mark()
{
        as_binary_expression::gc_mark();
}

// End of class as_expression_amp_equal.

// ------------- Class as_expression_vbar_equal follows. -------------

void as_expression_vbar_equal::accept_as_expr_visitor( ptr< as_expr_visitor > v )
{
        return v->visit_as_expression_vbar_equal( this );
}

/*!
   This factory method for class as_expression_vbar_equal takes values of all fields as arguments.
   \author lsg
 */
ptr< as_expression_vbar_equal > as_expression_vbar_equal::create(ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_expression > a__as_binary_expression__left,
                ptr< as_expression > a__as_binary_expression__right)
{
        return ptr< as_expression_vbar_equal > ( new as_expression_vbar_equal(a__as_base__location,
                a__as_binary_expression__left,
                a__as_binary_expression__right) );
}

/*!
   Generated constructor for class as_expression_vbar_equal.
   \author lsg
 */
as_expression_vbar_equal::as_expression_vbar_equal (ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_expression > a__as_binary_expression__left,
                ptr< as_expression > a__as_binary_expression__right)
        : as_binary_expression(a__as_base__location,
                a__as_binary_expression__left,
                a__as_binary_expression__right)
{}

ptr< object::reflection_list > as_expression_vbar_equal::reflection_get() const
{
        if (!reflection) {
                typedef class_reflection::field_metadata md;
                typedef class_reflection::field_metadata_list mdlist;
                ptr<mdlist> mdl = mdlist::create();
                reflection = reflection_list::create( as_binary_expression::reflection_get() );
                reflection->push_back( class_reflection::create( "as_expression_vbar_equal", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_expression_vbar_equal::field_values_get() const
{
        ptr < field_list_list > result = as_binary_expression::field_values_get();
        return result;
}


/*!
   Marking routine is used for garbage collection.
   \author lsg
 */
void as_expression_vbar_equal::gc_mark()
{
        as_binary_expression::gc_mark();
}

// End of class as_expression_vbar_equal.

// ------------- Class as_expression_less_less_equal follows. -------------

void as_expression_less_less_equal::accept_as_expr_visitor( ptr< as_expr_visitor > v )
{
        return v->visit_as_expression_less_less_equal( this );
}

/*!
   This factory method for class as_expression_less_less_equal takes values of all fields as arguments.
   \author lsg
 */
ptr< as_expression_less_less_equal > as_expression_less_less_equal::create(ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_expression > a__as_binary_expression__left,
                ptr< as_expression > a__as_binary_expression__right)
{
        return ptr< as_expression_less_less_equal > ( new as_expression_less_less_equal(a__as_base__location,
                a__as_binary_expression__left,
                a__as_binary_expression__right) );
}

/*!
   Generated constructor for class as_expression_less_less_equal.
   \author lsg
 */
as_expression_less_less_equal::as_expression_less_less_equal (ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_expression > a__as_binary_expression__left,
                ptr< as_expression > a__as_binary_expression__right)
        : as_binary_expression(a__as_base__location,
                a__as_binary_expression__left,
                a__as_binary_expression__right)
{}

ptr< object::reflection_list > as_expression_less_less_equal::reflection_get() const
{
        if (!reflection) {
                typedef class_reflection::field_metadata md;
                typedef class_reflection::field_metadata_list mdlist;
                ptr<mdlist> mdl = mdlist::create();
                reflection = reflection_list::create( as_binary_expression::reflection_get() );
                reflection->push_back( class_reflection::create( "as_expression_less_less_equal", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_expression_less_less_equal::field_values_get() const
{
        ptr < field_list_list > result = as_binary_expression::field_values_get();
        return result;
}


/*!
   Marking routine is used for garbage collection.
   \author lsg
 */
void as_expression_less_less_equal::gc_mark()
{
        as_binary_expression::gc_mark();
}

// End of class as_expression_less_less_equal.

// ------------- Class as_expression_greater_greater_equal follows. -------------

void as_expression_greater_greater_equal::accept_as_expr_visitor( ptr< as_expr_visitor > v )
{
        return v->visit_as_expression_greater_greater_equal( this );
}

/*!
   This factory method for class as_expression_greater_greater_equal takes values of all fields as arguments.
   \author lsg
 */
ptr< as_expression_greater_greater_equal > as_expression_greater_greater_equal::create(ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_expression > a__as_binary_expression__left,
                ptr< as_expression > a__as_binary_expression__right)
{
        return ptr< as_expression_greater_greater_equal > ( new as_expression_greater_greater_equal(a__as_base__location,
                a__as_binary_expression__left,
                a__as_binary_expression__right) );
}

/*!
   Generated constructor for class as_expression_greater_greater_equal.
   \author lsg
 */
as_expression_greater_greater_equal::as_expression_greater_greater_equal (ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_expression > a__as_binary_expression__left,
                ptr< as_expression > a__as_binary_expression__right)
        : as_binary_expression(a__as_base__location,
                a__as_binary_expression__left,
                a__as_binary_expression__right)
{}

ptr< object::reflection_list > as_expression_greater_greater_equal::reflection_get() const
{
        if (!reflection) {
                typedef class_reflection::field_metadata md;
                typedef class_reflection::field_metadata_list mdlist;
                ptr<mdlist> mdl = mdlist::create();
                reflection = reflection_list::create( as_binary_expression::reflection_get() );
                reflection->push_back( class_reflection::create( "as_expression_greater_greater_equal", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_expression_greater_greater_equal::field_values_get() const
{
        ptr < field_list_list > result = as_binary_expression::field_values_get();
        return result;
}


/*!
   Marking routine is used for garbage collection.
   \author lsg
 */
void as_expression_greater_greater_equal::gc_mark()
{
        as_binary_expression::gc_mark();
}

// End of class as_expression_greater_greater_equal.

// ------------- Class as_expression_equal_equal follows. -------------

void as_expression_equal_equal::accept_as_expr_visitor( ptr< as_expr_visitor > v )
{
        return v->visit_as_expression_equal_equal( this );
}

/*!
   This factory method for class as_expression_equal_equal takes values of all fields as arguments.
   \author lsg
 */
ptr< as_expression_equal_equal > as_expression_equal_equal::create(ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_expression > a__as_binary_expression__left,
                ptr< as_expression > a__as_binary_expression__right)
{
        return ptr< as_expression_equal_equal > ( new as_expression_equal_equal(a__as_base__location,
                a__as_binary_expression__left,
                a__as_binary_expression__right) );
}

/*!
   Generated constructor for class as_expression_equal_equal.
   \author lsg
 */
as_expression_equal_equal::as_expression_equal_equal (ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_expression > a__as_binary_expression__left,
                ptr< as_expression > a__as_binary_expression__right)
        : as_binary_expression(a__as_base__location,
                a__as_binary_expression__left,
                a__as_binary_expression__right)
{}

ptr< object::reflection_list > as_expression_equal_equal::reflection_get() const
{
        if (!reflection) {
                typedef class_reflection::field_metadata md;
                typedef class_reflection::field_metadata_list mdlist;
                ptr<mdlist> mdl = mdlist::create();
                reflection = reflection_list::create( as_binary_expression::reflection_get() );
                reflection->push_back( class_reflection::create( "as_expression_equal_equal", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_expression_equal_equal::field_values_get() const
{
        ptr < field_list_list > result = as_binary_expression::field_values_get();
        return result;
}


/*!
   Marking routine is used for garbage collection.
   \author lsg
 */
void as_expression_equal_equal::gc_mark()
{
        as_binary_expression::gc_mark();
}

// End of class as_expression_equal_equal.

// ------------- Class as_expression_exclam_equal follows. -------------

void as_expression_exclam_equal::accept_as_expr_visitor( ptr< as_expr_visitor > v )
{
        return v->visit_as_expression_exclam_equal( this );
}

/*!
   This factory method for class as_expression_exclam_equal takes values of all fields as arguments.
   \author lsg
 */
ptr< as_expression_exclam_equal > as_expression_exclam_equal::create(ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_expression > a__as_binary_expression__left,
                ptr< as_expression > a__as_binary_expression__right)
{
        return ptr< as_expression_exclam_equal > ( new as_expression_exclam_equal(a__as_base__location,
                a__as_binary_expression__left,
                a__as_binary_expression__right) );
}

/*!
   Generated constructor for class as_expression_exclam_equal.
   \author lsg
 */
as_expression_exclam_equal::as_expression_exclam_equal (ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_expression > a__as_binary_expression__left,
                ptr< as_expression > a__as_binary_expression__right)
        : as_binary_expression(a__as_base__location,
                a__as_binary_expression__left,
                a__as_binary_expression__right)
{}

ptr< object::reflection_list > as_expression_exclam_equal::reflection_get() const
{
        if (!reflection) {
                typedef class_reflection::field_metadata md;
                typedef class_reflection::field_metadata_list mdlist;
                ptr<mdlist> mdl = mdlist::create();
                reflection = reflection_list::create( as_binary_expression::reflection_get() );
                reflection->push_back( class_reflection::create( "as_expression_exclam_equal", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_expression_exclam_equal::field_values_get() const
{
        ptr < field_list_list > result = as_binary_expression::field_values_get();
        return result;
}


/*!
   Marking routine is used for garbage collection.
   \author lsg
 */
void as_expression_exclam_equal::gc_mark()
{
        as_binary_expression::gc_mark();
}

// End of class as_expression_exclam_equal.

// ------------- Class as_expression_less_equal follows. -------------

void as_expression_less_equal::accept_as_expr_visitor( ptr< as_expr_visitor > v )
{
        return v->visit_as_expression_less_equal( this );
}

/*!
   This factory method for class as_expression_less_equal takes values of all fields as arguments.
   \author lsg
 */
ptr< as_expression_less_equal > as_expression_less_equal::create(ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_expression > a__as_binary_expression__left,
                ptr< as_expression > a__as_binary_expression__right)
{
        return ptr< as_expression_less_equal > ( new as_expression_less_equal(a__as_base__location,
                a__as_binary_expression__left,
                a__as_binary_expression__right) );
}

/*!
   Generated constructor for class as_expression_less_equal.
   \author lsg
 */
as_expression_less_equal::as_expression_less_equal (ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_expression > a__as_binary_expression__left,
                ptr< as_expression > a__as_binary_expression__right)
        : as_binary_expression(a__as_base__location,
                a__as_binary_expression__left,
                a__as_binary_expression__right)
{}

ptr< object::reflection_list > as_expression_less_equal::reflection_get() const
{
        if (!reflection) {
                typedef class_reflection::field_metadata md;
                typedef class_reflection::field_metadata_list mdlist;
                ptr<mdlist> mdl = mdlist::create();
                reflection = reflection_list::create( as_binary_expression::reflection_get() );
                reflection->push_back( class_reflection::create( "as_expression_less_equal", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_expression_less_equal::field_values_get() const
{
        ptr < field_list_list > result = as_binary_expression::field_values_get();
        return result;
}


/*!
   Marking routine is used for garbage collection.
   \author lsg
 */
void as_expression_less_equal::gc_mark()
{
        as_binary_expression::gc_mark();
}

// End of class as_expression_less_equal.

// ------------- Class as_expression_greater_equal follows. -------------

void as_expression_greater_equal::accept_as_expr_visitor( ptr< as_expr_visitor > v )
{
        return v->visit_as_expression_greater_equal( this );
}

/*!
   This factory method for class as_expression_greater_equal takes values of all fields as arguments.
   \author lsg
 */
ptr< as_expression_greater_equal > as_expression_greater_equal::create(ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_expression > a__as_binary_expression__left,
                ptr< as_expression > a__as_binary_expression__right)
{
        return ptr< as_expression_greater_equal > ( new as_expression_greater_equal(a__as_base__location,
                a__as_binary_expression__left,
                a__as_binary_expression__right) );
}

/*!
   Generated constructor for class as_expression_greater_equal.
   \author lsg
 */
as_expression_greater_equal::as_expression_greater_equal (ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_expression > a__as_binary_expression__left,
                ptr< as_expression > a__as_binary_expression__right)
        : as_binary_expression(a__as_base__location,
                a__as_binary_expression__left,
                a__as_binary_expression__right)
{}

ptr< object::reflection_list > as_expression_greater_equal::reflection_get() const
{
        if (!reflection) {
                typedef class_reflection::field_metadata md;
                typedef class_reflection::field_metadata_list mdlist;
                ptr<mdlist> mdl = mdlist::create();
                reflection = reflection_list::create( as_binary_expression::reflection_get() );
                reflection->push_back( class_reflection::create( "as_expression_greater_equal", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_expression_greater_equal::field_values_get() const
{
        ptr < field_list_list > result = as_binary_expression::field_values_get();
        return result;
}


/*!
   Marking routine is used for garbage collection.
   \author lsg
 */
void as_expression_greater_equal::gc_mark()
{
        as_binary_expression::gc_mark();
}

// End of class as_expression_greater_equal.

// ------------- Class as_expression_less follows. -------------

void as_expression_less::accept_as_expr_visitor( ptr< as_expr_visitor > v )
{
        return v->visit_as_expression_less( this );
}

/*!
   This factory method for class as_expression_less takes values of all fields as arguments.
   \author lsg
 */
ptr< as_expression_less > as_expression_less::create(ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_expression > a__as_binary_expression__left,
                ptr< as_expression > a__as_binary_expression__right)
{
        return ptr< as_expression_less > ( new as_expression_less(a__as_base__location,
                a__as_binary_expression__left,
                a__as_binary_expression__right) );
}

/*!
   Generated constructor for class as_expression_less.
   \author lsg
 */
as_expression_less::as_expression_less (ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_expression > a__as_binary_expression__left,
                ptr< as_expression > a__as_binary_expression__right)
        : as_binary_expression(a__as_base__location,
                a__as_binary_expression__left,
                a__as_binary_expression__right)
{}

ptr< object::reflection_list > as_expression_less::reflection_get() const
{
        if (!reflection) {
                typedef class_reflection::field_metadata md;
                typedef class_reflection::field_metadata_list mdlist;
                ptr<mdlist> mdl = mdlist::create();
                reflection = reflection_list::create( as_binary_expression::reflection_get() );
                reflection->push_back( class_reflection::create( "as_expression_less", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_expression_less::field_values_get() const
{
        ptr < field_list_list > result = as_binary_expression::field_values_get();
        return result;
}


/*!
   Marking routine is used for garbage collection.
   \author lsg
 */
void as_expression_less::gc_mark()
{
        as_binary_expression::gc_mark();
}

// End of class as_expression_less.

// ------------- Class as_expression_greater follows. -------------

void as_expression_greater::accept_as_expr_visitor( ptr< as_expr_visitor > v )
{
        return v->visit_as_expression_greater( this );
}

/*!
   This factory method for class as_expression_greater takes values of all fields as arguments.
   \author lsg
 */
ptr< as_expression_greater > as_expression_greater::create(ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_expression > a__as_binary_expression__left,
                ptr< as_expression > a__as_binary_expression__right)
{
        return ptr< as_expression_greater > ( new as_expression_greater(a__as_base__location,
                a__as_binary_expression__left,
                a__as_binary_expression__right) );
}

/*!
   Generated constructor for class as_expression_greater.
   \author lsg
 */
as_expression_greater::as_expression_greater (ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_expression > a__as_binary_expression__left,
                ptr< as_expression > a__as_binary_expression__right)
        : as_binary_expression(a__as_base__location,
                a__as_binary_expression__left,
                a__as_binary_expression__right)
{}

ptr< object::reflection_list > as_expression_greater::reflection_get() const
{
        if (!reflection) {
                typedef class_reflection::field_metadata md;
                typedef class_reflection::field_metadata_list mdlist;
                ptr<mdlist> mdl = mdlist::create();
                reflection = reflection_list::create( as_binary_expression::reflection_get() );
                reflection->push_back( class_reflection::create( "as_expression_greater", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_expression_greater::field_values_get() const
{
        ptr < field_list_list > result = as_binary_expression::field_values_get();
        return result;
}


/*!
   Marking routine is used for garbage collection.
   \author lsg
 */
void as_expression_greater::gc_mark()
{
        as_binary_expression::gc_mark();
}

// End of class as_expression_greater.

// ------------- Class as_expression_vbar_vbar follows. -------------

void as_expression_vbar_vbar::accept_as_expr_visitor( ptr< as_expr_visitor > v )
{
        return v->visit_as_expression_vbar_vbar( this );
}

/*!
   This factory method for class as_expression_vbar_vbar takes values of all fields as arguments.
   \author lsg
 */
ptr< as_expression_vbar_vbar > as_expression_vbar_vbar::create(ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_expression > a__as_binary_expression__left,
                ptr< as_expression > a__as_binary_expression__right)
{
        return ptr< as_expression_vbar_vbar > ( new as_expression_vbar_vbar(a__as_base__location,
                a__as_binary_expression__left,
                a__as_binary_expression__right) );
}

/*!
   Generated constructor for class as_expression_vbar_vbar.
   \author lsg
 */
as_expression_vbar_vbar::as_expression_vbar_vbar (ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_expression > a__as_binary_expression__left,
                ptr< as_expression > a__as_binary_expression__right)
        : as_binary_expression(a__as_base__location,
                a__as_binary_expression__left,
                a__as_binary_expression__right)
{}

ptr< object::reflection_list > as_expression_vbar_vbar::reflection_get() const
{
        if (!reflection) {
                typedef class_reflection::field_metadata md;
                typedef class_reflection::field_metadata_list mdlist;
                ptr<mdlist> mdl = mdlist::create();
                reflection = reflection_list::create( as_binary_expression::reflection_get() );
                reflection->push_back( class_reflection::create( "as_expression_vbar_vbar", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_expression_vbar_vbar::field_values_get() const
{
        ptr < field_list_list > result = as_binary_expression::field_values_get();
        return result;
}


/*!
   Marking routine is used for garbage collection.
   \author lsg
 */
void as_expression_vbar_vbar::gc_mark()
{
        as_binary_expression::gc_mark();
}

// End of class as_expression_vbar_vbar.

// ------------- Class as_expression_amp_amp follows. -------------

void as_expression_amp_amp::accept_as_expr_visitor( ptr< as_expr_visitor > v )
{
        return v->visit_as_expression_amp_amp( this );
}

/*!
   This factory method for class as_expression_amp_amp takes values of all fields as arguments.
   \author lsg
 */
ptr< as_expression_amp_amp > as_expression_amp_amp::create(ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_expression > a__as_binary_expression__left,
                ptr< as_expression > a__as_binary_expression__right)
{
        return ptr< as_expression_amp_amp > ( new as_expression_amp_amp(a__as_base__location,
                a__as_binary_expression__left,
                a__as_binary_expression__right) );
}

/*!
   Generated constructor for class as_expression_amp_amp.
   \author lsg
 */
as_expression_amp_amp::as_expression_amp_amp (ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_expression > a__as_binary_expression__left,
                ptr< as_expression > a__as_binary_expression__right)
        : as_binary_expression(a__as_base__location,
                a__as_binary_expression__left,
                a__as_binary_expression__right)
{}

ptr< object::reflection_list > as_expression_amp_amp::reflection_get() const
{
        if (!reflection) {
                typedef class_reflection::field_metadata md;
                typedef class_reflection::field_metadata_list mdlist;
                ptr<mdlist> mdl = mdlist::create();
                reflection = reflection_list::create( as_binary_expression::reflection_get() );
                reflection->push_back( class_reflection::create( "as_expression_amp_amp", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_expression_amp_amp::field_values_get() const
{
        ptr < field_list_list > result = as_binary_expression::field_values_get();
        return result;
}


/*!
   Marking routine is used for garbage collection.
   \author lsg
 */
void as_expression_amp_amp::gc_mark()
{
        as_binary_expression::gc_mark();
}

// End of class as_expression_amp_amp.

// ------------- Class as_expression_vbar follows. -------------

void as_expression_vbar::accept_as_expr_visitor( ptr< as_expr_visitor > v )
{
        return v->visit_as_expression_vbar( this );
}

/*!
   This factory method for class as_expression_vbar takes values of all fields as arguments.
   \author lsg
 */
ptr< as_expression_vbar > as_expression_vbar::create(ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_expression > a__as_binary_expression__left,
                ptr< as_expression > a__as_binary_expression__right)
{
        return ptr< as_expression_vbar > ( new as_expression_vbar(a__as_base__location,
                a__as_binary_expression__left,
                a__as_binary_expression__right) );
}

/*!
   Generated constructor for class as_expression_vbar.
   \author lsg
 */
as_expression_vbar::as_expression_vbar (ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_expression > a__as_binary_expression__left,
                ptr< as_expression > a__as_binary_expression__right)
        : as_binary_expression(a__as_base__location,
                a__as_binary_expression__left,
                a__as_binary_expression__right)
{}

ptr< object::reflection_list > as_expression_vbar::reflection_get() const
{
        if (!reflection) {
                typedef class_reflection::field_metadata md;
                typedef class_reflection::field_metadata_list mdlist;
                ptr<mdlist> mdl = mdlist::create();
                reflection = reflection_list::create( as_binary_expression::reflection_get() );
                reflection->push_back( class_reflection::create( "as_expression_vbar", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_expression_vbar::field_values_get() const
{
        ptr < field_list_list > result = as_binary_expression::field_values_get();
        return result;
}


/*!
   Marking routine is used for garbage collection.
   \author lsg
 */
void as_expression_vbar::gc_mark()
{
        as_binary_expression::gc_mark();
}

// End of class as_expression_vbar.

// ------------- Class as_expression_amp follows. -------------

void as_expression_amp::accept_as_expr_visitor( ptr< as_expr_visitor > v )
{
        return v->visit_as_expression_amp( this );
}

/*!
   This factory method for class as_expression_amp takes values of all fields as arguments.
   \author lsg
 */
ptr< as_expression_amp > as_expression_amp::create(ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_expression > a__as_binary_expression__left,
                ptr< as_expression > a__as_binary_expression__right)
{
        return ptr< as_expression_amp > ( new as_expression_amp(a__as_base__location,
                a__as_binary_expression__left,
                a__as_binary_expression__right) );
}

/*!
   Generated constructor for class as_expression_amp.
   \author lsg
 */
as_expression_amp::as_expression_amp (ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_expression > a__as_binary_expression__left,
                ptr< as_expression > a__as_binary_expression__right)
        : as_binary_expression(a__as_base__location,
                a__as_binary_expression__left,
                a__as_binary_expression__right)
{}

ptr< object::reflection_list > as_expression_amp::reflection_get() const
{
        if (!reflection) {
                typedef class_reflection::field_metadata md;
                typedef class_reflection::field_metadata_list mdlist;
                ptr<mdlist> mdl = mdlist::create();
                reflection = reflection_list::create( as_binary_expression::reflection_get() );
                reflection->push_back( class_reflection::create( "as_expression_amp", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_expression_amp::field_values_get() const
{
        ptr < field_list_list > result = as_binary_expression::field_values_get();
        return result;
}


/*!
   Marking routine is used for garbage collection.
   \author lsg
 */
void as_expression_amp::gc_mark()
{
        as_binary_expression::gc_mark();
}

// End of class as_expression_amp.

// ------------- Class as_expression_hat follows. -------------

void as_expression_hat::accept_as_expr_visitor( ptr< as_expr_visitor > v )
{
        return v->visit_as_expression_hat( this );
}

/*!
   This factory method for class as_expression_hat takes values of all fields as arguments.
   \author lsg
 */
ptr< as_expression_hat > as_expression_hat::create(ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_expression > a__as_binary_expression__left,
                ptr< as_expression > a__as_binary_expression__right)
{
        return ptr< as_expression_hat > ( new as_expression_hat(a__as_base__location,
                a__as_binary_expression__left,
                a__as_binary_expression__right) );
}

/*!
   Generated constructor for class as_expression_hat.
   \author lsg
 */
as_expression_hat::as_expression_hat (ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_expression > a__as_binary_expression__left,
                ptr< as_expression > a__as_binary_expression__right)
        : as_binary_expression(a__as_base__location,
                a__as_binary_expression__left,
                a__as_binary_expression__right)
{}

ptr< object::reflection_list > as_expression_hat::reflection_get() const
{
        if (!reflection) {
                typedef class_reflection::field_metadata md;
                typedef class_reflection::field_metadata_list mdlist;
                ptr<mdlist> mdl = mdlist::create();
                reflection = reflection_list::create( as_binary_expression::reflection_get() );
                reflection->push_back( class_reflection::create( "as_expression_hat", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_expression_hat::field_values_get() const
{
        ptr < field_list_list > result = as_binary_expression::field_values_get();
        return result;
}


/*!
   Marking routine is used for garbage collection.
   \author lsg
 */
void as_expression_hat::gc_mark()
{
        as_binary_expression::gc_mark();
}

// End of class as_expression_hat.

// ------------- Class as_expression_less_less follows. -------------

void as_expression_less_less::accept_as_expr_visitor( ptr< as_expr_visitor > v )
{
        return v->visit_as_expression_less_less( this );
}

/*!
   This factory method for class as_expression_less_less takes values of all fields as arguments.
   \author lsg
 */
ptr< as_expression_less_less > as_expression_less_less::create(ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_expression > a__as_binary_expression__left,
                ptr< as_expression > a__as_binary_expression__right)
{
        return ptr< as_expression_less_less > ( new as_expression_less_less(a__as_base__location,
                a__as_binary_expression__left,
                a__as_binary_expression__right) );
}

/*!
   Generated constructor for class as_expression_less_less.
   \author lsg
 */
as_expression_less_less::as_expression_less_less (ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_expression > a__as_binary_expression__left,
                ptr< as_expression > a__as_binary_expression__right)
        : as_binary_expression(a__as_base__location,
                a__as_binary_expression__left,
                a__as_binary_expression__right)
{}

ptr< object::reflection_list > as_expression_less_less::reflection_get() const
{
        if (!reflection) {
                typedef class_reflection::field_metadata md;
                typedef class_reflection::field_metadata_list mdlist;
                ptr<mdlist> mdl = mdlist::create();
                reflection = reflection_list::create( as_binary_expression::reflection_get() );
                reflection->push_back( class_reflection::create( "as_expression_less_less", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_expression_less_less::field_values_get() const
{
        ptr < field_list_list > result = as_binary_expression::field_values_get();
        return result;
}


/*!
   Marking routine is used for garbage collection.
   \author lsg
 */
void as_expression_less_less::gc_mark()
{
        as_binary_expression::gc_mark();
}

// End of class as_expression_less_less.

// ------------- Class as_expression_greater_greater follows. -------------

void as_expression_greater_greater::accept_as_expr_visitor( ptr< as_expr_visitor > v )
{
        return v->visit_as_expression_greater_greater( this );
}

/*!
   This factory method for class as_expression_greater_greater takes values of all fields as arguments.
   \author lsg
 */
ptr< as_expression_greater_greater > as_expression_greater_greater::create(ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_expression > a__as_binary_expression__left,
                ptr< as_expression > a__as_binary_expression__right)
{
        return ptr< as_expression_greater_greater > ( new as_expression_greater_greater(a__as_base__location,
                a__as_binary_expression__left,
                a__as_binary_expression__right) );
}

/*!
   Generated constructor for class as_expression_greater_greater.
   \author lsg
 */
as_expression_greater_greater::as_expression_greater_greater (ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_expression > a__as_binary_expression__left,
                ptr< as_expression > a__as_binary_expression__right)
        : as_binary_expression(a__as_base__location,
                a__as_binary_expression__left,
                a__as_binary_expression__right)
{}

ptr< object::reflection_list > as_expression_greater_greater::reflection_get() const
{
        if (!reflection) {
                typedef class_reflection::field_metadata md;
                typedef class_reflection::field_metadata_list mdlist;
                ptr<mdlist> mdl = mdlist::create();
                reflection = reflection_list::create( as_binary_expression::reflection_get() );
                reflection->push_back( class_reflection::create( "as_expression_greater_greater", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_expression_greater_greater::field_values_get() const
{
        ptr < field_list_list > result = as_binary_expression::field_values_get();
        return result;
}


/*!
   Marking routine is used for garbage collection.
   \author lsg
 */
void as_expression_greater_greater::gc_mark()
{
        as_binary_expression::gc_mark();
}

// End of class as_expression_greater_greater.

// ------------- Class as_expression_plus follows. -------------

void as_expression_plus::accept_as_expr_visitor( ptr< as_expr_visitor > v )
{
        return v->visit_as_expression_plus( this );
}

/*!
   This factory method for class as_expression_plus takes values of all fields as arguments.
   \author lsg
 */
ptr< as_expression_plus > as_expression_plus::create(ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_expression > a__as_binary_expression__left,
                ptr< as_expression > a__as_binary_expression__right)
{
        return ptr< as_expression_plus > ( new as_expression_plus(a__as_base__location,
                a__as_binary_expression__left,
                a__as_binary_expression__right) );
}

/*!
   Generated constructor for class as_expression_plus.
   \author lsg
 */
as_expression_plus::as_expression_plus (ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_expression > a__as_binary_expression__left,
                ptr< as_expression > a__as_binary_expression__right)
        : as_binary_expression(a__as_base__location,
                a__as_binary_expression__left,
                a__as_binary_expression__right)
{}

ptr< object::reflection_list > as_expression_plus::reflection_get() const
{
        if (!reflection) {
                typedef class_reflection::field_metadata md;
                typedef class_reflection::field_metadata_list mdlist;
                ptr<mdlist> mdl = mdlist::create();
                reflection = reflection_list::create( as_binary_expression::reflection_get() );
                reflection->push_back( class_reflection::create( "as_expression_plus", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_expression_plus::field_values_get() const
{
        ptr < field_list_list > result = as_binary_expression::field_values_get();
        return result;
}


/*!
   Marking routine is used for garbage collection.
   \author lsg
 */
void as_expression_plus::gc_mark()
{
        as_binary_expression::gc_mark();
}

// End of class as_expression_plus.

// ------------- Class as_expression_minus follows. -------------

void as_expression_minus::accept_as_expr_visitor( ptr< as_expr_visitor > v )
{
        return v->visit_as_expression_minus( this );
}

/*!
   This factory method for class as_expression_minus takes values of all fields as arguments.
   \author lsg
 */
ptr< as_expression_minus > as_expression_minus::create(ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_expression > a__as_binary_expression__left,
                ptr< as_expression > a__as_binary_expression__right)
{
        return ptr< as_expression_minus > ( new as_expression_minus(a__as_base__location,
                a__as_binary_expression__left,
                a__as_binary_expression__right) );
}

/*!
   Generated constructor for class as_expression_minus.
   \author lsg
 */
as_expression_minus::as_expression_minus (ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_expression > a__as_binary_expression__left,
                ptr< as_expression > a__as_binary_expression__right)
        : as_binary_expression(a__as_base__location,
                a__as_binary_expression__left,
                a__as_binary_expression__right)
{}

ptr< object::reflection_list > as_expression_minus::reflection_get() const
{
        if (!reflection) {
                typedef class_reflection::field_metadata md;
                typedef class_reflection::field_metadata_list mdlist;
                ptr<mdlist> mdl = mdlist::create();
                reflection = reflection_list::create( as_binary_expression::reflection_get() );
                reflection->push_back( class_reflection::create( "as_expression_minus", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_expression_minus::field_values_get() const
{
        ptr < field_list_list > result = as_binary_expression::field_values_get();
        return result;
}


/*!
   Marking routine is used for garbage collection.
   \author lsg
 */
void as_expression_minus::gc_mark()
{
        as_binary_expression::gc_mark();
}

// End of class as_expression_minus.

// ------------- Class as_expression_star follows. -------------

void as_expression_star::accept_as_expr_visitor( ptr< as_expr_visitor > v )
{
        return v->visit_as_expression_star( this );
}

/*!
   This factory method for class as_expression_star takes values of all fields as arguments.
   \author lsg
 */
ptr< as_expression_star > as_expression_star::create(ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_expression > a__as_binary_expression__left,
                ptr< as_expression > a__as_binary_expression__right)
{
        return ptr< as_expression_star > ( new as_expression_star(a__as_base__location,
                a__as_binary_expression__left,
                a__as_binary_expression__right) );
}

/*!
   Generated constructor for class as_expression_star.
   \author lsg
 */
as_expression_star::as_expression_star (ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_expression > a__as_binary_expression__left,
                ptr< as_expression > a__as_binary_expression__right)
        : as_binary_expression(a__as_base__location,
                a__as_binary_expression__left,
                a__as_binary_expression__right)
{}

ptr< object::reflection_list > as_expression_star::reflection_get() const
{
        if (!reflection) {
                typedef class_reflection::field_metadata md;
                typedef class_reflection::field_metadata_list mdlist;
                ptr<mdlist> mdl = mdlist::create();
                reflection = reflection_list::create( as_binary_expression::reflection_get() );
                reflection->push_back( class_reflection::create( "as_expression_star", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_expression_star::field_values_get() const
{
        ptr < field_list_list > result = as_binary_expression::field_values_get();
        return result;
}


/*!
   Marking routine is used for garbage collection.
   \author lsg
 */
void as_expression_star::gc_mark()
{
        as_binary_expression::gc_mark();
}

// End of class as_expression_star.

// ------------- Class as_expression_slash follows. -------------

void as_expression_slash::accept_as_expr_visitor( ptr< as_expr_visitor > v )
{
        return v->visit_as_expression_slash( this );
}

/*!
   This factory method for class as_expression_slash takes values of all fields as arguments.
   \author lsg
 */
ptr< as_expression_slash > as_expression_slash::create(ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_expression > a__as_binary_expression__left,
                ptr< as_expression > a__as_binary_expression__right)
{
        return ptr< as_expression_slash > ( new as_expression_slash(a__as_base__location,
                a__as_binary_expression__left,
                a__as_binary_expression__right) );
}

/*!
   Generated constructor for class as_expression_slash.
   \author lsg
 */
as_expression_slash::as_expression_slash (ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_expression > a__as_binary_expression__left,
                ptr< as_expression > a__as_binary_expression__right)
        : as_binary_expression(a__as_base__location,
                a__as_binary_expression__left,
                a__as_binary_expression__right)
{}

ptr< object::reflection_list > as_expression_slash::reflection_get() const
{
        if (!reflection) {
                typedef class_reflection::field_metadata md;
                typedef class_reflection::field_metadata_list mdlist;
                ptr<mdlist> mdl = mdlist::create();
                reflection = reflection_list::create( as_binary_expression::reflection_get() );
                reflection->push_back( class_reflection::create( "as_expression_slash", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_expression_slash::field_values_get() const
{
        ptr < field_list_list > result = as_binary_expression::field_values_get();
        return result;
}


/*!
   Marking routine is used for garbage collection.
   \author lsg
 */
void as_expression_slash::gc_mark()
{
        as_binary_expression::gc_mark();
}

// End of class as_expression_slash.

// ------------- Class as_expression_percent follows. -------------

void as_expression_percent::accept_as_expr_visitor( ptr< as_expr_visitor > v )
{
        return v->visit_as_expression_percent( this );
}

/*!
   This factory method for class as_expression_percent takes values of all fields as arguments.
   \author lsg
 */
ptr< as_expression_percent > as_expression_percent::create(ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_expression > a__as_binary_expression__left,
                ptr< as_expression > a__as_binary_expression__right)
{
        return ptr< as_expression_percent > ( new as_expression_percent(a__as_base__location,
                a__as_binary_expression__left,
                a__as_binary_expression__right) );
}

/*!
   Generated constructor for class as_expression_percent.
   \author lsg
 */
as_expression_percent::as_expression_percent (ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_expression > a__as_binary_expression__left,
                ptr< as_expression > a__as_binary_expression__right)
        : as_binary_expression(a__as_base__location,
                a__as_binary_expression__left,
                a__as_binary_expression__right)
{}

ptr< object::reflection_list > as_expression_percent::reflection_get() const
{
        if (!reflection) {
                typedef class_reflection::field_metadata md;
                typedef class_reflection::field_metadata_list mdlist;
                ptr<mdlist> mdl = mdlist::create();
                reflection = reflection_list::create( as_binary_expression::reflection_get() );
                reflection->push_back( class_reflection::create( "as_expression_percent", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_expression_percent::field_values_get() const
{
        ptr < field_list_list > result = as_binary_expression::field_values_get();
        return result;
}


/*!
   Marking routine is used for garbage collection.
   \author lsg
 */
void as_expression_percent::gc_mark()
{
        as_binary_expression::gc_mark();
}

// End of class as_expression_percent.

// ------------- Class as_expression_dot_star follows. -------------

void as_expression_dot_star::accept_as_expr_visitor( ptr< as_expr_visitor > v )
{
        return v->visit_as_expression_dot_star( this );
}

/*!
   This factory method for class as_expression_dot_star takes values of all fields as arguments.
   \author lsg
 */
ptr< as_expression_dot_star > as_expression_dot_star::create(ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_expression > a__as_binary_expression__left,
                ptr< as_expression > a__as_binary_expression__right)
{
        return ptr< as_expression_dot_star > ( new as_expression_dot_star(a__as_base__location,
                a__as_binary_expression__left,
                a__as_binary_expression__right) );
}

/*!
   Generated constructor for class as_expression_dot_star.
   \author lsg
 */
as_expression_dot_star::as_expression_dot_star (ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_expression > a__as_binary_expression__left,
                ptr< as_expression > a__as_binary_expression__right)
        : as_binary_expression(a__as_base__location,
                a__as_binary_expression__left,
                a__as_binary_expression__right)
{}

ptr< object::reflection_list > as_expression_dot_star::reflection_get() const
{
        if (!reflection) {
                typedef class_reflection::field_metadata md;
                typedef class_reflection::field_metadata_list mdlist;
                ptr<mdlist> mdl = mdlist::create();
                reflection = reflection_list::create( as_binary_expression::reflection_get() );
                reflection->push_back( class_reflection::create( "as_expression_dot_star", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_expression_dot_star::field_values_get() const
{
        ptr < field_list_list > result = as_binary_expression::field_values_get();
        return result;
}


/*!
   Marking routine is used for garbage collection.
   \author lsg
 */
void as_expression_dot_star::gc_mark()
{
        as_binary_expression::gc_mark();
}

// End of class as_expression_dot_star.

// ------------- Class as_expression_minus_greater_star follows. -------------

void as_expression_minus_greater_star::accept_as_expr_visitor( ptr< as_expr_visitor > v )
{
        return v->visit_as_expression_minus_greater_star( this );
}

/*!
   This factory method for class as_expression_minus_greater_star takes values of all fields as arguments.
   \author lsg
 */
ptr< as_expression_minus_greater_star > as_expression_minus_greater_star::create(ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_expression > a__as_binary_expression__left,
                ptr< as_expression > a__as_binary_expression__right)
{
        return ptr< as_expression_minus_greater_star > ( new as_expression_minus_greater_star(a__as_base__location,
                a__as_binary_expression__left,
                a__as_binary_expression__right) );
}

/*!
   Generated constructor for class as_expression_minus_greater_star.
   \author lsg
 */
as_expression_minus_greater_star::as_expression_minus_greater_star (ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_expression > a__as_binary_expression__left,
                ptr< as_expression > a__as_binary_expression__right)
        : as_binary_expression(a__as_base__location,
                a__as_binary_expression__left,
                a__as_binary_expression__right)
{}

ptr< object::reflection_list > as_expression_minus_greater_star::reflection_get() const
{
        if (!reflection) {
                typedef class_reflection::field_metadata md;
                typedef class_reflection::field_metadata_list mdlist;
                ptr<mdlist> mdl = mdlist::create();
                reflection = reflection_list::create( as_binary_expression::reflection_get() );
                reflection->push_back( class_reflection::create( "as_expression_minus_greater_star", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_expression_minus_greater_star::field_values_get() const
{
        ptr < field_list_list > result = as_binary_expression::field_values_get();
        return result;
}


/*!
   Marking routine is used for garbage collection.
   \author lsg
 */
void as_expression_minus_greater_star::gc_mark()
{
        as_binary_expression::gc_mark();
}

// End of class as_expression_minus_greater_star.

// ------------- Class as_expression_brackets follows. -------------

void as_expression_brackets::accept_as_expr_visitor( ptr< as_expr_visitor > v )
{
        return v->visit_as_expression_brackets( this );
}

/*!
   This factory method for class as_expression_brackets takes values of all fields as arguments.
   \author lsg
 */
ptr< as_expression_brackets > as_expression_brackets::create(ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_expression > a__as_binary_expression__left,
                ptr< as_expression > a__as_binary_expression__right)
{
        return ptr< as_expression_brackets > ( new as_expression_brackets(a__as_base__location,
                a__as_binary_expression__left,
                a__as_binary_expression__right) );
}

/*!
   Generated constructor for class as_expression_brackets.
   \author lsg
 */
as_expression_brackets::as_expression_brackets (ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_expression > a__as_binary_expression__left,
                ptr< as_expression > a__as_binary_expression__right)
        : as_binary_expression(a__as_base__location,
                a__as_binary_expression__left,
                a__as_binary_expression__right)
{}

ptr< object::reflection_list > as_expression_brackets::reflection_get() const
{
        if (!reflection) {
                typedef class_reflection::field_metadata md;
                typedef class_reflection::field_metadata_list mdlist;
                ptr<mdlist> mdl = mdlist::create();
                reflection = reflection_list::create( as_binary_expression::reflection_get() );
                reflection->push_back( class_reflection::create( "as_expression_brackets", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_expression_brackets::field_values_get() const
{
        ptr < field_list_list > result = as_binary_expression::field_values_get();
        return result;
}


/*!
   Marking routine is used for garbage collection.
   \author lsg
 */
void as_expression_brackets::gc_mark()
{
        as_binary_expression::gc_mark();
}

// End of class as_expression_brackets.

// ------------- Class as_expression_plus_plus_pre follows. -------------

void as_expression_plus_plus_pre::accept_as_expr_visitor( ptr< as_expr_visitor > v )
{
        return v->visit_as_expression_plus_plus_pre( this );
}

/*!
   This factory method for class as_expression_plus_plus_pre takes values of all fields as arguments.
   \author lsg
 */
ptr< as_expression_plus_plus_pre > as_expression_plus_plus_pre::create(ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_expression > a__as_unary_expression__expr)
{
        return ptr< as_expression_plus_plus_pre > ( new as_expression_plus_plus_pre(a__as_base__location,
                a__as_unary_expression__expr) );
}

/*!
   Generated constructor for class as_expression_plus_plus_pre.
   \author lsg
 */
as_expression_plus_plus_pre::as_expression_plus_plus_pre (ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_expression > a__as_unary_expression__expr)
        : as_unary_expression(a__as_base__location,
                a__as_unary_expression__expr)
{}

ptr< object::reflection_list > as_expression_plus_plus_pre::reflection_get() const
{
        if (!reflection) {
                typedef class_reflection::field_metadata md;
                typedef class_reflection::field_metadata_list mdlist;
                ptr<mdlist> mdl = mdlist::create();
                reflection = reflection_list::create( as_unary_expression::reflection_get() );
                reflection->push_back( class_reflection::create( "as_expression_plus_plus_pre", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_expression_plus_plus_pre::field_values_get() const
{
        ptr < field_list_list > result = as_unary_expression::field_values_get();
        return result;
}


/*!
   Marking routine is used for garbage collection.
   \author lsg
 */
void as_expression_plus_plus_pre::gc_mark()
{
        as_unary_expression::gc_mark();
}

// End of class as_expression_plus_plus_pre.

// ------------- Class as_expression_plus_plus_post follows. -------------

void as_expression_plus_plus_post::accept_as_expr_visitor( ptr< as_expr_visitor > v )
{
        return v->visit_as_expression_plus_plus_post( this );
}

/*!
   This factory method for class as_expression_plus_plus_post takes values of all fields as arguments.
   \author lsg
 */
ptr< as_expression_plus_plus_post > as_expression_plus_plus_post::create(ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_expression > a__as_unary_expression__expr)
{
        return ptr< as_expression_plus_plus_post > ( new as_expression_plus_plus_post(a__as_base__location,
                a__as_unary_expression__expr) );
}

/*!
   Generated constructor for class as_expression_plus_plus_post.
   \author lsg
 */
as_expression_plus_plus_post::as_expression_plus_plus_post (ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_expression > a__as_unary_expression__expr)
        : as_unary_expression(a__as_base__location,
                a__as_unary_expression__expr)
{}

ptr< object::reflection_list > as_expression_plus_plus_post::reflection_get() const
{
        if (!reflection) {
                typedef class_reflection::field_metadata md;
                typedef class_reflection::field_metadata_list mdlist;
                ptr<mdlist> mdl = mdlist::create();
                reflection = reflection_list::create( as_unary_expression::reflection_get() );
                reflection->push_back( class_reflection::create( "as_expression_plus_plus_post", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_expression_plus_plus_post::field_values_get() const
{
        ptr < field_list_list > result = as_unary_expression::field_values_get();
        return result;
}


/*!
   Marking routine is used for garbage collection.
   \author lsg
 */
void as_expression_plus_plus_post::gc_mark()
{
        as_unary_expression::gc_mark();
}

// End of class as_expression_plus_plus_post.

// ------------- Class as_expression_minus_minus_pre follows. -------------

void as_expression_minus_minus_pre::accept_as_expr_visitor( ptr< as_expr_visitor > v )
{
        return v->visit_as_expression_minus_minus_pre( this );
}

/*!
   This factory method for class as_expression_minus_minus_pre takes values of all fields as arguments.
   \author lsg
 */
ptr< as_expression_minus_minus_pre > as_expression_minus_minus_pre::create(ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_expression > a__as_unary_expression__expr)
{
        return ptr< as_expression_minus_minus_pre > ( new as_expression_minus_minus_pre(a__as_base__location,
                a__as_unary_expression__expr) );
}

/*!
   Generated constructor for class as_expression_minus_minus_pre.
   \author lsg
 */
as_expression_minus_minus_pre::as_expression_minus_minus_pre (ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_expression > a__as_unary_expression__expr)
        : as_unary_expression(a__as_base__location,
                a__as_unary_expression__expr)
{}

ptr< object::reflection_list > as_expression_minus_minus_pre::reflection_get() const
{
        if (!reflection) {
                typedef class_reflection::field_metadata md;
                typedef class_reflection::field_metadata_list mdlist;
                ptr<mdlist> mdl = mdlist::create();
                reflection = reflection_list::create( as_unary_expression::reflection_get() );
                reflection->push_back( class_reflection::create( "as_expression_minus_minus_pre", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_expression_minus_minus_pre::field_values_get() const
{
        ptr < field_list_list > result = as_unary_expression::field_values_get();
        return result;
}


/*!
   Marking routine is used for garbage collection.
   \author lsg
 */
void as_expression_minus_minus_pre::gc_mark()
{
        as_unary_expression::gc_mark();
}

// End of class as_expression_minus_minus_pre.

// ------------- Class as_expression_minus_minus_post follows. -------------

void as_expression_minus_minus_post::accept_as_expr_visitor( ptr< as_expr_visitor > v )
{
        return v->visit_as_expression_minus_minus_post( this );
}

/*!
   This factory method for class as_expression_minus_minus_post takes values of all fields as arguments.
   \author lsg
 */
ptr< as_expression_minus_minus_post > as_expression_minus_minus_post::create(ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_expression > a__as_unary_expression__expr)
{
        return ptr< as_expression_minus_minus_post > ( new as_expression_minus_minus_post(a__as_base__location,
                a__as_unary_expression__expr) );
}

/*!
   Generated constructor for class as_expression_minus_minus_post.
   \author lsg
 */
as_expression_minus_minus_post::as_expression_minus_minus_post (ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_expression > a__as_unary_expression__expr)
        : as_unary_expression(a__as_base__location,
                a__as_unary_expression__expr)
{}

ptr< object::reflection_list > as_expression_minus_minus_post::reflection_get() const
{
        if (!reflection) {
                typedef class_reflection::field_metadata md;
                typedef class_reflection::field_metadata_list mdlist;
                ptr<mdlist> mdl = mdlist::create();
                reflection = reflection_list::create( as_unary_expression::reflection_get() );
                reflection->push_back( class_reflection::create( "as_expression_minus_minus_post", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_expression_minus_minus_post::field_values_get() const
{
        ptr < field_list_list > result = as_unary_expression::field_values_get();
        return result;
}


/*!
   Marking routine is used for garbage collection.
   \author lsg
 */
void as_expression_minus_minus_post::gc_mark()
{
        as_unary_expression::gc_mark();
}

// End of class as_expression_minus_minus_post.

// ------------- Class as_expression_unary_amp follows. -------------

void as_expression_unary_amp::accept_as_expr_visitor( ptr< as_expr_visitor > v )
{
        return v->visit_as_expression_unary_amp( this );
}

/*!
   This factory method for class as_expression_unary_amp takes values of all fields as arguments.
   \author lsg
 */
ptr< as_expression_unary_amp > as_expression_unary_amp::create(ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_expression > a__as_unary_expression__expr)
{
        return ptr< as_expression_unary_amp > ( new as_expression_unary_amp(a__as_base__location,
                a__as_unary_expression__expr) );
}

/*!
   Generated constructor for class as_expression_unary_amp.
   \author lsg
 */
as_expression_unary_amp::as_expression_unary_amp (ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_expression > a__as_unary_expression__expr)
        : as_unary_expression(a__as_base__location,
                a__as_unary_expression__expr)
{}

ptr< object::reflection_list > as_expression_unary_amp::reflection_get() const
{
        if (!reflection) {
                typedef class_reflection::field_metadata md;
                typedef class_reflection::field_metadata_list mdlist;
                ptr<mdlist> mdl = mdlist::create();
                reflection = reflection_list::create( as_unary_expression::reflection_get() );
                reflection->push_back( class_reflection::create( "as_expression_unary_amp", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_expression_unary_amp::field_values_get() const
{
        ptr < field_list_list > result = as_unary_expression::field_values_get();
        return result;
}


/*!
   Marking routine is used for garbage collection.
   \author lsg
 */
void as_expression_unary_amp::gc_mark()
{
        as_unary_expression::gc_mark();
}

// End of class as_expression_unary_amp.

// ------------- Class as_expression_unary_plus follows. -------------

void as_expression_unary_plus::accept_as_expr_visitor( ptr< as_expr_visitor > v )
{
        return v->visit_as_expression_unary_plus( this );
}

/*!
   This factory method for class as_expression_unary_plus takes values of all fields as arguments.
   \author lsg
 */
ptr< as_expression_unary_plus > as_expression_unary_plus::create(ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_expression > a__as_unary_expression__expr)
{
        return ptr< as_expression_unary_plus > ( new as_expression_unary_plus(a__as_base__location,
                a__as_unary_expression__expr) );
}

/*!
   Generated constructor for class as_expression_unary_plus.
   \author lsg
 */
as_expression_unary_plus::as_expression_unary_plus (ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_expression > a__as_unary_expression__expr)
        : as_unary_expression(a__as_base__location,
                a__as_unary_expression__expr)
{}

ptr< object::reflection_list > as_expression_unary_plus::reflection_get() const
{
        if (!reflection) {
                typedef class_reflection::field_metadata md;
                typedef class_reflection::field_metadata_list mdlist;
                ptr<mdlist> mdl = mdlist::create();
                reflection = reflection_list::create( as_unary_expression::reflection_get() );
                reflection->push_back( class_reflection::create( "as_expression_unary_plus", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_expression_unary_plus::field_values_get() const
{
        ptr < field_list_list > result = as_unary_expression::field_values_get();
        return result;
}


/*!
   Marking routine is used for garbage collection.
   \author lsg
 */
void as_expression_unary_plus::gc_mark()
{
        as_unary_expression::gc_mark();
}

// End of class as_expression_unary_plus.

// ------------- Class as_expression_unary_minus follows. -------------

void as_expression_unary_minus::accept_as_expr_visitor( ptr< as_expr_visitor > v )
{
        return v->visit_as_expression_unary_minus( this );
}

/*!
   This factory method for class as_expression_unary_minus takes values of all fields as arguments.
   \author lsg
 */
ptr< as_expression_unary_minus > as_expression_unary_minus::create(ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_expression > a__as_unary_expression__expr)
{
        return ptr< as_expression_unary_minus > ( new as_expression_unary_minus(a__as_base__location,
                a__as_unary_expression__expr) );
}

/*!
   Generated constructor for class as_expression_unary_minus.
   \author lsg
 */
as_expression_unary_minus::as_expression_unary_minus (ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_expression > a__as_unary_expression__expr)
        : as_unary_expression(a__as_base__location,
                a__as_unary_expression__expr)
{}

ptr< object::reflection_list > as_expression_unary_minus::reflection_get() const
{
        if (!reflection) {
                typedef class_reflection::field_metadata md;
                typedef class_reflection::field_metadata_list mdlist;
                ptr<mdlist> mdl = mdlist::create();
                reflection = reflection_list::create( as_unary_expression::reflection_get() );
                reflection->push_back( class_reflection::create( "as_expression_unary_minus", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_expression_unary_minus::field_values_get() const
{
        ptr < field_list_list > result = as_unary_expression::field_values_get();
        return result;
}


/*!
   Marking routine is used for garbage collection.
   \author lsg
 */
void as_expression_unary_minus::gc_mark()
{
        as_unary_expression::gc_mark();
}

// End of class as_expression_unary_minus.

// ------------- Class as_expression_unary_star follows. -------------

void as_expression_unary_star::accept_as_expr_visitor( ptr< as_expr_visitor > v )
{
        return v->visit_as_expression_unary_star( this );
}

/*!
   This factory method for class as_expression_unary_star takes values of all fields as arguments.
   \author lsg
 */
ptr< as_expression_unary_star > as_expression_unary_star::create(ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_expression > a__as_unary_expression__expr)
{
        return ptr< as_expression_unary_star > ( new as_expression_unary_star(a__as_base__location,
                a__as_unary_expression__expr) );
}

/*!
   Generated constructor for class as_expression_unary_star.
   \author lsg
 */
as_expression_unary_star::as_expression_unary_star (ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_expression > a__as_unary_expression__expr)
        : as_unary_expression(a__as_base__location,
                a__as_unary_expression__expr)
{}

ptr< object::reflection_list > as_expression_unary_star::reflection_get() const
{
        if (!reflection) {
                typedef class_reflection::field_metadata md;
                typedef class_reflection::field_metadata_list mdlist;
                ptr<mdlist> mdl = mdlist::create();
                reflection = reflection_list::create( as_unary_expression::reflection_get() );
                reflection->push_back( class_reflection::create( "as_expression_unary_star", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_expression_unary_star::field_values_get() const
{
        ptr < field_list_list > result = as_unary_expression::field_values_get();
        return result;
}


/*!
   Marking routine is used for garbage collection.
   \author lsg
 */
void as_expression_unary_star::gc_mark()
{
        as_unary_expression::gc_mark();
}

// End of class as_expression_unary_star.

// ------------- Class as_expression_tilde follows. -------------

void as_expression_tilde::accept_as_expr_visitor( ptr< as_expr_visitor > v )
{
        return v->visit_as_expression_tilde( this );
}

/*!
   This factory method for class as_expression_tilde takes values of all fields as arguments.
   \author lsg
 */
ptr< as_expression_tilde > as_expression_tilde::create(ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_expression > a__as_unary_expression__expr)
{
        return ptr< as_expression_tilde > ( new as_expression_tilde(a__as_base__location,
                a__as_unary_expression__expr) );
}

/*!
   Generated constructor for class as_expression_tilde.
   \author lsg
 */
as_expression_tilde::as_expression_tilde (ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_expression > a__as_unary_expression__expr)
        : as_unary_expression(a__as_base__location,
                a__as_unary_expression__expr)
{}

ptr< object::reflection_list > as_expression_tilde::reflection_get() const
{
        if (!reflection) {
                typedef class_reflection::field_metadata md;
                typedef class_reflection::field_metadata_list mdlist;
                ptr<mdlist> mdl = mdlist::create();
                reflection = reflection_list::create( as_unary_expression::reflection_get() );
                reflection->push_back( class_reflection::create( "as_expression_tilde", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_expression_tilde::field_values_get() const
{
        ptr < field_list_list > result = as_unary_expression::field_values_get();
        return result;
}


/*!
   Marking routine is used for garbage collection.
   \author lsg
 */
void as_expression_tilde::gc_mark()
{
        as_unary_expression::gc_mark();
}

// End of class as_expression_tilde.

// ------------- Class as_expression_exclam follows. -------------

void as_expression_exclam::accept_as_expr_visitor( ptr< as_expr_visitor > v )
{
        return v->visit_as_expression_exclam( this );
}

/*!
   This factory method for class as_expression_exclam takes values of all fields as arguments.
   \author lsg
 */
ptr< as_expression_exclam > as_expression_exclam::create(ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_expression > a__as_unary_expression__expr)
{
        return ptr< as_expression_exclam > ( new as_expression_exclam(a__as_base__location,
                a__as_unary_expression__expr) );
}

/*!
   Generated constructor for class as_expression_exclam.
   \author lsg
 */
as_expression_exclam::as_expression_exclam (ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_expression > a__as_unary_expression__expr)
        : as_unary_expression(a__as_base__location,
                a__as_unary_expression__expr)
{}

ptr< object::reflection_list > as_expression_exclam::reflection_get() const
{
        if (!reflection) {
                typedef class_reflection::field_metadata md;
                typedef class_reflection::field_metadata_list mdlist;
                ptr<mdlist> mdl = mdlist::create();
                reflection = reflection_list::create( as_unary_expression::reflection_get() );
                reflection->push_back( class_reflection::create( "as_expression_exclam", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_expression_exclam::field_values_get() const
{
        ptr < field_list_list > result = as_unary_expression::field_values_get();
        return result;
}


/*!
   Marking routine is used for garbage collection.
   \author lsg
 */
void as_expression_exclam::gc_mark()
{
        as_unary_expression::gc_mark();
}

// End of class as_expression_exclam.

// ------------- Class as_expression_sizeof_expr follows. -------------

void as_expression_sizeof_expr::accept_as_expr_visitor( ptr< as_expr_visitor > v )
{
        return v->visit_as_expression_sizeof_expr( this );
}

/*!
   This factory method for class as_expression_sizeof_expr takes values of all fields as arguments.
   \author lsg
 */
ptr< as_expression_sizeof_expr > as_expression_sizeof_expr::create(ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_expression > a__as_unary_expression__expr)
{
        return ptr< as_expression_sizeof_expr > ( new as_expression_sizeof_expr(a__as_base__location,
                a__as_unary_expression__expr) );
}

/*!
   Generated constructor for class as_expression_sizeof_expr.
   \author lsg
 */
as_expression_sizeof_expr::as_expression_sizeof_expr (ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_expression > a__as_unary_expression__expr)
        : as_unary_expression(a__as_base__location,
                a__as_unary_expression__expr)
{}

ptr< object::reflection_list > as_expression_sizeof_expr::reflection_get() const
{
        if (!reflection) {
                typedef class_reflection::field_metadata md;
                typedef class_reflection::field_metadata_list mdlist;
                ptr<mdlist> mdl = mdlist::create();
                reflection = reflection_list::create( as_unary_expression::reflection_get() );
                reflection->push_back( class_reflection::create( "as_expression_sizeof_expr", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_expression_sizeof_expr::field_values_get() const
{
        ptr < field_list_list > result = as_unary_expression::field_values_get();
        return result;
}


/*!
   Marking routine is used for garbage collection.
   \author lsg
 */
void as_expression_sizeof_expr::gc_mark()
{
        as_unary_expression::gc_mark();
}

// End of class as_expression_sizeof_expr.

// ------------- Class as_expression_typeid_expr follows. -------------

void as_expression_typeid_expr::accept_as_expr_visitor( ptr< as_expr_visitor > v )
{
        return v->visit_as_expression_typeid_expr( this );
}

/*!
   This factory method for class as_expression_typeid_expr takes values of all fields as arguments.
   \author lsg
 */
ptr< as_expression_typeid_expr > as_expression_typeid_expr::create(ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_expression > a__as_unary_expression__expr)
{
        return ptr< as_expression_typeid_expr > ( new as_expression_typeid_expr(a__as_base__location,
                a__as_unary_expression__expr) );
}

/*!
   Generated constructor for class as_expression_typeid_expr.
   \author lsg
 */
as_expression_typeid_expr::as_expression_typeid_expr (ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_expression > a__as_unary_expression__expr)
        : as_unary_expression(a__as_base__location,
                a__as_unary_expression__expr)
{}

ptr< object::reflection_list > as_expression_typeid_expr::reflection_get() const
{
        if (!reflection) {
                typedef class_reflection::field_metadata md;
                typedef class_reflection::field_metadata_list mdlist;
                ptr<mdlist> mdl = mdlist::create();
                reflection = reflection_list::create( as_unary_expression::reflection_get() );
                reflection->push_back( class_reflection::create( "as_expression_typeid_expr", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_expression_typeid_expr::field_values_get() const
{
        ptr < field_list_list > result = as_unary_expression::field_values_get();
        return result;
}


/*!
   Marking routine is used for garbage collection.
   \author lsg
 */
void as_expression_typeid_expr::gc_mark()
{
        as_unary_expression::gc_mark();
}

// End of class as_expression_typeid_expr.

// ------------- Class as_expression_delete_base follows. -------------

/*!
   \returns The value of as_expression_delete_base::context.
   \author lsg
 */
ptr< as_name > as_expression_delete_base::context_get() const
{
        return context;
}

/*!
   \param[in] x The new value to set as_expression_delete_base::context to.
   \author lsg
 */
void as_expression_delete_base::context_set(const ptr< as_name > & x)
{
        as_expression_delete_base::context = x;
}

void as_expression_delete_base::accept_as_expr_visitor( ptr< as_expr_visitor > v )
{
        return v->visit_as_expression_delete_base( this );
}

/*!
   This factory method for class as_expression_delete_base takes values of all fields as arguments.
   \author lsg
 */
ptr< as_expression_delete_base > as_expression_delete_base::create(ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_expression > a__as_unary_expression__expr,
                ptr< as_name > a__as_expression_delete_base__context)
{
        return ptr< as_expression_delete_base > ( new as_expression_delete_base(a__as_base__location,
                a__as_unary_expression__expr,
                a__as_expression_delete_base__context) );
}

/*!
   Generated constructor for class as_expression_delete_base.
   \author lsg
 */
as_expression_delete_base::as_expression_delete_base (ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_expression > a__as_unary_expression__expr,
                ptr< as_name > a__as_expression_delete_base__context)
        : as_unary_expression(a__as_base__location,
                a__as_unary_expression__expr), context(checked(a__as_expression_delete_base__context))
{}

ptr< object::reflection_list > as_expression_delete_base::reflection_get() const
{
        if (!reflection) {
                typedef class_reflection::field_metadata md;
                typedef class_reflection::field_metadata_list mdlist;
                ptr<mdlist> mdl = mdlist::create();
                mdl->push_back( md::create( "context", "as_name" ) );
                reflection = reflection_list::create( as_unary_expression::reflection_get() );
                reflection->push_back( class_reflection::create( "as_expression_delete_base", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_expression_delete_base::field_values_get() const
{
        ptr < field_list_list > result = as_unary_expression::field_values_get();
        result->push_back( value_list::create() );
        result->back()->push_back( this->context );
        return result;
}


/*!
   Marking routine is used for garbage collection.
   \author lsg
 */
void as_expression_delete_base::gc_mark()
{
        as_unary_expression::gc_mark();
}

// End of class as_expression_delete_base.

// ------------- Class as_expression_delete follows. -------------

void as_expression_delete::accept_as_expr_visitor( ptr< as_expr_visitor > v )
{
        return v->visit_as_expression_delete( this );
}

/*!
   This factory method for class as_expression_delete takes values of all fields as arguments.
   \author lsg
 */
ptr< as_expression_delete > as_expression_delete::create(ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_expression > a__as_unary_expression__expr,
                ptr< as_name > a__as_expression_delete_base__context)
{
        return ptr< as_expression_delete > ( new as_expression_delete(a__as_base__location,
                a__as_unary_expression__expr,
                a__as_expression_delete_base__context) );
}

/*!
   Generated constructor for class as_expression_delete.
   \author lsg
 */
as_expression_delete::as_expression_delete (ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_expression > a__as_unary_expression__expr,
                ptr< as_name > a__as_expression_delete_base__context)
        : as_expression_delete_base(a__as_base__location,
                a__as_unary_expression__expr,
                a__as_expression_delete_base__context)
{}

ptr< object::reflection_list > as_expression_delete::reflection_get() const
{
        if (!reflection) {
                typedef class_reflection::field_metadata md;
                typedef class_reflection::field_metadata_list mdlist;
                ptr<mdlist> mdl = mdlist::create();
                reflection = reflection_list::create( as_expression_delete_base::reflection_get() );
                reflection->push_back( class_reflection::create( "as_expression_delete", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_expression_delete::field_values_get() const
{
        ptr < field_list_list > result = as_expression_delete_base::field_values_get();
        return result;
}


/*!
   Marking routine is used for garbage collection.
   \author lsg
 */
void as_expression_delete::gc_mark()
{
        as_expression_delete_base::gc_mark();
}

// End of class as_expression_delete.

// ------------- Class as_expression_delete_array follows. -------------

void as_expression_delete_array::accept_as_expr_visitor( ptr< as_expr_visitor > v )
{
        return v->visit_as_expression_delete_array( this );
}

/*!
   This factory method for class as_expression_delete_array takes values of all fields as arguments.
   \author lsg
 */
ptr< as_expression_delete_array > as_expression_delete_array::create(ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_expression > a__as_unary_expression__expr,
                ptr< as_name > a__as_expression_delete_base__context)
{
        return ptr< as_expression_delete_array > ( new as_expression_delete_array(a__as_base__location,
                a__as_unary_expression__expr,
                a__as_expression_delete_base__context) );
}

/*!
   Generated constructor for class as_expression_delete_array.
   \author lsg
 */
as_expression_delete_array::as_expression_delete_array (ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_expression > a__as_unary_expression__expr,
                ptr< as_name > a__as_expression_delete_base__context)
        : as_expression_delete_base(a__as_base__location,
                a__as_unary_expression__expr,
                a__as_expression_delete_base__context)
{}

ptr< object::reflection_list > as_expression_delete_array::reflection_get() const
{
        if (!reflection) {
                typedef class_reflection::field_metadata md;
                typedef class_reflection::field_metadata_list mdlist;
                ptr<mdlist> mdl = mdlist::create();
                reflection = reflection_list::create( as_expression_delete_base::reflection_get() );
                reflection->push_back( class_reflection::create( "as_expression_delete_array", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_expression_delete_array::field_values_get() const
{
        ptr < field_list_list > result = as_expression_delete_base::field_values_get();
        return result;
}


/*!
   Marking routine is used for garbage collection.
   \author lsg
 */
void as_expression_delete_array::gc_mark()
{
        as_expression_delete_base::gc_mark();
}

// End of class as_expression_delete_array.

// ------------- Class as_expression_throw follows. -------------

void as_expression_throw::accept_as_expr_visitor( ptr< as_expr_visitor > v )
{
        return v->visit_as_expression_throw( this );
}

/*!
   This factory method for class as_expression_throw takes values of all fields as arguments.
   \author lsg
 */
ptr< as_expression_throw > as_expression_throw::create(ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_expression > a__as_unary_expression__expr)
{
        return ptr< as_expression_throw > ( new as_expression_throw(a__as_base__location,
                a__as_unary_expression__expr) );
}

/*!
   Generated constructor for class as_expression_throw.
   \author lsg
 */
as_expression_throw::as_expression_throw (ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_expression > a__as_unary_expression__expr)
        : as_unary_expression(a__as_base__location,
                a__as_unary_expression__expr)
{}

ptr< object::reflection_list > as_expression_throw::reflection_get() const
{
        if (!reflection) {
                typedef class_reflection::field_metadata md;
                typedef class_reflection::field_metadata_list mdlist;
                ptr<mdlist> mdl = mdlist::create();
                reflection = reflection_list::create( as_unary_expression::reflection_get() );
                reflection->push_back( class_reflection::create( "as_expression_throw", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_expression_throw::field_values_get() const
{
        ptr < field_list_list > result = as_unary_expression::field_values_get();
        return result;
}


/*!
   Marking routine is used for garbage collection.
   \author lsg
 */
void as_expression_throw::gc_mark()
{
        as_unary_expression::gc_mark();
}

// End of class as_expression_throw.

// ------------- Class as_expression_sizeof_type follows. -------------

/*!
   \returns The value of as_expression_sizeof_type::type_id.
   \author lsg
 */
ptr< as_type_id > as_expression_sizeof_type::type_id_get() const
{
        return type_id;
}

/*!
   \param[in] x The new value to set as_expression_sizeof_type::type_id to.
   \author lsg
 */
void as_expression_sizeof_type::type_id_set(const ptr< as_type_id > & x)
{
        as_expression_sizeof_type::type_id = x;
}

void as_expression_sizeof_type::accept_as_expr_visitor( ptr< as_expr_visitor > v )
{
        return v->visit_as_expression_sizeof_type( this );
}

/*!
   This factory method for class as_expression_sizeof_type takes values of all fields as arguments.
   \author lsg
 */
ptr< as_expression_sizeof_type > as_expression_sizeof_type::create(ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_type_id > a__as_expression_sizeof_type__type_id)
{
        return ptr< as_expression_sizeof_type > ( new as_expression_sizeof_type(a__as_base__location,
                a__as_expression_sizeof_type__type_id) );
}

/*!
   Generated constructor for class as_expression_sizeof_type.
   \author lsg
 */
as_expression_sizeof_type::as_expression_sizeof_type (ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_type_id > a__as_expression_sizeof_type__type_id)
        : as_expression(a__as_base__location), type_id(checked(a__as_expression_sizeof_type__type_id))
{}

ptr< object::reflection_list > as_expression_sizeof_type::reflection_get() const
{
        if (!reflection) {
                typedef class_reflection::field_metadata md;
                typedef class_reflection::field_metadata_list mdlist;
                ptr<mdlist> mdl = mdlist::create();
                mdl->push_back( md::create( "type_id", "as_type_id" ) );
                reflection = reflection_list::create( as_expression::reflection_get() );
                reflection->push_back( class_reflection::create( "as_expression_sizeof_type", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_expression_sizeof_type::field_values_get() const
{
        ptr < field_list_list > result = as_expression::field_values_get();
        result->push_back( value_list::create() );
        result->back()->push_back( this->type_id );
        return result;
}


/*!
   Marking routine is used for garbage collection.
   \author lsg
 */
void as_expression_sizeof_type::gc_mark()
{
        as_expression::gc_mark();
}

// End of class as_expression_sizeof_type.

// ------------- Class as_expression_typeid_type follows. -------------

/*!
   \returns The value of as_expression_typeid_type::type_id.
   \author lsg
 */
ptr< as_type_id > as_expression_typeid_type::type_id_get() const
{
        return type_id;
}

/*!
   \param[in] x The new value to set as_expression_typeid_type::type_id to.
   \author lsg
 */
void as_expression_typeid_type::type_id_set(const ptr< as_type_id > & x)
{
        as_expression_typeid_type::type_id = x;
}

void as_expression_typeid_type::accept_as_expr_visitor( ptr< as_expr_visitor > v )
{
        return v->visit_as_expression_typeid_type( this );
}

/*!
   This factory method for class as_expression_typeid_type takes values of all fields as arguments.
   \author lsg
 */
ptr< as_expression_typeid_type > as_expression_typeid_type::create(ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_type_id > a__as_expression_typeid_type__type_id)
{
        return ptr< as_expression_typeid_type > ( new as_expression_typeid_type(a__as_base__location,
                a__as_expression_typeid_type__type_id) );
}

/*!
   Generated constructor for class as_expression_typeid_type.
   \author lsg
 */
as_expression_typeid_type::as_expression_typeid_type (ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_type_id > a__as_expression_typeid_type__type_id)
        : as_expression(a__as_base__location), type_id(checked(a__as_expression_typeid_type__type_id))
{}

ptr< object::reflection_list > as_expression_typeid_type::reflection_get() const
{
        if (!reflection) {
                typedef class_reflection::field_metadata md;
                typedef class_reflection::field_metadata_list mdlist;
                ptr<mdlist> mdl = mdlist::create();
                mdl->push_back( md::create( "type_id", "as_type_id" ) );
                reflection = reflection_list::create( as_expression::reflection_get() );
                reflection->push_back( class_reflection::create( "as_expression_typeid_type", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_expression_typeid_type::field_values_get() const
{
        ptr < field_list_list > result = as_expression::field_values_get();
        result->push_back( value_list::create() );
        result->back()->push_back( this->type_id );
        return result;
}


/*!
   Marking routine is used for garbage collection.
   \author lsg
 */
void as_expression_typeid_type::gc_mark()
{
        as_expression::gc_mark();
}

// End of class as_expression_typeid_type.

// ------------- Class as_expression_new follows. -------------

/*!
   \returns The value of as_expression_new::context.
   \author lsg
 */
ptr< as_name > as_expression_new::context_get() const
{
        return context;
}

/*!
   \param[in] x The new value to set as_expression_new::context to.
   \author lsg
 */
void as_expression_new::context_set(const ptr< as_name > & x)
{
        as_expression_new::context = x;
}

/*!
   \returns The value of as_expression_new::new_placement.
   \author lsg
 */
ptr< ::lestes::std::list< srp< as_expression > > > as_expression_new::new_placement_get() const
{
        return new_placement;
}

/*!
   \param[in] x The new value to set as_expression_new::new_placement to.
   \author lsg
 */
void as_expression_new::new_placement_set(const ptr< ::lestes::std::list< srp< as_expression > > > & x)
{
        as_expression_new::new_placement = x;
}

/*!
   \returns The value of as_expression_new::type_id.
   \author lsg
 */
ptr< as_type_id > as_expression_new::type_id_get() const
{
        return type_id;
}

/*!
   \param[in] x The new value to set as_expression_new::type_id to.
   \author lsg
 */
void as_expression_new::type_id_set(const ptr< as_type_id > & x)
{
        as_expression_new::type_id = x;
}

/*!
   \returns The value of as_expression_new::initializer.
   \author lsg
 */
ptr< as_initializer > as_expression_new::initializer_get() const
{
        return initializer;
}

/*!
   \param[in] x The new value to set as_expression_new::initializer to.
   \author lsg
 */
void as_expression_new::initializer_set(const ptr< as_initializer > & x)
{
        as_expression_new::initializer = x;
}

void as_expression_new::accept_as_expr_visitor( ptr< as_expr_visitor > v )
{
        return v->visit_as_expression_new( this );
}

/*!
   This factory method for class as_expression_new takes values of all fields as arguments.
   \author lsg
 */
ptr< as_expression_new > as_expression_new::create(ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_name > a__as_expression_new__context,
                ptr< ::lestes::std::list< srp< as_expression > > > a__as_expression_new__new_placement,
                ptr< as_type_id > a__as_expression_new__type_id,
                ptr< as_initializer > a__as_expression_new__initializer)
{
        return ptr< as_expression_new > ( new as_expression_new(a__as_base__location,
                a__as_expression_new__context,
                a__as_expression_new__new_placement,
                a__as_expression_new__type_id,
                a__as_expression_new__initializer) );
}

/*!
   Generated constructor for class as_expression_new.
   \author lsg
 */
as_expression_new::as_expression_new (ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_name > a__as_expression_new__context,
                ptr< ::lestes::std::list< srp< as_expression > > > a__as_expression_new__new_placement,
                ptr< as_type_id > a__as_expression_new__type_id,
                ptr< as_initializer > a__as_expression_new__initializer)
        : as_expression(a__as_base__location), context(checked(a__as_expression_new__context)), new_placement(checked(a__as_expression_new__new_placement)), type_id(checked(a__as_expression_new__type_id)), initializer(a__as_expression_new__initializer)
{}

ptr< object::reflection_list > as_expression_new::reflection_get() const
{
        if (!reflection) {
                typedef class_reflection::field_metadata md;
                typedef class_reflection::field_metadata_list mdlist;
                ptr<mdlist> mdl = mdlist::create();
                mdl->push_back( md::create( "context", "as_name" ) );
                mdl->push_back( md::create( "new_placement", "list&lt; srp&lt; as_expression &gt; &gt;" ) );
                mdl->push_back( md::create( "type_id", "as_type_id" ) );
                mdl->push_back( md::create( "initializer", "as_initializer" ) );
                reflection = reflection_list::create( as_expression::reflection_get() );
                reflection->push_back( class_reflection::create( "as_expression_new", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_expression_new::field_values_get() const
{
        ptr < field_list_list > result = as_expression::field_values_get();
        result->push_back( value_list::create() );
        result->back()->push_back( this->context );
        result->push_back( value_list::create() );
        result->back()->push_back( this->new_placement );
        result->push_back( value_list::create() );
        result->back()->push_back( this->type_id );
        result->push_back( value_list::create() );
        result->back()->push_back( this->initializer );
        return result;
}


/*!
   Marking routine is used for garbage collection.
   \author lsg
 */
void as_expression_new::gc_mark()
{
        as_expression::gc_mark();
}

// End of class as_expression_new.

// ------------- Class as_this_expression follows. -------------

void as_this_expression::accept_as_expr_visitor( ptr< as_expr_visitor > v )
{
        return v->visit_as_this_expression( this );
}

/*!
   This factory method for class as_this_expression takes values of all fields as arguments.
   \author lsg
 */
ptr< as_this_expression > as_this_expression::create(ptr< ::lestes::std::source_location > a__as_base__location)
{
        return ptr< as_this_expression > ( new as_this_expression(a__as_base__location) );
}

/*!
   Generated constructor for class as_this_expression.
   \author lsg
 */
as_this_expression::as_this_expression (ptr< ::lestes::std::source_location > a__as_base__location)
        : as_expression(a__as_base__location)
{}

ptr< object::reflection_list > as_this_expression::reflection_get() const
{
        if (!reflection) {
                typedef class_reflection::field_metadata md;
                typedef class_reflection::field_metadata_list mdlist;
                ptr<mdlist> mdl = mdlist::create();
                reflection = reflection_list::create( as_expression::reflection_get() );
                reflection->push_back( class_reflection::create( "as_this_expression", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_this_expression::field_values_get() const
{
        ptr < field_list_list > result = as_expression::field_values_get();
        return result;
}


/*!
   Marking routine is used for garbage collection.
   \author lsg
 */
void as_this_expression::gc_mark()
{
        as_expression::gc_mark();
}

// End of class as_this_expression.

// ------------- Class as_literal follows. -------------

/*!
   \returns The value of as_literal::kind.
   \author lsg
 */
as_literal::literal_kind as_literal::kind_get() const
{
        return kind;
}

/*!
   \param[in] x The new value to set as_literal::kind to.
   \author lsg
 */
void as_literal::kind_set(literal_kind x)
{
        as_literal::kind = x;
}

/*!
   \returns The value of as_literal::value.
   \author lsg
 */
ptr< ::lestes::lang::cplus::lex::cpp_token > as_literal::value_get() const
{
        return value;
}

/*!
   \param[in] x The new value to set as_literal::value to.
   \author lsg
 */
void as_literal::value_set(const ptr< ::lestes::lang::cplus::lex::cpp_token > & x)
{
        as_literal::value = x;
}

void as_literal::accept_as_expr_visitor( ptr< as_expr_visitor > v )
{
        return v->visit_as_literal( this );
}

/*!
   This factory method for class as_literal takes values of all fields as arguments.
   \author lsg
 */
ptr< as_literal > as_literal::create(ptr< ::lestes::std::source_location > a__as_base__location,
                literal_kind a__as_literal__kind,
                ptr< ::lestes::lang::cplus::lex::cpp_token > a__as_literal__value)
{
        return ptr< as_literal > ( new as_literal(a__as_base__location,
                a__as_literal__kind,
                a__as_literal__value) );
}

/*!
   Generated constructor for class as_literal.
   \author lsg
 */
as_literal::as_literal (ptr< ::lestes::std::source_location > a__as_base__location,
                literal_kind a__as_literal__kind,
                ptr< ::lestes::lang::cplus::lex::cpp_token > a__as_literal__value)
        : as_expression(a__as_base__location), kind(a__as_literal__kind), value(checked(a__as_literal__value))
{}

ptr< object::reflection_list > as_literal::reflection_get() const
{
        if (!reflection) {
                typedef class_reflection::field_metadata md;
                typedef class_reflection::field_metadata_list mdlist;
                ptr<mdlist> mdl = mdlist::create();
                mdl->push_back( md::create( "kind", "literal_kind" ) );
                mdl->push_back( md::create( "value", "cpp_token" ) );
                reflection = reflection_list::create( as_expression::reflection_get() );
                reflection->push_back( class_reflection::create( "as_literal", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_literal::field_values_get() const
{
        ptr < field_list_list > result = as_expression::field_values_get();
        result->push_back( value_list::create() );
        result->back()->push_back( objectize< literal_kind > ::create( this->kind ) );
        result->push_back( value_list::create() );
        result->back()->push_back( this->value );
        return result;
}


/*!
   Marking routine is used for garbage collection.
   \author lsg
 */
void as_literal::gc_mark()
{
        as_expression::gc_mark();
}

// End of class as_literal.

// ------------- Class as_name_expression follows. -------------

/*!
   \returns The value of as_name_expression::name.
   \author lsg
 */
ptr< as_name > as_name_expression::name_get() const
{
        return name;
}

/*!
   \param[in] x The new value to set as_name_expression::name to.
   \author lsg
 */
void as_name_expression::name_set(const ptr< as_name > & x)
{
        as_name_expression::name = x;
}

void as_name_expression::accept_as_expr_visitor( ptr< as_expr_visitor > v )
{
        return v->visit_as_name_expression( this );
}

/*!
   This factory method for class as_name_expression takes values of all fields as arguments.
   \author lsg
 */
ptr< as_name_expression > as_name_expression::create(ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_name > a__as_name_expression__name)
{
        return ptr< as_name_expression > ( new as_name_expression(a__as_base__location,
                a__as_name_expression__name) );
}

/*!
   Generated constructor for class as_name_expression.
   \author lsg
 */
as_name_expression::as_name_expression (ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_name > a__as_name_expression__name)
        : as_expression(a__as_base__location), name(checked(a__as_name_expression__name))
{}

ptr< object::reflection_list > as_name_expression::reflection_get() const
{
        if (!reflection) {
                typedef class_reflection::field_metadata md;
                typedef class_reflection::field_metadata_list mdlist;
                ptr<mdlist> mdl = mdlist::create();
                mdl->push_back( md::create( "name", "as_name" ) );
                reflection = reflection_list::create( as_expression::reflection_get() );
                reflection->push_back( class_reflection::create( "as_name_expression", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_name_expression::field_values_get() const
{
        ptr < field_list_list > result = as_expression::field_values_get();
        result->push_back( value_list::create() );
        result->back()->push_back( this->name );
        return result;
}


/*!
   Marking routine is used for garbage collection.
   \author lsg
 */
void as_name_expression::gc_mark()
{
        as_expression::gc_mark();
}

// End of class as_name_expression.

// ------------- Class as_expression_cast_base follows. -------------

/*!
   \returns The value of as_expression_cast_base::type_id.
   \author lsg
 */
ptr< as_type_id > as_expression_cast_base::type_id_get() const
{
        return type_id;
}

/*!
   \param[in] x The new value to set as_expression_cast_base::type_id to.
   \author lsg
 */
void as_expression_cast_base::type_id_set(const ptr< as_type_id > & x)
{
        as_expression_cast_base::type_id = x;
}

/*!
   Generated constructor for class as_expression_cast_base.
   \author lsg
 */
as_expression_cast_base::as_expression_cast_base (ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_type_id > a__as_expression_cast_base__type_id)
        : as_expression(a__as_base__location), type_id(checked(a__as_expression_cast_base__type_id))
{}

ptr< object::reflection_list > as_expression_cast_base::reflection_get() const
{
        if (!reflection) {
                typedef class_reflection::field_metadata md;
                typedef class_reflection::field_metadata_list mdlist;
                ptr<mdlist> mdl = mdlist::create();
                mdl->push_back( md::create( "type_id", "as_type_id" ) );
                reflection = reflection_list::create( as_expression::reflection_get() );
                reflection->push_back( class_reflection::create( "as_expression_cast_base", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_expression_cast_base::field_values_get() const
{
        ptr < field_list_list > result = as_expression::field_values_get();
        result->push_back( value_list::create() );
        result->back()->push_back( this->type_id );
        return result;
}


/*!
   Marking routine is used for garbage collection.
   \author lsg
 */
void as_expression_cast_base::gc_mark()
{
        as_expression::gc_mark();
}

// End of class as_expression_cast_base.

// ------------- Class as_expression_cast_base_one follows. -------------

/*!
   \returns The value of as_expression_cast_base_one::expr.
   \author lsg
 */
ptr< as_expression > as_expression_cast_base_one::expr_get() const
{
        return expr;
}

/*!
   \param[in] x The new value to set as_expression_cast_base_one::expr to.
   \author lsg
 */
void as_expression_cast_base_one::expr_set(const ptr< as_expression > & x)
{
        as_expression_cast_base_one::expr = x;
}

/*!
   Generated constructor for class as_expression_cast_base_one.
   \author lsg
 */
as_expression_cast_base_one::as_expression_cast_base_one (ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_type_id > a__as_expression_cast_base__type_id,
                ptr< as_expression > a__as_expression_cast_base_one__expr)
        : as_expression_cast_base(a__as_base__location,
                a__as_expression_cast_base__type_id), expr(checked(a__as_expression_cast_base_one__expr))
{}

ptr< object::reflection_list > as_expression_cast_base_one::reflection_get() const
{
        if (!reflection) {
                typedef class_reflection::field_metadata md;
                typedef class_reflection::field_metadata_list mdlist;
                ptr<mdlist> mdl = mdlist::create();
                mdl->push_back( md::create( "expr", "as_expression" ) );
                reflection = reflection_list::create( as_expression_cast_base::reflection_get() );
                reflection->push_back( class_reflection::create( "as_expression_cast_base_one", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_expression_cast_base_one::field_values_get() const
{
        ptr < field_list_list > result = as_expression_cast_base::field_values_get();
        result->push_back( value_list::create() );
        result->back()->push_back( this->expr );
        return result;
}


/*!
   Marking routine is used for garbage collection.
   \author lsg
 */
void as_expression_cast_base_one::gc_mark()
{
        as_expression_cast_base::gc_mark();
}

// End of class as_expression_cast_base_one.

// ------------- Class as_expression_cast_base_list follows. -------------

/*!
   \returns The value of as_expression_cast_base_list::expressions.
   \author lsg
 */
ptr< ::lestes::std::list< srp< as_expression > > > as_expression_cast_base_list::expressions_get() const
{
        return expressions;
}

/*!
   \param[in] x The new value to set as_expression_cast_base_list::expressions to.
   \author lsg
 */
void as_expression_cast_base_list::expressions_set(const ptr< ::lestes::std::list< srp< as_expression > > > & x)
{
        as_expression_cast_base_list::expressions = x;
}

/*!
   Generated constructor for class as_expression_cast_base_list.
   \author lsg
 */
as_expression_cast_base_list::as_expression_cast_base_list (ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_type_id > a__as_expression_cast_base__type_id,
                ptr< ::lestes::std::list< srp< as_expression > > > a__as_expression_cast_base_list__expressions)
        : as_expression_cast_base(a__as_base__location,
                a__as_expression_cast_base__type_id), expressions(checked(a__as_expression_cast_base_list__expressions))
{}

ptr< object::reflection_list > as_expression_cast_base_list::reflection_get() const
{
        if (!reflection) {
                typedef class_reflection::field_metadata md;
                typedef class_reflection::field_metadata_list mdlist;
                ptr<mdlist> mdl = mdlist::create();
                mdl->push_back( md::create( "expressions", "list&lt; srp&lt; as_expression &gt; &gt;" ) );
                reflection = reflection_list::create( as_expression_cast_base::reflection_get() );
                reflection->push_back( class_reflection::create( "as_expression_cast_base_list", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_expression_cast_base_list::field_values_get() const
{
        ptr < field_list_list > result = as_expression_cast_base::field_values_get();
        result->push_back( value_list::create() );
        result->back()->push_back( this->expressions );
        return result;
}


/*!
   Marking routine is used for garbage collection.
   \author lsg
 */
void as_expression_cast_base_list::gc_mark()
{
        as_expression_cast_base::gc_mark();
}

// End of class as_expression_cast_base_list.

// ------------- Class as_expression_reinterpret_cast follows. -------------

void as_expression_reinterpret_cast::accept_as_expr_visitor( ptr< as_expr_visitor > v )
{
        return v->visit_as_expression_reinterpret_cast( this );
}

/*!
   This factory method for class as_expression_reinterpret_cast takes values of all fields as arguments.
   \author lsg
 */
ptr< as_expression_reinterpret_cast > as_expression_reinterpret_cast::create(ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_type_id > a__as_expression_cast_base__type_id,
                ptr< as_expression > a__as_expression_cast_base_one__expr)
{
        return ptr< as_expression_reinterpret_cast > ( new as_expression_reinterpret_cast(a__as_base__location,
                a__as_expression_cast_base__type_id,
                a__as_expression_cast_base_one__expr) );
}

/*!
   Generated constructor for class as_expression_reinterpret_cast.
   \author lsg
 */
as_expression_reinterpret_cast::as_expression_reinterpret_cast (ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_type_id > a__as_expression_cast_base__type_id,
                ptr< as_expression > a__as_expression_cast_base_one__expr)
        : as_expression_cast_base_one(a__as_base__location,
                a__as_expression_cast_base__type_id,
                a__as_expression_cast_base_one__expr)
{}

ptr< object::reflection_list > as_expression_reinterpret_cast::reflection_get() const
{
        if (!reflection) {
                typedef class_reflection::field_metadata md;
                typedef class_reflection::field_metadata_list mdlist;
                ptr<mdlist> mdl = mdlist::create();
                reflection = reflection_list::create( as_expression_cast_base_one::reflection_get() );
                reflection->push_back( class_reflection::create( "as_expression_reinterpret_cast", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_expression_reinterpret_cast::field_values_get() const
{
        ptr < field_list_list > result = as_expression_cast_base_one::field_values_get();
        return result;
}


/*!
   Marking routine is used for garbage collection.
   \author lsg
 */
void as_expression_reinterpret_cast::gc_mark()
{
        as_expression_cast_base_one::gc_mark();
}

// End of class as_expression_reinterpret_cast.

// ------------- Class as_expression_dynamic_cast follows. -------------

void as_expression_dynamic_cast::accept_as_expr_visitor( ptr< as_expr_visitor > v )
{
        return v->visit_as_expression_dynamic_cast( this );
}

/*!
   This factory method for class as_expression_dynamic_cast takes values of all fields as arguments.
   \author lsg
 */
ptr< as_expression_dynamic_cast > as_expression_dynamic_cast::create(ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_type_id > a__as_expression_cast_base__type_id,
                ptr< as_expression > a__as_expression_cast_base_one__expr)
{
        return ptr< as_expression_dynamic_cast > ( new as_expression_dynamic_cast(a__as_base__location,
                a__as_expression_cast_base__type_id,
                a__as_expression_cast_base_one__expr) );
}

/*!
   Generated constructor for class as_expression_dynamic_cast.
   \author lsg
 */
as_expression_dynamic_cast::as_expression_dynamic_cast (ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_type_id > a__as_expression_cast_base__type_id,
                ptr< as_expression > a__as_expression_cast_base_one__expr)
        : as_expression_cast_base_one(a__as_base__location,
                a__as_expression_cast_base__type_id,
                a__as_expression_cast_base_one__expr)
{}

ptr< object::reflection_list > as_expression_dynamic_cast::reflection_get() const
{
        if (!reflection) {
                typedef class_reflection::field_metadata md;
                typedef class_reflection::field_metadata_list mdlist;
                ptr<mdlist> mdl = mdlist::create();
                reflection = reflection_list::create( as_expression_cast_base_one::reflection_get() );
                reflection->push_back( class_reflection::create( "as_expression_dynamic_cast", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_expression_dynamic_cast::field_values_get() const
{
        ptr < field_list_list > result = as_expression_cast_base_one::field_values_get();
        return result;
}


/*!
   Marking routine is used for garbage collection.
   \author lsg
 */
void as_expression_dynamic_cast::gc_mark()
{
        as_expression_cast_base_one::gc_mark();
}

// End of class as_expression_dynamic_cast.

// ------------- Class as_expression_static_cast follows. -------------

void as_expression_static_cast::accept_as_expr_visitor( ptr< as_expr_visitor > v )
{
        return v->visit_as_expression_static_cast( this );
}

/*!
   This factory method for class as_expression_static_cast takes values of all fields as arguments.
   \author lsg
 */
ptr< as_expression_static_cast > as_expression_static_cast::create(ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_type_id > a__as_expression_cast_base__type_id,
                ptr< as_expression > a__as_expression_cast_base_one__expr)
{
        return ptr< as_expression_static_cast > ( new as_expression_static_cast(a__as_base__location,
                a__as_expression_cast_base__type_id,
                a__as_expression_cast_base_one__expr) );
}

/*!
   Generated constructor for class as_expression_static_cast.
   \author lsg
 */
as_expression_static_cast::as_expression_static_cast (ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_type_id > a__as_expression_cast_base__type_id,
                ptr< as_expression > a__as_expression_cast_base_one__expr)
        : as_expression_cast_base_one(a__as_base__location,
                a__as_expression_cast_base__type_id,
                a__as_expression_cast_base_one__expr)
{}

ptr< object::reflection_list > as_expression_static_cast::reflection_get() const
{
        if (!reflection) {
                typedef class_reflection::field_metadata md;
                typedef class_reflection::field_metadata_list mdlist;
                ptr<mdlist> mdl = mdlist::create();
                reflection = reflection_list::create( as_expression_cast_base_one::reflection_get() );
                reflection->push_back( class_reflection::create( "as_expression_static_cast", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_expression_static_cast::field_values_get() const
{
        ptr < field_list_list > result = as_expression_cast_base_one::field_values_get();
        return result;
}


/*!
   Marking routine is used for garbage collection.
   \author lsg
 */
void as_expression_static_cast::gc_mark()
{
        as_expression_cast_base_one::gc_mark();
}

// End of class as_expression_static_cast.

// ------------- Class as_expression_const_cast follows. -------------

void as_expression_const_cast::accept_as_expr_visitor( ptr< as_expr_visitor > v )
{
        return v->visit_as_expression_const_cast( this );
}

/*!
   This factory method for class as_expression_const_cast takes values of all fields as arguments.
   \author lsg
 */
ptr< as_expression_const_cast > as_expression_const_cast::create(ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_type_id > a__as_expression_cast_base__type_id,
                ptr< as_expression > a__as_expression_cast_base_one__expr)
{
        return ptr< as_expression_const_cast > ( new as_expression_const_cast(a__as_base__location,
                a__as_expression_cast_base__type_id,
                a__as_expression_cast_base_one__expr) );
}

/*!
   Generated constructor for class as_expression_const_cast.
   \author lsg
 */
as_expression_const_cast::as_expression_const_cast (ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_type_id > a__as_expression_cast_base__type_id,
                ptr< as_expression > a__as_expression_cast_base_one__expr)
        : as_expression_cast_base_one(a__as_base__location,
                a__as_expression_cast_base__type_id,
                a__as_expression_cast_base_one__expr)
{}

ptr< object::reflection_list > as_expression_const_cast::reflection_get() const
{
        if (!reflection) {
                typedef class_reflection::field_metadata md;
                typedef class_reflection::field_metadata_list mdlist;
                ptr<mdlist> mdl = mdlist::create();
                reflection = reflection_list::create( as_expression_cast_base_one::reflection_get() );
                reflection->push_back( class_reflection::create( "as_expression_const_cast", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_expression_const_cast::field_values_get() const
{
        ptr < field_list_list > result = as_expression_cast_base_one::field_values_get();
        return result;
}


/*!
   Marking routine is used for garbage collection.
   \author lsg
 */
void as_expression_const_cast::gc_mark()
{
        as_expression_cast_base_one::gc_mark();
}

// End of class as_expression_const_cast.

// ------------- Class as_expression_old_style_cast follows. -------------

void as_expression_old_style_cast::accept_as_expr_visitor( ptr< as_expr_visitor > v )
{
        return v->visit_as_expression_old_style_cast( this );
}

/*!
   This factory method for class as_expression_old_style_cast takes values of all fields as arguments.
   \author lsg
 */
ptr< as_expression_old_style_cast > as_expression_old_style_cast::create(ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_type_id > a__as_expression_cast_base__type_id,
                ptr< as_expression > a__as_expression_cast_base_one__expr)
{
        return ptr< as_expression_old_style_cast > ( new as_expression_old_style_cast(a__as_base__location,
                a__as_expression_cast_base__type_id,
                a__as_expression_cast_base_one__expr) );
}

/*!
   Generated constructor for class as_expression_old_style_cast.
   \author lsg
 */
as_expression_old_style_cast::as_expression_old_style_cast (ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_type_id > a__as_expression_cast_base__type_id,
                ptr< as_expression > a__as_expression_cast_base_one__expr)
        : as_expression_cast_base_one(a__as_base__location,
                a__as_expression_cast_base__type_id,
                a__as_expression_cast_base_one__expr)
{}

ptr< object::reflection_list > as_expression_old_style_cast::reflection_get() const
{
        if (!reflection) {
                typedef class_reflection::field_metadata md;
                typedef class_reflection::field_metadata_list mdlist;
                ptr<mdlist> mdl = mdlist::create();
                reflection = reflection_list::create( as_expression_cast_base_one::reflection_get() );
                reflection->push_back( class_reflection::create( "as_expression_old_style_cast", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_expression_old_style_cast::field_values_get() const
{
        ptr < field_list_list > result = as_expression_cast_base_one::field_values_get();
        return result;
}


/*!
   Marking routine is used for garbage collection.
   \author lsg
 */
void as_expression_old_style_cast::gc_mark()
{
        as_expression_cast_base_one::gc_mark();
}

// End of class as_expression_old_style_cast.

// ------------- Class as_expression_functional_style_cast follows. -------------

void as_expression_functional_style_cast::accept_as_expr_visitor( ptr< as_expr_visitor > v )
{
        return v->visit_as_expression_functional_style_cast( this );
}

/*!
   This factory method for class as_expression_functional_style_cast takes values of all fields as arguments.
   \author lsg
 */
ptr< as_expression_functional_style_cast > as_expression_functional_style_cast::create(ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_type_id > a__as_expression_cast_base__type_id,
                ptr< ::lestes::std::list< srp< as_expression > > > a__as_expression_cast_base_list__expressions)
{
        return ptr< as_expression_functional_style_cast > ( new as_expression_functional_style_cast(a__as_base__location,
                a__as_expression_cast_base__type_id,
                a__as_expression_cast_base_list__expressions) );
}

/*!
   Generated constructor for class as_expression_functional_style_cast.
   \author lsg
 */
as_expression_functional_style_cast::as_expression_functional_style_cast (ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_type_id > a__as_expression_cast_base__type_id,
                ptr< ::lestes::std::list< srp< as_expression > > > a__as_expression_cast_base_list__expressions)
        : as_expression_cast_base_list(a__as_base__location,
                a__as_expression_cast_base__type_id,
                a__as_expression_cast_base_list__expressions)
{}

ptr< object::reflection_list > as_expression_functional_style_cast::reflection_get() const
{
        if (!reflection) {
                typedef class_reflection::field_metadata md;
                typedef class_reflection::field_metadata_list mdlist;
                ptr<mdlist> mdl = mdlist::create();
                reflection = reflection_list::create( as_expression_cast_base_list::reflection_get() );
                reflection->push_back( class_reflection::create( "as_expression_functional_style_cast", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_expression_functional_style_cast::field_values_get() const
{
        ptr < field_list_list > result = as_expression_cast_base_list::field_values_get();
        return result;
}


/*!
   Marking routine is used for garbage collection.
   \author lsg
 */
void as_expression_functional_style_cast::gc_mark()
{
        as_expression_cast_base_list::gc_mark();
}

// End of class as_expression_functional_style_cast.

// ------------- Class as_postfix_expression follows. -------------

/*!
   Generated constructor for class as_postfix_expression.
   \author lsg
 */
as_postfix_expression::as_postfix_expression (ptr< ::lestes::std::source_location > a__as_base__location)
        : as_expression(a__as_base__location)
{}

ptr< object::reflection_list > as_postfix_expression::reflection_get() const
{
        if (!reflection) {
                typedef class_reflection::field_metadata md;
                typedef class_reflection::field_metadata_list mdlist;
                ptr<mdlist> mdl = mdlist::create();
                reflection = reflection_list::create( as_expression::reflection_get() );
                reflection->push_back( class_reflection::create( "as_postfix_expression", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_postfix_expression::field_values_get() const
{
        ptr < field_list_list > result = as_expression::field_values_get();
        return result;
}


/*!
   Marking routine is used for garbage collection.
   \author lsg
 */
void as_postfix_expression::gc_mark()
{
        as_expression::gc_mark();
}

// End of class as_postfix_expression.

// ------------- Class as_expression_member_access follows. -------------

/*!
   \returns The value of as_expression_member_access::prefix.
   \author lsg
 */
ptr< as_expression > as_expression_member_access::prefix_get() const
{
        return prefix;
}

/*!
   \param[in] x The new value to set as_expression_member_access::prefix to.
   \author lsg
 */
void as_expression_member_access::prefix_set(const ptr< as_expression > & x)
{
        as_expression_member_access::prefix = x;
}

/*!
   \returns The value of as_expression_member_access::postfix.
   \author lsg
 */
ptr< as_name > as_expression_member_access::postfix_get() const
{
        return postfix;
}

/*!
   \param[in] x The new value to set as_expression_member_access::postfix to.
   \author lsg
 */
void as_expression_member_access::postfix_set(const ptr< as_name > & x)
{
        as_expression_member_access::postfix = x;
}

/*!
   Generated constructor for class as_expression_member_access.
   \author lsg
 */
as_expression_member_access::as_expression_member_access (ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_expression > a__as_expression_member_access__prefix,
                ptr< as_name > a__as_expression_member_access__postfix)
        : as_postfix_expression(a__as_base__location), prefix(checked(a__as_expression_member_access__prefix)), postfix(checked(a__as_expression_member_access__postfix))
{}

ptr< object::reflection_list > as_expression_member_access::reflection_get() const
{
        if (!reflection) {
                typedef class_reflection::field_metadata md;
                typedef class_reflection::field_metadata_list mdlist;
                ptr<mdlist> mdl = mdlist::create();
                mdl->push_back( md::create( "prefix", "as_expression" ) );
                mdl->push_back( md::create( "postfix", "as_name" ) );
                reflection = reflection_list::create( as_postfix_expression::reflection_get() );
                reflection->push_back( class_reflection::create( "as_expression_member_access", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_expression_member_access::field_values_get() const
{
        ptr < field_list_list > result = as_postfix_expression::field_values_get();
        result->push_back( value_list::create() );
        result->back()->push_back( this->prefix );
        result->push_back( value_list::create() );
        result->back()->push_back( this->postfix );
        return result;
}


/*!
   Marking routine is used for garbage collection.
   \author lsg
 */
void as_expression_member_access::gc_mark()
{
        as_postfix_expression::gc_mark();
}

// End of class as_expression_member_access.

// ------------- Class as_expression_member_access_dot follows. -------------

void as_expression_member_access_dot::accept_as_expr_visitor( ptr< as_expr_visitor > v )
{
        return v->visit_as_expression_member_access_dot( this );
}

/*!
   This factory method for class as_expression_member_access_dot takes values of all fields as arguments.
   \author lsg
 */
ptr< as_expression_member_access_dot > as_expression_member_access_dot::create(ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_expression > a__as_expression_member_access__prefix,
                ptr< as_name > a__as_expression_member_access__postfix)
{
        return ptr< as_expression_member_access_dot > ( new as_expression_member_access_dot(a__as_base__location,
                a__as_expression_member_access__prefix,
                a__as_expression_member_access__postfix) );
}

/*!
   Generated constructor for class as_expression_member_access_dot.
   \author lsg
 */
as_expression_member_access_dot::as_expression_member_access_dot (ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_expression > a__as_expression_member_access__prefix,
                ptr< as_name > a__as_expression_member_access__postfix)
        : as_expression_member_access(a__as_base__location,
                a__as_expression_member_access__prefix,
                a__as_expression_member_access__postfix)
{}

ptr< object::reflection_list > as_expression_member_access_dot::reflection_get() const
{
        if (!reflection) {
                typedef class_reflection::field_metadata md;
                typedef class_reflection::field_metadata_list mdlist;
                ptr<mdlist> mdl = mdlist::create();
                reflection = reflection_list::create( as_expression_member_access::reflection_get() );
                reflection->push_back( class_reflection::create( "as_expression_member_access_dot", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_expression_member_access_dot::field_values_get() const
{
        ptr < field_list_list > result = as_expression_member_access::field_values_get();
        return result;
}


/*!
   Marking routine is used for garbage collection.
   \author lsg
 */
void as_expression_member_access_dot::gc_mark()
{
        as_expression_member_access::gc_mark();
}

// End of class as_expression_member_access_dot.

// ------------- Class as_expression_member_access_arrow follows. -------------

void as_expression_member_access_arrow::accept_as_expr_visitor( ptr< as_expr_visitor > v )
{
        return v->visit_as_expression_member_access_arrow( this );
}

/*!
   This factory method for class as_expression_member_access_arrow takes values of all fields as arguments.
   \author lsg
 */
ptr< as_expression_member_access_arrow > as_expression_member_access_arrow::create(ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_expression > a__as_expression_member_access__prefix,
                ptr< as_name > a__as_expression_member_access__postfix)
{
        return ptr< as_expression_member_access_arrow > ( new as_expression_member_access_arrow(a__as_base__location,
                a__as_expression_member_access__prefix,
                a__as_expression_member_access__postfix) );
}

/*!
   Generated constructor for class as_expression_member_access_arrow.
   \author lsg
 */
as_expression_member_access_arrow::as_expression_member_access_arrow (ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_expression > a__as_expression_member_access__prefix,
                ptr< as_name > a__as_expression_member_access__postfix)
        : as_expression_member_access(a__as_base__location,
                a__as_expression_member_access__prefix,
                a__as_expression_member_access__postfix)
{}

ptr< object::reflection_list > as_expression_member_access_arrow::reflection_get() const
{
        if (!reflection) {
                typedef class_reflection::field_metadata md;
                typedef class_reflection::field_metadata_list mdlist;
                ptr<mdlist> mdl = mdlist::create();
                reflection = reflection_list::create( as_expression_member_access::reflection_get() );
                reflection->push_back( class_reflection::create( "as_expression_member_access_arrow", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_expression_member_access_arrow::field_values_get() const
{
        ptr < field_list_list > result = as_expression_member_access::field_values_get();
        return result;
}


/*!
   Marking routine is used for garbage collection.
   \author lsg
 */
void as_expression_member_access_arrow::gc_mark()
{
        as_expression_member_access::gc_mark();
}

// End of class as_expression_member_access_arrow.

// ------------- Class as_expression_pseudo_destruct_dot follows. -------------

void as_expression_pseudo_destruct_dot::accept_as_expr_visitor( ptr< as_expr_visitor > v )
{
        return v->visit_as_expression_pseudo_destruct_dot( this );
}

/*!
   This factory method for class as_expression_pseudo_destruct_dot takes values of all fields as arguments.
   \author lsg
 */
ptr< as_expression_pseudo_destruct_dot > as_expression_pseudo_destruct_dot::create(ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_expression > a__as_expression_member_access__prefix,
                ptr< as_name > a__as_expression_member_access__postfix)
{
        return ptr< as_expression_pseudo_destruct_dot > ( new as_expression_pseudo_destruct_dot(a__as_base__location,
                a__as_expression_member_access__prefix,
                a__as_expression_member_access__postfix) );
}

/*!
   Generated constructor for class as_expression_pseudo_destruct_dot.
   \author lsg
 */
as_expression_pseudo_destruct_dot::as_expression_pseudo_destruct_dot (ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_expression > a__as_expression_member_access__prefix,
                ptr< as_name > a__as_expression_member_access__postfix)
        : as_expression_member_access(a__as_base__location,
                a__as_expression_member_access__prefix,
                a__as_expression_member_access__postfix)
{}

ptr< object::reflection_list > as_expression_pseudo_destruct_dot::reflection_get() const
{
        if (!reflection) {
                typedef class_reflection::field_metadata md;
                typedef class_reflection::field_metadata_list mdlist;
                ptr<mdlist> mdl = mdlist::create();
                reflection = reflection_list::create( as_expression_member_access::reflection_get() );
                reflection->push_back( class_reflection::create( "as_expression_pseudo_destruct_dot", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_expression_pseudo_destruct_dot::field_values_get() const
{
        ptr < field_list_list > result = as_expression_member_access::field_values_get();
        return result;
}


/*!
   Marking routine is used for garbage collection.
   \author lsg
 */
void as_expression_pseudo_destruct_dot::gc_mark()
{
        as_expression_member_access::gc_mark();
}

// End of class as_expression_pseudo_destruct_dot.

// ------------- Class as_expression_pseudo_destruct_arrow follows. -------------

void as_expression_pseudo_destruct_arrow::accept_as_expr_visitor( ptr< as_expr_visitor > v )
{
        return v->visit_as_expression_pseudo_destruct_arrow( this );
}

/*!
   This factory method for class as_expression_pseudo_destruct_arrow takes values of all fields as arguments.
   \author lsg
 */
ptr< as_expression_pseudo_destruct_arrow > as_expression_pseudo_destruct_arrow::create(ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_expression > a__as_expression_member_access__prefix,
                ptr< as_name > a__as_expression_member_access__postfix)
{
        return ptr< as_expression_pseudo_destruct_arrow > ( new as_expression_pseudo_destruct_arrow(a__as_base__location,
                a__as_expression_member_access__prefix,
                a__as_expression_member_access__postfix) );
}

/*!
   Generated constructor for class as_expression_pseudo_destruct_arrow.
   \author lsg
 */
as_expression_pseudo_destruct_arrow::as_expression_pseudo_destruct_arrow (ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_expression > a__as_expression_member_access__prefix,
                ptr< as_name > a__as_expression_member_access__postfix)
        : as_expression_member_access(a__as_base__location,
                a__as_expression_member_access__prefix,
                a__as_expression_member_access__postfix)
{}

ptr< object::reflection_list > as_expression_pseudo_destruct_arrow::reflection_get() const
{
        if (!reflection) {
                typedef class_reflection::field_metadata md;
                typedef class_reflection::field_metadata_list mdlist;
                ptr<mdlist> mdl = mdlist::create();
                reflection = reflection_list::create( as_expression_member_access::reflection_get() );
                reflection->push_back( class_reflection::create( "as_expression_pseudo_destruct_arrow", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_expression_pseudo_destruct_arrow::field_values_get() const
{
        ptr < field_list_list > result = as_expression_member_access::field_values_get();
        return result;
}


/*!
   Marking routine is used for garbage collection.
   \author lsg
 */
void as_expression_pseudo_destruct_arrow::gc_mark()
{
        as_expression_member_access::gc_mark();
}

// End of class as_expression_pseudo_destruct_arrow.

// ------------- Class as_expression_function_call follows. -------------

/*!
   \returns The value of as_expression_function_call::prefix.
   \author lsg
 */
ptr< as_expression > as_expression_function_call::prefix_get() const
{
        return prefix;
}

/*!
   \param[in] x The new value to set as_expression_function_call::prefix to.
   \author lsg
 */
void as_expression_function_call::prefix_set(const ptr< as_expression > & x)
{
        as_expression_function_call::prefix = x;
}

/*!
   \returns The value of as_expression_function_call::arguments.
   \author lsg
 */
ptr< ::lestes::std::list< srp< as_expression > > > as_expression_function_call::arguments_get() const
{
        return arguments;
}

/*!
   \param[in] x The new value to set as_expression_function_call::arguments to.
   \author lsg
 */
void as_expression_function_call::arguments_set(const ptr< ::lestes::std::list< srp< as_expression > > > & x)
{
        as_expression_function_call::arguments = x;
}

void as_expression_function_call::accept_as_expr_visitor( ptr< as_expr_visitor > v )
{
        return v->visit_as_expression_function_call( this );
}

/*!
   This factory method for class as_expression_function_call takes values of all fields as arguments.
   \author lsg
 */
ptr< as_expression_function_call > as_expression_function_call::create(ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_expression > a__as_expression_function_call__prefix,
                ptr< ::lestes::std::list< srp< as_expression > > > a__as_expression_function_call__arguments)
{
        return ptr< as_expression_function_call > ( new as_expression_function_call(a__as_base__location,
                a__as_expression_function_call__prefix,
                a__as_expression_function_call__arguments) );
}

/*!
   Generated constructor for class as_expression_function_call.
   \author lsg
 */
as_expression_function_call::as_expression_function_call (ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_expression > a__as_expression_function_call__prefix,
                ptr< ::lestes::std::list< srp< as_expression > > > a__as_expression_function_call__arguments)
        : as_expression(a__as_base__location), prefix(checked(a__as_expression_function_call__prefix)), arguments(checked(a__as_expression_function_call__arguments))
{}

ptr< object::reflection_list > as_expression_function_call::reflection_get() const
{
        if (!reflection) {
                typedef class_reflection::field_metadata md;
                typedef class_reflection::field_metadata_list mdlist;
                ptr<mdlist> mdl = mdlist::create();
                mdl->push_back( md::create( "prefix", "as_expression" ) );
                mdl->push_back( md::create( "arguments", "list&lt; srp&lt; as_expression &gt; &gt;" ) );
                reflection = reflection_list::create( as_expression::reflection_get() );
                reflection->push_back( class_reflection::create( "as_expression_function_call", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_expression_function_call::field_values_get() const
{
        ptr < field_list_list > result = as_expression::field_values_get();
        result->push_back( value_list::create() );
        result->back()->push_back( this->prefix );
        result->push_back( value_list::create() );
        result->back()->push_back( this->arguments );
        return result;
}


/*!
   Marking routine is used for garbage collection.
   \author lsg
 */
void as_expression_function_call::gc_mark()
{
        as_expression::gc_mark();
}

// End of class as_expression_function_call.

// ------------- Class as_constant_expression follows. -------------

void as_constant_expression::accept_as_expr_visitor( ptr< as_expr_visitor > v )
{
        return v->visit_as_constant_expression( this );
}

/*!
   This factory method for class as_constant_expression takes values of all fields as arguments.
   \author lsg
 */
ptr< as_constant_expression > as_constant_expression::create(ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_expression > a__as_unary_expression__expr)
{
        return ptr< as_constant_expression > ( new as_constant_expression(a__as_base__location,
                a__as_unary_expression__expr) );
}

/*!
   Generated constructor for class as_constant_expression.
   \author lsg
 */
as_constant_expression::as_constant_expression (ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_expression > a__as_unary_expression__expr)
        : as_unary_expression(a__as_base__location,
                a__as_unary_expression__expr)
{}

ptr< object::reflection_list > as_constant_expression::reflection_get() const
{
        if (!reflection) {
                typedef class_reflection::field_metadata md;
                typedef class_reflection::field_metadata_list mdlist;
                ptr<mdlist> mdl = mdlist::create();
                reflection = reflection_list::create( as_unary_expression::reflection_get() );
                reflection->push_back( class_reflection::create( "as_constant_expression", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_constant_expression::field_values_get() const
{
        ptr < field_list_list > result = as_unary_expression::field_values_get();
        return result;
}


/*!
   Marking routine is used for garbage collection.
   \author lsg
 */
void as_constant_expression::gc_mark()
{
        as_unary_expression::gc_mark();
}

// End of class as_constant_expression.


// static data members follow 
ptr<object::reflection_list> as_expression::reflection = reflection;
ptr<object::reflection_list> as_empty_expression::reflection = reflection;
ptr<object::reflection_list> as_binary_expression::reflection = reflection;
ptr<object::reflection_list> as_unary_expression::reflection = reflection;
ptr<object::reflection_list> as_ternary_expression::reflection = reflection;
ptr<object::reflection_list> as_expression_qmark::reflection = reflection;
ptr<object::reflection_list> as_expression_comma::reflection = reflection;
ptr<object::reflection_list> as_expression_equal::reflection = reflection;
ptr<object::reflection_list> as_expression_plus_equal::reflection = reflection;
ptr<object::reflection_list> as_expression_minus_equal::reflection = reflection;
ptr<object::reflection_list> as_expression_star_equal::reflection = reflection;
ptr<object::reflection_list> as_expression_slash_equal::reflection = reflection;
ptr<object::reflection_list> as_expression_percent_equal::reflection = reflection;
ptr<object::reflection_list> as_expression_hat_equal::reflection = reflection;
ptr<object::reflection_list> as_expression_amp_equal::reflection = reflection;
ptr<object::reflection_list> as_expression_vbar_equal::reflection = reflection;
ptr<object::reflection_list> as_expression_less_less_equal::reflection = reflection;
ptr<object::reflection_list> as_expression_greater_greater_equal::reflection = reflection;
ptr<object::reflection_list> as_expression_equal_equal::reflection = reflection;
ptr<object::reflection_list> as_expression_exclam_equal::reflection = reflection;
ptr<object::reflection_list> as_expression_less_equal::reflection = reflection;
ptr<object::reflection_list> as_expression_greater_equal::reflection = reflection;
ptr<object::reflection_list> as_expression_less::reflection = reflection;
ptr<object::reflection_list> as_expression_greater::reflection = reflection;
ptr<object::reflection_list> as_expression_vbar_vbar::reflection = reflection;
ptr<object::reflection_list> as_expression_amp_amp::reflection = reflection;
ptr<object::reflection_list> as_expression_vbar::reflection = reflection;
ptr<object::reflection_list> as_expression_amp::reflection = reflection;
ptr<object::reflection_list> as_expression_hat::reflection = reflection;
ptr<object::reflection_list> as_expression_less_less::reflection = reflection;
ptr<object::reflection_list> as_expression_greater_greater::reflection = reflection;
ptr<object::reflection_list> as_expression_plus::reflection = reflection;
ptr<object::reflection_list> as_expression_minus::reflection = reflection;
ptr<object::reflection_list> as_expression_star::reflection = reflection;
ptr<object::reflection_list> as_expression_slash::reflection = reflection;
ptr<object::reflection_list> as_expression_percent::reflection = reflection;
ptr<object::reflection_list> as_expression_dot_star::reflection = reflection;
ptr<object::reflection_list> as_expression_minus_greater_star::reflection = reflection;
ptr<object::reflection_list> as_expression_brackets::reflection = reflection;
ptr<object::reflection_list> as_expression_plus_plus_pre::reflection = reflection;
ptr<object::reflection_list> as_expression_plus_plus_post::reflection = reflection;
ptr<object::reflection_list> as_expression_minus_minus_pre::reflection = reflection;
ptr<object::reflection_list> as_expression_minus_minus_post::reflection = reflection;
ptr<object::reflection_list> as_expression_unary_amp::reflection = reflection;
ptr<object::reflection_list> as_expression_unary_plus::reflection = reflection;
ptr<object::reflection_list> as_expression_unary_minus::reflection = reflection;
ptr<object::reflection_list> as_expression_unary_star::reflection = reflection;
ptr<object::reflection_list> as_expression_tilde::reflection = reflection;
ptr<object::reflection_list> as_expression_exclam::reflection = reflection;
ptr<object::reflection_list> as_expression_sizeof_expr::reflection = reflection;
ptr<object::reflection_list> as_expression_typeid_expr::reflection = reflection;
ptr<object::reflection_list> as_expression_delete_base::reflection = reflection;
ptr<object::reflection_list> as_expression_delete::reflection = reflection;
ptr<object::reflection_list> as_expression_delete_array::reflection = reflection;
ptr<object::reflection_list> as_expression_throw::reflection = reflection;
ptr<object::reflection_list> as_expression_sizeof_type::reflection = reflection;
ptr<object::reflection_list> as_expression_typeid_type::reflection = reflection;
ptr<object::reflection_list> as_expression_new::reflection = reflection;
ptr<object::reflection_list> as_this_expression::reflection = reflection;
ptr<object::reflection_list> as_literal::reflection = reflection;
ptr<object::reflection_list> as_name_expression::reflection = reflection;
ptr<object::reflection_list> as_expression_cast_base::reflection = reflection;
ptr<object::reflection_list> as_expression_cast_base_one::reflection = reflection;
ptr<object::reflection_list> as_expression_cast_base_list::reflection = reflection;
ptr<object::reflection_list> as_expression_reinterpret_cast::reflection = reflection;
ptr<object::reflection_list> as_expression_dynamic_cast::reflection = reflection;
ptr<object::reflection_list> as_expression_static_cast::reflection = reflection;
ptr<object::reflection_list> as_expression_const_cast::reflection = reflection;
ptr<object::reflection_list> as_expression_old_style_cast::reflection = reflection;
ptr<object::reflection_list> as_expression_functional_style_cast::reflection = reflection;
ptr<object::reflection_list> as_postfix_expression::reflection = reflection;
ptr<object::reflection_list> as_expression_member_access::reflection = reflection;
ptr<object::reflection_list> as_expression_member_access_dot::reflection = reflection;
ptr<object::reflection_list> as_expression_member_access_arrow::reflection = reflection;
ptr<object::reflection_list> as_expression_pseudo_destruct_dot::reflection = reflection;
ptr<object::reflection_list> as_expression_pseudo_destruct_arrow::reflection = reflection;
ptr<object::reflection_list> as_expression_function_call::reflection = reflection;
ptr<object::reflection_list> as_constant_expression::reflection = reflection;

end_package(sem);
end_package(cplus);
end_package(lang);
end_package(lestes);

---