ss_type.g.hh

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.
                
*/

#ifndef lestes__lang__cplus__sem__ss_type_g_hh__included
#define lestes__lang__cplus__sem__ss_type_g_hh__included

#include <lestes/common.hh>
#include <lestes/std/pair_comparator.hh>
#include <lestes/std/map.hh>
#include <lestes/std/list.hh>
#include <lestes/std/set.hh>
#include <lestes/intercode/intercode.g.hh>
#include <lestes/lang/cplus/sem/or_ics.hh>

#include <lestes/std/objectize_macros.hh>
package(lestes);
package(md);
package(types);
class tm_data_type_base;
end_package(types);
end_package(md);
end_package(lestes);

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



                class ss_function_comparator;
        



class ss_declaration;
class ss_decl_seq;
class ss_base_specifier;
class ss_declaration_time;
class as_name;
class or_ics_functional;
class ss_type;
class or_ics_base;
class or_ics_base_cv;
class ss_type2tm_type_gen_base;
class ss_type_visitor;
class ss_builtin_type;
class ss_const;
class ss_volatile;
class ss_const_volatile;
class ss_referential;
class ss_reference;
class ss_pseudoreference;
class ss_pointer;
class ss_enum;
class ss_array;
class ss_member_pointer;
class ss_function;
class ss_member_function;
class ss_struct_base;
class ss_class;
class ss_union;
class ss_typename_type;


//! Base class for intercode types
class ss_type : public ::lestes::intercode::ss_base {
public:
        // WARNING: Detailed doxygen description for method
        // should be near it's implementation, not in XML file.

        /*! \brief Is this type void?

        Used for genarating pi calls. 
                                        Differentiate between call and callv. 
                                        Generic case returns false;
                        
        */
        virtual bool is_void();

        // WARNING: Detailed doxygen description for method
        // should be near it's implementation, not in XML file.

        /*! \brief Is this type volatile?

        
                                        Used for generating side effects. 
                                        Generic case returns false;
                                
        */
        virtual bool is_volatile();

        virtual ptr< ::lestes::std::list< srp< or_ics_functional > > > accept_or_ics_base( ptr< or_ics_base > v ) abstract;
        virtual or_cv_enum accept_or_ics_base_cv( ptr< or_ics_base_cv > v ) abstract;
        virtual ptr< ::lestes::md::types::tm_data_type_base > accept_ss_type2tm_type_gen_base( ptr< ss_type2tm_type_gen_base > v ) abstract;
        virtual void accept_ss_type_visitor( ptr< ss_type_visitor > v ) abstract;
        

        //! for purposes of dumping
        virtual ptr<reflection_list> reflection_get() const;
        //! for purposes of dumping
        virtual ptr<field_list_list> field_values_get() const;
        
protected:
        //! Generated constructor for class ss_type.
        ss_type (
                );

        //! Marking routine for class ss_type. 
        virtual void gc_mark();

private:
        static ptr<reflection_list> reflection;
        
}; // ss_type


//! Class for built-in types
class ss_builtin_type : public ss_type {
public:
        virtual ptr< ::lestes::std::list< srp< or_ics_functional > > > accept_or_ics_base( ptr< or_ics_base > v ) abstract;
        virtual or_cv_enum accept_or_ics_base_cv( ptr< or_ics_base_cv > v ) abstract;
        virtual ptr< ::lestes::md::types::tm_data_type_base > accept_ss_type2tm_type_gen_base( ptr< ss_type2tm_type_gen_base > v ) abstract;
        virtual void accept_ss_type_visitor( ptr< ss_type_visitor > v ) abstract;
        

        //! for purposes of dumping
        virtual ptr<reflection_list> reflection_get() const;
        //! for purposes of dumping
        virtual ptr<field_list_list> field_values_get() const;
        
protected:
        //! Generated constructor for class ss_builtin_type.
        ss_builtin_type (
                );

        //! Marking routine for class ss_builtin_type. 
        virtual void gc_mark();

private:
        static ptr<reflection_list> reflection;
        
}; // ss_builtin_type


/*! \brief Class for const types

Singleton class.
*/
class ss_const : public ss_type {
public:
        //! The method what_get returns the value of the field ss_const::what.
        ptr< ss_type > what_get() const;

        //! The method what_set sets the field ss_const::what to the given value.
        void what_set(const ptr< ss_type > &);

        // WARNING: Detailed doxygen description for method
        // should be near it's implementation, not in XML file.

