as_decl.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_access_specifier_visitor.v.g.hh>
#include <lestes/lang/cplus/sem/as_declaration_specifier_visitor.v.g.hh>
#include <lestes/lang/cplus/sem/as_declarator_op_visitor.v.g.hh>
#include <lestes/lang/cplus/sem/as_cv_qualifier_visitor.v.g.hh>
#include <lestes/lang/cplus/sem/as_id_visitor.v.g.hh>
#include <lestes/lang/cplus/sem/as_class_key_visitor.v.g.hh>
#include <lestes/lang/cplus/sem/as_expr.g.hh>
#include <lestes/lang/cplus/sem/as_statements.g.hh>
#include <lestes/lang/cplus/lex/cpp_token.hh>
#include <lestes/lang/cplus/syn/token.hh>

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

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

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


// ------------- Class as_string_literal follows. -------------

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

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

ptr< object::reflection_list > as_string_literal::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_string_literal", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_string_literal::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_string_literal::gc_mark()
{
	::lestes::intercode::as_base::gc_mark();
}

// End of class as_string_literal.

// ------------- Class as_declaration follows. -------------

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

ptr< object::reflection_list > as_declaration::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_declaration", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_declaration::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_declaration::gc_mark()
{
	::lestes::intercode::as_base::gc_mark();
}

// End of class as_declaration.

// ------------- Class as_block_declaration follows. -------------

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

ptr< object::reflection_list > as_block_declaration::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_declaration::reflection_get() );
                reflection->push_back( class_reflection::create( "as_block_declaration", mdl ) );
        }
        return reflection;
}

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


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

// End of class as_block_declaration.

// ------------- Class as_simple_declaration follows. -------------

/*!
   \returns The value of as_simple_declaration::declaration_specifiers.
   \author lsg
 */
ptr< ::lestes::std::list< srp< as_declaration_specifier > > > as_simple_declaration::declaration_specifiers_get() const
{
        return declaration_specifiers;
}

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

/*!
   \returns The value of as_simple_declaration::init_declarators.
   \author lsg
 */
ptr< ::lestes::std::list< srp< as_init_declarator > > > as_simple_declaration::init_declarators_get() const
{
        return init_declarators;
}

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

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

/*!
   Generated constructor for class as_simple_declaration.
   \author lsg
 */
as_simple_declaration::as_simple_declaration (ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< ::lestes::std::list< srp< as_declaration_specifier > > > a__as_simple_declaration__declaration_specifiers,
                ptr< ::lestes::std::list< srp< as_init_declarator > > > a__as_simple_declaration__init_declarators)
        : as_block_declaration(a__as_base__location), declaration_specifiers(checked(a__as_simple_declaration__declaration_specifiers)), init_declarators(checked(a__as_simple_declaration__init_declarators))
{}

