[pygccxml-commit] source/pygccxml/declarations mdecl_wrapper.py,NONE,1.1 __init__.py,1.37,1.38 namespace.py,1.10,1.11 scopedef.py,1.10,1.11

[Roman <rom...@us...>]

Update of /cvsroot/pygccxml/source/pygccxml/declarations
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv1204/pygccxml/declarations

Modified Files:
	__init__.py namespace.py scopedef.py 
Added Files:
	mdecl_wrapper.py 
Log Message:
moving select interface to pygccxml classes. 
Previous code should work unchanged, because I just moved it in hierarchy tree.

--- NEW FILE: mdecl_wrapper.py ---
# Copyright 2004 Roman Yakovenko.
# Distributed under the Boost Software License, Version 1.0. (See
# accompanying file LICENSE_1_0.txt or copy at
# http://www.boost.org/LICENSE_1_0.txt)

class call_redirector_t( object ):
    """Internal class used to call some function of objects"""
    def __init__( self, name, decls ):
        object.__init__( self )
        self.name = name
        self.decls = decls
            
    def __call__( self, *arguments, **keywords ):
        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: 
    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>}
        """
        object.__init__( self )
        self.__dict__['_decls'] = decls

    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 __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
        @param value: new value of attribute
        """
        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 )
Index: namespace.py
===================================================================
RCS file: /cvsroot/pygccxml/source/pygccxml/declarations/namespace.py,v
retrieving revision 1.10
retrieving revision 1.11
diff -C2 -d -r1.10 -r1.11
*** namespace.py	22 Mar 2006 10:38:29 -0000	1.10
--- namespace.py	20 Apr 2006 10:11:25 -0000	1.11
***************
*** 57,58 ****
--- 57,116 ----
          #if not keep_parent:
          #    decl.parent=None
+ 
+     def namespace( self, name=None, function=None, recursive=None ):
+         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 ):
+         return self._find_multiple( scopedef.scopedef_t._impl_matchers[ namespace_t.namespace ]
+                                     , name=name
+                                     , function=function
+                                     , recursive=recursive )
+ 
+     def free_function( self, name=None, function=None, return_type=None, arg_types=None, header_dir=None, header_file=None, recursive=None ):
+         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 
+                                   , header_dir=header_dir
+                                   , 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 ):
+         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 
+                                     , header_dir=header_dir
+                                     , header_file=header_file
+                                     , recursive=recursive)
+ 
+     def free_operator( self, name=None, function=None, symbol=None, return_type=None, arg_types=None, header_dir=None, header_file=None, recursive=None ):
+         return self._find_single( scopedef.scopedef_t._impl_matchers[ namespace_t.free_operator ]
+                                   , name=name
+                                   , symbol=symbol
+                                   , function=function
+                                   , decl_type=self._impl_decl_types[ namespace_t.free_operator ]
+                                   , return_type=return_type
+                                   , arg_types=arg_types 
+                                   , header_dir=header_dir
+                                   , 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 ):
+         return self._find_multiple( scopedef.scopedef_t._impl_matchers[ namespace_t.free_operator ]
+                                     , name=name
+                                     , symbol=symbol
+                                     , function=function
+                                     , decl_type=self._impl_decl_types[ namespace_t.free_operator ]
+                                     , return_type=return_type
+                                     , arg_types=arg_types 
+                                     , header_dir=header_dir
+                                     , header_file=header_file 
+                                     , recursive=recursive )
\ No newline at end of file

Index: __init__.py
===================================================================
RCS file: /cvsroot/pygccxml/source/pygccxml/declarations/__init__.py,v
retrieving revision 1.37
retrieving revision 1.38
diff -C2 -d -r1.37 -r1.38
*** __init__.py	16 Mar 2006 06:31:29 -0000	1.37
--- __init__.py	20 Apr 2006 10:11:25 -0000	1.38
***************
*** 149,152 ****
  from matcher import matcher
  
  from decl_printer import decl_printer_t
! from decl_printer import print_declarations
\ No newline at end of file
--- 149,229 ----
  from matcher import matcher
  
+ from mdecl_wrapper import mdecl_wrapper_t
+ 
  from decl_printer import decl_printer_t
