as_other.g.cc

Go to the documentation of this file.

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

#include <lestes/lang/cplus/sem/as_decl.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/std/list.hh>
#include <lestes/std/pair.hh>
#include <lestes/std/reflect.hh>

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

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


// ------------- Class as_no_token follows. -------------

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

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

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

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

// End of class as_no_token.

// ------------- Class as_statement_seq follows. -------------

/*!
   \returns The value of as_statement_seq::l.
   \author lsg
 */
ptr< ::lestes::std::list< srp< as_statement > > > as_statement_seq::l_get() const
{
        return l;
}

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

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

/*!
   Generated constructor for class as_statement_seq.
   \author lsg
 */
as_statement_seq::as_statement_seq (ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< ::lestes::std::list< srp< as_statement > > > a__as_statement_seq__l)
        : as_base(a__as_base__location), l(checked(a__as_statement_seq__l))
{}

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

ptr< object::field_list_list > as_statement_seq::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->l );
        return result;
}


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

// End of class as_statement_seq.

// ------------- Class as_expression_list follows. -------------

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

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

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

/*!
   Generated constructor for class as_expression_list.
   \author lsg
 */
as_expression_list::as_expression_list (ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< ::lestes::std::list< srp< as_expression > > > a__as_expression_list__l)
        : as_base(a__as_base__location), l(checked(a__as_expression_list__l))
{}

ptr< object::reflection_list > as_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( "l", "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_expression_list", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_expression_list::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->l );
        return result;
}


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

// End of class as_expression_list.

// ------------- Class as_declarator_op_seq follows. -------------

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

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

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

/*!
   Generated constructor for class as_declarator_op_seq.
   \author lsg
 */
as_declarator_op_seq::as_declarator_op_seq (ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< ::lestes::std::list< srp< as_declarator_op > > > a__as_declarator_op_seq__l)
        : as_base(a__as_base__location), l(checked(a__as_declarator_op_seq__l))
{}

ptr< object::reflection_list > as_declarator_op_seq::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( "l", "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_op_seq", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_declarator_op_seq::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->l );
        return result;
}


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

// End of class as_declarator_op_seq.

// ------------- Class as_mem_initializer_list follows. -------------

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

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

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

/*!
   Generated constructor for class as_mem_initializer_list.
   \author lsg
 */
as_mem_initializer_list::as_mem_initializer_list (ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< ::lestes::std::list< srp< as_mem_initializer > > > a__as_mem_initializer_list__l)
        : as_base(a__as_base__location), l(checked(a__as_mem_initializer_list__l))
{}

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

ptr< object::field_list_list > as_mem_initializer_list::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->l );
        return result;
}


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

// End of class as_mem_initializer_list.

// ------------- Class as_cv_qualifier_seq follows. -------------

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

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

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

/*!
   Generated constructor for class as_cv_qualifier_seq.
   \author lsg
 */
as_cv_qualifier_seq::as_cv_qualifier_seq (ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< ::lestes::std::list< srp< as_cv_qualifier > > > a__as_cv_qualifier_seq__l)
        : as_base(a__as_base__location), l(checked(a__as_cv_qualifier_seq__l))
{}

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

ptr< object::field_list_list > as_cv_qualifier_seq::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->l );
        return result;
}


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

// End of class as_cv_qualifier_seq.

// ------------- Class as_enumerator_list follows. -------------

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

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

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

/*!
   Generated constructor for class as_enumerator_list.
   \author lsg
 */
as_enumerator_list::as_enumerator_list (ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< ::lestes::std::list< srp< as_enumerator_definition > > > a__as_enumerator_list__l)
        : as_base(a__as_base__location), l(checked(a__as_enumerator_list__l))
{}

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

ptr< object::field_list_list > as_enumerator_list::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->l );
        return result;
}


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

// End of class as_enumerator_list.

// ------------- Class as_base_specifier_list follows. -------------

/*!
   \returns The value of as_base_specifier_list::l.
   \author lsg
 */
ptr< ::lestes::std::list< srp< as_base_specifier > > > as_base_specifier_list::l_get() const
{
        return l;
}

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

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

/*!
   Generated constructor for class as_base_specifier_list.
   \author lsg
 */
as_base_specifier_list::as_base_specifier_list (ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< ::lestes::std::list< srp< as_base_specifier > > > a__as_base_specifier_list__l)
        : as_base(a__as_base__location), l(checked(a__as_base_specifier_list__l))
{}

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

ptr< object::field_list_list > as_base_specifier_list::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->l );
        return result;
}


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

// End of class as_base_specifier_list.

// ------------- Class as_template_param_list follows. -------------

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

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

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