        /*! \brief Is this type void?

        Used for genarating pi calls. 
                                        Differentiate between call and callv. 
                                        Generic case returns false;
                        
        */
        virtual bool is_void();

        //! get the instance representing appropriately qualified argument type
        static ptr< ss_type > instance(ptr< ss_type > type);

        virtual ptr< ::lestes::std::list< srp< or_ics_functional > > > accept_or_ics_base( ptr< or_ics_base > v );
        virtual or_cv_enum accept_or_ics_base_cv( ptr< or_ics_base_cv > v );
        virtual ptr< ::lestes::md::types::tm_data_type_base > accept_ss_type2tm_type_gen_base( ptr< ss_type2tm_type_gen_base > v );
        virtual void accept_ss_type_visitor( ptr< ss_type_visitor > v );
        
        //! First generated factory method for class ss_const.
        static ptr< ss_const > create (
                ptr< ss_type > a__ss_const__what);

        

        //! for purposes of dumping
        virtual ptr<reflection_list> reflection_get() const;
        //! for purposes of dumping
        virtual ptr<field_list_list> field_values_get() const;
        
protected:
        //! Generated constructor for class ss_const.
        ss_const (
                ptr< ss_type > a__ss_const__what);

        //! Marking routine for class ss_const. 
        virtual void gc_mark();

private:
        srp< ss_type > what;
        //! holder for the class instances
        static ptr< ::lestes::std::map< srp< ss_type >, srp< ss_type > > >  the_instances;
        static ptr<reflection_list> reflection;
        
}; // ss_const


/*! \brief Class for volatile types

Singleton class.
*/
class ss_volatile : public ss_type {
public:
        //! The method what_get returns the value of the field ss_volatile::what.
        ptr< ss_type > what_get() const;

        //! The method what_set sets the field ss_volatile::what to the given value.
        void what_set(const ptr< ss_type > &);

        // WARNING: Detailed doxygen description for method
        // should be near it's implementation, not in XML file.

        /*! \brief Is this type void?

        Used for genarating pi calls. 
                                        Differentiate between call and callv. 
                                        Generic case returns false;
                        
        */
        virtual bool is_void();

        // WARNING: Detailed doxygen description for method
        // should be near it's implementation, not in XML file.

        /*! \brief Is this type volatile?

        Used for generating side effects. 
                                        Returns true.
                        
        */
        virtual bool is_volatile();

        //! get the instance representing appropriately qualified argument type
        static ptr< ss_type > instance(ptr< ss_type > type);

        virtual ptr< ::lestes::std::list< srp< or_ics_functional > > > accept_or_ics_base( ptr< or_ics_base > v );
        virtual or_cv_enum accept_or_ics_base_cv( ptr< or_ics_base_cv > v );
        virtual ptr< ::lestes::md::types::tm_data_type_base > accept_ss_type2tm_type_gen_base( ptr< ss_type2tm_type_gen_base > v );
        virtual void accept_ss_type_visitor( ptr< ss_type_visitor > v );
        
        //! First generated factory method for class ss_volatile.
        static ptr< ss_volatile > create (
                ptr< ss_type > a__ss_volatile__what);

        

        //! for purposes of dumping
        virtual ptr<reflection_list> reflection_get() const;
        //! for purposes of dumping
        virtual ptr<field_list_list> field_values_get() const;
        
protected:
        //! Generated constructor for class ss_volatile.
        ss_volatile (
                ptr< ss_type > a__ss_volatile__what);

        //! Marking routine for class ss_volatile. 
        virtual void gc_mark();

private:
        srp< ss_type > what;
        //! holder for the class instances
        static ptr< ::lestes::std::map< srp< ss_type >, srp< ss_type > > >  the_instances;
        static ptr<reflection_list> reflection;
        
}; // ss_volatile


/*! \brief Class for volatile types

Singleton class
*/
class ss_const_volatile : public ss_type {
public:
        //! The method what_get returns the value of the field ss_const_volatile::what.
        ptr< ss_type > what_get() const;

        //! The method what_set sets the field ss_const_volatile::what to the given value.
        void what_set(const ptr< ss_type > &);

        // WARNING: Detailed doxygen description for method
        // should be near it's implementation, not in XML file.

        /*! \brief Is this type void?

        Used for genarating pi calls. 
                                        Differentiate between call and callv. 
                                        Generic case returns false;
                        
        */
        virtual bool is_void();

