Package pyplusplus :: Package decl_wrappers :: Module decl_wrapper

Source Code for Module pyplusplus.decl_wrappers.decl_wrapper

  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  """defines base class for all code generator configuration classes""" 
  7   
  8  import algorithm 
  9  from pyplusplus import _logging_ 
 10  from pygccxml import declarations 
 11  from pyplusplus import messages 
12 13 -class decl_wrapper_t(object):
14 """code generator declaration configuration base class 15 16 This class contains configuration that could be applied to all declarations. 17 """ 18 19 SPECIAL_TYPEDEF_PICK_ANY = True 20
21 - def __init__(self):
22 object.__init__(self) 23 self._alias = None 24 self._ignore = False 25 self._already_exposed = False 26 self._exportable = None 27 self._exportable_reason = None 28 self._documentation = None 29 self.__msgs_to_ignore = set() 30 self._include_files = []
31 32 @property
33 - def logger( self ):
34 """reference to L{_logging_.loggers.declarations}""" 35 return _logging_.loggers.declarations
36
37 - def _get_documentation( self ):
38 return self._documentation
39 - def _set_documentation( self, value ):
40 self._documentation = value
41 documentation = property( _get_documentation, _set_documentation 42 , doc="exposed declaration Python documentation string" ) 43
44 - def _generate_valid_name(self, name=None):
45 if name == None: 46 name = self.name 47 return algorithm.create_valid_name( name )
48
49 - def __select_alias_directives( self, be_smart ):
50 if not isinstance( self, declarations.class_types ): 51 return [] 52 typedefs = list( set( filter( lambda typedef: typedef.is_directive, self.aliases ) ) ) 53 if decl_wrapper_t.SPECIAL_TYPEDEF_PICK_ANY: 54 if typedefs and be_smart: 55 longest_name_len = 0 56 longest_typedef = None 57 for typedef in typedefs: 58 typedef_name_len = len( typedef.name ) 59 if longest_name_len < typedef_name_len: 60 longest_name_len = typedef_name_len 61 longest_typedef = typedef 62 return [longest_typedef] 63 else: 64 return typedefs 65 else: 66 return typedefs
67
68 - def _get_alias(self):
69 if not self._alias: 70 directives = self.__select_alias_directives(be_smart=True) 71 if 1 == len( directives ): 72 self._alias = directives[0].name 73 else: 74 if declarations.templates.is_instantiation( self.name ): 75 container_aliases = [ 'value_type', 'key_type', 'mapped_type' ] 76 if isinstance( self, declarations.class_t ) \ 77 and 1 == len( set( map( lambda typedef: typedef.name, self.aliases ) ) ) \ 78 and self.aliases[0].name not in container_aliases: 79 self._alias = self.aliases[0].name 80 else: 81 self._alias = algorithm.create_valid_name( self.partial_name ) 82 else: 83 if declarations.is_class( self ) or declarations.is_class_declaration( self ): 84 self._alias = algorithm.create_valid_name( self.partial_name ) 85 else: 86 self._alias = self.partial_name 87 return self._alias
88 - def _set_alias(self, alias):
89 self._alias = alias
90 alias = property( _get_alias, _set_alias 91 , doc="the name under which, Python will know the declaration" ) 92
93 - def rename( self, new_name ):
94 """give new name to the declaration, under which Python will know the declaration""" 95 self.alias = new_name
96
97 - def _get_ignore( self ):
98 return self._ignore
99 - def _set_ignore( self, value ):
100 self._ignore = value
101 ignore = property( _get_ignore, _set_ignore 102 , doc="boolean flag, which says whether to export declaration to Python or not" ) 103
104 - def get_already_exposed( self ):
105 return self._already_exposed
106 - def set_already_exposed( self, value ):
107 self._already_exposed = value
108 already_exposed = property( get_already_exposed, set_already_exposed 109 , doc="boolean flag, which says whether the declaration is already exposed or not" ) 110
111 - def exclude( self, compilation_errors=False ):
112 """exclude "self" and child declarations from being exposed. 113 114 If compile_time_errors is True, than only declarations, which will cause 115 compilation error will be excluded 116 """ 117 self.ignore = True
118
119 - def include( self, already_exposed=False ):
120 """include "self" and child declarations to be exposed.""" 121 self.ignore = False 122 self.already_exposed = already_exposed
123
124 - def why_not_exportable( self ):
125 """return the reason( string ) that explains why this declaration could not be exported 126 127 If declaration could be exported, than method will return None 128 """ 129 if None is self._exportable_reason: 130 self.get_exportable() 131 return self._exportable_reason
132
133 - def _exportable_impl( self ):
134 return ''
135
136 - def get_exportable( self ):
137 """return True if declaration could be exposed to Python, False otherwise""" 138 if self._exportable is None: 139 if self.name.startswith( '__' ) or '.' in self.name: 140 self._exportable_reason = messages.W1000 141 elif self.location and self.location.file_name == "<internal>": 142 self._exportable_reason = messages.W1001 143 elif self.is_artificial \ 144 and not isinstance( self, ( declarations.class_t, declarations.enumeration_t ) ): 145 self._exportable_reason = messages.W1002 146 else: 147 self._exportable_reason = self._exportable_impl( ) 148 self._exportable = not bool( self._exportable_reason ) 149 return self._exportable
150 - def set_exportable( self, exportable ):
151 """change "exportable" status 152 153 This function should be use in case Py++ made a mistake and signed the 154 declaration as unexportable.""" 155 self._exportable = exportable
156 157 exportable = property( get_exportable, set_exportable 158 , doc="Returns True if declaration could be exported to Python, otherwise False" ) 159
160 - def _readme_impl( self ):
161 return []
162
163 - def readme( self, skip_ignored=True ):
164 """return important information( hints/tips/warning message ) Py++ has about 165 this declaration. 166 167 skip_ignored argument allows you to control the information reported to you. 168 For more information please read: http://www.language-binding.net/pyplusplus/documentation/warnings.html 169 """ 170 msgs = [] 171 if not self.exportable: 172 msgs.append( self.why_not_exportable() ) 173 174 if declarations.templates.is_instantiation( self.name ) \ 175 and self.alias == self._generate_valid_name(): 176 msgs.append( messages.W1043 % self.alias ) 177 178 directives = self.__select_alias_directives(be_smart=False) 179 if 1 < len( directives ): 180 msgs.append( messages.W1048 181 % ( self.alias, ', '.join( map( lambda typedef: typedef.name, directives ) ) ) ) 182 183 msgs.extend( self._readme_impl() ) 184 185 return messages.filter_disabled_msgs( msgs, self.__msgs_to_ignore )
186 187 @property
188 - def disabled_messages( self ):
189 """list of messages to ignore""" 190 return self.__msgs_to_ignore 191 disabled_messaged = disabled_messages
192
193 - def disable_messages( self, *args ):
194 """set messages, which should not be reported to you 195 196 Usage example: decl.disable_messages( messages.W1001, messages.W1040 ) 197 """ 198 for msg in args: 199 msg_id = messages.find_out_message_id( msg ) 200 if not msg_id: 201 raise RuntimeError( "Unable to find out message id. The message is: " + msg ) 202 self.__msgs_to_ignore.add( msg )
203 disable_warnings = disable_messages 204 205 @property
206 - def include_files( self ):
207 """list of header files, to be included from the file, the generated code will be placed-in""" 208 return self._include_files
209