Revision: 427
Author: roman_yakovenko
Date: 2006-08-21 01:04:14 -0700 (Mon, 21 Aug 2006)
ViewCVS: http://svn.sourceforge.net/pygccxml/?rev=427&view=rev
Log Message:
-----------
updating documentation strings
Modified Paths:
--------------
pygccxml_dev/pygccxml/declarations/calldef.py
pygccxml_dev/pygccxml/declarations/class_declaration.py
pygccxml_dev/pygccxml/declarations/cpptypes.py
pygccxml_dev/pygccxml/declarations/decl_factory.py
pygccxml_dev/pygccxml/declarations/declaration.py
pygccxml_dev/pygccxml/declarations/enumeration.py
pygccxml_dev/pygccxml/declarations/filtering.py
pygccxml_dev/pygccxml/declarations/mdecl_wrapper.py
pygccxml_dev/pygccxml/declarations/namespace.py
pygccxml_dev/pygccxml/declarations/pattern_parser.py
pygccxml_dev/pygccxml/declarations/scopedef.py
pygccxml_dev/pygccxml/declarations/type_traits.py
pygccxml_dev/pygccxml/declarations/typedef.py
pygccxml_dev/pygccxml/declarations/variable.py
pygccxml_dev/pygccxml/utils/__init__.py
Modified: pygccxml_dev/pygccxml/declarations/calldef.py
===================================================================
--- pygccxml_dev/pygccxml/declarations/calldef.py 2006-08-20 19:53:54 UTC (rev 426)
+++ pygccxml_dev/pygccxml/declarations/calldef.py 2006-08-21 08:04:14 UTC (rev 427)
@@ -8,18 +8,18 @@
This modules contains definition for next C++ declarations:
- operator
- - member
+ - member
- free
- - function
+ - function
- member
- free
- constructor
- destructor
"""
-import cpptypes
+import cpptypes
import algorithm
-import declaration
+import declaration
import type_traits
import call_invocation
@@ -29,7 +29,7 @@
VIRTUAL = 'virtual'
PURE_VIRTUAL = 'pure virtual'
ALL = [NOT_VIRTUAL, VIRTUAL, PURE_VIRTUAL]
-#preserving backward compatebility
+#preserving backward compatebility
FUNCTION_VIRTUALITY_TYPES = VIRTUALITY_TYPES
#First level in hierarchy of calldef
@@ -37,13 +37,13 @@
"""
class, that describes argument of "callable" declaration
"""
-
+
def __init__( self, name='', type=None, default_value=None ):
object.__init__(self)
self._name = name
self._default_value = default_value
self._type = type
-
+
def __str__(self):
if self.default_value==None:
return "%s %s"%(self.type, self.name)
@@ -104,20 +104,20 @@
self._return_type = return_type
self._has_extern = has_extern
self._demangled_name = None
-
+
def _get__cmp__call_items(self):
- """@undocumented _get__cmp__call_items:"""
+ """implementation details"""
raise NotImplementedError()
def _get__cmp__items( self ):
- """@undocumented _get__cmp__items:"""
+ """implementation details"""
items = [ self._sorted_list( self.arguments )
, self.return_type
, self.has_extern
, self._sorted_list( self.exceptions ) ]
items.extend( self._get__cmp__call_items() )
return items
-
+
def __eq__(self, other):
if not declaration.declaration_t.__eq__( self, other ):
return False
@@ -125,7 +125,7 @@
and self.arguments == other.arguments \
and self.has_extern == other.has_extern \
and self._sorted_list( self.exceptions ) \
- == other._sorted_list( other.exceptions )
+ == other._sorted_list( other.exceptions )
def _get_arguments(self):
return self._arguments
@@ -160,7 +160,7 @@
= algorithm.find_all_declarations( self.parent.declarations
, type=calldef_t
, name=self.name
- , recursive=False )
+ , recursive=False )
if not overloaded_funcs:
return overloaded_funcs
overloaded_funcs_ids = map( id, overloaded_funcs )
@@ -178,30 +178,30 @@
doc="""Was this callable declared as "extern"?
@type: bool
""")
-
+
def __remove_parent_fname( self, demangled ):
- """@undocumented __remove_parent_fname:"""
+ """implementation details"""
demangled = demangled.strip()
parent_fname = algorithm.full_name( self.parent )
if parent_fname.startswith( '::' ) and not demangled.startswith( '::' ):
parent_fname = parent_fname[2:]
demangled = demangled[ len( parent_fname ): ]
return demangled
-
+
def _get_demangled_name( self ):
if not self.demangled:
self._demangled_name = ''
-
+
if self._demangled_name:
return self._demangled_name
-
+
if self._demangled_name == '':
return self.name
-
+
demangled = self.demangled
if self.return_type:
return_type = type_traits.remove_alias( self.return_type ).decl_string
-
+
if return_type.startswith( '::' ) and not self.demangled.startswith( '::' ):
return_type = return_type[2:]
demangled = self.demangled
@@ -216,7 +216,7 @@
if demangled_name.startswith( self.name ):
self._demangled_name = demangled_name
return self._demangled_name
-
+
#well, I am going to try an other strategy
fname = algorithm.full_name( self )
found = self.demangled.find( fname )
@@ -238,9 +238,10 @@
#if -1 == found:
self._demangled_name = ''
return self.name
-
- demangled_name = property( _get_demangled_name )
-
+
+ demangled_name = property( _get_demangled_name
+ , doc="returns function demangled name. It can help you to deal with function template instantiations")
+
#Second level in hierarchy of calldef
class member_calldef_t( calldef_t ):
"""base class for "callable" declarations that defined within C++ class or struct"""
@@ -274,9 +275,9 @@
return "%s [%s]"%(res, cls)
def _get__cmp__call_items(self):
- """@undocumented _get__cmp__call_items:"""
+ """implementation details"""
return [ self.virtuality, self.has_static, self.has_const ]
-
+
def __eq__(self, other):
if not calldef_t.__eq__( self, other ):
return False
@@ -289,7 +290,7 @@
def _set_virtuality(self, virtuality):
assert virtuality in VIRTUALITY_TYPES.ALL
self._virtuality = virtuality
- virtuality = property( _get_virtuality, _set_virtuality
+ virtuality = property( _get_virtuality, _set_virtuality
, doc="""Describes the "virtuality" of the member (as defined by the string constants in the class L{VIRTUALITY_TYPES}).
@type: str""")
@@ -326,8 +327,8 @@
def _create_decl_string(self):
return self.function_type().decl_string
-
+
class free_calldef_t( calldef_t ):
"""base class for "callable" declarations that defined within C++ namespace"""
def __init__( self, *args, **keywords ):
@@ -354,7 +355,7 @@
return "%s [%s]"%(res, cls)
def _get__cmp__call_items(self):
- """@undocumented _get__cmp__call_items:"""
+ """implementation details"""
return []
def function_type(self):
@@ -370,12 +371,12 @@
OPERATOR_WORD_LEN = len( 'operator' )
def __init__(self):
object.__init__(self)
-
+
def _get_symbol(self):
return self.name[operator_t.OPERATOR_WORD_LEN:].strip()
symbol = property( _get_symbol,
doc="returns symbol of operator. For example: operator+, symbol is equal to '+'")
-
+
#Third level in hierarchy of calldef
class member_function_t( member_calldef_t ):
"""describes member function declaration"""
@@ -387,8 +388,8 @@
"""describes constructor declaration"""
def __init__( self, *args, **keywords ):
member_calldef_t.__init__( self, *args, **keywords )
-
- def _get_is_copy_constructor(self):
+
+ def _get_is_copy_constructor(self):
args = self.arguments
if 1 != len( args ):
return False
@@ -431,4 +432,4 @@
"""describes free operator declaration"""
def __init__( self, *args, **keywords ):
free_calldef_t.__init__( self, *args, **keywords )
- operator_t.__init__( self, *args, **keywords )
\ No newline at end of file
+ operator_t.__init__( self, *args, **keywords )
Modified: pygccxml_dev/pygccxml/declarations/class_declaration.py
===================================================================
--- pygccxml_dev/pygccxml/declarations/class_declaration.py 2006-08-20 19:53:54 UTC (rev 426)
+++ pygccxml_dev/pygccxml/declarations/class_declaration.py 2006-08-21 08:04:14 UTC (rev 427)
@@ -20,7 +20,7 @@
"""class that defines "access" constants"""
PUBLIC = "public"
PRIVATE = "private"
- PROTECTED = "protected"
+ PROTECTED = "protected"
ALL = [ PUBLIC, PRIVATE, PROTECTED ]
class CLASS_TYPES:
@@ -31,10 +31,9 @@
ALL = [ CLASS, STRUCT, UNION ]
class hierarchy_info_t( object ):
- """
- describes class relationship
- """
+ """describes class relationship"""
def __init__(self, related_class=None, access=None ):
+ """creates class that contains partial information about class relationship"""
if related_class:
assert( isinstance( related_class, class_t ) )
self._related_class = related_class
@@ -78,17 +77,19 @@
class class_declaration_t( declaration.declaration_t ):
"""describes class declaration"""
def __init__( self, name='' ):
+ """creates class that describes C++ class declaration( and not definition )"""
declaration.declaration_t.__init__( self, name )
-
+
def _get__cmp__items(self):
- """@undocumented _get__cmp__items:"""
- return []
+ """implementation details"""
+ return []
class class_t( scopedef.scopedef_t ):
"""describes class definition"""
USE_DEMANGLED_AS_NAME = True
def __init__( self, name='', class_type=CLASS_TYPES.CLASS, is_abstract=False ):
+ """creates class that describes C++ class definition"""
scopedef.scopedef_t.__init__( self, name )
if class_type:
assert( class_type in CLASS_TYPES.ALL )
@@ -100,7 +101,7 @@
self._private_members = []
self._protected_members = []
self._aliases = []
-
+
def _get_name_impl( self ):
if not self._name: #class with empty name
return self._name
@@ -111,13 +112,13 @@
if self.demangled.startswith( fname ):
tmp = self.demangled[ len( fname ): ] #demangled::name
if tmp.startswith( '::' ):
- tmp = tmp[2:]
+ tmp = tmp[2:]
return tmp
else:
return self._name
else:
return self._name
-
+
def __str__(self):
name = algorithm.full_name(self)
if name[:2]=="::":
@@ -125,15 +126,15 @@
return "%s [%s]"%(name, self.class_type)
def _get__cmp__scope_items(self):
- """@undocumented _get__cmp__scope_items:"""
- return [ self.class_type
+ """implementation details"""
+ return [ self.class_type
, self._sorted_list( [ algorithm.declaration_path( base.related_class ) for base in self.bases ] )
, self._sorted_list( [ algorithm.declaration_path( derive.related_class ) for derive in self.derived ] )
- , self.is_abstract
+ , self.is_abstract
, self._sorted_list( self.public_members )
, self._sorted_list( self.private_members )
, self._sorted_list( self.protected_members ) ]
-
+
def __eq__(self, other):
if not scopedef.scopedef_t.__eq__( self, other ):
return False
@@ -177,7 +178,7 @@
return all_bases
recursive_bases = property( _get_recursive_bases
, doc="returns a list of all L{base classes<hierarchy_info_t>}")
-
+
def _get_derived(self):
return self._derived
def _set_derived( self, new_derived ):
@@ -238,12 +239,12 @@
def get_members( self, access=None):
"""
returns list of members according to access type
-
+
If access equals to None, then returned list will contain all members.
-
+
@param access: describes desired members
@type access: L{ACCESS_TYPES}
-
+
@return: [ members ]
"""
if access == ACCESS_TYPES.PUBLIC:
@@ -262,10 +263,10 @@
def set_members( self, access, new_members ):
"""
set list of members according to access type
-
+
@param access: describes desired members
@type access: L{ACCESS_TYPES}
-
+
@param new_members: list of new members
@type new_members: [ L{member<declaration_t>} ]
"""
@@ -278,11 +279,11 @@
self.private_members = new_members
for member in new_members:
member.parent = self
-
+
def remove_declaration( self, decl ):
"""
removes decl from members list
-
+
@param decl: declaration to be removed
@type decl: L{declaration_t}
"""
@@ -299,14 +300,14 @@
#add more comment about this.
#if not keep_parent:
# decl.parent=None
-
+
def find_out_member_access_type( self, member ):
"""
returns member access type
-
+
@param member: member of the class
@type member: L{declaration_t}
-
+
@return: L{ACCESS_TYPES}
"""
assert member.parent is self
@@ -317,4 +318,4 @@
elif member in self.private_members:
return ACCESS_TYPES.PRIVATE
else:
- raise RuntimeError( "Unable to find member within internal members list." )
\ No newline at end of file
+ raise RuntimeError( "Unable to find member within internal members list." )
Modified: pygccxml_dev/pygccxml/declarations/cpptypes.py
===================================================================
--- pygccxml_dev/pygccxml/declarations/cpptypes.py 2006-08-20 19:53:54 UTC (rev 426)
+++ pygccxml_dev/pygccxml/declarations/cpptypes.py 2006-08-21 08:04:14 UTC (rev 427)
@@ -40,27 +40,30 @@
def _clone_impl( self ):
raise NotImplementedError()
-
+
def clone( self ):
"returns new instance of the type"
answer = self._clone_impl()
assert answer
return answer
-
+
#There are cases when GCC-XML reports something like this
#<Unimplemented id="_9482" tree_code="188" tree_code_name="template_type_parm" node="0xcc4d5b0"/>
#In this case I will use this as type
class dummy_type_t( type_t ):
- #This class is very usefull for code generation
+ """provides L{type_t} interface for a string, that defines C++ type.
+
+ This class could be very useful in the code generator.
+ """
def __init__( self, decl_string ):
type_t.__init__( self )
self._decl_string = decl_string
-
+
def _create_decl_string(self):
return self._decl_string
-
+
def _clone_impl( self ):
return dummy_type_t( self._decl_string )
@@ -71,10 +74,10 @@
def _create_decl_string(self):
return '?unknown?'
-
+
def _clone_impl( self ):
- return self
-
+ return self
+
################################################################################
## Fundamental types:
@@ -91,142 +94,168 @@
return self
class java_fundamental_t( fundamental_t ):
+ """base class for all JNI defined fundamental types"""
def __init__( self, name ):
fundamental_t.__init__( self, name )
class void_t( fundamental_t ):
+ """represents void type"""
CPPNAME = 'void'
def __init__( self ):
fundamental_t.__init__( self,void_t.CPPNAME )
class char_t( fundamental_t ):
+ """represents char type"""
CPPNAME = 'char'
def __init__( self ):
fundamental_t.__init__( self, char_t.CPPNAME )
class unsigned_char_t( fundamental_t ):
+ """represents unsigned char type"""
CPPNAME = 'unsigned char'
def __init__( self ):
fundamental_t.__init__( self, unsigned_char_t.CPPNAME )
class wchar_t( fundamental_t ):
+ """represents wchar_t type"""
CPPNAME = 'wchar_t'
def __init__( self ):
fundamental_t.__init__( self, wchar_t.CPPNAME )
class short_int_t( fundamental_t ):
+ """represents short int type"""
CPPNAME = 'short int'
def __init__( self ):
fundamental_t.__init__( self, short_int_t.CPPNAME )
class short_unsigned_int_t( fundamental_t ):
+ """represents short unsigned int type"""
CPPNAME = 'short unsigned int'
def __init__( self ):
fundamental_t.__init__( self, short_unsigned_int_t.CPPNAME )
class bool_t( fundamental_t ):
+ """represents bool type"""
CPPNAME = 'bool'
def __init__( self ):
fundamental_t.__init__( self, bool_t.CPPNAME )
class int_t( fundamental_t ):
+ """represents int type"""
CPPNAME = 'int'
def __init__( self ):
fundamental_t.__init__( self, int_t.CPPNAME )
class unsigned_int_t( fundamental_t ):
+ """represents unsigned int type"""
CPPNAME = 'unsigned int'
def __init__( self ):
fundamental_t.__init__( self, unsigned_int_t.CPPNAME )
class long_int_t( fundamental_t ):
+ """represents long int type"""
CPPNAME = 'long int'
def __init__( self ):
fundamental_t.__init__( self, long_int_t.CPPNAME )
class long_unsigned_int_t( fundamental_t ):
+ """represents long unsigned int type"""
CPPNAME = 'long unsigned int'
def __init__( self ):
fundamental_t.__init__( self, long_unsigned_int_t.CPPNAME )
class long_long_int_t( fundamental_t ):
+ """represents long long int type"""
CPPNAME = 'long long int'
def __init__( self ):
fundamental_t.__init__( self, long_long_int_t.CPPNAME )
class long_long_unsigned_int_t( fundamental_t ):
+ """represents long long unsigned int type"""
CPPNAME = 'long long unsigned int'
def __init__( self ):
fundamental_t.__init__( self, long_long_unsigned_int_t.CPPNAME )
class float_t( fundamental_t ):
+ """represents float type"""
CPPNAME = 'float'
def __init__( self ):
fundamental_t.__init__( self, float_t.CPPNAME )
class double_t( fundamental_t ):
+ """represents double type"""
CPPNAME = 'double'
def __init__( self ):
fundamental_t.__init__( self, double_t.CPPNAME )
class long_double_t( fundamental_t ):
+ """represents long double type"""
CPPNAME = 'long double'
def __init__( self ):
fundamental_t.__init__( self, long_double_t.CPPNAME )
class complex_double_t( fundamental_t ):
+ """represents complex double type"""
CPPNAME = 'complex double'
def __init__( self ):
fundamental_t.__init__( self, complex_double_t.CPPNAME )
class complex_long_double_t( fundamental_t ):
+ """represents complex long double type"""
CPPNAME = 'complex long double'
def __init__( self ):
fundamental_t.__init__( self, complex_long_double_t.CPPNAME )
class complex_float_t( fundamental_t ):
+ """represents complex float type"""
CPPNAME = 'complex float'
def __init__( self ):
fundamental_t.__init__( self, complex_float_t.CPPNAME )
class jbyte_t( java_fundamental_t ):
+ """represents jbyte type"""
JNAME = 'jbyte'
def __init__( self ):
java_fundamental_t.__init__( self, jbyte_t.JNAME )
class jshort_t( java_fundamental_t ):
+ """represents jshort type"""
JNAME = 'jshort'
def __init__( self ):
java_fundamental_t.__init__( self, jshort_t.JNAME )
class jint_t( java_fundamental_t ):
+ """represents jint type"""
JNAME = 'jint'
def __init__( self ):
java_fundamental_t.__init__( self, jint_t.JNAME )
class jlong_t( java_fundamental_t ):
+ """represents jlong type"""
JNAME = 'jlong'
def __init__( self ):
java_fundamental_t.__init__( self, jlong_t.JNAME )
class jfloat_t( java_fundamental_t ):
+ """represents jfloat type"""
JNAME = 'jfloat'
def __init__( self ):
java_fundamental_t.__init__( self, jfloat_t.JNAME )
-
class jdouble_t( java_fundamental_t ):
+ """represents jdouble type"""
JNAME = 'jdouble'
def __init__( self ):
java_fundamental_t.__init__( self, jdouble_t.JNAME )
-
class jchar_t( java_fundamental_t ):
+ """represents jchar type"""
JNAME = 'jchar'
def __init__( self ):
java_fundamental_t.__init__( self, jchar_t.JNAME )
class jboolean_t( java_fundamental_t ):
+ """represents jboolean type"""
JNAME = 'jboolean'
def __init__( self ):
java_fundamental_t.__init__( self, jboolean_t.JNAME )
@@ -271,8 +300,11 @@
, '__java_double' : jdouble_t()
, '__java_char' : jchar_t()
, '__java_boolean' : jboolean_t()
-
}
+"""
+defines a mapping between funcdamental type name and its synonym to the instance
+of class that describes the type
+"""
################################################################################
## Compaund types:
@@ -292,6 +324,7 @@
, doc="reference to internal/base class")
class volatile_t( compound_t ):
+ """represents C{volatile whatever} type"""
def __init__( self, base ):
compound_t.__init__( self, base)
@@ -300,8 +333,9 @@
def _clone_impl( self ):
return volatile_t( self.base.clone() )
-
+
class const_t( compound_t ):
+ """represents C{whatever const} type"""
def __init__( self, base ):
compound_t.__init__( self, base )
@@ -312,6 +346,7 @@
return const_t( self.base.clone() )
class pointer_t( compound_t ):
+ """represents C{whatever*} type"""
def __init__( self, base ):
compound_t.__init__( self, base )
@@ -322,6 +357,7 @@
return pointer_t( self.base.clone() )
class reference_t( compound_t ):
+ """represents C{whatever&} type"""
def __init__( self, base ):
compound_t.__init__( self, base)
@@ -332,6 +368,7 @@
return reference_t( self.base.clone() )
class array_t( compound_t ):
+ """represents C++ array type"""
SIZE_UNKNOWN = -1
def __init__( self, base, size ):
compound_t.__init__( self, base )
@@ -339,7 +376,7 @@
def _get_size(self):
return self._size
- size = property( _get_size,
+ size = property( _get_size,
doc="returns array size" )
def _create_decl_string(self):
@@ -355,7 +392,7 @@
self._return_type = return_type
if arguments_types is None:
arguments_types = []
- self._arguments_types = arguments_types
+ self._arguments_types = arguments_types
def _get_return_type(self):
return self._return_type
@@ -379,45 +416,49 @@
type_t.__init__(self)
calldef_type_t.__init__( self, return_type, arguments_types )
- @staticmethod
+ @staticmethod
def create_decl_string( return_type, arguments_types ):
"""
returns free function type
-
+
@param return_type: function return type
@type return_type: L{type_t}
-
+
@param arguments_types: list of argument L{type<type_t>}
-
+
@return: L{free_function_type_t}
"""
- return free_function_type_t.NAME_TEMPLATE % {
+ return free_function_type_t.NAME_TEMPLATE % {
'return_type' : return_type.decl_string
, 'arguments' : ','.join( map( lambda x: x.decl_string, arguments_types ) ) }
-
+
def _create_decl_string(self):
return self.create_decl_string( self.return_type, self.arguments_types )
def _clone_impl( self ):
rt_clone = None
if self.return_type:
- rt_clone = self.return_type.clone()
+ rt_clone = self.return_type.clone()
return free_function_type_t( rt_clone
, [ arg.clone() for arg in self.arguments_types ] )
#TODO: create real typedef
def create_typedef( self, typedef_name, unused=None):
+ """returns string, that contains valid C++ code, that defines typedef to function type
+
+ @param name: the desired name of typedef
+ """
#unused argument simplifies user code
- return free_function_type_t.TYPEDEF_NAME_TEMPLATE % {
+ return free_function_type_t.TYPEDEF_NAME_TEMPLATE % {
'typedef_name' : typedef_name
- , 'return_type' : self.return_type.decl_string
+ , 'return_type' : self.return_type.decl_string
, 'arguments' : ','.join( map( lambda x: x.decl_string, self.arguments_types ) ) }
-
+
class member_function_type_t( type_t, calldef_type_t ):
"""describes member function type"""
NAME_TEMPLATE = '%(return_type)s ( %(class)s::* )( %(arguments)s ) %(has_const)s'
TYPEDEF_NAME_TEMPLATE = '%(return_type)s ( %(class)s::*%(typedef_name)s )( %(arguments)s ) %(has_const)s'
-
+
def __init__( self, class_inst=None, return_type=None, arguments_types=None, has_const=False):
type_t.__init__(self)
calldef_type_t.__init__( self, return_type, arguments_types )
@@ -429,7 +470,7 @@
def _set_has_const(self, has_const ):
self._has_const = has_const
has_const = property( _get_has_const, _set_has_const
- , doc="describes, whether function has const modifier")
+ , doc="describes, whether function has const modifier")
def _get_class_inst(self):
return self._class_inst
@@ -440,9 +481,8 @@
#TODO: create real typedef
def create_typedef( self, typedef_name, class_alias=None):
- """
- creates typedef to the function type
-
+ """creates typedef to the function type
+
@param typedef_name: desired type name
@return: string
"""
@@ -451,12 +491,12 @@
has_const_str = 'const'
if None is class_alias:
class_alias = self.class_inst.decl_string
- return member_function_type_t.TYPEDEF_NAME_TEMPLATE % {
+ return member_function_type_t.TYPEDEF_NAME_TEMPLATE % {
'typedef_name' : typedef_name
- , 'return_type' : self.return_type.decl_string
+ , 'return_type' : self.return_type.decl_string
, 'class' : class_alias
, 'arguments' : ','.join( map( lambda x: x.decl_string, self.arguments_types ) )
- , 'has_const' : has_const_str }
+ , 'has_const' : has_const_str }
def create(self):
return self.create_decl_string( self.return_type
@@ -465,7 +505,7 @@
, self.has_const )
- @staticmethod
+ @staticmethod
def create_decl_string(return_type, class_decl_string, arguments_types, has_const):
has_const_str = ''
if has_const:
@@ -473,12 +513,12 @@
return_type_decl_string = ''
if return_type:
return_type_decl_string = return_type.decl_string
- return member_function_type_t.NAME_TEMPLATE % {
- 'return_type' : return_type_decl_string
+ return member_function_type_t.NAME_TEMPLATE % {
+ 'return_type' : return_type_decl_string
, 'class' : class_decl_string
, 'arguments' : ','.join( map( lambda x: x.decl_string, arguments_types ) )
- , 'has_const' : has_const_str }
-
+ , 'has_const' : has_const_str }
+
def _create_decl_string(self):
return self.create_decl_string( self.return_type
, self.class_inst.decl_string
@@ -489,19 +529,19 @@
rt_clone = None
if self.return_type:
rt_clone = self.return_type.clone()
-
+
return member_function_type_t( self.class_inst
, rt_clone
, [ arg.clone() for arg in self.arguments_types ]
, self.has_const )
-
+
class member_variable_type_t( compound_t ):
"""describes member variable type"""
NAME_TEMPLATE = '%(type)s ( %(class)s::* )'
def __init__( self, class_inst=None, variable_type=None ):
compound_t.__init__(self, class_inst)
- self._mv_type = variable_type
+ self._mv_type = variable_type
def _get_variable_type(self):
return self._mv_type
@@ -516,13 +556,13 @@
def _clone_impl( self ):
return member_variable_type_t( class_inst=self.base
, variable_type=self.variable_type.clone() )
-
+
################################################################################
## declarated types:
class declarated_t( type_t ):
- """describes type declared by user"""
+ """class that binds between to hierarchies: L{type_t} and L{declaration_t}"""
def __init__( self, declaration ):
type_t.__init__( self )
self._declaration = declaration
@@ -541,6 +581,7 @@
return declarated_t( self.declaration )
class type_qualifiers_t( object ):
+ """contains additional information about type: mutable, static, extern"""
def __init__(self, has_static=False, has_mutable=False ):
self._has_static = has_static
self._has_mutable = has_mutable
@@ -572,15 +613,3 @@
def _set_has_mutable(self, has_mutable ):
self._has_mutable = has_mutable
has_mutable = property( _get_has_mutable, _set_has_mutable )
-
- #~ def apply_qualifiers( qualifiers, type ):
- #~ result = []
- #~ if qualifiers.has_static:
- #~ result.append( 'static' )
- #~ if qualifiers.has_mutable:
- #~ result.append( 'mutable' )
- #~ if isinstance( type, type_t ):
- #~ result.append( type.decl_string )
- #~ else:
- #~ result.append( type )
- #~ return ' '.join( result )
Modified: pygccxml_dev/pygccxml/declarations/decl_factory.py
===================================================================
--- pygccxml_dev/pygccxml/declarations/decl_factory.py 2006-08-20 19:53:54 UTC (rev 426)
+++ pygccxml_dev/pygccxml/declarations/decl_factory.py 2006-08-21 08:04:14 UTC (rev 427)
@@ -4,7 +4,7 @@
# http://www.boost.org/LICENSE_1_0.txt)
"""
-defines declarations factory class
+defines default declarations factory class
"""
from calldef import member_function_t
@@ -26,43 +26,57 @@
declarations factory class
"""
def __init__(self):
+ """creates declarations factory"""
object.__init__(self)
-
+
def create_member_function( self, *arguments, **keywords ):
+ """creates instance of class that describes member function declaration"""
return member_function_t(*arguments, **keywords)
-
+
def create_constructor( self, *arguments, **keywords ):
+ """creates instance of class that describes constructor declaration"""
return constructor_t(*arguments, **keywords)
-
+
def create_destructor( self, *arguments, **keywords ):
+ """creates instance of class that describes destructor declaration"""
return destructor_t(*arguments, **keywords)
-
+
def create_member_operator( self, *arguments, **keywords ):
+ """creates instance of class that describes member operator declaration"""
return member_operator_t(*arguments, **keywords)
-
+
def create_casting_operator( self, *arguments, **keywords ):
+ """creates instance of class that describes casting operator declaration"""
return casting_operator_t(*arguments, **keywords)
-
+
def create_free_function( self, *arguments, **keywords ):
+ """creates instance of class that describes free function declaration"""
return free_function_t(*arguments, **keywords)
-
+
def create_free_operator( self, *arguments, **keywords ):
+ """creates instance of class that describes free operator declaration"""
return free_operator_t(*arguments, **keywords)
def create_class_declaration(self, *arguments, **keywords ):
+ """creates instance of class that describes class declaration"""
return class_declaration_t(*arguments, **keywords)
-
+
def create_class( self, *arguments, **keywords ):
+ """creates instance of class that describes class definition declaration"""
return class_t(*arguments, **keywords)
-
+
def create_enumeration( self, *arguments, **keywords ):
+ """creates instance of class that describes enumeration declaration"""
return enumeration_t(*arguments, **keywords)
-
+
def create_namespace( self, *arguments, **keywords ):
+ """creates instance of class that describes namespace declaration"""
return namespace_t(*arguments, **keywords)
-
+
def create_typedef( self, *arguments, **keywords ):
+ """creates instance of class that describes typedef declaration"""
return typedef_t(*arguments, **keywords)
-
+
def create_variable( self, *arguments, **keywords ):
+ """creates instance of class that describes variable declaration"""
return variable_t(*arguments, **keywords)
Modified: pygccxml_dev/pygccxml/declarations/declaration.py
===================================================================
--- pygccxml_dev/pygccxml/declarations/declaration.py 2006-08-20 19:53:54 UTC (rev 426)
+++ pygccxml_dev/pygccxml/declarations/declaration.py 2006-08-21 08:04:14 UTC (rev 427)
@@ -15,8 +15,7 @@
class location_t(object):
-
- """Provides information about the location of the declaration within the source file.
+ """provides information about the location of the declaration within the source file.
The header file name and the line number of the declaration can be
accessed via the attributes C{file_name} and C{line}.
@@ -57,7 +56,7 @@
, doc="""The line number where the declaration was found
@type: int
""")
-
+
def as_tuple( self ):
"""Return the header file name and the line number.
@@ -68,7 +67,7 @@
class declaration_t( object ):
"""Base class for all classes that represent a C++ declaration.
"""
-
+
def __init__( self, name='', location=None, is_artificial=False, mangled=None, demangled=None ):
self._name = name
self._location = location
@@ -94,25 +93,25 @@
# Append the declaration class
cls = self.__class__.__name__
if cls[-2:]=="_t":
- cls = cls[:-2]
+ cls = cls[:-2]
return "%s [%s]"%(name, cls)
- @staticmethod
+ @staticmethod
def _sorted_list( some_list ):
- """@undocumented _sorted_list:"""
+ """implementation details"""
some_list.sort()
return some_list
def _get__cmp__items( self ):
- """@undocumented _get__cmp__items:"""
- #Every derived class should implement this method. This method should
+ """implementation details"""
+ #Every derived class should implement this method. This method should
#return a list of items, that should be compared.
print '_get__cmp__items not implemented for class ', self.__class__.__name__
raise NotImplemented()
def _get__cmp__data(self):
- """@undocumented _get__cmp__data:"""
+ """implementation details"""
data = [ algorithm.declaration_path( self.parent ), self.name, self.location ]
data.extend( self._get__cmp__items() )
return data
@@ -120,8 +119,8 @@
def __eq__(self, other):
"""
function will return true, if both declarations refers to the same object.
- This function could be implemented in terms of _get__cmp__data, but in
- this case it will downgrade performance. self.mangled property is not
+ This function could be implemented in terms of _get__cmp__data, but in
+ this case it will downgrade performance. self.mangled property is not
compared, because it could be chaned from one compilation time to an
other.
"""
@@ -145,13 +144,13 @@
if not isinstance( other, self.__class__ ):
return self.__class__.__name__ < other.__class__.__name__
return self._get__cmp__data() < other._get__cmp__data()
-
+
def _get_name_impl( self ):
return self._name
-
+
def _get_name( self ):
return self._get_name_impl()
-
+
def _set_name( self, new_name ):
self._name = new_name
name = property( _get_name, _set_name
@@ -222,10 +221,10 @@
def _create_decl_string(self):
return algorithm.full_name( self )
-
+
def _decl_string(self):
- return self._create_decl_string()
+ return self._create_decl_string()
decl_string = property( _decl_string,
doc="""Full name of the declaration
@type: str
- """ )
\ No newline at end of file
+ """ )
Modified: pygccxml_dev/pygccxml/declarations/enumeration.py
===================================================================
--- pygccxml_dev/pygccxml/declarations/enumeration.py 2006-08-20 19:53:54 UTC (rev 426)
+++ pygccxml_dev/pygccxml/declarations/enumeration.py 2006-08-21 08:04:14 UTC (rev 427)
@@ -16,11 +16,11 @@
describes C++ enum
"""
def __init__( self, name='', values=None ):
- """Constructor.
+ """creates class that describes C++ enum declaration
The items of the list 'values' may either be strings containing
the enumeration value name or tuples (name, numvalue).
-
+
@param name: Enum name
@type name: str
@param parent: Parent declaration
@@ -43,7 +43,7 @@
return self.values == other.values
def _get__cmp__items( self ):
- """@undocumented _get__cmp__items:"""
+ """implementation details"""
return [self.values]
def _get_values(self):
@@ -108,7 +108,8 @@
return False
def get_name2value_dict( self ):
+ """returns a dictionary, that maps between enum name( key ) and enum value( value )"""
x = {}
for val, num in self._values:
x[val] = num
- return x
\ No newline at end of file
+ return x
Modified: pygccxml_dev/pygccxml/declarations/filtering.py
===================================================================
--- pygccxml_dev/pygccxml/declarations/filtering.py 2006-08-20 19:53:54 UTC (rev 426)
+++ pygccxml_dev/pygccxml/declarations/filtering.py 2006-08-21 08:04:14 UTC (rev 427)
@@ -4,41 +4,44 @@
# http://www.boost.org/LICENSE_1_0.txt)
"""
-defines few algorithms for filtering declarations
+deprecated!
+
+This module defines few algorithms for filtering declarations.
"""
import os
import algorithm
class filtering:
- """
+ """deprecated!
+
defines few algorithms for filtering declarations
"""
-
- @staticmethod
+
+ @staticmethod
def normalize_path( some_path ):
"""return os.path.normcase( os.path.normpath( some_path ) )"""
return os.path.normcase( os.path.normpath( some_path ) )
-
- @staticmethod
+
+ @staticmethod
def contains_parent_dir( fpath, dirs ):
#precondition: dirs and fpath should be normalize_path'ed before calling this function
return bool( filter( lambda dir: fpath.startswith( dir ), dirs ) )
-
- @staticmethod
- def by_location( decls, locations ):
+
+ @staticmethod
+ def by_location( decls, locations ):
"""
returns list of declarations that belongs to specified locations.
-
+
This function works recursively. Pay attention: if you remove namespace,
then you remove all declarations defined within the namespace.
-
+
@param decls: declaration or list of declarations
@type decls: L{declaration<declaration_t>} or list of L{declarations<declaration_t>}
-
+
@param locations: list of directories and/or files names
@type locations: list of strings
-
+
@return: list of L{declarations<declaration_t>}
"""
#precondition: decls is a list of op level namespaces
@@ -48,7 +51,7 @@
dirs = filter( lambda location: os.path.isdir( location ), locations )
files = filter( lambda location: os.path.isfile( location ), locations )
result = []
- for decl in temp_decls:
+ for decl in temp_decls:
if not decl.location:
result.append( decl )
continue
@@ -57,21 +60,20 @@
result.append( decl )
return result
- @staticmethod
+ @staticmethod
def user_defined( decls, matcher ):
"""
returns list of declarations that match user specified criteria.
-
+
This function works recursively.
-
+
@param decls: declaration or list of declarations
@type decls: L{declaration<declaration_t>} or list of L{declarations<declaration_t>}
-
+
@param matcher: callable object, that takes 1 argument - declaration
and returns True if object should stay, and false otherwise
-
+
@return: list of L{declarations<declaration_t>}
- """
+ """
#precondition: decls is a list of op level namespaces
return filter( matcher, algorithm.make_flatten( decls ) )
-
\ No newline at end of file
Modified: pygccxml_dev/pygccxml/declarations/mdecl_wrapper.py
===================================================================
--- pygccxml_dev/pygccxml/declarations/mdecl_wrapper.py 2006-08-20 19:53:54 UTC (rev 426)
+++ pygccxml_dev/pygccxml/declarations/mdecl_wrapper.py 2006-08-21 08:04:14 UTC (rev 427)
@@ -3,32 +3,45 @@
# accompanying file LICENSE_1_0.txt or copy at
# http://www.boost.org/LICENSE_1_0.txt)
+"""
+defines class L{mdecl_wrapper_t} that allows to work on set of declarations,
+as it was one declaration.
+
+The L{class<mdecl_wrapper_t>} allows user to not write "for" loops within the code.
+"""
+
class call_redirector_t( object ):
"""Internal class used to call some function of objects"""
def __init__( self, name, decls ):
+ """creates call_redirector_t instance.
+
+ @param name: name of method, to be called on every object in C{decls} list
+ @param decls: list of objects
+ """
object.__init__( self )
self.name = name
self.decls = decls
-
+
def __call__( self, *arguments, **keywords ):
+ """calls method C{self.name} on every object within C{self.decls} list"""
for d in self.decls:
callable_ = getattr(d, self.name)
callable_( *arguments, **keywords )
class mdecl_wrapper_t( object ):
- """Multiple declarations wrapper.
-
- The main purpose of this class is to allow an user to work on many
- declarations, as they were only one single declaration.
-
- Example:
+ """Multiple declarations wrapper.
+
+ The main purpose of this class is to allow an user to work on many
+ declarations, as they were only one single declaration.
+
+ Example:
mb = module_builder_t( ... )
#lets say we want to exclude all member functions, that returns reference to int:
mb.member_functions( return_type='int &' ).exclude()
-
+
"exclude" function will be called on every function that match the criteria.
"""
-
+
def __init__( self, decls ):
"""@param decls: list of declarations to operate on.
@type decls: list of L{declaration wrappers<decl_wrapper_t>}
@@ -42,19 +55,19 @@
def __len__( self ):
"""returns the number of declarations"""
return len( self.decls )
-
+
def __getitem__( self, index ):
"""provides access to declaration"""
return self.decls[index]
-
+
def __iter__( self ):
return iter(self.decls)
-
+
def __ensure_attribute( self, name ):
invalid_decls = filter( lambda d: not hasattr( d, name ), self.decls )
if invalid_decls:
raise RuntimeError( "Not all declarations have '%s' attribute." % name )
-
+
def __setattr__( self, name, value ):
"""Updates the value of attribute on all declarations.
@param name: name of attribute
@@ -63,11 +76,11 @@
self.__ensure_attribute( name )
for d in self.decls:
setattr( d, name, value )
-
+
def __getattr__( self, name ):
"""@param name: name of method
"""
return call_redirector_t( name, self.decls )
-
+
def __contains__( self, item ):
- return item in self.decls
\ No newline at end of file
+ return item in self.decls
Modified: pygccxml_dev/pygccxml/declarations/namespace.py
===================================================================
--- pygccxml_dev/pygccxml/declarations/namespace.py 2006-08-20 19:53:54 UTC (rev 426)
+++ pygccxml_dev/pygccxml/declarations/namespace.py 2006-08-21 08:04:14 UTC (rev 427)
@@ -3,9 +3,8 @@
# accompanying file LICENSE_1_0.txt or copy at
# http://www.boost.org/LICENSE_1_0.txt)
-"""
-defines class, that describes C++ namespace
-"""
+"""defines class, that describes C++ namespace declaration"""
+
import declaration
import scopedef
import algorithm
@@ -14,8 +13,9 @@
"""
describes C++ namespace
"""
-
+
def __init__( self, name='', declarations=None ):
+ """creates class that describes C++ namespace declaration"""
scopedef.scopedef_t.__init__( self, name )
if not declarations:
declarations = []
@@ -28,15 +28,17 @@
return "%s [namespace]"%name
def _get__cmp__scope_items(self):
- """@undocumented _get__cmp__scope_items:"""
+ """implementation details"""
return [ self._sorted_list( self.declarations ) ]
-
+
def _get_declarations_impl(self):
return self._declarations
def _set_declarations(self, declarations):
self._declarations = declarations
- declarations = property( scopedef.scopedef_t._get_declarations, _set_declarations )
-
+ declarations = property( scopedef.scopedef_t._get_declarations
+ , _set_declarations
+ , doc="list of all declarations, defined in the namespace")
+
def take_parenting( self, inst ):
"""Takes parenting from inst and transfers it to self"""
if self is inst:
@@ -45,11 +47,11 @@
decl.parent = self
self.declarations.append( decl )
inst.declarations = []
-
+
def remove_declaration( self, decl ):
"""
removes decl from members list
-
+
@param decl: declaration to be removed
@type decl: L{declaration_t}
"""
@@ -59,12 +61,14 @@
# decl.parent=None
def namespace( self, name=None, function=None, recursive=None ):
+ """returns reference to namespace declaration, that is matched defined criterias"""
return self._find_single( scopedef.scopedef_t._impl_matchers[ namespace_t.namespace ]
, name=name
, function=function
, recursive=recursive )
def namespaces( self, name=None, function=None, recursive=None, allow_empty=None ):
+ """returns a set of namespace declarations, that are matched defined criterias"""
return self._find_multiple( scopedef.scopedef_t._impl_matchers[ namespace_t.namespace ]
, name=name
, function=function
@@ -72,51 +76,54 @@
, allow_empty=allow_empty)
def free_function( self, name=None, function=None, return_type=None, arg_types=None, header_dir=None, header_file=None, recursive=None ):
+ """returns reference to free function declaration, that is matched defined criterias"""
return self._find_single( scopedef.scopedef_t._impl_matchers[ namespace_t.free_function ]
, name=name
, function=function
, decl_type=self._impl_decl_types[ namespace_t.free_function ]
, return_type=return_type
- , arg_types=arg_types
+ , arg_types=arg_types
, header_dir=header_dir
- , header_file=header_file
+ , header_file=header_file
, recursive=recursive )
def free_functions( self, name=None, function=None, return_type=None, arg_types=None, header_dir=None, header_file=None, recursive=None, allow_empty=None ):
+ """returns a set of free function declarations, that are matched defined criterias"""
return self._find_multiple( scopedef.scopedef_t._impl_matchers[ namespace_t.free_function ]
, name=name
, function=function
, decl_type=self._impl_decl_types[ namespace_t.free_function ]
, return_type=return_type
- , arg_types=arg_types
+ , arg_types=arg_types
, header_dir=header_dir
, header_file=header_file
, recursive=recursive
, allow_empty=allow_empty)
def free_operator( self, name=None, function=None, symbol=None, return_type=None, arg_types=None, header_dir=None, header_file=None, recursive=None ):
+ """returns reference to free operator declaration, that is matched defined criterias"""
return self._find_single( scopedef.scopedef_t._impl_matchers[ namespace_t.free_operator ]
, name=self._build_operator_name( name, function, symbol )
, symbol=symbol
, function=function
, decl_type=self._impl_decl_types[ namespace_t.free_operator ]
, return_type=return_type
- , arg_types=arg_types
+ , arg_types=arg_types
, header_dir=header_dir
- , header_file=header_file
+ , header_file=header_file
, recursive=recursive )
def free_operators( self, name=None, function=None, symbol=None, return_type=None, arg_types=None, header_dir=None, header_file=None, recursive=None, allow_empty=None ):
+ """returns a set of free operator declarations, that are matched defined criterias"""
return self._find_multiple( scopedef.scopedef_t._impl_matchers[ namespace_t.free_operator ]
, name=self._build_operator_name( name, function, symbol )
, symbol=symbol
, function=function
, decl_type=self._impl_decl_types[ namespace_t.free_operator ]
, return_type=return_type
- , arg_types=arg_types
+ , arg_types=arg_types
, header_dir=header_dir
- , header_file=header_file
+ , header_file=header_file
, recursive=recursive
, allow_empty=allow_empty)
-
-
\ No newline at end of file
+
Modified: pygccxml_dev/pygccxml/declarations/pattern_parser.py
===================================================================
--- pygccxml_dev/pygccxml/declarations/pattern_parser.py 2006-08-20 19:53:54 UTC (rev 426)
+++ pygccxml_dev/pygccxml/declarations/pattern_parser.py 2006-08-21 08:04:14 UTC (rev 427)
@@ -3,13 +3,12 @@
# accompanying file LICENSE_1_0.txt or copy at
# http://www.boost.org/LICENSE_1_0.txt)
-"""
-implementation details
-"""
+"""implementation details"""
import types
class parser_t( object ):
+ """implementation details"""
def __init__( self
, pattern_char_begin
, pattern_char_end
@@ -21,12 +20,14 @@
self.__text_qualifier = '"'
self.__char_qualifier = "'"
self.__escape = '\\'
-
- def has_pattern( self, decl_string ):
+
+ def has_pattern( self, decl_string ):
+ """implementation details"""
last_part = decl_string.split( '::' )[-1]
return -1 != last_part.find( self.__end )
def name( self, decl_string ):
+ """implementation details"""
assert isinstance( decl_string, types.StringTypes )
if not self.has_pattern( decl_string ):
return decl_string
@@ -34,6 +35,7 @@
return decl_string[0: args_begin].strip()
def __find_args_separator( self, decl_string, start_pos ):
+ """implementation details"""
bracket_depth = 0
for index, ch in enumerate( decl_string[start_pos:] ):
if ch not in ( self.__begin, self.__end, self.__separator ):
@@ -50,12 +52,13 @@
return -1
def args( self, decl_string ):
+ """implementation details"""
args_begin = decl_string.find( self.__begin )
args_end = decl_string.rfind( self.__end )
if -1 in ( args_begin, args_end ) or args_begin == args_end:
raise RuntimeError( "%s doesn't valid template instantiation string" % decl_string )
-
- args_only = decl_string[args_begin + 1: args_end ]
+
+ args_only = decl_string[args_begin + 1: args_end ]
args = []
previous_found, found = 0, 0
while True:
@@ -71,10 +74,13 @@
return [ arg.strip() for arg in args ]
NOT_FOUND = ( -1, -1 )
+ """implementation details"""
+
def find_args(self, text, start=None ):
+ """implementation details"""
if start==None:
start = 0
- first_occurance = text.find( self.__begin, start )
+ first_occurance = text.find( self.__begin, start )
if first_occurance == -1:
return self.NOT_FOUND
previous_found, found = first_occurance + 1, 0
@@ -88,11 +94,13 @@
previous_found = found + 1 #skip found sep
def split( self, decl_string ):
+ """implementation details"""
assert self.has_pattern( decl_string )
return self.name( decl_string ), self.args( decl_string )
-
+
def split_recursive( self, decl_string ):
- assert self.has_pattern( decl_string )
+ """implementation details"""
+ assert self.has_pattern( decl_string )
answer = []
to_go = [ decl_string ]
while to_go:
@@ -102,8 +110,9 @@
if self.has_pattern( arg ):
to_go.append( arg )
return answer
-
+
def join( self, name, args ):
+ """implementation details"""
args = filter( None, args)
args_str = ''
if not args:
@@ -112,5 +121,6 @@
args_str = ' ' + args[0] + ' '
else:
args_str = ' ' + ', '.join( args ) + ' '
-
- return ''.join( [ name, self.__begin, args_str, self.__end ] )
\ No newline at end of file
+
+ return ''.join( [ name, self.__begin, args_str, self.__end ] )
+
Modified: pygccxml_dev/pygccxml/declarations/scopedef.py
===================================================================
--- pygccxml_dev/pygccxml/declarations/scopedef.py 2006-08-20 19:53:54 UTC (rev 426)
+++ pygccxml_dev/pygccxml/declarations/scopedef.py 2006-08-21 08:04:14 UTC (rev 427)
@@ -21,51 +21,51 @@
This is the base class for all declaration classes that may have
children nodes. The children can be accessed via the C{declarations}
property.
-
+
Also this class provides "get/select/find" interface. Using this class you
- can get instance or instances of internal declaration(s).
-
+ can get instance or instances of internal declaration(s).
+
You can find declaration(s) using next criteria:
1. name - declaration name, could be full qualified name
2. header_dir - directory, to which belongs file, that the declaration was declarated in.
- header_dir should be absolute path.
+ header_dir should be absolute path.
3. header_file - file that the declaration was declarated in.
4. function - user ( your ) custom criteria. The interesting thing is that
this function will be joined with other arguments ( criteria ).
5. recursive - the search declaration range, if True will be search in
internal declarations too.
-
+
Every "select" API you can invoke and pass as first argument at declaration
name or function. This class will find out correctly what argument represents.
-
+
Example::
ns - referrers to global namespace
ns.member_function( "do_something ) - will return reference to member
function named "do_something". If there is no such function exception
will be raised. If there is more then one function exception will be
raised too.
-
+
Example 2::
ns - referers to global namespace
- do_smths = ns.member_functions( "do_something ) - will return instance
+ do_smths = ns.member_functions( "do_something ) - will return instance
of L{mdecl_wrapper_t} object. This object allows you few things:
-
+
1. To iterate on selected declarations
2. To set some property to desired value using one line of code only:
do_smths.call_policies = x
3. To call some function on every instance using one line of code:
do_smths.exclude()
-
- Pay attention: you can not use "get" functions or properties.
+
+ Pay attention: you can not use "get" functions or properties.
"""
- RECURSIVE_DEFAULT = True
+ RECURSIVE_DEFAULT = True
ALLOW_EMPTY_MDECL_WRAPPER = False
-
+
_impl_matchers = {} #this class variable is used to prevent recursive imports
_impl_decl_types = {} #this class variable is used to prevent recursive imports
_impl_all_decl_types = [] #this class variable is used to prevent recursive imports
-
+
def __init__( self, name=''):
declaration.declaration_t.__init__( self, name )
@@ -78,18 +78,18 @@
def _get_logger( self ):
return utils.loggers.queries_engine
- _logger = property( _get_logger )
-
+ _logger = property( _get_logger, doc="reference to C{queries_engine} logger" )
+
def _get__cmp__scope_i...
[truncated message content] |