Package pyplusplus :: Package decl_wrappers :: Module class_wrapper :: Class class_t |

# type class_t

source code

                                                 object --+
                                                          |
                                     class_common_details_t --+
                                                              |
                                             object --+       |
                                                      |       |
                            decl_wrapper.decl_wrapper_t --+   |
                                                          |   |
                                scopedef_wrapper.scopedef_t --+
                                                              |
                                         object --+           |
                                                  |           |
    pygccxml.declarations.declaration.declaration_t --+       |
                                                      |       |
              pygccxml.declarations.scopedef.scopedef_t --+   |
                                                          |   |
            pygccxml.declarations.class_declaration.class_t --+
                                                              |
                                                             class_t

Nested Classes
EXPOSED_CLASS_TYPE
Inherited from `pygccxml.declarations.scopedef.scopedef_t`: `declaration_not_found_t`, `multiple_declarations_found_t`

Instance Methods
__init__(self, *arguments, **keywords) creates class that describes C++ class definition | source code
add_fake_constructors(self, f) f - reference to a calldef_t object or list of them | source code
add_destructor_code(self, code) adds code to the class-wrapper destructor | source code
translate_exception_to_string(self, python_exception_type, to_string) registers exception translation to string | source code
add_declaration_code(self, code) adds the code to the declaration section | source code
add_registration_code(self, code, works_on_instance=True, tail=True) adds the code to the class registration section | source code
add_code(self, code, works_on_instance=True, tail=True) adds the code to the class registration section | source code
add_wrapper_code(self, code) adds code to the class wrapper class definition | source code
set_constructors_body(self, body) Sets the body for all constructors | source code
get_exportable_members(self, sort=None) returns list of internal declarations that should\could be exported | source code
add_property(self, name, fget, fset=None, doc=`'````'`) adds new property to the class | source code
add_properties(self, recognizer=None, exclude_accessors=False) | source code
add_static_property(self, name, fget, fset=None, doc=`'````'`) adds new static property to the class | source code
redefined_funcs(self) returns list of member functions that should be defined in class wrapper | source code
is_wrapper_needed(self) returns an explanation( list of str ) why wrapper is needed. | source code
guess_always_expose_using_scope_value(self) | source code
Inherited from `scopedef_wrapper.scopedef_t`: `exclude`, `include` Inherited from `decl_wrapper.decl_wrapper_t`: `disable_messages`, `disable_warnings`, `get_already_exposed`, `get_exportable`, `readme`, `rename`, `set_already_exposed`, `set_exportable`, `why_not_exportable` Inherited from `pygccxml.declarations.class_declaration.class_t`: `__eq__`, `__str__`, `adopt_declaration`, `find_copy_constructor`, `find_noncopyable_vars`, `find_out_member_access_type`, `find_trivial_constructor`, `get_members`, `i_depend_on_them`, `remove_declaration` Inherited from `pygccxml.declarations.scopedef.scopedef_t`: `__getitem__`, `calldef`, `calldefs`, `casting_operator`, `casting_operators`, `class_`, `classes`, `clear_optimizer`, `constructor`, `constructors`, `decl`, `decls`, `enum`, `enumeration`, `enumerations`, `enums`, `init_optimizer`, `mem_fun`, `mem_funs`, `mem_oper`, `mem_opers`, `member_function`, `member_functions`, `member_operator`, `member_operators`, `operator`, `operators`, `typedef`, `typedefs`, `var`, `variable`, `variables`, `vars` Inherited from `pygccxml.declarations.declaration.declaration_t`: `__lt__`, `__ne__`, `create_decl_string`