ptr< object::reflection_list > as_simple_declaration::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( "declaration_specifiers", "list&lt; srp&lt; as_declaration_specifier &gt; &gt;" ) );
                mdl->push_back( md::create( "init_declarators", "list&lt; srp&lt; as_init_declarator &gt; &gt;" ) );
                reflection = reflection_list::create( as_block_declaration::reflection_get() );
                reflection->push_back( class_reflection::create( "as_simple_declaration", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_simple_declaration::field_values_get() const
{
        ptr < field_list_list > result = as_block_declaration::field_values_get();
        result->push_back( value_list::create() );
        result->back()->push_back( this->declaration_specifiers );
        result->push_back( value_list::create() );
        result->back()->push_back( this->init_declarators );
        return result;
}


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

// End of class as_simple_declaration.

// ------------- Class as_init_declarator follows. -------------

/*!
   \returns The value of as_init_declarator::declarator.
   \author lsg
 */
ptr< as_declarator > as_init_declarator::declarator_get() const
{
        return declarator;
}

/*!
   \param[in] x The new value to set as_init_declarator::declarator to.
   \author lsg
 */
void as_init_declarator::declarator_set(const ptr< as_declarator > & x)
{
        as_init_declarator::declarator = x;
}

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

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

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

/*!
   Generated constructor for class as_init_declarator.
   \author lsg
 */
as_init_declarator::as_init_declarator (ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_declarator > a__as_init_declarator__declarator,
                ptr< as_initializer > a__as_init_declarator__initializer)
        : as_base(a__as_base__location), declarator(checked(a__as_init_declarator__declarator)), initializer(a__as_init_declarator__initializer)
{}

ptr< object::reflection_list > as_init_declarator::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( "declarator", "as_declarator" ) );
                mdl->push_back( md::create( "initializer", "as_initializer" ) );
                reflection = reflection_list::create( ::lestes::intercode::as_base::reflection_get() );
                reflection->push_back( class_reflection::create( "as_init_declarator", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_init_declarator::field_values_get() const
{
        ptr < field_list_list > result = ::lestes::intercode::as_base::field_values_get();
        result->push_back( value_list::create() );
        result->back()->push_back( this->declarator );
        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_init_declarator::gc_mark()
{
	::lestes::intercode::as_base::gc_mark();
}

// End of class as_init_declarator.

// ------------- Class as_initializer follows. -------------

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

ptr< object::reflection_list > as_initializer::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_initializer", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_initializer::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_initializer::gc_mark()
{
	::lestes::intercode::as_base::gc_mark();
}

// End of class as_initializer.

// ------------- Class as_initializer_expression_list follows. -------------

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

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

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

/*!
   Generated constructor for class as_initializer_expression_list.
   \author lsg
 */
as_initializer_expression_list::as_initializer_expression_list (ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< ::lestes::std::list< srp< as_expression > > > a__as_initializer_expression_list__expressions)
        : as_initializer(a__as_base__location), expressions(checked(a__as_initializer_expression_list__expressions))
{}

ptr< object::reflection_list > as_initializer_expression_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_initializer::reflection_get() );
                reflection->push_back( class_reflection::create( "as_initializer_expression_list", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_initializer_expression_list::field_values_get() const
{
        ptr < field_list_list > result = as_initializer::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_initializer_expression_list::gc_mark()
{
        as_initializer::gc_mark();
}

// End of class as_initializer_expression_list.

// ------------- Class as_initializer_clause follows. -------------

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

ptr< object::reflection_list > as_initializer_clause::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_initializer::reflection_get() );
                reflection->push_back( class_reflection::create( "as_initializer_clause", mdl ) );
        }
        return reflection;
}

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


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

// End of class as_initializer_clause.

// ------------- Class as_initializer_clause_expression follows. -------------

/*!
   \returns The value of as_initializer_clause_expression::expression.
   \author lsg
 */
ptr< as_expression > as_initializer_clause_expression::expression_get() const
{
        return expression;
}

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

void as_initializer_clause_expression::accept_as_initializer_clause_visitor( ptr< as_initializer_clause_visitor > v )
{
        return v->visit_as_initializer_clause_expression( this );
}

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

/*!
   Generated constructor for class as_initializer_clause_expression.
   \author lsg
 */
as_initializer_clause_expression::as_initializer_clause_expression (ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_expression > a__as_initializer_clause_expression__expression)
        : as_initializer_clause(a__as_base__location), expression(checked(a__as_initializer_clause_expression__expression))
{}

ptr< object::reflection_list > as_initializer_clause_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( "expression", "as_expression" ) );
                reflection = reflection_list::create( as_initializer_clause::reflection_get() );
                reflection->push_back( class_reflection::create( "as_initializer_clause_expression", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_initializer_clause_expression::field_values_get() const
{
        ptr < field_list_list > result = as_initializer_clause::field_values_get();
        result->push_back( value_list::create() );
        result->back()->push_back( this->expression );
        return result;
}


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

// End of class as_initializer_clause_expression.

// ------------- Class as_initializer_clause_braced follows. -------------

/*!
   \returns The value of as_initializer_clause_braced::initializers.
   \author lsg
 */
ptr< ::lestes::std::list< srp< as_initializer_clause > > > as_initializer_clause_braced::initializers_get() const
{
        return initializers;
}

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

void as_initializer_clause_braced::accept_as_initializer_clause_visitor( ptr< as_initializer_clause_visitor > v )
{
        return v->visit_as_initializer_clause_braced( this );
}

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

/*!
   Generated constructor for class as_initializer_clause_braced.
   \author lsg
 */
as_initializer_clause_braced::as_initializer_clause_braced (ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< ::lestes::std::list< srp< as_initializer_clause > > > a__as_initializer_clause_braced__initializers)
        : as_initializer_clause(a__as_base__location), initializers(checked(a__as_initializer_clause_braced__initializers))
{}

ptr< object::reflection_list > as_initializer_clause_braced::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( "initializers", "list&lt; srp&lt; as_initializer_clause &gt; &gt;" ) );
                reflection = reflection_list::create( as_initializer_clause::reflection_get() );
                reflection->push_back( class_reflection::create( "as_initializer_clause_braced", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_initializer_clause_braced::field_values_get() const
{
        ptr < field_list_list > result = as_initializer_clause::field_values_get();
        result->push_back( value_list::create() );
        result->back()->push_back( this->initializers );
        return result;
}


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

// End of class as_initializer_clause_braced.

// ------------- Class as_function_definition follows. -------------

/*!
   \returns The value of as_function_definition::declaration_specifiers.
   \author lsg
 */
ptr< ::lestes::std::list< srp< as_declaration_specifier > > > as_function_definition::declaration_specifiers_get() const
{
        return declaration_specifiers;
}

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

/*!
   \returns The value of as_function_definition::declarator.
   \author lsg
 */
ptr< as_declarator > as_function_definition::declarator_get() const
{
        return declarator;
}

/*!
   \param[in] x The new value to set as_function_definition::declarator to.
   \author lsg
 */
void as_function_definition::declarator_set(const ptr< as_declarator > & x)
{
        as_function_definition::declarator = x;
}

/*!
   \returns The value of as_function_definition::mem_initializers.
   \author lsg
 */
ptr< ::lestes::std::list< srp< as_mem_initializer > > > as_function_definition::mem_initializers_get() const
{
        return mem_initializers;
}

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

/*!
   \returns The value of as_function_definition::function_body.
   \author lsg
 */
ptr< ::lestes::lang::cplus::syn::bison_pack_token > as_function_definition::function_body_get() const
{
        return function_body;
}

/*!
   \param[in] x The new value to set as_function_definition::function_body to.
   \author lsg
 */
void as_function_definition::function_body_set(const ptr< ::lestes::lang::cplus::syn::bison_pack_token > & x)
{
        as_function_definition::function_body = x;
}

/*!
   \returns The value of as_function_definition::handlers.
   \author lsg
 */
ptr< ::lestes::std::list< srp< as_handler > > > as_function_definition::handlers_get() const
{
        return handlers;
}

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

/*!
   \returns The value of as_function_definition::parsed_body.
   \author lsg
 */
ptr< ::lestes::intercode::as_base > as_function_definition::parsed_body_get() const
{
        return parsed_body;
}

/*!
   \param[in] x The new value to set as_function_definition::parsed_body to.
   \author lsg
 */
void as_function_definition::parsed_body_set(const ptr< ::lestes::intercode::as_base > & x)
{
        as_function_definition::parsed_body = x;
}

/*!
   This factory method for class as_function_definition takes values of all fields as arguments.
   \author lsg
 */
ptr< as_function_definition > as_function_definition::create(ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< ::lestes::std::list< srp< as_declaration_specifier > > > a__as_function_definition__declaration_specifiers,
                ptr< as_declarator > a__as_function_definition__declarator,
                ptr< ::lestes::std::list< srp< as_mem_initializer > > > a__as_function_definition__mem_initializers,
                ptr< ::lestes::lang::cplus::syn::bison_pack_token > a__as_function_definition__function_body,
                ptr< ::lestes::std::list< srp< as_handler > > > a__as_function_definition__handlers,
                ptr< ::lestes::intercode::as_base > a__as_function_definition__parsed_body)
{
        return ptr< as_function_definition > ( new as_function_definition(a__as_base__location,
                a__as_function_definition__declaration_specifiers,
                a__as_function_definition__declarator,
                a__as_function_definition__mem_initializers,
                a__as_function_definition__function_body,
                a__as_function_definition__handlers,
                a__as_function_definition__parsed_body) );
}

/*!
   This factory method for class as_function_definition uses initializers.
   \author lsg
 */
ptr< as_function_definition > as_function_definition::create(ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< ::lestes::std::list< srp< as_declaration_specifier > > > a__as_function_definition__declaration_specifiers,
                ptr< as_declarator > a__as_function_definition__declarator,
                ptr< ::lestes::std::list< srp< as_mem_initializer > > > a__as_function_definition__mem_initializers,
                ptr< ::lestes::lang::cplus::syn::bison_pack_token > a__as_function_definition__function_body,
                ptr< ::lestes::std::list< srp< as_handler > > > a__as_function_definition__handlers)
{
        return ptr< as_function_definition > ( new as_function_definition(a__as_base__location, a__as_function_definition__declaration_specifiers, a__as_function_definition__declarator, a__as_function_definition__mem_initializers, a__as_function_definition__function_body, a__as_function_definition__handlers, NULL) );
}

/*!
   Generated constructor for class as_function_definition.
   \author lsg
 */
as_function_definition::as_function_definition (ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< ::lestes::std::list< srp< as_declaration_specifier > > > a__as_function_definition__declaration_specifiers,
                ptr< as_declarator > a__as_function_definition__declarator,
                ptr< ::lestes::std::list< srp< as_mem_initializer > > > a__as_function_definition__mem_initializers,
                ptr< ::lestes::lang::cplus::syn::bison_pack_token > a__as_function_definition__function_body,
                ptr< ::lestes::std::list< srp< as_handler > > > a__as_function_definition__handlers,
                ptr< ::lestes::intercode::as_base > a__as_function_definition__parsed_body)
        : as_declaration(a__as_base__location), declaration_specifiers(checked(a__as_function_definition__declaration_specifiers)), declarator(checked(a__as_function_definition__declarator)), mem_initializers(checked(a__as_function_definition__mem_initializers)), function_body(checked(a__as_function_definition__function_body)), handlers(checked(a__as_function_definition__handlers)), parsed_body(a__as_function_definition__parsed_body)
{}

ptr< object::reflection_list > as_function_definition::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( "declaration_specifiers", "list&lt; srp&lt; as_declaration_specifier &gt; &gt;" ) );
                mdl->push_back( md::create( "declarator", "as_declarator" ) );
                mdl->push_back( md::create( "mem_initializers", "list&lt; srp&lt; as_mem_initializer &gt; &gt;" ) );
                mdl->push_back( md::create( "function_body", "bison_pack_token" ) );
                mdl->push_back( md::create( "handlers", "list&lt; srp&lt; as_handler &gt; &gt;" ) );
                mdl->push_back( md::create( "parsed_body", "as_base" ) );
                reflection = reflection_list::create( as_declaration::reflection_get() );
                reflection->push_back( class_reflection::create( "as_function_definition", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_function_definition::field_values_get() const
{
        ptr < field_list_list > result = as_declaration::field_values_get();
        result->push_back( value_list::create() );
        result->back()->push_back( this->declaration_specifiers );
        result->push_back( value_list::create() );
        result->back()->push_back( this->declarator );
        result->push_back( value_list::create() );
        result->back()->push_back( this->mem_initializers );
        result->push_back( value_list::create() );
        result->back()->push_back( this->function_body );
        result->push_back( value_list::create() );
        result->back()->push_back( this->handlers );
        result->push_back( value_list::create() );
        result->back()->push_back( this->parsed_body );
        return result;
}


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

// End of class as_function_definition.

// ------------- Class as_template_declaration follows. -------------

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

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

/*!
   \returns The value of as_template_declaration::template_params.
   \author lsg
 */
ptr< ::lestes::std::list< srp< as_template_param > > > as_template_declaration::template_params_get() const
{
        return template_params;
}

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

/*!
   \returns The value of as_template_declaration::declararion.
   \author lsg
 */
ptr< as_declaration > as_template_declaration::declararion_get() const
{
        return declararion;
}

/*!
   \param[in] x The new value to set as_template_declaration::declararion to.
   \author lsg
 */
void as_template_declaration::declararion_set(const ptr< as_declaration > & x)
{
        as_template_declaration::declararion = x;
}

/*!
   This factory method for class as_template_declaration takes values of all fields as arguments.
   \author lsg
 */
ptr< as_template_declaration > as_template_declaration::create(ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< ::lestes::lang::cplus::lex::cpp_token > a__as_template_declaration__exported,
                ptr< ::lestes::std::list< srp< as_template_param > > > a__as_template_declaration__template_params,
                ptr< as_declaration > a__as_template_declaration__declararion)
{
        return ptr< as_template_declaration > ( new as_template_declaration(a__as_base__location,
                a__as_template_declaration__exported,
                a__as_template_declaration__template_params,
                a__as_template_declaration__declararion) );
}

/*!
   Generated constructor for class as_template_declaration.
   \author lsg
 */
as_template_declaration::as_template_declaration (ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< ::lestes::lang::cplus::lex::cpp_token > a__as_template_declaration__exported,
                ptr< ::lestes::std::list< srp< as_template_param > > > a__as_template_declaration__template_params,
                ptr< as_declaration > a__as_template_declaration__declararion)
        : as_declaration(a__as_base__location), exported(a__as_template_declaration__exported), template_params(checked(a__as_template_declaration__template_params)), declararion(checked(a__as_template_declaration__declararion))
{}

ptr< object::reflection_list > as_template_declaration::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( "exported", "cpp_token" ) );
                mdl->push_back( md::create( "template_params", "list&lt; srp&lt; as_template_param &gt; &gt;" ) );
                mdl->push_back( md::create( "declararion", "as_declaration" ) );
                reflection = reflection_list::create( as_declaration::reflection_get() );
                reflection->push_back( class_reflection::create( "as_template_declaration", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_template_declaration::field_values_get() const
{
        ptr < field_list_list > result = as_declaration::field_values_get();
        result->push_back( value_list::create() );
        result->back()->push_back( this->exported );
        result->push_back( value_list::create() );
        result->back()->push_back( this->template_params );
        result->push_back( value_list::create() );
        result->back()->push_back( this->declararion );
        return result;
}


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

// End of class as_template_declaration.

// ------------- Class as_template_param follows. -------------

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

ptr< object::reflection_list > as_template_param::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_template_param", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_template_param::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_template_param::gc_mark()
{
	::lestes::intercode::as_base::gc_mark();
}

// End of class as_template_param.

// ------------- Class as_template_type_param follows. -------------

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

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

ptr< object::reflection_list > as_template_type_param::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_template_param::reflection_get() );
                reflection->push_back( class_reflection::create( "as_template_type_param", mdl ) );
        }
        return reflection;
}

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


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

// End of class as_template_type_param.

// ------------- Class as_template_type_param_type follows. -------------

/*!
   \returns The value of as_template_type_param_type::identifier.
   \author lsg
 */
ptr< as_identifier > as_template_type_param_type::identifier_get() const
{
        return identifier;
}

/*!
   \param[in] x The new value to set as_template_type_param_type::identifier to.
   \author lsg
 */
void as_template_type_param_type::identifier_set(const ptr< as_identifier > & x)
{
        as_template_type_param_type::identifier = x;
}

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

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

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

/*!
   Generated constructor for class as_template_type_param_type.
   \author lsg
 */
as_template_type_param_type::as_template_type_param_type (ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_identifier > a__as_template_type_param_type__identifier,
                ptr< as_type_id > a__as_template_type_param_type__type_id)
        : as_template_type_param(a__as_base__location), identifier(a__as_template_type_param_type__identifier), type_id(a__as_template_type_param_type__type_id)
{}

ptr< object::reflection_list > as_template_type_param_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( "identifier", "as_identifier" ) );
                mdl->push_back( md::create( "type_id", "as_type_id" ) );
                reflection = reflection_list::create( as_template_type_param::reflection_get() );
                reflection->push_back( class_reflection::create( "as_template_type_param_type", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_template_type_param_type::field_values_get() const
{
        ptr < field_list_list > result = as_template_type_param::field_values_get();
        result->push_back( value_list::create() );
        result->back()->push_back( this->identifier );
        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_template_type_param_type::gc_mark()
{
        as_template_type_param::gc_mark();
}

// End of class as_template_type_param_type.

// ------------- Class as_template_type_param_template follows. -------------

/*!
   \returns The value of as_template_type_param_template::template_params.
   \author lsg
 */
ptr< ::lestes::std::list< srp< as_template_param > > > as_template_type_param_template::template_params_get() const
{
        return template_params;
}

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

/*!
   \returns The value of as_template_type_param_template::identifier.
   \author lsg
 */
ptr< as_identifier > as_template_type_param_template::identifier_get() const
{
        return identifier;
}

/*!
   \param[in] x The new value to set as_template_type_param_template::identifier to.
   \author lsg
 */
void as_template_type_param_template::identifier_set(const ptr< as_identifier > & x)
{
        as_template_type_param_template::identifier = x;
}

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

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

/*!
   This factory method for class as_template_type_param_template takes values of all fields as arguments.
   \author lsg
 */
ptr< as_template_type_param_template > as_template_type_param_template::create(ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< ::lestes::std::list< srp< as_template_param > > > a__as_template_type_param_template__template_params,
                ptr< as_identifier > a__as_template_type_param_template__identifier,
                ptr< as_name > a__as_template_type_param_template__initializer)
{
        return ptr< as_template_type_param_template > ( new as_template_type_param_template(a__as_base__location,
                a__as_template_type_param_template__template_params,
                a__as_template_type_param_template__identifier,
                a__as_template_type_param_template__initializer) );
}

/*!
   Generated constructor for class as_template_type_param_template.
   \author lsg
 */
as_template_type_param_template::as_template_type_param_template (ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< ::lestes::std::list< srp< as_template_param > > > a__as_template_type_param_template__template_params,
                ptr< as_identifier > a__as_template_type_param_template__identifier,
                ptr< as_name > a__as_template_type_param_template__initializer)
        : as_template_type_param(a__as_base__location), template_params(checked(a__as_template_type_param_template__template_params)), identifier(a__as_template_type_param_template__identifier), initializer(checked(a__as_template_type_param_template__initializer))
{}

ptr< object::reflection_list > as_template_type_param_template::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( "template_params", "list&lt; srp&lt; as_template_param &gt; &gt;" ) );
                mdl->push_back( md::create( "identifier", "as_identifier" ) );
                mdl->push_back( md::create( "initializer", "as_name" ) );
                reflection = reflection_list::create( as_template_type_param::reflection_get() );
                reflection->push_back( class_reflection::create( "as_template_type_param_template", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_template_type_param_template::field_values_get() const
{
        ptr < field_list_list > result = as_template_type_param::field_values_get();
        result->push_back( value_list::create() );
        result->back()->push_back( this->template_params );
        result->push_back( value_list::create() );
        result->back()->push_back( this->identifier );
        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_template_type_param_template::gc_mark()
{
        as_template_type_param::gc_mark();
}

// End of class as_template_type_param_template.

// ------------- Class as_template_nontype_param follows. -------------

/*!
   \returns The value of as_template_nontype_param::param.
   \author lsg
 */
ptr< as_param_declaration > as_template_nontype_param::param_get() const
{
        return param;
}

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

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

/*!
   Generated constructor for class as_template_nontype_param.
   \author lsg
 */
as_template_nontype_param::as_template_nontype_param (ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_param_declaration > a__as_template_nontype_param__param)
        : as_template_param(a__as_base__location), param(checked(a__as_template_nontype_param__param))
{}

ptr< object::reflection_list > as_template_nontype_param::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( "param", "as_param_declaration" ) );
                reflection = reflection_list::create( as_template_param::reflection_get() );
                reflection->push_back( class_reflection::create( "as_template_nontype_param", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_template_nontype_param::field_values_get() const
{
        ptr < field_list_list > result = as_template_param::field_values_get();
        result->push_back( value_list::create() );
        result->back()->push_back( this->param );
        return result;
}


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

// End of class as_template_nontype_param.

// ------------- Class as_mem_initializer follows. -------------

/*!
   \returns The value of as_mem_initializer::id.
   \author lsg
 */
ptr< as_name > as_mem_initializer::id_get() const
{
        return id;
}

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

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

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

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

/*!
   Generated constructor for class as_mem_initializer.
   \author lsg
 */
as_mem_initializer::as_mem_initializer (ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_name > a__as_mem_initializer__id,
                ptr< ::lestes::std::list< srp< as_expression > > > a__as_mem_initializer__expressions)
        : as_base(a__as_base__location), id(checked(a__as_mem_initializer__id)), expressions(checked(a__as_mem_initializer__expressions))
{}

ptr< object::reflection_list > as_mem_initializer::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( "id", "as_name" ) );
                mdl->push_back( md::create( "expressions", "list&lt; srp&lt; as_expression &gt; &gt;" ) );
                reflection = reflection_list::create( ::lestes::intercode::as_base::reflection_get() );
                reflection->push_back( class_reflection::create( "as_mem_initializer", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_mem_initializer::field_values_get() const
{
        ptr < field_list_list > result = ::lestes::intercode::as_base::field_values_get();
        result->push_back( value_list::create() );
        result->back()->push_back( this->id );
        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_mem_initializer::gc_mark()
{
	::lestes::intercode::as_base::gc_mark();
}

// End of class as_mem_initializer.

// ------------- Class as_explicit_instantiation follows. -------------

/*!
   \returns The value of as_explicit_instantiation::declaration.
   \author lsg
 */
ptr< as_declaration > as_explicit_instantiation::declaration_get() const
{
        return declaration;
}

/*!
   \param[in] x The new value to set as_explicit_instantiation::declaration to.
   \author lsg
 */
void as_explicit_instantiation::declaration_set(const ptr< as_declaration > & x)
{
        as_explicit_instantiation::declaration = x;
}

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

/*!
   Generated constructor for class as_explicit_instantiation.
   \author lsg
 */
as_explicit_instantiation::as_explicit_instantiation (ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_declaration > a__as_explicit_instantiation__declaration)
        : as_declaration(a__as_base__location), declaration(checked(a__as_explicit_instantiation__declaration))
{}

ptr< object::reflection_list > as_explicit_instantiation::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( "declaration", "as_declaration" ) );
                reflection = reflection_list::create( as_declaration::reflection_get() );
                reflection->push_back( class_reflection::create( "as_explicit_instantiation", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_explicit_instantiation::field_values_get() const
{
        ptr < field_list_list > result = as_declaration::field_values_get();
        result->push_back( value_list::create() );
        result->back()->push_back( this->declaration );
        return result;
}


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

// End of class as_explicit_instantiation.

// ------------- Class as_explicit_specialization follows. -------------

/*!
   \returns The value of as_explicit_specialization::declaration.
   \author lsg
 */
ptr< as_declaration > as_explicit_specialization::declaration_get() const
{
        return declaration;
}

/*!
   \param[in] x The new value to set as_explicit_specialization::declaration to.
   \author lsg
 */
void as_explicit_specialization::declaration_set(const ptr< as_declaration > & x)
{
        as_explicit_specialization::declaration = x;
}

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

/*!
   Generated constructor for class as_explicit_specialization.
   \author lsg
 */
as_explicit_specialization::as_explicit_specialization (ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_declaration > a__as_explicit_specialization__declaration)
        : as_declaration(a__as_base__location), declaration(checked(a__as_explicit_specialization__declaration))
{}

ptr< object::reflection_list > as_explicit_specialization::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( "declaration", "as_declaration" ) );
                reflection = reflection_list::create( as_declaration::reflection_get() );
                reflection->push_back( class_reflection::create( "as_explicit_specialization", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_explicit_specialization::field_values_get() const
{
        ptr < field_list_list > result = as_declaration::field_values_get();
        result->push_back( value_list::create() );
        result->back()->push_back( this->declaration );
        return result;
}


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

// End of class as_explicit_specialization.

// ------------- Class as_linkage_specification follows. -------------

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

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

/*!
   \returns The value of as_linkage_specification::declarations.
   \author lsg
 */
ptr< ::lestes::std::list< srp< as_declaration > > > as_linkage_specification::declarations_get() const
{
        return declarations;
}

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

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

/*!
   Generated constructor for class as_linkage_specification.
   \author lsg
 */
as_linkage_specification::as_linkage_specification (ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< ::lestes::lang::cplus::lex::cpp_token > a__as_linkage_specification__linkage_specification,
                ptr< ::lestes::std::list< srp< as_declaration > > > a__as_linkage_specification__declarations)
        : as_declaration(a__as_base__location), linkage_specification(checked(a__as_linkage_specification__linkage_specification)), declarations(checked(a__as_linkage_specification__declarations))
{}

ptr< object::reflection_list > as_linkage_specification::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( "linkage_specification", "cpp_token" ) );
                mdl->push_back( md::create( "declarations", "list&lt; srp&lt; as_declaration &gt; &gt;" ) );
                reflection = reflection_list::create( as_declaration::reflection_get() );
                reflection->push_back( class_reflection::create( "as_linkage_specification", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_linkage_specification::field_values_get() const
{
        ptr < field_list_list > result = as_declaration::field_values_get();
        result->push_back( value_list::create() );
        result->back()->push_back( this->linkage_specification );
        result->push_back( value_list::create() );
        result->back()->push_back( this->declarations );
        return result;
}


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

// End of class as_linkage_specification.

// ------------- Class as_id follows. -------------

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

ptr< object::reflection_list > as_id::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_id", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_id::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_id::gc_mark()
{
	::lestes::intercode::as_base::gc_mark();
}

// End of class as_id.

// ------------- Class as_template_id follows. -------------

/*!
   \returns The value of as_template_id::token.
   \author lsg
 */
ptr< ::lestes::lang::cplus::syn::bison_id_token > as_template_id::token_get() const
{
        return token;
}

/*!
   \param[in] x The new value to set as_template_id::token to.
   \author lsg
 */
void as_template_id::token_set(const ptr< ::lestes::lang::cplus::syn::bison_id_token > & x)
{
        as_template_id::token = x;
}

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

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

void as_template_id::accept_as_id_visitor( ptr< as_id_visitor > v )
{
        return v->visit_as_template_id( this );
}

/*!
   This factory method for class as_template_id takes values of all fields as arguments.
   \author lsg
 */
ptr< as_template_id > as_template_id::create(ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< ::lestes::lang::cplus::syn::bison_id_token > a__as_template_id__token,
                ptr< ::lestes::std::list< srp< as_template_argument > > > a__as_template_id__arguments)
{
        return ptr< as_template_id > ( new as_template_id(a__as_base__location,
                a__as_template_id__token,
                a__as_template_id__arguments) );
}

/*!
   Generated constructor for class as_template_id.
   \author lsg
 */
as_template_id::as_template_id (ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< ::lestes::lang::cplus::syn::bison_id_token > a__as_template_id__token,
                ptr< ::lestes::std::list< srp< as_template_argument > > > a__as_template_id__arguments)
        : as_id(a__as_base__location), token(checked(a__as_template_id__token)), arguments(a__as_template_id__arguments)
{}

ptr< object::reflection_list > as_template_id::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( "token", "bison_id_token" ) );
                mdl->push_back( md::create( "arguments", "list&lt; srp&lt; as_template_argument &gt; &gt;" ) );
                reflection = reflection_list::create( as_id::reflection_get() );
                reflection->push_back( class_reflection::create( "as_template_id", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_template_id::field_values_get() const
{
        ptr < field_list_list > result = as_id::field_values_get();
        result->push_back( value_list::create() );
        result->back()->push_back( this->token );
        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_template_id::gc_mark()
{
        as_id::gc_mark();
}

// End of class as_template_id.

// ------------- Class as_identifier follows. -------------

/*!
   \returns The value of as_identifier::token.
   \author lsg
 */
ptr< ::lestes::lang::cplus::syn::bison_id_token > as_identifier::token_get() const
{
        return token;
}

/*!
   \param[in] x The new value to set as_identifier::token to.
   \author lsg
 */
void as_identifier::token_set(const ptr< ::lestes::lang::cplus::syn::bison_id_token > & x)
{
        as_identifier::token = x;
}

void as_identifier::accept_as_id_visitor( ptr< as_id_visitor > v )
{
        return v->visit_as_identifier( this );
}

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

/*!
   Generated constructor for class as_identifier.
   \author lsg
 */
as_identifier::as_identifier (ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< ::lestes::lang::cplus::syn::bison_id_token > a__as_identifier__token)
        : as_id(a__as_base__location), token(checked(a__as_identifier__token))
{}

ptr< object::reflection_list > as_identifier::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( "token", "bison_id_token" ) );
                reflection = reflection_list::create( as_id::reflection_get() );
                reflection->push_back( class_reflection::create( "as_identifier", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_identifier::field_values_get() const
{
        ptr < field_list_list > result = as_id::field_values_get();
        result->push_back( value_list::create() );
        result->back()->push_back( this->token );
        return result;
}


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

// End of class as_identifier.

// ------------- Class as_destructor_id follows. -------------

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

ptr< object::reflection_list > as_destructor_id::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_id::reflection_get() );
                reflection->push_back( class_reflection::create( "as_destructor_id", mdl ) );
        }
        return reflection;
}

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


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

// End of class as_destructor_id.

// ------------- Class as_destructor_id_token follows. -------------

/*!
   \returns The value of as_destructor_id_token::token.
   \author lsg
 */
ptr< ::lestes::lang::cplus::syn::bison_id_token > as_destructor_id_token::token_get() const
{
        return token;
}

/*!
   \param[in] x The new value to set as_destructor_id_token::token to.
   \author lsg
 */
void as_destructor_id_token::token_set(const ptr< ::lestes::lang::cplus::syn::bison_id_token > & x)
{
        as_destructor_id_token::token = x;
}

void as_destructor_id_token::accept_as_id_visitor( ptr< as_id_visitor > v )
{
        return v->visit_as_destructor_id_token( this );
}

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

/*!
   Generated constructor for class as_destructor_id_token.
   \author lsg
 */
as_destructor_id_token::as_destructor_id_token (ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< ::lestes::lang::cplus::syn::bison_id_token > a__as_destructor_id_token__token)
        : as_destructor_id(a__as_base__location), token(checked(a__as_destructor_id_token__token))
{}

ptr< object::reflection_list > as_destructor_id_token::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( "token", "bison_id_token" ) );
                reflection = reflection_list::create( as_destructor_id::reflection_get() );
                reflection->push_back( class_reflection::create( "as_destructor_id_token", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_destructor_id_token::field_values_get() const
{
        ptr < field_list_list > result = as_destructor_id::field_values_get();
        result->push_back( value_list::create() );
        result->back()->push_back( this->token );
        return result;
}


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

// End of class as_destructor_id_token.

// ------------- Class as_destructor_id_template follows. -------------

/*!
   \returns The value of as_destructor_id_template::template_id.
   \author lsg
 */
ptr< as_template_id > as_destructor_id_template::template_id_get() const
{
        return template_id;
}

/*!
   \param[in] x The new value to set as_destructor_id_template::template_id to.
   \author lsg
 */
void as_destructor_id_template::template_id_set(const ptr< as_template_id > & x)
{
        as_destructor_id_template::template_id = x;
}

void as_destructor_id_template::accept_as_id_visitor( ptr< as_id_visitor > v )
{
        return v->visit_as_destructor_id_template( this );
}

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

/*!
   Generated constructor for class as_destructor_id_template.
   \author lsg
 */
as_destructor_id_template::as_destructor_id_template (ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_template_id > a__as_destructor_id_template__template_id)
        : as_destructor_id(a__as_base__location), template_id(checked(a__as_destructor_id_template__template_id))
{}

ptr< object::reflection_list > as_destructor_id_template::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( "template_id", "as_template_id" ) );
                reflection = reflection_list::create( as_destructor_id::reflection_get() );
                reflection->push_back( class_reflection::create( "as_destructor_id_template", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_destructor_id_template::field_values_get() const
{
        ptr < field_list_list > result = as_destructor_id::field_values_get();
        result->push_back( value_list::create() );
        result->back()->push_back( this->template_id );
        return result;
}


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

// End of class as_destructor_id_template.

// ------------- Class as_constructor_id follows. -------------

/*!
   \returns The value of as_constructor_id::declaration_specifiers.
   \author lsg
 */
ptr< ::lestes::std::list< srp< as_declaration_specifier > > > as_constructor_id::declaration_specifiers_get() const
{
        return declaration_specifiers;
}

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

void as_constructor_id::accept_as_id_visitor( ptr< as_id_visitor > v )
{
        return v->visit_as_constructor_id( this );
}

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

/*!
   Generated constructor for class as_constructor_id.
   \author lsg
 */
as_constructor_id::as_constructor_id (ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< ::lestes::std::list< srp< as_declaration_specifier > > > a__as_constructor_id__declaration_specifiers)
        : as_id(a__as_base__location), declaration_specifiers(checked(a__as_constructor_id__declaration_specifiers))
{}

ptr< object::reflection_list > as_constructor_id::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( "declaration_specifiers", "list&lt; srp&lt; as_declaration_specifier &gt; &gt;" ) );
                reflection = reflection_list::create( as_id::reflection_get() );
                reflection->push_back( class_reflection::create( "as_constructor_id", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_constructor_id::field_values_get() const
{
        ptr < field_list_list > result = as_id::field_values_get();
        result->push_back( value_list::create() );
        result->back()->push_back( this->declaration_specifiers );
        return result;
}


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

// End of class as_constructor_id.

// ------------- Class as_op_function_id follows. -------------

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

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

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

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

void as_op_function_id::accept_as_id_visitor( ptr< as_id_visitor > v )
{
        return v->visit_as_op_function_id( this );
}

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

/*!
   Generated constructor for class as_op_function_id.
   \author lsg
 */
as_op_function_id::as_op_function_id (ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< ::lestes::lang::cplus::lex::cpp_token > a__as_op_function_id__op,
                ptr< ::lestes::std::list< srp< as_template_argument > > > a__as_op_function_id__arguments)
        : as_id(a__as_base__location), op(checked(a__as_op_function_id__op)), arguments(a__as_op_function_id__arguments)
{}

ptr< object::reflection_list > as_op_function_id::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( "op", "cpp_token" ) );
                mdl->push_back( md::create( "arguments", "list&lt; srp&lt; as_template_argument &gt; &gt;" ) );
                reflection = reflection_list::create( as_id::reflection_get() );
                reflection->push_back( class_reflection::create( "as_op_function_id", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_op_function_id::field_values_get() const
{
        ptr < field_list_list > result = as_id::field_values_get();
        result->push_back( value_list::create() );
        result->back()->push_back( this->op );
        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_op_function_id::gc_mark()
{
        as_id::gc_mark();
}

// End of class as_op_function_id.

// ------------- Class as_conv_function_id follows. -------------

/*!
   \returns The value of as_conv_function_id::specifiers.
   \author lsg
 */
ptr< ::lestes::std::list< srp< as_type_specifier > > > as_conv_function_id::specifiers_get() const
{
        return specifiers;
}

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

/*!
   \returns The value of as_conv_function_id::ptr_ops.
   \author lsg
 */
ptr< ::lestes::std::list< srp< as_declarator_op > > > as_conv_function_id::ptr_ops_get() const
{
        return ptr_ops;
}

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

void as_conv_function_id::accept_as_id_visitor( ptr< as_id_visitor > v )
{
        return v->visit_as_conv_function_id( this );
}

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

/*!
   Generated constructor for class as_conv_function_id.
   \author lsg
 */
as_conv_function_id::as_conv_function_id (ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< ::lestes::std::list< srp< as_type_specifier > > > a__as_conv_function_id__specifiers,
                ptr< ::lestes::std::list< srp< as_declarator_op > > > a__as_conv_function_id__ptr_ops)
        : as_id(a__as_base__location), specifiers(checked(a__as_conv_function_id__specifiers)), ptr_ops(checked(a__as_conv_function_id__ptr_ops))
{}

ptr< object::reflection_list > as_conv_function_id::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( "specifiers", "list&lt; srp&lt; as_type_specifier &gt; &gt;" ) );
                mdl->push_back( md::create( "ptr_ops", "list&lt; srp&lt; as_declarator_op &gt; &gt;" ) );
                reflection = reflection_list::create( as_id::reflection_get() );
                reflection->push_back( class_reflection::create( "as_conv_function_id", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_conv_function_id::field_values_get() const
{
        ptr < field_list_list > result = as_id::field_values_get();
        result->push_back( value_list::create() );
        result->back()->push_back( this->specifiers );
        result->push_back( value_list::create() );
        result->back()->push_back( this->ptr_ops );
        return result;
}


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

// End of class as_conv_function_id.

// ------------- Class as_empty_id follows. -------------

void as_empty_id::accept_as_id_visitor( ptr< as_id_visitor > v )
{
        return v->visit_as_empty_id( this );
}

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

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

ptr< object::reflection_list > as_empty_id::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_id::reflection_get() );
                reflection->push_back( class_reflection::create( "as_empty_id", mdl ) );
        }
        return reflection;
}

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


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

// End of class as_empty_id.

// ------------- Class as_global_namespace_fake_id follows. -------------

void as_global_namespace_fake_id::accept_as_id_visitor( ptr< as_id_visitor > v )
{
        return v->visit_as_global_namespace_fake_id( this );
}

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

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

ptr< object::reflection_list > as_global_namespace_fake_id::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_id::reflection_get() );
                reflection->push_back( class_reflection::create( "as_global_namespace_fake_id", mdl ) );
        }
        return reflection;
}

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


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

// End of class as_global_namespace_fake_id.

// ------------- Class as_name follows. -------------

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

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

/*!
   \returns The value of as_name::identifier.
   \author lsg
 */
ptr< as_id > as_name::identifier_get() const
{
        return identifier;
}

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

/*!
   \returns The value of as_name::was_qualified.
   \author lsg
 */
bool as_name::was_qualified_get() const
{
        return was_qualified;
}

/*!
   \param[in] x The new value to set as_name::was_qualified to.
   \author lsg
 */
void as_name::was_qualified_set(bool x)
{
        as_name::was_qualified = x;
}

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

/*!
   This factory method for class as_name uses initializers.
   \author lsg
 */
ptr< as_name > as_name::create(ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_name > a__as_name__qualification,
                ptr< as_id > a__as_name__identifier)
{
        return ptr< as_name > ( new as_name(a__as_base__location, a__as_name__qualification, a__as_name__identifier, false) );
}

/*!
   Generated constructor for class as_name.
   \author lsg
 */
as_name::as_name (ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_name > a__as_name__qualification,
                ptr< as_id > a__as_name__identifier,
                bool a__as_name__was_qualified)
        : as_base(a__as_base__location), qualification(a__as_name__qualification), identifier(checked(a__as_name__identifier)), was_qualified(a__as_name__was_qualified)
{}

ptr< object::reflection_list > as_name::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( "qualification", "as_name" ) );
                mdl->push_back( md::create( "identifier", "as_id" ) );
                mdl->push_back( md::create( "was_qualified", "bool" ) );
                reflection = reflection_list::create( ::lestes::intercode::as_base::reflection_get() );
                reflection->push_back( class_reflection::create( "as_name", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_name::field_values_get() const
{
        ptr < field_list_list > result = ::lestes::intercode::as_base::field_values_get();
        result->push_back( value_list::create() );
        result->back()->push_back( this->qualification );
        result->push_back( value_list::create() );
        result->back()->push_back( this->identifier );
        result->push_back( value_list::create() );
        result->back()->push_back( objectize< bool > ::create( this->was_qualified ) );
        return result;
}


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

// End of class as_name.

// ------------- Class as_base_specifier follows. -------------

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

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

/*!
   \returns The value of as_base_specifier::access_specifier.
   \author lsg
 */
ptr< as_access_specifier > as_base_specifier::access_specifier_get() const
{
        return access_specifier;
}

/*!
   \param[in] x The new value to set as_base_specifier::access_specifier to.
   \author lsg
 */
void as_base_specifier::access_specifier_set(const ptr< as_access_specifier > & x)
{
        as_base_specifier::access_specifier = x;
}

/*!
   \returns The value of as_base_specifier::class_name.
   \author lsg
 */
ptr< as_name > as_base_specifier::class_name_get() const
{
        return class_name;
}

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

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

/*!
   Generated constructor for class as_base_specifier.
   \author lsg
 */
as_base_specifier::as_base_specifier (ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< ::lestes::lang::cplus::lex::cpp_token > a__as_base_specifier__virtual_base,
                ptr< as_access_specifier > a__as_base_specifier__access_specifier,
                ptr< as_name > a__as_base_specifier__class_name)
        : as_base(a__as_base__location), virtual_base(a__as_base_specifier__virtual_base), access_specifier(a__as_base_specifier__access_specifier), class_name(checked(a__as_base_specifier__class_name))
{}

ptr< object::reflection_list > as_base_specifier::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( "virtual_base", "cpp_token" ) );
                mdl->push_back( md::create( "access_specifier", "as_access_specifier" ) );
                mdl->push_back( md::create( "class_name", "as_name" ) );
                reflection = reflection_list::create( ::lestes::intercode::as_base::reflection_get() );
                reflection->push_back( class_reflection::create( "as_base_specifier", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_base_specifier::field_values_get() const
{
        ptr < field_list_list > result = ::lestes::intercode::as_base::field_values_get();
        result->push_back( value_list::create() );
        result->back()->push_back( this->virtual_base );
        result->push_back( value_list::create() );
        result->back()->push_back( this->access_specifier );
        result->push_back( value_list::create() );
        result->back()->push_back( this->class_name );
        return result;
}


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

// End of class as_base_specifier.

// ------------- Class as_asm_declaration follows. -------------

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

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

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

/*!
   Generated constructor for class as_asm_declaration.
   \author lsg
 */
as_asm_declaration::as_asm_declaration (ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< ::lestes::lang::cplus::lex::cpp_token > a__as_asm_declaration__assembler)
        : as_block_declaration(a__as_base__location), assembler(checked(a__as_asm_declaration__assembler))
{}

ptr< object::reflection_list > as_asm_declaration::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( "assembler", "cpp_token" ) );
                reflection = reflection_list::create( as_block_declaration::reflection_get() );
                reflection->push_back( class_reflection::create( "as_asm_declaration", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_asm_declaration::field_values_get() const
{
        ptr < field_list_list > result = as_block_declaration::field_values_get();
        result->push_back( value_list::create() );
        result->back()->push_back( this->assembler );
        return result;
}


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

// End of class as_asm_declaration.

// ------------- Class as_gnu_asm_declaration follows. -------------

/*!
   \returns The value of as_gnu_asm_declaration::out_specification.
   \author lsg
 */
ptr< ::lestes::std::list< srp< as_gnu_asm_specification > > > as_gnu_asm_declaration::out_specification_get() const
{
        return out_specification;
}

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

/*!
   \returns The value of as_gnu_asm_declaration::in_specification.
   \author lsg
 */
ptr< ::lestes::std::list< srp< as_gnu_asm_specification > > > as_gnu_asm_declaration::in_specification_get() const
{
        return in_specification;
}

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

/*!
   \returns The value of as_gnu_asm_declaration::gobble_list.
   \author lsg
 */
ptr< ::lestes::std::list< srp< as_string_literal > > > as_gnu_asm_declaration::gobble_list_get() const
{
        return gobble_list;
}

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

/*!
   This factory method for class as_gnu_asm_declaration takes values of all fields as arguments.
   \author lsg
 */
ptr< as_gnu_asm_declaration > as_gnu_asm_declaration::create(ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< ::lestes::lang::cplus::lex::cpp_token > a__as_asm_declaration__assembler,
                ptr< ::lestes::std::list< srp< as_gnu_asm_specification > > > a__as_gnu_asm_declaration__out_specification,
                ptr< ::lestes::std::list< srp< as_gnu_asm_specification > > > a__as_gnu_asm_declaration__in_specification,
                ptr< ::lestes::std::list< srp< as_string_literal > > > a__as_gnu_asm_declaration__gobble_list)
{
        return ptr< as_gnu_asm_declaration > ( new as_gnu_asm_declaration(a__as_base__location,
                a__as_asm_declaration__assembler,
                a__as_gnu_asm_declaration__out_specification,
                a__as_gnu_asm_declaration__in_specification,
                a__as_gnu_asm_declaration__gobble_list) );
}

/*!
   Generated constructor for class as_gnu_asm_declaration.
   \author lsg
 */
as_gnu_asm_declaration::as_gnu_asm_declaration (ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< ::lestes::lang::cplus::lex::cpp_token > a__as_asm_declaration__assembler,
                ptr< ::lestes::std::list< srp< as_gnu_asm_specification > > > a__as_gnu_asm_declaration__out_specification,
                ptr< ::lestes::std::list< srp< as_gnu_asm_specification > > > a__as_gnu_asm_declaration__in_specification,
                ptr< ::lestes::std::list< srp< as_string_literal > > > a__as_gnu_asm_declaration__gobble_list)
        : as_asm_declaration(a__as_base__location,
                a__as_asm_declaration__assembler), out_specification(checked(a__as_gnu_asm_declaration__out_specification)), in_specification(checked(a__as_gnu_asm_declaration__in_specification)), gobble_list(checked(a__as_gnu_asm_declaration__gobble_list))
{}

ptr< object::reflection_list > as_gnu_asm_declaration::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( "out_specification", "list&lt; srp&lt; as_gnu_asm_specification &gt; &gt;" ) );
                mdl->push_back( md::create( "in_specification", "list&lt; srp&lt; as_gnu_asm_specification &gt; &gt;" ) );
                mdl->push_back( md::create( "gobble_list", "list&lt; srp&lt; as_string_literal &gt; &gt;" ) );
                reflection = reflection_list::create( as_asm_declaration::reflection_get() );
                reflection->push_back( class_reflection::create( "as_gnu_asm_declaration", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_gnu_asm_declaration::field_values_get() const
{
        ptr < field_list_list > result = as_asm_declaration::field_values_get();
        result->push_back( value_list::create() );
        result->back()->push_back( this->out_specification );
        result->push_back( value_list::create() );
        result->back()->push_back( this->in_specification );
        result->push_back( value_list::create() );
        result->back()->push_back( this->gobble_list );
        return result;
}


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

// End of class as_gnu_asm_declaration.

// ------------- Class as_gnu_asm_specification follows. -------------

/*!
   \returns The value of as_gnu_asm_specification::constraint.
   \author lsg
 */
ptr< as_string_literal > as_gnu_asm_specification::constraint_get() const
{
        return constraint;
}

/*!
   \param[in] x The new value to set as_gnu_asm_specification::constraint to.
   \author lsg
 */
void as_gnu_asm_specification::constraint_set(const ptr< as_string_literal > & x)
{
        as_gnu_asm_specification::constraint = x;
}

/*!
   \returns The value of as_gnu_asm_specification::expression.
   \author lsg
 */
ptr< as_expression > as_gnu_asm_specification::expression_get() const
{
        return expression;
}

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

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

/*!
   Generated constructor for class as_gnu_asm_specification.
   \author lsg
 */
as_gnu_asm_specification::as_gnu_asm_specification (ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_string_literal > a__as_gnu_asm_specification__constraint,
                ptr< as_expression > a__as_gnu_asm_specification__expression)
        : as_base(a__as_base__location), constraint(checked(a__as_gnu_asm_specification__constraint)), expression(checked(a__as_gnu_asm_specification__expression))
{}

ptr< object::reflection_list > as_gnu_asm_specification::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( "constraint", "as_string_literal" ) );
                mdl->push_back( md::create( "expression", "as_expression" ) );
                reflection = reflection_list::create( ::lestes::intercode::as_base::reflection_get() );
                reflection->push_back( class_reflection::create( "as_gnu_asm_specification", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_gnu_asm_specification::field_values_get() const
{
        ptr < field_list_list > result = ::lestes::intercode::as_base::field_values_get();
        result->push_back( value_list::create() );
        result->back()->push_back( this->constraint );
        result->push_back( value_list::create() );
        result->back()->push_back( this->expression );
        return result;
}


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

// End of class as_gnu_asm_specification.

// ------------- Class as_namespace_alias_declaration follows. -------------

/*!
   \returns The value of as_namespace_alias_declaration::identifier.
   \author lsg
 */
ptr< as_identifier > as_namespace_alias_declaration::identifier_get() const
{
        return identifier;
}

/*!
   \param[in] x The new value to set as_namespace_alias_declaration::identifier to.
   \author lsg
 */
void as_namespace_alias_declaration::identifier_set(const ptr< as_identifier > & x)
{
        as_namespace_alias_declaration::identifier = x;
}

/*!
   \returns The value of as_namespace_alias_declaration::ns.
   \author lsg
 */
ptr< as_name > as_namespace_alias_declaration::ns_get() const
{
        return ns;
}

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

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

/*!
   Generated constructor for class as_namespace_alias_declaration.
   \author lsg
 */
as_namespace_alias_declaration::as_namespace_alias_declaration (ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_identifier > a__as_namespace_alias_declaration__identifier,
                ptr< as_name > a__as_namespace_alias_declaration__ns)
        : as_block_declaration(a__as_base__location), identifier(checked(a__as_namespace_alias_declaration__identifier)), ns(checked(a__as_namespace_alias_declaration__ns))
{}

ptr< object::reflection_list > as_namespace_alias_declaration::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( "identifier", "as_identifier" ) );
                mdl->push_back( md::create( "ns", "as_name" ) );
                reflection = reflection_list::create( as_block_declaration::reflection_get() );
                reflection->push_back( class_reflection::create( "as_namespace_alias_declaration", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_namespace_alias_declaration::field_values_get() const
{
        ptr < field_list_list > result = as_block_declaration::field_values_get();
        result->push_back( value_list::create() );
        result->back()->push_back( this->identifier );
        result->push_back( value_list::create() );
        result->back()->push_back( this->ns );
        return result;
}


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

// End of class as_namespace_alias_declaration.

// ------------- Class as_namespace_definition follows. -------------

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

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

/*!
   \returns The value of as_namespace_definition::declarations.
   \author lsg
 */
ptr< ::lestes::std::list< srp< as_declaration > > > as_namespace_definition::declarations_get() const
{
        return declarations;
}

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

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

/*!
   Generated constructor for class as_namespace_definition.
   \author lsg
 */
as_namespace_definition::as_namespace_definition (ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_name > a__as_namespace_definition__name,
                ptr< ::lestes::std::list< srp< as_declaration > > > a__as_namespace_definition__declarations)
        : as_declaration(a__as_base__location), name(checked(a__as_namespace_definition__name)), declarations(checked(a__as_namespace_definition__declarations))
{}

ptr< object::reflection_list > as_namespace_definition::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" ) );
                mdl->push_back( md::create( "declarations", "list&lt; srp&lt; as_declaration &gt; &gt;" ) );
                reflection = reflection_list::create( as_declaration::reflection_get() );
                reflection->push_back( class_reflection::create( "as_namespace_definition", mdl ) );
        }
        return reflection;
}

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


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

// End of class as_namespace_definition.

// ------------- Class as_using follows. -------------

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

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

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

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

ptr< object::reflection_list > as_using::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_block_declaration::reflection_get() );
                reflection->push_back( class_reflection::create( "as_using", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_using::field_values_get() const
{
        ptr < field_list_list > result = as_block_declaration::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_using::gc_mark()
{
        as_block_declaration::gc_mark();
}

// End of class as_using.

// ------------- Class as_using_declaration follows. -------------

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

/*!
   Generated constructor for class as_using_declaration.
   \author lsg
 */
as_using_declaration::as_using_declaration (ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_name > a__as_using__name)
        : as_using(a__as_base__location,
                a__as_using__name)
{}

ptr< object::reflection_list > as_using_declaration::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_using::reflection_get() );
                reflection->push_back( class_reflection::create( "as_using_declaration", mdl ) );
        }
        return reflection;
}

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


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

// End of class as_using_declaration.

// ------------- Class as_using_declaration_with_typename follows. -------------

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

/*!
   Generated constructor for class as_using_declaration_with_typename.
   \author lsg
 */
as_using_declaration_with_typename::as_using_declaration_with_typename (ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_name > a__as_using__name)
        : as_using_declaration(a__as_base__location,
                a__as_using__name)
{}

ptr< object::reflection_list > as_using_declaration_with_typename::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_using_declaration::reflection_get() );
                reflection->push_back( class_reflection::create( "as_using_declaration_with_typename", mdl ) );
        }
        return reflection;
}

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


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

// End of class as_using_declaration_with_typename.

// ------------- Class as_access_declaration follows. -------------

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

/*!
   Generated constructor for class as_access_declaration.
   \author lsg
 */
as_access_declaration::as_access_declaration (ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_name > a__as_using__name)
        : as_using_declaration(a__as_base__location,
                a__as_using__name)
{}

ptr< object::reflection_list > as_access_declaration::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_using_declaration::reflection_get() );
                reflection->push_back( class_reflection::create( "as_access_declaration", mdl ) );
        }
        return reflection;
}

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


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

// End of class as_access_declaration.

// ------------- Class as_using_directive follows. -------------

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

/*!
   Generated constructor for class as_using_directive.
   \author lsg
 */
as_using_directive::as_using_directive (ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_name > a__as_using__name)
        : as_using(a__as_base__location,
                a__as_using__name)
{}

ptr< object::reflection_list > as_using_directive::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_using::reflection_get() );
                reflection->push_back( class_reflection::create( "as_using_directive", mdl ) );
        }
        return reflection;
}

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


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

// End of class as_using_directive.

// ------------- Class as_enumerator_definition follows. -------------

/*!
   \returns The value of as_enumerator_definition::enumerator.
   \author lsg
 */
ptr< as_identifier > as_enumerator_definition::enumerator_get() const
{
        return enumerator;
}

/*!
   \param[in] x The new value to set as_enumerator_definition::enumerator to.
   \author lsg
 */
void as_enumerator_definition::enumerator_set(const ptr< as_identifier > & x)
{
        as_enumerator_definition::enumerator = x;
}

/*!
   \returns The value of as_enumerator_definition::value.
   \author lsg
 */
ptr< as_constant_expression > as_enumerator_definition::value_get() const
{
        return value;
}

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

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

/*!
   Generated constructor for class as_enumerator_definition.
   \author lsg
 */
as_enumerator_definition::as_enumerator_definition (ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_identifier > a__as_enumerator_definition__enumerator,
                ptr< as_constant_expression > a__as_enumerator_definition__value)
        : as_base(a__as_base__location), enumerator(checked(a__as_enumerator_definition__enumerator)), value(checked(a__as_enumerator_definition__value))
{}

ptr< object::reflection_list > as_enumerator_definition::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( "enumerator", "as_identifier" ) );
                mdl->push_back( md::create( "value", "as_constant_expression" ) );
                reflection = reflection_list::create( ::lestes::intercode::as_base::reflection_get() );
                reflection->push_back( class_reflection::create( "as_enumerator_definition", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_enumerator_definition::field_values_get() const
{
        ptr < field_list_list > result = ::lestes::intercode::as_base::field_values_get();
        result->push_back( value_list::create() );
        result->back()->push_back( this->enumerator );
        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_enumerator_definition::gc_mark()
{
	::lestes::intercode::as_base::gc_mark();
}

// End of class as_enumerator_definition.

// ------------- Class as_param_declaration follows. -------------

/*!
   \returns The value of as_param_declaration::declaration_specifiers.
   \author lsg
 */
ptr< ::lestes::std::list< srp< as_declaration_specifier > > > as_param_declaration::declaration_specifiers_get() const
{
        return declaration_specifiers;
}

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

/*!
   \returns The value of as_param_declaration::declarator.
   \author lsg
 */
ptr< as_declarator > as_param_declaration::declarator_get() const
{
        return declarator;
}

/*!
   \param[in] x The new value to set as_param_declaration::declarator to.
   \author lsg
 */
void as_param_declaration::declarator_set(const ptr< as_declarator > & x)
{
        as_param_declaration::declarator = x;
}

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

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

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

/*!
   Generated constructor for class as_param_declaration.
   \author lsg
 */
as_param_declaration::as_param_declaration (ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< ::lestes::std::list< srp< as_declaration_specifier > > > a__as_param_declaration__declaration_specifiers,
                ptr< as_declarator > a__as_param_declaration__declarator,
                ptr< as_expression > a__as_param_declaration__initializer)
        : as_base(a__as_base__location), declaration_specifiers(checked(a__as_param_declaration__declaration_specifiers)), declarator(checked(a__as_param_declaration__declarator)), initializer(checked(a__as_param_declaration__initializer))
{}

ptr< object::reflection_list > as_param_declaration::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( "declaration_specifiers", "list&lt; srp&lt; as_declaration_specifier &gt; &gt;" ) );
                mdl->push_back( md::create( "declarator", "as_declarator" ) );
                mdl->push_back( md::create( "initializer", "as_expression" ) );
                reflection = reflection_list::create( ::lestes::intercode::as_base::reflection_get() );
                reflection->push_back( class_reflection::create( "as_param_declaration", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_param_declaration::field_values_get() const
{
        ptr < field_list_list > result = ::lestes::intercode::as_base::field_values_get();
        result->push_back( value_list::create() );
        result->back()->push_back( this->declaration_specifiers );
        result->push_back( value_list::create() );
        result->back()->push_back( this->declarator );
        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_param_declaration::gc_mark()
{
	::lestes::intercode::as_base::gc_mark();
}

// End of class as_param_declaration.

// ------------- Class as_access_specifier follows. -------------

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

ptr< object::reflection_list > as_access_specifier::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_access_specifier", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_access_specifier::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_access_specifier::gc_mark()
{
	::lestes::intercode::as_base::gc_mark();
}

// End of class as_access_specifier.

// ------------- Class as_access_specifier_public follows. -------------

void as_access_specifier_public::accept_as_access_specifier_visitor( ptr< as_access_specifier_visitor > v )
{
        return v->visit_as_access_specifier_public( this );
}

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

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

ptr< object::reflection_list > as_access_specifier_public::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_access_specifier::reflection_get() );
                reflection->push_back( class_reflection::create( "as_access_specifier_public", mdl ) );
        }
        return reflection;
}

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


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

// End of class as_access_specifier_public.

// ------------- Class as_access_specifier_protected follows. -------------

void as_access_specifier_protected::accept_as_access_specifier_visitor( ptr< as_access_specifier_visitor > v )
{
        return v->visit_as_access_specifier_protected( this );
}

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

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

ptr< object::reflection_list > as_access_specifier_protected::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_access_specifier::reflection_get() );
                reflection->push_back( class_reflection::create( "as_access_specifier_protected", mdl ) );
        }
        return reflection;
}

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


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

// End of class as_access_specifier_protected.

// ------------- Class as_access_specifier_private follows. -------------

void as_access_specifier_private::accept_as_access_specifier_visitor( ptr< as_access_specifier_visitor > v )
{
        return v->visit_as_access_specifier_private( this );
}

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

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

ptr< object::reflection_list > as_access_specifier_private::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_access_specifier::reflection_get() );
                reflection->push_back( class_reflection::create( "as_access_specifier_private", mdl ) );
        }
        return reflection;
}

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


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

// End of class as_access_specifier_private.

// ------------- Class as_param_decl_clause follows. -------------

/*!
   \returns The value of as_param_decl_clause::parameters.
   \author lsg
 */
ptr< ::lestes::std::list< srp< as_param_declaration > > > as_param_decl_clause::parameters_get() const
{
        return parameters;
}

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

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

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

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

/*!
   Generated constructor for class as_param_decl_clause.
   \author lsg
 */
as_param_decl_clause::as_param_decl_clause (ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< ::lestes::std::list< srp< as_param_declaration > > > a__as_param_decl_clause__parameters,
                ptr< ::lestes::lang::cplus::lex::cpp_token > a__as_param_decl_clause__ellipsis)
        : as_base(a__as_base__location), parameters(checked(a__as_param_decl_clause__parameters)), ellipsis(a__as_param_decl_clause__ellipsis)
{}

ptr< object::reflection_list > as_param_decl_clause::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( "parameters", "list&lt; srp&lt; as_param_declaration &gt; &gt;" ) );
                mdl->push_back( md::create( "ellipsis", "cpp_token" ) );
                reflection = reflection_list::create( ::lestes::intercode::as_base::reflection_get() );
                reflection->push_back( class_reflection::create( "as_param_decl_clause", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_param_decl_clause::field_values_get() const
{
        ptr < field_list_list > result = ::lestes::intercode::as_base::field_values_get();
        result->push_back( value_list::create() );
        result->back()->push_back( this->parameters );
        result->push_back( value_list::create() );
        result->back()->push_back( this->ellipsis );
        return result;
}


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

// End of class as_param_decl_clause.

// ------------- Class as_declaration_specifier follows. -------------

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

ptr< object::reflection_list > as_declaration_specifier::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_declaration_specifier", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_declaration_specifier::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_declaration_specifier::gc_mark()
{
	::lestes::intercode::as_base::gc_mark();
}

// End of class as_declaration_specifier.

// ------------- Class as_function_specifier follows. -------------

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

ptr< object::reflection_list > as_function_specifier::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_declaration_specifier::reflection_get() );
                reflection->push_back( class_reflection::create( "as_function_specifier", mdl ) );
        }
        return reflection;
}

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


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

// End of class as_function_specifier.

// ------------- Class as_function_specifier_inline follows. -------------

void as_function_specifier_inline::accept_as_declaration_specifier_visitor( ptr< as_declaration_specifier_visitor > v )
{
        return v->visit_as_function_specifier_inline( this );
}

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

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

ptr< object::reflection_list > as_function_specifier_inline::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_function_specifier::reflection_get() );
                reflection->push_back( class_reflection::create( "as_function_specifier_inline", mdl ) );
        }
        return reflection;
}

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


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