! from decl_printer import print_declarations
! 
! 
! #implementation details: I need this trick in order to prevent recursive imports
! import scopedef
! 
! scopedef.scopedef_t._impl_all_decl_types = [
!     scopedef.scopedef_t
!     , enumeration_t
!     , namespace_t
!     , class_t
!     , class_declaration_t
!     , typedef_t
!     , variable_t
!     , calldef_t
!     , member_calldef_t
!     , free_calldef_t
!     , operator_t
!     , member_function_t
!     , constructor_t
!     , destructor_t
!     , member_operator_t
!     , casting_operator_t
!     , free_function_t
!     , free_operator_t 
! ]
! 
! impl_matchers = scopedef.scopedef_t._impl_matchers
! impl_decl_types = scopedef.scopedef_t._impl_decl_types
! 
! impl_matchers[ scopedef.scopedef_t.decl ] = declaration_matcher_t
! 
! impl_matchers[ scopedef.scopedef_t.class_ ] = declaration_matcher_t
! impl_decl_types[ scopedef.scopedef_t.class_ ] = class_t
! 
! impl_matchers[ scopedef.scopedef_t.variable ] = variable_matcher_t
! 
! impl_matchers[ scopedef.scopedef_t.calldef ] = calldef_matcher_t
! impl_decl_types[ scopedef.scopedef_t.calldef ] = calldef_t
! 
! impl_matchers[ scopedef.scopedef_t.operator ] = operator_matcher_t
! 
! impl_matchers[ scopedef.scopedef_t.member_function ] = calldef_matcher_t
! impl_decl_types[ scopedef.scopedef_t.member_function ] = member_function_t
! 
! impl_matchers[ scopedef.scopedef_t.constructor ] = calldef_matcher_t
! impl_decl_types[ scopedef.scopedef_t.constructor ] = constructor_t
! 
! impl_matchers[ scopedef.scopedef_t.member_operator ] = operator_matcher_t
! impl_decl_types[ scopedef.scopedef_t.member_operator ] = member_operator_t
! 
! impl_matchers[ scopedef.scopedef_t.member_operator ] = operator_matcher_t
! impl_decl_types[ scopedef.scopedef_t.member_operator ] = member_operator_t
! 
! impl_matchers[ scopedef.scopedef_t.casting_operator ] = calldef_matcher_t
! impl_decl_types[ scopedef.scopedef_t.casting_operator ] = casting_operator_t
! 
! impl_matchers[ scopedef.scopedef_t.enumeration ] = declaration_matcher_t
! impl_decl_types[ scopedef.scopedef_t.enumeration ] = enumeration_t
! 
! impl_matchers[ namespace_t.namespace ] = namespace_matcher_t
! 
! impl_matchers[ namespace_t.free_function ] = calldef_matcher_t
! impl_decl_types[ namespace_t.free_function ] = free_function_t
! 
! impl_matchers[ namespace_t.free_operator ] = operator_matcher_t
! impl_decl_types[ namespace_t.free_operator ] = free_operator_t
! 
! 
! 
! 
! 
! 
! 
! 
! 

Index: scopedef.py
===================================================================
RCS file: /cvsroot/pygccxml/source/pygccxml/declarations/scopedef.py,v
retrieving revision 1.10
retrieving revision 1.11
diff -C2 -d -r1.10 -r1.11
*** scopedef.py	15 Mar 2006 10:27:40 -0000	1.10
--- scopedef.py	20 Apr 2006 10:11:25 -0000	1.11
***************
*** 8,12 ****
--- 8,18 ----
  """
  
+ import time
+ import algorithm
+ import filtering
  import declaration
+ import mdecl_wrapper
+ from pygccxml import utils
+ import matcher as matcher_module
  
  class scopedef_t( declaration.declaration_t ):
***************
*** 16,23 ****
--- 22,80 ----
      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). 
+     
+     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. 
+         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 - referers 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 
+         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.     
      """
+ 
+     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='', parent=''):
          declaration.declaration_t.__init__( self, name, parent )
  
+         self._optimized = False
+         self._type2decls = {}
+         self._type2name2decls = {}
+         self._type2decls_nr = {}
+         self._type2name2decls_nr = {}
+         self._all_decls = None
+ 
      def _get__cmp__scope_items(self):
          raise NotImplementedError()
***************
*** 46,47 ****
--- 103,495 ----
      def remove_declaration( self, decl ):
          raise NotImplementedError()