        // WARNING: Detailed doxygen description for method
        // should be near it's implementation, not in XML file.

        /*! \brief Is this type volatile?

        Used for generating side effects. 
                                        Returns true.
                        
        */
        virtual bool is_volatile();

        virtual ptr< ::lestes::std::list< srp< or_ics_functional > > > accept_or_ics_base( ptr< or_ics_base > v );
        virtual or_cv_enum accept_or_ics_base_cv( ptr< or_ics_base_cv > v );
        virtual ptr< ::lestes::md::types::tm_data_type_base > accept_ss_type2tm_type_gen_base( ptr< ss_type2tm_type_gen_base > v );
        virtual void accept_ss_type_visitor( ptr< ss_type_visitor > v );
        
        //! First generated factory method for class ss_const_volatile.
        static ptr< ss_const_volatile > create (
                ptr< ss_type > a__ss_const_volatile__what);

        

        //! for purposes of dumping
        virtual ptr<reflection_list> reflection_get() const;
        //! for purposes of dumping
        virtual ptr<field_list_list> field_values_get() const;
        
protected:
        //! Generated constructor for class ss_const_volatile.
        ss_const_volatile (
                ptr< ss_type > a__ss_const_volatile__what);

        //! Marking routine for class ss_const_volatile. 
        virtual void gc_mark();

private:
        srp< ss_type > what;
        static ptr<reflection_list> reflection;
        
}; // ss_const_volatile


/*! \brief Class for references

Type representing lvalues.
*/
class ss_referential : public ss_type {
public:
        //! The method what_get returns the value of the field ss_referential::what.
        ptr< ss_type > what_get() const;

        //! The method what_set sets the field ss_referential::what to the given value.
        void what_set(const ptr< ss_type > &);

        // WARNING: Detailed doxygen description for method
        // should be near it's implementation, not in XML file.

        /*! \brief Is this type void?

        Used for genarating pi calls. 
                                        Differentiate between call and callv. 
                                        Generic case returns false;
                        
        */
        virtual bool is_void();

        // WARNING: Detailed doxygen description for method
        // should be near it's implementation, not in XML file.

        /*! \brief Is this type volatile?

        Used for generating side effects. 
                                        Returns true.
                        
        */
        virtual bool is_volatile();

        virtual ptr< ::lestes::std::list< srp< or_ics_functional > > > accept_or_ics_base( ptr< or_ics_base > v ) abstract;
        virtual or_cv_enum accept_or_ics_base_cv( ptr< or_ics_base_cv > v ) abstract;
        virtual ptr< ::lestes::md::types::tm_data_type_base > accept_ss_type2tm_type_gen_base( ptr< ss_type2tm_type_gen_base > v ) abstract;
        virtual void accept_ss_type_visitor( ptr< ss_type_visitor > v ) abstract;
        

        //! for purposes of dumping
        virtual ptr<reflection_list> reflection_get() const;
        //! for purposes of dumping
        virtual ptr<field_list_list> field_values_get() const;
        
protected:
        //! Generated constructor for class ss_referential.
        ss_referential (
                ptr< ss_type > a__ss_referential__what);

        //! Marking routine for class ss_referential. 
        virtual void gc_mark();

private:
        srp< ss_type > what;
        static ptr<reflection_list> reflection;
        
}; // ss_referential


/*! \brief Class for referenced types via &

Compare with ss_address_of. Singleton class.
*/
class ss_reference : public ss_referential {
public:
        //! get the instance representing reference to the argument type
        static ptr< ss_type > instance(ptr< ss_type > type);

        virtual ptr< ::lestes::std::list< srp< or_ics_functional > > > accept_or_ics_base( ptr< or_ics_base > v );
        virtual or_cv_enum accept_or_ics_base_cv( ptr< or_ics_base_cv > v );
        virtual ptr< ::lestes::md::types::tm_data_type_base > accept_ss_type2tm_type_gen_base( ptr< ss_type2tm_type_gen_base > v );
        virtual void accept_ss_type_visitor( ptr< ss_type_visitor > v );
        
        //! First generated factory method for class ss_reference.
        static ptr< ss_reference > create (
                ptr< ss_type > a__ss_referential__what);

        

        //! for purposes of dumping
        virtual ptr<reflection_list> reflection_get() const;
        //! for purposes of dumping
        virtual ptr<field_list_list> field_values_get() const;
        
protected:
        //! Generated constructor for class ss_reference.
        ss_reference (
                ptr< ss_type > a__ss_referential__what);