// End of class as_function_specifier_inline.

// ------------- Class as_function_specifier_virtual follows. -------------

void as_function_specifier_virtual::accept_as_declaration_specifier_visitor( ptr< as_declaration_specifier_visitor > v )
{
        return v->visit_as_function_specifier_virtual( this );
}

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

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

ptr< object::reflection_list > as_function_specifier_virtual::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_function_specifier::reflection_get() );
                reflection->push_back( class_reflection::create( "as_function_specifier_virtual", mdl ) );
        }
        return reflection;
}

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


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

// End of class as_function_specifier_virtual.

// ------------- Class as_function_specifier_explicit follows. -------------

void as_function_specifier_explicit::accept_as_declaration_specifier_visitor( ptr< as_declaration_specifier_visitor > v )
{
        return v->visit_as_function_specifier_explicit( this );
}

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

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

ptr< object::reflection_list > as_function_specifier_explicit::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_function_specifier::reflection_get() );
                reflection->push_back( class_reflection::create( "as_function_specifier_explicit", mdl ) );
        }
        return reflection;
}

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


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

// End of class as_function_specifier_explicit.

// ------------- Class as_friend_specifier follows. -------------

void as_friend_specifier::accept_as_declaration_specifier_visitor( ptr< as_declaration_specifier_visitor > v )
{
        return v->visit_as_friend_specifier( this );
}

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

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

