1   
  2   
  3   
  4   
  5   
  6  "defines property_t helper class" 
  7   
  8  import algorithm 
  9  from pyplusplus import messages 
 10  from pyplusplus import _logging_ 
 11  from pygccxml import declarations 
 14      """This class describes a "property".  
 15       
 16      It keeps 
 17      """ 
 18 -    def __init__( self, name, fget, fset=None, doc=None, is_static=False ): 
  24   
 25      @property 
 28   
 29      @property 
 32   
 33      @property 
 36   
 38          if None is self._doc:             
 39              doc = ['get'] 
 40              if self.fset: 
 41                  doc.append( r'\\set' ) 
 42              doc.append( r' property, built on top of \"%s\"' % self.fget ) 
 43              if self.fset: 
 44                  doc.append( r' and \"%s\"' % self.fset ) 
 45              self._doc = '"%s"' % ''.join( doc ) 
 46          return self._doc 
  49      doc = property( _get_doc, _set_doc ) 
 50   
 51      @property 
 53          return self._is_static 
  54   
  62   
 67   
 69          raise NotImplementedError() 
  70   
 72          raise NotImplementedError() 
  73   
 84   
 95   
106   
108          getters = [] 
109          setters = [] 
110          for mem_fun in mem_funs: 
111              if not self.is_accessor( mem_fun ): 
112                  continue  
113              elif self.is_getter( mem_fun ): 
114                  getters.append( mem_fun ) 
115              elif self.is_setter( mem_fun ): 
116                  setters.append( mem_fun ) 
117              else: 
118                  continue 
119          return ( getters, setters ) 
 120   
122          return self.__get_accessors( cls.mem_funs( recursive=False, allow_empty=True ) )  
 123       
133       
135          mem_funs = [] 
136          map( lambda base_cls: mem_funs.extend( base_cls.mem_funs( recursive=False, allow_empty=True ) ) 
137               , self.base_classes( cls ) ) 
138          return self.__get_accessors( mem_funs ) 
  139   
144           
146          return [  (  'is', 'set' ) 
147                  , ( 'get', 'set' ) 
148                  , ( 'has', 'set' ) 
149                  , (    '', 'set' ) ] 
 150   
152          if not name.startswith( prefix ): 
153              return False 
154          if len( name ) < len( prefix ): 
155              return False 
156          return True 
 157   
159          if not self.check_prefix( gname, gprefix ): 
160              return False 
161          if not self.check_prefix( sname, sprefix ): 
162              return False 
163          if gname[ len( gprefix ): ] != sname[ len( sprefix ): ]: 
164              return False 
165          return True 
 166   
168          convert = lambda x: x + '_' 
169          if gprefix: 
170              gprefix = convert( gprefix ) 
171          return ( gprefix, convert( sprefix ) ) 
 172   
174          convert = lambda x: x[0].upper() + x[1:] 
175          if gprefix: 
176              gprefix = convert( gprefix ) 
177          return ( gprefix, convert( sprefix ) ) 
 178   
180          convert = lambda x: x[0].lower() + x[1:] 
181          if gprefix: 
182              gprefix = convert( gprefix ) 
183          return ( gprefix, convert( sprefix ) ) 
 184   
197   
212   
230   
237   
245   
 252   
254 -    def __init__( self, cls, recognizer=None, exclude_accessors=False ): 
 255          self.cls = cls 
256          if None is recognizer: 
257              recognizer = name_based_recognizer_t() 
258          self.recognizer = recognizer 
259          self.exclude_accessors = exclude_accessors 
260          self.getters, self.setters = recognizer.class_accessors( cls ) 
261          self.inherited_getters, self.inherited_setters = recognizer.inherited_accessors( cls ) 
 262   
268           
286   
287          relevant_decls = [] 
288          relevant_classes = [self.cls] + self.recognizer.base_classes( self.cls ) 
289          for cls in relevant_classes:            
290              relevant_decls.extend( cls.decls( is_relevant, recursive=False, allow_empty=True ) ) 
291          return not bool( relevant_decls ) 
293 -    def find_properties( self, getters, setters, used_getters, used_setters ): 
 294          properties = [] 
295          for fget in getters: 
296              if fget in used_getters: 
297                  continue 
298              for fset in setters: 
299                  if fset in used_setters: 
300                      continue 
301                  property_ = self.recognizer.create_property( fget, fset ) 
302                  if property_: 
303                      if self.__is_legal_property( property_ ): 
304                          used_getters.add( fget ) 
305                          used_setters.add( fset ) 
306                          properties.append( property_ ) 
307                          break 
308                      else: 
309                          self.__report_illegal_property( property_ ) 
310          return properties 
 311           
313          used_getters = set() 
314          used_setters = set() 
315          properties = [] 
316           
317          properties.extend( 
318              self.find_properties( self.getters, self.setters, used_getters, used_setters ) ) 
319           
320          properties.extend( 
321              self.find_properties( self.getters, self.inherited_setters, used_getters, used_setters ) ) 
322           
323          properties.extend( 
324              self.find_properties( self.inherited_getters, self.setters, used_getters, used_setters ) ) 
325   
326          for fget in self.getters: 
327              if fget in used_getters: 
328                  continue 
329              property_ = self.recognizer.create_read_only_property( fget ) 
330              if property_: 
331                  if self.__is_legal_property( property_ ): 
332                      used_getters.add( fget ) 
333                      properties.append( property_ ) 
334                  else: 
335                      self.__report_illegal_property( property_ ) 
336                       
337          if self.exclude_accessors: 
338              map( lambda accessor: accessor.exclude(), used_getters ) 
339              map( lambda accessor: accessor.exclude(), used_setters ) 
340   
341          return properties 
 342   
347