/*!
   Generated constructor for class as_template_param_list.
   \author lsg
 */
as_template_param_list::as_template_param_list (ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< ::lestes::std::list< srp< as_template_param > > > a__as_template_param_list__l)
        : as_base(a__as_base__location), l(checked(a__as_template_param_list__l))
{}

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

ptr< object::field_list_list > as_template_param_list::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->l );
        return result;
}


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

// End of class as_template_param_list.

// ------------- Class as_init_declarator_list follows. -------------

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

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

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

/*!
   Generated constructor for class as_init_declarator_list.
   \author lsg
 */
as_init_declarator_list::as_init_declarator_list (ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< ::lestes::std::list< srp< as_init_declarator > > > a__as_init_declarator_list__l)
        : as_base(a__as_base__location), l(checked(a__as_init_declarator_list__l))
{}

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

ptr< object::field_list_list > as_init_declarator_list::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->l );
        return result;
}


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

// End of class as_init_declarator_list.

// ------------- Class as_param_declaration_list follows. -------------

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

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

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

/*!
   Generated constructor for class as_param_declaration_list.
   \author lsg
 */
as_param_declaration_list::as_param_declaration_list (ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< ::lestes::std::list< srp< as_param_declaration > > > a__as_param_declaration_list__l)
        : as_base(a__as_base__location), l(checked(a__as_param_declaration_list__l))
{}

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

ptr< object::field_list_list > as_param_declaration_list::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->l );
        return result;
}


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

// End of class as_param_declaration_list.

// ------------- Class as_initializer_list follows. -------------

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

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

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

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

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

ptr< object::field_list_list > as_initializer_list::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->l );
        return result;
}


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

// End of class as_initializer_list.

// ------------- Class as_handler_seq follows. -------------

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

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

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

/*!
   Generated constructor for class as_handler_seq.
   \author lsg
 */
as_handler_seq::as_handler_seq (ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< ::lestes::std::list< srp< as_handler > > > a__as_handler_seq__l)
        : as_base(a__as_base__location), l(checked(a__as_handler_seq__l))
{}

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

ptr< object::field_list_list > as_handler_seq::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->l );
        return result;
}


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

// End of class as_handler_seq.

// ------------- Class as_type_id_list follows. -------------

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

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

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

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

ptr< object::reflection_list > as_type_id_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( "l", "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_type_id_list", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > as_type_id_list::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->l );
        return result;
}


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

// End of class as_type_id_list.

// ------------- Class as_template_argument_list follows. -------------

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

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

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

/*!
   Generated constructor for class as_template_argument_list.
   \author lsg
 */
as_template_argument_list::as_template_argument_list (ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< ::lestes::std::list< srp< as_template_argument > > > a__as_template_argument_list__l)
        : as_base(a__as_base__location), l(checked(a__as_template_argument_list__l))
{}

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

ptr< object::field_list_list > as_template_argument_list::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->l );
        return result;
}


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

// End of class as_template_argument_list.

// ------------- Class as_declaration_seq follows. -------------

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

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

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

/*!
   Generated constructor for class as_declaration_seq.
   \author lsg
 */
as_declaration_seq::as_declaration_seq (ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< ::lestes::std::list< srp< as_declaration > > > a__as_declaration_seq__l)
        : as_base(a__as_base__location), l(checked(a__as_declaration_seq__l))
{}

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

ptr< object::field_list_list > as_declaration_seq::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->l );
        return result;
}


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

// End of class as_declaration_seq.

// ------------- Class as_member_declarator_list follows. -------------

/*!
   \returns The value of as_member_declarator_list::l.
   \author lsg
 */
ptr< ::lestes::std::list< srp< as_member_declarator > > > as_member_declarator_list::l_get() const
{
        return l;
}

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

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

/*!
   Generated constructor for class as_member_declarator_list.
   \author lsg
 */
as_member_declarator_list::as_member_declarator_list (ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< ::lestes::std::list< srp< as_member_declarator > > > a__as_member_declarator_list__l)
        : as_base(a__as_base__location), l(checked(a__as_member_declarator_list__l))
{}

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

ptr< object::field_list_list > as_member_declarator_list::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->l );
        return result;
}


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

// End of class as_member_declarator_list.

// ------------- Class as_declaration_specifier_seq follows. -------------

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

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

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

/*!
   Generated constructor for class as_declaration_specifier_seq.
   \author lsg
 */
as_declaration_specifier_seq::as_declaration_specifier_seq (ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< ::lestes::std::list< srp< as_declaration_specifier > > > a__as_declaration_specifier_seq__l)
        : as_base(a__as_base__location), l(checked(a__as_declaration_specifier_seq__l))
{}

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

