ss_type_builtin.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/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/md/types/tm_data_type_base.g.hh>

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

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

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


// ------------- Class ss_bool follows. -------------

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

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

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

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

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

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

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

ptr< object::field_list_list > ss_bool::field_values_get() const
{
        ptr < field_list_list > result = ss_builtin_type::field_values_get();
        result->push_back( value_list::create() );
        result->back()->push_back( this->the_instance );
        return result;
}


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

// End of class ss_bool.

// ------------- Class ss_void follows. -------------

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

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

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

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

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

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

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

ptr< object::field_list_list > ss_void::field_values_get() const
{
        ptr < field_list_list > result = ss_builtin_type::field_values_get();
        result->push_back( value_list::create() );
        result->back()->push_back( this->the_instance );
        return result;
}


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

// End of class ss_void.

// ------------- Class ss_integral follows. -------------

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

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

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


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

// End of class ss_integral.

// ------------- Class ss_type_int follows. -------------

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

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

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


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

// End of class ss_type_int.

// ------------- Class ss_type_sint follows. -------------

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

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

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

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

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

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

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

ptr< object::field_list_list > ss_type_sint::field_values_get() const
{
        ptr < field_list_list > result = ss_type_int::field_values_get();
        result->push_back( value_list::create() );
        result->back()->push_back( this->the_instance );
        return result;
}


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

// End of class ss_type_sint.

// ------------- Class ss_type_uint follows. -------------

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

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

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

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

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

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

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

ptr< object::field_list_list > ss_type_uint::field_values_get() const
{
        ptr < field_list_list > result = ss_type_int::field_values_get();
        result->push_back( value_list::create() );
        result->back()->push_back( this->the_instance );
        return result;
}


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

// End of class ss_type_uint.

// ------------- Class ss_type_long follows. -------------

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

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

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


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

// End of class ss_type_long.

// ------------- Class ss_type_slong follows. -------------

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

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

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

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

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

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

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

ptr< object::field_list_list > ss_type_slong::field_values_get() const
{
        ptr < field_list_list > result = ss_type_long::field_values_get();
        result->push_back( value_list::create() );
        result->back()->push_back( this->the_instance );
        return result;
}


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

// End of class ss_type_slong.

// ------------- Class ss_type_ulong follows. -------------

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

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

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

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

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

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

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

ptr< object::field_list_list > ss_type_ulong::field_values_get() const
{
        ptr < field_list_list > result = ss_type_long::field_values_get();
        result->push_back( value_list::create() );
        result->back()->push_back( this->the_instance );
        return result;
}


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

// End of class ss_type_ulong.

// ------------- Class ss_type_short follows. -------------

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

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

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


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

// End of class ss_type_short.

// ------------- Class ss_type_sshort follows. -------------

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

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

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

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

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

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

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

ptr< object::field_list_list > ss_type_sshort::field_values_get() const
{
        ptr < field_list_list > result = ss_type_short::field_values_get();
        result->push_back( value_list::create() );
        result->back()->push_back( this->the_instance );
        return result;
}


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

// End of class ss_type_sshort.

// ------------- Class ss_type_ushort follows. -------------

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

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

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

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

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

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

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

ptr< object::field_list_list > ss_type_ushort::field_values_get() const
{
        ptr < field_list_list > result = ss_type_short::field_values_get();
        result->push_back( value_list::create() );
        result->back()->push_back( this->the_instance );
        return result;
}


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

// End of class ss_type_ushort.

// ------------- Class ss_type_char follows. -------------

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

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

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


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

// End of class ss_type_char.

// ------------- Class ss_type_wchar_t follows. -------------

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

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

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

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

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

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

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

ptr< object::field_list_list > ss_type_wchar_t::field_values_get() const
{
        ptr < field_list_list > result = ss_type_char::field_values_get();
        result->push_back( value_list::create() );
        result->back()->push_back( this->the_instance );
        return result;
}


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

// End of class ss_type_wchar_t.

// ------------- Class ss_type_schar follows. -------------

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

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

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

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

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

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

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

ptr< object::field_list_list > ss_type_schar::field_values_get() const
{
        ptr < field_list_list > result = ss_type_char::field_values_get();
        result->push_back( value_list::create() );
        result->back()->push_back( this->the_instance );
        return result;
}


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

// End of class ss_type_schar.

// ------------- Class ss_type_uchar follows. -------------

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

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

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

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

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

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

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

