0001 # THIS FILE IS AUTOMATICALLY GENERATED. EDIT THE SOURCE FILE NOT THIS ONE 0002 0003 """Various descriptions of data specific to Sanyo Katana-II (SCP-6650)""" 0004 0005 from prototypes import * 0006 0007 # Make all sanyo stuff available in this module as well 0008 from p_sanyo import * 0009 from p_sanyomedia import * 0010 from p_sanyonewer import * 0011 from p_sanyo4930 import * 0012 from p_sanyo6600 import * 0013 0014 # We use LSB for all integer like fields 0015 UINT=UINTlsb 0016 BOOL=BOOLlsb 0017 NUMPHONEBOOKENTRIES=300 0018 MAXNUMBERS=500 0019 MAXEMAILS=600 0020 MAXURLS=300 0021 MAXMEMOS=300 0022 MAXADDRESSES=300 0023 _NUMSPEEDDIALS=8 0024 _NUMLONGNUMBERS=5 0025 _LONGPHONENUMBERLEN=30 0026 _NUMEVENTSLOTS=100 0027 _NUMCALLALARMSLOTS=15 0028 0029 MAXNUMBERLEN=32 0030 MAXEMAILLEN=96 0031 MAXURLLEN=96 0032 MAXMEMOLEN=96 0033 HASRINGPICBUF=0 0034 NUMGROUPS=20 0035 NUMPHONENUMBERS=7 0036 NUMEMAILS=2 0037 FIRSTSPEEDDIAL=2 0038 LASTSPEEDDIAL=9 0039 0040 0041 class pbsortbuffer(BaseProtogenClass): 0042 "Various arrays for sorting the phone book, speed dial, determining which" 0043 __fields=['startcommand', 'bufsize', 'comment', 'groupslotsused', 'pad', 'groupslotusedflags', 'slotsused', 'usedflags', 'speeddialindex', 'nameslotsused', 'nameusedflags', 'sortorder', 'pbfirstletters', 'numslotsused', 'numusedflags', 'emailslotsused', 'emailusedflags', 'urlslotsused', 'urlusedflags', 'num_address', 'addressusedflags', 'num_memo', 'memousedflags', 'junk'] 0044 0045 def __init__(self, *args, **kwargs): 0046 dict={} 0047 # What was supplied to this function 0048 dict.update(kwargs) 0049 # Parent constructor 0050 super(pbsortbuffer,self).__init__(**dict) 0051 if self.__class__ is pbsortbuffer: 0052 self._update(args,dict) 0053 0054 0055 def getfields(self): 0056 return self.__fields 0057 0058 0059 def _update(self, args, kwargs): 0060 super(pbsortbuffer,self)._update(args,kwargs) 0061 keys=kwargs.keys() 0062 for key in keys: 0063 if key in self.__fields: 0064 setattr(self, key, kwargs[key]) 0065 del kwargs[key] 0066 # Were any unrecognized kwargs passed in? 0067 if __debug__: 0068 self._complainaboutunusedargs(pbsortbuffer,kwargs) 0069 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 0070 # Make all P fields that haven't already been constructed 0071 try: self.__field_startcommand 0072 except: 0073 self.__field_startcommand=UINT(**{'constant': 0x76}) 0074 try: self.__field_bufsize 0075 except: 0076 self.__field_bufsize=UINT(**{'constant': 4096}) 0077 try: self.__field_comment 0078 except: 0079 self.__field_comment=USTRING(**{'default': "sort buffer"}) 0080 0081 0082 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 0083 'Writes this packet to the supplied buffer' 0084 self._bufferstartoffset=buf.getcurrentoffset() 0085 self.__field_groupslotsused.writetobuffer(buf) 0086 try: self.__field_pad 0087 except: 0088 self.__field_pad=UNKNOWN(**{'sizeinbytes': 2}) 0089 self.__field_pad.writetobuffer(buf) 0090 try: self.__field_groupslotusedflags 0091 except: 0092 self.__field_groupslotusedflags=LIST(**{'elementclass': _gen_p_sanyo6650_67, 'length': NUMGROUPS, 'createdefault': True}) 0093 self.__field_groupslotusedflags.writetobuffer(buf) 0094 self.__field_slotsused.writetobuffer(buf) 0095 try: self.__field_usedflags 0096 except: 0097 self.__field_usedflags=LIST(**{'elementclass': _gen_p_sanyo6650_71, 'length': NUMPHONEBOOKENTRIES, 'createdefault': True}) 0098 self.__field_usedflags.writetobuffer(buf) 0099 try: self.__field_speeddialindex 0100 except: 0101 self.__field_speeddialindex=LIST(**{'elementclass': _gen_p_sanyo6650_73, 'length': _NUMSPEEDDIALS}) 0102 self.__field_speeddialindex.writetobuffer(buf) 0103 self.__field_nameslotsused.writetobuffer(buf) 0104 try: self.__field_nameusedflags 0105 except: 0106 self.__field_nameusedflags=LIST(**{'elementclass': _gen_p_sanyo6650_77, 'length': NUMPHONEBOOKENTRIES, 'createdefault': True}) 0107 self.__field_nameusedflags.writetobuffer(buf) 0108 try: self.__field_sortorder 0109 except: 0110 self.__field_sortorder=LIST(**{'elementclass': _gen_p_sanyo6650_79, 'length': NUMPHONEBOOKENTRIES}) 0111 self.__field_sortorder.writetobuffer(buf) 0112 self.__field_pbfirstletters.writetobuffer(buf) 0113 self.__field_numslotsused.writetobuffer(buf) 0114 try: self.__field_numusedflags 0115 except: 0116 self.__field_numusedflags=LIST(**{'elementclass': _gen_p_sanyo6650_84, 'length': MAXNUMBERS, 'createdefault': True}) 0117 self.__field_numusedflags.writetobuffer(buf) 0118 self.__field_emailslotsused.writetobuffer(buf) 0119 try: self.__field_emailusedflags 0120 except: 0121 self.__field_emailusedflags=LIST(**{'elementclass': _gen_p_sanyo6650_88, 'length': MAXEMAILS, 'createdefault': True}) 0122 self.__field_emailusedflags.writetobuffer(buf) 0123 self.__field_urlslotsused.writetobuffer(buf) 0124 try: self.__field_urlusedflags 0125 except: 0126 self.__field_urlusedflags=LIST(**{'elementclass': _gen_p_sanyo6650_91, 'length': MAXURLS, 'createdefault': True}) 0127 self.__field_urlusedflags.writetobuffer(buf) 0128 self.__field_num_address.writetobuffer(buf) 0129 try: self.__field_addressusedflags 0130 except: 0131 self.__field_addressusedflags=LIST(**{'elementclass': _gen_p_sanyo6650_95, 'length': NUMPHONEBOOKENTRIES, 'createdefault': True}) 0132 self.__field_addressusedflags.writetobuffer(buf) 0133 self.__field_num_memo.writetobuffer(buf) 0134 try: self.__field_memousedflags 0135 except: 0136 self.__field_memousedflags=LIST(**{'elementclass': _gen_p_sanyo6650_99, 'length': NUMPHONEBOOKENTRIES, 'createdefault': True}) 0137 self.__field_memousedflags.writetobuffer(buf) 0138 try: self.__field_junk 0139 except: 0140 self.__field_junk=UNKNOWN(**{'sizeinbytes': 543}) 0141 self.__field_junk.writetobuffer(buf) 0142 self._bufferendoffset=buf.getcurrentoffset() 0143 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 0144 0145 0146 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 0147 'Reads this packet from the supplied buffer' 0148 self._bufferstartoffset=buf.getcurrentoffset() 0149 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 0150 self.__field_groupslotsused=UINT(**{'sizeinbytes': 1}) 0151 self.__field_groupslotsused.readfrombuffer(buf) 0152 self.__field_pad=UNKNOWN(**{'sizeinbytes': 2}) 0153 self.__field_pad.readfrombuffer(buf) 0154 self.__field_groupslotusedflags=LIST(**{'elementclass': _gen_p_sanyo6650_67, 'length': NUMGROUPS, 'createdefault': True}) 0155 self.__field_groupslotusedflags.readfrombuffer(buf) 0156 self.__field_slotsused=UINT(**{'sizeinbytes': 2}) 0157 self.__field_slotsused.readfrombuffer(buf) 0158 self.__field_usedflags=LIST(**{'elementclass': _gen_p_sanyo6650_71, 'length': NUMPHONEBOOKENTRIES, 'createdefault': True}) 0159 self.__field_usedflags.readfrombuffer(buf) 0160 self.__field_speeddialindex=LIST(**{'elementclass': _gen_p_sanyo6650_73, 'length': _NUMSPEEDDIALS}) 0161 self.__field_speeddialindex.readfrombuffer(buf) 0162 self.__field_nameslotsused=UINT(**{'sizeinbytes': 2}) 0163 self.__field_nameslotsused.readfrombuffer(buf) 0164 self.__field_nameusedflags=LIST(**{'elementclass': _gen_p_sanyo6650_77, 'length': NUMPHONEBOOKENTRIES, 'createdefault': True}) 0165 self.__field_nameusedflags.readfrombuffer(buf) 0166 self.__field_sortorder=LIST(**{'elementclass': _gen_p_sanyo6650_79, 'length': NUMPHONEBOOKENTRIES}) 0167 self.__field_sortorder.readfrombuffer(buf) 0168 self.__field_pbfirstletters=USTRING(**{'terminator': None, 'sizeinbytes': NUMPHONEBOOKENTRIES}) 0169 self.__field_pbfirstletters.readfrombuffer(buf) 0170 self.__field_numslotsused=UINT(**{'sizeinbytes': 2}) 0171 self.__field_numslotsused.readfrombuffer(buf) 0172 self.__field_numusedflags=LIST(**{'elementclass': _gen_p_sanyo6650_84, 'length': MAXNUMBERS, 'createdefault': True}) 0173 self.__field_numusedflags.readfrombuffer(buf) 0174 self.__field_emailslotsused=UINT(**{'sizeinbytes': 2}) 0175 self.__field_emailslotsused.readfrombuffer(buf) 0176 self.__field_emailusedflags=LIST(**{'elementclass': _gen_p_sanyo6650_88, 'length': MAXEMAILS, 'createdefault': True}) 0177 self.__field_emailusedflags.readfrombuffer(buf) 0178 self.__field_urlslotsused=UINT(**{'sizeinbytes': 2}) 0179 self.__field_urlslotsused.readfrombuffer(buf) 0180 self.__field_urlusedflags=LIST(**{'elementclass': _gen_p_sanyo6650_91, 'length': MAXURLS, 'createdefault': True}) 0181 self.__field_urlusedflags.readfrombuffer(buf) 0182 self.__field_num_address=UINT(**{'sizeinbytes': 2}) 0183 self.__field_num_address.readfrombuffer(buf) 0184 self.__field_addressusedflags=LIST(**{'elementclass': _gen_p_sanyo6650_95, 'length': NUMPHONEBOOKENTRIES, 'createdefault': True}) 0185 self.__field_addressusedflags.readfrombuffer(buf) 0186 self.__field_num_memo=UINT(**{'sizeinbytes': 2}) 0187 self.__field_num_memo.readfrombuffer(buf) 0188 self.__field_memousedflags=LIST(**{'elementclass': _gen_p_sanyo6650_99, 'length': NUMPHONEBOOKENTRIES, 'createdefault': True}) 0189 self.__field_memousedflags.readfrombuffer(buf) 0190 self.__field_junk=UNKNOWN(**{'sizeinbytes': 543}) 0191 self.__field_junk.readfrombuffer(buf) 0192 self._bufferendoffset=buf.getcurrentoffset() 0193 0194 0195 def __getfield_startcommand(self): 0196 return self.__field_startcommand.getvalue() 0197 0198 def __setfield_startcommand(self, value): 0199 if isinstance(value,UINT): 0200 self.__field_startcommand=value 0201 else: 0202 self.__field_startcommand=UINT(value,**{'constant': 0x76}) 0203 0204 def __delfield_startcommand(self): del self.__field_startcommand 0205 0206 startcommand=property(__getfield_startcommand, __setfield_startcommand, __delfield_startcommand, "Starting command for R/W buf parts") 0207 0208 def __getfield_bufsize(self): 0209 return self.__field_bufsize.getvalue() 0210 0211 def __setfield_bufsize(self, value): 0212 if isinstance(value,UINT): 0213 self.__field_bufsize=value 0214 else: 0215 self.__field_bufsize=UINT(value,**{'constant': 4096}) 0216 0217 def __delfield_bufsize(self): del self.__field_bufsize 0218 0219 bufsize=property(__getfield_bufsize, __setfield_bufsize, __delfield_bufsize, None) 0220 0221 def __getfield_comment(self): 0222 try: self.__field_comment 0223 except: 0224 self.__field_comment=USTRING(**{'default': "sort buffer"}) 0225 return self.__field_comment.getvalue() 0226 0227 def __setfield_comment(self, value): 0228 if isinstance(value,USTRING): 0229 self.__field_comment=value 0230 else: 0231 self.__field_comment=USTRING(value,**{'default': "sort buffer"}) 0232 0233 def __delfield_comment(self): del self.__field_comment 0234 0235 comment=property(__getfield_comment, __setfield_comment, __delfield_comment, None) 0236 0237 def __getfield_groupslotsused(self): 0238 return self.__field_groupslotsused.getvalue() 0239 0240 def __setfield_groupslotsused(self, value): 0241 if isinstance(value,UINT): 0242 self.__field_groupslotsused=value 0243 else: 0244 self.__field_groupslotsused=UINT(value,**{'sizeinbytes': 1}) 0245 0246 def __delfield_groupslotsused(self): del self.__field_groupslotsused 0247 0248 groupslotsused=property(__getfield_groupslotsused, __setfield_groupslotsused, __delfield_groupslotsused, None) 0249 0250 def __getfield_pad(self): 0251 try: self.__field_pad 0252 except: 0253 self.__field_pad=UNKNOWN(**{'sizeinbytes': 2}) 0254 return self.__field_pad.getvalue() 0255 0256 def __setfield_pad(self, value): 0257 if isinstance(value,UNKNOWN): 0258 self.__field_pad=value 0259 else: 0260 self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 2}) 0261 0262 def __delfield_pad(self): del self.__field_pad 0263 0264 pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None) 0265 0266 def __getfield_groupslotusedflags(self): 0267 try: self.__field_groupslotusedflags 0268 except: 0269 self.__field_groupslotusedflags=LIST(**{'elementclass': _gen_p_sanyo6650_67, 'length': NUMGROUPS, 'createdefault': True}) 0270 return self.__field_groupslotusedflags.getvalue() 0271 0272 def __setfield_groupslotusedflags(self, value): 0273 if isinstance(value,LIST): 0274 self.__field_groupslotusedflags=value 0275 else: 0276 self.__field_groupslotusedflags=LIST(value,**{'elementclass': _gen_p_sanyo6650_67, 'length': NUMGROUPS, 'createdefault': True}) 0277 0278 def __delfield_groupslotusedflags(self): del self.__field_groupslotusedflags 0279 0280 groupslotusedflags=property(__getfield_groupslotusedflags, __setfield_groupslotusedflags, __delfield_groupslotusedflags, None) 0281 0282 def __getfield_slotsused(self): 0283 return self.__field_slotsused.getvalue() 0284 0285 def __setfield_slotsused(self, value): 0286 if isinstance(value,UINT): 0287 self.__field_slotsused=value 0288 else: 0289 self.__field_slotsused=UINT(value,**{'sizeinbytes': 2}) 0290 0291 def __delfield_slotsused(self): del self.__field_slotsused 0292 0293 slotsused=property(__getfield_slotsused, __setfield_slotsused, __delfield_slotsused, None) 0294 0295 def __getfield_usedflags(self): 0296 try: self.__field_usedflags 0297 except: 0298 self.__field_usedflags=LIST(**{'elementclass': _gen_p_sanyo6650_71, 'length': NUMPHONEBOOKENTRIES, 'createdefault': True}) 0299 return self.__field_usedflags.getvalue() 0300 0301 def __setfield_usedflags(self, value): 0302 if isinstance(value,LIST): 0303 self.__field_usedflags=value 0304 else: 0305 self.__field_usedflags=LIST(value,**{'elementclass': _gen_p_sanyo6650_71, 'length': NUMPHONEBOOKENTRIES, 'createdefault': True}) 0306 0307 def __delfield_usedflags(self): del self.__field_usedflags 0308 0309 usedflags=property(__getfield_usedflags, __setfield_usedflags, __delfield_usedflags, None) 0310 0311 def __getfield_speeddialindex(self): 0312 try: self.__field_speeddialindex 0313 except: 0314 self.__field_speeddialindex=LIST(**{'elementclass': _gen_p_sanyo6650_73, 'length': _NUMSPEEDDIALS}) 0315 return self.__field_speeddialindex.getvalue() 0316 0317 def __setfield_speeddialindex(self, value): 0318 if isinstance(value,LIST): 0319 self.__field_speeddialindex=value 0320 else: 0321 self.__field_speeddialindex=LIST(value,**{'elementclass': _gen_p_sanyo6650_73, 'length': _NUMSPEEDDIALS}) 0322 0323 def __delfield_speeddialindex(self): del self.__field_speeddialindex 0324 0325 speeddialindex=property(__getfield_speeddialindex, __setfield_speeddialindex, __delfield_speeddialindex, None) 0326 0327 def __getfield_nameslotsused(self): 0328 return self.__field_nameslotsused.getvalue() 0329 0330 def __setfield_nameslotsused(self, value): 0331 if isinstance(value,UINT): 0332 self.__field_nameslotsused=value 0333 else: 0334 self.__field_nameslotsused=UINT(value,**{'sizeinbytes': 2}) 0335 0336 def __delfield_nameslotsused(self): del self.__field_nameslotsused 0337 0338 nameslotsused=property(__getfield_nameslotsused, __setfield_nameslotsused, __delfield_nameslotsused, "Always seems to be the same. Why duplicated?") 0339 0340 def __getfield_nameusedflags(self): 0341 try: self.__field_nameusedflags 0342 except: 0343 self.__field_nameusedflags=LIST(**{'elementclass': _gen_p_sanyo6650_77, 'length': NUMPHONEBOOKENTRIES, 'createdefault': True}) 0344 return self.__field_nameusedflags.getvalue() 0345 0346 def __setfield_nameusedflags(self, value): 0347 if isinstance(value,LIST): 0348 self.__field_nameusedflags=value 0349 else: 0350 self.__field_nameusedflags=LIST(value,**{'elementclass': _gen_p_sanyo6650_77, 'length': NUMPHONEBOOKENTRIES, 'createdefault': True}) 0351 0352 def __delfield_nameusedflags(self): del self.__field_nameusedflags 0353 0354 nameusedflags=property(__getfield_nameusedflags, __setfield_nameusedflags, __delfield_nameusedflags, None) 0355 0356 def __getfield_sortorder(self): 0357 try: self.__field_sortorder 0358 except: 0359 self.__field_sortorder=LIST(**{'elementclass': _gen_p_sanyo6650_79, 'length': NUMPHONEBOOKENTRIES}) 0360 return self.__field_sortorder.getvalue() 0361 0362 def __setfield_sortorder(self, value): 0363 if isinstance(value,LIST): 0364 self.__field_sortorder=value 0365 else: 0366 self.__field_sortorder=LIST(value,**{'elementclass': _gen_p_sanyo6650_79, 'length': NUMPHONEBOOKENTRIES}) 0367 0368 def __delfield_sortorder(self): del self.__field_sortorder 0369 0370 sortorder=property(__getfield_sortorder, __setfield_sortorder, __delfield_sortorder, None) 0371 0372 def __getfield_pbfirstletters(self): 0373 return self.__field_pbfirstletters.getvalue() 0374 0375 def __setfield_pbfirstletters(self, value): 0376 if isinstance(value,USTRING): 0377 self.__field_pbfirstletters=value 0378 else: 0379 self.__field_pbfirstletters=USTRING(value,**{'terminator': None, 'sizeinbytes': NUMPHONEBOOKENTRIES}) 0380 0381 def __delfield_pbfirstletters(self): del self.__field_pbfirstletters 0382 0383 pbfirstletters=property(__getfield_pbfirstletters, __setfield_pbfirstletters, __delfield_pbfirstletters, None) 0384 0385 def __getfield_numslotsused(self): 0386 return self.__field_numslotsused.getvalue() 0387 0388 def __setfield_numslotsused(self, value): 0389 if isinstance(value,UINT): 0390 self.__field_numslotsused=value 0391 else: 0392 self.__field_numslotsused=UINT(value,**{'sizeinbytes': 2}) 0393 0394 def __delfield_numslotsused(self): del self.__field_numslotsused 0395 0396 numslotsused=property(__getfield_numslotsused, __setfield_numslotsused, __delfield_numslotsused, "Number of phone number slots used") 0397 0398 def __getfield_numusedflags(self): 0399 try: self.__field_numusedflags 0400 except: 0401 self.__field_numusedflags=LIST(**{'elementclass': _gen_p_sanyo6650_84, 'length': MAXNUMBERS, 'createdefault': True}) 0402 return self.__field_numusedflags.getvalue() 0403 0404 def __setfield_numusedflags(self, value): 0405 if isinstance(value,LIST): 0406 self.__field_numusedflags=value 0407 else: 0408 self.__field_numusedflags=LIST(value,**{'elementclass': _gen_p_sanyo6650_84, 'length': MAXNUMBERS, 'createdefault': True}) 0409 0410 def __delfield_numusedflags(self): del self.__field_numusedflags 0411 0412 numusedflags=property(__getfield_numusedflags, __setfield_numusedflags, __delfield_numusedflags, None) 0413 0414 def __getfield_emailslotsused(self): 0415 return self.__field_emailslotsused.getvalue() 0416 0417 def __setfield_emailslotsused(self, value): 0418 if isinstance(value,UINT): 0419 self.__field_emailslotsused=value 0420 else: 0421 self.__field_emailslotsused=UINT(value,**{'sizeinbytes': 2}) 0422 0423 def __delfield_emailslotsused(self): del self.__field_emailslotsused 0424 0425 emailslotsused=property(__getfield_emailslotsused, __setfield_emailslotsused, __delfield_emailslotsused, None) 0426 0427 def __getfield_emailusedflags(self): 0428 try: self.__field_emailusedflags 0429 except: 0430 self.__field_emailusedflags=LIST(**{'elementclass': _gen_p_sanyo6650_88, 'length': MAXEMAILS, 'createdefault': True}) 0431 return self.__field_emailusedflags.getvalue() 0432 0433 def __setfield_emailusedflags(self, value): 0434 if isinstance(value,LIST): 0435 self.__field_emailusedflags=value 0436 else: 0437 self.__field_emailusedflags=LIST(value,**{'elementclass': _gen_p_sanyo6650_88, 'length': MAXEMAILS, 'createdefault': True}) 0438 0439 def __delfield_emailusedflags(self): del self.__field_emailusedflags 0440 0441 emailusedflags=property(__getfield_emailusedflags, __setfield_emailusedflags, __delfield_emailusedflags, None) 0442 0443 def __getfield_urlslotsused(self): 0444 return self.__field_urlslotsused.getvalue() 0445 0446 def __setfield_urlslotsused(self, value): 0447 if isinstance(value,UINT): 0448 self.__field_urlslotsused=value 0449 else: 0450 self.__field_urlslotsused=UINT(value,**{'sizeinbytes': 2}) 0451 0452 def __delfield_urlslotsused(self): del self.__field_urlslotsused 0453 0454 urlslotsused=property(__getfield_urlslotsused, __setfield_urlslotsused, __delfield_urlslotsused, None) 0455 0456 def __getfield_urlusedflags(self): 0457 try: self.__field_urlusedflags 0458 except: 0459 self.__field_urlusedflags=LIST(**{'elementclass': _gen_p_sanyo6650_91, 'length': MAXURLS, 'createdefault': True}) 0460 return self.__field_urlusedflags.getvalue() 0461 0462 def __setfield_urlusedflags(self, value): 0463 if isinstance(value,LIST): 0464 self.__field_urlusedflags=value 0465 else: 0466 self.__field_urlusedflags=LIST(value,**{'elementclass': _gen_p_sanyo6650_91, 'length': MAXURLS, 'createdefault': True}) 0467 0468 def __delfield_urlusedflags(self): del self.__field_urlusedflags 0469 0470 urlusedflags=property(__getfield_urlusedflags, __setfield_urlusedflags, __delfield_urlusedflags, None) 0471 0472 def __getfield_num_address(self): 0473 return self.__field_num_address.getvalue() 0474 0475 def __setfield_num_address(self, value): 0476 if isinstance(value,UINT): 0477 self.__field_num_address=value 0478 else: 0479 self.__field_num_address=UINT(value,**{'sizeinbytes': 2}) 0480 0481 def __delfield_num_address(self): del self.__field_num_address 0482 0483 num_address=property(__getfield_num_address, __setfield_num_address, __delfield_num_address, None) 0484 0485 def __getfield_addressusedflags(self): 0486 try: self.__field_addressusedflags 0487 except: 0488 self.__field_addressusedflags=LIST(**{'elementclass': _gen_p_sanyo6650_95, 'length': NUMPHONEBOOKENTRIES, 'createdefault': True}) 0489 return self.__field_addressusedflags.getvalue() 0490 0491 def __setfield_addressusedflags(self, value): 0492 if isinstance(value,LIST): 0493 self.__field_addressusedflags=value 0494 else: 0495 self.__field_addressusedflags=LIST(value,**{'elementclass': _gen_p_sanyo6650_95, 'length': NUMPHONEBOOKENTRIES, 'createdefault': True}) 0496 0497 def __delfield_addressusedflags(self): del self.__field_addressusedflags 0498 0499 addressusedflags=property(__getfield_addressusedflags, __setfield_addressusedflags, __delfield_addressusedflags, None) 0500 0501 def __getfield_num_memo(self): 0502 return self.__field_num_memo.getvalue() 0503 0504 def __setfield_num_memo(self, value): 0505 if isinstance(value,UINT): 0506 self.__field_num_memo=value 0507 else: 0508 self.__field_num_memo=UINT(value,**{'sizeinbytes': 2}) 0509 0510 def __delfield_num_memo(self): del self.__field_num_memo 0511 0512 num_memo=property(__getfield_num_memo, __setfield_num_memo, __delfield_num_memo, None) 0513 0514 def __getfield_memousedflags(self): 0515 try: self.__field_memousedflags 0516 except: 0517 self.__field_memousedflags=LIST(**{'elementclass': _gen_p_sanyo6650_99, 'length': NUMPHONEBOOKENTRIES, 'createdefault': True}) 0518 return self.__field_memousedflags.getvalue() 0519 0520 def __setfield_memousedflags(self, value): 0521 if isinstance(value,LIST): 0522 self.__field_memousedflags=value 0523 else: 0524 self.__field_memousedflags=LIST(value,**{'elementclass': _gen_p_sanyo6650_99, 'length': NUMPHONEBOOKENTRIES, 'createdefault': True}) 0525 0526 def __delfield_memousedflags(self): del self.__field_memousedflags 0527 0528 memousedflags=property(__getfield_memousedflags, __setfield_memousedflags, __delfield_memousedflags, None) 0529 0530 def __getfield_junk(self): 0531 try: self.__field_junk 0532 except: 0533 self.__field_junk=UNKNOWN(**{'sizeinbytes': 543}) 0534 return self.__field_junk.getvalue() 0535 0536 def __setfield_junk(self, value): 0537 if isinstance(value,UNKNOWN): 0538 self.__field_junk=value 0539 else: 0540 self.__field_junk=UNKNOWN(value,**{'sizeinbytes': 543}) 0541 0542 def __delfield_junk(self): del self.__field_junk 0543 0544 junk=property(__getfield_junk, __setfield_junk, __delfield_junk, None) 0545 0546 def iscontainer(self): 0547 return True 0548 0549 def containerelements(self): 0550 yield ('startcommand', self.__field_startcommand, "Starting command for R/W buf parts") 0551 yield ('bufsize', self.__field_bufsize, None) 0552 yield ('comment', self.__field_comment, None) 0553 yield ('groupslotsused', self.__field_groupslotsused, None) 0554 yield ('pad', self.__field_pad, None) 0555 yield ('groupslotusedflags', self.__field_groupslotusedflags, None) 0556 yield ('slotsused', self.__field_slotsused, None) 0557 yield ('usedflags', self.__field_usedflags, None) 0558 yield ('speeddialindex', self.__field_speeddialindex, None) 0559 yield ('nameslotsused', self.__field_nameslotsused, "Always seems to be the same. Why duplicated?") 0560 yield ('nameusedflags', self.__field_nameusedflags, None) 0561 yield ('sortorder', self.__field_sortorder, None) 0562 yield ('pbfirstletters', self.__field_pbfirstletters, None) 0563 yield ('numslotsused', self.__field_numslotsused, "Number of phone number slots used") 0564 yield ('numusedflags', self.__field_numusedflags, None) 0565 yield ('emailslotsused', self.__field_emailslotsused, None) 0566 yield ('emailusedflags', self.__field_emailusedflags, None) 0567 yield ('urlslotsused', self.__field_urlslotsused, None) 0568 yield ('urlusedflags', self.__field_urlusedflags, None) 0569 yield ('num_address', self.__field_num_address, None) 0570 yield ('addressusedflags', self.__field_addressusedflags, None) 0571 yield ('num_memo', self.__field_num_memo, None) 0572 yield ('memousedflags', self.__field_memousedflags, None) 0573 yield ('junk', self.__field_junk, None) 0574 0575 0576 0577 0578 class _gen_p_sanyo6650_67(BaseProtogenClass): 0579 'Anonymous inner class' 0580 __fields=['used'] 0581 0582 def __init__(self, *args, **kwargs): 0583 dict={} 0584 # What was supplied to this function 0585 dict.update(kwargs) 0586 # Parent constructor 0587 super(_gen_p_sanyo6650_67,self).__init__(**dict) 0588 if self.__class__ is _gen_p_sanyo6650_67: 0589 self._update(args,dict) 0590 0591 0592 def getfields(self): 0593 return self.__fields 0594 0595 0596 def _update(self, args, kwargs): 0597 super(_gen_p_sanyo6650_67,self)._update(args,kwargs) 0598 keys=kwargs.keys() 0599 for key in keys: 0600 if key in self.__fields: 0601 setattr(self, key, kwargs[key]) 0602 del kwargs[key] 0603 # Were any unrecognized kwargs passed in? 0604 if __debug__: 0605 self._complainaboutunusedargs(_gen_p_sanyo6650_67,kwargs) 0606 if len(args): 0607 dict2={'sizeinbytes': 1} 0608 dict2.update(kwargs) 0609 kwargs=dict2 0610 self.__field_used=UINT(*args,**dict2) 0611 # Make all P fields that haven't already been constructed 0612 0613 0614 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 0615 'Writes this packet to the supplied buffer' 0616 self._bufferstartoffset=buf.getcurrentoffset() 0617 self.__field_used.writetobuffer(buf) 0618 self._bufferendoffset=buf.getcurrentoffset() 0619 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 0620 0621 0622 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 0623 'Reads this packet from the supplied buffer' 0624 self._bufferstartoffset=buf.getcurrentoffset() 0625 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 0626 self.__field_used=UINT(**{'sizeinbytes': 1}) 0627 self.__field_used.readfrombuffer(buf) 0628 self._bufferendoffset=buf.getcurrentoffset() 0629 0630 0631 def __getfield_used(self): 0632 return self.__field_used.getvalue() 0633 0634 def __setfield_used(self, value): 0635 if isinstance(value,UINT): 0636 self.__field_used=value 0637 else: 0638 self.__field_used=UINT(value,**{'sizeinbytes': 1}) 0639 0640 def __delfield_used(self): del self.__field_used 0641 0642 used=property(__getfield_used, __setfield_used, __delfield_used, "1 if slot in use") 0643 0644 def iscontainer(self): 0645 return True 0646 0647 def containerelements(self): 0648 yield ('used', self.__field_used, "1 if slot in use") 0649 0650 0651 0652 0653 class _gen_p_sanyo6650_71(BaseProtogenClass): 0654 'Anonymous inner class' 0655 __fields=['used'] 0656 0657 def __init__(self, *args, **kwargs): 0658 dict={} 0659 # What was supplied to this function 0660 dict.update(kwargs) 0661 # Parent constructor 0662 super(_gen_p_sanyo6650_71,self).__init__(**dict) 0663 if self.__class__ is _gen_p_sanyo6650_71: 0664 self._update(args,dict) 0665 0666 0667 def getfields(self): 0668 return self.__fields 0669 0670 0671 def _update(self, args, kwargs): 0672 super(_gen_p_sanyo6650_71,self)._update(args,kwargs) 0673 keys=kwargs.keys() 0674 for key in keys: 0675 if key in self.__fields: 0676 setattr(self, key, kwargs[key]) 0677 del kwargs[key] 0678 # Were any unrecognized kwargs passed in? 0679 if __debug__: 0680 self._complainaboutunusedargs(_gen_p_sanyo6650_71,kwargs) 0681 if len(args): 0682 dict2={'sizeinbytes': 1} 0683 dict2.update(kwargs) 0684 kwargs=dict2 0685 self.__field_used=UINT(*args,**dict2) 0686 # Make all P fields that haven't already been constructed 0687 0688 0689 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 0690 'Writes this packet to the supplied buffer' 0691 self._bufferstartoffset=buf.getcurrentoffset() 0692 self.__field_used.writetobuffer(buf) 0693 self._bufferendoffset=buf.getcurrentoffset() 0694 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 0695 0696 0697 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 0698 'Reads this packet from the supplied buffer' 0699 self._bufferstartoffset=buf.getcurrentoffset() 0700 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 0701 self.__field_used=UINT(**{'sizeinbytes': 1}) 0702 self.__field_used.readfrombuffer(buf) 0703 self._bufferendoffset=buf.getcurrentoffset() 0704 0705 0706 def __getfield_used(self): 0707 return self.__field_used.getvalue() 0708 0709 def __setfield_used(self, value): 0710 if isinstance(value,UINT): 0711 self.__field_used=value 0712 else: 0713 self.__field_used=UINT(value,**{'sizeinbytes': 1}) 0714 0715 def __delfield_used(self): del self.__field_used 0716 0717 used=property(__getfield_used, __setfield_used, __delfield_used, "1 if slot in use") 0718 0719 def iscontainer(self): 0720 return True 0721 0722 def containerelements(self): 0723 yield ('used', self.__field_used, "1 if slot in use") 0724 0725 0726 0727 0728 class _gen_p_sanyo6650_73(BaseProtogenClass): 0729 'Anonymous inner class' 0730 __fields=['numslot'] 0731 0732 def __init__(self, *args, **kwargs): 0733 dict={} 0734 # What was supplied to this function 0735 dict.update(kwargs) 0736 # Parent constructor 0737 super(_gen_p_sanyo6650_73,self).__init__(**dict) 0738 if self.__class__ is _gen_p_sanyo6650_73: 0739 self._update(args,dict) 0740 0741 0742 def getfields(self): 0743 return self.__fields 0744 0745 0746 def _update(self, args, kwargs): 0747 super(_gen_p_sanyo6650_73,self)._update(args,kwargs) 0748 keys=kwargs.keys() 0749 for key in keys: 0750 if key in self.__fields: 0751 setattr(self, key, kwargs[key]) 0752 del kwargs[key] 0753 # Were any unrecognized kwargs passed in? 0754 if __debug__: 0755 self._complainaboutunusedargs(_gen_p_sanyo6650_73,kwargs) 0756 if len(args): 0757 dict2={'sizeinbytes': 2, 'default': 0xffff} 0758 dict2.update(kwargs) 0759 kwargs=dict2 0760 self.__field_numslot=UINT(*args,**dict2) 0761 # Make all P fields that haven't already been constructed 0762 0763 0764 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 0765 'Writes this packet to the supplied buffer' 0766 self._bufferstartoffset=buf.getcurrentoffset() 0767 self.__field_numslot.writetobuffer(buf) 0768 self._bufferendoffset=buf.getcurrentoffset() 0769 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 0770 0771 0772 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 0773 'Reads this packet from the supplied buffer' 0774 self._bufferstartoffset=buf.getcurrentoffset() 0775 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 0776 self.__field_numslot=UINT(**{'sizeinbytes': 2, 'default': 0xffff}) 0777 self.__field_numslot.readfrombuffer(buf) 0778 self._bufferendoffset=buf.getcurrentoffset() 0779 0780 0781 def __getfield_numslot(self): 0782 return self.__field_numslot.getvalue() 0783 0784 def __setfield_numslot(self, value): 0785 if isinstance(value,UINT): 0786 self.__field_numslot=value 0787 else: 0788 self.__field_numslot=UINT(value,**{'sizeinbytes': 2, 'default': 0xffff}) 0789 0790 def __delfield_numslot(self): del self.__field_numslot 0791 0792 numslot=property(__getfield_numslot, __setfield_numslot, __delfield_numslot, None) 0793 0794 def iscontainer(self): 0795 return True 0796 0797 def containerelements(self): 0798 yield ('numslot', self.__field_numslot, None) 0799 0800 0801 0802 0803 class _gen_p_sanyo6650_77(BaseProtogenClass): 0804 'Anonymous inner class' 0805 __fields=['used'] 0806 0807 def __init__(self, *args, **kwargs): 0808 dict={} 0809 # What was supplied to this function 0810 dict.update(kwargs) 0811 # Parent constructor 0812 super(_gen_p_sanyo6650_77,self).__init__(**dict) 0813 if self.__class__ is _gen_p_sanyo6650_77: 0814 self._update(args,dict) 0815 0816 0817 def getfields(self): 0818 return self.__fields 0819 0820 0821 def _update(self, args, kwargs): 0822 super(_gen_p_sanyo6650_77,self)._update(args,kwargs) 0823 keys=kwargs.keys() 0824 for key in keys: 0825 if key in self.__fields: 0826 setattr(self, key, kwargs[key]) 0827 del kwargs[key] 0828 # Were any unrecognized kwargs passed in? 0829 if __debug__: 0830 self._complainaboutunusedargs(_gen_p_sanyo6650_77,kwargs) 0831 if len(args): 0832 dict2={'sizeinbytes': 1} 0833 dict2.update(kwargs) 0834 kwargs=dict2 0835 self.__field_used=UINT(*args,**dict2) 0836 # Make all P fields that haven't already been constructed 0837 0838 0839 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 0840 'Writes this packet to the supplied buffer' 0841 self._bufferstartoffset=buf.getcurrentoffset() 0842 self.__field_used.writetobuffer(buf) 0843 self._bufferendoffset=buf.getcurrentoffset() 0844 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 0845 0846 0847 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 0848 'Reads this packet from the supplied buffer' 0849 self._bufferstartoffset=buf.getcurrentoffset() 0850 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 0851 self.__field_used=UINT(**{'sizeinbytes': 1}) 0852 self.__field_used.readfrombuffer(buf) 0853 self._bufferendoffset=buf.getcurrentoffset() 0854 0855 0856 def __getfield_used(self): 0857 return self.__field_used.getvalue() 0858 0859 def __setfield_used(self, value): 0860 if isinstance(value,UINT): 0861 self.__field_used=value 0862 else: 0863 self.__field_used=UINT(value,**{'sizeinbytes': 1}) 0864 0865 def __delfield_used(self): del self.__field_used 0866 0867 used=property(__getfield_used, __setfield_used, __delfield_used, "1 if slot in use") 0868 0869 def iscontainer(self): 0870 return True 0871 0872 def containerelements(self): 0873 yield ('used', self.__field_used, "1 if slot in use") 0874 0875 0876 0877 0878 class _gen_p_sanyo6650_79(BaseProtogenClass): 0879 'Anonymous inner class' 0880 __fields=['pbslot'] 0881 0882 def __init__(self, *args, **kwargs): 0883 dict={} 0884 # What was supplied to this function 0885 dict.update(kwargs) 0886 # Parent constructor 0887 super(_gen_p_sanyo6650_79,self).__init__(**dict) 0888 if self.__class__ is _gen_p_sanyo6650_79: 0889 self._update(args,dict) 0890 0891 0892 def getfields(self): 0893 return self.__fields 0894 0895 0896 def _update(self, args, kwargs): 0897 super(_gen_p_sanyo6650_79,self)._update(args,kwargs) 0898 keys=kwargs.keys() 0899 for key in keys: 0900 if key in self.__fields: 0901 setattr(self, key, kwargs[key]) 0902 del kwargs[key] 0903 # Were any unrecognized kwargs passed in? 0904 if __debug__: 0905 self._complainaboutunusedargs(_gen_p_sanyo6650_79,kwargs) 0906 if len(args): 0907 dict2={'sizeinbytes': 2, 'default': 0xffff} 0908 dict2.update(kwargs) 0909 kwargs=dict2 0910 self.__field_pbslot=UINT(*args,**dict2) 0911 # Make all P fields that haven't already been constructed 0912 0913 0914 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 0915 'Writes this packet to the supplied buffer' 0916 self._bufferstartoffset=buf.getcurrentoffset() 0917 self.__field_pbslot.writetobuffer(buf) 0918 self._bufferendoffset=buf.getcurrentoffset() 0919 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 0920 0921 0922 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 0923 'Reads this packet from the supplied buffer' 0924 self._bufferstartoffset=buf.getcurrentoffset() 0925 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 0926 self.__field_pbslot=UINT(**{'sizeinbytes': 2, 'default': 0xffff}) 0927 self.__field_pbslot.readfrombuffer(buf) 0928 self._bufferendoffset=buf.getcurrentoffset() 0929 0930 0931 def __getfield_pbslot(self): 0932 return self.__field_pbslot.getvalue() 0933 0934 def __setfield_pbslot(self, value): 0935 if isinstance(value,UINT): 0936 self.__field_pbslot=value 0937 else: 0938 self.__field_pbslot=UINT(value,**{'sizeinbytes': 2, 'default': 0xffff}) 0939 0940 def __delfield_pbslot(self): del self.__field_pbslot 0941 0942 pbslot=property(__getfield_pbslot, __setfield_pbslot, __delfield_pbslot, None) 0943 0944 def iscontainer(self): 0945 return True 0946 0947 def containerelements(self): 0948 yield ('pbslot', self.__field_pbslot, None) 0949 0950 0951 0952 0953 class _gen_p_sanyo6650_84(BaseProtogenClass): 0954 'Anonymous inner class' 0955 __fields=['used'] 0956 0957 def __init__(self, *args, **kwargs): 0958 dict={} 0959 # What was supplied to this function 0960 dict.update(kwargs) 0961 # Parent constructor 0962 super(_gen_p_sanyo6650_84,self).__init__(**dict) 0963 if self.__class__ is _gen_p_sanyo6650_84: 0964 self._update(args,dict) 0965 0966 0967 def getfields(self): 0968 return self.__fields 0969 0970 0971 def _update(self, args, kwargs): 0972 super(_gen_p_sanyo6650_84,self)._update(args,kwargs) 0973 keys=kwargs.keys() 0974 for key in keys: 0975 if key in self.__fields: 0976 setattr(self, key, kwargs[key]) 0977 del kwargs[key] 0978 # Were any unrecognized kwargs passed in? 0979 if __debug__: 0980 self._complainaboutunusedargs(_gen_p_sanyo6650_84,kwargs) 0981 if len(args): 0982 dict2={'sizeinbytes': 1} 0983 dict2.update(kwargs) 0984 kwargs=dict2 0985 self.__field_used=UINT(*args,**dict2) 0986 # Make all P fields that haven't already been constructed 0987 0988 0989 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 0990 'Writes this packet to the supplied buffer' 0991 self._bufferstartoffset=buf.getcurrentoffset() 0992 self.__field_used.writetobuffer(buf) 0993 self._bufferendoffset=buf.getcurrentoffset() 0994 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 0995 0996 0997 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 0998 'Reads this packet from the supplied buffer' 0999 self._bufferstartoffset=buf.getcurrentoffset() 1000 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 1001 self.__field_used=UINT(**{'sizeinbytes': 1}) 1002 self.__field_used.readfrombuffer(buf) 1003 self._bufferendoffset=buf.getcurrentoffset() 1004 1005 1006 def __getfield_used(self): 1007 return self.__field_used.getvalue() 1008 1009 def __setfield_used(self, value): 1010 if isinstance(value,UINT): 1011 self.__field_used=value 1012 else: 1013 self.__field_used=UINT(value,**{'sizeinbytes': 1}) 1014 1015 def __delfield_used(self): del self.__field_used 1016 1017 used=property(__getfield_used, __setfield_used, __delfield_used, "1 if slot in use") 1018 1019 def iscontainer(self): 1020 return True 1021 1022 def containerelements(self): 1023 yield ('used', self.__field_used, "1 if slot in use") 1024 1025 1026 1027 1028 class _gen_p_sanyo6650_88(BaseProtogenClass): 1029 'Anonymous inner class' 1030 __fields=['used'] 1031 1032 def __init__(self, *args, **kwargs): 1033 dict={} 1034 # What was supplied to this function 1035 dict.update(kwargs) 1036 # Parent constructor 1037 super(_gen_p_sanyo6650_88,self).__init__(**dict) 1038 if self.__class__ is _gen_p_sanyo6650_88: 1039 self._update(args,dict) 1040 1041 1042 def getfields(self): 1043 return self.__fields 1044 1045 1046 def _update(self, args, kwargs): 1047 super(_gen_p_sanyo6650_88,self)._update(args,kwargs) 1048 keys=kwargs.keys() 1049 for key in keys: 1050 if key in self.__fields: 1051 setattr(self, key, kwargs[key]) 1052 del kwargs[key] 1053 # Were any unrecognized kwargs passed in? 1054 if __debug__: 1055 self._complainaboutunusedargs(_gen_p_sanyo6650_88,kwargs) 1056 if len(args): 1057 dict2={'sizeinbytes': 1} 1058 dict2.update(kwargs) 1059 kwargs=dict2 1060 self.__field_used=UINT(*args,**dict2) 1061 # Make all P fields that haven't already been constructed 1062 1063 1064 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 1065 'Writes this packet to the supplied buffer' 1066 self._bufferstartoffset=buf.getcurrentoffset() 1067 self.__field_used.writetobuffer(buf) 1068 self._bufferendoffset=buf.getcurrentoffset() 1069 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 1070 1071 1072 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 1073 'Reads this packet from the supplied buffer' 1074 self._bufferstartoffset=buf.getcurrentoffset() 1075 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 1076 self.__field_used=UINT(**{'sizeinbytes': 1}) 1077 self.__field_used.readfrombuffer(buf) 1078 self._bufferendoffset=buf.getcurrentoffset() 1079 1080 1081 def __getfield_used(self): 1082 return self.__field_used.getvalue() 1083 1084 def __setfield_used(self, value): 1085 if isinstance(value,UINT): 1086 self.__field_used=value 1087 else: 1088 self.__field_used=UINT(value,**{'sizeinbytes': 1}) 1089 1090 def __delfield_used(self): del self.__field_used 1091 1092 used=property(__getfield_used, __setfield_used, __delfield_used, "1 if slot in use") 1093 1094 def iscontainer(self): 1095 return True 1096 1097 def containerelements(self): 1098 yield ('used', self.__field_used, "1 if slot in use") 1099 1100 1101 1102 1103 class _gen_p_sanyo6650_91(BaseProtogenClass): 1104 'Anonymous inner class' 1105 __fields=['used'] 1106 1107 def __init__(self, *args, **kwargs): 1108 dict={} 1109 # What was supplied to this function 1110 dict.update(kwargs) 1111 # Parent constructor 1112 super(_gen_p_sanyo6650_91,self).__init__(**dict) 1113 if self.__class__ is _gen_p_sanyo6650_91: 1114 self._update(args,dict) 1115 1116 1117 def getfields(self): 1118 return self.__fields 1119 1120 1121 def _update(self, args, kwargs): 1122 super(_gen_p_sanyo6650_91,self)._update(args,kwargs) 1123 keys=kwargs.keys() 1124 for key in keys: 1125 if key in self.__fields: 1126 setattr(self, key, kwargs[key]) 1127 del kwargs[key] 1128 # Were any unrecognized kwargs passed in? 1129 if __debug__: 1130 self._complainaboutunusedargs(_gen_p_sanyo6650_91,kwargs) 1131 if len(args): 1132 dict2={'sizeinbytes': 1} 1133 dict2.update(kwargs) 1134 kwargs=dict2 1135 self.__field_used=UINT(*args,**dict2) 1136 # Make all P fields that haven't already been constructed 1137 1138 1139 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 1140 'Writes this packet to the supplied buffer' 1141 self._bufferstartoffset=buf.getcurrentoffset() 1142 self.__field_used.writetobuffer(buf) 1143 self._bufferendoffset=buf.getcurrentoffset() 1144 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 1145 1146 1147 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 1148 'Reads this packet from the supplied buffer' 1149 self._bufferstartoffset=buf.getcurrentoffset() 1150 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 1151 self.__field_used=UINT(**{'sizeinbytes': 1}) 1152 self.__field_used.readfrombuffer(buf) 1153 self._bufferendoffset=buf.getcurrentoffset() 1154 1155 1156 def __getfield_used(self): 1157 return self.__field_used.getvalue() 1158 1159 def __setfield_used(self, value): 1160 if isinstance(value,UINT): 1161 self.__field_used=value 1162 else: 1163 self.__field_used=UINT(value,**{'sizeinbytes': 1}) 1164 1165 def __delfield_used(self): del self.__field_used 1166 1167 used=property(__getfield_used, __setfield_used, __delfield_used, "1 if slot in use") 1168 1169 def iscontainer(self): 1170 return True 1171 1172 def containerelements(self): 1173 yield ('used', self.__field_used, "1 if slot in use") 1174 1175 1176 1177 1178 class _gen_p_sanyo6650_95(BaseProtogenClass): 1179 'Anonymous inner class' 1180 __fields=['used'] 1181 1182 def __init__(self, *args, **kwargs): 1183 dict={} 1184 # What was supplied to this function 1185 dict.update(kwargs) 1186 # Parent constructor 1187 super(_gen_p_sanyo6650_95,self).__init__(**dict) 1188 if self.__class__ is _gen_p_sanyo6650_95: 1189 self._update(args,dict) 1190 1191 1192 def getfields(self): 1193 return self.__fields 1194 1195 1196 def _update(self, args, kwargs): 1197 super(_gen_p_sanyo6650_95,self)._update(args,kwargs) 1198 keys=kwargs.keys() 1199 for key in keys: 1200 if key in self.__fields: 1201 setattr(self, key, kwargs[key]) 1202 del kwargs[key] 1203 # Were any unrecognized kwargs passed in? 1204 if __debug__: 1205 self._complainaboutunusedargs(_gen_p_sanyo6650_95,kwargs) 1206 if len(args): 1207 dict2={'sizeinbytes': 1} 1208 dict2.update(kwargs) 1209 kwargs=dict2 1210 self.__field_used=UINT(*args,**dict2) 1211 # Make all P fields that haven't already been constructed 1212 1213 1214 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 1215 'Writes this packet to the supplied buffer' 1216 self._bufferstartoffset=buf.getcurrentoffset() 1217 self.__field_used.writetobuffer(buf) 1218 self._bufferendoffset=buf.getcurrentoffset() 1219 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 1220 1221 1222 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 1223 'Reads this packet from the supplied buffer' 1224 self._bufferstartoffset=buf.getcurrentoffset() 1225 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 1226 self.__field_used=UINT(**{'sizeinbytes': 1}) 1227 self.__field_used.readfrombuffer(buf) 1228 self._bufferendoffset=buf.getcurrentoffset() 1229 1230 1231 def __getfield_used(self): 1232 return self.__field_used.getvalue() 1233 1234 def __setfield_used(self, value): 1235 if isinstance(value,UINT): 1236 self.__field_used=value 1237 else: 1238 self.__field_used=UINT(value,**{'sizeinbytes': 1}) 1239 1240 def __delfield_used(self): del self.__field_used 1241 1242 used=property(__getfield_used, __setfield_used, __delfield_used, "1 if slot in use") 1243 1244 def iscontainer(self): 1245 return True 1246 1247 def containerelements(self): 1248 yield ('used', self.__field_used, "1 if slot in use") 1249 1250 1251 1252 1253 class _gen_p_sanyo6650_99(BaseProtogenClass): 1254 'Anonymous inner class' 1255 __fields=['used'] 1256 1257 def __init__(self, *args, **kwargs): 1258 dict={} 1259 # What was supplied to this function 1260 dict.update(kwargs) 1261 # Parent constructor 1262 super(_gen_p_sanyo6650_99,self).__init__(**dict) 1263 if self.__class__ is _gen_p_sanyo6650_99: 1264 self._update(args,dict) 1265 1266 1267 def getfields(self): 1268 return self.__fields 1269 1270 1271 def _update(self, args, kwargs): 1272 super(_gen_p_sanyo6650_99,self)._update(args,kwargs) 1273 keys=kwargs.keys() 1274 for key in keys: 1275 if key in self.__fields: 1276 setattr(self, key, kwargs[key]) 1277 del kwargs[key] 1278 # Were any unrecognized kwargs passed in? 1279 if __debug__: 1280 self._complainaboutunusedargs(_gen_p_sanyo6650_99,kwargs) 1281 if len(args): 1282 dict2={'sizeinbytes': 1} 1283 dict2.update(kwargs) 1284 kwargs=dict2 1285 self.__field_used=UINT(*args,**dict2) 1286 # Make all P fields that haven't already been constructed 1287 1288 1289 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 1290 'Writes this packet to the supplied buffer' 1291 self._bufferstartoffset=buf.getcurrentoffset() 1292 self.__field_used.writetobuffer(buf) 1293 self._bufferendoffset=buf.getcurrentoffset() 1294 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 1295 1296 1297 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 1298 'Reads this packet from the supplied buffer' 1299 self._bufferstartoffset=buf.getcurrentoffset() 1300 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 1301 self.__field_used=UINT(**{'sizeinbytes': 1}) 1302 self.__field_used.readfrombuffer(buf) 1303 self._bufferendoffset=buf.getcurrentoffset() 1304 1305 1306 def __getfield_used(self): 1307 return self.__field_used.getvalue() 1308 1309 def __setfield_used(self, value): 1310 if isinstance(value,UINT): 1311 self.__field_used=value 1312 else: 1313 self.__field_used=UINT(value,**{'sizeinbytes': 1}) 1314 1315 def __delfield_used(self): del self.__field_used 1316 1317 used=property(__getfield_used, __setfield_used, __delfield_used, "1 if slot in use") 1318 1319 def iscontainer(self): 1320 return True 1321 1322 def containerelements(self): 1323 yield ('used', self.__field_used, "1 if slot in use") 1324 1325 1326 1327 1328
Generated by PyXR 0.9.4