ss_type.g.cc

Go to the documentation of this file.

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

/*!
        \file
        \brief Intercode structure for project Lestes
        
                        This file describes a set of classes and data types used for intercode layer -ss-.
                        It is an output from a XSLT template which generates C++ code.
                
*/

#include <lestes/lang/cplus/sem/as_decl.g.hh>
#include <lestes/lang/cplus/sem/ss_declaration.g.hh>
#include <lestes/lang/cplus/sem/ss_type_visitor.v.g.hh>
#include <lestes/lang/cplus/sem/or_visitor.v.g.hh>
#include <lestes/lang/cplus/sem/ss_declaration_visitor.v.g.hh>
#include <lestes/lang/cplus/sem/ss_decl_name_visitor.v.g.hh>
#include <lestes/lang/cplus/sem/ss_misc.g.hh>
#include <lestes/md/types/tm_data_type_base.g.hh>
#include <lestes/lang/cplus/lex/location.hh>
#include <lestes/lang/cplus/sem/ss_expression.g.hh>
#include <lestes/lang/cplus/sem/ss_type.hh>

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

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

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


// ------------- Class ss_type follows. -------------

/*!
   Generated constructor for class ss_type.
   \author lsg
 */
ss_type::ss_type ()
        : ss_base()
{}

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

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


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

// End of class ss_type.

// ------------- Class ss_builtin_type follows. -------------

/*!
   Generated constructor for class ss_builtin_type.
   \author lsg
 */
ss_builtin_type::ss_builtin_type ()
        : ss_type()
{}

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

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


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

// End of class ss_builtin_type.

// ------------- Class ss_const follows. -------------

/*!
   \returns The value of ss_const::what.
   \author lsg
 */
ptr< ss_type > ss_const::what_get() const
{
        return what;
}

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

ptr< ::lestes::std::list< srp< or_ics_functional > > > ss_const::accept_or_ics_base( ptr< or_ics_base > v )
{
        return v->visit_ss_const( this );
}

or_cv_enum ss_const::accept_or_ics_base_cv( ptr< or_ics_base_cv > v )
{
        return v->visit_ss_const( this );
}

ptr< ::lestes::md::types::tm_data_type_base > ss_const::accept_ss_type2tm_type_gen_base( ptr< ss_type2tm_type_gen_base > v )
{
        return v->visit_ss_const( this );
}

void ss_const::accept_ss_type_visitor( ptr< ss_type_visitor > v )
{
        return v->visit_ss_const( this );
}

/*!
   This factory method for class ss_const takes values of all fields as arguments.
   \author lsg
 */
ptr< ss_const > ss_const::create(ptr< ss_type > a__ss_const__what)
{
        return ptr< ss_const > ( new ss_const(a__ss_const__what) );
}

/*!
   Generated constructor for class ss_const.
   \author lsg
 */
ss_const::ss_const (ptr< ss_type > a__ss_const__what)
        : ss_type(), what(checked(a__ss_const__what))
{}