ptr< object::reflection_list > as_friend_specifier::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_declaration_specifier::reflection_get() );
                reflection->push_back( class_reflection::create( "as_friend_specifier", mdl ) );
        }
        return reflection;
}

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


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

// End of class as_friend_specifier.

// ------------- Class as_typedef_specifier follows. -------------

void as_typedef_specifier::accept_as_declaration_specifier_visitor( ptr< as_declaration_specifier_visitor > v )
{
        return v->visit_as_typedef_specifier( this );
}

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

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

ptr< object::reflection_list > as_typedef_specifier::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_declaration_specifier::reflection_get() );
                reflection->push_back( class_reflection::create( "as_typedef_specifier", mdl ) );
        }
        return reflection;
}

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


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

// End of class as_typedef_specifier.

// ------------- Class as_storage_class_specifier follows. -------------

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

ptr< object::reflection_list > as_storage_class_specifier::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_declaration_specifier::reflection_get() );
                reflection->push_back( class_reflection::create( "as_storage_class_specifier", mdl ) );
        }
        return reflection;
}

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


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

// End of class as_storage_class_specifier.

// ------------- Class as_storage_class_specifier_auto follows. -------------

void as_storage_class_specifier_auto::accept_as_declaration_specifier_visitor( ptr< as_declaration_specifier_visitor > v )
{
        return v->visit_as_storage_class_specifier_auto( this );
}

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

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

ptr< object::reflection_list > as_storage_class_specifier_auto::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_storage_class_specifier::reflection_get() );
                reflection->push_back( class_reflection::create( "as_storage_class_specifier_auto", mdl ) );
        }
        return reflection;
}

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


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

// End of class as_storage_class_specifier_auto.

// ------------- Class as_storage_class_specifier_register follows. -------------

void as_storage_class_specifier_register::accept_as_declaration_specifier_visitor( ptr< as_declaration_specifier_visitor > v )
{
        return v->visit_as_storage_class_specifier_register( this );
}

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

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

ptr< object::reflection_list > as_storage_class_specifier_register::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_storage_class_specifier::reflection_get() );
                reflection->push_back( class_reflection::create( "as_storage_class_specifier_register", mdl ) );
        }
        return reflection;
}

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


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

// End of class as_storage_class_specifier_register.

// ------------- Class as_storage_class_specifier_static follows. -------------

void as_storage_class_specifier_static::accept_as_declaration_specifier_visitor( ptr< as_declaration_specifier_visitor > v )
{
        return v->visit_as_storage_class_specifier_static( this );
}

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

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