ptr< object::field_list_list > ss_type_uchar::field_values_get() const
{
        ptr < field_list_list > result = ss_type_char::field_values_get();
        result->push_back( value_list::create() );
        result->back()->push_back( this->the_instance );
        return result;
}


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

// End of class ss_type_uchar.

// ------------- Class ss_type_pchar follows. -------------

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

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

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

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

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

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

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

ptr< object::field_list_list > ss_type_pchar::field_values_get() const
{
        ptr < field_list_list > result = ss_type_char::field_values_get();
        result->push_back( value_list::create() );
        result->back()->push_back( this->the_instance );
        return result;
}


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

// End of class ss_type_pchar.

// ------------- Class ss_floating follows. -------------

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

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

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


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

// End of class ss_floating.

// ------------- Class ss_type_float follows. -------------

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

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

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

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

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

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

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

ptr< object::field_list_list > ss_type_float::field_values_get() const
{
        ptr < field_list_list > result = ss_floating::field_values_get();
        result->push_back( value_list::create() );
        result->back()->push_back( this->the_instance );
        return result;
}


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

// End of class ss_type_float.

// ------------- Class ss_type_double follows. -------------

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

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

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

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

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

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

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

ptr< object::field_list_list > ss_type_double::field_values_get() const
{
        ptr < field_list_list > result = ss_floating::field_values_get();
        result->push_back( value_list::create() );
        result->back()->push_back( this->the_instance );
        return result;
}


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

// End of class ss_type_double.

// ------------- Class ss_type_ldouble follows. -------------

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

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

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

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

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

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

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

ptr< object::field_list_list > ss_type_ldouble::field_values_get() const
{
        ptr < field_list_list > result = ss_floating::field_values_get();
        result->push_back( value_list::create() );
        result->back()->push_back( this->the_instance );
        return result;
}


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

// End of class ss_type_ldouble.


// static data members follow 
ptr< ss_type > ss_bool::the_instance = the_instance;
ptr<object::reflection_list> ss_bool::reflection = reflection;
ptr< ss_type > ss_void::the_instance = the_instance;
ptr<object::reflection_list> ss_void::reflection = reflection;
ptr<object::reflection_list> ss_integral::reflection = reflection;
ptr<object::reflection_list> ss_type_int::reflection = reflection;
ptr< ss_type > ss_type_sint::the_instance = the_instance;
ptr<object::reflection_list> ss_type_sint::reflection = reflection;
ptr< ss_type > ss_type_uint::the_instance = the_instance;
ptr<object::reflection_list> ss_type_uint::reflection = reflection;
ptr<object::reflection_list> ss_type_long::reflection = reflection;
ptr< ss_type > ss_type_slong::the_instance = the_instance;
ptr<object::reflection_list> ss_type_slong::reflection = reflection;
ptr< ss_type > ss_type_ulong::the_instance = the_instance;
ptr<object::reflection_list> ss_type_ulong::reflection = reflection;
ptr<object::reflection_list> ss_type_short::reflection = reflection;
ptr< ss_type > ss_type_sshort::the_instance = the_instance;
ptr<object::reflection_list> ss_type_sshort::reflection = reflection;
ptr< ss_type > ss_type_ushort::the_instance = the_instance;
ptr<object::reflection_list> ss_type_ushort::reflection = reflection;
ptr<object::reflection_list> ss_type_char::reflection = reflection;
ptr< ss_type > ss_type_wchar_t::the_instance = the_instance;
ptr<object::reflection_list> ss_type_wchar_t::reflection = reflection;
ptr< ss_type > ss_type_schar::the_instance = the_instance;
ptr<object::reflection_list> ss_type_schar::reflection = reflection;
ptr< ss_type > ss_type_uchar::the_instance = the_instance;
ptr<object::reflection_list> ss_type_uchar::reflection = reflection;
ptr< ss_type > ss_type_pchar::the_instance = the_instance;
ptr<object::reflection_list> ss_type_pchar::reflection = reflection;
ptr<object::reflection_list> ss_floating::reflection = reflection;
ptr< ss_type > ss_type_float::the_instance = the_instance;
ptr<object::reflection_list> ss_type_float::reflection = reflection;
ptr< ss_type > ss_type_double::the_instance = the_instance;
ptr<object::reflection_list> ss_type_double::reflection = reflection;
ptr< ss_type > ss_type_ldouble::the_instance = the_instance;
ptr<object::reflection_list> ss_type_ldouble::reflection = reflection;

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

---