Class Variables
| FAKE_CONSTRUCTOR_TYPES = ``(`<class 'pygccxml.declarations.callde`...``
| FAKE_CONSTRUCTOR_TYPE_NAMES = ``'``member and free functions``'``
Inherited from `decl_wrapper.decl_wrapper_t`: `SPECIAL_TYPEDEF_PICK_ANY` Inherited from `pygccxml.declarations.class_declaration.class_t`: `USE_DEMANGLED_AS_NAME` Inherited from `pygccxml.declarations.scopedef.scopedef_t`: `ALLOW_EMPTY_MDECL_WRAPPER`, `RECURSIVE_DEFAULT`

Properties
| fake_constructors list of fake constructors
| redefine_operators tells Py++ to redefine operators from base class in this class, False by default
| exposed_class_type set this value to CLASS_TYPE.WRAPPER, if you need to transfer ownership ofpolymorphic class
| held_type string, this property tells Py++ what HeldType this class hasDefault value is calculated, based on information presented in exposed declarations
| noncopyable True if the class is noncopyable, False otherwiesDefault value is calculated, based on information presented in the declarations tree
| wrapper_alias class-wrapper name
| declaration_code List of strings, that contains valid C++ code, that will be added to the class declaration section
| registration_code_head List of strings, that contains valid C++ code, that will be added to the head of the class registration section
| registration_code_tail List of strings, that contains valid C++ code, that will be added to the tail of the class registration section
| registration_code List of strings, that contains all C++ code, that will be added to the class registration section
| wrapper_code List of strings, that contains valid C++ code, that will be added to the class wrapper.
| null_constructor_body null constructor code, that will be added as is to the null constructor of class-wrapper
| copy_constructor_body copy constructor code, that will be added as is to the copy constructor of class-wrapper
| destructor_code list of code to be added to wrapper destructor
| exception_argument_name exception argument name for translate exception function
| exception_translation_code C++ exception to Python exception translation code Example: PyErr_SetString(PyExc_RuntimeError, exc.what()); Py++ will generate the rest of the code.
| properties list of properties
| require_self_reference boolean, if True the first argument to the constructor will be reference to self object
| expose_this boolean, if True an object address( this pointer ) will be exposed to Python as integer.
| expose_sizeof boolean, if True the sizeof(obj) will be exposed to Python as integer.
| introduces_new_scope returns True, if during exposing this class, new scope will be created
| no_init If True, class will be registered with 'boost::python::no_init'
Inherited from `class_common_details_t`: `always_expose_using_scope`, `class_var_name`, `equality_comparable`, `indexing_suite`, `indexing_suite_version`, `less_than_comparable`, `opaque` Inherited from `decl_wrapper.decl_wrapper_t`: `alias`, `already_exposed`, `disabled_messages`, `documentation`, `exportable`, `ignore`, `include_files`, `logger` Inherited from `pygccxml.declarations.class_declaration.class_t`: `aliases`, `bases`, `byte_align`, `byte_size`, `class_type`, `container_traits`, `derived`, `is_abstract`, `private_members`, `protected_members`, `public_members`, `recursive_bases`, `recursive_derived` Inherited from `pygccxml.declarations.scopedef.scopedef_t`: `declarations` Inherited from `pygccxml.declarations.declaration.declaration_t`: `attributes`, `cache`, `compiler`, `decl_string`, `demangled`, `is_artificial`, `location`, `mangled`, `name`, `parent`, `partial_decl_string`, `partial_name`, `top_parent`

Method Details

### __init__(self, *arguments, **keywords) (Constructor) | source code
creates class that describes C++ class definition Overrides: pygccxml.declarations.declaration.declaration_t.__init__

### add_fake_constructors(self, f) | source code
f - reference to a calldef_t object or list of them boost::python::make_constructor allows to register a C++ function, as a class constructor.

### translate_exception_to_string(self, python_exception_type, to_string) | source code
registers exception translation to string Parameters: `python_exception_type` (str) - Python exception type, for example PyExc_RuntimeError `to_string` (str) - C++ expression that extracts information from exception. The type of expression should be char*.

### add_registration_code(self, code, works_on_instance=True, tail=True) | source code
adds the code to the class registration section Parameters: `works_on_instance` (bool) - If true, the custom code can be applied directly to obj inst. Example: ObjInst.code `tail` (bool) - if True, the custom code is appended to the end of the class registration code.

### add_code(self, code, works_on_instance=True, tail=True) | source code
adds the code to the class registration section Parameters: `works_on_instance` (bool) - If true, the custom code can be applied directly to obj inst. Example: ObjInst.code `tail` (bool) - if True, the custom code is appended to the end of the class registration code.

### add_property(self, name, fget, fset=None, doc=`'````'`) | source code
adds new property to the class Parameters: `name` (str) - name of the property `fget` - reference to the class member function `fset` - reference to the class member function, could be None `doc` - documentation string

### redefined_funcs(self) | source code
    returns list of member functions that should be defined in class wrapper

    It comes useful in 3 tier hierarchy:
    struct base{
        virtual void do_nothing() = 0;
    };

    struct derived{
        virtual void do_something() = 0;
    };

    struct concrete{
        virtual void do_nothing(){}
        virtual void do_something(){}
    };

    derived_wrapper should define do_nothing function, otherwise the generated
    code will not compile

### is_wrapper_needed(self) | source code
returns an explanation( list of str ) why wrapper is needed. If wrapper is not needed than [] will be returned.

### guess_always_expose_using_scope_value(self) | source code
Overrides: class_common_details_t.guess_always_expose_using_scope_value

Class Variable Details

  ### FAKE_CONSTRUCTOR_TYPES Value:
      (<class 'pygccxml.declarations.calldef.member_function_t'>,
       <class 'pygccxml.declarations.calldef.free_function_t'>)

Property Details

### fake_constructors list of fake constructors

### redefine_operators tells Py++ to redefine operators from base class in this class, False by default Get Method: _get_redefine_operators(self) Set Method: _set_redefine_operators(self, new_value)

### exposed_class_type set this value to CLASS_TYPE.WRAPPER, if you need to transfer ownership ofpolymorphic class Get Method: _get_exposed_class_type(self) Set Method: _set_exposed_class_type(self, class_type)

### held_type string, this property tells Py++ what HeldType this class hasDefault value is calculated, based on information presented in exposed declarations Get Method: _get_held_type(self) Set Method: _set_held_type(self, held_type)

### noncopyable True if the class is noncopyable, False otherwiesDefault value is calculated, based on information presented in the declarations tree Get Method: _get_noncopyable(self) Set Method: _set_noncopyable(self, noncopyable)

### wrapper_alias class-wrapper name Get Method: _get_wrapper_alias(self) Set Method: _set_wrapper_alias(self, walias)

### declaration_code List of strings, that contains valid C++ code, that will be added to the class declaration section

### registration_code_head List of strings, that contains valid C++ code, that will be added to the head of the class registration section

### registration_code_tail List of strings, that contains valid C++ code, that will be added to the tail of the class registration section

### registration_code List of strings, that contains all C++ code, that will be added to the class registration section

### wrapper_code List of strings, that contains valid C++ code, that will be added to the class wrapper.

### null_constructor_body null constructor code, that will be added as is to the null constructor of class-wrapper Get Method: _get_null_constructor_body(self) Set Method: _set_null_constructor_body(self, body)

### copy_constructor_body copy constructor code, that will be added as is to the copy constructor of class-wrapper Get Method: _get_copy_constructor_body(self) Set Method: _set_copy_constructor_body(self, body)

### destructor_code list of code to be added to wrapper destructor

### exception_argument_name exception argument name for translate exception function If you don't understand what this argument is, please take a look on Boost.Python documentation: http://www.boost.org/libs/python/doc/v2/exception_translator.html

### exception_translation_code C++ exception to Python exception translation code Example: PyErr_SetString(PyExc_RuntimeError, exc.what()); Py++ will generate the rest of the code. Pay attention: the exception variable name is exc. Get Method: _get_exception_translation_code(self) Set Method: _set_exception_translation_code(self, code)

### properties list of properties

### require_self_reference boolean, if True the first argument to the constructor will be reference to self object Get Method: _get_require_self_reference(self) Set Method: _set_require_self_reference(self, require_self_reference)

### expose_this boolean, if True an object address( this pointer ) will be exposed to Python as integer. Get Method: _get_expose_this(self) Set Method: _set_expose_this(self, new_value)

### expose_sizeof boolean, if True the sizeof(obj) will be exposed to Python as integer. Get Method: _get_expose_sizeof(self) Set Method: _set_expose_sizeof(self, new_value)

### introduces_new_scope returns True, if during exposing this class, new scope will be created For example, anonymous structs will be exposed in a parent scope.

### no_init If True, class will be registered with 'boost::python::no_init' Get Method: _get_no_init(self) Set Method: _set_no_init(self, value)