        //! Marking routine for class ss_reference. 
        virtual void gc_mark();

private:
        //! holder for the class instances
        static ptr< ::lestes::std::map< srp< ss_type >, srp< ss_type > > >  the_instances;
        static ptr<reflection_list> reflection;
        
}; // ss_reference


/*! \brief Class for pseudo-referenced types

Represents usual variable.
*/
class ss_pseudoreference : public ss_referential {
public:
        //! get the instance representing reference to the argument type
        static ptr< ss_type > instance(ptr< ss_type > type);

        virtual ptr< ::lestes::std::list< srp< or_ics_functional > > > accept_or_ics_base( ptr< or_ics_base > v );
        virtual or_cv_enum accept_or_ics_base_cv( ptr< or_ics_base_cv > v );
        virtual ptr< ::lestes::md::types::tm_data_type_base > accept_ss_type2tm_type_gen_base( ptr< ss_type2tm_type_gen_base > v );
        virtual void accept_ss_type_visitor( ptr< ss_type_visitor > v );
        
        //! First generated factory method for class ss_pseudoreference.
        static ptr< ss_pseudoreference > create (
                ptr< ss_type > a__ss_referential__what);

        

        //! for purposes of dumping
        virtual ptr<reflection_list> reflection_get() const;
        //! for purposes of dumping
        virtual ptr<field_list_list> field_values_get() const;
        
protected:
        //! Generated constructor for class ss_pseudoreference.
        ss_pseudoreference (
                ptr< ss_type > a__ss_referential__what);

        //! Marking routine for class ss_pseudoreference. 
        virtual void gc_mark();

private:
        //! holder for the class instances
        static ptr< ::lestes::std::map< srp< ss_type >, srp< ss_type > > >  the_instances;
        static ptr<reflection_list> reflection;
        
}; // ss_pseudoreference


/*! \brief Class for pointered types

Singleton class.
*/
class ss_pointer : public ss_type {
public:
        //! The method what_get returns the value of the field ss_pointer::what.
        ptr< ss_type > what_get() const;

        //! The method what_set sets the field ss_pointer::what to the given value.
        void what_set(const ptr< ss_type > &);

        //! get the instance representing pointer to the argument type
        static ptr< ss_type > instance(ptr< ss_type > type);

        virtual ptr< ::lestes::std::list< srp< or_ics_functional > > > accept_or_ics_base( ptr< or_ics_base > v );
        virtual or_cv_enum accept_or_ics_base_cv( ptr< or_ics_base_cv > v );
        virtual ptr< ::lestes::md::types::tm_data_type_base > accept_ss_type2tm_type_gen_base( ptr< ss_type2tm_type_gen_base > v );
        virtual void accept_ss_type_visitor( ptr< ss_type_visitor > v );
        
        //! First generated factory method for class ss_pointer.
        static ptr< ss_pointer > create (
                ptr< ss_type > a__ss_pointer__what);

        

        //! for purposes of dumping
        virtual ptr<reflection_list> reflection_get() const;
        //! for purposes of dumping
        virtual ptr<field_list_list> field_values_get() const;
        
protected:
        //! Generated constructor for class ss_pointer.
        ss_pointer (
                ptr< ss_type > a__ss_pointer__what);

        //! Marking routine for class ss_pointer. 
        virtual void gc_mark();

private:
        srp< ss_type > what;
        //! holder for the class instances
        static ptr< ::lestes::std::map< srp< ss_type >, srp< ss_type > > >  the_instances;
        static ptr<reflection_list> reflection;
        
}; // ss_pointer


//! Class for enumeration type
class ss_enum : public ss_type {
public:
        //! The method enumerators_get returns the value of the field ss_enum::enumerators.
        ptr< ::lestes::std::list< srp< ss_declaration > > > enumerators_get() const;

        //! The method enumerators_set sets the field ss_enum::enumerators to the given value.
        void enumerators_set(const ptr< ::lestes::std::list< srp< ss_declaration > > > & );

        virtual ptr< ::lestes::std::list< srp< or_ics_functional > > > accept_or_ics_base( ptr< or_ics_base > v );
        virtual or_cv_enum accept_or_ics_base_cv( ptr< or_ics_base_cv > v );
        virtual ptr< ::lestes::md::types::tm_data_type_base > accept_ss_type2tm_type_gen_base( ptr< ss_type2tm_type_gen_base > v );
        virtual void accept_ss_type_visitor( ptr< ss_type_visitor > v );
        