ptr< object::reflection_list > as_storage_class_specifier_static::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_storage_class_specifier::reflection_get() );
                reflection->push_back( class_reflection::create( "as_storage_class_specifier_static", mdl ) );
        }
        return reflection;
}

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


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

// End of class as_storage_class_specifier_static.

// ------------- Class as_storage_class_specifier_extern follows. -------------

void as_storage_class_specifier_extern::accept_as_declaration_specifier_visitor( ptr< as_declaration_specifier_visitor > v )
{
        return v->visit_as_storage_class_specifier_extern( this );
}

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

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

ptr< object::reflection_list > as_storage_class_specifier_extern::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_storage_class_specifier::reflection_get() );
                reflection->push_back( class_reflection::create( "as_storage_class_specifier_extern", mdl ) );
        }
        return reflection;
}

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


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

// End of class as_storage_class_specifier_extern.

// ------------- Class as_storage_class_specifier_mutable follows. -------------

void as_storage_class_specifier_mutable::accept_as_declaration_specifier_visitor( ptr< as_declaration_specifier_visitor > v )
{
        return v->visit_as_storage_class_specifier_mutable( this );
}

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

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

ptr< object::reflection_list > as_storage_class_specifier_mutable::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_storage_class_specifier::reflection_get() );
                reflection->push_back( class_reflection::create( "as_storage_class_specifier_mutable", mdl ) );
        }
        return reflection;
}

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


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

// End of class as_storage_class_specifier_mutable.

// ------------- Class as_type_specifier follows. -------------

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

ptr< object::reflection_list > as_type_specifier::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_declaration_specifier::reflection_get() );
                reflection->push_back( class_reflection::create( "as_type_specifier", mdl ) );
        }
        return reflection;
}

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


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

// End of class as_type_specifier.

// ------------- Class as_enumeration_specifier follows. -------------

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

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

/*!
   \returns The value of as_enumeration_specifier::enumerators.
   \author lsg
 */
ptr< ::lestes::std::list< srp< as_enumerator_definition > > > as_enumeration_specifier::enumerators_get() const
{
        return enumerators;
}

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

void as_enumeration_specifier::accept_as_declaration_specifier_visitor( ptr< as_declaration_specifier_visitor > v )
{
        return v->visit_as_enumeration_specifier( this );
}

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

/*!
   Generated constructor for class as_enumeration_specifier.
   \author lsg
 */
as_enumeration_specifier::as_enumeration_specifier (ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_name > a__as_enumeration_specifier__name,
                ptr< ::lestes::std::list< srp< as_enumerator_definition > > > a__as_enumeration_specifier__enumerators)
        : as_type_specifier(a__as_base__location), name(a__as_enumeration_specifier__name), enumerators(checked(a__as_enumeration_specifier__enumerators))
{}

ptr< object::reflection_list > as_enumeration_specifier::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" ) );
                mdl->push_back( md::create( "enumerators", "list&lt; srp&lt; as_enumerator_definition &gt; &gt;" ) );
                reflection = reflection_list::create( as_type_specifier::reflection_get() );
                reflection->push_back( class_reflection::create( "as_enumeration_specifier", mdl ) );
        }
        return reflection;
}

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


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

// End of class as_enumeration_specifier.

// ------------- Class as_simple_type_specifier follows. -------------

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

ptr< object::reflection_list > as_simple_type_specifier::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_type_specifier::reflection_get() );
                reflection->push_back( class_reflection::create( "as_simple_type_specifier", mdl ) );
        }
        return reflection;
}

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


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

// End of class as_simple_type_specifier.

// ------------- Class as_builtin_simple_type_specifier follows. -------------

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

ptr< object::reflection_list > as_builtin_simple_type_specifier::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_simple_type_specifier::reflection_get() );
                reflection->push_back( class_reflection::create( "as_builtin_simple_type_specifier", mdl ) );
        }
        return reflection;
}

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


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

// End of class as_builtin_simple_type_specifier.

// ------------- Class as_char_simple_type_specifier follows. -------------

void as_char_simple_type_specifier::accept_as_declaration_specifier_visitor( ptr< as_declaration_specifier_visitor > v )
{
        return v->visit_as_char_simple_type_specifier( this );
}

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

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

ptr< object::reflection_list > as_char_simple_type_specifier::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_builtin_simple_type_specifier::reflection_get() );
                reflection->push_back( class_reflection::create( "as_char_simple_type_specifier", mdl ) );
        }
        return reflection;
}

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


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

// End of class as_char_simple_type_specifier.

// ------------- Class as_wchar_t_simple_type_specifier follows. -------------

void as_wchar_t_simple_type_specifier::accept_as_declaration_specifier_visitor( ptr< as_declaration_specifier_visitor > v )
{
        return v->visit_as_wchar_t_simple_type_specifier( this );
}

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

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

ptr< object::reflection_list > as_wchar_t_simple_type_specifier::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_builtin_simple_type_specifier::reflection_get() );
                reflection->push_back( class_reflection::create( "as_wchar_t_simple_type_specifier", mdl ) );
        }
        return reflection;
}

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


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

// End of class as_wchar_t_simple_type_specifier.

// ------------- Class as_bool_simple_type_specifier follows. -------------

void as_bool_simple_type_specifier::accept_as_declaration_specifier_visitor( ptr< as_declaration_specifier_visitor > v )
{
        return v->visit_as_bool_simple_type_specifier( this );
}

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

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

ptr< object::reflection_list > as_bool_simple_type_specifier::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_builtin_simple_type_specifier::reflection_get() );
                reflection->push_back( class_reflection::create( "as_bool_simple_type_specifier", mdl ) );
        }
        return reflection;
}

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


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

// End of class as_bool_simple_type_specifier.

// ------------- Class as_short_simple_type_specifier follows. -------------

void as_short_simple_type_specifier::accept_as_declaration_specifier_visitor( ptr< as_declaration_specifier_visitor > v )
{
        return v->visit_as_short_simple_type_specifier( this );
}

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

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

ptr< object::reflection_list > as_short_simple_type_specifier::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_builtin_simple_type_specifier::reflection_get() );
                reflection->push_back( class_reflection::create( "as_short_simple_type_specifier", mdl ) );
        }
        return reflection;
}

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


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

// End of class as_short_simple_type_specifier.

// ------------- Class as_int_simple_type_specifier follows. -------------

void as_int_simple_type_specifier::accept_as_declaration_specifier_visitor( ptr< as_declaration_specifier_visitor > v )
{
        return v->visit_as_int_simple_type_specifier( this );
}

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

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

ptr< object::reflection_list > as_int_simple_type_specifier::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_builtin_simple_type_specifier::reflection_get() );
                reflection->push_back( class_reflection::create( "as_int_simple_type_specifier", mdl ) );
        }
        return reflection;
}

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


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

// End of class as_int_simple_type_specifier.

// ------------- Class as_long_simple_type_specifier follows. -------------

void as_long_simple_type_specifier::accept_as_declaration_specifier_visitor( ptr< as_declaration_specifier_visitor > v )
{
        return v->visit_as_long_simple_type_specifier( this );
}

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

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

ptr< object::reflection_list > as_long_simple_type_specifier::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_builtin_simple_type_specifier::reflection_get() );
                reflection->push_back( class_reflection::create( "as_long_simple_type_specifier", mdl ) );
        }
        return reflection;
}

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


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

// End of class as_long_simple_type_specifier.

// ------------- Class as_signed_simple_type_specifier follows. -------------

void as_signed_simple_type_specifier::accept_as_declaration_specifier_visitor( ptr< as_declaration_specifier_visitor > v )
{
        return v->visit_as_signed_simple_type_specifier( this );
}

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

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

ptr< object::reflection_list > as_signed_simple_type_specifier::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_builtin_simple_type_specifier::reflection_get() );
                reflection->push_back( class_reflection::create( "as_signed_simple_type_specifier", mdl ) );
        }
        return reflection;
}

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


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

// End of class as_signed_simple_type_specifier.

// ------------- Class as_unsigned_simple_type_specifier follows. -------------

void as_unsigned_simple_type_specifier::accept_as_declaration_specifier_visitor( ptr< as_declaration_specifier_visitor > v )
{
        return v->visit_as_unsigned_simple_type_specifier( this );
}

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

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

ptr< object::reflection_list > as_unsigned_simple_type_specifier::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_builtin_simple_type_specifier::reflection_get() );
                reflection->push_back( class_reflection::create( "as_unsigned_simple_type_specifier", mdl ) );
        }
        return reflection;
}

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


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

// End of class as_unsigned_simple_type_specifier.

// ------------- Class as_float_simple_type_specifier follows. -------------

void as_float_simple_type_specifier::accept_as_declaration_specifier_visitor( ptr< as_declaration_specifier_visitor > v )
{
        return v->visit_as_float_simple_type_specifier( this );
}

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

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

ptr< object::reflection_list > as_float_simple_type_specifier::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_builtin_simple_type_specifier::reflection_get() );
                reflection->push_back( class_reflection::create( "as_float_simple_type_specifier", mdl ) );
        }
        return reflection;
}

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


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

// End of class as_float_simple_type_specifier.

// ------------- Class as_double_simple_type_specifier follows. -------------

void as_double_simple_type_specifier::accept_as_declaration_specifier_visitor( ptr< as_declaration_specifier_visitor > v )
{
        return v->visit_as_double_simple_type_specifier( this );
}

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

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

ptr< object::reflection_list > as_double_simple_type_specifier::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_builtin_simple_type_specifier::reflection_get() );
                reflection->push_back( class_reflection::create( "as_double_simple_type_specifier", mdl ) );
        }
        return reflection;
}

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


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

// End of class as_double_simple_type_specifier.

// ------------- Class as_void_simple_type_specifier follows. -------------

void as_void_simple_type_specifier::accept_as_declaration_specifier_visitor( ptr< as_declaration_specifier_visitor > v )
{
        return v->visit_as_void_simple_type_specifier( this );
}

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

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

ptr< object::reflection_list > as_void_simple_type_specifier::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_builtin_simple_type_specifier::reflection_get() );
                reflection->push_back( class_reflection::create( "as_void_simple_type_specifier", mdl ) );
        }
        return reflection;
}

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


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

// End of class as_void_simple_type_specifier.

// ------------- Class as_cv_qualifier follows. -------------

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

ptr< object::reflection_list > as_cv_qualifier::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_type_specifier::reflection_get() );
                reflection->push_back( class_reflection::create( "as_cv_qualifier", mdl ) );
        }
        return reflection;
}

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


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

// End of class as_cv_qualifier.

// ------------- Class as_cv_qualifier_const follows. -------------

void as_cv_qualifier_const::accept_as_cv_qualifier_visitor( ptr< as_cv_qualifier_visitor > v )
{
        return v->visit_as_cv_qualifier_const( this );
}

void as_cv_qualifier_const::accept_as_declaration_specifier_visitor( ptr< as_declaration_specifier_visitor > v )
{
        return v->visit_as_cv_qualifier_const( this );
}

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

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

ptr< object::reflection_list > as_cv_qualifier_const::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_cv_qualifier::reflection_get() );
                reflection->push_back( class_reflection::create( "as_cv_qualifier_const", mdl ) );
        }
        return reflection;
}

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


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

// End of class as_cv_qualifier_const.

// ------------- Class as_cv_qualifier_volatile follows. -------------

void as_cv_qualifier_volatile::accept_as_cv_qualifier_visitor( ptr< as_cv_qualifier_visitor > v )
{
        return v->visit_as_cv_qualifier_volatile( this );
}

void as_cv_qualifier_volatile::accept_as_declaration_specifier_visitor( ptr< as_declaration_specifier_visitor > v )
{
        return v->visit_as_cv_qualifier_volatile( this );
}

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

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

ptr< object::reflection_list > as_cv_qualifier_volatile::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_cv_qualifier::reflection_get() );
                reflection->push_back( class_reflection::create( "as_cv_qualifier_volatile", mdl ) );
        }
        return reflection;
}

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


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

// End of class as_cv_qualifier_volatile.

// ------------- Class as_cv_qualifier_restrict follows. -------------

void as_cv_qualifier_restrict::accept_as_cv_qualifier_visitor( ptr< as_cv_qualifier_visitor > v )
{
        return v->visit_as_cv_qualifier_restrict( this );
}

void as_cv_qualifier_restrict::accept_as_declaration_specifier_visitor( ptr< as_declaration_specifier_visitor > v )
{
        return v->visit_as_cv_qualifier_restrict( this );
}

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

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

ptr< object::reflection_list > as_cv_qualifier_restrict::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_cv_qualifier::reflection_get() );
                reflection->push_back( class_reflection::create( "as_cv_qualifier_restrict", mdl ) );
        }
        return reflection;
}

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


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

// End of class as_cv_qualifier_restrict.

// ------------- Class as_elaborated_type_specifier follows. -------------

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

ptr< object::reflection_list > as_elaborated_type_specifier::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_type_specifier::reflection_get() );
                reflection->push_back( class_reflection::create( "as_elaborated_type_specifier", mdl ) );
        }
        return reflection;
}

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


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

// End of class as_elaborated_type_specifier.

// ------------- Class as_named_simple_type_specifier follows. -------------

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

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

void as_named_simple_type_specifier::accept_as_declaration_specifier_visitor( ptr< as_declaration_specifier_visitor > v )
{
        return v->visit_as_named_simple_type_specifier( this );
}

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

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

