pygccxml.declarations.scopedef

Package pygccxml :: Package declarations :: Module scopedef |

# Source Code for Module pygccxml.declarations.scopedef

      1  # Copyright 2004-2008 Roman Yakovenko.
      2  # Distributed under the Boost Software License, Version 1.0. (See
      3  # accompanying file LICENSE_1_0.txt or copy at
      4  # http://www.boost.org/LICENSE_1_0.txt)
      5
      6  """
      7  defines base class for L{namespace_t} and L{class_t} classes
      8  """
      9
     10  import time
     11  import algorithm
     12  import filtering
     13  import templates
     14  import declaration
     15  import mdecl_wrapper
     16  from pygccxml import utils
     17  import matcher as matcher_module
     18
     19 -class scopedef_t( declaration.declaration_t ):
     20      """Base class for L{namespace_t} and L{class_t} classes.
     21
     22      This is the base class for all declaration classes that may have
     23      children nodes. The children can be accessed via the C{declarations}
     24      property.
     25
     26      Also this class provides "get/select/find" interface. Using this class you
     27      can get instance or instances of internal declaration(s).
     28
     29      You can find declaration(s) using next criteria:
     30          1. name - declaration name, could be full qualified name
     31          2. header_dir - directory, to which belongs file, that the declaration was declarated in.
     32             header_dir should be absolute path.
     33          3. header_file - file that the declaration was declarated in.
     34          4. function - user ( your ) custom criteria. The interesting thing is that
     35             this function will be joined with other arguments ( criteria ).
     36          5. recursive - the search declaration range, if True will be search in
     37            internal declarations too.
     38
     39      Every "select" API you can invoke and pass as first argument at declaration
     40      name or function. This class will find out correctly what argument represents.
     41
     42      Example::
     43          ns - referrers to global namespace
     44          ns.member_function( "do_something ) - will return reference to member
     45          function named "do_something". If there is no such function exception
     46          will be raised. If there is more then one function exception will be
     47          raised too.
     48
     49      Example 2::
     50          ns - referers to global namespace
     51          do_smths = ns.member_functions( "do_something ) - will return instance
     52          of L{mdecl_wrapper_t} object. This object allows you few things:
     53
     54          1. To iterate on selected declarations
     55          2. To set some property to desired value using one line of code only:
     56             do_smths.call_policies = x
     57          3. To call some function on every instance using one line of code:
     58             do_smths.exclude()
     59
     60          Pay attention: you can not use "get" functions or properties.
     61      """
     62
     63      RECURSIVE_DEFAULT = True
     64      ALLOW_EMPTY_MDECL_WRAPPER = False
     65
     66      declaration_not_found_t = matcher_module.matcher.declaration_not_found_t
     67      multiple_declarations_found_t = matcher_module.matcher.multiple_declarations_found_t
     68
     69      _impl_matchers = {} #this class variable is used to prevent recursive imports
     70      _impl_decl_types = {} #this class variable is used to prevent recursive imports
     71      _impl_all_decl_types = [] #this class variable is used to prevent recursive imports
     72
     73 -    def __init__( self, name=''):
     74          declaration.declaration_t.__init__( self, name )
     75
     76          self._optimized = False
     77          self._type2decls = {}
     78          self._type2name2decls = {}
     79          self._type2decls_nr = {}
     80          self._type2name2decls_nr = {}
     81          self._all_decls = None
     82          self._all_decls_not_recursive = None
     83
     84 -    def _get_logger( self ):
     85          return utils.loggers.queries_engine
     86      _logger = property( _get_logger, doc="reference to C{queries_engine} logger" )
     87
     88 -    def _get__cmp__scope_items(self):
     89          """implementation details"""
     90          raise NotImplementedError()
     91
     92 -    def _get__cmp__items(self):
     93          """implementation details"""
     94          items = []
     95          if self._optimized:
     96              #in this case we don't need to build class internal declarations list
     97              items.append( self._sorted_list( self._all_decls_not_recursive ) )
     98          else:
     99              items.append( self._sorted_list( self.declarations ) )
    100          items.extend( self._get__cmp__scope_items() )
    101          return items
    102
    103 -    def __eq__(self, other):
    104          if not declaration.declaration_t.__eq__( self, other ):
    105              return False
    106          return self._sorted_list( self.declarations[:] ) \
    107                 == other._sorted_list( other.declarations[:] )
    108          #self_decls = self._all_decls_not_recursive
    109          #if not self._optimized:
    110              #self_decls = self._sorted_list( self.declarations[:] )
    111          #other_decls = other._all_decls_not_recursive[:]
    112          #if not other._optimized:
    113              #other_decls = other._sorted_list( other.declarations[:] )
    114          #else:
    115              #return  self_decls == other_decls
    116
    117 -    def _get_declarations_impl(self):
    118          raise NotImplementedError()
    119
    120 -    def _get_declarations(self):
    121          if True == self._optimized:
    122              return self._all_decls_not_recursive
    123          else:
    124              return self._get_declarations_impl()
    125      declarations = property( _get_declarations, doc="list of children L{declarations<declaration_t>}" )
    126
    127 -    def remove_declaration( self, decl ):
    128          raise NotImplementedError()
    129
    130 -    def __decl_types( self, decl ):
    131          """implementation details"""
    132          types = []
    133          bases = list( decl.__class__.__bases__ )
    134          visited = set()
    135          if 'pygccxml' in decl.__class__.__module__:
    136              types.append( decl.__class__ )
    137          while bases:
    138              base = bases.pop()
    139              if base is declaration.declaration_t:
    140                  continue
    141              if base in visited:
    142                  continue
    143              if 'pygccxml' not in base.__module__:
    144                  continue
    145              types.append( base )
    146              bases.extend( base.__bases__ )
    147          return types
    148
    149 -    def clear_optimizer(self):
    150          """Cleans query optimizer state"""
    151          self._optimized = False
    152          self._type2decls = {}
    153          self._type2name2decls = {}
    154          self._type2decls_nr = {}
    155          self._type2name2decls_nr = {}
    156          self._all_decls = None
    157          self._all_decls_not_recursive = None
    158
    159          map( lambda decl: decl.clear_optimizer()
    160               , filter( lambda decl: isinstance( decl, scopedef_t )
    161                         ,  self.declarations ) )
    162
    163 -    def init_optimizer(self):
    164          """Initializes query optimizer state.
    165          There are 4 internals hash tables:
    166              1. from type to declarations
    167              2. from type to declarations for non-recursive queries
    168              3. from type to name to declarations
    169              4. from type to name to declarations for non-recursive queries
    170
    171          Almost every query includes declaration type information. Also very
    172          common query is to search some declaration(s) by name or full name.
    173          Those hashtables allows to search declaration very quick.
    174          """
    175          if self.name == '::':
    176              self._logger.debug( "preparing data structures for query optimizer - started" )
    177          start_time = time.clock()
    178
    179          self.clear_optimizer()
    180
    181          for dtype in scopedef_t._impl_all_decl_types:
    182              self._type2decls[ dtype ] = []
    183              self._type2decls_nr[ dtype ] = []
    184              self._type2name2decls[ dtype ] = {}
    185              self._type2name2decls_nr[ dtype ] = {}
    186
    187          self._all_decls_not_recursive = self.declarations
    188          self._all_decls = algorithm.make_flatten( self._all_decls_not_recursive )
    189          for decl in self._all_decls:
    190              types = self.__decl_types( decl )
    191              for type_ in types:
    192                  self._type2decls[ type_ ].append( decl )
    193                  name2decls = self._type2name2decls[ type_ ]
    194                  if not name2decls.has_key( decl.name ):
    195                      name2decls[ decl.name ] = []
    196                  name2decls[ decl.name ].append( decl )
    197                  if self is decl.parent:
    198                      self._type2decls_nr[ type_ ].append( decl )
    199                      name2decls_nr = self._type2name2decls_nr[ type_ ]
    200                      if not name2decls_nr.has_key( decl.name ):
    201                          name2decls_nr[ decl.name ] = []
    202                      name2decls_nr[ decl.name ].append( decl )
    203
    204          map( lambda decl: decl.init_optimizer()
    205               , filter( lambda decl: isinstance( decl, scopedef_t )
    206                         ,  self._all_decls_not_recursive ) )
    207          if self.name == '::':
    208              self._logger.debug( "preparing data structures for query optimizer - done( %f seconds ). "
    209                                  % ( time.clock() - start_time ) )
    210          self._optimized = True
    211
    212 -    def _build_operator_function( self, name, function ):
    213          if callable( name ):
    214              return name
    215          else:
    216              return function
    217
    218 -    def _build_operator_name( self, name, function, symbol ):
    219          """implementation details"""
    220          def add_operator( sym ):
    221              if 'new' in sym or 'delete' in sym:
    222                  return 'operator ' + sym
    223              else:
    224                  return 'operator'+ sym
    225          if callable( name ) and None is function:
    226              name = None
    227          if name:
    228              if not 'operator' in name:
    229                 name = add_operator( name )
    230              return name
    231          elif symbol:
    232              return add_operator( symbol )
    233          return name #both name and symbol are None
    234
    235 -    def _on_rename( self ):
    236          for decl in self.decls(allow_empty=True):
    237              decl.cache.reset_name_based()
    238          #I am not sure whether to introduce this or not?
    239          #It could be very time consuming operation + it changes optimize query
    240          #data structures.
    241          #if self.parent:
    242          #    if self.parent._optimized:
    243          #        self.parent.init_optimizer()
    244
    245 -    def __normalize_args( self, **keywds ):
    246          """implementation details"""
    247          if callable( keywds['name'] ) and None is keywds['function']:
    248              keywds['function'] = keywds['name']
    249              keywds['name'] = None
    250          return keywds
    251
    252 -    def __findout_recursive( self, **keywds ):
    253          """implementation details"""
    254          if None is keywds[ 'recursive' ]:
    255              return self.RECURSIVE_DEFAULT
    256          else:
    257              return keywds[ 'recursive' ]
    258
    259 -    def __findout_allow_empty( self, **keywds ):
    260          """implementation details"""
    261          if None is keywds[ 'allow_empty' ]:
    262              return self.ALLOW_EMPTY_MDECL_WRAPPER
    263          else:
    264              return keywds[ 'allow_empty' ]
    265
    266 -    def __findout_decl_type( self, match_class, **keywds ):
    267          """implementation details"""
    268          if keywds.has_key( 'decl_type' ):
    269              return keywds['decl_type']
    270
    271          matcher_args = keywds.copy()
    272          del matcher_args['function']
    273          del matcher_args['recursive']
    274          if matcher_args.has_key('allow_empty'):
    275              del matcher_args['allow_empty']
    276
    277          matcher = match_class( **matcher_args )
    278          if matcher.decl_type:
    279              return matcher.decl_type
    280          return None
    281
    282 -    def __create_matcher( self, match_class, **keywds ):
    283          """implementation details"""
    284          matcher_args = keywds.copy()
    285          del matcher_args['function']
    286          del matcher_args['recursive']
    287          if matcher_args.has_key('allow_empty'):
    288              del matcher_args['allow_empty']
    289
    290          matcher = match_class( **matcher_args )
    291          if keywds['function']:
    292              self._logger.debug( 'running query: %s and <user defined function>' % str( matcher ) )
    293              return lambda decl: matcher( decl ) and keywds['function'](decl)
    294          else:
    295              self._logger.debug( 'running query: %s' % str( matcher ) )
    296              return matcher
    297
    298 -    def __findout_range( self, name, decl_type, recursive ):
    299          """implementation details"""
    300          if not self._optimized:
    301              self._logger.debug( 'running non optimized query - optimization has not been done' )
    302              decls = self.declarations
    303              if recursive:
    304                  decls = algorithm.make_flatten( self.declarations )
    305              if decl_type:
    306                  decls = filter( lambda d: isinstance( d, decl_type ), decls )
    307              return decls
    308
    309          if name and templates.is_instantiation( name ):
    310              #templates has tricky mode to compare them, so lets check the whole
    311              #range
    312              name = None
    313
    314          if name and decl_type:
    315              matcher = scopedef_t._impl_matchers[ scopedef_t.decl ]( name=name )
    316              if matcher.is_full_name():
    317                  name = matcher.decl_name_only
    318              if recursive:
    319                  self._logger.debug( 'query has been optimized on type and name' )
    320                  if self._type2name2decls[decl_type].has_key( name ):
    321                      return self._type2name2decls[decl_type][name]
    322                  else:
    323                      return []
    324              else:
    325                  self._logger.debug( 'non recursive query has been optimized on type and name' )
    326                  if self._type2name2decls_nr[decl_type].has_key( name ):
    327                      return self._type2name2decls_nr[decl_type][name]
    328                  else:
    329                      return []
    330          elif decl_type:
    331              if recursive:
    332                  self._logger.debug( 'query has been optimized on type' )
    333                  return self._type2decls[ decl_type ]
    334              else:
    335                  self._logger.debug( 'non recursive query has been optimized on type' )
    336                  return self._type2decls_nr[ decl_type ]
    337          else:
    338              if recursive:
    339                  self._logger.debug( 'query has not been optimized ( hint: query does not contain type and/or name )' )
    340                  return self._all_decls
    341              else:
    342                  self._logger.debug( 'non recursive query has not been optimized ( hint: query does not contain type and/or name )' )
    343                  return self._all_decls_not_recursive
    344
    345 -    def _find_single( self, match_class, **keywds ):
    346          """implementation details"""
    347          self._logger.debug( 'find single query execution - started' )
    348          start_time = time.clock()
    349          norm_keywds = self.__normalize_args( **keywds )
    350          matcher = self.__create_matcher( match_class, **norm_keywds )
    351          dtype = self.__findout_decl_type( match_class, **norm_keywds )
    352          recursive_ = self.__findout_recursive( **norm_keywds )
    353          decls = self.__findout_range( norm_keywds['name'], dtype, recursive_ )
    354          found = matcher_module.matcher.get_single( matcher, decls, False )
    355          self._logger.debug( 'find single query execution - done( %f seconds )' % ( time.clock() - start_time ) )
    356          return found
    357
    358 -    def _find_multiple( self, match_class, **keywds ):
    359          """implementation details"""
    360          self._logger.debug( 'find all query execution - started' )
    361          start_time = time.clock()
    362          norm_keywds = self.__normalize_args( **keywds )
    363          matcher = self.__create_matcher( match_class, **norm_keywds )
    364          dtype = self.__findout_decl_type( match_class, **norm_keywds )
    365          recursive_ = self.__findout_recursive( **norm_keywds )
    366          allow_empty = self.__findout_allow_empty( **norm_keywds )
    367          decls = self.__findout_range( norm_keywds['name'], dtype, recursive_ )
    368          found = matcher_module.matcher.find( matcher, decls, False )
    369          mfound = mdecl_wrapper.mdecl_wrapper_t( found )
    370          self._logger.debug( '%d declaration(s) that match query' % len(mfound) )
    371          self._logger.debug( 'find single query execution - done( %f seconds )'
    372                       % ( time.clock() - start_time ) )
    373          if not mfound and not allow_empty:
    374              raise RuntimeError( "Multi declaration query returned 0 declarations." )
    375          return mfound
    376
    377 -    def decl( self, name=None, function=None, decl_type=None, header_dir=None, header_file=None, recursive=None ):
    378          """returns reference to declaration, that is matched defined criterias"""
    379          return self._find_single( self._impl_matchers[ scopedef_t.decl ]
    380                                    , name=name
    381                                    , function=function
    382                                    , decl_type=decl_type
    383                                    , header_dir=header_dir
    384                                    , header_file=header_file
    385                                    , recursive=recursive)
    386
    387 -    def decls( self, name=None, function=None, decl_type=None, header_dir=None, header_file=None, recursive=None, allow_empty=None ):
    388          """returns a set of declarations, that are matched defined criterias"""
    389          return self._find_multiple( self._impl_matchers[ scopedef_t.decl ]
    390                                      , name=name
    391                                      , function=function
    392                                      , decl_type=decl_type
    393                                      , header_dir=header_dir
    394                                      , header_file=header_file
    395                                      , recursive=recursive
    396                                      , allow_empty=allow_empty)
    397
    398 -    def class_( self, name=None, function=None, header_dir=None, header_file=None, recursive=None ):
    399          """returns reference to class declaration, that is matched defined criterias"""
    400          return self._find_single( self._impl_matchers[ scopedef_t.class_ ]
    401                                    , name=name
    402                                    , function=function
    403                                    , decl_type=self._impl_decl_types[ scopedef_t.class_ ]
    404                                    , header_dir=header_dir
    405                                    , header_file=header_file
    406                                    , recursive=recursive)
    407
    408 -    def classes( self, name=None, function=None, header_dir=None, header_file=None, recursive=None, allow_empty=None ):
    409          """returns a set of class declarations, that are matched defined criterias"""
    410          return self._find_multiple( self._impl_matchers[ scopedef_t.class_ ]
    411                                      , name=name
    412                                      , function=function
    413                                      , decl_type=self._impl_decl_types[ scopedef_t.class_ ]
    414                                      , header_dir=header_dir
    415                                      , header_file=header_file
    416                                      , recursive=recursive
    417                                      , allow_empty=allow_empty)
    418
    419 -    def variable( self, name=None, function=None, type=None, header_dir=None, header_file=None, recursive=None ):
    420          """returns reference to variable declaration, that is matched defined criterias"""
    421          return self._find_single( self._impl_matchers[ scopedef_t.variable ]
    422                                    , name=name
    423                                    , function=function
    424                                    , type=type
    425                                    , header_dir=header_dir
    426                                    , header_file=header_file
    427                                    , recursive=recursive)
    428      var = variable #small alias
    429
    430 -    def variables( self, name=None, function=None, type=None, header_dir=None, header_file=None, recursive=None, allow_empty=None ):
    431          """returns a set of variable declarations, that are matched defined criterias"""
    432          return self._find_multiple( self._impl_matchers[ scopedef_t.variable ]
    433                                      , name=name
    434                                      , function=function
    435                                      , type=type
    436                                      , header_dir=header_dir
    437                                      , header_file=header_file
    438                                      , recursive=recursive
    439                                      , allow_empty=allow_empty)
    440      vars = variables #small alias
    441
    442 -    def calldef( self, name=None, function=None, return_type=None, arg_types=None, header_dir=None, header_file=None, recursive=None ):
    443          """returns reference to "calldef" declaration, that is matched defined criterias"""
    444          return self._find_single( self._impl_matchers[ scopedef_t.calldef ]
    445                                    , name=name
    446                                    , function=function
    447                                    , decl_type=self._impl_decl_types[ scopedef_t.calldef ]
    448                                    , return_type=return_type
    449                                    , arg_types=arg_types
    450                                    , header_dir=header_dir
    451                                    , header_file=header_file
    452                                    , recursive=recursive )
    453
    454 -    def calldefs( self, name=None, function=None, return_type=None, arg_types=None, header_dir=None, header_file=None, recursive=None, allow_empty=None ):
    455          """returns a set of calldef declarations, that are matched defined criterias"""
    456          return self._find_multiple( self._impl_matchers[ scopedef_t.calldef ]
    457                                      , name=name
    458                                      , function=function
    459                                      , decl_type=self._impl_decl_types[ scopedef_t.calldef ]
    460                                      , return_type=return_type
    461                                      , arg_types=arg_types
    462                                      , header_dir=header_dir
    463                                      , header_file=header_file
    464                                      , recursive=recursive
    465                                      , allow_empty=allow_empty)
    466
    467 -    def operator( self, name=None, function=None, symbol=None, return_type=None, arg_types=None, header_dir=None, header_file=None, recursive=None ):
    468          """returns reference to operator declaration, that is matched defined criterias"""
    469          return self._find_single( self._impl_matchers[ scopedef_t.operator ]
    470                                    , name=self._build_operator_name( name, function, symbol )
    471                                    , symbol=symbol
    472                                    , function=self._build_operator_function( name, function )
    473                                    , decl_type=self._impl_decl_types[ scopedef_t.operator ]
    474                                    , return_type=return_type
    475                                    , arg_types=arg_types
    476                                    , header_dir=header_dir
    477                                    , header_file=header_file
    478                                    , recursive=recursive )
    479
    480 -    def 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 ):
    481          """returns a set of operator declarations, that are matched defined criterias"""
    482          return self._find_multiple( self._impl_matchers[ scopedef_t.operator ]
    483                                      , name=self._build_operator_name( name, function, symbol )
    484                                      , symbol=symbol
    485                                      , function=self._build_operator_function( name, function )
    486                                      , decl_type=self._impl_decl_types[ scopedef_t.operator ]
    487                                      , return_type=return_type
    488                                      , arg_types=arg_types
    489                                      , header_dir=header_dir
    490                                      , header_file=header_file
    491                                      , recursive=recursive
    492                                      , allow_empty=allow_empty)
    493
    494 -    def member_function( self, name=None, function=None, return_type=None, arg_types=None, header_dir=None, header_file=None, recursive=None ):
    495          """returns reference to member declaration, that is matched defined criterias"""
    496          return self._find_single( self._impl_matchers[ scopedef_t.member_function ]
    497                                    , name=name
    498                                    , function=function
    499                                    , decl_type=self._impl_decl_types[ scopedef_t.member_function ]
    500                                    , return_type=return_type
    501                                    , arg_types=arg_types
    502                                    , header_dir=header_dir
    503                                    , header_file=header_file
    504                                    , recursive=recursive )
    505      mem_fun = member_function
    506
    507 -    def member_functions( self, name=None, function=None, return_type=None, arg_types=None, header_dir=None, header_file=None, recursive=None, allow_empty=None ):
    508          """returns a set of member function declarations, that are matched defined criterias"""
    509          return self._find_multiple( self._impl_matchers[ scopedef_t.member_function ]
    510                                      , name=name
    511                                      , function=function
    512                                      , decl_type=self._impl_decl_types[ scopedef_t.member_function ]
    513                                      , return_type=return_type
    514                                      , arg_types=arg_types
    515                                      , header_dir=header_dir
    516                                      , header_file=header_file
    517                                      , recursive=recursive
    518                                      , allow_empty=allow_empty)
    519      mem_funs = member_functions
    520
    521 -    def constructor( self, name=None, function=None, return_type=None, arg_types=None, header_dir=None, header_file=None, recursive=None ):
    522          """returns reference to constructor declaration, that is matched defined criterias"""
    523          return self._find_single( self._impl_matchers[ scopedef_t.constructor ]
    524                                    , name=name
    525                                    , function=function
    526                                    , decl_type=self._impl_decl_types[ scopedef_t.constructor ]
    527                                    , return_type=return_type
    528                                    , arg_types=arg_types
    529                                    , header_dir=header_dir
    530                                    , header_file=header_file
    531                                    , recursive=recursive )
    532
    533 -    def constructors( self, name=None, function=None, return_type=None, arg_types=None, header_dir=None, header_file=None, recursive=None, allow_empty=None ):
    534          """returns a set of constructor declarations, that are matched defined criterias"""
    535          return self._find_multiple( self._impl_matchers[ scopedef_t.constructor ]
    536                                      , name=name
    537                                      , function=function
    538                                      , decl_type=self._impl_decl_types[ scopedef_t.constructor ]
    539                                      , return_type=return_type
    540                                      , arg_types=arg_types
    541                                      , header_dir=header_dir
    542                                      , header_file=header_file
    543                                      , recursive=recursive
    544                                      , allow_empty=allow_empty)
    545
    546 -    def member_operator( self, name=None, function=None, symbol=None, return_type=None, arg_types=None, header_dir=None, header_file=None, recursive=None ):
    547          """returns reference to member operator declaration, that is matched defined criterias"""
    548          return self._find_single( self._impl_matchers[ scopedef_t.member_operator ]
    549                                    , name=self._build_operator_name( name, function, symbol )
    550                                    , symbol=symbol
    551                                    , function=self._build_operator_function( name, function )
    552                                    , decl_type=self._impl_decl_types[ scopedef_t.member_operator ]
    553                                    , return_type=return_type
    554                                    , arg_types=arg_types
    555                                    , header_dir=header_dir
    556                                    , header_file=header_file
    557                                    , recursive=recursive )
    558      mem_oper = member_operator
    559 -    def member_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 ):
    560          """returns a set of member operator declarations, that are matched defined criterias"""
    561          return self._find_multiple( self._impl_matchers[ scopedef_t.member_operator ]
    562                                      , name=self._build_operator_name( name, function, symbol )
    563                                      , symbol=symbol
    564                                      , function=self._build_operator_function( name, function )
    565                                      , decl_type=self._impl_decl_types[ scopedef_t.member_operator ]
    566                                      , return_type=return_type
    567                                      , arg_types=arg_types
    568                                      , header_dir=header_dir
    569                                      , header_file=header_file
    570                                      , recursive=recursive
    571                                      , allow_empty=allow_empty)
    572      mem_opers = member_operators
    573
    574 -    def casting_operator( self, name=None, function=None, return_type=None, arg_types=None, header_dir=None, header_file=None, recursive=None ):
    575          """returns reference to casting operator declaration, that is matched defined criterias"""
    576          return self._find_single( self._impl_matchers[ scopedef_t.casting_operator ]
    577                                    , name=name
    578                                    , function=function
    579                                    , decl_type=self._impl_decl_types[ scopedef_t.casting_operator ]
    580                                    , return_type=return_type
    581                                    , arg_types=arg_types
    582                                    , header_dir=header_dir
    583                                    , header_file=header_file
    584                                    , recursive=recursive )
    585
    586 -    def casting_operators( self, name=None, function=None, return_type=None, arg_types=None, header_dir=None, header_file=None, recursive=None, allow_empty=None ):
    587          """returns a set of casting operator declarations, that are matched defined criterias"""
    588          return self._find_multiple( self._impl_matchers[ scopedef_t.casting_operator ]
    589                                      , name=name
    590                                      , function=function
    591                                      , decl_type=self._impl_decl_types[ scopedef_t.casting_operator ]
    592                                      , return_type=return_type
    593                                      , arg_types=arg_types
    594                                      , header_dir=header_dir
    595                                      , header_file=header_file
    596                                      , recursive=recursive
    597                                      , allow_empty=allow_empty)
    598
    599 -    def enumeration( self, name=None, function=None, header_dir=None, header_file=None, recursive=None ):
    600          """returns reference to enumeration declaration, that is matched defined criterias"""
    601          return self._find_single( self._impl_matchers[ scopedef_t.enumeration ]
    602                                    , name=name
    603                                    , function=function
    604                                    , decl_type=self._impl_decl_types[ scopedef_t.enumeration ]
    605                                    , header_dir=header_dir
    606                                    , header_file=header_file
    607                                    , recursive=recursive)
    608
    609      enum = enumeration
    610      """adding small aliase to enumeration method"""
    611
    612 -    def enumerations( self, name=None, function=None, header_dir=None, header_file=None, recursive=None, allow_empty=None ):
    613          """returns a set of enumeration declarations, that are matched defined criterias"""
    614          return self._find_multiple( self._impl_matchers[ scopedef_t.enumeration ]
    615                                      , name=name
    616                                      , function=function
    617                                      , decl_type=self._impl_decl_types[ scopedef_t.enumeration ]
    618                                      , header_dir=header_dir
    619                                      , header_file=header_file
    620                                      , recursive=recursive
    621                                      , allow_empty=allow_empty)
    622      #adding small aliase
    623      enums = enumerations
    624
    625 -    def typedef( self, name=None, function=None, header_dir=None, header_file=None, recursive=None ):
    626          """returns reference to typedef declaration, that is matched defined criterias"""
    627          return self._find_single( self._impl_matchers[ scopedef_t.typedef ]
    628                                    , name=name
    629                                    , function=function
    630                                    , decl_type=self._impl_decl_types[ scopedef_t.typedef ]
    631                                    , header_dir=header_dir
    632                                    , header_file=header_file
    633                                    , recursive=recursive)
    634
    635 -    def typedefs( self, name=None, function=None, header_dir=None, header_file=None, recursive=None, allow_empty=None ):
    636          """returns a set of typedef declarations, that are matched defined criterias"""
    637          return self._find_multiple( self._impl_matchers[ scopedef_t.typedef ]
    638                                      , name=name
    639                                      , function=function
    640                                      , decl_type=self._impl_decl_types[ scopedef_t.typedef ]
    641                                      , header_dir=header_dir
    642                                      , header_file=header_file
    643                                      , recursive=recursive
    644                                      , allow_empty=allow_empty)
    645
    646 -    def __getitem__(self, name_or_function):
    647          """ Allow simple name based find of decls.  Internally just calls decls() method.
    648              @param name_or_function  Name of decl to lookup or finder function.
    649          """
    650          return self.decls(name_or_function)
    651