        //! First generated factory method for class ss_enum.
        static ptr< ss_enum > create (
                ptr< ::lestes::std::list< srp< ss_declaration > > > a__ss_enum__enumerators);

        

        //! for purposes of dumping
        virtual ptr<reflection_list> reflection_get() const;
        //! for purposes of dumping
        virtual ptr<field_list_list> field_values_get() const;
        
protected:
        //! Generated constructor for class ss_enum.
        ss_enum (
                ptr< ::lestes::std::list< srp< ss_declaration > > > a__ss_enum__enumerators);

        //! Marking routine for class ss_enum. 
        virtual void gc_mark();

private:
        srp< ::lestes::std::list< srp< ss_declaration > > >  enumerators;
        static ptr<reflection_list> reflection;
        
}; // ss_enum


//! Class for array type
class ss_array : public ss_type {
public:
        //! The method bound_get returns the value of the field ss_array::bound.
        t_size bound_get() const;

        //! The method bound_set sets the field ss_array::bound to the given value.
        void bound_set(t_size);

        //! The method type_get returns the value of the field ss_array::type.
        ptr< ss_type > type_get() const;

        //! The method type_set sets the field ss_array::type to the given value.
        void type_set(const ptr< ss_type > &);

        //! get the instance representing array of the argument type
        static ptr< ss_type > instance(t_size size, ptr< ss_type > type);

        virtual ptr< ::lestes::std::list< srp< or_ics_functional > > > accept_or_ics_base( ptr< or_ics_base > v );
        virtual or_cv_enum accept_or_ics_base_cv( ptr< or_ics_base_cv > v );
        virtual ptr< ::lestes::md::types::tm_data_type_base > accept_ss_type2tm_type_gen_base( ptr< ss_type2tm_type_gen_base > v );
        virtual void accept_ss_type_visitor( ptr< ss_type_visitor > v );
        
        //! First generated factory method for class ss_array.
        static ptr< ss_array > create (
                t_size a__ss_array__bound,
                ptr< ss_type > a__ss_array__type);

        

        //! for purposes of dumping
        virtual ptr<reflection_list> reflection_get() const;
        //! for purposes of dumping
        virtual ptr<field_list_list> field_values_get() const;
        
protected:
        //! Generated constructor for class ss_array.
        ss_array (
                t_size a__ss_array__bound,
                ptr< ss_type > a__ss_array__type);

        //! Marking routine for class ss_array. 
        virtual void gc_mark();

private:
        t_size bound;
        srp< ss_type > type;
        //! holder for the class instances
        static 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 > > > > > >  the_instances;
        static ptr<reflection_list> reflection;
        
}; // ss_array


//! Class for member pointer (8.3.3)
class ss_member_pointer : public ss_type {
public:
        //! The method base_get returns the value of the field ss_member_pointer::base.
        ptr< ss_type > base_get() const;

        //! The method base_set sets the field ss_member_pointer::base to the given value.
        void base_set(const ptr< ss_type > &);

        //! The method item_get returns the value of the field ss_member_pointer::item.
        ptr< ss_type > item_get() const;

        //! The method item_set sets the field ss_member_pointer::item to the given value.
        void item_set(const ptr< ss_type > &);

        //! get the instance representing array of the argument type
        static ptr< ss_type > instance(ptr< ss_type > base_type, ptr< ss_type > element_type);

        virtual ptr< ::lestes::std::list< srp< or_ics_functional > > > accept_or_ics_base( ptr< or_ics_base > v );
        virtual or_cv_enum accept_or_ics_base_cv( ptr< or_ics_base_cv > v );
        virtual ptr< ::lestes::md::types::tm_data_type_base > accept_ss_type2tm_type_gen_base( ptr< ss_type2tm_type_gen_base > v );
        virtual void accept_ss_type_visitor( ptr< ss_type_visitor > v );
        
        //! First generated factory method for class ss_member_pointer.
        static ptr< ss_member_pointer > create (
                ptr< ss_type > a__ss_member_pointer__base,
                ptr< ss_type > a__ss_member_pointer__item);

        