ptr< object::reflection_list > as_named_simple_type_specifier::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_simple_type_specifier::reflection_get() );
                reflection->push_back( class_reflection::create( "as_named_simple_type_specifier", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_named_simple_type_specifier::field_values_get() const
{
        ptr < field_list_list > result = as_simple_type_specifier::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_named_simple_type_specifier::gc_mark()
{
        as_simple_type_specifier::gc_mark();
}

// End of class as_named_simple_type_specifier.

// ------------- Class as_exception_specification follows. -------------

/*!
   \returns The value of as_exception_specification::type_ids.
   \author lsg
 */
ptr< ::lestes::std::list< srp< as_type_id > > > as_exception_specification::type_ids_get() const
{
        return type_ids;
}

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

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

/*!
   Generated constructor for class as_exception_specification.
   \author lsg
 */
as_exception_specification::as_exception_specification (ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< ::lestes::std::list< srp< as_type_id > > > a__as_exception_specification__type_ids)
        : as_base(a__as_base__location), type_ids(checked(a__as_exception_specification__type_ids))
{}

ptr< object::reflection_list > as_exception_specification::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_ids", "list&lt; srp&lt; as_type_id &gt; &gt;" ) );
                reflection = reflection_list::create( ::lestes::intercode::as_base::reflection_get() );
                reflection->push_back( class_reflection::create( "as_exception_specification", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_exception_specification::field_values_get() const
{
        ptr < field_list_list > result = ::lestes::intercode::as_base::field_values_get();
        result->push_back( value_list::create() );
        result->back()->push_back( this->type_ids );
        return result;
}


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

// End of class as_exception_specification.

// ------------- Class as_elaborated_type_specifier_typename follows. -------------

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

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

void as_elaborated_type_specifier_typename::accept_as_declaration_specifier_visitor( ptr< as_declaration_specifier_visitor > v )
{
        return v->visit_as_elaborated_type_specifier_typename( this );
}

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

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

ptr< object::reflection_list > as_elaborated_type_specifier_typename::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_elaborated_type_specifier::reflection_get() );
                reflection->push_back( class_reflection::create( "as_elaborated_type_specifier_typename", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_elaborated_type_specifier_typename::field_values_get() const
{
        ptr < field_list_list > result = as_elaborated_type_specifier::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_elaborated_type_specifier_typename::gc_mark()
{
        as_elaborated_type_specifier::gc_mark();
}

// End of class as_elaborated_type_specifier_typename.

// ------------- Class as_elaborated_type_specifier_tagged follows. -------------

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

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

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

ptr< object::reflection_list > as_elaborated_type_specifier_tagged::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_elaborated_type_specifier::reflection_get() );
                reflection->push_back( class_reflection::create( "as_elaborated_type_specifier_tagged", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_elaborated_type_specifier_tagged::field_values_get() const
{
        ptr < field_list_list > result = as_elaborated_type_specifier::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_elaborated_type_specifier_tagged::gc_mark()
{
        as_elaborated_type_specifier::gc_mark();
}

// End of class as_elaborated_type_specifier_tagged.

// ------------- Class as_elaborated_type_specifier_class_key follows. -------------

/*!
   \returns The value of as_elaborated_type_specifier_class_key::key.
   \author lsg
 */
ptr< as_class_key > as_elaborated_type_specifier_class_key::key_get() const
{
        return key;
}

/*!
   \param[in] x The new value to set as_elaborated_type_specifier_class_key::key to.
   \author lsg
 */
void as_elaborated_type_specifier_class_key::key_set(const ptr< as_class_key > & x)
{
        as_elaborated_type_specifier_class_key::key = x;
}

void as_elaborated_type_specifier_class_key::accept_as_declaration_specifier_visitor( ptr< as_declaration_specifier_visitor > v )
{
        return v->visit_as_elaborated_type_specifier_class_key( this );
}

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

/*!
   Generated constructor for class as_elaborated_type_specifier_class_key.
   \author lsg
 */
as_elaborated_type_specifier_class_key::as_elaborated_type_specifier_class_key (ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_name > a__as_elaborated_type_specifier_tagged__name,
                ptr< as_class_key > a__as_elaborated_type_specifier_class_key__key)
        : as_elaborated_type_specifier_tagged(a__as_base__location,
                a__as_elaborated_type_specifier_tagged__name), key(checked(a__as_elaborated_type_specifier_class_key__key))
{}

ptr< object::reflection_list > as_elaborated_type_specifier_class_key::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( "key", "as_class_key" ) );
                reflection = reflection_list::create( as_elaborated_type_specifier_tagged::reflection_get() );
                reflection->push_back( class_reflection::create( "as_elaborated_type_specifier_class_key", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_elaborated_type_specifier_class_key::field_values_get() const
{
        ptr < field_list_list > result = as_elaborated_type_specifier_tagged::field_values_get();
        result->push_back( value_list::create() );
        result->back()->push_back( this->key );
        return result;
}


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

// End of class as_elaborated_type_specifier_class_key.

// ------------- Class as_elaborated_type_specifier_enum follows. -------------

void as_elaborated_type_specifier_enum::accept_as_declaration_specifier_visitor( ptr< as_declaration_specifier_visitor > v )
{
        return v->visit_as_elaborated_type_specifier_enum( this );
}

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

/*!
   Generated constructor for class as_elaborated_type_specifier_enum.
   \author lsg
 */
as_elaborated_type_specifier_enum::as_elaborated_type_specifier_enum (ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_name > a__as_elaborated_type_specifier_tagged__name)
        : as_elaborated_type_specifier_tagged(a__as_base__location,
                a__as_elaborated_type_specifier_tagged__name)
{}

ptr< object::reflection_list > as_elaborated_type_specifier_enum::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_elaborated_type_specifier_tagged::reflection_get() );
                reflection->push_back( class_reflection::create( "as_elaborated_type_specifier_enum", mdl ) );
        }
        return reflection;
}

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


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

// End of class as_elaborated_type_specifier_enum.

// ------------- Class as_template_argument follows. -------------

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

ptr< object::reflection_list > as_template_argument::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_template_argument", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_template_argument::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_template_argument::gc_mark()
{
	::lestes::intercode::as_base::gc_mark();
}

// End of class as_template_argument.

// ------------- Class as_non_type_template_argument follows. -------------

/*!
   \returns The value of as_non_type_template_argument::expression.
   \author lsg
 */
ptr< as_expression > as_non_type_template_argument::expression_get() const
{
        return expression;
}

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

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

/*!
   Generated constructor for class as_non_type_template_argument.
   \author lsg
 */
as_non_type_template_argument::as_non_type_template_argument (ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_expression > a__as_non_type_template_argument__expression)
        : as_template_argument(a__as_base__location), expression(checked(a__as_non_type_template_argument__expression))
{}

ptr< object::reflection_list > as_non_type_template_argument::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( "expression", "as_expression" ) );
                reflection = reflection_list::create( as_template_argument::reflection_get() );
                reflection->push_back( class_reflection::create( "as_non_type_template_argument", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_non_type_template_argument::field_values_get() const
{
        ptr < field_list_list > result = as_template_argument::field_values_get();
        result->push_back( value_list::create() );
        result->back()->push_back( this->expression );
        return result;
}


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

// End of class as_non_type_template_argument.

// ------------- Class as_type_template_argument follows. -------------

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

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

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

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

ptr< object::reflection_list > as_type_template_argument::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_template_argument::reflection_get() );
                reflection->push_back( class_reflection::create( "as_type_template_argument", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_type_template_argument::field_values_get() const
{
        ptr < field_list_list > result = as_template_argument::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_type_template_argument::gc_mark()
{
        as_template_argument::gc_mark();
}

// End of class as_type_template_argument.

// ------------- Class as_declarator follows. -------------

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

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

/*!
   \returns The value of as_declarator::declarator_ops.
   \author lsg
 */
ptr< ::lestes::std::list< srp< as_declarator_op > > > as_declarator::declarator_ops_get() const
{
        return declarator_ops;
}

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

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

/*!
   Generated constructor for class as_declarator.
   \author lsg
 */
as_declarator::as_declarator (ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_name > a__as_declarator__name,
                ptr< ::lestes::std::list< srp< as_declarator_op > > > a__as_declarator__declarator_ops)
        : as_base(a__as_base__location), name(a__as_declarator__name), declarator_ops(checked(a__as_declarator__declarator_ops))
{}

ptr< object::reflection_list > as_declarator::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" ) );
                mdl->push_back( md::create( "declarator_ops", "list&lt; srp&lt; as_declarator_op &gt; &gt;" ) );
                reflection = reflection_list::create( ::lestes::intercode::as_base::reflection_get() );
                reflection->push_back( class_reflection::create( "as_declarator", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_declarator::field_values_get() const
{
        ptr < field_list_list > result = ::lestes::intercode::as_base::field_values_get();
        result->push_back( value_list::create() );
        result->back()->push_back( this->name );
        result->push_back( value_list::create() );
        result->back()->push_back( this->declarator_ops );
        return result;
}


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

// End of class as_declarator.

// ------------- Class as_dummy_declarator follows. -------------

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

/*!
   Generated constructor for class as_dummy_declarator.
   \author lsg
 */
as_dummy_declarator::as_dummy_declarator (ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_name > a__as_declarator__name,
                ptr< ::lestes::std::list< srp< as_declarator_op > > > a__as_declarator__declarator_ops)
        : as_declarator(a__as_base__location,
                a__as_declarator__name,
                a__as_declarator__declarator_ops)
{}

ptr< object::reflection_list > as_dummy_declarator::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_declarator::reflection_get() );
                reflection->push_back( class_reflection::create( "as_dummy_declarator", mdl ) );
        }
        return reflection;
}

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


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

// End of class as_dummy_declarator.

// ------------- Class as_declarator_op follows. -------------

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

ptr< object::reflection_list > as_declarator_op::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_declarator_op", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_declarator_op::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_declarator_op::gc_mark()
{
	::lestes::intercode::as_base::gc_mark();
}

// End of class as_declarator_op.

// ------------- Class as_declarator_op_ptr follows. -------------

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

ptr< object::reflection_list > as_declarator_op_ptr::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_declarator_op::reflection_get() );
                reflection->push_back( class_reflection::create( "as_declarator_op_ptr", mdl ) );
        }
        return reflection;
}

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


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

// End of class as_declarator_op_ptr.

// ------------- Class as_ptr_op_star follows. -------------

/*!
   \returns The value of as_ptr_op_star::cv_qualifiers.
   \author lsg
 */
ptr< ::lestes::std::list< srp< as_cv_qualifier > > > as_ptr_op_star::cv_qualifiers_get() const
{
        return cv_qualifiers;
}

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

void as_ptr_op_star::accept_as_declarator_op_visitor( ptr< as_declarator_op_visitor > v )
{
        return v->visit_as_ptr_op_star( this );
}

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

/*!
   Generated constructor for class as_ptr_op_star.
   \author lsg
 */
as_ptr_op_star::as_ptr_op_star (ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< ::lestes::std::list< srp< as_cv_qualifier > > > a__as_ptr_op_star__cv_qualifiers)
        : as_declarator_op_ptr(a__as_base__location), cv_qualifiers(checked(a__as_ptr_op_star__cv_qualifiers))
{}

ptr< object::reflection_list > as_ptr_op_star::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( "cv_qualifiers", "list&lt; srp&lt; as_cv_qualifier &gt; &gt;" ) );
                reflection = reflection_list::create( as_declarator_op_ptr::reflection_get() );
                reflection->push_back( class_reflection::create( "as_ptr_op_star", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_ptr_op_star::field_values_get() const
{
        ptr < field_list_list > result = as_declarator_op_ptr::field_values_get();
        result->push_back( value_list::create() );
        result->back()->push_back( this->cv_qualifiers );
        return result;
}


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

// End of class as_ptr_op_star.

// ------------- Class as_ptr_op_amp follows. -------------

void as_ptr_op_amp::accept_as_declarator_op_visitor( ptr< as_declarator_op_visitor > v )
{
        return v->visit_as_ptr_op_amp( this );
}

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

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

ptr< object::reflection_list > as_ptr_op_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_declarator_op_ptr::reflection_get() );
                reflection->push_back( class_reflection::create( "as_ptr_op_amp", mdl ) );
        }
        return reflection;
}

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


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

// End of class as_ptr_op_amp.

// ------------- Class as_ptr_op_member_ptr follows. -------------

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

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

/*!
   \returns The value of as_ptr_op_member_ptr::cv_qualifiers.
   \author lsg
 */
ptr< ::lestes::std::list< srp< as_cv_qualifier > > > as_ptr_op_member_ptr::cv_qualifiers_get() const
{
        return cv_qualifiers;
}

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

void as_ptr_op_member_ptr::accept_as_declarator_op_visitor( ptr< as_declarator_op_visitor > v )
{
        return v->visit_as_ptr_op_member_ptr( this );
}

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

/*!
   Generated constructor for class as_ptr_op_member_ptr.
   \author lsg
 */
as_ptr_op_member_ptr::as_ptr_op_member_ptr (ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_name > a__as_ptr_op_member_ptr__name,
                ptr< ::lestes::std::list< srp< as_cv_qualifier > > > a__as_ptr_op_member_ptr__cv_qualifiers)
        : as_declarator_op_ptr(a__as_base__location), name(checked(a__as_ptr_op_member_ptr__name)), cv_qualifiers(checked(a__as_ptr_op_member_ptr__cv_qualifiers))
{}

ptr< object::reflection_list > as_ptr_op_member_ptr::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" ) );
                mdl->push_back( md::create( "cv_qualifiers", "list&lt; srp&lt; as_cv_qualifier &gt; &gt;" ) );
                reflection = reflection_list::create( as_declarator_op_ptr::reflection_get() );
                reflection->push_back( class_reflection::create( "as_ptr_op_member_ptr", mdl ) );
        }
        return reflection;
}

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


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

// End of class as_ptr_op_member_ptr.

// ------------- Class as_declarator_op_func follows. -------------

/*!
   \returns The value of as_declarator_op_func::parameters.
   \author lsg
 */
ptr< as_param_decl_clause > as_declarator_op_func::parameters_get() const
{
        return parameters;
}

/*!
   \param[in] x The new value to set as_declarator_op_func::parameters to.
   \author lsg
 */
void as_declarator_op_func::parameters_set(const ptr< as_param_decl_clause > & x)
{
        as_declarator_op_func::parameters = x;
}

/*!
   \returns The value of as_declarator_op_func::cv_qualifiers.
   \author lsg
 */
ptr< ::lestes::std::list< srp< as_cv_qualifier > > > as_declarator_op_func::cv_qualifiers_get() const
{
        return cv_qualifiers;
}

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

/*!
   \returns The value of as_declarator_op_func::exception_specification.
   \author lsg
 */
ptr< as_exception_specification > as_declarator_op_func::exception_specification_get() const
{
        return exception_specification;
}

/*!
   \param[in] x The new value to set as_declarator_op_func::exception_specification to.
   \author lsg
 */
void as_declarator_op_func::exception_specification_set(const ptr< as_exception_specification > & x)
{
        as_declarator_op_func::exception_specification = x;
}

void as_declarator_op_func::accept_as_declarator_op_visitor( ptr< as_declarator_op_visitor > v )
{
        return v->visit_as_declarator_op_func( this );
}

/*!
   This factory method for class as_declarator_op_func takes values of all fields as arguments.
   \author lsg
 */
ptr< as_declarator_op_func > as_declarator_op_func::create(ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_param_decl_clause > a__as_declarator_op_func__parameters,
                ptr< ::lestes::std::list< srp< as_cv_qualifier > > > a__as_declarator_op_func__cv_qualifiers,
                ptr< as_exception_specification > a__as_declarator_op_func__exception_specification)
{
        return ptr< as_declarator_op_func > ( new as_declarator_op_func(a__as_base__location,
                a__as_declarator_op_func__parameters,
                a__as_declarator_op_func__cv_qualifiers,
                a__as_declarator_op_func__exception_specification) );
}

/*!
   Generated constructor for class as_declarator_op_func.
   \author lsg
 */
as_declarator_op_func::as_declarator_op_func (ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_param_decl_clause > a__as_declarator_op_func__parameters,
                ptr< ::lestes::std::list< srp< as_cv_qualifier > > > a__as_declarator_op_func__cv_qualifiers,
                ptr< as_exception_specification > a__as_declarator_op_func__exception_specification)
        : as_declarator_op(a__as_base__location), parameters(checked(a__as_declarator_op_func__parameters)), cv_qualifiers(checked(a__as_declarator_op_func__cv_qualifiers)), exception_specification(a__as_declarator_op_func__exception_specification)
{}

ptr< object::reflection_list > as_declarator_op_func::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( "parameters", "as_param_decl_clause" ) );
                mdl->push_back( md::create( "cv_qualifiers", "list&lt; srp&lt; as_cv_qualifier &gt; &gt;" ) );
                mdl->push_back( md::create( "exception_specification", "as_exception_specification" ) );
                reflection = reflection_list::create( as_declarator_op::reflection_get() );
                reflection->push_back( class_reflection::create( "as_declarator_op_func", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_declarator_op_func::field_values_get() const
{
        ptr < field_list_list > result = as_declarator_op::field_values_get();
        result->push_back( value_list::create() );
        result->back()->push_back( this->parameters );
        result->push_back( value_list::create() );
        result->back()->push_back( this->cv_qualifiers );
        result->push_back( value_list::create() );
        result->back()->push_back( this->exception_specification );
        return result;
}


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

// End of class as_declarator_op_func.

// ------------- Class as_declarator_op_array follows. -------------

/*!
   \returns The value of as_declarator_op_array::constant_expression.
   \author lsg
 */
ptr< as_constant_expression > as_declarator_op_array::constant_expression_get() const
{
        return constant_expression;
}

/*!
   \param[in] x The new value to set as_declarator_op_array::constant_expression to.
   \author lsg
 */
void as_declarator_op_array::constant_expression_set(const ptr< as_constant_expression > & x)
{
        as_declarator_op_array::constant_expression = x;
}

void as_declarator_op_array::accept_as_declarator_op_visitor( ptr< as_declarator_op_visitor > v )
{
        return v->visit_as_declarator_op_array( this );
}

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

/*!
   Generated constructor for class as_declarator_op_array.
   \author lsg
 */
as_declarator_op_array::as_declarator_op_array (ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_constant_expression > a__as_declarator_op_array__constant_expression)
        : as_declarator_op(a__as_base__location), constant_expression(checked(a__as_declarator_op_array__constant_expression))
{}

ptr< object::reflection_list > as_declarator_op_array::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( "constant_expression", "as_constant_expression" ) );
                reflection = reflection_list::create( as_declarator_op::reflection_get() );
                reflection->push_back( class_reflection::create( "as_declarator_op_array", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_declarator_op_array::field_values_get() const
{
        ptr < field_list_list > result = as_declarator_op::field_values_get();
        result->push_back( value_list::create() );
        result->back()->push_back( this->constant_expression );
        return result;
}


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

// End of class as_declarator_op_array.

// ------------- Class as_declarator_op_non_constant_array follows. -------------

/*!
   \returns The value of as_declarator_op_non_constant_array::expression.
   \author lsg
 */
ptr< as_expression > as_declarator_op_non_constant_array::expression_get() const
{
        return expression;
}

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

void as_declarator_op_non_constant_array::accept_as_declarator_op_visitor( ptr< as_declarator_op_visitor > v )
{
        return v->visit_as_declarator_op_non_constant_array( this );
}

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

/*!
   Generated constructor for class as_declarator_op_non_constant_array.
   \author lsg
 */
as_declarator_op_non_constant_array::as_declarator_op_non_constant_array (ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_expression > a__as_declarator_op_non_constant_array__expression)
        : as_declarator_op(a__as_base__location), expression(checked(a__as_declarator_op_non_constant_array__expression))
{}

ptr< object::reflection_list > as_declarator_op_non_constant_array::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( "expression", "as_expression" ) );
                reflection = reflection_list::create( as_declarator_op::reflection_get() );
                reflection->push_back( class_reflection::create( "as_declarator_op_non_constant_array", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_declarator_op_non_constant_array::field_values_get() const
{
        ptr < field_list_list > result = as_declarator_op::field_values_get();
        result->push_back( value_list::create() );
        result->back()->push_back( this->expression );
        return result;
}


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

// End of class as_declarator_op_non_constant_array.

// ------------- Class as_type_id follows. -------------

/*!
   \returns The value of as_type_id::type_specifiers.
   \author lsg
 */
ptr< ::lestes::std::list< srp< as_type_specifier > > > as_type_id::type_specifiers_get() const
{
        return type_specifiers;
}

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

/*!
   \returns The value of as_type_id::declarator.
   \author lsg
 */
ptr< as_declarator > as_type_id::declarator_get() const
{
        return declarator;
}

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

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

/*!
   Generated constructor for class as_type_id.
   \author lsg
 */
as_type_id::as_type_id (ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< ::lestes::std::list< srp< as_type_specifier > > > a__as_type_id__type_specifiers,
                ptr< as_declarator > a__as_type_id__declarator)
        : as_base(a__as_base__location), type_specifiers(checked(a__as_type_id__type_specifiers)), declarator(checked(a__as_type_id__declarator))
{}

ptr< object::reflection_list > as_type_id::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_specifiers", "list&lt; srp&lt; as_type_specifier &gt; &gt;" ) );
                mdl->push_back( md::create( "declarator", "as_declarator" ) );
                reflection = reflection_list::create( ::lestes::intercode::as_base::reflection_get() );
                reflection->push_back( class_reflection::create( "as_type_id", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_type_id::field_values_get() const
{
        ptr < field_list_list > result = ::lestes::intercode::as_base::field_values_get();
        result->push_back( value_list::create() );
        result->back()->push_back( this->type_specifiers );
        result->push_back( value_list::create() );
        result->back()->push_back( this->declarator );
        return result;
}


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

// End of class as_type_id.

// ------------- Class as_class_key follows. -------------

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

ptr< object::reflection_list > as_class_key::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_class_key", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_class_key::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_class_key::gc_mark()
{
	::lestes::intercode::as_base::gc_mark();
}

// End of class as_class_key.

// ------------- Class as_class_key_class follows. -------------

void as_class_key_class::accept_as_class_key_visitor( ptr< as_class_key_visitor > v )
{
        return v->visit_as_class_key_class( this );
}

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

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

ptr< object::reflection_list > as_class_key_class::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_class_key::reflection_get() );
                reflection->push_back( class_reflection::create( "as_class_key_class", mdl ) );
        }
        return reflection;
}

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


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

// End of class as_class_key_class.

// ------------- Class as_class_key_struct follows. -------------

void as_class_key_struct::accept_as_class_key_visitor( ptr< as_class_key_visitor > v )
{
        return v->visit_as_class_key_struct( this );
}

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

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

ptr< object::reflection_list > as_class_key_struct::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_class_key::reflection_get() );
                reflection->push_back( class_reflection::create( "as_class_key_struct", mdl ) );
        }
        return reflection;
}

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


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

// End of class as_class_key_struct.

// ------------- Class as_class_key_union follows. -------------

void as_class_key_union::accept_as_class_key_visitor( ptr< as_class_key_visitor > v )
{
        return v->visit_as_class_key_union( this );
}

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

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

ptr< object::reflection_list > as_class_key_union::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_class_key::reflection_get() );
                reflection->push_back( class_reflection::create( "as_class_key_union", mdl ) );
        }
        return reflection;
}

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


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