ptr< object::reflection_list > ss_const::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( "what", "ss_type" ) );
                mdl->push_back( md::create( "the_instances", "map&lt; srp&lt; ss_type &gt;, srp&lt; ss_type &gt; &gt;" ) );
                reflection = reflection_list::create( ss_type::reflection_get() );
                reflection->push_back( class_reflection::create( "ss_const", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > ss_const::field_values_get() const
{
        ptr < field_list_list > result = ss_type::field_values_get();
        result->push_back( value_list::create() );
        result->back()->push_back( this->what );
        result->push_back( value_list::create() );
        result->back()->push_back( this->the_instances );
        return result;
}


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

// End of class ss_const.

// ------------- Class ss_volatile follows. -------------

/*!
   \returns The value of ss_volatile::what.
   \author lsg
 */
ptr< ss_type > ss_volatile::what_get() const
{
        return what;
}

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

ptr< ::lestes::std::list< srp< or_ics_functional > > > ss_volatile::accept_or_ics_base( ptr< or_ics_base > v )
{
        return v->visit_ss_volatile( this );
}

or_cv_enum ss_volatile::accept_or_ics_base_cv( ptr< or_ics_base_cv > v )
{
        return v->visit_ss_volatile( this );
}

ptr< ::lestes::md::types::tm_data_type_base > ss_volatile::accept_ss_type2tm_type_gen_base( ptr< ss_type2tm_type_gen_base > v )
{
        return v->visit_ss_volatile( this );
}

void ss_volatile::accept_ss_type_visitor( ptr< ss_type_visitor > v )
{
        return v->visit_ss_volatile( this );
}

/*!
   This factory method for class ss_volatile takes values of all fields as arguments.
   \author lsg
 */
ptr< ss_volatile > ss_volatile::create(ptr< ss_type > a__ss_volatile__what)
{
        return ptr< ss_volatile > ( new ss_volatile(a__ss_volatile__what) );
}

/*!
   Generated constructor for class ss_volatile.
   \author lsg
 */
ss_volatile::ss_volatile (ptr< ss_type > a__ss_volatile__what)
        : ss_type(), what(checked(a__ss_volatile__what))
{}

ptr< object::reflection_list > ss_volatile::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( "what", "ss_type" ) );
                mdl->push_back( md::create( "the_instances", "map&lt; srp&lt; ss_type &gt;, srp&lt; ss_type &gt; &gt;" ) );
                reflection = reflection_list::create( ss_type::reflection_get() );
                reflection->push_back( class_reflection::create( "ss_volatile", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > ss_volatile::field_values_get() const
{
        ptr < field_list_list > result = ss_type::field_values_get();
        result->push_back( value_list::create() );
        result->back()->push_back( this->what );
        result->push_back( value_list::create() );
        result->back()->push_back( this->the_instances );
        return result;
}


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

// End of class ss_volatile.

// ------------- Class ss_const_volatile follows. -------------

/*!
   \returns The value of ss_const_volatile::what.
   \author lsg
 */
ptr< ss_type > ss_const_volatile::what_get() const
{
        return what;
}

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

ptr< ::lestes::std::list< srp< or_ics_functional > > > ss_const_volatile::accept_or_ics_base( ptr< or_ics_base > v )
{
        return v->visit_ss_const_volatile( this );
}

or_cv_enum ss_const_volatile::accept_or_ics_base_cv( ptr< or_ics_base_cv > v )
{
        return v->visit_ss_const_volatile( this );
}

ptr< ::lestes::md::types::tm_data_type_base > ss_const_volatile::accept_ss_type2tm_type_gen_base( ptr< ss_type2tm_type_gen_base > v )
{
        return v->visit_ss_const_volatile( this );
}

void ss_const_volatile::accept_ss_type_visitor( ptr< ss_type_visitor > v )
{
        return v->visit_ss_const_volatile( this );
}

/*!
   This factory method for class ss_const_volatile takes values of all fields as arguments.
   \author lsg
 */
ptr< ss_const_volatile > ss_const_volatile::create(ptr< ss_type > a__ss_const_volatile__what)
{
        return ptr< ss_const_volatile > ( new ss_const_volatile(a__ss_const_volatile__what) );
}

/*!
   Generated constructor for class ss_const_volatile.
   \author lsg
 */
ss_const_volatile::ss_const_volatile (ptr< ss_type > a__ss_const_volatile__what)
        : ss_type(), what(checked(a__ss_const_volatile__what))
{}

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

ptr< object::field_list_list > ss_const_volatile::field_values_get() const
{
        ptr < field_list_list > result = ss_type::field_values_get();
        result->push_back( value_list::create() );
        result->back()->push_back( this->what );
        return result;
}


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

// End of class ss_const_volatile.

// ------------- Class ss_referential follows. -------------

/*!
   \returns The value of ss_referential::what.
   \author lsg
 */
ptr< ss_type > ss_referential::what_get() const
{
        return what;
}

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

/*!
   Generated constructor for class ss_referential.
   \author lsg
 */
ss_referential::ss_referential (ptr< ss_type > a__ss_referential__what)
        : ss_type(), what(checked(a__ss_referential__what))
{}

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

ptr< object::field_list_list > ss_referential::field_values_get() const
{
        ptr < field_list_list > result = ss_type::field_values_get();
        result->push_back( value_list::create() );
        result->back()->push_back( this->what );
        return result;
}


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

// End of class ss_referential.

// ------------- Class ss_reference follows. -------------

ptr< ::lestes::std::list< srp< or_ics_functional > > > ss_reference::accept_or_ics_base( ptr< or_ics_base > v )
{
        return v->visit_ss_reference( this );
}

or_cv_enum ss_reference::accept_or_ics_base_cv( ptr< or_ics_base_cv > v )
{
        return v->visit_ss_reference( this );
}

ptr< ::lestes::md::types::tm_data_type_base > ss_reference::accept_ss_type2tm_type_gen_base( ptr< ss_type2tm_type_gen_base > v )
{
        return v->visit_ss_reference( this );
}

void ss_reference::accept_ss_type_visitor( ptr< ss_type_visitor > v )
{
        return v->visit_ss_reference( this );
}

/*!
   This factory method for class ss_reference takes values of all fields as arguments.
   \author lsg
 */
ptr< ss_reference > ss_reference::create(ptr< ss_type > a__ss_referential__what)
{
        return ptr< ss_reference > ( new ss_reference(a__ss_referential__what) );
}

/*!
   Generated constructor for class ss_reference.
   \author lsg
 */
ss_reference::ss_reference (ptr< ss_type > a__ss_referential__what)
        : ss_referential(a__ss_referential__what)
{}

ptr< object::reflection_list > ss_reference::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( "the_instances", "map&lt; srp&lt; ss_type &gt;, srp&lt; ss_type &gt; &gt;" ) );
                reflection = reflection_list::create( ss_referential::reflection_get() );
                reflection->push_back( class_reflection::create( "ss_reference", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > ss_reference::field_values_get() const
{
        ptr < field_list_list > result = ss_referential::field_values_get();
        result->push_back( value_list::create() );
        result->back()->push_back( this->the_instances );
        return result;
}


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

// End of class ss_reference.

// ------------- Class ss_pseudoreference follows. -------------

ptr< ::lestes::std::list< srp< or_ics_functional > > > ss_pseudoreference::accept_or_ics_base( ptr< or_ics_base > v )
{
        return v->visit_ss_pseudoreference( this );
}

or_cv_enum ss_pseudoreference::accept_or_ics_base_cv( ptr< or_ics_base_cv > v )
{
        return v->visit_ss_pseudoreference( this );
}

ptr< ::lestes::md::types::tm_data_type_base > ss_pseudoreference::accept_ss_type2tm_type_gen_base( ptr< ss_type2tm_type_gen_base > v )
{
        return v->visit_ss_pseudoreference( this );
}

void ss_pseudoreference::accept_ss_type_visitor( ptr< ss_type_visitor > v )
{
        return v->visit_ss_pseudoreference( this );
}

/*!
   This factory method for class ss_pseudoreference takes values of all fields as arguments.
   \author lsg
 */
ptr< ss_pseudoreference > ss_pseudoreference::create(ptr< ss_type > a__ss_referential__what)
{
        return ptr< ss_pseudoreference > ( new ss_pseudoreference(a__ss_referential__what) );
}

/*!
   Generated constructor for class ss_pseudoreference.
   \author lsg
 */
ss_pseudoreference::ss_pseudoreference (ptr< ss_type > a__ss_referential__what)
        : ss_referential(a__ss_referential__what)
{}

ptr< object::reflection_list > ss_pseudoreference::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( "the_instances", "map&lt; srp&lt; ss_type &gt;, srp&lt; ss_type &gt; &gt;" ) );
                reflection = reflection_list::create( ss_referential::reflection_get() );
                reflection->push_back( class_reflection::create( "ss_pseudoreference", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > ss_pseudoreference::field_values_get() const
{
        ptr < field_list_list > result = ss_referential::field_values_get();
        result->push_back( value_list::create() );
        result->back()->push_back( this->the_instances );
        return result;
}


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

// End of class ss_pseudoreference.

// ------------- Class ss_pointer follows. -------------

/*!
   \returns The value of ss_pointer::what.
   \author lsg
 */
ptr< ss_type > ss_pointer::what_get() const
{
        return what;
}

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

ptr< ::lestes::std::list< srp< or_ics_functional > > > ss_pointer::accept_or_ics_base( ptr< or_ics_base > v )
{
        return v->visit_ss_pointer( this );
}

or_cv_enum ss_pointer::accept_or_ics_base_cv( ptr< or_ics_base_cv > v )
{
        return v->visit_ss_pointer( this );
}

ptr< ::lestes::md::types::tm_data_type_base > ss_pointer::accept_ss_type2tm_type_gen_base( ptr< ss_type2tm_type_gen_base > v )
{
        return v->visit_ss_pointer( this );
}

void ss_pointer::accept_ss_type_visitor( ptr< ss_type_visitor > v )
{
        return v->visit_ss_pointer( this );
}

/*!
   This factory method for class ss_pointer takes values of all fields as arguments.
   \author lsg
 */
ptr< ss_pointer > ss_pointer::create(ptr< ss_type > a__ss_pointer__what)
{
        return ptr< ss_pointer > ( new ss_pointer(a__ss_pointer__what) );
}

/*!
   Generated constructor for class ss_pointer.
   \author lsg
 */
ss_pointer::ss_pointer (ptr< ss_type > a__ss_pointer__what)
        : ss_type(), what(checked(a__ss_pointer__what))
{}

ptr< object::reflection_list > ss_pointer::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( "what", "ss_type" ) );
                mdl->push_back( md::create( "the_instances", "map&lt; srp&lt; ss_type &gt;, srp&lt; ss_type &gt; &gt;" ) );
                reflection = reflection_list::create( ss_type::reflection_get() );
                reflection->push_back( class_reflection::create( "ss_pointer", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > ss_pointer::field_values_get() const
{
        ptr < field_list_list > result = ss_type::field_values_get();
        result->push_back( value_list::create() );
        result->back()->push_back( this->what );
        result->push_back( value_list::create() );
        result->back()->push_back( this->the_instances );
        return result;
}


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

// End of class ss_pointer.

// ------------- Class ss_enum follows. -------------

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

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

ptr< ::lestes::std::list< srp< or_ics_functional > > > ss_enum::accept_or_ics_base( ptr< or_ics_base > v )
{
        return v->visit_ss_enum( this );
}

or_cv_enum ss_enum::accept_or_ics_base_cv( ptr< or_ics_base_cv > v )
{
        return v->visit_ss_enum( this );
}

ptr< ::lestes::md::types::tm_data_type_base > ss_enum::accept_ss_type2tm_type_gen_base( ptr< ss_type2tm_type_gen_base > v )
{
        return v->visit_ss_enum( this );
}

void ss_enum::accept_ss_type_visitor( ptr< ss_type_visitor > v )
{
        return v->visit_ss_enum( this );
}

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

/*!
   Generated constructor for class ss_enum.
   \author lsg
 */
ss_enum::ss_enum (ptr< ::lestes::std::list< srp< ss_declaration > > > a__ss_enum__enumerators)
        : ss_type(), enumerators(checked(a__ss_enum__enumerators))
{}

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

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


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

// End of class ss_enum.

// ------------- Class ss_array follows. -------------

/*!
   \returns The value of ss_array::bound.
   \author lsg
 */
t_size ss_array::bound_get() const
{
        return bound;
}

/*!
   \param[in] x The new value to set ss_array::bound to.
   \author lsg
 */
void ss_array::bound_set(t_size x)
{
        ss_array::bound = x;
}

/*!
   \returns The value of ss_array::type.
   \author lsg
 */
ptr< ss_type > ss_array::type_get() const
{
        return type;
}

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

ptr< ::lestes::std::list< srp< or_ics_functional > > > ss_array::accept_or_ics_base( ptr< or_ics_base > v )
{
        return v->visit_ss_array( this );
}

or_cv_enum ss_array::accept_or_ics_base_cv( ptr< or_ics_base_cv > v )
{
        return v->visit_ss_array( this );
}

ptr< ::lestes::md::types::tm_data_type_base > ss_array::accept_ss_type2tm_type_gen_base( ptr< ss_type2tm_type_gen_base > v )
{
        return v->visit_ss_array( this );
}

void ss_array::accept_ss_type_visitor( ptr< ss_type_visitor > v )
{
        return v->visit_ss_array( this );
}

/*!
   This factory method for class ss_array takes values of all fields as arguments.
   \author lsg
 */
ptr< ss_array > ss_array::create(t_size a__ss_array__bound,
                ptr< ss_type > a__ss_array__type)
{
        return ptr< ss_array > ( new ss_array(a__ss_array__bound,
                a__ss_array__type) );
}

/*!
   Generated constructor for class ss_array.
   \author lsg
 */
ss_array::ss_array (t_size a__ss_array__bound,
                ptr< ss_type > a__ss_array__type)
        : ss_type(), bound(a__ss_array__bound), type(checked(a__ss_array__type))
{}

ptr< object::reflection_list > ss_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( "bound", "t_size" ) );
                mdl->push_back( md::create( "type", "ss_type" ) );
                mdl->push_back( md::create( "the_instances", "map&lt; srp &lt; ::lestes::std::pair &lt; t_size, srp &lt; ss_type &gt; &gt; &gt;, srp&lt; ss_type &gt;, ::lestes::std::pair_comparator &lt; srp &lt; ::lestes::std::pair &lt; t_size, srp &lt; ss_type &gt; &gt; &gt; &gt; &gt;" ) );
                reflection = reflection_list::create( ss_type::reflection_get() );
                reflection->push_back( class_reflection::create( "ss_array", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > ss_array::field_values_get() const
{
        ptr < field_list_list > result = ss_type::field_values_get();
        result->push_back( value_list::create() );
        result->back()->push_back( objectize< t_size > ::create( this->bound ) );
        result->push_back( value_list::create() );
        result->back()->push_back( this->type );
        result->push_back( value_list::create() );
        result->back()->push_back( this->the_instances );
        return result;
}


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

// End of class ss_array.

// ------------- Class ss_member_pointer follows. -------------

/*!
   \returns The value of ss_member_pointer::base.
   \author lsg
 */
ptr< ss_type > ss_member_pointer::base_get() const
{
        return base;
}

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

/*!
   \returns The value of ss_member_pointer::item.
   \author lsg
 */
ptr< ss_type > ss_member_pointer::item_get() const
{
        return item;
}

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

ptr< ::lestes::std::list< srp< or_ics_functional > > > ss_member_pointer::accept_or_ics_base( ptr< or_ics_base > v )
{
        return v->visit_ss_member_pointer( this );
}

or_cv_enum ss_member_pointer::accept_or_ics_base_cv( ptr< or_ics_base_cv > v )
{
        return v->visit_ss_member_pointer( this );
}

ptr< ::lestes::md::types::tm_data_type_base > ss_member_pointer::accept_ss_type2tm_type_gen_base( ptr< ss_type2tm_type_gen_base > v )
{
        return v->visit_ss_member_pointer( this );
}

void ss_member_pointer::accept_ss_type_visitor( ptr< ss_type_visitor > v )
{
        return v->visit_ss_member_pointer( this );
}

/*!
   This factory method for class ss_member_pointer takes values of all fields as arguments.
   \author lsg
 */
ptr< ss_member_pointer > ss_member_pointer::create(ptr< ss_type > a__ss_member_pointer__base,
                ptr< ss_type > a__ss_member_pointer__item)
{
        return ptr< ss_member_pointer > ( new ss_member_pointer(a__ss_member_pointer__base,
                a__ss_member_pointer__item) );
}

/*!
   Generated constructor for class ss_member_pointer.
   \author lsg
 */
ss_member_pointer::ss_member_pointer (ptr< ss_type > a__ss_member_pointer__base,
                ptr< ss_type > a__ss_member_pointer__item)
        : ss_type(), base(checked(a__ss_member_pointer__base)), item(checked(a__ss_member_pointer__item))
{}

ptr< object::reflection_list > ss_member_pointer::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( "base", "ss_type" ) );
                mdl->push_back( md::create( "item", "ss_type" ) );
                mdl->push_back( md::create( "the_instances", "map&lt; srp &lt; ::lestes::std::pair &lt; srp &lt; ss_type &gt;, srp &lt; ss_type &gt; &gt; &gt;, srp&lt; ss_type &gt;, ::lestes::std::pair_comparator &lt; srp &lt; ::lestes::std::pair &lt; srp &lt; ss_type &gt;, srp &lt; ss_type &gt; &gt; &gt; &gt; &gt;" ) );
                reflection = reflection_list::create( ss_type::reflection_get() );
                reflection->push_back( class_reflection::create( "ss_member_pointer", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > ss_member_pointer::field_values_get() const
{
        ptr < field_list_list > result = ss_type::field_values_get();
        result->push_back( value_list::create() );
        result->back()->push_back( this->base );
        result->push_back( value_list::create() );
        result->back()->push_back( this->item );
        result->push_back( value_list::create() );
        result->back()->push_back( this->the_instances );
        return result;
}


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

// End of class ss_member_pointer.

// ------------- Class ss_function follows. -------------

/*!
   \returns The value of ss_function::returns.
   \author lsg
 */
ptr< ss_type > ss_function::returns_get() const
{
        return returns;
}

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

/*!
   \returns The value of ss_function::params.
   \author lsg
 */
ptr< ::lestes::std::list< srp< ss_type > > > ss_function::params_get() const
{
        return params;
}

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

/*!
   \returns The value of ss_function::ellipsis.
   \author lsg
 */
bool ss_function::ellipsis_get() const
{
        return ellipsis;
}

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

ptr< ::lestes::std::list< srp< or_ics_functional > > > ss_function::accept_or_ics_base( ptr< or_ics_base > v )
{
        return v->visit_ss_function( this );
}

or_cv_enum ss_function::accept_or_ics_base_cv( ptr< or_ics_base_cv > v )
{
        return v->visit_ss_function( this );
}

ptr< ::lestes::md::types::tm_data_type_base > ss_function::accept_ss_type2tm_type_gen_base( ptr< ss_type2tm_type_gen_base > v )
{
        return v->visit_ss_function( this );
}

void ss_function::accept_ss_type_visitor( ptr< ss_type_visitor > v )
{
        return v->visit_ss_function( this );
}

/*!
   This factory method for class ss_function takes values of all fields as arguments.
   \author lsg
 */
ptr< ss_function > ss_function::create(ptr< ss_type > a__ss_function__returns,
                ptr< ::lestes::std::list< srp< ss_type > > > a__ss_function__params,
                bool a__ss_function__ellipsis)
{
        return ptr< ss_function > ( new ss_function(a__ss_function__returns,
                a__ss_function__params,
                a__ss_function__ellipsis) );
}

/*!
   Generated constructor for class ss_function.
   \author lsg
 */
ss_function::ss_function (ptr< ss_type > a__ss_function__returns,
                ptr< ::lestes::std::list< srp< ss_type > > > a__ss_function__params,
                bool a__ss_function__ellipsis)
        : ss_type(), returns(checked(a__ss_function__returns)), params(checked(a__ss_function__params)), ellipsis(a__ss_function__ellipsis)
{}

ptr< object::reflection_list > ss_function::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( "instances", "set&lt; srp&lt; ss_function &gt;, ss_function_comparator &gt;" ) );
                mdl->push_back( md::create( "returns", "ss_type" ) );
                mdl->push_back( md::create( "params", "list&lt; srp&lt; ss_type &gt; &gt;" ) );
                mdl->push_back( md::create( "ellipsis", "bool" ) );
                reflection = reflection_list::create( ss_type::reflection_get() );
                reflection->push_back( class_reflection::create( "ss_function", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > ss_function::field_values_get() const
{
        ptr < field_list_list > result = ss_type::field_values_get();
        result->push_back( value_list::create() );
        result->back()->push_back( this->instances );
        result->push_back( value_list::create() );
        result->back()->push_back( this->returns );
        result->push_back( value_list::create() );
        result->back()->push_back( this->params );
        result->push_back( value_list::create() );
        result->back()->push_back( objectize< bool > ::create( this->ellipsis ) );
        return result;
}


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

// End of class ss_function.

// ------------- Class ss_member_function follows. -------------

/*!
   \returns The value of ss_member_function::this_type.
   \author lsg
 */
ptr< ss_type > ss_member_function::this_type_get() const
{
        return this_type;
}

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

ptr< ::lestes::std::list< srp< or_ics_functional > > > ss_member_function::accept_or_ics_base( ptr< or_ics_base > v )
{
        return v->visit_ss_member_function( this );
}

or_cv_enum ss_member_function::accept_or_ics_base_cv( ptr< or_ics_base_cv > v )
{
        return v->visit_ss_member_function( this );
}

ptr< ::lestes::md::types::tm_data_type_base > ss_member_function::accept_ss_type2tm_type_gen_base( ptr< ss_type2tm_type_gen_base > v )
{
        return v->visit_ss_member_function( this );
}

void ss_member_function::accept_ss_type_visitor( ptr< ss_type_visitor > v )
{
        return v->visit_ss_member_function( this );
}

/*!
   This factory method for class ss_member_function takes values of all fields as arguments.
   \author lsg
 */
ptr< ss_member_function > ss_member_function::create(ptr< ss_type > a__ss_function__returns,
                ptr< ::lestes::std::list< srp< ss_type > > > a__ss_function__params,
                bool a__ss_function__ellipsis,
                ptr< ss_type > a__ss_member_function__this_type)
{
        return ptr< ss_member_function > ( new ss_member_function(a__ss_function__returns,
                a__ss_function__params,
                a__ss_function__ellipsis,
                a__ss_member_function__this_type) );
}

/*!
   Generated constructor for class ss_member_function.
   \author lsg
 */
ss_member_function::ss_member_function (ptr< ss_type > a__ss_function__returns,
                ptr< ::lestes::std::list< srp< ss_type > > > a__ss_function__params,
                bool a__ss_function__ellipsis,
                ptr< ss_type > a__ss_member_function__this_type)
        : ss_function(a__ss_function__returns,
                a__ss_function__params,
                a__ss_function__ellipsis), this_type(checked(a__ss_member_function__this_type))
{}

ptr< object::reflection_list > ss_member_function::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( "this_type", "ss_type" ) );
                reflection = reflection_list::create( ss_function::reflection_get() );
                reflection->push_back( class_reflection::create( "ss_member_function", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > ss_member_function::field_values_get() const
{
        ptr < field_list_list > result = ss_function::field_values_get();
        result->push_back( value_list::create() );
        result->back()->push_back( this->this_type );
        return result;
}


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

// End of class ss_member_function.

// ------------- Class ss_struct_base follows. -------------

/*!
   \returns The value of ss_struct_base::members.
   \author lsg
 */
ptr< ss_decl_seq > ss_struct_base::members_get() const
{
        return members;
}

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

/*!
   \returns The value of ss_struct_base::decl.
   \author lsg
 */
ptr< ss_declaration > ss_struct_base::decl_get() const
{
        return decl;
}

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

/*!
   \returns The value of ss_struct_base::POD.
   \author lsg
 */
bool ss_struct_base::POD_get() const
{
        return POD;
}

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

/*!
   \returns The value of ss_struct_base::completion_time.
   \author lsg
 */
ptr< ss_declaration_time > ss_struct_base::completion_time_get() const
{
        return completion_time;
}

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

/*!
   Generated constructor for class ss_struct_base.
   \author lsg
 */
ss_struct_base::ss_struct_base (ptr< ss_decl_seq > a__ss_struct_base__members,
                ptr< ss_declaration > a__ss_struct_base__decl,
                bool a__ss_struct_base__POD,
                ptr< ss_declaration_time > a__ss_struct_base__completion_time)
        : ss_type(), members(checked(a__ss_struct_base__members)), decl(checked(a__ss_struct_base__decl)), POD(a__ss_struct_base__POD), completion_time(checked(a__ss_struct_base__completion_time))
{}

ptr< object::reflection_list > ss_struct_base::reflection_get() const
{
        if (!reflection) {
                typedef class_reflection::field_metadata md;
                typedef class_reflection::field_metadata_list mdlist;
                ptr<mdlist> mdl = mdlist::create();
                mdl->push_back( md::create( "members", "ss_decl_seq" ) );
                mdl->push_back( md::create( "decl", "ss_declaration" ) );
                mdl->push_back( md::create( "POD", "bool" ) );
                mdl->push_back( md::create( "completion_time", "ss_declaration_time" ) );
                reflection = reflection_list::create( ss_type::reflection_get() );
                reflection->push_back( class_reflection::create( "ss_struct_base", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > ss_struct_base::field_values_get() const
{
        ptr < field_list_list > result = ss_type::field_values_get();
        result->push_back( value_list::create() );
        result->back()->push_back( this->members );
        result->push_back( value_list::create() );
        result->back()->push_back( this->decl );
        result->push_back( value_list::create() );
        result->back()->push_back( objectize< bool > ::create( this->POD ) );
        result->push_back( value_list::create() );
        result->back()->push_back( this->completion_time );
        return result;
}


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

// End of class ss_struct_base.

// ------------- Class ss_class follows. -------------

/*!
   \returns The value of ss_class::bases.
   \author lsg
 */
ptr< ::lestes::std::list< srp< ss_base_specifier > > > ss_class::bases_get() const
{
        return bases;
}

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

/*!
   \returns The value of ss_class::descendants.
   \author lsg
 */
ptr< ::lestes::std::set< srp< ss_class > > > ss_class::descendants_get() const
{
        return descendants;
}

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

ptr< ::lestes::std::list< srp< or_ics_functional > > > ss_class::accept_or_ics_base( ptr< or_ics_base > v )
{
        return v->visit_ss_class( this );
}

or_cv_enum ss_class::accept_or_ics_base_cv( ptr< or_ics_base_cv > v )
{
        return v->visit_ss_class( this );
}

ptr< ::lestes::md::types::tm_data_type_base > ss_class::accept_ss_type2tm_type_gen_base( ptr< ss_type2tm_type_gen_base > v )
{
        return v->visit_ss_class( this );
}

void ss_class::accept_ss_type_visitor( ptr< ss_type_visitor > v )
{
        return v->visit_ss_class( this );
}

/*!
   This factory method for class ss_class takes values of all fields as arguments.
   \author lsg
 */
ptr< ss_class > ss_class::create(ptr< ss_decl_seq > a__ss_struct_base__members,
                ptr< ss_declaration > a__ss_struct_base__decl,
                bool a__ss_struct_base__POD,
                ptr< ss_declaration_time > a__ss_struct_base__completion_time,
                ptr< ::lestes::std::list< srp< ss_base_specifier > > > a__ss_class__bases,
                ptr< ::lestes::std::set< srp< ss_class > > > a__ss_class__descendants)
{
        return ptr< ss_class > ( new ss_class(a__ss_struct_base__members,
                a__ss_struct_base__decl,
                a__ss_struct_base__POD,
                a__ss_struct_base__completion_time,
                a__ss_class__bases,
                a__ss_class__descendants) );
}

/*!
   This factory method for class ss_class uses initializers.
   \author lsg
 */
ptr< ss_class > ss_class::create(ptr< ss_decl_seq > a__ss_struct_base__members,
                ptr< ss_declaration > a__ss_struct_base__decl,
                bool a__ss_struct_base__POD,
                ptr< ss_declaration_time > a__ss_struct_base__completion_time,
                ptr< ::lestes::std::list< srp< ss_base_specifier > > > a__ss_class__bases)
{
        return ptr< ss_class > ( new ss_class(a__ss_struct_base__members, a__ss_struct_base__decl, a__ss_struct_base__POD, a__ss_struct_base__completion_time, a__ss_class__bases, ::lestes::std::set< srp< ss_class > > ::create()) );
}

/*!
   Generated constructor for class ss_class.
   \author lsg
 */
ss_class::ss_class (ptr< ss_decl_seq > a__ss_struct_base__members,
                ptr< ss_declaration > a__ss_struct_base__decl,
                bool a__ss_struct_base__POD,
                ptr< ss_declaration_time > a__ss_struct_base__completion_time,
                ptr< ::lestes::std::list< srp< ss_base_specifier > > > a__ss_class__bases,
                ptr< ::lestes::std::set< srp< ss_class > > > a__ss_class__descendants)
        : ss_struct_base(a__ss_struct_base__members,
                a__ss_struct_base__decl,
                a__ss_struct_base__POD,
                a__ss_struct_base__completion_time), bases(checked(a__ss_class__bases)), descendants(checked(a__ss_class__descendants))
{}

ptr< object::reflection_list > ss_class::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( "bases", "list&lt; srp&lt; ss_base_specifier &gt; &gt;" ) );
                mdl->push_back( md::create( "descendants", "set&lt; srp&lt; ss_class &gt; &gt;" ) );
                reflection = reflection_list::create( ss_struct_base::reflection_get() );
                reflection->push_back( class_reflection::create( "ss_class", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > ss_class::field_values_get() const
{
        ptr < field_list_list > result = ss_struct_base::field_values_get();
        result->push_back( value_list::create() );
        result->back()->push_back( this->bases );
        result->push_back( value_list::create() );
        result->back()->push_back( this->descendants );
        return result;
}


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

// End of class ss_class.

// ------------- Class ss_union follows. -------------

ptr< ::lestes::std::list< srp< or_ics_functional > > > ss_union::accept_or_ics_base( ptr< or_ics_base > v )
{
        return v->visit_ss_union( this );
}

or_cv_enum ss_union::accept_or_ics_base_cv( ptr< or_ics_base_cv > v )
{
        return v->visit_ss_union( this );
}

ptr< ::lestes::md::types::tm_data_type_base > ss_union::accept_ss_type2tm_type_gen_base( ptr< ss_type2tm_type_gen_base > v )
{
        return v->visit_ss_union( this );
}

void ss_union::accept_ss_type_visitor( ptr< ss_type_visitor > v )
{
        return v->visit_ss_union( this );
}

/*!
   This factory method for class ss_union takes values of all fields as arguments.
   \author lsg
 */
ptr< ss_union > ss_union::create(ptr< ss_decl_seq > a__ss_struct_base__members,
                ptr< ss_declaration > a__ss_struct_base__decl,
                bool a__ss_struct_base__POD,
                ptr< ss_declaration_time > a__ss_struct_base__completion_time)
{
        return ptr< ss_union > ( new ss_union(a__ss_struct_base__members,
                a__ss_struct_base__decl,
                a__ss_struct_base__POD,
                a__ss_struct_base__completion_time) );
}

/*!
   Generated constructor for class ss_union.
   \author lsg
 */
ss_union::ss_union (ptr< ss_decl_seq > a__ss_struct_base__members,
                ptr< ss_declaration > a__ss_struct_base__decl,
                bool a__ss_struct_base__POD,
                ptr< ss_declaration_time > a__ss_struct_base__completion_time)
        : ss_struct_base(a__ss_struct_base__members,
                a__ss_struct_base__decl,
                a__ss_struct_base__POD,
                a__ss_struct_base__completion_time)
{}

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

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


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

// End of class ss_union.

// ------------- Class ss_typename_type follows. -------------

/*!
   \returns The value of ss_typename_type::contained_in.
   \author lsg
 */
ptr< ss_decl_seq > ss_typename_type::contained_in_get() const
{
        return contained_in;
}

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

/*!
   \returns The value of ss_typename_type::decl_time.
   \author lsg
 */
ptr< ss_declaration_time > ss_typename_type::decl_time_get() const
{
        return decl_time;
}

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

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

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

/*!
   Generated constructor for class ss_typename_type.
   \author lsg
 */
ss_typename_type::ss_typename_type (ptr< ss_decl_seq > a__ss_typename_type__contained_in,
                ptr< ss_declaration_time > a__ss_typename_type__decl_time,
                ptr< as_name > a__ss_typename_type__qualified_name)
        : ss_type(), contained_in(checked(a__ss_typename_type__contained_in)), decl_time(checked(a__ss_typename_type__decl_time)), qualified_name(checked(a__ss_typename_type__qualified_name))
{}

ptr< object::reflection_list > ss_typename_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( "contained_in", "ss_decl_seq" ) );
                mdl->push_back( md::create( "decl_time", "ss_declaration_time" ) );
                mdl->push_back( md::create( "qualified_name", "as_name" ) );
                reflection = reflection_list::create( ss_type::reflection_get() );
                reflection->push_back( class_reflection::create( "ss_typename_type", mdl ) );
        }
        return reflection;
}

ptr< object::field_list_list > ss_typename_type::field_values_get() const
{
        ptr < field_list_list > result = ss_type::field_values_get();
        result->push_back( value_list::create() );
        result->back()->push_back( this->contained_in );
        result->push_back( value_list::create() );
        result->back()->push_back( this->decl_time );
        result->push_back( value_list::create() );
        result->back()->push_back( this->qualified_name );
        return result;
}


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

// End of class ss_typename_type.


// static data members follow 
ptr<object::reflection_list> ss_type::reflection = reflection;
ptr<object::reflection_list> ss_builtin_type::reflection = reflection;
ptr< ::lestes::std::map< srp< ss_type >, srp< ss_type > > > ss_const::the_instances = ::lestes::std::map< srp< ss_type >, srp< ss_type > > ::create();
ptr<object::reflection_list> ss_const::reflection = reflection;
ptr< ::lestes::std::map< srp< ss_type >, srp< ss_type > > > ss_volatile::the_instances = ::lestes::std::map< srp< ss_type >, srp< ss_type > > ::create();
ptr<object::reflection_list> ss_volatile::reflection = reflection;
ptr<object::reflection_list> ss_const_volatile::reflection = reflection;
ptr<object::reflection_list> ss_referential::reflection = reflection;
ptr< ::lestes::std::map< srp< ss_type >, srp< ss_type > > > ss_reference::the_instances = ::lestes::std::map< srp< ss_type >, srp< ss_type > > ::create();
ptr<object::reflection_list> ss_reference::reflection = reflection;
ptr< ::lestes::std::map< srp< ss_type >, srp< ss_type > > > ss_pseudoreference::the_instances = ::lestes::std::map< srp< ss_type >, srp< ss_type > > ::create();
ptr<object::reflection_list> ss_pseudoreference::reflection = reflection;
ptr< ::lestes::std::map< srp< ss_type >, srp< ss_type > > > ss_pointer::the_instances = ::lestes::std::map< srp< ss_type >, srp< ss_type > > ::create();
ptr<object::reflection_list> ss_pointer::reflection = reflection;
ptr<object::reflection_list> ss_enum::reflection = reflection;
ptr< ::lestes::std::map< srp < ::lestes::std::pair < t_size, srp < ss_type > > >, srp< ss_type >, ::lestes::std::pair_comparator < srp < ::lestes::std::pair < t_size, srp < ss_type > > > > > > ss_array::the_instances = ::lestes::std::map< srp < ::lestes::std::pair < t_size, srp < ss_type > > >, srp< ss_type >, ::lestes::std::pair_comparator < srp < ::lestes::std::pair < t_size, srp < ss_type > > > > > ::create();
ptr<object::reflection_list> ss_array::reflection = reflection;
ptr< ::lestes::std::map< srp < ::lestes::std::pair < srp < ss_type >, srp < ss_type > > >, srp< ss_type >, ::lestes::std::pair_comparator < srp < ::lestes::std::pair < srp < ss_type >, srp < ss_type > > > > > > ss_member_pointer::the_instances = ::lestes::std::map< srp < ::lestes::std::pair < srp < ss_type >, srp < ss_type > > >, srp< ss_type >, ::lestes::std::pair_comparator < srp < ::lestes::std::pair < srp < ss_type >, srp < ss_type > > > > > ::create();
ptr<object::reflection_list> ss_member_pointer::reflection = reflection;
ptr< ::lestes::std::set< srp< ss_function >, ss_function_comparator > > ss_function::instances = ::lestes::std::set< srp< ss_function >, ss_function_comparator > ::create();
ptr<object::reflection_list> ss_function::reflection = reflection;
ptr<object::reflection_list> ss_member_function::reflection = reflection;
ptr<object::reflection_list> ss_struct_base::reflection = reflection;
ptr<object::reflection_list> ss_class::reflection = reflection;
ptr<object::reflection_list> ss_union::reflection = reflection;
ptr<object::reflection_list> ss_typename_type::reflection = reflection;

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

---