        //! for purposes of dumping
        virtual ptr<reflection_list> reflection_get() const;
        //! for purposes of dumping
        virtual ptr<field_list_list> field_values_get() const;
        
protected:
        //! Generated constructor for class ss_member_pointer.
        ss_member_pointer (
                ptr< ss_type > a__ss_member_pointer__base,
                ptr< ss_type > a__ss_member_pointer__item);

        //! Marking routine for class ss_member_pointer. 
        virtual void gc_mark();

private:
        srp< ss_type > base;
        srp< ss_type > item;
        //! holder for the class instances
        static 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 > > > > > >  the_instances;
        static ptr<reflection_list> reflection;
        
}; // ss_member_pointer


/*! \brief Class for function type.

Represents namespace function.
*/
class ss_function : public ss_type {
public:
        //! The method returns_get returns the value of the field ss_function::returns.
        ptr< ss_type > returns_get() const;

        //! The method returns_set sets the field ss_function::returns to the given value.
        void returns_set(const ptr< ss_type > &);

        //! The method params_get returns the value of the field ss_function::params.
        ptr< ::lestes::std::list< srp< ss_type > > > params_get() const;

        //! The method params_set sets the field ss_function::params to the given value.
        void params_set(const ptr< ::lestes::std::list< srp< ss_type > > > & );

        //! The method ellipsis_get returns the value of the field ss_function::ellipsis.
        bool ellipsis_get() const;

        //! The method ellipsis_set sets the field ss_function::ellipsis to the given value.
        void ellipsis_set(bool);

        //! Returns the instance representing specified function.
        static ptr< ss_type > instance(ptr< ss_type > return_type, ptr < ::lestes::std::list < srp<ss_type> > > param_types, bool ellipsis);

        //! Compares to other ss_function for inequality.
        bool less_than(ptr< ss_function > other);

        //! Compares to other ss_function signature.
        bool equal_signature(ptr< ss_function > other);

        virtual ptr< ::lestes::std::list< srp< or_ics_functional > > > accept_or_ics_base( ptr< or_ics_base > v );
        virtual or_cv_enum accept_or_ics_base_cv( ptr< or_ics_base_cv > v );
        virtual ptr< ::lestes::md::types::tm_data_type_base > accept_ss_type2tm_type_gen_base( ptr< ss_type2tm_type_gen_base > v );
        virtual void accept_ss_type_visitor( ptr< ss_type_visitor > v );
        
        //! First generated factory method for class ss_function.
        static ptr< 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);

        

        //! for purposes of dumping
        virtual ptr<reflection_list> reflection_get() const;
        //! for purposes of dumping
        virtual ptr<field_list_list> field_values_get() const;
        
protected:
        //! Generated constructor for class 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);

        //! Marking routine for class ss_function. 
        virtual void gc_mark();

private:
        //! The singleton instances of the class.
        static ptr< ::lestes::std::set< srp< ss_function >, ss_function_comparator > >  instances;
        //! The return type of the function.
        srp< ss_type > returns;
        //! The types of parameters of the function.
        srp< ::lestes::std::list< srp< ss_type > > >  params;
        /*! \brief Whether current function has an ellipsis(...) in function parameters.

        Rationale for field contra individual class: There is no C++ type, which corresponds to ellipsis.
        */
        bool ellipsis;
        static ptr<reflection_list> reflection;
        
}; // ss_function


//! Class for member function type
class ss_member_function : public ss_function {
public:
        //! The method this_type_get returns the value of the field ss_member_function::this_type.
        ptr< ss_type > this_type_get() const;

        //! The method this_type_set sets the field ss_member_function::this_type to the given value.
        void this_type_set(const ptr< ss_type > &);

        virtual ptr< ::lestes::std::list< srp< or_ics_functional > > > accept_or_ics_base( ptr< or_ics_base > v );
        virtual or_cv_enum accept_or_ics_base_cv( ptr< or_ics_base_cv > v );
        virtual ptr< ::lestes::md::types::tm_data_type_base > accept_ss_type2tm_type_gen_base( ptr< ss_type2tm_type_gen_base > v );
        virtual void accept_ss_type_visitor( ptr< ss_type_visitor > v );
        
        //! First generated factory method for class ss_member_function.
        static ptr< 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);

        

        //! for purposes of dumping
        virtual ptr<reflection_list> reflection_get() const;
        //! for purposes of dumping
        virtual ptr<field_list_list> field_values_get() const;
        
protected:
        //! Generated constructor for class 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);

        //! Marking routine for class ss_member_function. 
        virtual void gc_mark();