// End of class as_class_key_union.

// ------------- Class as_member_declaration follows. -------------

/*!
   \returns The value of as_member_declaration::access_specifier.
   \author lsg
 */
ptr< as_access_specifier > as_member_declaration::access_specifier_get() const
{
        return access_specifier;
}

/*!
   \param[in] x The new value to set as_member_declaration::access_specifier to.
   \author lsg
 */
void as_member_declaration::access_specifier_set(const ptr< as_access_specifier > & x)
{
        as_member_declaration::access_specifier = x;
}

/*!
   Generated constructor for class as_member_declaration.
   \author lsg
 */
as_member_declaration::as_member_declaration (ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_access_specifier > a__as_member_declaration__access_specifier)
        : as_base(a__as_base__location), access_specifier(checked(a__as_member_declaration__access_specifier))
{}

ptr< object::reflection_list > as_member_declaration::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( "access_specifier", "as_access_specifier" ) );
                reflection = reflection_list::create( ::lestes::intercode::as_base::reflection_get() );
                reflection->push_back( class_reflection::create( "as_member_declaration", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_member_declaration::field_values_get() const
{
        ptr < field_list_list > result = ::lestes::intercode::as_base::field_values_get();
        result->push_back( value_list::create() );
        result->back()->push_back( this->access_specifier );
        return result;
}


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

// End of class as_member_declaration.

// ------------- Class as_member_using_declaration follows. -------------

/*!
   \returns The value of as_member_using_declaration::using_declaration.
   \author lsg
 */
ptr< as_using_declaration > as_member_using_declaration::using_declaration_get() const
{
        return using_declaration;
}

/*!
   \param[in] x The new value to set as_member_using_declaration::using_declaration to.
   \author lsg
 */
void as_member_using_declaration::using_declaration_set(const ptr< as_using_declaration > & x)
{
        as_member_using_declaration::using_declaration = x;
}

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

/*!
   Generated constructor for class as_member_using_declaration.
   \author lsg
 */
as_member_using_declaration::as_member_using_declaration (ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_access_specifier > a__as_member_declaration__access_specifier,
                ptr< as_using_declaration > a__as_member_using_declaration__using_declaration)
        : as_member_declaration(a__as_base__location,
                a__as_member_declaration__access_specifier), using_declaration(checked(a__as_member_using_declaration__using_declaration))
{}

ptr< object::reflection_list > as_member_using_declaration::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( "using_declaration", "as_using_declaration" ) );
                reflection = reflection_list::create( as_member_declaration::reflection_get() );
                reflection->push_back( class_reflection::create( "as_member_using_declaration", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_member_using_declaration::field_values_get() const
{
        ptr < field_list_list > result = as_member_declaration::field_values_get();
        result->push_back( value_list::create() );
        result->back()->push_back( this->using_declaration );
        return result;
}


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

// End of class as_member_using_declaration.

// ------------- Class as_member_template_declaration follows. -------------

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

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

/*!
   \returns The value of as_member_template_declaration::template_params.
   \author lsg
 */
ptr< ::lestes::std::list< srp< as_template_param > > > as_member_template_declaration::template_params_get() const
{
        return template_params;
}

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

/*!
   \returns The value of as_member_template_declaration::declararion.
   \author lsg
 */
ptr< as_member_declaration > as_member_template_declaration::declararion_get() const
{
        return declararion;
}

/*!
   \param[in] x The new value to set as_member_template_declaration::declararion to.
   \author lsg
 */
void as_member_template_declaration::declararion_set(const ptr< as_member_declaration > & x)
{
        as_member_template_declaration::declararion = x;
}

/*!
   This factory method for class as_member_template_declaration takes values of all fields as arguments.
   \author lsg
 */
ptr< as_member_template_declaration > as_member_template_declaration::create(ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_access_specifier > a__as_member_declaration__access_specifier,
                ptr< ::lestes::lang::cplus::lex::cpp_token > a__as_member_template_declaration__exported,
                ptr< ::lestes::std::list< srp< as_template_param > > > a__as_member_template_declaration__template_params,
                ptr< as_member_declaration > a__as_member_template_declaration__declararion)
{
        return ptr< as_member_template_declaration > ( new as_member_template_declaration(a__as_base__location,
                a__as_member_declaration__access_specifier,
                a__as_member_template_declaration__exported,
                a__as_member_template_declaration__template_params,
                a__as_member_template_declaration__declararion) );
}

/*!
   Generated constructor for class as_member_template_declaration.
   \author lsg
 */
as_member_template_declaration::as_member_template_declaration (ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_access_specifier > a__as_member_declaration__access_specifier,
                ptr< ::lestes::lang::cplus::lex::cpp_token > a__as_member_template_declaration__exported,
                ptr< ::lestes::std::list< srp< as_template_param > > > a__as_member_template_declaration__template_params,
                ptr< as_member_declaration > a__as_member_template_declaration__declararion)
        : as_member_declaration(a__as_base__location,
                a__as_member_declaration__access_specifier), exported(a__as_member_template_declaration__exported), template_params(checked(a__as_member_template_declaration__template_params)), declararion(checked(a__as_member_template_declaration__declararion))
{}

ptr< object::reflection_list > as_member_template_declaration::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( "exported", "cpp_token" ) );
                mdl->push_back( md::create( "template_params", "list&lt; srp&lt; as_template_param &gt; &gt;" ) );
                mdl->push_back( md::create( "declararion", "as_member_declaration" ) );
                reflection = reflection_list::create( as_member_declaration::reflection_get() );
                reflection->push_back( class_reflection::create( "as_member_template_declaration", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_member_template_declaration::field_values_get() const
{
        ptr < field_list_list > result = as_member_declaration::field_values_get();
        result->push_back( value_list::create() );
        result->back()->push_back( this->exported );
        result->push_back( value_list::create() );
        result->back()->push_back( this->template_params );
        result->push_back( value_list::create() );
        result->back()->push_back( this->declararion );
        return result;
}


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

// End of class as_member_template_declaration.

// ------------- Class as_member_function_definition follows. -------------

/*!
   \returns The value of as_member_function_definition::function_definition.
   \author lsg
 */
ptr< as_function_definition > as_member_function_definition::function_definition_get() const
{
        return function_definition;
}

/*!
   \param[in] x The new value to set as_member_function_definition::function_definition to.
   \author lsg
 */
void as_member_function_definition::function_definition_set(const ptr< as_function_definition > & x)
{
        as_member_function_definition::function_definition = x;
}

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

/*!
   Generated constructor for class as_member_function_definition.
   \author lsg
 */
as_member_function_definition::as_member_function_definition (ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_access_specifier > a__as_member_declaration__access_specifier,
                ptr< as_function_definition > a__as_member_function_definition__function_definition)
        : as_member_declaration(a__as_base__location,
                a__as_member_declaration__access_specifier), function_definition(checked(a__as_member_function_definition__function_definition))
{}

ptr< object::reflection_list > as_member_function_definition::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( "function_definition", "as_function_definition" ) );
                reflection = reflection_list::create( as_member_declaration::reflection_get() );
                reflection->push_back( class_reflection::create( "as_member_function_definition", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_member_function_definition::field_values_get() const
{
        ptr < field_list_list > result = as_member_declaration::field_values_get();
        result->push_back( value_list::create() );
        result->back()->push_back( this->function_definition );
        return result;
}


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

// End of class as_member_function_definition.

// ------------- Class as_member_declaration_ordinary follows. -------------

/*!
   \returns The value of as_member_declaration_ordinary::declaration_specifiers.
   \author lsg
 */
ptr< ::lestes::std::list< srp< as_declaration_specifier > > > as_member_declaration_ordinary::declaration_specifiers_get() const
{
        return declaration_specifiers;
}

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

/*!
   \returns The value of as_member_declaration_ordinary::declarators.
   \author lsg
 */
ptr< ::lestes::std::list< srp< as_member_declarator > > > as_member_declaration_ordinary::declarators_get() const
{
        return declarators;
}

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

/*!
   This factory method for class as_member_declaration_ordinary takes values of all fields as arguments.
   \author lsg
 */
ptr< as_member_declaration_ordinary > as_member_declaration_ordinary::create(ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_access_specifier > a__as_member_declaration__access_specifier,
                ptr< ::lestes::std::list< srp< as_declaration_specifier > > > a__as_member_declaration_ordinary__declaration_specifiers,
                ptr< ::lestes::std::list< srp< as_member_declarator > > > a__as_member_declaration_ordinary__declarators)
{
        return ptr< as_member_declaration_ordinary > ( new as_member_declaration_ordinary(a__as_base__location,
                a__as_member_declaration__access_specifier,
                a__as_member_declaration_ordinary__declaration_specifiers,
                a__as_member_declaration_ordinary__declarators) );
}

/*!
   Generated constructor for class as_member_declaration_ordinary.
   \author lsg
 */
as_member_declaration_ordinary::as_member_declaration_ordinary (ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_access_specifier > a__as_member_declaration__access_specifier,
                ptr< ::lestes::std::list< srp< as_declaration_specifier > > > a__as_member_declaration_ordinary__declaration_specifiers,
                ptr< ::lestes::std::list< srp< as_member_declarator > > > a__as_member_declaration_ordinary__declarators)
        : as_member_declaration(a__as_base__location,
                a__as_member_declaration__access_specifier), declaration_specifiers(checked(a__as_member_declaration_ordinary__declaration_specifiers)), declarators(checked(a__as_member_declaration_ordinary__declarators))
{}

ptr< object::reflection_list > as_member_declaration_ordinary::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( "declaration_specifiers", "list&lt; srp&lt; as_declaration_specifier &gt; &gt;" ) );
                mdl->push_back( md::create( "declarators", "list&lt; srp&lt; as_member_declarator &gt; &gt;" ) );
                reflection = reflection_list::create( as_member_declaration::reflection_get() );
                reflection->push_back( class_reflection::create( "as_member_declaration_ordinary", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_member_declaration_ordinary::field_values_get() const
{
        ptr < field_list_list > result = as_member_declaration::field_values_get();
        result->push_back( value_list::create() );
        result->back()->push_back( this->declaration_specifiers );
        result->push_back( value_list::create() );
        result->back()->push_back( this->declarators );
        return result;
}


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

// End of class as_member_declaration_ordinary.

// ------------- Class as_member_declarator follows. -------------

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

ptr< object::reflection_list > as_member_declarator::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_member_declarator", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_member_declarator::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_member_declarator::gc_mark()
{
	::lestes::intercode::as_base::gc_mark();
}

// End of class as_member_declarator.

// ------------- Class as_bitfield_member_declarator follows. -------------

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

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

/*!
   \returns The value of as_bitfield_member_declarator::width.
   \author lsg
 */
ptr< as_constant_expression > as_bitfield_member_declarator::width_get() const
{
        return width;
}

/*!
   \param[in] x The new value to set as_bitfield_member_declarator::width to.
   \author lsg
 */
void as_bitfield_member_declarator::width_set(const ptr< as_constant_expression > & x)
{
        as_bitfield_member_declarator::width = x;
}

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

/*!
   Generated constructor for class as_bitfield_member_declarator.
   \author lsg
 */
as_bitfield_member_declarator::as_bitfield_member_declarator (ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_name > a__as_bitfield_member_declarator__name,
                ptr< as_constant_expression > a__as_bitfield_member_declarator__width)
        : as_member_declarator(a__as_base__location), name(a__as_bitfield_member_declarator__name), width(checked(a__as_bitfield_member_declarator__width))
{}

ptr< object::reflection_list > as_bitfield_member_declarator::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" ) );
                mdl->push_back( md::create( "width", "as_constant_expression" ) );
                reflection = reflection_list::create( as_member_declarator::reflection_get() );
                reflection->push_back( class_reflection::create( "as_bitfield_member_declarator", mdl ) );
        }
        return reflection;
}

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


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

// End of class as_bitfield_member_declarator.

// ------------- Class as_ordinary_member_declarator follows. -------------

/*!
   \returns The value of as_ordinary_member_declarator::declarator.
   \author lsg
 */
ptr< as_declarator > as_ordinary_member_declarator::declarator_get() const
{
        return declarator;
}

/*!
   \param[in] x The new value to set as_ordinary_member_declarator::declarator to.
   \author lsg
 */
void as_ordinary_member_declarator::declarator_set(const ptr< as_declarator > & x)
{
        as_ordinary_member_declarator::declarator = x;
}

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

/*!
   Generated constructor for class as_ordinary_member_declarator.
   \author lsg
 */
as_ordinary_member_declarator::as_ordinary_member_declarator (ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_declarator > a__as_ordinary_member_declarator__declarator)
        : as_member_declarator(a__as_base__location), declarator(checked(a__as_ordinary_member_declarator__declarator))
{}

ptr< object::reflection_list > as_ordinary_member_declarator::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( "declarator", "as_declarator" ) );
                reflection = reflection_list::create( as_member_declarator::reflection_get() );
                reflection->push_back( class_reflection::create( "as_ordinary_member_declarator", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_ordinary_member_declarator::field_values_get() const
{
        ptr < field_list_list > result = as_member_declarator::field_values_get();
        result->push_back( value_list::create() );
        result->back()->push_back( this->declarator );
        return result;
}


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

// End of class as_ordinary_member_declarator.

// ------------- Class as_initialized_member_declarator follows. -------------

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

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

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

/*!
   Generated constructor for class as_initialized_member_declarator.
   \author lsg
 */
as_initialized_member_declarator::as_initialized_member_declarator (ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_declarator > a__as_ordinary_member_declarator__declarator,
                ptr< as_constant_expression > a__as_initialized_member_declarator__initializer)
        : as_ordinary_member_declarator(a__as_base__location,
                a__as_ordinary_member_declarator__declarator), initializer(checked(a__as_initialized_member_declarator__initializer))
{}

ptr< object::reflection_list > as_initialized_member_declarator::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( "initializer", "as_constant_expression" ) );
                reflection = reflection_list::create( as_ordinary_member_declarator::reflection_get() );
                reflection->push_back( class_reflection::create( "as_initialized_member_declarator", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_initialized_member_declarator::field_values_get() const
{
        ptr < field_list_list > result = as_ordinary_member_declarator::field_values_get();
        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_initialized_member_declarator::gc_mark()
{
        as_ordinary_member_declarator::gc_mark();
}

// End of class as_initialized_member_declarator.

// ------------- Class as_pure_member_declarator follows. -------------

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

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

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

/*!
   Generated constructor for class as_pure_member_declarator.
   \author lsg
 */
as_pure_member_declarator::as_pure_member_declarator (ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_declarator > a__as_ordinary_member_declarator__declarator,
                ptr< ::lestes::lang::cplus::lex::cpp_token > a__as_pure_member_declarator__pure_specifier)
        : as_ordinary_member_declarator(a__as_base__location,
                a__as_ordinary_member_declarator__declarator), pure_specifier(checked(a__as_pure_member_declarator__pure_specifier))
{}

ptr< object::reflection_list > as_pure_member_declarator::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( "pure_specifier", "cpp_token" ) );
                reflection = reflection_list::create( as_ordinary_member_declarator::reflection_get() );
                reflection->push_back( class_reflection::create( "as_pure_member_declarator", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_pure_member_declarator::field_values_get() const
{
        ptr < field_list_list > result = as_ordinary_member_declarator::field_values_get();
        result->push_back( value_list::create() );
        result->back()->push_back( this->pure_specifier );
        return result;
}


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

// End of class as_pure_member_declarator.

// ------------- Class as_class_specifier follows. -------------

/*!
   \returns The value of as_class_specifier::key.
   \author lsg
 */
ptr< as_class_key > as_class_specifier::key_get() const
{
        return key;
}

/*!
   \param[in] x The new value to set as_class_specifier::key to.
   \author lsg
 */
void as_class_specifier::key_set(const ptr< as_class_key > & x)
{
        as_class_specifier::key = x;
}

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

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

/*!
   \returns The value of as_class_specifier::base_specifiers.
   \author lsg
 */
ptr< ::lestes::std::list< srp< as_base_specifier > > > as_class_specifier::base_specifiers_get() const
{
        return base_specifiers;
}

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

/*!
   \returns The value of as_class_specifier::member_declarations.
   \author lsg
 */
ptr< ::lestes::std::list< srp< as_member_declaration > > > as_class_specifier::member_declarations_get() const
{
        return member_declarations;
}

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

void as_class_specifier::accept_as_declaration_specifier_visitor( ptr< as_declaration_specifier_visitor > v )
{
        return v->visit_as_class_specifier( this );
}

/*!
   This factory method for class as_class_specifier takes values of all fields as arguments.
   \author lsg
 */
ptr< as_class_specifier > as_class_specifier::create(ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_class_key > a__as_class_specifier__key,
                ptr< as_name > a__as_class_specifier__name,
                ptr< ::lestes::std::list< srp< as_base_specifier > > > a__as_class_specifier__base_specifiers,
                ptr< ::lestes::std::list< srp< as_member_declaration > > > a__as_class_specifier__member_declarations)
{
        return ptr< as_class_specifier > ( new as_class_specifier(a__as_base__location,
                a__as_class_specifier__key,
                a__as_class_specifier__name,
                a__as_class_specifier__base_specifiers,
                a__as_class_specifier__member_declarations) );
}

/*!
   Generated constructor for class as_class_specifier.
   \author lsg
 */
as_class_specifier::as_class_specifier (ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_class_key > a__as_class_specifier__key,
                ptr< as_name > a__as_class_specifier__name,
                ptr< ::lestes::std::list< srp< as_base_specifier > > > a__as_class_specifier__base_specifiers,
                ptr< ::lestes::std::list< srp< as_member_declaration > > > a__as_class_specifier__member_declarations)
        : as_type_specifier(a__as_base__location), key(checked(a__as_class_specifier__key)), name(checked(a__as_class_specifier__name)), base_specifiers(checked(a__as_class_specifier__base_specifiers)), member_declarations(checked(a__as_class_specifier__member_declarations))
{}

ptr< object::reflection_list > as_class_specifier::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( "key", "as_class_key" ) );
                mdl->push_back( md::create( "name", "as_name" ) );
                mdl->push_back( md::create( "base_specifiers", "list&lt; srp&lt; as_base_specifier &gt; &gt;" ) );
                mdl->push_back( md::create( "member_declarations", "list&lt; srp&lt; as_member_declaration &gt; &gt;" ) );
                reflection = reflection_list::create( as_type_specifier::reflection_get() );
                reflection->push_back( class_reflection::create( "as_class_specifier", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_class_specifier::field_values_get() const
{
        ptr < field_list_list > result = as_type_specifier::field_values_get();
        result->push_back( value_list::create() );
        result->back()->push_back( this->key );
        result->push_back( value_list::create() );
        result->back()->push_back( this->name );
        result->push_back( value_list::create() );
        result->back()->push_back( this->base_specifiers );
        result->push_back( value_list::create() );
        result->back()->push_back( this->member_declarations );
        return result;
}


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

// End of class as_class_specifier.

// ------------- Class as_class_forward_member_declaration follows. -------------

/*!
   \returns The value of as_class_forward_member_declaration::key.
   \author lsg
 */
ptr< as_class_key > as_class_forward_member_declaration::key_get() const
{
        return key;
}

/*!
   \param[in] x The new value to set as_class_forward_member_declaration::key to.
   \author lsg
 */
void as_class_forward_member_declaration::key_set(const ptr< as_class_key > & x)
{
        as_class_forward_member_declaration::key = x;
}

/*!
   \returns The value of as_class_forward_member_declaration::identifier.
   \author lsg
 */
ptr< as_identifier > as_class_forward_member_declaration::identifier_get() const
{
        return identifier;
}

/*!
   \param[in] x The new value to set as_class_forward_member_declaration::identifier to.
   \author lsg
 */
void as_class_forward_member_declaration::identifier_set(const ptr< as_identifier > & x)
{
        as_class_forward_member_declaration::identifier = x;
}

/*!
   This factory method for class as_class_forward_member_declaration takes values of all fields as arguments.
   \author lsg
 */
ptr< as_class_forward_member_declaration > as_class_forward_member_declaration::create(ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_access_specifier > a__as_member_declaration__access_specifier,
                ptr< as_class_key > a__as_class_forward_member_declaration__key,
                ptr< as_identifier > a__as_class_forward_member_declaration__identifier)
{
        return ptr< as_class_forward_member_declaration > ( new as_class_forward_member_declaration(a__as_base__location,
                a__as_member_declaration__access_specifier,
                a__as_class_forward_member_declaration__key,
                a__as_class_forward_member_declaration__identifier) );
}

/*!
   Generated constructor for class as_class_forward_member_declaration.
   \author lsg
 */
as_class_forward_member_declaration::as_class_forward_member_declaration (ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_access_specifier > a__as_member_declaration__access_specifier,
                ptr< as_class_key > a__as_class_forward_member_declaration__key,
                ptr< as_identifier > a__as_class_forward_member_declaration__identifier)
        : as_member_declaration(a__as_base__location,
                a__as_member_declaration__access_specifier), key(checked(a__as_class_forward_member_declaration__key)), identifier(checked(a__as_class_forward_member_declaration__identifier))
{}

ptr< object::reflection_list > as_class_forward_member_declaration::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( "key", "as_class_key" ) );
                mdl->push_back( md::create( "identifier", "as_identifier" ) );
                reflection = reflection_list::create( as_member_declaration::reflection_get() );
                reflection->push_back( class_reflection::create( "as_class_forward_member_declaration", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_class_forward_member_declaration::field_values_get() const
{
        ptr < field_list_list > result = as_member_declaration::field_values_get();
        result->push_back( value_list::create() );
        result->back()->push_back( this->key );
        result->push_back( value_list::create() );
        result->back()->push_back( this->identifier );
        return result;
}


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

// End of class as_class_forward_member_declaration.

// ------------- Class as_class_forward_declaration follows. -------------

/*!
   \returns The value of as_class_forward_declaration::key.
   \author lsg
 */
ptr< as_class_key > as_class_forward_declaration::key_get() const
{
        return key;
}

/*!
   \param[in] x The new value to set as_class_forward_declaration::key to.
   \author lsg
 */
void as_class_forward_declaration::key_set(const ptr< as_class_key > & x)
{
        as_class_forward_declaration::key = x;
}

/*!
   \returns The value of as_class_forward_declaration::identifier.
   \author lsg
 */
ptr< as_identifier > as_class_forward_declaration::identifier_get() const
{
        return identifier;
}

/*!
   \param[in] x The new value to set as_class_forward_declaration::identifier to.
   \author lsg
 */
void as_class_forward_declaration::identifier_set(const ptr< as_identifier > & x)
{
        as_class_forward_declaration::identifier = x;
}

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

/*!
   Generated constructor for class as_class_forward_declaration.
   \author lsg
 */
as_class_forward_declaration::as_class_forward_declaration (ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< as_class_key > a__as_class_forward_declaration__key,
                ptr< as_identifier > a__as_class_forward_declaration__identifier)
        : as_block_declaration(a__as_base__location), key(checked(a__as_class_forward_declaration__key)), identifier(checked(a__as_class_forward_declaration__identifier))
{}

ptr< object::reflection_list > as_class_forward_declaration::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( "key", "as_class_key" ) );
                mdl->push_back( md::create( "identifier", "as_identifier" ) );
                reflection = reflection_list::create( as_block_declaration::reflection_get() );
                reflection->push_back( class_reflection::create( "as_class_forward_declaration", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_class_forward_declaration::field_values_get() const
{
        ptr < field_list_list > result = as_block_declaration::field_values_get();
        result->push_back( value_list::create() );
        result->back()->push_back( this->key );
        result->push_back( value_list::create() );
        result->back()->push_back( this->identifier );
        return result;
}


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

// End of class as_class_forward_declaration.


// static data members follow 
ptr<object::reflection_list> as_string_literal::reflection = reflection;
ptr<object::reflection_list> as_declaration::reflection = reflection;
ptr<object::reflection_list> as_block_declaration::reflection = reflection;
ptr<object::reflection_list> as_simple_declaration::reflection = reflection;
ptr<object::reflection_list> as_init_declarator::reflection = reflection;
ptr<object::reflection_list> as_initializer::reflection = reflection;
ptr<object::reflection_list> as_initializer_expression_list::reflection = reflection;
ptr<object::reflection_list> as_initializer_clause::reflection = reflection;
ptr<object::reflection_list> as_initializer_clause_expression::reflection = reflection;
ptr<object::reflection_list> as_initializer_clause_braced::reflection = reflection;
ptr<object::reflection_list> as_function_definition::reflection = reflection;
ptr<object::reflection_list> as_template_declaration::reflection = reflection;
ptr<object::reflection_list> as_template_param::reflection = reflection;
ptr<object::reflection_list> as_template_type_param::reflection = reflection;
ptr<object::reflection_list> as_template_type_param_type::reflection = reflection;
ptr<object::reflection_list> as_template_type_param_template::reflection = reflection;
ptr<object::reflection_list> as_template_nontype_param::reflection = reflection;
ptr<object::reflection_list> as_mem_initializer::reflection = reflection;
ptr<object::reflection_list> as_explicit_instantiation::reflection = reflection;
ptr<object::reflection_list> as_explicit_specialization::reflection = reflection;
ptr<object::reflection_list> as_linkage_specification::reflection = reflection;
ptr<object::reflection_list> as_id::reflection = reflection;
ptr<object::reflection_list> as_template_id::reflection = reflection;
ptr<object::reflection_list> as_identifier::reflection = reflection;
ptr<object::reflection_list> as_destructor_id::reflection = reflection;
ptr<object::reflection_list> as_destructor_id_token::reflection = reflection;
ptr<object::reflection_list> as_destructor_id_template::reflection = reflection;
ptr<object::reflection_list> as_constructor_id::reflection = reflection;
ptr<object::reflection_list> as_op_function_id::reflection = reflection;
ptr<object::reflection_list> as_conv_function_id::reflection = reflection;
ptr<object::reflection_list> as_empty_id::reflection = reflection;
ptr<object::reflection_list> as_global_namespace_fake_id::reflection = reflection;
ptr<object::reflection_list> as_name::reflection = reflection;
ptr<object::reflection_list> as_base_specifier::reflection = reflection;
ptr<object::reflection_list> as_asm_declaration::reflection = reflection;
ptr<object::reflection_list> as_gnu_asm_declaration::reflection = reflection;
ptr<object::reflection_list> as_gnu_asm_specification::reflection = reflection;
ptr<object::reflection_list> as_namespace_alias_declaration::reflection = reflection;
ptr<object::reflection_list> as_namespace_definition::reflection = reflection;
ptr<object::reflection_list> as_using::reflection = reflection;
ptr<object::reflection_list> as_using_declaration::reflection = reflection;
ptr<object::reflection_list> as_using_declaration_with_typename::reflection = reflection;
ptr<object::reflection_list> as_access_declaration::reflection = reflection;
ptr<object::reflection_list> as_using_directive::reflection = reflection;
ptr<object::reflection_list> as_enumerator_definition::reflection = reflection;
ptr<object::reflection_list> as_param_declaration::reflection = reflection;
ptr<object::reflection_list> as_access_specifier::reflection = reflection;
ptr<object::reflection_list> as_access_specifier_public::reflection = reflection;
ptr<object::reflection_list> as_access_specifier_protected::reflection = reflection;
ptr<object::reflection_list> as_access_specifier_private::reflection = reflection;
ptr<object::reflection_list> as_param_decl_clause::reflection = reflection;
ptr<object::reflection_list> as_declaration_specifier::reflection = reflection;
ptr<object::reflection_list> as_function_specifier::reflection = reflection;
ptr<object::reflection_list> as_function_specifier_inline::reflection = reflection;
ptr<object::reflection_list> as_function_specifier_virtual::reflection = reflection;
ptr<object::reflection_list> as_function_specifier_explicit::reflection = reflection;
ptr<object::reflection_list> as_friend_specifier::reflection = reflection;
ptr<object::reflection_list> as_typedef_specifier::reflection = reflection;
ptr<object::reflection_list> as_storage_class_specifier::reflection = reflection;
ptr<object::reflection_list> as_storage_class_specifier_auto::reflection = reflection;
ptr<object::reflection_list> as_storage_class_specifier_register::reflection = reflection;
ptr<object::reflection_list> as_storage_class_specifier_static::reflection = reflection;
ptr<object::reflection_list> as_storage_class_specifier_extern::reflection = reflection;
ptr<object::reflection_list> as_storage_class_specifier_mutable::reflection = reflection;
ptr<object::reflection_list> as_type_specifier::reflection = reflection;
ptr<object::reflection_list> as_enumeration_specifier::reflection = reflection;
ptr<object::reflection_list> as_simple_type_specifier::reflection = reflection;
ptr<object::reflection_list> as_builtin_simple_type_specifier::reflection = reflection;
ptr<object::reflection_list> as_char_simple_type_specifier::reflection = reflection;
ptr<object::reflection_list> as_wchar_t_simple_type_specifier::reflection = reflection;
ptr<object::reflection_list> as_bool_simple_type_specifier::reflection = reflection;
ptr<object::reflection_list> as_short_simple_type_specifier::reflection = reflection;
ptr<object::reflection_list> as_int_simple_type_specifier::reflection = reflection;
ptr<object::reflection_list> as_long_simple_type_specifier::reflection = reflection;
ptr<object::reflection_list> as_signed_simple_type_specifier::reflection = reflection;
ptr<object::reflection_list> as_unsigned_simple_type_specifier::reflection = reflection;
ptr<object::reflection_list> as_float_simple_type_specifier::reflection = reflection;
ptr<object::reflection_list> as_double_simple_type_specifier::reflection = reflection;
ptr<object::reflection_list> as_void_simple_type_specifier::reflection = reflection;
ptr<object::reflection_list> as_cv_qualifier::reflection = reflection;
ptr<object::reflection_list> as_cv_qualifier_const::reflection = reflection;
ptr<object::reflection_list> as_cv_qualifier_volatile::reflection = reflection;
ptr<object::reflection_list> as_cv_qualifier_restrict::reflection = reflection;
ptr<object::reflection_list> as_elaborated_type_specifier::reflection = reflection;
ptr<object::reflection_list> as_named_simple_type_specifier::reflection = reflection;
ptr<object::reflection_list> as_exception_specification::reflection = reflection;
ptr<object::reflection_list> as_elaborated_type_specifier_typename::reflection = reflection;
ptr<object::reflection_list> as_elaborated_type_specifier_tagged::reflection = reflection;
ptr<object::reflection_list> as_elaborated_type_specifier_class_key::reflection = reflection;
ptr<object::reflection_list> as_elaborated_type_specifier_enum::reflection = reflection;
ptr<object::reflection_list> as_template_argument::reflection = reflection;
ptr<object::reflection_list> as_non_type_template_argument::reflection = reflection;
ptr<object::reflection_list> as_type_template_argument::reflection = reflection;
ptr<object::reflection_list> as_declarator::reflection = reflection;
ptr<object::reflection_list> as_dummy_declarator::reflection = reflection;
ptr<object::reflection_list> as_declarator_op::reflection = reflection;
ptr<object::reflection_list> as_declarator_op_ptr::reflection = reflection;
ptr<object::reflection_list> as_ptr_op_star::reflection = reflection;
ptr<object::reflection_list> as_ptr_op_amp::reflection = reflection;
ptr<object::reflection_list> as_ptr_op_member_ptr::reflection = reflection;
ptr<object::reflection_list> as_declarator_op_func::reflection = reflection;
ptr<object::reflection_list> as_declarator_op_array::reflection = reflection;
ptr<object::reflection_list> as_declarator_op_non_constant_array::reflection = reflection;
ptr<object::reflection_list> as_type_id::reflection = reflection;
ptr<object::reflection_list> as_class_key::reflection = reflection;
ptr<object::reflection_list> as_class_key_class::reflection = reflection;
ptr<object::reflection_list> as_class_key_struct::reflection = reflection;
ptr<object::reflection_list> as_class_key_union::reflection = reflection;
ptr<object::reflection_list> as_member_declaration::reflection = reflection;
ptr<object::reflection_list> as_member_using_declaration::reflection = reflection;
ptr<object::reflection_list> as_member_template_declaration::reflection = reflection;
ptr<object::reflection_list> as_member_function_definition::reflection = reflection;
ptr<object::reflection_list> as_member_declaration_ordinary::reflection = reflection;
ptr<object::reflection_list> as_member_declarator::reflection = reflection;
ptr<object::reflection_list> as_bitfield_member_declarator::reflection = reflection;
ptr<object::reflection_list> as_ordinary_member_declarator::reflection = reflection;
ptr<object::reflection_list> as_initialized_member_declarator::reflection = reflection;
ptr<object::reflection_list> as_pure_member_declarator::reflection = reflection;
ptr<object::reflection_list> as_class_specifier::reflection = reflection;
ptr<object::reflection_list> as_class_forward_member_declaration::reflection = reflection;
ptr<object::reflection_list> as_class_forward_declaration::reflection = reflection;

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

---