ptr< object::field_list_list > as_declaration_specifier_seq::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->l );
        return result;
}


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

// End of class as_declaration_specifier_seq.

// ------------- Class as_type_specifier_seq follows. -------------

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

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

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

/*!
   Generated constructor for class as_type_specifier_seq.
   \author lsg
 */
as_type_specifier_seq::as_type_specifier_seq (ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< ::lestes::std::list< srp< as_type_specifier > > > a__as_type_specifier_seq__l)
        : as_base(a__as_base__location), l(checked(a__as_type_specifier_seq__l))
{}

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

ptr< object::field_list_list > as_type_specifier_seq::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->l );
        return result;
}


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

// End of class as_type_specifier_seq.

// ------------- Class as_member_specification follows. -------------

/*!
   \returns The value of as_member_specification::l.
   \author lsg
 */
ptr< ::lestes::std::list< srp< as_member_declaration > > > as_member_specification::l_get() const
{
        return l;
}

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

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

/*!
   Generated constructor for class as_member_specification.
   \author lsg
 */
as_member_specification::as_member_specification (ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< ::lestes::std::list< srp< as_member_declaration > > > a__as_member_specification__l)
        : as_base(a__as_base__location), l(checked(a__as_member_specification__l))
{}

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

ptr< object::field_list_list > as_member_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->l );
        return result;
}


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

// End of class as_member_specification.

// ------------- Class as_anyid_opt_bearer follows. -------------

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

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

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

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

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

ptr< object::field_list_list > as_anyid_opt_bearer::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->value );
        return result;
}


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

// End of class as_anyid_opt_bearer.

// ------------- Class as_excptn_spec_opt_bearer follows. -------------

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

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

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

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

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

ptr< object::field_list_list > as_excptn_spec_opt_bearer::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->value );
        return result;
}


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

// End of class as_excptn_spec_opt_bearer.

// ------------- Class as_virtual_opt_bearer follows. -------------

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

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

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

/*!
   Generated constructor for class as_virtual_opt_bearer.
   \author lsg
 */
as_virtual_opt_bearer::as_virtual_opt_bearer (ptr< ::lestes::std::source_location > a__as_base__location,
                ptr< ::lestes::lang::cplus::lex::cpp_token > a__as_virtual_opt_bearer__value)
        : as_base(a__as_base__location), value(a__as_virtual_opt_bearer__value)
{}

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

ptr< object::field_list_list > as_virtual_opt_bearer::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->value );
        return result;
}


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

// End of class as_virtual_opt_bearer.

// ------------- Class as_access_spec_opt_bearer follows. -------------

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

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

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

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

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

ptr< object::field_list_list > as_access_spec_opt_bearer::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->value );
        return result;
}


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

// End of class as_access_spec_opt_bearer.


// static data members follow 
ptr<object::reflection_list> as_no_token::reflection = reflection;
ptr<object::reflection_list> as_statement_seq::reflection = reflection;
ptr<object::reflection_list> as_expression_list::reflection = reflection;
ptr<object::reflection_list> as_declarator_op_seq::reflection = reflection;
ptr<object::reflection_list> as_mem_initializer_list::reflection = reflection;
ptr<object::reflection_list> as_cv_qualifier_seq::reflection = reflection;
ptr<object::reflection_list> as_enumerator_list::reflection = reflection;
ptr<object::reflection_list> as_base_specifier_list::reflection = reflection;
ptr<object::reflection_list> as_template_param_list::reflection = reflection;
ptr<object::reflection_list> as_init_declarator_list::reflection = reflection;
ptr<object::reflection_list> as_param_declaration_list::reflection = reflection;
ptr<object::reflection_list> as_initializer_list::reflection = reflection;
ptr<object::reflection_list> as_handler_seq::reflection = reflection;
ptr<object::reflection_list> as_type_id_list::reflection = reflection;
ptr<object::reflection_list> as_template_argument_list::reflection = reflection;
ptr<object::reflection_list> as_declaration_seq::reflection = reflection;
ptr<object::reflection_list> as_member_declarator_list::reflection = reflection;
ptr<object::reflection_list> as_declaration_specifier_seq::reflection = reflection;
ptr<object::reflection_list> as_type_specifier_seq::reflection = reflection;
ptr<object::reflection_list> as_member_specification::reflection = reflection;
ptr<object::reflection_list> as_anyid_opt_bearer::reflection = reflection;
ptr<object::reflection_list> as_excptn_spec_opt_bearer::reflection = reflection;
ptr<object::reflection_list> as_virtual_opt_bearer::reflection = reflection;
ptr<object::reflection_list> as_access_spec_opt_bearer::reflection = reflection;

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

---