private:
        /*! \brief  The type of "this" as it will be seen in the function.

         
                                        In a function declared const in class "a" (e.g. int a::f(int) const;)
                                        This field will represent the type "a const *".
                                
        */
        srp< ss_type > this_type;
        static ptr<reflection_list> reflection;
        
}; // ss_member_function


//! Base class for structurated objects
class ss_struct_base : public ss_type {
public:
        //! The method members_get returns the value of the field ss_struct_base::members.
        ptr< ss_decl_seq > members_get() const;

        //! The method members_set sets the field ss_struct_base::members to the given value.
        void members_set(const ptr< ss_decl_seq > &);

        //! The method decl_get returns the value of the field ss_struct_base::decl.
        ptr< ss_declaration > decl_get() const;

        //! The method decl_set sets the field ss_struct_base::decl to the given value.
        void decl_set(const ptr< ss_declaration > &);

        //! The method POD_get returns the value of the field ss_struct_base::POD.
        bool POD_get() const;

        //! The method POD_set sets the field ss_struct_base::POD to the given value.
        void POD_set(bool);

        //! The method completion_time_get returns the value of the field ss_struct_base::completion_time.
        ptr< ss_declaration_time > completion_time_get() const;

        //! The method completion_time_set sets the field ss_struct_base::completion_time to the given value.
        void completion_time_set(const ptr< ss_declaration_time > &);

        virtual ptr< ::lestes::std::list< srp< or_ics_functional > > > accept_or_ics_base( ptr< or_ics_base > v ) abstract;
        virtual or_cv_enum accept_or_ics_base_cv( ptr< or_ics_base_cv > v ) abstract;
        virtual ptr< ::lestes::md::types::tm_data_type_base > accept_ss_type2tm_type_gen_base( ptr< ss_type2tm_type_gen_base > v ) abstract;
        virtual void accept_ss_type_visitor( ptr< ss_type_visitor > v ) abstract;
        

        //! for purposes of dumping
        virtual ptr<reflection_list> reflection_get() const;
        //! for purposes of dumping
        virtual ptr<field_list_list> field_values_get() const;
        
protected:
        //! Generated constructor for class 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);

        //! Marking routine for class ss_struct_base. 
        virtual void gc_mark();

private:
        srp< ss_decl_seq > members;
        /*! \brief Points to declaration of this class

        Declaration is needed because of access to enclosing scopes.
        */
        srp< ss_declaration > decl;
        //! Is this class POD strcuture ?
        bool POD;
        /*! \brief  Structures can have forward declaration 

         Before structure is completed, this field is set to NULL. 
        */
        srp< ss_declaration_time > completion_time;
        static ptr<reflection_list> reflection;
        
}; // ss_struct_base


/*! \brief Class for struct-class types

Distinction of struct-class: default visibility is resolved before. TODO struct x class POD status
*/
class ss_class : public ss_struct_base {
public:
        //! The method bases_get returns the value of the field ss_class::bases.
        ptr< ::lestes::std::list< srp< ss_base_specifier > > > bases_get() const;

        //! The method bases_set sets the field ss_class::bases to the given value.
        void bases_set(const ptr< ::lestes::std::list< srp< ss_base_specifier > > > & );

        //! The method descendants_get returns the value of the field ss_class::descendants.
        ptr< ::lestes::std::set< srp< ss_class > > > descendants_get() const;

        //! The method descendants_set sets the field ss_class::descendants to the given value.
        void descendants_set(const ptr< ::lestes::std::set< srp< ss_class > > > & );

        // WARNING: Detailed doxygen description for method
        // should be near it's implementation, not in XML file.

        /*! \brief Check whether is this class ancestor of parameter.

        Used in overload resolution.        
                        
        */
        bool is_ancestor(ptr< ss_class > descendant);

        virtual ptr< ::lestes::std::list< srp< or_ics_functional > > > accept_or_ics_base( ptr< or_ics_base > v );
        virtual or_cv_enum accept_or_ics_base_cv( ptr< or_ics_base_cv > v );
        virtual ptr< ::lestes::md::types::tm_data_type_base > accept_ss_type2tm_type_gen_base( ptr< ss_type2tm_type_gen_base > v );
        virtual void accept_ss_type_visitor( ptr< ss_type_visitor > v );
        