+ 
+ 
+     def __decl_types( self, decl ):
+         types = []
+         bases = list( decl.__class__.__bases__ )
+         visited = set()
+         if 'pygccxml' in decl.__class__.__module__:
+             types.append( decl.__class__ )
+         while bases:
+             base = bases.pop()
+             if base is declaration.declaration_t:
+                 continue
+             if base in visited:
+                 continue
+             if 'pygccxml' not in base.__module__:
+                 continue
+             types.append( base )
+             bases.extend( base.__bases__ )
+         return types
+ 
+     def clear_optimizer(self):
+         """Cleans query optimizer state"""
+         self._optimized = False
+         self._type2decls = {}
+         self._type2name2decls = {}
+         self._type2decls_nr = {}
+         self._type2name2decls_nr = {}
+         self._all_decls = None
+ 
+         map( lambda decl: decl.clear_optimizer()
+              , filter( lambda decl: isinstance( decl, scopedef_t )
+                        ,  self.declarations ) )
+ 
+     def init_optimizer(self):
+         """Initializes query optimizer state.
+         There are 4 internals hash tables:
+             1. from type to declarations
+             2. from type to declarations for non-recursive queries
+             3. from type to name to declarations
+             4. from type to name to declarations for non-recursive queries
+             
+         Almost every query includes declaration type information. Also very
+         common query is to search some declaration(s) by name or full name.
+         Those hashtables allows to search declaration very quick. 
+         """
+         utils.logger.debug( "preparing data structures for query optimizer - started" )
+         start_time = time.clock()
+         
+         self.clear_optimizer()
+         
+         for dtype in scopedef_t._impl_all_decl_types:
+             self._type2decls[ dtype ] = []
+             self._type2decls_nr[ dtype ] = []
+             self._type2name2decls[ dtype ] = {}
+             self._type2name2decls_nr[ dtype ] = {}
+         
+         self._all_decls = algorithm.make_flatten( self.declarations )
+         for decl in self._all_decls:
+             types = self.__decl_types( decl )
+             for type_ in types:
+                 self._type2decls[ type_ ].append( decl )
+                 name2decls = self._type2name2decls[ type_ ]
+                 if not name2decls.has_key( decl.name ):
+                     name2decls[ decl.name ] = []
+                 name2decls[ decl.name ].append( decl )
+                 if self is decl.parent:
+                     self._type2decls_nr[ type_ ].append( decl )
+                     name2decls_nr = self._type2name2decls_nr[ type_ ]
+                     if not name2decls_nr.has_key( decl.name ):
+                         name2decls_nr[ decl.name ] = []
+                     name2decls_nr[ decl.name ].append( decl )
+ 
+         map( lambda decl: decl.init_optimizer()
+              , filter( lambda decl: isinstance( decl, scopedef_t ),  self.declarations ) )
+ 
+         utils.logger.debug( "preparing data structures for query optimizer - done( %f seconds ). " 
+                       % ( time.clock() - start_time ) )
+         self._optimized = True
+         
+ 
+     def __normalize_args( self, **keywds ):
+         if callable( keywds['name'] ) and None is keywds['function']:
+             keywds['function'] = keywds['name']
+             keywds['name'] = None
+         return keywds
+     
+     def __findout_recursive( self, **keywds ):
+         if None is keywds[ 'recursive' ]:
+             return self.RECURSIVE_DEFAULT
+         else: 
+             return keywds[ 'recursive' ]
+         
+     def __findout_decl_type( self, match_class, **keywds ):
+         if keywds.has_key( 'decl_type' ):
+             return keywds['decl_type']
+         
+         matcher_args = keywds.copy()
+         del matcher_args['function']
+         del matcher_args['recursive']
+ 
+         matcher = match_class( **matcher_args )
+         if matcher.decl_type:
+             return matcher.decl_type
+         return None
+             
+     def __create_matcher( self, match_class, **keywds ):
+         matcher_args = keywds.copy()
+         del matcher_args['function']
+         del matcher_args['recursive']
+ 
+         matcher = match_class( **matcher_args )
+         if keywds['function']:
+             utils.logger.info( 'running query: %s and <user defined function>' % str( matcher ) )
+             return lambda decl: matcher( decl ) and keywds['function'](decl)
+         else:
+             utils.logger.info( 'running query: %s' % str( matcher ) )                
+             return matcher
+     
+     def __findout_range( self, name, decl_type, recursive ):
+         if not self._optimized:
+             utils.logger.info( 'running non optimized query - optimization has not been done' )
+             decls = self.declarations
+             if recursive:
+                 decls = algorithm.make_flatten( self.declarations )
+             return decls
+ 
+         if name and decl_type:
+             matcher = scopedef_t._impl_matchers[ scopedef_t.decl ]( name=name )
+             if matcher.is_full_name():
+                 name = matcher.decl_name_only
+             if recursive:
+                 utils.logger.info( 'query has been optimized on type and name' )            
+                 return self._type2name2decls[decl_type][name]
+             else:
+                 utils.logger.info( 'non recursive query has been optimized on type and name' )
+                 return self._type2name2decls_nr[decl_type][name]
+         elif decl_type:
+             if recursive:
+                 utils.logger.info( 'query has been optimized on type' )            
+                 return self._type2decls[ decl_type ]
+             else:
+                 utils.logger.info( 'non recursive query has been optimized on type' )            
+                 return self._type2decls_nr[ decl_type ]
+         else:
+             if recursive:
+                 utils.logger.info( 'query has not been optimized ( hint: query does not contain type and/or name )' )
+                 return self._all_decls
+             else:
+                 utils.logger.info( 'non recursive query has not been optimized ( hint: query does not contain type and/or name )' )
+                 return self.declarations
+ 
+     def _find_single( self, match_class, **keywds ):
+         utils.logger.info( 'find single query execution - started' )
+         start_time = time.clock()      
+         norm_keywds = self.__normalize_args( **keywds )
+         matcher = self.__create_matcher( match_class, **norm_keywds )
+         dtype = self.__findout_decl_type( match_class, **norm_keywds )
+         recursive_ = self.__findout_recursive( **norm_keywds )
+         decls = self.__findout_range( norm_keywds['name'], dtype, recursive_ )
+         found = matcher_module.matcher.get_single( matcher, decls, False )
+         utils.logger.info( 'find single query execution - done( %f seconds )' % ( time.clock() - start_time ) )
+         return found
+ 
+     def _find_multiple( self, match_class, **keywds ):
+         utils.logger.info( 'find all query execution - started' )
+         start_time = time.clock() 
+         norm_keywds = self.__normalize_args( **keywds )
+         matcher = self.__create_matcher( match_class, **norm_keywds )
+         dtype = self.__findout_decl_type( match_class, **norm_keywds )
+         recursive_ = self.__findout_recursive( **norm_keywds )
+         decls = self.__findout_range( norm_keywds['name'], dtype, recursive_ )
+         found = matcher_module.matcher.find( matcher, decls, False )
+         mfound = mdecl_wrapper.mdecl_wrapper_t( found )
+         utils.logger.info( '%d declaration(s) that match query' % len(mfound) )
+         utils.logger.info( 'find single query execution - done( %f seconds )' 
+                      % ( time.clock() - start_time ) )
+         if not mfound and not self.ALLOW_EMPTY_MDECL_WRAPPER:
+             raise RuntimeError( "Multi declaration query returned 0 declarations." )
+         return mfound
+         
+ 
+     def decl( self, name=None, function=None, header_dir=None, header_file=None, recursive=None ):     
+         """Finds any declaration by criteria. Please see L{scopedef_t} for full explanation."""
+         return self._find_single( self._impl_matchers[ scopedef_t.decl ]
+                                   , name=name
+                                   , function=function
+                                   , header_dir=header_dir
+                                   , header_file=header_file
+                                   , recursive=recursive)
+ 
+     def decls( self, name=None, function=None, header_dir=None, header_file=None, recursive=None ):
+         return self._find_multiple( self._impl_matchers[ scopedef_t.decl ]
+                                     , name=name
+                                     , function=function
+                                     , header_dir=header_dir
+                                     , header_file=header_file 
+                                     , recursive=recursive)
+ 
+     def class_( self, name=None, function=None, header_dir=None, header_file=None, recursive=None ):
+         return self._find_single( self._impl_matchers[ scopedef_t.class_ ]
+                                   , name=name
+                                   , function=function
+                                   , decl_type=self._impl_decl_types[ scopedef_t.class_ ]
+                                   , header_dir=header_dir
+                                   , header_file=header_file 
+                                   , recursive=recursive)
+ 
+     def classes( self, name=None, function=None, header_dir=None, header_file=None, recursive=None ):
+         return self._find_multiple( self._impl_matchers[ scopedef_t.class_ ]
+                                     , name=name
+                                     , function=function
+                                     , decl_type=self._impl_decl_types[ scopedef_t.class_ ]
+                                     , header_dir=header_dir
+                                     , header_file=header_file 
+                                     , recursive=recursive)
+     
+     def variable( self, name=None, function=None, type=None, header_dir=None, header_file=None, recursive=None ):
+         return self._find_single( self._impl_matchers[ scopedef_t.variable ]
+                                   , name=name
+                                   , function=function
+                                   , type=type
+                                   , header_dir=header_dir
+                                   , header_file=header_file 
+                                   , recursive=recursive)
+ 
+     def variables( self, name=None, function=None, type=None, header_dir=None, header_file=None, recursive=None ):
+         return self._find_multiple( self._impl_matchers[ scopedef_t.variable ]
+                                     , name=name
+                                     , function=function
+                                     , type=type
+                                     , header_dir=header_dir
+                                     , header_file=header_file
+                                     , recursive=recursive )
+     
+     def calldef( self, name=None, function=None, return_type=None, arg_types=None, header_dir=None, header_file=None, recursive=None ):
+         return self._find_single( self._impl_matchers[ scopedef_t.calldef ]
+                                   , name=name
+                                   , function=function
+                                   , decl_type=self._impl_decl_types[ scopedef_t.calldef ]
+                                   , return_type=return_type
+                                   , arg_types=arg_types 
+                                   , header_dir=header_dir
+                                   , header_file=header_file 
+                                   , recursive=recursive )
+ 
+     def calldefs( self, name=None, function=None, return_type=None, arg_types=None, header_dir=None, header_file=None, recursive=None ):
+         return self._find_multiple( self._impl_matchers[ scopedef_t.calldef ]
+                                     , name=name
+                                     , function=function
+                                     , decl_type=self._impl_decl_types[ scopedef_t.calldef ]
+                                     , return_type=return_type
+                                     , arg_types=arg_types 
+                                     , header_dir=header_dir
+                                     , header_file=header_file
+                                     , recursive=recursive)
+     
+     def operator( self, name=None, function=None, symbol=None, return_type=None, arg_types=None, decl_type=None, header_dir=None, header_file=None, recursive=None ):
+         return self._find_single( self._impl_matchers[ scopedef_t.operator ]
+                                   , name=name
+                                   , symbol=symbol
+                                   , function=function
+                                   , decl_type=self._impl_decl_types[ scopedef_t.operator ]
+                                   , return_type=return_type
+                                   , arg_types=arg_types 
+                                   , header_dir=header_dir
+                                   , header_file=header_file 
+                                   , recursive=recursive )
+ 
+     def operators( self, name=None, function=None, symbol=None, return_type=None, arg_types=None, decl_type=None, header_dir=None, header_file=None, recursive=None ):
+         return self._find_multiple( self._impl_matchers[ scopedef_t.operator ]
+                                     , name=name
+                                     , symbol=symbol
+                                     , function=function
+                                     , decl_type=self._impl_decl_types[ scopedef_t.operator ]
+                                     , return_type=return_type
+                                     , arg_types=arg_types 
+                                     , header_dir=header_dir
+                                     , header_file=header_file 
+                                     , recursive=recursive )
+ 
+     def member_function( self, name=None, function=None, return_type=None, arg_types=None, header_dir=None, header_file=None, recursive=None ):
+         return self._find_single( self._impl_matchers[ scopedef_t.member_function ]
+                                   , name=name
+                                   , function=function
+                                   , decl_type=self._impl_decl_types[ scopedef_t.member_function ]
+                                   , return_type=return_type
+                                   , arg_types=arg_types 
+                                   , header_dir=header_dir
+                                   , header_file=header_file 
+                                   , recursive=recursive )
+ 
+     def member_functions( self, name=None, function=None, return_type=None, arg_types=None, header_dir=None, header_file=None, recursive=None ):
+         return self._find_multiple( self._impl_matchers[ scopedef_t.member_function ]
+                                     , name=name
+                                     , function=function
+                                     , decl_type=self._impl_decl_types[ scopedef_t.member_function ]
+                                     , return_type=return_type
+                                     , arg_types=arg_types 
+                                     , header_dir=header_dir
+                                     , header_file=header_file
+                                     , recursive=recursive)
+     
+     def constructor( self, name=None, function=None, return_type=None, arg_types=None, header_dir=None, header_file=None, recursive=None ):
+         return self._find_single( self._impl_matchers[ scopedef_t.constructor ]
+                                   , name=name
+                                   , function=function
+                                   , decl_type=self._impl_decl_types[ scopedef_t.constructor ]
+                                   , return_type=return_type
+                                   , arg_types=arg_types 
+                                   , header_dir=header_dir
+                                   , header_file=header_file 
+                                   , recursive=recursive )
+ 
+     def constructors( self, name=None, function=None, return_type=None, arg_types=None, header_dir=None, header_file=None, recursive=None ):
+         return self._find_multiple( self._impl_matchers[ scopedef_t.constructor ]
+                                     , name=name
+                                     , function=function
+                                     , decl_type=self._impl_decl_types[ scopedef_t.constructor ]
+                                     , return_type=return_type
+                                     , arg_types=arg_types 
+                                     , header_dir=header_dir
+                                     , header_file=header_file
+                                     , recursive=recursive)
+     
+     def member_operator( self, name=None, function=None, symbol=None, return_type=None, arg_types=None, header_dir=None, header_file=None, recursive=None ):
+         return self._find_single( self._impl_matchers[ scopedef_t.member_operator ]
+                                   , name=name
+                                   , symbol=symbol
+                                   , function=function
+                                   , decl_type=self._impl_decl_types[ scopedef_t.member_operator ]
+                                   , return_type=return_type
+                                   , arg_types=arg_types 
+                                   , header_dir=header_dir
+                                   , header_file=header_file 
+                                   , recursive=recursive )
+ 
+     def member_operators( self, name=None, function=None, symbol=None, return_type=None, arg_types=None, header_dir=None, header_file=None, recursive=None ):
+         return self._find_multiple( self._impl_matchers[ scopedef_t.member_operator ]
+                                     , name=name
+                                     , symbol=symbol
+                                     , function=function
+                                     , decl_type=self._impl_decl_types[ scopedef_t.member_operator ]
+                                     , return_type=return_type
+                                     , arg_types=arg_types 
+                                     , header_dir=header_dir
+                                     , header_file=header_file 
+                                     , recursive=recursive ) 
+     
+     def casting_operator( self, name=None, function=None, return_type=None, arg_types=None, header_dir=None, header_file=None, recursive=None ):
+         return self._find_single( self._impl_matchers[ scopedef_t.casting_operator ]
+                                   , name=name
+                                   , function=function
+                                   , decl_type=self._impl_decl_types[ scopedef_t.casting_operator ]
+                                   , return_type=return_type
+                                   , arg_types=arg_types 
+                                   , header_dir=header_dir
+                                   , header_file=header_file 
+                                   , recursive=recursive )
+ 
+     def casting_operators( self, name=None, function=None, return_type=None, arg_types=None, header_dir=None, header_file=None, recursive=None ):
+         return self._find_multiple( self._impl_matchers[ scopedef_t.casting_operator ]
+                                     , name=name
+                                     , function=function
+                                     , decl_type=self._impl_decl_types[ scopedef_t.casting_operator ]
+                                     , return_type=return_type
+                                     , arg_types=arg_types 
+                                     , header_dir=header_dir
+                                     , header_file=header_file
+                                     , recursive=recursive)
+ 
+     def enumeration( self, name=None, function=None, header_dir=None, header_file=None, recursive=None ):     
+         return self._find_single( self._impl_matchers[ scopedef_t.enumeration ]
+                                   , name=name
+                                   , function=function
+                                   , decl_type=self._impl_decl_types[ scopedef_t.enumeration ]
+                                   , header_dir=header_dir
+                                   , header_file=header_file
+                                   , recursive=recursive)
+     #adding small aliase
+     enum = enumeration
+     
+     def enumerations( self, name=None, function=None, header_dir=None, header_file=None, recursive=None ):
+         return self._find_multiple( self._impl_matchers[ scopedef_t.enumeration ]
+                                     , name=name
+                                     , function=function
+                                     , decl_type=self._impl_decl_types[ scopedef_t.enumeration ]
+                                     , header_dir=header_dir
+                                     , header_file=header_file 
+                                     , recursive=recursive)
+     #adding small aliase
+     enums = enumerations        
\ No newline at end of file