        //! First generated factory method for class ss_class.
        static ptr< 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);

        //! Second generated factory method for class ss_class.
        static ptr< 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);

        

        //! for purposes of dumping
        virtual ptr<reflection_list> reflection_get() const;
        //! for purposes of dumping
        virtual ptr<field_list_list> field_values_get() const;
        
protected:
        //! Generated constructor for class 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);

        //! Marking routine for class ss_class. 
        virtual void gc_mark();

private:
        /*! 
        Bases of the class are in the list, because ABI-structure-layout has to now order.
        */
        srp< ::lestes::std::list< srp< ss_base_specifier > > >  bases;
        /*! \brief Direct descendant classes of current class.

        Rationale: Overload resolution needs to know descendants. 
                                        (Conversions of member pointers into member pointer of derived class.[4.11/2])
                                
        */
        srp< ::lestes::std::set< srp< ss_class > > >  descendants;
        static ptr<reflection_list> reflection;
        
}; // ss_class


//! Class for union type
class ss_union : public ss_struct_base {
public:
        virtual ptr< ::lestes::std::list< srp< or_ics_functional > > > accept_or_ics_base( ptr< or_ics_base > v );
        virtual or_cv_enum accept_or_ics_base_cv( ptr< or_ics_base_cv > v );
        virtual ptr< ::lestes::md::types::tm_data_type_base > accept_ss_type2tm_type_gen_base( ptr< ss_type2tm_type_gen_base > v );
        virtual void accept_ss_type_visitor( ptr< ss_type_visitor > v );
        
        //! First generated factory method for class ss_union.
        static ptr< 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);

        

        //! for purposes of dumping
        virtual ptr<reflection_list> reflection_get() const;
        //! for purposes of dumping
        virtual ptr<field_list_list> field_values_get() const;
        
protected:
        //! Generated constructor for class 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);

        //! Marking routine for class ss_union. 
        virtual void gc_mark();

private:
        static ptr<reflection_list> reflection;
        
}; // ss_union


/*! \brief Class for template typename types


                                This type is prepared for template typename types such as:

                                template<typename X> class A {
                                typename X::T a(typename X::F);
                                };

                                and since the templates are not now implemented, processing with this
                                type will cause lassert.
                        
*/
class ss_typename_type : public ss_type {
public:
        //! The method contained_in_get returns the value of the field ss_typename_type::contained_in.
        ptr< ss_decl_seq > contained_in_get() const;

        //! The method contained_in_set sets the field ss_typename_type::contained_in to the given value.
        void contained_in_set(const ptr< ss_decl_seq > &);

        //! The method decl_time_get returns the value of the field ss_typename_type::decl_time.
        ptr< ss_declaration_time > decl_time_get() const;

        //! The method decl_time_set sets the field ss_typename_type::decl_time to the given value.
        void decl_time_set(const ptr< ss_declaration_time > &);

        //! The method qualified_name_get returns the value of the field ss_typename_type::qualified_name.
        ptr< as_name > qualified_name_get() const;

        //! The method qualified_name_set sets the field ss_typename_type::qualified_name to the given value.
        void qualified_name_set(const ptr< as_name > &);

        virtual ptr< ::lestes::std::list< srp< or_ics_functional > > > accept_or_ics_base( ptr< or_ics_base > v ) abstract;
        virtual or_cv_enum accept_or_ics_base_cv( ptr< or_ics_base_cv > v ) abstract;
        virtual ptr< ::lestes::md::types::tm_data_type_base > accept_ss_type2tm_type_gen_base( ptr< ss_type2tm_type_gen_base > v ) abstract;
        virtual void accept_ss_type_visitor( ptr< ss_type_visitor > v ) abstract;
        

        //! for purposes of dumping
        virtual ptr<reflection_list> reflection_get() const;
        //! for purposes of dumping
        virtual ptr<field_list_list> field_values_get() const;
        
protected:
        //! Generated constructor for class 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);

        //! Marking routine for class ss_typename_type. 
        virtual void gc_mark();

private:
        srp< ss_decl_seq > contained_in;
        srp< ss_declaration_time > decl_time;
        /*! \brief This field represents qualified name.

        
                                        Since we dont know the type before template initialization happens, there is
                                        no obvious standard ss_type representing this name. To convert
                                        current as type to ss type, we will wait for instantiation.
                                
        */
        srp< as_name > qualified_name;
        static ptr<reflection_list> reflection;
        
}; // ss_typename_type


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

#endif // lestes__lang__cplus__sem__ss_type_g_hh__included

---