0001 # THIS FILE IS AUTOMATICALLY GENERATED. EDIT THE SOURCE FILE NOT THIS ONE 0002 0003 """Various descriptions of data specific to Sanyo Katana (SCP-6600)""" 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 0013 # We use LSB for all integer like fields 0014 UINT=UINTlsb 0015 BOOL=BOOLlsb 0016 NUMPHONEBOOKENTRIES=500 0017 MAXNUMBERS=700 0018 MAXEMAILS=1000 0019 MAXURLS=500 0020 MAXMEMOS=500 0021 MAXADDRESSES=500 0022 _NUMSPEEDDIALS=8 0023 _NUMLONGNUMBERS=5 0024 _LONGPHONENUMBERLEN=30 0025 _NUMEVENTSLOTS=100 0026 _NUMCALLALARMSLOTS=15 0027 # Need to check. Is max phone will hold 32/96 or 33/97 0028 MAXNUMBERLEN=48 0029 MAXEMAILLEN=96 0030 MAXURLLEN=96 0031 MAXMEMOLEN=96 0032 HASRINGPICBUF=0 0033 NUMGROUPS=20 0034 NUMPHONENUMBERS=7 0035 NUMEMAILS=2 0036 FIRSTSPEEDDIAL=2 0037 LASTSPEEDDIAL=9 0038 0039 0040 class historyresponse(BaseProtogenClass): 0041 __fields=['header', 'entry', 'pad'] 0042 0043 def __init__(self, *args, **kwargs): 0044 dict={} 0045 # What was supplied to this function 0046 dict.update(kwargs) 0047 # Parent constructor 0048 super(historyresponse,self).__init__(**dict) 0049 if self.__class__ is historyresponse: 0050 self._update(args,dict) 0051 0052 0053 def getfields(self): 0054 return self.__fields 0055 0056 0057 def _update(self, args, kwargs): 0058 super(historyresponse,self)._update(args,kwargs) 0059 keys=kwargs.keys() 0060 for key in keys: 0061 if key in self.__fields: 0062 setattr(self, key, kwargs[key]) 0063 del kwargs[key] 0064 # Were any unrecognized kwargs passed in? 0065 if __debug__: 0066 self._complainaboutunusedargs(historyresponse,kwargs) 0067 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 0068 # Make all P fields that haven't already been constructed 0069 0070 0071 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 0072 'Writes this packet to the supplied buffer' 0073 self._bufferstartoffset=buf.getcurrentoffset() 0074 self.__field_header.writetobuffer(buf) 0075 self.__field_entry.writetobuffer(buf) 0076 self.__field_pad.writetobuffer(buf) 0077 self._bufferendoffset=buf.getcurrentoffset() 0078 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 0079 0080 0081 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 0082 'Reads this packet from the supplied buffer' 0083 self._bufferstartoffset=buf.getcurrentoffset() 0084 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 0085 self.__field_header=sanyoheader() 0086 self.__field_header.readfrombuffer(buf) 0087 self.__field_entry=historyentry() 0088 self.__field_entry.readfrombuffer(buf) 0089 self.__field_pad=UNKNOWN(**{'sizeinbytes': 428}) 0090 self.__field_pad.readfrombuffer(buf) 0091 self._bufferendoffset=buf.getcurrentoffset() 0092 0093 0094 def __getfield_header(self): 0095 return self.__field_header.getvalue() 0096 0097 def __setfield_header(self, value): 0098 if isinstance(value,sanyoheader): 0099 self.__field_header=value 0100 else: 0101 self.__field_header=sanyoheader(value,) 0102 0103 def __delfield_header(self): del self.__field_header 0104 0105 header=property(__getfield_header, __setfield_header, __delfield_header, None) 0106 0107 def __getfield_entry(self): 0108 return self.__field_entry.getvalue() 0109 0110 def __setfield_entry(self, value): 0111 if isinstance(value,historyentry): 0112 self.__field_entry=value 0113 else: 0114 self.__field_entry=historyentry(value,) 0115 0116 def __delfield_entry(self): del self.__field_entry 0117 0118 entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None) 0119 0120 def __getfield_pad(self): 0121 return self.__field_pad.getvalue() 0122 0123 def __setfield_pad(self, value): 0124 if isinstance(value,UNKNOWN): 0125 self.__field_pad=value 0126 else: 0127 self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 428}) 0128 0129 def __delfield_pad(self): del self.__field_pad 0130 0131 pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None) 0132 0133 def iscontainer(self): 0134 return True 0135 0136 def containerelements(self): 0137 yield ('header', self.__field_header, None) 0138 yield ('entry', self.__field_entry, None) 0139 yield ('pad', self.__field_pad, None) 0140 0141 0142 0143 0144 class historyentry(BaseProtogenClass): 0145 __fields=['slot', 'date', 'phonenumlen', 'phonenum', 'name', 'dunno2', 'dunno3'] 0146 0147 def __init__(self, *args, **kwargs): 0148 dict={} 0149 # What was supplied to this function 0150 dict.update(kwargs) 0151 # Parent constructor 0152 super(historyentry,self).__init__(**dict) 0153 if self.__class__ is historyentry: 0154 self._update(args,dict) 0155 0156 0157 def getfields(self): 0158 return self.__fields 0159 0160 0161 def _update(self, args, kwargs): 0162 super(historyentry,self)._update(args,kwargs) 0163 keys=kwargs.keys() 0164 for key in keys: 0165 if key in self.__fields: 0166 setattr(self, key, kwargs[key]) 0167 del kwargs[key] 0168 # Were any unrecognized kwargs passed in? 0169 if __debug__: 0170 self._complainaboutunusedargs(historyentry,kwargs) 0171 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 0172 # Make all P fields that haven't already been constructed 0173 0174 0175 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 0176 'Writes this packet to the supplied buffer' 0177 self._bufferstartoffset=buf.getcurrentoffset() 0178 self.__field_slot.writetobuffer(buf) 0179 self.__field_date.writetobuffer(buf) 0180 self.__field_phonenumlen.writetobuffer(buf) 0181 self.__field_phonenum.writetobuffer(buf) 0182 self.__field_name.writetobuffer(buf) 0183 self.__field_dunno2.writetobuffer(buf) 0184 self.__field_dunno3.writetobuffer(buf) 0185 self._bufferendoffset=buf.getcurrentoffset() 0186 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 0187 0188 0189 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 0190 'Reads this packet from the supplied buffer' 0191 self._bufferstartoffset=buf.getcurrentoffset() 0192 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 0193 self.__field_slot=UINT(**{'sizeinbytes': 2}) 0194 self.__field_slot.readfrombuffer(buf) 0195 self.__field_date=GPSDATE(**{'sizeinbytes': 4}) 0196 self.__field_date.readfrombuffer(buf) 0197 self.__field_phonenumlen=UINT(**{'sizeinbytes': 1}) 0198 self.__field_phonenumlen.readfrombuffer(buf) 0199 self.__field_phonenum=USTRING(**{'sizeinbytes': 48, 'raiseonunterminatedread': False}) 0200 self.__field_phonenum.readfrombuffer(buf) 0201 self.__field_name=USTRING(**{'sizeinbytes': 16, 'raiseonunterminatedread': False, 'raiseontruncate': False, 'terminator': None}) 0202 self.__field_name.readfrombuffer(buf) 0203 self.__field_dunno2=UNKNOWN(**{'sizeinbytes': 1}) 0204 self.__field_dunno2.readfrombuffer(buf) 0205 self.__field_dunno3=UNKNOWN(**{'sizeinbytes': 1}) 0206 self.__field_dunno3.readfrombuffer(buf) 0207 self._bufferendoffset=buf.getcurrentoffset() 0208 0209 0210 def __getfield_slot(self): 0211 return self.__field_slot.getvalue() 0212 0213 def __setfield_slot(self, value): 0214 if isinstance(value,UINT): 0215 self.__field_slot=value 0216 else: 0217 self.__field_slot=UINT(value,**{'sizeinbytes': 2}) 0218 0219 def __delfield_slot(self): del self.__field_slot 0220 0221 slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None) 0222 0223 def __getfield_date(self): 0224 return self.__field_date.getvalue() 0225 0226 def __setfield_date(self, value): 0227 if isinstance(value,GPSDATE): 0228 self.__field_date=value 0229 else: 0230 self.__field_date=GPSDATE(value,**{'sizeinbytes': 4}) 0231 0232 def __delfield_date(self): del self.__field_date 0233 0234 date=property(__getfield_date, __setfield_date, __delfield_date, None) 0235 0236 def __getfield_phonenumlen(self): 0237 return self.__field_phonenumlen.getvalue() 0238 0239 def __setfield_phonenumlen(self, value): 0240 if isinstance(value,UINT): 0241 self.__field_phonenumlen=value 0242 else: 0243 self.__field_phonenumlen=UINT(value,**{'sizeinbytes': 1}) 0244 0245 def __delfield_phonenumlen(self): del self.__field_phonenumlen 0246 0247 phonenumlen=property(__getfield_phonenumlen, __setfield_phonenumlen, __delfield_phonenumlen, None) 0248 0249 def __getfield_phonenum(self): 0250 return self.__field_phonenum.getvalue() 0251 0252 def __setfield_phonenum(self, value): 0253 if isinstance(value,USTRING): 0254 self.__field_phonenum=value 0255 else: 0256 self.__field_phonenum=USTRING(value,**{'sizeinbytes': 48, 'raiseonunterminatedread': False}) 0257 0258 def __delfield_phonenum(self): del self.__field_phonenum 0259 0260 phonenum=property(__getfield_phonenum, __setfield_phonenum, __delfield_phonenum, None) 0261 0262 def __getfield_name(self): 0263 return self.__field_name.getvalue() 0264 0265 def __setfield_name(self, value): 0266 if isinstance(value,USTRING): 0267 self.__field_name=value 0268 else: 0269 self.__field_name=USTRING(value,**{'sizeinbytes': 16, 'raiseonunterminatedread': False, 'raiseontruncate': False, 'terminator': None}) 0270 0271 def __delfield_name(self): del self.__field_name 0272 0273 name=property(__getfield_name, __setfield_name, __delfield_name, None) 0274 0275 def __getfield_dunno2(self): 0276 return self.__field_dunno2.getvalue() 0277 0278 def __setfield_dunno2(self, value): 0279 if isinstance(value,UNKNOWN): 0280 self.__field_dunno2=value 0281 else: 0282 self.__field_dunno2=UNKNOWN(value,**{'sizeinbytes': 1}) 0283 0284 def __delfield_dunno2(self): del self.__field_dunno2 0285 0286 dunno2=property(__getfield_dunno2, __setfield_dunno2, __delfield_dunno2, None) 0287 0288 def __getfield_dunno3(self): 0289 return self.__field_dunno3.getvalue() 0290 0291 def __setfield_dunno3(self, value): 0292 if isinstance(value,UNKNOWN): 0293 self.__field_dunno3=value 0294 else: 0295 self.__field_dunno3=UNKNOWN(value,**{'sizeinbytes': 1}) 0296 0297 def __delfield_dunno3(self): del self.__field_dunno3 0298 0299 dunno3=property(__getfield_dunno3, __setfield_dunno3, __delfield_dunno3, None) 0300 0301 def iscontainer(self): 0302 return True 0303 0304 def containerelements(self): 0305 yield ('slot', self.__field_slot, None) 0306 yield ('date', self.__field_date, None) 0307 yield ('phonenumlen', self.__field_phonenumlen, None) 0308 yield ('phonenum', self.__field_phonenum, None) 0309 yield ('name', self.__field_name, None) 0310 yield ('dunno2', self.__field_dunno2, None) 0311 yield ('dunno3', self.__field_dunno3, None) 0312 0313 0314 0315 0316 class pbsortbuffer(BaseProtogenClass): 0317 "Various arrays for sorting the phone book, speed dial, determining which" 0318 __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'] 0319 0320 def __init__(self, *args, **kwargs): 0321 dict={} 0322 # What was supplied to this function 0323 dict.update(kwargs) 0324 # Parent constructor 0325 super(pbsortbuffer,self).__init__(**dict) 0326 if self.__class__ is pbsortbuffer: 0327 self._update(args,dict) 0328 0329 0330 def getfields(self): 0331 return self.__fields 0332 0333 0334 def _update(self, args, kwargs): 0335 super(pbsortbuffer,self)._update(args,kwargs) 0336 keys=kwargs.keys() 0337 for key in keys: 0338 if key in self.__fields: 0339 setattr(self, key, kwargs[key]) 0340 del kwargs[key] 0341 # Were any unrecognized kwargs passed in? 0342 if __debug__: 0343 self._complainaboutunusedargs(pbsortbuffer,kwargs) 0344 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 0345 # Make all P fields that haven't already been constructed 0346 try: self.__field_startcommand 0347 except: 0348 self.__field_startcommand=UINT(**{'constant': 0x76}) 0349 try: self.__field_bufsize 0350 except: 0351 self.__field_bufsize=UINT(**{'constant': 6144}) 0352 try: self.__field_comment 0353 except: 0354 self.__field_comment=USTRING(**{'default': "sort buffer"}) 0355 0356 0357 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 0358 'Writes this packet to the supplied buffer' 0359 self._bufferstartoffset=buf.getcurrentoffset() 0360 self.__field_groupslotsused.writetobuffer(buf) 0361 try: self.__field_pad 0362 except: 0363 self.__field_pad=UNKNOWN(**{'sizeinbytes': 2}) 0364 self.__field_pad.writetobuffer(buf) 0365 try: self.__field_groupslotusedflags 0366 except: 0367 self.__field_groupslotusedflags=LIST(**{'elementclass': _gen_p_sanyo6600_79, 'length': NUMGROUPS, 'createdefault': True}) 0368 self.__field_groupslotusedflags.writetobuffer(buf) 0369 self.__field_slotsused.writetobuffer(buf) 0370 try: self.__field_usedflags 0371 except: 0372 self.__field_usedflags=LIST(**{'elementclass': _gen_p_sanyo6600_83, 'length': NUMPHONEBOOKENTRIES, 'createdefault': True}) 0373 self.__field_usedflags.writetobuffer(buf) 0374 try: self.__field_speeddialindex 0375 except: 0376 self.__field_speeddialindex=LIST(**{'elementclass': _gen_p_sanyo6600_85, 'length': _NUMSPEEDDIALS}) 0377 self.__field_speeddialindex.writetobuffer(buf) 0378 self.__field_nameslotsused.writetobuffer(buf) 0379 try: self.__field_nameusedflags 0380 except: 0381 self.__field_nameusedflags=LIST(**{'elementclass': _gen_p_sanyo6600_89, 'length': NUMPHONEBOOKENTRIES, 'createdefault': True}) 0382 self.__field_nameusedflags.writetobuffer(buf) 0383 try: self.__field_sortorder 0384 except: 0385 self.__field_sortorder=LIST(**{'elementclass': _gen_p_sanyo6600_91, 'length': NUMPHONEBOOKENTRIES}) 0386 self.__field_sortorder.writetobuffer(buf) 0387 self.__field_pbfirstletters.writetobuffer(buf) 0388 self.__field_numslotsused.writetobuffer(buf) 0389 try: self.__field_numusedflags 0390 except: 0391 self.__field_numusedflags=LIST(**{'elementclass': _gen_p_sanyo6600_96, 'length': MAXNUMBERS, 'createdefault': True}) 0392 self.__field_numusedflags.writetobuffer(buf) 0393 self.__field_emailslotsused.writetobuffer(buf) 0394 try: self.__field_emailusedflags 0395 except: 0396 self.__field_emailusedflags=LIST(**{'elementclass': _gen_p_sanyo6600_100, 'length': MAXEMAILS, 'createdefault': True}) 0397 self.__field_emailusedflags.writetobuffer(buf) 0398 self.__field_urlslotsused.writetobuffer(buf) 0399 try: self.__field_urlusedflags 0400 except: 0401 self.__field_urlusedflags=LIST(**{'elementclass': _gen_p_sanyo6600_103, 'length': MAXURLS, 'createdefault': True}) 0402 self.__field_urlusedflags.writetobuffer(buf) 0403 self.__field_num_address.writetobuffer(buf) 0404 try: self.__field_addressusedflags 0405 except: 0406 self.__field_addressusedflags=LIST(**{'elementclass': _gen_p_sanyo6600_107, 'length': NUMPHONEBOOKENTRIES, 'createdefault': True}) 0407 self.__field_addressusedflags.writetobuffer(buf) 0408 self.__field_num_memo.writetobuffer(buf) 0409 try: self.__field_memousedflags 0410 except: 0411 self.__field_memousedflags=LIST(**{'elementclass': _gen_p_sanyo6600_111, 'length': NUMPHONEBOOKENTRIES, 'createdefault': True}) 0412 self.__field_memousedflags.writetobuffer(buf) 0413 try: self.__field_junk 0414 except: 0415 self.__field_junk=UNKNOWN(**{'sizeinbytes': 391}) 0416 self.__field_junk.writetobuffer(buf) 0417 self._bufferendoffset=buf.getcurrentoffset() 0418 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 0419 0420 0421 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 0422 'Reads this packet from the supplied buffer' 0423 self._bufferstartoffset=buf.getcurrentoffset() 0424 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 0425 self.__field_groupslotsused=UINT(**{'sizeinbytes': 1}) 0426 self.__field_groupslotsused.readfrombuffer(buf) 0427 self.__field_pad=UNKNOWN(**{'sizeinbytes': 2}) 0428 self.__field_pad.readfrombuffer(buf) 0429 self.__field_groupslotusedflags=LIST(**{'elementclass': _gen_p_sanyo6600_79, 'length': NUMGROUPS, 'createdefault': True}) 0430 self.__field_groupslotusedflags.readfrombuffer(buf) 0431 self.__field_slotsused=UINT(**{'sizeinbytes': 2}) 0432 self.__field_slotsused.readfrombuffer(buf) 0433 self.__field_usedflags=LIST(**{'elementclass': _gen_p_sanyo6600_83, 'length': NUMPHONEBOOKENTRIES, 'createdefault': True}) 0434 self.__field_usedflags.readfrombuffer(buf) 0435 self.__field_speeddialindex=LIST(**{'elementclass': _gen_p_sanyo6600_85, 'length': _NUMSPEEDDIALS}) 0436 self.__field_speeddialindex.readfrombuffer(buf) 0437 self.__field_nameslotsused=UINT(**{'sizeinbytes': 2}) 0438 self.__field_nameslotsused.readfrombuffer(buf) 0439 self.__field_nameusedflags=LIST(**{'elementclass': _gen_p_sanyo6600_89, 'length': NUMPHONEBOOKENTRIES, 'createdefault': True}) 0440 self.__field_nameusedflags.readfrombuffer(buf) 0441 self.__field_sortorder=LIST(**{'elementclass': _gen_p_sanyo6600_91, 'length': NUMPHONEBOOKENTRIES}) 0442 self.__field_sortorder.readfrombuffer(buf) 0443 self.__field_pbfirstletters=USTRING(**{'terminator': None, 'sizeinbytes': NUMPHONEBOOKENTRIES}) 0444 self.__field_pbfirstletters.readfrombuffer(buf) 0445 self.__field_numslotsused=UINT(**{'sizeinbytes': 2}) 0446 self.__field_numslotsused.readfrombuffer(buf) 0447 self.__field_numusedflags=LIST(**{'elementclass': _gen_p_sanyo6600_96, 'length': MAXNUMBERS, 'createdefault': True}) 0448 self.__field_numusedflags.readfrombuffer(buf) 0449 self.__field_emailslotsused=UINT(**{'sizeinbytes': 2}) 0450 self.__field_emailslotsused.readfrombuffer(buf) 0451 self.__field_emailusedflags=LIST(**{'elementclass': _gen_p_sanyo6600_100, 'length': MAXEMAILS, 'createdefault': True}) 0452 self.__field_emailusedflags.readfrombuffer(buf) 0453 self.__field_urlslotsused=UINT(**{'sizeinbytes': 2}) 0454 self.__field_urlslotsused.readfrombuffer(buf) 0455 self.__field_urlusedflags=LIST(**{'elementclass': _gen_p_sanyo6600_103, 'length': MAXURLS, 'createdefault': True}) 0456 self.__field_urlusedflags.readfrombuffer(buf) 0457 self.__field_num_address=UINT(**{'sizeinbytes': 2}) 0458 self.__field_num_address.readfrombuffer(buf) 0459 self.__field_addressusedflags=LIST(**{'elementclass': _gen_p_sanyo6600_107, 'length': NUMPHONEBOOKENTRIES, 'createdefault': True}) 0460 self.__field_addressusedflags.readfrombuffer(buf) 0461 self.__field_num_memo=UINT(**{'sizeinbytes': 2}) 0462 self.__field_num_memo.readfrombuffer(buf) 0463 self.__field_memousedflags=LIST(**{'elementclass': _gen_p_sanyo6600_111, 'length': NUMPHONEBOOKENTRIES, 'createdefault': True}) 0464 self.__field_memousedflags.readfrombuffer(buf) 0465 self.__field_junk=UNKNOWN(**{'sizeinbytes': 391}) 0466 self.__field_junk.readfrombuffer(buf) 0467 self._bufferendoffset=buf.getcurrentoffset() 0468 0469 0470 def __getfield_startcommand(self): 0471 return self.__field_startcommand.getvalue() 0472 0473 def __setfield_startcommand(self, value): 0474 if isinstance(value,UINT): 0475 self.__field_startcommand=value 0476 else: 0477 self.__field_startcommand=UINT(value,**{'constant': 0x76}) 0478 0479 def __delfield_startcommand(self): del self.__field_startcommand 0480 0481 startcommand=property(__getfield_startcommand, __setfield_startcommand, __delfield_startcommand, "Starting command for R/W buf parts") 0482 0483 def __getfield_bufsize(self): 0484 return self.__field_bufsize.getvalue() 0485 0486 def __setfield_bufsize(self, value): 0487 if isinstance(value,UINT): 0488 self.__field_bufsize=value 0489 else: 0490 self.__field_bufsize=UINT(value,**{'constant': 6144}) 0491 0492 def __delfield_bufsize(self): del self.__field_bufsize 0493 0494 bufsize=property(__getfield_bufsize, __setfield_bufsize, __delfield_bufsize, None) 0495 0496 def __getfield_comment(self): 0497 try: self.__field_comment 0498 except: 0499 self.__field_comment=USTRING(**{'default': "sort buffer"}) 0500 return self.__field_comment.getvalue() 0501 0502 def __setfield_comment(self, value): 0503 if isinstance(value,USTRING): 0504 self.__field_comment=value 0505 else: 0506 self.__field_comment=USTRING(value,**{'default': "sort buffer"}) 0507 0508 def __delfield_comment(self): del self.__field_comment 0509 0510 comment=property(__getfield_comment, __setfield_comment, __delfield_comment, None) 0511 0512 def __getfield_groupslotsused(self): 0513 return self.__field_groupslotsused.getvalue() 0514 0515 def __setfield_groupslotsused(self, value): 0516 if isinstance(value,UINT): 0517 self.__field_groupslotsused=value 0518 else: 0519 self.__field_groupslotsused=UINT(value,**{'sizeinbytes': 1}) 0520 0521 def __delfield_groupslotsused(self): del self.__field_groupslotsused 0522 0523 groupslotsused=property(__getfield_groupslotsused, __setfield_groupslotsused, __delfield_groupslotsused, None) 0524 0525 def __getfield_pad(self): 0526 try: self.__field_pad 0527 except: 0528 self.__field_pad=UNKNOWN(**{'sizeinbytes': 2}) 0529 return self.__field_pad.getvalue() 0530 0531 def __setfield_pad(self, value): 0532 if isinstance(value,UNKNOWN): 0533 self.__field_pad=value 0534 else: 0535 self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 2}) 0536 0537 def __delfield_pad(self): del self.__field_pad 0538 0539 pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None) 0540 0541 def __getfield_groupslotusedflags(self): 0542 try: self.__field_groupslotusedflags 0543 except: 0544 self.__field_groupslotusedflags=LIST(**{'elementclass': _gen_p_sanyo6600_79, 'length': NUMGROUPS, 'createdefault': True}) 0545 return self.__field_groupslotusedflags.getvalue() 0546 0547 def __setfield_groupslotusedflags(self, value): 0548 if isinstance(value,LIST): 0549 self.__field_groupslotusedflags=value 0550 else: 0551 self.__field_groupslotusedflags=LIST(value,**{'elementclass': _gen_p_sanyo6600_79, 'length': NUMGROUPS, 'createdefault': True}) 0552 0553 def __delfield_groupslotusedflags(self): del self.__field_groupslotusedflags 0554 0555 groupslotusedflags=property(__getfield_groupslotusedflags, __setfield_groupslotusedflags, __delfield_groupslotusedflags, None) 0556 0557 def __getfield_slotsused(self): 0558 return self.__field_slotsused.getvalue() 0559 0560 def __setfield_slotsused(self, value): 0561 if isinstance(value,UINT): 0562 self.__field_slotsused=value 0563 else: 0564 self.__field_slotsused=UINT(value,**{'sizeinbytes': 2}) 0565 0566 def __delfield_slotsused(self): del self.__field_slotsused 0567 0568 slotsused=property(__getfield_slotsused, __setfield_slotsused, __delfield_slotsused, None) 0569 0570 def __getfield_usedflags(self): 0571 try: self.__field_usedflags 0572 except: 0573 self.__field_usedflags=LIST(**{'elementclass': _gen_p_sanyo6600_83, 'length': NUMPHONEBOOKENTRIES, 'createdefault': True}) 0574 return self.__field_usedflags.getvalue() 0575 0576 def __setfield_usedflags(self, value): 0577 if isinstance(value,LIST): 0578 self.__field_usedflags=value 0579 else: 0580 self.__field_usedflags=LIST(value,**{'elementclass': _gen_p_sanyo6600_83, 'length': NUMPHONEBOOKENTRIES, 'createdefault': True}) 0581 0582 def __delfield_usedflags(self): del self.__field_usedflags 0583 0584 usedflags=property(__getfield_usedflags, __setfield_usedflags, __delfield_usedflags, None) 0585 0586 def __getfield_speeddialindex(self): 0587 try: self.__field_speeddialindex 0588 except: 0589 self.__field_speeddialindex=LIST(**{'elementclass': _gen_p_sanyo6600_85, 'length': _NUMSPEEDDIALS}) 0590 return self.__field_speeddialindex.getvalue() 0591 0592 def __setfield_speeddialindex(self, value): 0593 if isinstance(value,LIST): 0594 self.__field_speeddialindex=value 0595 else: 0596 self.__field_speeddialindex=LIST(value,**{'elementclass': _gen_p_sanyo6600_85, 'length': _NUMSPEEDDIALS}) 0597 0598 def __delfield_speeddialindex(self): del self.__field_speeddialindex 0599 0600 speeddialindex=property(__getfield_speeddialindex, __setfield_speeddialindex, __delfield_speeddialindex, None) 0601 0602 def __getfield_nameslotsused(self): 0603 return self.__field_nameslotsused.getvalue() 0604 0605 def __setfield_nameslotsused(self, value): 0606 if isinstance(value,UINT): 0607 self.__field_nameslotsused=value 0608 else: 0609 self.__field_nameslotsused=UINT(value,**{'sizeinbytes': 2}) 0610 0611 def __delfield_nameslotsused(self): del self.__field_nameslotsused 0612 0613 nameslotsused=property(__getfield_nameslotsused, __setfield_nameslotsused, __delfield_nameslotsused, "Always seems to be the same. Why duplicated?") 0614 0615 def __getfield_nameusedflags(self): 0616 try: self.__field_nameusedflags 0617 except: 0618 self.__field_nameusedflags=LIST(**{'elementclass': _gen_p_sanyo6600_89, 'length': NUMPHONEBOOKENTRIES, 'createdefault': True}) 0619 return self.__field_nameusedflags.getvalue() 0620 0621 def __setfield_nameusedflags(self, value): 0622 if isinstance(value,LIST): 0623 self.__field_nameusedflags=value 0624 else: 0625 self.__field_nameusedflags=LIST(value,**{'elementclass': _gen_p_sanyo6600_89, 'length': NUMPHONEBOOKENTRIES, 'createdefault': True}) 0626 0627 def __delfield_nameusedflags(self): del self.__field_nameusedflags 0628 0629 nameusedflags=property(__getfield_nameusedflags, __setfield_nameusedflags, __delfield_nameusedflags, None) 0630 0631 def __getfield_sortorder(self): 0632 try: self.__field_sortorder 0633 except: 0634 self.__field_sortorder=LIST(**{'elementclass': _gen_p_sanyo6600_91, 'length': NUMPHONEBOOKENTRIES}) 0635 return self.__field_sortorder.getvalue() 0636 0637 def __setfield_sortorder(self, value): 0638 if isinstance(value,LIST): 0639 self.__field_sortorder=value 0640 else: 0641 self.__field_sortorder=LIST(value,**{'elementclass': _gen_p_sanyo6600_91, 'length': NUMPHONEBOOKENTRIES}) 0642 0643 def __delfield_sortorder(self): del self.__field_sortorder 0644 0645 sortorder=property(__getfield_sortorder, __setfield_sortorder, __delfield_sortorder, None) 0646 0647 def __getfield_pbfirstletters(self): 0648 return self.__field_pbfirstletters.getvalue() 0649 0650 def __setfield_pbfirstletters(self, value): 0651 if isinstance(value,USTRING): 0652 self.__field_pbfirstletters=value 0653 else: 0654 self.__field_pbfirstletters=USTRING(value,**{'terminator': None, 'sizeinbytes': NUMPHONEBOOKENTRIES}) 0655 0656 def __delfield_pbfirstletters(self): del self.__field_pbfirstletters 0657 0658 pbfirstletters=property(__getfield_pbfirstletters, __setfield_pbfirstletters, __delfield_pbfirstletters, None) 0659 0660 def __getfield_numslotsused(self): 0661 return self.__field_numslotsused.getvalue() 0662 0663 def __setfield_numslotsused(self, value): 0664 if isinstance(value,UINT): 0665 self.__field_numslotsused=value 0666 else: 0667 self.__field_numslotsused=UINT(value,**{'sizeinbytes': 2}) 0668 0669 def __delfield_numslotsused(self): del self.__field_numslotsused 0670 0671 numslotsused=property(__getfield_numslotsused, __setfield_numslotsused, __delfield_numslotsused, "Number of phone number slots used") 0672 0673 def __getfield_numusedflags(self): 0674 try: self.__field_numusedflags 0675 except: 0676 self.__field_numusedflags=LIST(**{'elementclass': _gen_p_sanyo6600_96, 'length': MAXNUMBERS, 'createdefault': True}) 0677 return self.__field_numusedflags.getvalue() 0678 0679 def __setfield_numusedflags(self, value): 0680 if isinstance(value,LIST): 0681 self.__field_numusedflags=value 0682 else: 0683 self.__field_numusedflags=LIST(value,**{'elementclass': _gen_p_sanyo6600_96, 'length': MAXNUMBERS, 'createdefault': True}) 0684 0685 def __delfield_numusedflags(self): del self.__field_numusedflags 0686 0687 numusedflags=property(__getfield_numusedflags, __setfield_numusedflags, __delfield_numusedflags, None) 0688 0689 def __getfield_emailslotsused(self): 0690 return self.__field_emailslotsused.getvalue() 0691 0692 def __setfield_emailslotsused(self, value): 0693 if isinstance(value,UINT): 0694 self.__field_emailslotsused=value 0695 else: 0696 self.__field_emailslotsused=UINT(value,**{'sizeinbytes': 2}) 0697 0698 def __delfield_emailslotsused(self): del self.__field_emailslotsused 0699 0700 emailslotsused=property(__getfield_emailslotsused, __setfield_emailslotsused, __delfield_emailslotsused, None) 0701 0702 def __getfield_emailusedflags(self): 0703 try: self.__field_emailusedflags 0704 except: 0705 self.__field_emailusedflags=LIST(**{'elementclass': _gen_p_sanyo6600_100, 'length': MAXEMAILS, 'createdefault': True}) 0706 return self.__field_emailusedflags.getvalue() 0707 0708 def __setfield_emailusedflags(self, value): 0709 if isinstance(value,LIST): 0710 self.__field_emailusedflags=value 0711 else: 0712 self.__field_emailusedflags=LIST(value,**{'elementclass': _gen_p_sanyo6600_100, 'length': MAXEMAILS, 'createdefault': True}) 0713 0714 def __delfield_emailusedflags(self): del self.__field_emailusedflags 0715 0716 emailusedflags=property(__getfield_emailusedflags, __setfield_emailusedflags, __delfield_emailusedflags, None) 0717 0718 def __getfield_urlslotsused(self): 0719 return self.__field_urlslotsused.getvalue() 0720 0721 def __setfield_urlslotsused(self, value): 0722 if isinstance(value,UINT): 0723 self.__field_urlslotsused=value 0724 else: 0725 self.__field_urlslotsused=UINT(value,**{'sizeinbytes': 2}) 0726 0727 def __delfield_urlslotsused(self): del self.__field_urlslotsused 0728 0729 urlslotsused=property(__getfield_urlslotsused, __setfield_urlslotsused, __delfield_urlslotsused, None) 0730 0731 def __getfield_urlusedflags(self): 0732 try: self.__field_urlusedflags 0733 except: 0734 self.__field_urlusedflags=LIST(**{'elementclass': _gen_p_sanyo6600_103, 'length': MAXURLS, 'createdefault': True}) 0735 return self.__field_urlusedflags.getvalue() 0736 0737 def __setfield_urlusedflags(self, value): 0738 if isinstance(value,LIST): 0739 self.__field_urlusedflags=value 0740 else: 0741 self.__field_urlusedflags=LIST(value,**{'elementclass': _gen_p_sanyo6600_103, 'length': MAXURLS, 'createdefault': True}) 0742 0743 def __delfield_urlusedflags(self): del self.__field_urlusedflags 0744 0745 urlusedflags=property(__getfield_urlusedflags, __setfield_urlusedflags, __delfield_urlusedflags, None) 0746 0747 def __getfield_num_address(self): 0748 return self.__field_num_address.getvalue() 0749 0750 def __setfield_num_address(self, value): 0751 if isinstance(value,UINT): 0752 self.__field_num_address=value 0753 else: 0754 self.__field_num_address=UINT(value,**{'sizeinbytes': 2}) 0755 0756 def __delfield_num_address(self): del self.__field_num_address 0757 0758 num_address=property(__getfield_num_address, __setfield_num_address, __delfield_num_address, None) 0759 0760 def __getfield_addressusedflags(self): 0761 try: self.__field_addressusedflags 0762 except: 0763 self.__field_addressusedflags=LIST(**{'elementclass': _gen_p_sanyo6600_107, 'length': NUMPHONEBOOKENTRIES, 'createdefault': True}) 0764 return self.__field_addressusedflags.getvalue() 0765 0766 def __setfield_addressusedflags(self, value): 0767 if isinstance(value,LIST): 0768 self.__field_addressusedflags=value 0769 else: 0770 self.__field_addressusedflags=LIST(value,**{'elementclass': _gen_p_sanyo6600_107, 'length': NUMPHONEBOOKENTRIES, 'createdefault': True}) 0771 0772 def __delfield_addressusedflags(self): del self.__field_addressusedflags 0773 0774 addressusedflags=property(__getfield_addressusedflags, __setfield_addressusedflags, __delfield_addressusedflags, None) 0775 0776 def __getfield_num_memo(self): 0777 return self.__field_num_memo.getvalue() 0778 0779 def __setfield_num_memo(self, value): 0780 if isinstance(value,UINT): 0781 self.__field_num_memo=value 0782 else: 0783 self.__field_num_memo=UINT(value,**{'sizeinbytes': 2}) 0784 0785 def __delfield_num_memo(self): del self.__field_num_memo 0786 0787 num_memo=property(__getfield_num_memo, __setfield_num_memo, __delfield_num_memo, None) 0788 0789 def __getfield_memousedflags(self): 0790 try: self.__field_memousedflags 0791 except: 0792 self.__field_memousedflags=LIST(**{'elementclass': _gen_p_sanyo6600_111, 'length': NUMPHONEBOOKENTRIES, 'createdefault': True}) 0793 return self.__field_memousedflags.getvalue() 0794 0795 def __setfield_memousedflags(self, value): 0796 if isinstance(value,LIST): 0797 self.__field_memousedflags=value 0798 else: 0799 self.__field_memousedflags=LIST(value,**{'elementclass': _gen_p_sanyo6600_111, 'length': NUMPHONEBOOKENTRIES, 'createdefault': True}) 0800 0801 def __delfield_memousedflags(self): del self.__field_memousedflags 0802 0803 memousedflags=property(__getfield_memousedflags, __setfield_memousedflags, __delfield_memousedflags, None) 0804 0805 def __getfield_junk(self): 0806 try: self.__field_junk 0807 except: 0808 self.__field_junk=UNKNOWN(**{'sizeinbytes': 391}) 0809 return self.__field_junk.getvalue() 0810 0811 def __setfield_junk(self, value): 0812 if isinstance(value,UNKNOWN): 0813 self.__field_junk=value 0814 else: 0815 self.__field_junk=UNKNOWN(value,**{'sizeinbytes': 391}) 0816 0817 def __delfield_junk(self): del self.__field_junk 0818 0819 junk=property(__getfield_junk, __setfield_junk, __delfield_junk, None) 0820 0821 def iscontainer(self): 0822 return True 0823 0824 def containerelements(self): 0825 yield ('startcommand', self.__field_startcommand, "Starting command for R/W buf parts") 0826 yield ('bufsize', self.__field_bufsize, None) 0827 yield ('comment', self.__field_comment, None) 0828 yield ('groupslotsused', self.__field_groupslotsused, None) 0829 yield ('pad', self.__field_pad, None) 0830 yield ('groupslotusedflags', self.__field_groupslotusedflags, None) 0831 yield ('slotsused', self.__field_slotsused, None) 0832 yield ('usedflags', self.__field_usedflags, None) 0833 yield ('speeddialindex', self.__field_speeddialindex, None) 0834 yield ('nameslotsused', self.__field_nameslotsused, "Always seems to be the same. Why duplicated?") 0835 yield ('nameusedflags', self.__field_nameusedflags, None) 0836 yield ('sortorder', self.__field_sortorder, None) 0837 yield ('pbfirstletters', self.__field_pbfirstletters, None) 0838 yield ('numslotsused', self.__field_numslotsused, "Number of phone number slots used") 0839 yield ('numusedflags', self.__field_numusedflags, None) 0840 yield ('emailslotsused', self.__field_emailslotsused, None) 0841 yield ('emailusedflags', self.__field_emailusedflags, None) 0842 yield ('urlslotsused', self.__field_urlslotsused, None) 0843 yield ('urlusedflags', self.__field_urlusedflags, None) 0844 yield ('num_address', self.__field_num_address, None) 0845 yield ('addressusedflags', self.__field_addressusedflags, None) 0846 yield ('num_memo', self.__field_num_memo, None) 0847 yield ('memousedflags', self.__field_memousedflags, None) 0848 yield ('junk', self.__field_junk, None) 0849 0850 0851 0852 0853 class _gen_p_sanyo6600_79(BaseProtogenClass): 0854 'Anonymous inner class' 0855 __fields=['used'] 0856 0857 def __init__(self, *args, **kwargs): 0858 dict={} 0859 # What was supplied to this function 0860 dict.update(kwargs) 0861 # Parent constructor 0862 super(_gen_p_sanyo6600_79,self).__init__(**dict) 0863 if self.__class__ is _gen_p_sanyo6600_79: 0864 self._update(args,dict) 0865 0866 0867 def getfields(self): 0868 return self.__fields 0869 0870 0871 def _update(self, args, kwargs): 0872 super(_gen_p_sanyo6600_79,self)._update(args,kwargs) 0873 keys=kwargs.keys() 0874 for key in keys: 0875 if key in self.__fields: 0876 setattr(self, key, kwargs[key]) 0877 del kwargs[key] 0878 # Were any unrecognized kwargs passed in? 0879 if __debug__: 0880 self._complainaboutunusedargs(_gen_p_sanyo6600_79,kwargs) 0881 if len(args): 0882 dict2={'sizeinbytes': 1} 0883 dict2.update(kwargs) 0884 kwargs=dict2 0885 self.__field_used=UINT(*args,**dict2) 0886 # Make all P fields that haven't already been constructed 0887 0888 0889 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 0890 'Writes this packet to the supplied buffer' 0891 self._bufferstartoffset=buf.getcurrentoffset() 0892 self.__field_used.writetobuffer(buf) 0893 self._bufferendoffset=buf.getcurrentoffset() 0894 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 0895 0896 0897 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 0898 'Reads this packet from the supplied buffer' 0899 self._bufferstartoffset=buf.getcurrentoffset() 0900 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 0901 self.__field_used=UINT(**{'sizeinbytes': 1}) 0902 self.__field_used.readfrombuffer(buf) 0903 self._bufferendoffset=buf.getcurrentoffset() 0904 0905 0906 def __getfield_used(self): 0907 return self.__field_used.getvalue() 0908 0909 def __setfield_used(self, value): 0910 if isinstance(value,UINT): 0911 self.__field_used=value 0912 else: 0913 self.__field_used=UINT(value,**{'sizeinbytes': 1}) 0914 0915 def __delfield_used(self): del self.__field_used 0916 0917 used=property(__getfield_used, __setfield_used, __delfield_used, "1 if slot in use") 0918 0919 def iscontainer(self): 0920 return True 0921 0922 def containerelements(self): 0923 yield ('used', self.__field_used, "1 if slot in use") 0924 0925 0926 0927 0928 class _gen_p_sanyo6600_83(BaseProtogenClass): 0929 'Anonymous inner class' 0930 __fields=['used'] 0931 0932 def __init__(self, *args, **kwargs): 0933 dict={} 0934 # What was supplied to this function 0935 dict.update(kwargs) 0936 # Parent constructor 0937 super(_gen_p_sanyo6600_83,self).__init__(**dict) 0938 if self.__class__ is _gen_p_sanyo6600_83: 0939 self._update(args,dict) 0940 0941 0942 def getfields(self): 0943 return self.__fields 0944 0945 0946 def _update(self, args, kwargs): 0947 super(_gen_p_sanyo6600_83,self)._update(args,kwargs) 0948 keys=kwargs.keys() 0949 for key in keys: 0950 if key in self.__fields: 0951 setattr(self, key, kwargs[key]) 0952 del kwargs[key] 0953 # Were any unrecognized kwargs passed in? 0954 if __debug__: 0955 self._complainaboutunusedargs(_gen_p_sanyo6600_83,kwargs) 0956 if len(args): 0957 dict2={'sizeinbytes': 1} 0958 dict2.update(kwargs) 0959 kwargs=dict2 0960 self.__field_used=UINT(*args,**dict2) 0961 # Make all P fields that haven't already been constructed 0962 0963 0964 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 0965 'Writes this packet to the supplied buffer' 0966 self._bufferstartoffset=buf.getcurrentoffset() 0967 self.__field_used.writetobuffer(buf) 0968 self._bufferendoffset=buf.getcurrentoffset() 0969 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 0970 0971 0972 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 0973 'Reads this packet from the supplied buffer' 0974 self._bufferstartoffset=buf.getcurrentoffset() 0975 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 0976 self.__field_used=UINT(**{'sizeinbytes': 1}) 0977 self.__field_used.readfrombuffer(buf) 0978 self._bufferendoffset=buf.getcurrentoffset() 0979 0980 0981 def __getfield_used(self): 0982 return self.__field_used.getvalue() 0983 0984 def __setfield_used(self, value): 0985 if isinstance(value,UINT): 0986 self.__field_used=value 0987 else: 0988 self.__field_used=UINT(value,**{'sizeinbytes': 1}) 0989 0990 def __delfield_used(self): del self.__field_used 0991 0992 used=property(__getfield_used, __setfield_used, __delfield_used, "1 if slot in use") 0993 0994 def iscontainer(self): 0995 return True 0996 0997 def containerelements(self): 0998 yield ('used', self.__field_used, "1 if slot in use") 0999 1000 1001 1002 1003 class _gen_p_sanyo6600_85(BaseProtogenClass): 1004 'Anonymous inner class' 1005 __fields=['numslot'] 1006 1007 def __init__(self, *args, **kwargs): 1008 dict={} 1009 # What was supplied to this function 1010 dict.update(kwargs) 1011 # Parent constructor 1012 super(_gen_p_sanyo6600_85,self).__init__(**dict) 1013 if self.__class__ is _gen_p_sanyo6600_85: 1014 self._update(args,dict) 1015 1016 1017 def getfields(self): 1018 return self.__fields 1019 1020 1021 def _update(self, args, kwargs): 1022 super(_gen_p_sanyo6600_85,self)._update(args,kwargs) 1023 keys=kwargs.keys() 1024 for key in keys: 1025 if key in self.__fields: 1026 setattr(self, key, kwargs[key]) 1027 del kwargs[key] 1028 # Were any unrecognized kwargs passed in? 1029 if __debug__: 1030 self._complainaboutunusedargs(_gen_p_sanyo6600_85,kwargs) 1031 if len(args): 1032 dict2={'sizeinbytes': 2, 'default': 0xffff} 1033 dict2.update(kwargs) 1034 kwargs=dict2 1035 self.__field_numslot=UINT(*args,**dict2) 1036 # Make all P fields that haven't already been constructed 1037 1038 1039 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 1040 'Writes this packet to the supplied buffer' 1041 self._bufferstartoffset=buf.getcurrentoffset() 1042 self.__field_numslot.writetobuffer(buf) 1043 self._bufferendoffset=buf.getcurrentoffset() 1044 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 1045 1046 1047 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 1048 'Reads this packet from the supplied buffer' 1049 self._bufferstartoffset=buf.getcurrentoffset() 1050 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 1051 self.__field_numslot=UINT(**{'sizeinbytes': 2, 'default': 0xffff}) 1052 self.__field_numslot.readfrombuffer(buf) 1053 self._bufferendoffset=buf.getcurrentoffset() 1054 1055 1056 def __getfield_numslot(self): 1057 return self.__field_numslot.getvalue() 1058 1059 def __setfield_numslot(self, value): 1060 if isinstance(value,UINT): 1061 self.__field_numslot=value 1062 else: 1063 self.__field_numslot=UINT(value,**{'sizeinbytes': 2, 'default': 0xffff}) 1064 1065 def __delfield_numslot(self): del self.__field_numslot 1066 1067 numslot=property(__getfield_numslot, __setfield_numslot, __delfield_numslot, None) 1068 1069 def iscontainer(self): 1070 return True 1071 1072 def containerelements(self): 1073 yield ('numslot', self.__field_numslot, None) 1074 1075 1076 1077 1078 class _gen_p_sanyo6600_89(BaseProtogenClass): 1079 'Anonymous inner class' 1080 __fields=['used'] 1081 1082 def __init__(self, *args, **kwargs): 1083 dict={} 1084 # What was supplied to this function 1085 dict.update(kwargs) 1086 # Parent constructor 1087 super(_gen_p_sanyo6600_89,self).__init__(**dict) 1088 if self.__class__ is _gen_p_sanyo6600_89: 1089 self._update(args,dict) 1090 1091 1092 def getfields(self): 1093 return self.__fields 1094 1095 1096 def _update(self, args, kwargs): 1097 super(_gen_p_sanyo6600_89,self)._update(args,kwargs) 1098 keys=kwargs.keys() 1099 for key in keys: 1100 if key in self.__fields: 1101 setattr(self, key, kwargs[key]) 1102 del kwargs[key] 1103 # Were any unrecognized kwargs passed in? 1104 if __debug__: 1105 self._complainaboutunusedargs(_gen_p_sanyo6600_89,kwargs) 1106 if len(args): 1107 dict2={'sizeinbytes': 1} 1108 dict2.update(kwargs) 1109 kwargs=dict2 1110 self.__field_used=UINT(*args,**dict2) 1111 # Make all P fields that haven't already been constructed 1112 1113 1114 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 1115 'Writes this packet to the supplied buffer' 1116 self._bufferstartoffset=buf.getcurrentoffset() 1117 self.__field_used.writetobuffer(buf) 1118 self._bufferendoffset=buf.getcurrentoffset() 1119 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 1120 1121 1122 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 1123 'Reads this packet from the supplied buffer' 1124 self._bufferstartoffset=buf.getcurrentoffset() 1125 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 1126 self.__field_used=UINT(**{'sizeinbytes': 1}) 1127 self.__field_used.readfrombuffer(buf) 1128 self._bufferendoffset=buf.getcurrentoffset() 1129 1130 1131 def __getfield_used(self): 1132 return self.__field_used.getvalue() 1133 1134 def __setfield_used(self, value): 1135 if isinstance(value,UINT): 1136 self.__field_used=value 1137 else: 1138 self.__field_used=UINT(value,**{'sizeinbytes': 1}) 1139 1140 def __delfield_used(self): del self.__field_used 1141 1142 used=property(__getfield_used, __setfield_used, __delfield_used, "1 if slot in use") 1143 1144 def iscontainer(self): 1145 return True 1146 1147 def containerelements(self): 1148 yield ('used', self.__field_used, "1 if slot in use") 1149 1150 1151 1152 1153 class _gen_p_sanyo6600_91(BaseProtogenClass): 1154 'Anonymous inner class' 1155 __fields=['pbslot'] 1156 1157 def __init__(self, *args, **kwargs): 1158 dict={} 1159 # What was supplied to this function 1160 dict.update(kwargs) 1161 # Parent constructor 1162 super(_gen_p_sanyo6600_91,self).__init__(**dict) 1163 if self.__class__ is _gen_p_sanyo6600_91: 1164 self._update(args,dict) 1165 1166 1167 def getfields(self): 1168 return self.__fields 1169 1170 1171 def _update(self, args, kwargs): 1172 super(_gen_p_sanyo6600_91,self)._update(args,kwargs) 1173 keys=kwargs.keys() 1174 for key in keys: 1175 if key in self.__fields: 1176 setattr(self, key, kwargs[key]) 1177 del kwargs[key] 1178 # Were any unrecognized kwargs passed in? 1179 if __debug__: 1180 self._complainaboutunusedargs(_gen_p_sanyo6600_91,kwargs) 1181 if len(args): 1182 dict2={'sizeinbytes': 2, 'default': 0xffff} 1183 dict2.update(kwargs) 1184 kwargs=dict2 1185 self.__field_pbslot=UINT(*args,**dict2) 1186 # Make all P fields that haven't already been constructed 1187 1188 1189 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 1190 'Writes this packet to the supplied buffer' 1191 self._bufferstartoffset=buf.getcurrentoffset() 1192 self.__field_pbslot.writetobuffer(buf) 1193 self._bufferendoffset=buf.getcurrentoffset() 1194 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 1195 1196 1197 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 1198 'Reads this packet from the supplied buffer' 1199 self._bufferstartoffset=buf.getcurrentoffset() 1200 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 1201 self.__field_pbslot=UINT(**{'sizeinbytes': 2, 'default': 0xffff}) 1202 self.__field_pbslot.readfrombuffer(buf) 1203 self._bufferendoffset=buf.getcurrentoffset() 1204 1205 1206 def __getfield_pbslot(self): 1207 return self.__field_pbslot.getvalue() 1208 1209 def __setfield_pbslot(self, value): 1210 if isinstance(value,UINT): 1211 self.__field_pbslot=value 1212 else: 1213 self.__field_pbslot=UINT(value,**{'sizeinbytes': 2, 'default': 0xffff}) 1214 1215 def __delfield_pbslot(self): del self.__field_pbslot 1216 1217 pbslot=property(__getfield_pbslot, __setfield_pbslot, __delfield_pbslot, None) 1218 1219 def iscontainer(self): 1220 return True 1221 1222 def containerelements(self): 1223 yield ('pbslot', self.__field_pbslot, None) 1224 1225 1226 1227 1228 class _gen_p_sanyo6600_96(BaseProtogenClass): 1229 'Anonymous inner class' 1230 __fields=['used'] 1231 1232 def __init__(self, *args, **kwargs): 1233 dict={} 1234 # What was supplied to this function 1235 dict.update(kwargs) 1236 # Parent constructor 1237 super(_gen_p_sanyo6600_96,self).__init__(**dict) 1238 if self.__class__ is _gen_p_sanyo6600_96: 1239 self._update(args,dict) 1240 1241 1242 def getfields(self): 1243 return self.__fields 1244 1245 1246 def _update(self, args, kwargs): 1247 super(_gen_p_sanyo6600_96,self)._update(args,kwargs) 1248 keys=kwargs.keys() 1249 for key in keys: 1250 if key in self.__fields: 1251 setattr(self, key, kwargs[key]) 1252 del kwargs[key] 1253 # Were any unrecognized kwargs passed in? 1254 if __debug__: 1255 self._complainaboutunusedargs(_gen_p_sanyo6600_96,kwargs) 1256 if len(args): 1257 dict2={'sizeinbytes': 1} 1258 dict2.update(kwargs) 1259 kwargs=dict2 1260 self.__field_used=UINT(*args,**dict2) 1261 # Make all P fields that haven't already been constructed 1262 1263 1264 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 1265 'Writes this packet to the supplied buffer' 1266 self._bufferstartoffset=buf.getcurrentoffset() 1267 self.__field_used.writetobuffer(buf) 1268 self._bufferendoffset=buf.getcurrentoffset() 1269 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 1270 1271 1272 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 1273 'Reads this packet from the supplied buffer' 1274 self._bufferstartoffset=buf.getcurrentoffset() 1275 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 1276 self.__field_used=UINT(**{'sizeinbytes': 1}) 1277 self.__field_used.readfrombuffer(buf) 1278 self._bufferendoffset=buf.getcurrentoffset() 1279 1280 1281 def __getfield_used(self): 1282 return self.__field_used.getvalue() 1283 1284 def __setfield_used(self, value): 1285 if isinstance(value,UINT): 1286 self.__field_used=value 1287 else: 1288 self.__field_used=UINT(value,**{'sizeinbytes': 1}) 1289 1290 def __delfield_used(self): del self.__field_used 1291 1292 used=property(__getfield_used, __setfield_used, __delfield_used, "1 if slot in use") 1293 1294 def iscontainer(self): 1295 return True 1296 1297 def containerelements(self): 1298 yield ('used', self.__field_used, "1 if slot in use") 1299 1300 1301 1302 1303 class _gen_p_sanyo6600_100(BaseProtogenClass): 1304 'Anonymous inner class' 1305 __fields=['used'] 1306 1307 def __init__(self, *args, **kwargs): 1308 dict={} 1309 # What was supplied to this function 1310 dict.update(kwargs) 1311 # Parent constructor 1312 super(_gen_p_sanyo6600_100,self).__init__(**dict) 1313 if self.__class__ is _gen_p_sanyo6600_100: 1314 self._update(args,dict) 1315 1316 1317 def getfields(self): 1318 return self.__fields 1319 1320 1321 def _update(self, args, kwargs): 1322 super(_gen_p_sanyo6600_100,self)._update(args,kwargs) 1323 keys=kwargs.keys() 1324 for key in keys: 1325 if key in self.__fields: 1326 setattr(self, key, kwargs[key]) 1327 del kwargs[key] 1328 # Were any unrecognized kwargs passed in? 1329 if __debug__: 1330 self._complainaboutunusedargs(_gen_p_sanyo6600_100,kwargs) 1331 if len(args): 1332 dict2={'sizeinbytes': 1} 1333 dict2.update(kwargs) 1334 kwargs=dict2 1335 self.__field_used=UINT(*args,**dict2) 1336 # Make all P fields that haven't already been constructed 1337 1338 1339 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 1340 'Writes this packet to the supplied buffer' 1341 self._bufferstartoffset=buf.getcurrentoffset() 1342 self.__field_used.writetobuffer(buf) 1343 self._bufferendoffset=buf.getcurrentoffset() 1344 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 1345 1346 1347 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 1348 'Reads this packet from the supplied buffer' 1349 self._bufferstartoffset=buf.getcurrentoffset() 1350 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 1351 self.__field_used=UINT(**{'sizeinbytes': 1}) 1352 self.__field_used.readfrombuffer(buf) 1353 self._bufferendoffset=buf.getcurrentoffset() 1354 1355 1356 def __getfield_used(self): 1357 return self.__field_used.getvalue() 1358 1359 def __setfield_used(self, value): 1360 if isinstance(value,UINT): 1361 self.__field_used=value 1362 else: 1363 self.__field_used=UINT(value,**{'sizeinbytes': 1}) 1364 1365 def __delfield_used(self): del self.__field_used 1366 1367 used=property(__getfield_used, __setfield_used, __delfield_used, "1 if slot in use") 1368 1369 def iscontainer(self): 1370 return True 1371 1372 def containerelements(self): 1373 yield ('used', self.__field_used, "1 if slot in use") 1374 1375 1376 1377 1378 class _gen_p_sanyo6600_103(BaseProtogenClass): 1379 'Anonymous inner class' 1380 __fields=['used'] 1381 1382 def __init__(self, *args, **kwargs): 1383 dict={} 1384 # What was supplied to this function 1385 dict.update(kwargs) 1386 # Parent constructor 1387 super(_gen_p_sanyo6600_103,self).__init__(**dict) 1388 if self.__class__ is _gen_p_sanyo6600_103: 1389 self._update(args,dict) 1390 1391 1392 def getfields(self): 1393 return self.__fields 1394 1395 1396 def _update(self, args, kwargs): 1397 super(_gen_p_sanyo6600_103,self)._update(args,kwargs) 1398 keys=kwargs.keys() 1399 for key in keys: 1400 if key in self.__fields: 1401 setattr(self, key, kwargs[key]) 1402 del kwargs[key] 1403 # Were any unrecognized kwargs passed in? 1404 if __debug__: 1405 self._complainaboutunusedargs(_gen_p_sanyo6600_103,kwargs) 1406 if len(args): 1407 dict2={'sizeinbytes': 1} 1408 dict2.update(kwargs) 1409 kwargs=dict2 1410 self.__field_used=UINT(*args,**dict2) 1411 # Make all P fields that haven't already been constructed 1412 1413 1414 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 1415 'Writes this packet to the supplied buffer' 1416 self._bufferstartoffset=buf.getcurrentoffset() 1417 self.__field_used.writetobuffer(buf) 1418 self._bufferendoffset=buf.getcurrentoffset() 1419 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 1420 1421 1422 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 1423 'Reads this packet from the supplied buffer' 1424 self._bufferstartoffset=buf.getcurrentoffset() 1425 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 1426 self.__field_used=UINT(**{'sizeinbytes': 1}) 1427 self.__field_used.readfrombuffer(buf) 1428 self._bufferendoffset=buf.getcurrentoffset() 1429 1430 1431 def __getfield_used(self): 1432 return self.__field_used.getvalue() 1433 1434 def __setfield_used(self, value): 1435 if isinstance(value,UINT): 1436 self.__field_used=value 1437 else: 1438 self.__field_used=UINT(value,**{'sizeinbytes': 1}) 1439 1440 def __delfield_used(self): del self.__field_used 1441 1442 used=property(__getfield_used, __setfield_used, __delfield_used, "1 if slot in use") 1443 1444 def iscontainer(self): 1445 return True 1446 1447 def containerelements(self): 1448 yield ('used', self.__field_used, "1 if slot in use") 1449 1450 1451 1452 1453 class _gen_p_sanyo6600_107(BaseProtogenClass): 1454 'Anonymous inner class' 1455 __fields=['used'] 1456 1457 def __init__(self, *args, **kwargs): 1458 dict={} 1459 # What was supplied to this function 1460 dict.update(kwargs) 1461 # Parent constructor 1462 super(_gen_p_sanyo6600_107,self).__init__(**dict) 1463 if self.__class__ is _gen_p_sanyo6600_107: 1464 self._update(args,dict) 1465 1466 1467 def getfields(self): 1468 return self.__fields 1469 1470 1471 def _update(self, args, kwargs): 1472 super(_gen_p_sanyo6600_107,self)._update(args,kwargs) 1473 keys=kwargs.keys() 1474 for key in keys: 1475 if key in self.__fields: 1476 setattr(self, key, kwargs[key]) 1477 del kwargs[key] 1478 # Were any unrecognized kwargs passed in? 1479 if __debug__: 1480 self._complainaboutunusedargs(_gen_p_sanyo6600_107,kwargs) 1481 if len(args): 1482 dict2={'sizeinbytes': 1} 1483 dict2.update(kwargs) 1484 kwargs=dict2 1485 self.__field_used=UINT(*args,**dict2) 1486 # Make all P fields that haven't already been constructed 1487 1488 1489 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 1490 'Writes this packet to the supplied buffer' 1491 self._bufferstartoffset=buf.getcurrentoffset() 1492 self.__field_used.writetobuffer(buf) 1493 self._bufferendoffset=buf.getcurrentoffset() 1494 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 1495 1496 1497 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 1498 'Reads this packet from the supplied buffer' 1499 self._bufferstartoffset=buf.getcurrentoffset() 1500 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 1501 self.__field_used=UINT(**{'sizeinbytes': 1}) 1502 self.__field_used.readfrombuffer(buf) 1503 self._bufferendoffset=buf.getcurrentoffset() 1504 1505 1506 def __getfield_used(self): 1507 return self.__field_used.getvalue() 1508 1509 def __setfield_used(self, value): 1510 if isinstance(value,UINT): 1511 self.__field_used=value 1512 else: 1513 self.__field_used=UINT(value,**{'sizeinbytes': 1}) 1514 1515 def __delfield_used(self): del self.__field_used 1516 1517 used=property(__getfield_used, __setfield_used, __delfield_used, "1 if slot in use") 1518 1519 def iscontainer(self): 1520 return True 1521 1522 def containerelements(self): 1523 yield ('used', self.__field_used, "1 if slot in use") 1524 1525 1526 1527 1528 class _gen_p_sanyo6600_111(BaseProtogenClass): 1529 'Anonymous inner class' 1530 __fields=['used'] 1531 1532 def __init__(self, *args, **kwargs): 1533 dict={} 1534 # What was supplied to this function 1535 dict.update(kwargs) 1536 # Parent constructor 1537 super(_gen_p_sanyo6600_111,self).__init__(**dict) 1538 if self.__class__ is _gen_p_sanyo6600_111: 1539 self._update(args,dict) 1540 1541 1542 def getfields(self): 1543 return self.__fields 1544 1545 1546 def _update(self, args, kwargs): 1547 super(_gen_p_sanyo6600_111,self)._update(args,kwargs) 1548 keys=kwargs.keys() 1549 for key in keys: 1550 if key in self.__fields: 1551 setattr(self, key, kwargs[key]) 1552 del kwargs[key] 1553 # Were any unrecognized kwargs passed in? 1554 if __debug__: 1555 self._complainaboutunusedargs(_gen_p_sanyo6600_111,kwargs) 1556 if len(args): 1557 dict2={'sizeinbytes': 1} 1558 dict2.update(kwargs) 1559 kwargs=dict2 1560 self.__field_used=UINT(*args,**dict2) 1561 # Make all P fields that haven't already been constructed 1562 1563 1564 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 1565 'Writes this packet to the supplied buffer' 1566 self._bufferstartoffset=buf.getcurrentoffset() 1567 self.__field_used.writetobuffer(buf) 1568 self._bufferendoffset=buf.getcurrentoffset() 1569 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 1570 1571 1572 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 1573 'Reads this packet from the supplied buffer' 1574 self._bufferstartoffset=buf.getcurrentoffset() 1575 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 1576 self.__field_used=UINT(**{'sizeinbytes': 1}) 1577 self.__field_used.readfrombuffer(buf) 1578 self._bufferendoffset=buf.getcurrentoffset() 1579 1580 1581 def __getfield_used(self): 1582 return self.__field_used.getvalue() 1583 1584 def __setfield_used(self, value): 1585 if isinstance(value,UINT): 1586 self.__field_used=value 1587 else: 1588 self.__field_used=UINT(value,**{'sizeinbytes': 1}) 1589 1590 def __delfield_used(self): del self.__field_used 1591 1592 used=property(__getfield_used, __setfield_used, __delfield_used, "1 if slot in use") 1593 1594 def iscontainer(self): 1595 return True 1596 1597 def containerelements(self): 1598 yield ('used', self.__field_used, "1 if slot in use") 1599 1600 1601 1602 1603 class cannedmessagerequest(BaseProtogenClass): 1604 __fields=['header'] 1605 1606 def __init__(self, *args, **kwargs): 1607 dict={} 1608 # What was supplied to this function 1609 dict.update(kwargs) 1610 # Parent constructor 1611 super(cannedmessagerequest,self).__init__(**dict) 1612 if self.__class__ is cannedmessagerequest: 1613 self._update(args,dict) 1614 1615 1616 def getfields(self): 1617 return self.__fields 1618 1619 1620 def _update(self, args, kwargs): 1621 super(cannedmessagerequest,self)._update(args,kwargs) 1622 keys=kwargs.keys() 1623 for key in keys: 1624 if key in self.__fields: 1625 setattr(self, key, kwargs[key]) 1626 del kwargs[key] 1627 # Were any unrecognized kwargs passed in? 1628 if __debug__: 1629 self._complainaboutunusedargs(cannedmessagerequest,kwargs) 1630 if len(args): 1631 dict2={'packettype': 0x0e, 'command': 0x5b} 1632 dict2.update(kwargs) 1633 kwargs=dict2 1634 self.__field_header=sanyoheader(*args,**dict2) 1635 # Make all P fields that haven't already been constructed 1636 1637 1638 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 1639 'Writes this packet to the supplied buffer' 1640 self._bufferstartoffset=buf.getcurrentoffset() 1641 try: self.__field_header 1642 except: 1643 self.__field_header=sanyoheader(**{'packettype': 0x0e, 'command': 0x5b}) 1644 self.__field_header.writetobuffer(buf) 1645 self._bufferendoffset=buf.getcurrentoffset() 1646 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 1647 1648 1649 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 1650 'Reads this packet from the supplied buffer' 1651 self._bufferstartoffset=buf.getcurrentoffset() 1652 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 1653 self.__field_header=sanyoheader(**{'packettype': 0x0e, 'command': 0x5b}) 1654 self.__field_header.readfrombuffer(buf) 1655 self._bufferendoffset=buf.getcurrentoffset() 1656 1657 1658 def __getfield_header(self): 1659 try: self.__field_header 1660 except: 1661 self.__field_header=sanyoheader(**{'packettype': 0x0e, 'command': 0x5b}) 1662 return self.__field_header.getvalue() 1663 1664 def __setfield_header(self, value): 1665 if isinstance(value,sanyoheader): 1666 self.__field_header=value 1667 else: 1668 self.__field_header=sanyoheader(value,**{'packettype': 0x0e, 'command': 0x5b}) 1669 1670 def __delfield_header(self): del self.__field_header 1671 1672 header=property(__getfield_header, __setfield_header, __delfield_header, None) 1673 1674 def iscontainer(self): 1675 return True 1676 1677 def containerelements(self): 1678 yield ('header', self.__field_header, None) 1679 1680 1681 1682 1683 class pbinfo(BaseProtogenClass): 1684 __fields=['fa', 'faset', 'byte1', 'byte2', 'byte3'] 1685 1686 def __init__(self, *args, **kwargs): 1687 dict={} 1688 # What was supplied to this function 1689 dict.update(kwargs) 1690 # Parent constructor 1691 super(pbinfo,self).__init__(**dict) 1692 if self.__class__ is pbinfo: 1693 self._update(args,dict) 1694 1695 1696 def getfields(self): 1697 return self.__fields 1698 1699 1700 def _update(self, args, kwargs): 1701 super(pbinfo,self)._update(args,kwargs) 1702 keys=kwargs.keys() 1703 for key in keys: 1704 if key in self.__fields: 1705 setattr(self, key, kwargs[key]) 1706 del kwargs[key] 1707 # Were any unrecognized kwargs passed in? 1708 if __debug__: 1709 self._complainaboutunusedargs(pbinfo,kwargs) 1710 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 1711 # Make all P fields that haven't already been constructed 1712 1713 1714 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 1715 'Writes this packet to the supplied buffer' 1716 self._bufferstartoffset=buf.getcurrentoffset() 1717 try: self.__field_fa 1718 except: 1719 self.__field_fa=UINT(**{'sizeinbytes': 2, 'constant': 0x00fa}) 1720 self.__field_fa.writetobuffer(buf) 1721 try: self.__field_faset 1722 except: 1723 self.__field_faset=UINT(**{'sizeinbytes': 1, 'default': 0x02}) 1724 self.__field_faset.writetobuffer(buf) 1725 self.__field_byte1.writetobuffer(buf) 1726 self.__field_byte2.writetobuffer(buf) 1727 self.__field_byte3.writetobuffer(buf) 1728 self._bufferendoffset=buf.getcurrentoffset() 1729 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 1730 1731 1732 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 1733 'Reads this packet from the supplied buffer' 1734 self._bufferstartoffset=buf.getcurrentoffset() 1735 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 1736 self.__field_fa=UINT(**{'sizeinbytes': 2, 'constant': 0x00fa}) 1737 self.__field_fa.readfrombuffer(buf) 1738 self.__field_faset=UINT(**{'sizeinbytes': 1, 'default': 0x02}) 1739 self.__field_faset.readfrombuffer(buf) 1740 self.__field_byte1=UINT(**{'sizeinbytes': 1}) 1741 self.__field_byte1.readfrombuffer(buf) 1742 self.__field_byte2=UINT(**{'sizeinbytes': 1}) 1743 self.__field_byte2.readfrombuffer(buf) 1744 self.__field_byte3=UINT(**{'sizeinbytes': 2}) 1745 self.__field_byte3.readfrombuffer(buf) 1746 self._bufferendoffset=buf.getcurrentoffset() 1747 1748 1749 def __getfield_fa(self): 1750 try: self.__field_fa 1751 except: 1752 self.__field_fa=UINT(**{'sizeinbytes': 2, 'constant': 0x00fa}) 1753 return self.__field_fa.getvalue() 1754 1755 def __setfield_fa(self, value): 1756 if isinstance(value,UINT): 1757 self.__field_fa=value 1758 else: 1759 self.__field_fa=UINT(value,**{'sizeinbytes': 2, 'constant': 0x00fa}) 1760 1761 def __delfield_fa(self): del self.__field_fa 1762 1763 fa=property(__getfield_fa, __setfield_fa, __delfield_fa, None) 1764 1765 def __getfield_faset(self): 1766 try: self.__field_faset 1767 except: 1768 self.__field_faset=UINT(**{'sizeinbytes': 1, 'default': 0x02}) 1769 return self.__field_faset.getvalue() 1770 1771 def __setfield_faset(self, value): 1772 if isinstance(value,UINT): 1773 self.__field_faset=value 1774 else: 1775 self.__field_faset=UINT(value,**{'sizeinbytes': 1, 'default': 0x02}) 1776 1777 def __delfield_faset(self): del self.__field_faset 1778 1779 faset=property(__getfield_faset, __setfield_faset, __delfield_faset, None) 1780 1781 def __getfield_byte1(self): 1782 return self.__field_byte1.getvalue() 1783 1784 def __setfield_byte1(self, value): 1785 if isinstance(value,UINT): 1786 self.__field_byte1=value 1787 else: 1788 self.__field_byte1=UINT(value,**{'sizeinbytes': 1}) 1789 1790 def __delfield_byte1(self): del self.__field_byte1 1791 1792 byte1=property(__getfield_byte1, __setfield_byte1, __delfield_byte1, None) 1793 1794 def __getfield_byte2(self): 1795 return self.__field_byte2.getvalue() 1796 1797 def __setfield_byte2(self, value): 1798 if isinstance(value,UINT): 1799 self.__field_byte2=value 1800 else: 1801 self.__field_byte2=UINT(value,**{'sizeinbytes': 1}) 1802 1803 def __delfield_byte2(self): del self.__field_byte2 1804 1805 byte2=property(__getfield_byte2, __setfield_byte2, __delfield_byte2, None) 1806 1807 def __getfield_byte3(self): 1808 return self.__field_byte3.getvalue() 1809 1810 def __setfield_byte3(self, value): 1811 if isinstance(value,UINT): 1812 self.__field_byte3=value 1813 else: 1814 self.__field_byte3=UINT(value,**{'sizeinbytes': 2}) 1815 1816 def __delfield_byte3(self): del self.__field_byte3 1817 1818 byte3=property(__getfield_byte3, __setfield_byte3, __delfield_byte3, None) 1819 1820 def iscontainer(self): 1821 return True 1822 1823 def containerelements(self): 1824 yield ('fa', self.__field_fa, None) 1825 yield ('faset', self.__field_faset, None) 1826 yield ('byte1', self.__field_byte1, None) 1827 yield ('byte2', self.__field_byte2, None) 1828 yield ('byte3', self.__field_byte3, None) 1829 1830 1831 1832 1833 class contactindexrequest(BaseProtogenClass): 1834 __fields=['header', 'slot'] 1835 1836 def __init__(self, *args, **kwargs): 1837 dict={} 1838 # What was supplied to this function 1839 dict.update(kwargs) 1840 # Parent constructor 1841 super(contactindexrequest,self).__init__(**dict) 1842 if self.__class__ is contactindexrequest: 1843 self._update(args,dict) 1844 1845 1846 def getfields(self): 1847 return self.__fields 1848 1849 1850 def _update(self, args, kwargs): 1851 super(contactindexrequest,self)._update(args,kwargs) 1852 keys=kwargs.keys() 1853 for key in keys: 1854 if key in self.__fields: 1855 setattr(self, key, kwargs[key]) 1856 del kwargs[key] 1857 # Were any unrecognized kwargs passed in? 1858 if __debug__: 1859 self._complainaboutunusedargs(contactindexrequest,kwargs) 1860 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 1861 # Make all P fields that haven't already been constructed 1862 1863 1864 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 1865 'Writes this packet to the supplied buffer' 1866 self._bufferstartoffset=buf.getcurrentoffset() 1867 try: self.__field_header 1868 except: 1869 self.__field_header=sanyoheader(**{'packettype': 0x16, 'command': 0x88}) 1870 self.__field_header.writetobuffer(buf) 1871 self.__field_slot.writetobuffer(buf) 1872 self._bufferendoffset=buf.getcurrentoffset() 1873 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 1874 1875 1876 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 1877 'Reads this packet from the supplied buffer' 1878 self._bufferstartoffset=buf.getcurrentoffset() 1879 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 1880 self.__field_header=sanyoheader(**{'packettype': 0x16, 'command': 0x88}) 1881 self.__field_header.readfrombuffer(buf) 1882 self.__field_slot=UINT(**{'sizeinbytes': 2}) 1883 self.__field_slot.readfrombuffer(buf) 1884 self._bufferendoffset=buf.getcurrentoffset() 1885 1886 1887 def __getfield_header(self): 1888 try: self.__field_header 1889 except: 1890 self.__field_header=sanyoheader(**{'packettype': 0x16, 'command': 0x88}) 1891 return self.__field_header.getvalue() 1892 1893 def __setfield_header(self, value): 1894 if isinstance(value,sanyoheader): 1895 self.__field_header=value 1896 else: 1897 self.__field_header=sanyoheader(value,**{'packettype': 0x16, 'command': 0x88}) 1898 1899 def __delfield_header(self): del self.__field_header 1900 1901 header=property(__getfield_header, __setfield_header, __delfield_header, None) 1902 1903 def __getfield_slot(self): 1904 return self.__field_slot.getvalue() 1905 1906 def __setfield_slot(self, value): 1907 if isinstance(value,UINT): 1908 self.__field_slot=value 1909 else: 1910 self.__field_slot=UINT(value,**{'sizeinbytes': 2}) 1911 1912 def __delfield_slot(self): del self.__field_slot 1913 1914 slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None) 1915 1916 def iscontainer(self): 1917 return True 1918 1919 def containerelements(self): 1920 yield ('header', self.__field_header, None) 1921 yield ('slot', self.__field_slot, None) 1922 1923 1924 1925 1926 class contactindexentry(BaseProtogenClass): 1927 __fields=['groupid', 'slot', 'namep', 'numberps', 'emailps', 'urlp', 'addressp', 'memop', 'ringerid', 'pictureid', 'defaultnum', 'secret'] 1928 1929 def __init__(self, *args, **kwargs): 1930 dict={} 1931 # What was supplied to this function 1932 dict.update(kwargs) 1933 # Parent constructor 1934 super(contactindexentry,self).__init__(**dict) 1935 if self.__class__ is contactindexentry: 1936 self._update(args,dict) 1937 1938 1939 def getfields(self): 1940 return self.__fields 1941 1942 1943 def _update(self, args, kwargs): 1944 super(contactindexentry,self)._update(args,kwargs) 1945 keys=kwargs.keys() 1946 for key in keys: 1947 if key in self.__fields: 1948 setattr(self, key, kwargs[key]) 1949 del kwargs[key] 1950 # Were any unrecognized kwargs passed in? 1951 if __debug__: 1952 self._complainaboutunusedargs(contactindexentry,kwargs) 1953 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 1954 # Make all P fields that haven't already been constructed 1955 1956 1957 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 1958 'Writes this packet to the supplied buffer' 1959 self._bufferstartoffset=buf.getcurrentoffset() 1960 self.__field_groupid.writetobuffer(buf) 1961 self.__field_slot.writetobuffer(buf) 1962 try: self.__field_namep 1963 except: 1964 self.__field_namep=UINT(**{'sizeinbytes': 2, 'default': 0xffff}) 1965 self.__field_namep.writetobuffer(buf) 1966 try: self.__field_numberps 1967 except: 1968 self.__field_numberps=LIST(**{'elementclass': _gen_p_sanyo6600_143, 'length': NUMPHONENUMBERS}) 1969 self.__field_numberps.writetobuffer(buf) 1970 try: self.__field_emailps 1971 except: 1972 self.__field_emailps=LIST(**{'elementclass': _gen_p_sanyo6600_145, 'length': NUMEMAILS}) 1973 self.__field_emailps.writetobuffer(buf) 1974 try: self.__field_urlp 1975 except: 1976 self.__field_urlp=UINT(**{'sizeinbytes': 2, 'default': 0xffff}) 1977 self.__field_urlp.writetobuffer(buf) 1978 try: self.__field_addressp 1979 except: 1980 self.__field_addressp=UINT(**{'sizeinbytes': 2, 'default': 0xffff}) 1981 self.__field_addressp.writetobuffer(buf) 1982 try: self.__field_memop 1983 except: 1984 self.__field_memop=UINT(**{'sizeinbytes': 2, 'default': 0xffff}) 1985 self.__field_memop.writetobuffer(buf) 1986 try: self.__field_ringerid 1987 except: 1988 self.__field_ringerid=UINT(**{'sizeinbytes': 2, 'default': 0xfff0}) 1989 self.__field_ringerid.writetobuffer(buf) 1990 try: self.__field_pictureid 1991 except: 1992 self.__field_pictureid=UINT(**{'sizeinbytes': 2, 'default': 0xfffe}) 1993 self.__field_pictureid.writetobuffer(buf) 1994 try: self.__field_defaultnum 1995 except: 1996 self.__field_defaultnum=UINT(**{'sizeinbytes': 2, 'default': 0}) 1997 self.__field_defaultnum.writetobuffer(buf) 1998 try: self.__field_secret 1999 except: 2000 self.__field_secret=UINT(**{'sizeinbytes': 1, 'default': 0}) 2001 self.__field_secret.writetobuffer(buf) 2002 self._bufferendoffset=buf.getcurrentoffset() 2003 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 2004 2005 2006 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 2007 'Reads this packet from the supplied buffer' 2008 self._bufferstartoffset=buf.getcurrentoffset() 2009 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 2010 self.__field_groupid=UINT(**{'sizeinbytes': 1}) 2011 self.__field_groupid.readfrombuffer(buf) 2012 self.__field_slot=UINT(**{'sizeinbytes': 2}) 2013 self.__field_slot.readfrombuffer(buf) 2014 self.__field_namep=UINT(**{'sizeinbytes': 2, 'default': 0xffff}) 2015 self.__field_namep.readfrombuffer(buf) 2016 self.__field_numberps=LIST(**{'elementclass': _gen_p_sanyo6600_143, 'length': NUMPHONENUMBERS}) 2017 self.__field_numberps.readfrombuffer(buf) 2018 self.__field_emailps=LIST(**{'elementclass': _gen_p_sanyo6600_145, 'length': NUMEMAILS}) 2019 self.__field_emailps.readfrombuffer(buf) 2020 self.__field_urlp=UINT(**{'sizeinbytes': 2, 'default': 0xffff}) 2021 self.__field_urlp.readfrombuffer(buf) 2022 self.__field_addressp=UINT(**{'sizeinbytes': 2, 'default': 0xffff}) 2023 self.__field_addressp.readfrombuffer(buf) 2024 self.__field_memop=UINT(**{'sizeinbytes': 2, 'default': 0xffff}) 2025 self.__field_memop.readfrombuffer(buf) 2026 self.__field_ringerid=UINT(**{'sizeinbytes': 2, 'default': 0xfff0}) 2027 self.__field_ringerid.readfrombuffer(buf) 2028 self.__field_pictureid=UINT(**{'sizeinbytes': 2, 'default': 0xfffe}) 2029 self.__field_pictureid.readfrombuffer(buf) 2030 self.__field_defaultnum=UINT(**{'sizeinbytes': 2, 'default': 0}) 2031 self.__field_defaultnum.readfrombuffer(buf) 2032 self.__field_secret=UINT(**{'sizeinbytes': 1, 'default': 0}) 2033 self.__field_secret.readfrombuffer(buf) 2034 self._bufferendoffset=buf.getcurrentoffset() 2035 2036 2037 def __getfield_groupid(self): 2038 return self.__field_groupid.getvalue() 2039 2040 def __setfield_groupid(self, value): 2041 if isinstance(value,UINT): 2042 self.__field_groupid=value 2043 else: 2044 self.__field_groupid=UINT(value,**{'sizeinbytes': 1}) 2045 2046 def __delfield_groupid(self): del self.__field_groupid 2047 2048 groupid=property(__getfield_groupid, __setfield_groupid, __delfield_groupid, None) 2049 2050 def __getfield_slot(self): 2051 return self.__field_slot.getvalue() 2052 2053 def __setfield_slot(self, value): 2054 if isinstance(value,UINT): 2055 self.__field_slot=value 2056 else: 2057 self.__field_slot=UINT(value,**{'sizeinbytes': 2}) 2058 2059 def __delfield_slot(self): del self.__field_slot 2060 2061 slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None) 2062 2063 def __getfield_namep(self): 2064 try: self.__field_namep 2065 except: 2066 self.__field_namep=UINT(**{'sizeinbytes': 2, 'default': 0xffff}) 2067 return self.__field_namep.getvalue() 2068 2069 def __setfield_namep(self, value): 2070 if isinstance(value,UINT): 2071 self.__field_namep=value 2072 else: 2073 self.__field_namep=UINT(value,**{'sizeinbytes': 2, 'default': 0xffff}) 2074 2075 def __delfield_namep(self): del self.__field_namep 2076 2077 namep=property(__getfield_namep, __setfield_namep, __delfield_namep, None) 2078 2079 def __getfield_numberps(self): 2080 try: self.__field_numberps 2081 except: 2082 self.__field_numberps=LIST(**{'elementclass': _gen_p_sanyo6600_143, 'length': NUMPHONENUMBERS}) 2083 return self.__field_numberps.getvalue() 2084 2085 def __setfield_numberps(self, value): 2086 if isinstance(value,LIST): 2087 self.__field_numberps=value 2088 else: 2089 self.__field_numberps=LIST(value,**{'elementclass': _gen_p_sanyo6600_143, 'length': NUMPHONENUMBERS}) 2090 2091 def __delfield_numberps(self): del self.__field_numberps 2092 2093 numberps=property(__getfield_numberps, __setfield_numberps, __delfield_numberps, None) 2094 2095 def __getfield_emailps(self): 2096 try: self.__field_emailps 2097 except: 2098 self.__field_emailps=LIST(**{'elementclass': _gen_p_sanyo6600_145, 'length': NUMEMAILS}) 2099 return self.__field_emailps.getvalue() 2100 2101 def __setfield_emailps(self, value): 2102 if isinstance(value,LIST): 2103 self.__field_emailps=value 2104 else: 2105 self.__field_emailps=LIST(value,**{'elementclass': _gen_p_sanyo6600_145, 'length': NUMEMAILS}) 2106 2107 def __delfield_emailps(self): del self.__field_emailps 2108 2109 emailps=property(__getfield_emailps, __setfield_emailps, __delfield_emailps, None) 2110 2111 def __getfield_urlp(self): 2112 try: self.__field_urlp 2113 except: 2114 self.__field_urlp=UINT(**{'sizeinbytes': 2, 'default': 0xffff}) 2115 return self.__field_urlp.getvalue() 2116 2117 def __setfield_urlp(self, value): 2118 if isinstance(value,UINT): 2119 self.__field_urlp=value 2120 else: 2121 self.__field_urlp=UINT(value,**{'sizeinbytes': 2, 'default': 0xffff}) 2122 2123 def __delfield_urlp(self): del self.__field_urlp 2124 2125 urlp=property(__getfield_urlp, __setfield_urlp, __delfield_urlp, None) 2126 2127 def __getfield_addressp(self): 2128 try: self.__field_addressp 2129 except: 2130 self.__field_addressp=UINT(**{'sizeinbytes': 2, 'default': 0xffff}) 2131 return self.__field_addressp.getvalue() 2132 2133 def __setfield_addressp(self, value): 2134 if isinstance(value,UINT): 2135 self.__field_addressp=value 2136 else: 2137 self.__field_addressp=UINT(value,**{'sizeinbytes': 2, 'default': 0xffff}) 2138 2139 def __delfield_addressp(self): del self.__field_addressp 2140 2141 addressp=property(__getfield_addressp, __setfield_addressp, __delfield_addressp, None) 2142 2143 def __getfield_memop(self): 2144 try: self.__field_memop 2145 except: 2146 self.__field_memop=UINT(**{'sizeinbytes': 2, 'default': 0xffff}) 2147 return self.__field_memop.getvalue() 2148 2149 def __setfield_memop(self, value): 2150 if isinstance(value,UINT): 2151 self.__field_memop=value 2152 else: 2153 self.__field_memop=UINT(value,**{'sizeinbytes': 2, 'default': 0xffff}) 2154 2155 def __delfield_memop(self): del self.__field_memop 2156 2157 memop=property(__getfield_memop, __setfield_memop, __delfield_memop, None) 2158 2159 def __getfield_ringerid(self): 2160 try: self.__field_ringerid 2161 except: 2162 self.__field_ringerid=UINT(**{'sizeinbytes': 2, 'default': 0xfff0}) 2163 return self.__field_ringerid.getvalue() 2164 2165 def __setfield_ringerid(self, value): 2166 if isinstance(value,UINT): 2167 self.__field_ringerid=value 2168 else: 2169 self.__field_ringerid=UINT(value,**{'sizeinbytes': 2, 'default': 0xfff0}) 2170 2171 def __delfield_ringerid(self): del self.__field_ringerid 2172 2173 ringerid=property(__getfield_ringerid, __setfield_ringerid, __delfield_ringerid, None) 2174 2175 def __getfield_pictureid(self): 2176 try: self.__field_pictureid 2177 except: 2178 self.__field_pictureid=UINT(**{'sizeinbytes': 2, 'default': 0xfffe}) 2179 return self.__field_pictureid.getvalue() 2180 2181 def __setfield_pictureid(self, value): 2182 if isinstance(value,UINT): 2183 self.__field_pictureid=value 2184 else: 2185 self.__field_pictureid=UINT(value,**{'sizeinbytes': 2, 'default': 0xfffe}) 2186 2187 def __delfield_pictureid(self): del self.__field_pictureid 2188 2189 pictureid=property(__getfield_pictureid, __setfield_pictureid, __delfield_pictureid, None) 2190 2191 def __getfield_defaultnum(self): 2192 try: self.__field_defaultnum 2193 except: 2194 self.__field_defaultnum=UINT(**{'sizeinbytes': 2, 'default': 0}) 2195 return self.__field_defaultnum.getvalue() 2196 2197 def __setfield_defaultnum(self, value): 2198 if isinstance(value,UINT): 2199 self.__field_defaultnum=value 2200 else: 2201 self.__field_defaultnum=UINT(value,**{'sizeinbytes': 2, 'default': 0}) 2202 2203 def __delfield_defaultnum(self): del self.__field_defaultnum 2204 2205 defaultnum=property(__getfield_defaultnum, __setfield_defaultnum, __delfield_defaultnum, None) 2206 2207 def __getfield_secret(self): 2208 try: self.__field_secret 2209 except: 2210 self.__field_secret=UINT(**{'sizeinbytes': 1, 'default': 0}) 2211 return self.__field_secret.getvalue() 2212 2213 def __setfield_secret(self, value): 2214 if isinstance(value,UINT): 2215 self.__field_secret=value 2216 else: 2217 self.__field_secret=UINT(value,**{'sizeinbytes': 1, 'default': 0}) 2218 2219 def __delfield_secret(self): del self.__field_secret 2220 2221 secret=property(__getfield_secret, __setfield_secret, __delfield_secret, None) 2222 2223 def iscontainer(self): 2224 return True 2225 2226 def containerelements(self): 2227 yield ('groupid', self.__field_groupid, None) 2228 yield ('slot', self.__field_slot, None) 2229 yield ('namep', self.__field_namep, None) 2230 yield ('numberps', self.__field_numberps, None) 2231 yield ('emailps', self.__field_emailps, None) 2232 yield ('urlp', self.__field_urlp, None) 2233 yield ('addressp', self.__field_addressp, None) 2234 yield ('memop', self.__field_memop, None) 2235 yield ('ringerid', self.__field_ringerid, None) 2236 yield ('pictureid', self.__field_pictureid, None) 2237 yield ('defaultnum', self.__field_defaultnum, None) 2238 yield ('secret', self.__field_secret, None) 2239 2240 2241 2242 2243 class _gen_p_sanyo6600_143(BaseProtogenClass): 2244 'Anonymous inner class' 2245 __fields=['slot'] 2246 2247 def __init__(self, *args, **kwargs): 2248 dict={} 2249 # What was supplied to this function 2250 dict.update(kwargs) 2251 # Parent constructor 2252 super(_gen_p_sanyo6600_143,self).__init__(**dict) 2253 if self.__class__ is _gen_p_sanyo6600_143: 2254 self._update(args,dict) 2255 2256 2257 def getfields(self): 2258 return self.__fields 2259 2260 2261 def _update(self, args, kwargs): 2262 super(_gen_p_sanyo6600_143,self)._update(args,kwargs) 2263 keys=kwargs.keys() 2264 for key in keys: 2265 if key in self.__fields: 2266 setattr(self, key, kwargs[key]) 2267 del kwargs[key] 2268 # Were any unrecognized kwargs passed in? 2269 if __debug__: 2270 self._complainaboutunusedargs(_gen_p_sanyo6600_143,kwargs) 2271 if len(args): 2272 dict2={'sizeinbytes': 2, 'default': 0xffff} 2273 dict2.update(kwargs) 2274 kwargs=dict2 2275 self.__field_slot=UINT(*args,**dict2) 2276 # Make all P fields that haven't already been constructed 2277 2278 2279 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 2280 'Writes this packet to the supplied buffer' 2281 self._bufferstartoffset=buf.getcurrentoffset() 2282 self.__field_slot.writetobuffer(buf) 2283 self._bufferendoffset=buf.getcurrentoffset() 2284 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 2285 2286 2287 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 2288 'Reads this packet from the supplied buffer' 2289 self._bufferstartoffset=buf.getcurrentoffset() 2290 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 2291 self.__field_slot=UINT(**{'sizeinbytes': 2, 'default': 0xffff}) 2292 self.__field_slot.readfrombuffer(buf) 2293 self._bufferendoffset=buf.getcurrentoffset() 2294 2295 2296 def __getfield_slot(self): 2297 return self.__field_slot.getvalue() 2298 2299 def __setfield_slot(self, value): 2300 if isinstance(value,UINT): 2301 self.__field_slot=value 2302 else: 2303 self.__field_slot=UINT(value,**{'sizeinbytes': 2, 'default': 0xffff}) 2304 2305 def __delfield_slot(self): del self.__field_slot 2306 2307 slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None) 2308 2309 def iscontainer(self): 2310 return True 2311 2312 def containerelements(self): 2313 yield ('slot', self.__field_slot, None) 2314 2315 2316 2317 2318 class _gen_p_sanyo6600_145(BaseProtogenClass): 2319 'Anonymous inner class' 2320 __fields=['slot'] 2321 2322 def __init__(self, *args, **kwargs): 2323 dict={} 2324 # What was supplied to this function 2325 dict.update(kwargs) 2326 # Parent constructor 2327 super(_gen_p_sanyo6600_145,self).__init__(**dict) 2328 if self.__class__ is _gen_p_sanyo6600_145: 2329 self._update(args,dict) 2330 2331 2332 def getfields(self): 2333 return self.__fields 2334 2335 2336 def _update(self, args, kwargs): 2337 super(_gen_p_sanyo6600_145,self)._update(args,kwargs) 2338 keys=kwargs.keys() 2339 for key in keys: 2340 if key in self.__fields: 2341 setattr(self, key, kwargs[key]) 2342 del kwargs[key] 2343 # Were any unrecognized kwargs passed in? 2344 if __debug__: 2345 self._complainaboutunusedargs(_gen_p_sanyo6600_145,kwargs) 2346 if len(args): 2347 dict2={'sizeinbytes': 2, 'default': 0xffff} 2348 dict2.update(kwargs) 2349 kwargs=dict2 2350 self.__field_slot=UINT(*args,**dict2) 2351 # Make all P fields that haven't already been constructed 2352 2353 2354 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 2355 'Writes this packet to the supplied buffer' 2356 self._bufferstartoffset=buf.getcurrentoffset() 2357 self.__field_slot.writetobuffer(buf) 2358 self._bufferendoffset=buf.getcurrentoffset() 2359 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 2360 2361 2362 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 2363 'Reads this packet from the supplied buffer' 2364 self._bufferstartoffset=buf.getcurrentoffset() 2365 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 2366 self.__field_slot=UINT(**{'sizeinbytes': 2, 'default': 0xffff}) 2367 self.__field_slot.readfrombuffer(buf) 2368 self._bufferendoffset=buf.getcurrentoffset() 2369 2370 2371 def __getfield_slot(self): 2372 return self.__field_slot.getvalue() 2373 2374 def __setfield_slot(self, value): 2375 if isinstance(value,UINT): 2376 self.__field_slot=value 2377 else: 2378 self.__field_slot=UINT(value,**{'sizeinbytes': 2, 'default': 0xffff}) 2379 2380 def __delfield_slot(self): del self.__field_slot 2381 2382 slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None) 2383 2384 def iscontainer(self): 2385 return True 2386 2387 def containerelements(self): 2388 yield ('slot', self.__field_slot, None) 2389 2390 2391 2392 2393 class contactindexresponse(BaseProtogenClass): 2394 __fields=['header', 'slot', 'entry', 'pad'] 2395 2396 def __init__(self, *args, **kwargs): 2397 dict={} 2398 # What was supplied to this function 2399 dict.update(kwargs) 2400 # Parent constructor 2401 super(contactindexresponse,self).__init__(**dict) 2402 if self.__class__ is contactindexresponse: 2403 self._update(args,dict) 2404 2405 2406 def getfields(self): 2407 return self.__fields 2408 2409 2410 def _update(self, args, kwargs): 2411 super(contactindexresponse,self)._update(args,kwargs) 2412 keys=kwargs.keys() 2413 for key in keys: 2414 if key in self.__fields: 2415 setattr(self, key, kwargs[key]) 2416 del kwargs[key] 2417 # Were any unrecognized kwargs passed in? 2418 if __debug__: 2419 self._complainaboutunusedargs(contactindexresponse,kwargs) 2420 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 2421 # Make all P fields that haven't already been constructed 2422 2423 2424 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 2425 'Writes this packet to the supplied buffer' 2426 self._bufferstartoffset=buf.getcurrentoffset() 2427 self.__field_header.writetobuffer(buf) 2428 self.__field_slot.writetobuffer(buf) 2429 self.__field_entry.writetobuffer(buf) 2430 self.__field_pad.writetobuffer(buf) 2431 self._bufferendoffset=buf.getcurrentoffset() 2432 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 2433 2434 2435 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 2436 'Reads this packet from the supplied buffer' 2437 self._bufferstartoffset=buf.getcurrentoffset() 2438 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 2439 self.__field_header=sanyoheader() 2440 self.__field_header.readfrombuffer(buf) 2441 self.__field_slot=UINT(**{'sizeinbytes': 2}) 2442 self.__field_slot.readfrombuffer(buf) 2443 self.__field_entry=contactindexentry() 2444 self.__field_entry.readfrombuffer(buf) 2445 self.__field_pad=UNKNOWN() 2446 self.__field_pad.readfrombuffer(buf) 2447 self._bufferendoffset=buf.getcurrentoffset() 2448 2449 2450 def __getfield_header(self): 2451 return self.__field_header.getvalue() 2452 2453 def __setfield_header(self, value): 2454 if isinstance(value,sanyoheader): 2455 self.__field_header=value 2456 else: 2457 self.__field_header=sanyoheader(value,) 2458 2459 def __delfield_header(self): del self.__field_header 2460 2461 header=property(__getfield_header, __setfield_header, __delfield_header, None) 2462 2463 def __getfield_slot(self): 2464 return self.__field_slot.getvalue() 2465 2466 def __setfield_slot(self, value): 2467 if isinstance(value,UINT): 2468 self.__field_slot=value 2469 else: 2470 self.__field_slot=UINT(value,**{'sizeinbytes': 2}) 2471 2472 def __delfield_slot(self): del self.__field_slot 2473 2474 slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None) 2475 2476 def __getfield_entry(self): 2477 return self.__field_entry.getvalue() 2478 2479 def __setfield_entry(self, value): 2480 if isinstance(value,contactindexentry): 2481 self.__field_entry=value 2482 else: 2483 self.__field_entry=contactindexentry(value,) 2484 2485 def __delfield_entry(self): del self.__field_entry 2486 2487 entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None) 2488 2489 def __getfield_pad(self): 2490 return self.__field_pad.getvalue() 2491 2492 def __setfield_pad(self, value): 2493 if isinstance(value,UNKNOWN): 2494 self.__field_pad=value 2495 else: 2496 self.__field_pad=UNKNOWN(value,) 2497 2498 def __delfield_pad(self): del self.__field_pad 2499 2500 pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None) 2501 2502 def iscontainer(self): 2503 return True 2504 2505 def containerelements(self): 2506 yield ('header', self.__field_header, None) 2507 yield ('slot', self.__field_slot, None) 2508 yield ('entry', self.__field_entry, None) 2509 yield ('pad', self.__field_pad, None) 2510 2511 2512 2513 2514 class contactindexupdaterequest(BaseProtogenClass): 2515 __fields=['header', 'slot', 'entry'] 2516 2517 def __init__(self, *args, **kwargs): 2518 dict={} 2519 # What was supplied to this function 2520 dict.update(kwargs) 2521 # Parent constructor 2522 super(contactindexupdaterequest,self).__init__(**dict) 2523 if self.__class__ is contactindexupdaterequest: 2524 self._update(args,dict) 2525 2526 2527 def getfields(self): 2528 return self.__fields 2529 2530 2531 def _update(self, args, kwargs): 2532 super(contactindexupdaterequest,self)._update(args,kwargs) 2533 keys=kwargs.keys() 2534 for key in keys: 2535 if key in self.__fields: 2536 setattr(self, key, kwargs[key]) 2537 del kwargs[key] 2538 # Were any unrecognized kwargs passed in? 2539 if __debug__: 2540 self._complainaboutunusedargs(contactindexupdaterequest,kwargs) 2541 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 2542 # Make all P fields that haven't already been constructed 2543 2544 2545 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 2546 'Writes this packet to the supplied buffer' 2547 self._bufferstartoffset=buf.getcurrentoffset() 2548 try: self.__field_header 2549 except: 2550 self.__field_header=sanyowriteheader(**{'packettype': 0x16, 'command': 0x88}) 2551 self.__field_header.writetobuffer(buf) 2552 self.__field_slot.writetobuffer(buf) 2553 try: self.__field_entry 2554 except: 2555 self.__field_entry=contactindexentry() 2556 self.__field_entry.writetobuffer(buf) 2557 self._bufferendoffset=buf.getcurrentoffset() 2558 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 2559 2560 2561 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 2562 'Reads this packet from the supplied buffer' 2563 self._bufferstartoffset=buf.getcurrentoffset() 2564 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 2565 self.__field_header=sanyowriteheader(**{'packettype': 0x16, 'command': 0x88}) 2566 self.__field_header.readfrombuffer(buf) 2567 self.__field_slot=UINT(**{'sizeinbytes': 2}) 2568 self.__field_slot.readfrombuffer(buf) 2569 self.__field_entry=contactindexentry() 2570 self.__field_entry.readfrombuffer(buf) 2571 self._bufferendoffset=buf.getcurrentoffset() 2572 2573 2574 def __getfield_header(self): 2575 try: self.__field_header 2576 except: 2577 self.__field_header=sanyowriteheader(**{'packettype': 0x16, 'command': 0x88}) 2578 return self.__field_header.getvalue() 2579 2580 def __setfield_header(self, value): 2581 if isinstance(value,sanyowriteheader): 2582 self.__field_header=value 2583 else: 2584 self.__field_header=sanyowriteheader(value,**{'packettype': 0x16, 'command': 0x88}) 2585 2586 def __delfield_header(self): del self.__field_header 2587 2588 header=property(__getfield_header, __setfield_header, __delfield_header, None) 2589 2590 def __getfield_slot(self): 2591 return self.__field_slot.getvalue() 2592 2593 def __setfield_slot(self, value): 2594 if isinstance(value,UINT): 2595 self.__field_slot=value 2596 else: 2597 self.__field_slot=UINT(value,**{'sizeinbytes': 2}) 2598 2599 def __delfield_slot(self): del self.__field_slot 2600 2601 slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None) 2602 2603 def __getfield_entry(self): 2604 try: self.__field_entry 2605 except: 2606 self.__field_entry=contactindexentry() 2607 return self.__field_entry.getvalue() 2608 2609 def __setfield_entry(self, value): 2610 if isinstance(value,contactindexentry): 2611 self.__field_entry=value 2612 else: 2613 self.__field_entry=contactindexentry(value,) 2614 2615 def __delfield_entry(self): del self.__field_entry 2616 2617 entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None) 2618 2619 def iscontainer(self): 2620 return True 2621 2622 def containerelements(self): 2623 yield ('header', self.__field_header, None) 2624 yield ('slot', self.__field_slot, None) 2625 yield ('entry', self.__field_entry, None) 2626 2627 2628 2629 2630 class numberrequest(BaseProtogenClass): 2631 __fields=['header', 'slot'] 2632 2633 def __init__(self, *args, **kwargs): 2634 dict={} 2635 # What was supplied to this function 2636 dict.update(kwargs) 2637 # Parent constructor 2638 super(numberrequest,self).__init__(**dict) 2639 if self.__class__ is numberrequest: 2640 self._update(args,dict) 2641 2642 2643 def getfields(self): 2644 return self.__fields 2645 2646 2647 def _update(self, args, kwargs): 2648 super(numberrequest,self)._update(args,kwargs) 2649 keys=kwargs.keys() 2650 for key in keys: 2651 if key in self.__fields: 2652 setattr(self, key, kwargs[key]) 2653 del kwargs[key] 2654 # Were any unrecognized kwargs passed in? 2655 if __debug__: 2656 self._complainaboutunusedargs(numberrequest,kwargs) 2657 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 2658 # Make all P fields that haven't already been constructed 2659 2660 2661 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 2662 'Writes this packet to the supplied buffer' 2663 self._bufferstartoffset=buf.getcurrentoffset() 2664 try: self.__field_header 2665 except: 2666 self.__field_header=sanyoheader(**{'packettype': 0x16, 'command': 0x8f}) 2667 self.__field_header.writetobuffer(buf) 2668 self.__field_slot.writetobuffer(buf) 2669 self._bufferendoffset=buf.getcurrentoffset() 2670 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 2671 2672 2673 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 2674 'Reads this packet from the supplied buffer' 2675 self._bufferstartoffset=buf.getcurrentoffset() 2676 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 2677 self.__field_header=sanyoheader(**{'packettype': 0x16, 'command': 0x8f}) 2678 self.__field_header.readfrombuffer(buf) 2679 self.__field_slot=UINT(**{'sizeinbytes': 2}) 2680 self.__field_slot.readfrombuffer(buf) 2681 self._bufferendoffset=buf.getcurrentoffset() 2682 2683 2684 def __getfield_header(self): 2685 try: self.__field_header 2686 except: 2687 self.__field_header=sanyoheader(**{'packettype': 0x16, 'command': 0x8f}) 2688 return self.__field_header.getvalue() 2689 2690 def __setfield_header(self, value): 2691 if isinstance(value,sanyoheader): 2692 self.__field_header=value 2693 else: 2694 self.__field_header=sanyoheader(value,**{'packettype': 0x16, 'command': 0x8f}) 2695 2696 def __delfield_header(self): del self.__field_header 2697 2698 header=property(__getfield_header, __setfield_header, __delfield_header, None) 2699 2700 def __getfield_slot(self): 2701 return self.__field_slot.getvalue() 2702 2703 def __setfield_slot(self, value): 2704 if isinstance(value,UINT): 2705 self.__field_slot=value 2706 else: 2707 self.__field_slot=UINT(value,**{'sizeinbytes': 2}) 2708 2709 def __delfield_slot(self): del self.__field_slot 2710 2711 slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None) 2712 2713 def iscontainer(self): 2714 return True 2715 2716 def containerelements(self): 2717 yield ('header', self.__field_header, None) 2718 yield ('slot', self.__field_slot, None) 2719 2720 2721 2722 2723 class numberentry(BaseProtogenClass): 2724 __fields=['contactp', 'numberlen', 'number', 'pad', 'numbertype'] 2725 2726 def __init__(self, *args, **kwargs): 2727 dict={} 2728 # What was supplied to this function 2729 dict.update(kwargs) 2730 # Parent constructor 2731 super(numberentry,self).__init__(**dict) 2732 if self.__class__ is numberentry: 2733 self._update(args,dict) 2734 2735 2736 def getfields(self): 2737 return self.__fields 2738 2739 2740 def _update(self, args, kwargs): 2741 super(numberentry,self)._update(args,kwargs) 2742 keys=kwargs.keys() 2743 for key in keys: 2744 if key in self.__fields: 2745 setattr(self, key, kwargs[key]) 2746 del kwargs[key] 2747 # Were any unrecognized kwargs passed in? 2748 if __debug__: 2749 self._complainaboutunusedargs(numberentry,kwargs) 2750 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 2751 # Make all P fields that haven't already been constructed 2752 2753 2754 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 2755 'Writes this packet to the supplied buffer' 2756 self._bufferstartoffset=buf.getcurrentoffset() 2757 self.__field_contactp.writetobuffer(buf) 2758 self.__field_numberlen.writetobuffer(buf) 2759 try: self.__field_number 2760 except: 2761 self.__field_number=USTRING(**{'sizeinbytes': 48, 'default': "", 'raiseonunterminatedread': False, 'raiseontruncate': False, 'terminator': None}) 2762 self.__field_number.writetobuffer(buf) 2763 try: self.__field_pad 2764 except: 2765 self.__field_pad=UNKNOWN(**{'sizeinbytes': 1}) 2766 self.__field_pad.writetobuffer(buf) 2767 self.__field_numbertype.writetobuffer(buf) 2768 self._bufferendoffset=buf.getcurrentoffset() 2769 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 2770 2771 2772 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 2773 'Reads this packet from the supplied buffer' 2774 self._bufferstartoffset=buf.getcurrentoffset() 2775 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 2776 self.__field_contactp=UINT(**{'sizeinbytes': 2}) 2777 self.__field_contactp.readfrombuffer(buf) 2778 self.__field_numberlen=UINT(**{'sizeinbytes': 1}) 2779 self.__field_numberlen.readfrombuffer(buf) 2780 self.__field_number=USTRING(**{'sizeinbytes': 48, 'default': "", 'raiseonunterminatedread': False, 'raiseontruncate': False, 'terminator': None}) 2781 self.__field_number.readfrombuffer(buf) 2782 self.__field_pad=UNKNOWN(**{'sizeinbytes': 1}) 2783 self.__field_pad.readfrombuffer(buf) 2784 self.__field_numbertype=UINT(**{'sizeinbytes': 1}) 2785 self.__field_numbertype.readfrombuffer(buf) 2786 self._bufferendoffset=buf.getcurrentoffset() 2787 2788 2789 def __getfield_contactp(self): 2790 return self.__field_contactp.getvalue() 2791 2792 def __setfield_contactp(self, value): 2793 if isinstance(value,UINT): 2794 self.__field_contactp=value 2795 else: 2796 self.__field_contactp=UINT(value,**{'sizeinbytes': 2}) 2797 2798 def __delfield_contactp(self): del self.__field_contactp 2799 2800 contactp=property(__getfield_contactp, __setfield_contactp, __delfield_contactp, "Pointer to contact number belongs") 2801 2802 def __getfield_numberlen(self): 2803 return self.__field_numberlen.getvalue() 2804 2805 def __setfield_numberlen(self, value): 2806 if isinstance(value,UINT): 2807 self.__field_numberlen=value 2808 else: 2809 self.__field_numberlen=UINT(value,**{'sizeinbytes': 1}) 2810 2811 def __delfield_numberlen(self): del self.__field_numberlen 2812 2813 numberlen=property(__getfield_numberlen, __setfield_numberlen, __delfield_numberlen, None) 2814 2815 def __getfield_number(self): 2816 try: self.__field_number 2817 except: 2818 self.__field_number=USTRING(**{'sizeinbytes': 48, 'default': "", 'raiseonunterminatedread': False, 'raiseontruncate': False, 'terminator': None}) 2819 return self.__field_number.getvalue() 2820 2821 def __setfield_number(self, value): 2822 if isinstance(value,USTRING): 2823 self.__field_number=value 2824 else: 2825 self.__field_number=USTRING(value,**{'sizeinbytes': 48, 'default': "", 'raiseonunterminatedread': False, 'raiseontruncate': False, 'terminator': None}) 2826 2827 def __delfield_number(self): del self.__field_number 2828 2829 number=property(__getfield_number, __setfield_number, __delfield_number, None) 2830 2831 def __getfield_pad(self): 2832 try: self.__field_pad 2833 except: 2834 self.__field_pad=UNKNOWN(**{'sizeinbytes': 1}) 2835 return self.__field_pad.getvalue() 2836 2837 def __setfield_pad(self, value): 2838 if isinstance(value,UNKNOWN): 2839 self.__field_pad=value 2840 else: 2841 self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 1}) 2842 2843 def __delfield_pad(self): del self.__field_pad 2844 2845 pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None) 2846 2847 def __getfield_numbertype(self): 2848 return self.__field_numbertype.getvalue() 2849 2850 def __setfield_numbertype(self, value): 2851 if isinstance(value,UINT): 2852 self.__field_numbertype=value 2853 else: 2854 self.__field_numbertype=UINT(value,**{'sizeinbytes': 1}) 2855 2856 def __delfield_numbertype(self): del self.__field_numbertype 2857 2858 numbertype=property(__getfield_numbertype, __setfield_numbertype, __delfield_numbertype, None) 2859 2860 def iscontainer(self): 2861 return True 2862 2863 def containerelements(self): 2864 yield ('contactp', self.__field_contactp, "Pointer to contact number belongs") 2865 yield ('numberlen', self.__field_numberlen, None) 2866 yield ('number', self.__field_number, None) 2867 yield ('pad', self.__field_pad, None) 2868 yield ('numbertype', self.__field_numbertype, None) 2869 2870 2871 2872 2873 class numberresponse(BaseProtogenClass): 2874 __fields=['header', 'slot', 'entry', 'pad'] 2875 2876 def __init__(self, *args, **kwargs): 2877 dict={} 2878 # What was supplied to this function 2879 dict.update(kwargs) 2880 # Parent constructor 2881 super(numberresponse,self).__init__(**dict) 2882 if self.__class__ is numberresponse: 2883 self._update(args,dict) 2884 2885 2886 def getfields(self): 2887 return self.__fields 2888 2889 2890 def _update(self, args, kwargs): 2891 super(numberresponse,self)._update(args,kwargs) 2892 keys=kwargs.keys() 2893 for key in keys: 2894 if key in self.__fields: 2895 setattr(self, key, kwargs[key]) 2896 del kwargs[key] 2897 # Were any unrecognized kwargs passed in? 2898 if __debug__: 2899 self._complainaboutunusedargs(numberresponse,kwargs) 2900 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 2901 # Make all P fields that haven't already been constructed 2902 2903 2904 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 2905 'Writes this packet to the supplied buffer' 2906 self._bufferstartoffset=buf.getcurrentoffset() 2907 self.__field_header.writetobuffer(buf) 2908 self.__field_slot.writetobuffer(buf) 2909 self.__field_entry.writetobuffer(buf) 2910 self.__field_pad.writetobuffer(buf) 2911 self._bufferendoffset=buf.getcurrentoffset() 2912 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 2913 2914 2915 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 2916 'Reads this packet from the supplied buffer' 2917 self._bufferstartoffset=buf.getcurrentoffset() 2918 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 2919 self.__field_header=sanyoheader() 2920 self.__field_header.readfrombuffer(buf) 2921 self.__field_slot=UINT(**{'sizeinbytes': 2}) 2922 self.__field_slot.readfrombuffer(buf) 2923 self.__field_entry=numberentry() 2924 self.__field_entry.readfrombuffer(buf) 2925 self.__field_pad=UNKNOWN() 2926 self.__field_pad.readfrombuffer(buf) 2927 self._bufferendoffset=buf.getcurrentoffset() 2928 2929 2930 def __getfield_header(self): 2931 return self.__field_header.getvalue() 2932 2933 def __setfield_header(self, value): 2934 if isinstance(value,sanyoheader): 2935 self.__field_header=value 2936 else: 2937 self.__field_header=sanyoheader(value,) 2938 2939 def __delfield_header(self): del self.__field_header 2940 2941 header=property(__getfield_header, __setfield_header, __delfield_header, None) 2942 2943 def __getfield_slot(self): 2944 return self.__field_slot.getvalue() 2945 2946 def __setfield_slot(self, value): 2947 if isinstance(value,UINT): 2948 self.__field_slot=value 2949 else: 2950 self.__field_slot=UINT(value,**{'sizeinbytes': 2}) 2951 2952 def __delfield_slot(self): del self.__field_slot 2953 2954 slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None) 2955 2956 def __getfield_entry(self): 2957 return self.__field_entry.getvalue() 2958 2959 def __setfield_entry(self, value): 2960 if isinstance(value,numberentry): 2961 self.__field_entry=value 2962 else: 2963 self.__field_entry=numberentry(value,) 2964 2965 def __delfield_entry(self): del self.__field_entry 2966 2967 entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None) 2968 2969 def __getfield_pad(self): 2970 return self.__field_pad.getvalue() 2971 2972 def __setfield_pad(self, value): 2973 if isinstance(value,UNKNOWN): 2974 self.__field_pad=value 2975 else: 2976 self.__field_pad=UNKNOWN(value,) 2977 2978 def __delfield_pad(self): del self.__field_pad 2979 2980 pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None) 2981 2982 def iscontainer(self): 2983 return True 2984 2985 def containerelements(self): 2986 yield ('header', self.__field_header, None) 2987 yield ('slot', self.__field_slot, None) 2988 yield ('entry', self.__field_entry, None) 2989 yield ('pad', self.__field_pad, None) 2990 2991 2992 2993 2994 class numberupdaterequest(BaseProtogenClass): 2995 __fields=['header', 'slot', 'entry'] 2996 2997 def __init__(self, *args, **kwargs): 2998 dict={} 2999 # What was supplied to this function 3000 dict.update(kwargs) 3001 # Parent constructor 3002 super(numberupdaterequest,self).__init__(**dict) 3003 if self.__class__ is numberupdaterequest: 3004 self._update(args,dict) 3005 3006 3007 def getfields(self): 3008 return self.__fields 3009 3010 3011 def _update(self, args, kwargs): 3012 super(numberupdaterequest,self)._update(args,kwargs) 3013 keys=kwargs.keys() 3014 for key in keys: 3015 if key in self.__fields: 3016 setattr(self, key, kwargs[key]) 3017 del kwargs[key] 3018 # Were any unrecognized kwargs passed in? 3019 if __debug__: 3020 self._complainaboutunusedargs(numberupdaterequest,kwargs) 3021 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 3022 # Make all P fields that haven't already been constructed 3023 3024 3025 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 3026 'Writes this packet to the supplied buffer' 3027 self._bufferstartoffset=buf.getcurrentoffset() 3028 try: self.__field_header 3029 except: 3030 self.__field_header=sanyowriteheader(**{'packettype': 0x16, 'command': 0x8f}) 3031 self.__field_header.writetobuffer(buf) 3032 self.__field_slot.writetobuffer(buf) 3033 try: self.__field_entry 3034 except: 3035 self.__field_entry=numberentry() 3036 self.__field_entry.writetobuffer(buf) 3037 self._bufferendoffset=buf.getcurrentoffset() 3038 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 3039 3040 3041 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 3042 'Reads this packet from the supplied buffer' 3043 self._bufferstartoffset=buf.getcurrentoffset() 3044 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 3045 self.__field_header=sanyowriteheader(**{'packettype': 0x16, 'command': 0x8f}) 3046 self.__field_header.readfrombuffer(buf) 3047 self.__field_slot=UINT(**{'sizeinbytes': 2}) 3048 self.__field_slot.readfrombuffer(buf) 3049 self.__field_entry=numberentry() 3050 self.__field_entry.readfrombuffer(buf) 3051 self._bufferendoffset=buf.getcurrentoffset() 3052 3053 3054 def __getfield_header(self): 3055 try: self.__field_header 3056 except: 3057 self.__field_header=sanyowriteheader(**{'packettype': 0x16, 'command': 0x8f}) 3058 return self.__field_header.getvalue() 3059 3060 def __setfield_header(self, value): 3061 if isinstance(value,sanyowriteheader): 3062 self.__field_header=value 3063 else: 3064 self.__field_header=sanyowriteheader(value,**{'packettype': 0x16, 'command': 0x8f}) 3065 3066 def __delfield_header(self): del self.__field_header 3067 3068 header=property(__getfield_header, __setfield_header, __delfield_header, None) 3069 3070 def __getfield_slot(self): 3071 return self.__field_slot.getvalue() 3072 3073 def __setfield_slot(self, value): 3074 if isinstance(value,UINT): 3075 self.__field_slot=value 3076 else: 3077 self.__field_slot=UINT(value,**{'sizeinbytes': 2}) 3078 3079 def __delfield_slot(self): del self.__field_slot 3080 3081 slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None) 3082 3083 def __getfield_entry(self): 3084 try: self.__field_entry 3085 except: 3086 self.__field_entry=numberentry() 3087 return self.__field_entry.getvalue() 3088 3089 def __setfield_entry(self, value): 3090 if isinstance(value,numberentry): 3091 self.__field_entry=value 3092 else: 3093 self.__field_entry=numberentry(value,) 3094 3095 def __delfield_entry(self): del self.__field_entry 3096 3097 entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None) 3098 3099 def iscontainer(self): 3100 return True 3101 3102 def containerelements(self): 3103 yield ('header', self.__field_header, None) 3104 yield ('slot', self.__field_slot, None) 3105 yield ('entry', self.__field_entry, None) 3106 3107 3108 3109 3110 class namerequest(BaseProtogenClass): 3111 __fields=['header', 'slot'] 3112 3113 def __init__(self, *args, **kwargs): 3114 dict={} 3115 # What was supplied to this function 3116 dict.update(kwargs) 3117 # Parent constructor 3118 super(namerequest,self).__init__(**dict) 3119 if self.__class__ is namerequest: 3120 self._update(args,dict) 3121 3122 3123 def getfields(self): 3124 return self.__fields 3125 3126 3127 def _update(self, args, kwargs): 3128 super(namerequest,self)._update(args,kwargs) 3129 keys=kwargs.keys() 3130 for key in keys: 3131 if key in self.__fields: 3132 setattr(self, key, kwargs[key]) 3133 del kwargs[key] 3134 # Were any unrecognized kwargs passed in? 3135 if __debug__: 3136 self._complainaboutunusedargs(namerequest,kwargs) 3137 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 3138 # Make all P fields that haven't already been constructed 3139 3140 3141 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 3142 'Writes this packet to the supplied buffer' 3143 self._bufferstartoffset=buf.getcurrentoffset() 3144 try: self.__field_header 3145 except: 3146 self.__field_header=sanyoheader(**{'packettype': 0x16, 'command': 0x8c}) 3147 self.__field_header.writetobuffer(buf) 3148 self.__field_slot.writetobuffer(buf) 3149 self._bufferendoffset=buf.getcurrentoffset() 3150 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 3151 3152 3153 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 3154 'Reads this packet from the supplied buffer' 3155 self._bufferstartoffset=buf.getcurrentoffset() 3156 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 3157 self.__field_header=sanyoheader(**{'packettype': 0x16, 'command': 0x8c}) 3158 self.__field_header.readfrombuffer(buf) 3159 self.__field_slot=UINT(**{'sizeinbytes': 2}) 3160 self.__field_slot.readfrombuffer(buf) 3161 self._bufferendoffset=buf.getcurrentoffset() 3162 3163 3164 def __getfield_header(self): 3165 try: self.__field_header 3166 except: 3167 self.__field_header=sanyoheader(**{'packettype': 0x16, 'command': 0x8c}) 3168 return self.__field_header.getvalue() 3169 3170 def __setfield_header(self, value): 3171 if isinstance(value,sanyoheader): 3172 self.__field_header=value 3173 else: 3174 self.__field_header=sanyoheader(value,**{'packettype': 0x16, 'command': 0x8c}) 3175 3176 def __delfield_header(self): del self.__field_header 3177 3178 header=property(__getfield_header, __setfield_header, __delfield_header, None) 3179 3180 def __getfield_slot(self): 3181 return self.__field_slot.getvalue() 3182 3183 def __setfield_slot(self, value): 3184 if isinstance(value,UINT): 3185 self.__field_slot=value 3186 else: 3187 self.__field_slot=UINT(value,**{'sizeinbytes': 2}) 3188 3189 def __delfield_slot(self): del self.__field_slot 3190 3191 slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None) 3192 3193 def iscontainer(self): 3194 return True 3195 3196 def containerelements(self): 3197 yield ('header', self.__field_header, None) 3198 yield ('slot', self.__field_slot, None) 3199 3200 3201 3202 3203 class nameentry(BaseProtogenClass): 3204 __fields=['contactp', 'name_len', 'name_len2', 'name'] 3205 3206 def __init__(self, *args, **kwargs): 3207 dict={} 3208 # What was supplied to this function 3209 dict.update(kwargs) 3210 # Parent constructor 3211 super(nameentry,self).__init__(**dict) 3212 if self.__class__ is nameentry: 3213 self._update(args,dict) 3214 3215 3216 def getfields(self): 3217 return self.__fields 3218 3219 3220 def _update(self, args, kwargs): 3221 super(nameentry,self)._update(args,kwargs) 3222 keys=kwargs.keys() 3223 for key in keys: 3224 if key in self.__fields: 3225 setattr(self, key, kwargs[key]) 3226 del kwargs[key] 3227 # Were any unrecognized kwargs passed in? 3228 if __debug__: 3229 self._complainaboutunusedargs(nameentry,kwargs) 3230 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 3231 # Make all P fields that haven't already been constructed 3232 3233 3234 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 3235 'Writes this packet to the supplied buffer' 3236 self._bufferstartoffset=buf.getcurrentoffset() 3237 self.__field_contactp.writetobuffer(buf) 3238 self.__field_name_len.writetobuffer(buf) 3239 self.__field_name_len2.writetobuffer(buf) 3240 self.__field_name.writetobuffer(buf) 3241 self._bufferendoffset=buf.getcurrentoffset() 3242 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 3243 3244 3245 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 3246 'Reads this packet from the supplied buffer' 3247 self._bufferstartoffset=buf.getcurrentoffset() 3248 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 3249 self.__field_contactp=UINT(**{'sizeinbytes': 2}) 3250 self.__field_contactp.readfrombuffer(buf) 3251 self.__field_name_len=UINT(**{'sizeinbytes': 1}) 3252 self.__field_name_len.readfrombuffer(buf) 3253 self.__field_name_len2=UINT(**{'sizeinbytes': 1}) 3254 self.__field_name_len2.readfrombuffer(buf) 3255 self.__field_name=USTRING(**{'sizeinbytes': 32, 'default': "", 'raiseonunterminatedread': False, 'raiseontruncate': False, 'terminator': None}) 3256 self.__field_name.readfrombuffer(buf) 3257 self._bufferendoffset=buf.getcurrentoffset() 3258 3259 3260 def __getfield_contactp(self): 3261 return self.__field_contactp.getvalue() 3262 3263 def __setfield_contactp(self, value): 3264 if isinstance(value,UINT): 3265 self.__field_contactp=value 3266 else: 3267 self.__field_contactp=UINT(value,**{'sizeinbytes': 2}) 3268 3269 def __delfield_contactp(self): del self.__field_contactp 3270 3271 contactp=property(__getfield_contactp, __setfield_contactp, __delfield_contactp, None) 3272 3273 def __getfield_name_len(self): 3274 return self.__field_name_len.getvalue() 3275 3276 def __setfield_name_len(self, value): 3277 if isinstance(value,UINT): 3278 self.__field_name_len=value 3279 else: 3280 self.__field_name_len=UINT(value,**{'sizeinbytes': 1}) 3281 3282 def __delfield_name_len(self): del self.__field_name_len 3283 3284 name_len=property(__getfield_name_len, __setfield_name_len, __delfield_name_len, None) 3285 3286 def __getfield_name_len2(self): 3287 return self.__field_name_len2.getvalue() 3288 3289 def __setfield_name_len2(self, value): 3290 if isinstance(value,UINT): 3291 self.__field_name_len2=value 3292 else: 3293 self.__field_name_len2=UINT(value,**{'sizeinbytes': 1}) 3294 3295 def __delfield_name_len2(self): del self.__field_name_len2 3296 3297 name_len2=property(__getfield_name_len2, __setfield_name_len2, __delfield_name_len2, None) 3298 3299 def __getfield_name(self): 3300 return self.__field_name.getvalue() 3301 3302 def __setfield_name(self, value): 3303 if isinstance(value,USTRING): 3304 self.__field_name=value 3305 else: 3306 self.__field_name=USTRING(value,**{'sizeinbytes': 32, 'default': "", 'raiseonunterminatedread': False, 'raiseontruncate': False, 'terminator': None}) 3307 3308 def __delfield_name(self): del self.__field_name 3309 3310 name=property(__getfield_name, __setfield_name, __delfield_name, None) 3311 3312 def iscontainer(self): 3313 return True 3314 3315 def containerelements(self): 3316 yield ('contactp', self.__field_contactp, None) 3317 yield ('name_len', self.__field_name_len, None) 3318 yield ('name_len2', self.__field_name_len2, None) 3319 yield ('name', self.__field_name, None) 3320 3321 3322 3323 3324 class nameresponse(BaseProtogenClass): 3325 __fields=['header', 'slot', 'entry', 'pad'] 3326 3327 def __init__(self, *args, **kwargs): 3328 dict={} 3329 # What was supplied to this function 3330 dict.update(kwargs) 3331 # Parent constructor 3332 super(nameresponse,self).__init__(**dict) 3333 if self.__class__ is nameresponse: 3334 self._update(args,dict) 3335 3336 3337 def getfields(self): 3338 return self.__fields 3339 3340 3341 def _update(self, args, kwargs): 3342 super(nameresponse,self)._update(args,kwargs) 3343 keys=kwargs.keys() 3344 for key in keys: 3345 if key in self.__fields: 3346 setattr(self, key, kwargs[key]) 3347 del kwargs[key] 3348 # Were any unrecognized kwargs passed in? 3349 if __debug__: 3350 self._complainaboutunusedargs(nameresponse,kwargs) 3351 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 3352 # Make all P fields that haven't already been constructed 3353 3354 3355 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 3356 'Writes this packet to the supplied buffer' 3357 self._bufferstartoffset=buf.getcurrentoffset() 3358 self.__field_header.writetobuffer(buf) 3359 self.__field_slot.writetobuffer(buf) 3360 self.__field_entry.writetobuffer(buf) 3361 self.__field_pad.writetobuffer(buf) 3362 self._bufferendoffset=buf.getcurrentoffset() 3363 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 3364 3365 3366 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 3367 'Reads this packet from the supplied buffer' 3368 self._bufferstartoffset=buf.getcurrentoffset() 3369 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 3370 self.__field_header=sanyoheader() 3371 self.__field_header.readfrombuffer(buf) 3372 self.__field_slot=UINT(**{'sizeinbytes': 2}) 3373 self.__field_slot.readfrombuffer(buf) 3374 self.__field_entry=nameentry() 3375 self.__field_entry.readfrombuffer(buf) 3376 self.__field_pad=UNKNOWN() 3377 self.__field_pad.readfrombuffer(buf) 3378 self._bufferendoffset=buf.getcurrentoffset() 3379 3380 3381 def __getfield_header(self): 3382 return self.__field_header.getvalue() 3383 3384 def __setfield_header(self, value): 3385 if isinstance(value,sanyoheader): 3386 self.__field_header=value 3387 else: 3388 self.__field_header=sanyoheader(value,) 3389 3390 def __delfield_header(self): del self.__field_header 3391 3392 header=property(__getfield_header, __setfield_header, __delfield_header, None) 3393 3394 def __getfield_slot(self): 3395 return self.__field_slot.getvalue() 3396 3397 def __setfield_slot(self, value): 3398 if isinstance(value,UINT): 3399 self.__field_slot=value 3400 else: 3401 self.__field_slot=UINT(value,**{'sizeinbytes': 2}) 3402 3403 def __delfield_slot(self): del self.__field_slot 3404 3405 slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None) 3406 3407 def __getfield_entry(self): 3408 return self.__field_entry.getvalue() 3409 3410 def __setfield_entry(self, value): 3411 if isinstance(value,nameentry): 3412 self.__field_entry=value 3413 else: 3414 self.__field_entry=nameentry(value,) 3415 3416 def __delfield_entry(self): del self.__field_entry 3417 3418 entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None) 3419 3420 def __getfield_pad(self): 3421 return self.__field_pad.getvalue() 3422 3423 def __setfield_pad(self, value): 3424 if isinstance(value,UNKNOWN): 3425 self.__field_pad=value 3426 else: 3427 self.__field_pad=UNKNOWN(value,) 3428 3429 def __delfield_pad(self): del self.__field_pad 3430 3431 pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None) 3432 3433 def iscontainer(self): 3434 return True 3435 3436 def containerelements(self): 3437 yield ('header', self.__field_header, None) 3438 yield ('slot', self.__field_slot, None) 3439 yield ('entry', self.__field_entry, None) 3440 yield ('pad', self.__field_pad, None) 3441 3442 3443 3444 3445 class nameupdaterequest(BaseProtogenClass): 3446 __fields=['header', 'slot', 'entry'] 3447 3448 def __init__(self, *args, **kwargs): 3449 dict={} 3450 # What was supplied to this function 3451 dict.update(kwargs) 3452 # Parent constructor 3453 super(nameupdaterequest,self).__init__(**dict) 3454 if self.__class__ is nameupdaterequest: 3455 self._update(args,dict) 3456 3457 3458 def getfields(self): 3459 return self.__fields 3460 3461 3462 def _update(self, args, kwargs): 3463 super(nameupdaterequest,self)._update(args,kwargs) 3464 keys=kwargs.keys() 3465 for key in keys: 3466 if key in self.__fields: 3467 setattr(self, key, kwargs[key]) 3468 del kwargs[key] 3469 # Were any unrecognized kwargs passed in? 3470 if __debug__: 3471 self._complainaboutunusedargs(nameupdaterequest,kwargs) 3472 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 3473 # Make all P fields that haven't already been constructed 3474 3475 3476 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 3477 'Writes this packet to the supplied buffer' 3478 self._bufferstartoffset=buf.getcurrentoffset() 3479 try: self.__field_header 3480 except: 3481 self.__field_header=sanyowriteheader(**{'packettype': 0x16, 'command': 0x8c}) 3482 self.__field_header.writetobuffer(buf) 3483 self.__field_slot.writetobuffer(buf) 3484 try: self.__field_entry 3485 except: 3486 self.__field_entry=nameentry() 3487 self.__field_entry.writetobuffer(buf) 3488 self._bufferendoffset=buf.getcurrentoffset() 3489 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 3490 3491 3492 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 3493 'Reads this packet from the supplied buffer' 3494 self._bufferstartoffset=buf.getcurrentoffset() 3495 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 3496 self.__field_header=sanyowriteheader(**{'packettype': 0x16, 'command': 0x8c}) 3497 self.__field_header.readfrombuffer(buf) 3498 self.__field_slot=UINT(**{'sizeinbytes': 2}) 3499 self.__field_slot.readfrombuffer(buf) 3500 self.__field_entry=nameentry() 3501 self.__field_entry.readfrombuffer(buf) 3502 self._bufferendoffset=buf.getcurrentoffset() 3503 3504 3505 def __getfield_header(self): 3506 try: self.__field_header 3507 except: 3508 self.__field_header=sanyowriteheader(**{'packettype': 0x16, 'command': 0x8c}) 3509 return self.__field_header.getvalue() 3510 3511 def __setfield_header(self, value): 3512 if isinstance(value,sanyowriteheader): 3513 self.__field_header=value 3514 else: 3515 self.__field_header=sanyowriteheader(value,**{'packettype': 0x16, 'command': 0x8c}) 3516 3517 def __delfield_header(self): del self.__field_header 3518 3519 header=property(__getfield_header, __setfield_header, __delfield_header, None) 3520 3521 def __getfield_slot(self): 3522 return self.__field_slot.getvalue() 3523 3524 def __setfield_slot(self, value): 3525 if isinstance(value,UINT): 3526 self.__field_slot=value 3527 else: 3528 self.__field_slot=UINT(value,**{'sizeinbytes': 2}) 3529 3530 def __delfield_slot(self): del self.__field_slot 3531 3532 slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None) 3533 3534 def __getfield_entry(self): 3535 try: self.__field_entry 3536 except: 3537 self.__field_entry=nameentry() 3538 return self.__field_entry.getvalue() 3539 3540 def __setfield_entry(self, value): 3541 if isinstance(value,nameentry): 3542 self.__field_entry=value 3543 else: 3544 self.__field_entry=nameentry(value,) 3545 3546 def __delfield_entry(self): del self.__field_entry 3547 3548 entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None) 3549 3550 def iscontainer(self): 3551 return True 3552 3553 def containerelements(self): 3554 yield ('header', self.__field_header, None) 3555 yield ('slot', self.__field_slot, None) 3556 yield ('entry', self.__field_entry, None) 3557 3558 3559 3560 3561 class urlrequest(BaseProtogenClass): 3562 __fields=['header', 'slot'] 3563 3564 def __init__(self, *args, **kwargs): 3565 dict={} 3566 # What was supplied to this function 3567 dict.update(kwargs) 3568 # Parent constructor 3569 super(urlrequest,self).__init__(**dict) 3570 if self.__class__ is urlrequest: 3571 self._update(args,dict) 3572 3573 3574 def getfields(self): 3575 return self.__fields 3576 3577 3578 def _update(self, args, kwargs): 3579 super(urlrequest,self)._update(args,kwargs) 3580 keys=kwargs.keys() 3581 for key in keys: 3582 if key in self.__fields: 3583 setattr(self, key, kwargs[key]) 3584 del kwargs[key] 3585 # Were any unrecognized kwargs passed in? 3586 if __debug__: 3587 self._complainaboutunusedargs(urlrequest,kwargs) 3588 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 3589 # Make all P fields that haven't already been constructed 3590 3591 3592 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 3593 'Writes this packet to the supplied buffer' 3594 self._bufferstartoffset=buf.getcurrentoffset() 3595 try: self.__field_header 3596 except: 3597 self.__field_header=sanyoheader(**{'packettype': 0x16, 'command': 0x98}) 3598 self.__field_header.writetobuffer(buf) 3599 self.__field_slot.writetobuffer(buf) 3600 self._bufferendoffset=buf.getcurrentoffset() 3601 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 3602 3603 3604 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 3605 'Reads this packet from the supplied buffer' 3606 self._bufferstartoffset=buf.getcurrentoffset() 3607 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 3608 self.__field_header=sanyoheader(**{'packettype': 0x16, 'command': 0x98}) 3609 self.__field_header.readfrombuffer(buf) 3610 self.__field_slot=UINT(**{'sizeinbytes': 2}) 3611 self.__field_slot.readfrombuffer(buf) 3612 self._bufferendoffset=buf.getcurrentoffset() 3613 3614 3615 def __getfield_header(self): 3616 try: self.__field_header 3617 except: 3618 self.__field_header=sanyoheader(**{'packettype': 0x16, 'command': 0x98}) 3619 return self.__field_header.getvalue() 3620 3621 def __setfield_header(self, value): 3622 if isinstance(value,sanyoheader): 3623 self.__field_header=value 3624 else: 3625 self.__field_header=sanyoheader(value,**{'packettype': 0x16, 'command': 0x98}) 3626 3627 def __delfield_header(self): del self.__field_header 3628 3629 header=property(__getfield_header, __setfield_header, __delfield_header, None) 3630 3631 def __getfield_slot(self): 3632 return self.__field_slot.getvalue() 3633 3634 def __setfield_slot(self, value): 3635 if isinstance(value,UINT): 3636 self.__field_slot=value 3637 else: 3638 self.__field_slot=UINT(value,**{'sizeinbytes': 2}) 3639 3640 def __delfield_slot(self): del self.__field_slot 3641 3642 slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None) 3643 3644 def iscontainer(self): 3645 return True 3646 3647 def containerelements(self): 3648 yield ('header', self.__field_header, None) 3649 yield ('slot', self.__field_slot, None) 3650 3651 3652 3653 3654 class urlentry(BaseProtogenClass): 3655 __fields=['contactp', 'url_len', 'url', 'pad', 'type'] 3656 3657 def __init__(self, *args, **kwargs): 3658 dict={} 3659 # What was supplied to this function 3660 dict.update(kwargs) 3661 # Parent constructor 3662 super(urlentry,self).__init__(**dict) 3663 if self.__class__ is urlentry: 3664 self._update(args,dict) 3665 3666 3667 def getfields(self): 3668 return self.__fields 3669 3670 3671 def _update(self, args, kwargs): 3672 super(urlentry,self)._update(args,kwargs) 3673 keys=kwargs.keys() 3674 for key in keys: 3675 if key in self.__fields: 3676 setattr(self, key, kwargs[key]) 3677 del kwargs[key] 3678 # Were any unrecognized kwargs passed in? 3679 if __debug__: 3680 self._complainaboutunusedargs(urlentry,kwargs) 3681 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 3682 # Make all P fields that haven't already been constructed 3683 3684 3685 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 3686 'Writes this packet to the supplied buffer' 3687 self._bufferstartoffset=buf.getcurrentoffset() 3688 self.__field_contactp.writetobuffer(buf) 3689 self.__field_url_len.writetobuffer(buf) 3690 try: self.__field_url 3691 except: 3692 self.__field_url=USTRING(**{'sizeinbytes': 96, 'default': "", 'raiseonunterminatedread': False, 'raiseontruncate': False, 'terminator': None}) 3693 self.__field_url.writetobuffer(buf) 3694 try: self.__field_pad 3695 except: 3696 self.__field_pad=UNKNOWN(**{'sizeinbytes': 1}) 3697 self.__field_pad.writetobuffer(buf) 3698 try: self.__field_type 3699 except: 3700 self.__field_type=UINT(**{'sizeinbytes': 1, 'default': 9}) 3701 self.__field_type.writetobuffer(buf) 3702 self._bufferendoffset=buf.getcurrentoffset() 3703 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 3704 3705 3706 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 3707 'Reads this packet from the supplied buffer' 3708 self._bufferstartoffset=buf.getcurrentoffset() 3709 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 3710 self.__field_contactp=UINT(**{'sizeinbytes': 2}) 3711 self.__field_contactp.readfrombuffer(buf) 3712 self.__field_url_len=UINT(**{'sizeinbytes': 1}) 3713 self.__field_url_len.readfrombuffer(buf) 3714 self.__field_url=USTRING(**{'sizeinbytes': 96, 'default': "", 'raiseonunterminatedread': False, 'raiseontruncate': False, 'terminator': None}) 3715 self.__field_url.readfrombuffer(buf) 3716 self.__field_pad=UNKNOWN(**{'sizeinbytes': 1}) 3717 self.__field_pad.readfrombuffer(buf) 3718 self.__field_type=UINT(**{'sizeinbytes': 1, 'default': 9}) 3719 self.__field_type.readfrombuffer(buf) 3720 self._bufferendoffset=buf.getcurrentoffset() 3721 3722 3723 def __getfield_contactp(self): 3724 return self.__field_contactp.getvalue() 3725 3726 def __setfield_contactp(self, value): 3727 if isinstance(value,UINT): 3728 self.__field_contactp=value 3729 else: 3730 self.__field_contactp=UINT(value,**{'sizeinbytes': 2}) 3731 3732 def __delfield_contactp(self): del self.__field_contactp 3733 3734 contactp=property(__getfield_contactp, __setfield_contactp, __delfield_contactp, "Pointer to contact number belongs") 3735 3736 def __getfield_url_len(self): 3737 return self.__field_url_len.getvalue() 3738 3739 def __setfield_url_len(self, value): 3740 if isinstance(value,UINT): 3741 self.__field_url_len=value 3742 else: 3743 self.__field_url_len=UINT(value,**{'sizeinbytes': 1}) 3744 3745 def __delfield_url_len(self): del self.__field_url_len 3746 3747 url_len=property(__getfield_url_len, __setfield_url_len, __delfield_url_len, None) 3748 3749 def __getfield_url(self): 3750 try: self.__field_url 3751 except: 3752 self.__field_url=USTRING(**{'sizeinbytes': 96, 'default': "", 'raiseonunterminatedread': False, 'raiseontruncate': False, 'terminator': None}) 3753 return self.__field_url.getvalue() 3754 3755 def __setfield_url(self, value): 3756 if isinstance(value,USTRING): 3757 self.__field_url=value 3758 else: 3759 self.__field_url=USTRING(value,**{'sizeinbytes': 96, 'default': "", 'raiseonunterminatedread': False, 'raiseontruncate': False, 'terminator': None}) 3760 3761 def __delfield_url(self): del self.__field_url 3762 3763 url=property(__getfield_url, __setfield_url, __delfield_url, None) 3764 3765 def __getfield_pad(self): 3766 try: self.__field_pad 3767 except: 3768 self.__field_pad=UNKNOWN(**{'sizeinbytes': 1}) 3769 return self.__field_pad.getvalue() 3770 3771 def __setfield_pad(self, value): 3772 if isinstance(value,UNKNOWN): 3773 self.__field_pad=value 3774 else: 3775 self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 1}) 3776 3777 def __delfield_pad(self): del self.__field_pad 3778 3779 pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None) 3780 3781 def __getfield_type(self): 3782 try: self.__field_type 3783 except: 3784 self.__field_type=UINT(**{'sizeinbytes': 1, 'default': 9}) 3785 return self.__field_type.getvalue() 3786 3787 def __setfield_type(self, value): 3788 if isinstance(value,UINT): 3789 self.__field_type=value 3790 else: 3791 self.__field_type=UINT(value,**{'sizeinbytes': 1, 'default': 9}) 3792 3793 def __delfield_type(self): del self.__field_type 3794 3795 type=property(__getfield_type, __setfield_type, __delfield_type, "Always 9 for World Icon") 3796 3797 def iscontainer(self): 3798 return True 3799 3800 def containerelements(self): 3801 yield ('contactp', self.__field_contactp, "Pointer to contact number belongs") 3802 yield ('url_len', self.__field_url_len, None) 3803 yield ('url', self.__field_url, None) 3804 yield ('pad', self.__field_pad, None) 3805 yield ('type', self.__field_type, "Always 9 for World Icon") 3806 3807 3808 3809 3810 class urlresponse(BaseProtogenClass): 3811 __fields=['header', 'slot', 'entry', 'pad'] 3812 3813 def __init__(self, *args, **kwargs): 3814 dict={} 3815 # What was supplied to this function 3816 dict.update(kwargs) 3817 # Parent constructor 3818 super(urlresponse,self).__init__(**dict) 3819 if self.__class__ is urlresponse: 3820 self._update(args,dict) 3821 3822 3823 def getfields(self): 3824 return self.__fields 3825 3826 3827 def _update(self, args, kwargs): 3828 super(urlresponse,self)._update(args,kwargs) 3829 keys=kwargs.keys() 3830 for key in keys: 3831 if key in self.__fields: 3832 setattr(self, key, kwargs[key]) 3833 del kwargs[key] 3834 # Were any unrecognized kwargs passed in? 3835 if __debug__: 3836 self._complainaboutunusedargs(urlresponse,kwargs) 3837 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 3838 # Make all P fields that haven't already been constructed 3839 3840 3841 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 3842 'Writes this packet to the supplied buffer' 3843 self._bufferstartoffset=buf.getcurrentoffset() 3844 self.__field_header.writetobuffer(buf) 3845 self.__field_slot.writetobuffer(buf) 3846 self.__field_entry.writetobuffer(buf) 3847 self.__field_pad.writetobuffer(buf) 3848 self._bufferendoffset=buf.getcurrentoffset() 3849 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 3850 3851 3852 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 3853 'Reads this packet from the supplied buffer' 3854 self._bufferstartoffset=buf.getcurrentoffset() 3855 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 3856 self.__field_header=sanyoheader() 3857 self.__field_header.readfrombuffer(buf) 3858 self.__field_slot=UINT(**{'sizeinbytes': 2}) 3859 self.__field_slot.readfrombuffer(buf) 3860 self.__field_entry=urlentry() 3861 self.__field_entry.readfrombuffer(buf) 3862 self.__field_pad=UNKNOWN() 3863 self.__field_pad.readfrombuffer(buf) 3864 self._bufferendoffset=buf.getcurrentoffset() 3865 3866 3867 def __getfield_header(self): 3868 return self.__field_header.getvalue() 3869 3870 def __setfield_header(self, value): 3871 if isinstance(value,sanyoheader): 3872 self.__field_header=value 3873 else: 3874 self.__field_header=sanyoheader(value,) 3875 3876 def __delfield_header(self): del self.__field_header 3877 3878 header=property(__getfield_header, __setfield_header, __delfield_header, None) 3879 3880 def __getfield_slot(self): 3881 return self.__field_slot.getvalue() 3882 3883 def __setfield_slot(self, value): 3884 if isinstance(value,UINT): 3885 self.__field_slot=value 3886 else: 3887 self.__field_slot=UINT(value,**{'sizeinbytes': 2}) 3888 3889 def __delfield_slot(self): del self.__field_slot 3890 3891 slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None) 3892 3893 def __getfield_entry(self): 3894 return self.__field_entry.getvalue() 3895 3896 def __setfield_entry(self, value): 3897 if isinstance(value,urlentry): 3898 self.__field_entry=value 3899 else: 3900 self.__field_entry=urlentry(value,) 3901 3902 def __delfield_entry(self): del self.__field_entry 3903 3904 entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None) 3905 3906 def __getfield_pad(self): 3907 return self.__field_pad.getvalue() 3908 3909 def __setfield_pad(self, value): 3910 if isinstance(value,UNKNOWN): 3911 self.__field_pad=value 3912 else: 3913 self.__field_pad=UNKNOWN(value,) 3914 3915 def __delfield_pad(self): del self.__field_pad 3916 3917 pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None) 3918 3919 def iscontainer(self): 3920 return True 3921 3922 def containerelements(self): 3923 yield ('header', self.__field_header, None) 3924 yield ('slot', self.__field_slot, None) 3925 yield ('entry', self.__field_entry, None) 3926 yield ('pad', self.__field_pad, None) 3927 3928 3929 3930 3931 class urlupdaterequest(BaseProtogenClass): 3932 __fields=['header', 'slot', 'entry'] 3933 3934 def __init__(self, *args, **kwargs): 3935 dict={} 3936 # What was supplied to this function 3937 dict.update(kwargs) 3938 # Parent constructor 3939 super(urlupdaterequest,self).__init__(**dict) 3940 if self.__class__ is urlupdaterequest: 3941 self._update(args,dict) 3942 3943 3944 def getfields(self): 3945 return self.__fields 3946 3947 3948 def _update(self, args, kwargs): 3949 super(urlupdaterequest,self)._update(args,kwargs) 3950 keys=kwargs.keys() 3951 for key in keys: 3952 if key in self.__fields: 3953 setattr(self, key, kwargs[key]) 3954 del kwargs[key] 3955 # Were any unrecognized kwargs passed in? 3956 if __debug__: 3957 self._complainaboutunusedargs(urlupdaterequest,kwargs) 3958 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 3959 # Make all P fields that haven't already been constructed 3960 3961 3962 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 3963 'Writes this packet to the supplied buffer' 3964 self._bufferstartoffset=buf.getcurrentoffset() 3965 try: self.__field_header 3966 except: 3967 self.__field_header=sanyowriteheader(**{'packettype': 0x16, 'command': 0x98}) 3968 self.__field_header.writetobuffer(buf) 3969 self.__field_slot.writetobuffer(buf) 3970 try: self.__field_entry 3971 except: 3972 self.__field_entry=urlentry() 3973 self.__field_entry.writetobuffer(buf) 3974 self._bufferendoffset=buf.getcurrentoffset() 3975 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 3976 3977 3978 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 3979 'Reads this packet from the supplied buffer' 3980 self._bufferstartoffset=buf.getcurrentoffset() 3981 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 3982 self.__field_header=sanyowriteheader(**{'packettype': 0x16, 'command': 0x98}) 3983 self.__field_header.readfrombuffer(buf) 3984 self.__field_slot=UINT(**{'sizeinbytes': 2}) 3985 self.__field_slot.readfrombuffer(buf) 3986 self.__field_entry=urlentry() 3987 self.__field_entry.readfrombuffer(buf) 3988 self._bufferendoffset=buf.getcurrentoffset() 3989 3990 3991 def __getfield_header(self): 3992 try: self.__field_header 3993 except: 3994 self.__field_header=sanyowriteheader(**{'packettype': 0x16, 'command': 0x98}) 3995 return self.__field_header.getvalue() 3996 3997 def __setfield_header(self, value): 3998 if isinstance(value,sanyowriteheader): 3999 self.__field_header=value 4000 else: 4001 self.__field_header=sanyowriteheader(value,**{'packettype': 0x16, 'command': 0x98}) 4002 4003 def __delfield_header(self): del self.__field_header 4004 4005 header=property(__getfield_header, __setfield_header, __delfield_header, None) 4006 4007 def __getfield_slot(self): 4008 return self.__field_slot.getvalue() 4009 4010 def __setfield_slot(self, value): 4011 if isinstance(value,UINT): 4012 self.__field_slot=value 4013 else: 4014 self.__field_slot=UINT(value,**{'sizeinbytes': 2}) 4015 4016 def __delfield_slot(self): del self.__field_slot 4017 4018 slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None) 4019 4020 def __getfield_entry(self): 4021 try: self.__field_entry 4022 except: 4023 self.__field_entry=urlentry() 4024 return self.__field_entry.getvalue() 4025 4026 def __setfield_entry(self, value): 4027 if isinstance(value,urlentry): 4028 self.__field_entry=value 4029 else: 4030 self.__field_entry=urlentry(value,) 4031 4032 def __delfield_entry(self): del self.__field_entry 4033 4034 entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None) 4035 4036 def iscontainer(self): 4037 return True 4038 4039 def containerelements(self): 4040 yield ('header', self.__field_header, None) 4041 yield ('slot', self.__field_slot, None) 4042 yield ('entry', self.__field_entry, None) 4043 4044 4045 4046 4047 class addressrequest(BaseProtogenClass): 4048 __fields=['header', 'slot'] 4049 4050 def __init__(self, *args, **kwargs): 4051 dict={} 4052 # What was supplied to this function 4053 dict.update(kwargs) 4054 # Parent constructor 4055 super(addressrequest,self).__init__(**dict) 4056 if self.__class__ is addressrequest: 4057 self._update(args,dict) 4058 4059 4060 def getfields(self): 4061 return self.__fields 4062 4063 4064 def _update(self, args, kwargs): 4065 super(addressrequest,self)._update(args,kwargs) 4066 keys=kwargs.keys() 4067 for key in keys: 4068 if key in self.__fields: 4069 setattr(self, key, kwargs[key]) 4070 del kwargs[key] 4071 # Were any unrecognized kwargs passed in? 4072 if __debug__: 4073 self._complainaboutunusedargs(addressrequest,kwargs) 4074 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 4075 # Make all P fields that haven't already been constructed 4076 4077 4078 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 4079 'Writes this packet to the supplied buffer' 4080 self._bufferstartoffset=buf.getcurrentoffset() 4081 try: self.__field_header 4082 except: 4083 self.__field_header=sanyoheader(**{'packettype': 0x16, 'command': 0x9b}) 4084 self.__field_header.writetobuffer(buf) 4085 self.__field_slot.writetobuffer(buf) 4086 self._bufferendoffset=buf.getcurrentoffset() 4087 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 4088 4089 4090 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 4091 'Reads this packet from the supplied buffer' 4092 self._bufferstartoffset=buf.getcurrentoffset() 4093 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 4094 self.__field_header=sanyoheader(**{'packettype': 0x16, 'command': 0x9b}) 4095 self.__field_header.readfrombuffer(buf) 4096 self.__field_slot=UINT(**{'sizeinbytes': 2}) 4097 self.__field_slot.readfrombuffer(buf) 4098 self._bufferendoffset=buf.getcurrentoffset() 4099 4100 4101 def __getfield_header(self): 4102 try: self.__field_header 4103 except: 4104 self.__field_header=sanyoheader(**{'packettype': 0x16, 'command': 0x9b}) 4105 return self.__field_header.getvalue() 4106 4107 def __setfield_header(self, value): 4108 if isinstance(value,sanyoheader): 4109 self.__field_header=value 4110 else: 4111 self.__field_header=sanyoheader(value,**{'packettype': 0x16, 'command': 0x9b}) 4112 4113 def __delfield_header(self): del self.__field_header 4114 4115 header=property(__getfield_header, __setfield_header, __delfield_header, None) 4116 4117 def __getfield_slot(self): 4118 return self.__field_slot.getvalue() 4119 4120 def __setfield_slot(self, value): 4121 if isinstance(value,UINT): 4122 self.__field_slot=value 4123 else: 4124 self.__field_slot=UINT(value,**{'sizeinbytes': 2}) 4125 4126 def __delfield_slot(self): del self.__field_slot 4127 4128 slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None) 4129 4130 def iscontainer(self): 4131 return True 4132 4133 def containerelements(self): 4134 yield ('header', self.__field_header, None) 4135 yield ('slot', self.__field_slot, None) 4136 4137 4138 4139 4140 class addressentry(BaseProtogenClass): 4141 __fields=['contactp', 'address_len', 'address'] 4142 4143 def __init__(self, *args, **kwargs): 4144 dict={} 4145 # What was supplied to this function 4146 dict.update(kwargs) 4147 # Parent constructor 4148 super(addressentry,self).__init__(**dict) 4149 if self.__class__ is addressentry: 4150 self._update(args,dict) 4151 4152 4153 def getfields(self): 4154 return self.__fields 4155 4156 4157 def _update(self, args, kwargs): 4158 super(addressentry,self)._update(args,kwargs) 4159 keys=kwargs.keys() 4160 for key in keys: 4161 if key in self.__fields: 4162 setattr(self, key, kwargs[key]) 4163 del kwargs[key] 4164 # Were any unrecognized kwargs passed in? 4165 if __debug__: 4166 self._complainaboutunusedargs(addressentry,kwargs) 4167 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 4168 # Make all P fields that haven't already been constructed 4169 4170 4171 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 4172 'Writes this packet to the supplied buffer' 4173 self._bufferstartoffset=buf.getcurrentoffset() 4174 self.__field_contactp.writetobuffer(buf) 4175 self.__field_address_len.writetobuffer(buf) 4176 try: self.__field_address 4177 except: 4178 self.__field_address=USTRING(**{'sizeinbytes': 256, 'default': "", 'raiseonunterminatedread': False, 'raiseontruncate': False, 'terminator': None}) 4179 self.__field_address.writetobuffer(buf) 4180 self._bufferendoffset=buf.getcurrentoffset() 4181 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 4182 4183 4184 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 4185 'Reads this packet from the supplied buffer' 4186 self._bufferstartoffset=buf.getcurrentoffset() 4187 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 4188 self.__field_contactp=UINT(**{'sizeinbytes': 2}) 4189 self.__field_contactp.readfrombuffer(buf) 4190 self.__field_address_len=UINT(**{'sizeinbytes': 2}) 4191 self.__field_address_len.readfrombuffer(buf) 4192 self.__field_address=USTRING(**{'sizeinbytes': 256, 'default': "", 'raiseonunterminatedread': False, 'raiseontruncate': False, 'terminator': None}) 4193 self.__field_address.readfrombuffer(buf) 4194 self._bufferendoffset=buf.getcurrentoffset() 4195 4196 4197 def __getfield_contactp(self): 4198 return self.__field_contactp.getvalue() 4199 4200 def __setfield_contactp(self, value): 4201 if isinstance(value,UINT): 4202 self.__field_contactp=value 4203 else: 4204 self.__field_contactp=UINT(value,**{'sizeinbytes': 2}) 4205 4206 def __delfield_contactp(self): del self.__field_contactp 4207 4208 contactp=property(__getfield_contactp, __setfield_contactp, __delfield_contactp, "Pointer to contact number belongs") 4209 4210 def __getfield_address_len(self): 4211 return self.__field_address_len.getvalue() 4212 4213 def __setfield_address_len(self, value): 4214 if isinstance(value,UINT): 4215 self.__field_address_len=value 4216 else: 4217 self.__field_address_len=UINT(value,**{'sizeinbytes': 2}) 4218 4219 def __delfield_address_len(self): del self.__field_address_len 4220 4221 address_len=property(__getfield_address_len, __setfield_address_len, __delfield_address_len, None) 4222 4223 def __getfield_address(self): 4224 try: self.__field_address 4225 except: 4226 self.__field_address=USTRING(**{'sizeinbytes': 256, 'default': "", 'raiseonunterminatedread': False, 'raiseontruncate': False, 'terminator': None}) 4227 return self.__field_address.getvalue() 4228 4229 def __setfield_address(self, value): 4230 if isinstance(value,USTRING): 4231 self.__field_address=value 4232 else: 4233 self.__field_address=USTRING(value,**{'sizeinbytes': 256, 'default': "", 'raiseonunterminatedread': False, 'raiseontruncate': False, 'terminator': None}) 4234 4235 def __delfield_address(self): del self.__field_address 4236 4237 address=property(__getfield_address, __setfield_address, __delfield_address, None) 4238 4239 def iscontainer(self): 4240 return True 4241 4242 def containerelements(self): 4243 yield ('contactp', self.__field_contactp, "Pointer to contact number belongs") 4244 yield ('address_len', self.__field_address_len, None) 4245 yield ('address', self.__field_address, None) 4246 4247 4248 4249 4250 class addressresponse(BaseProtogenClass): 4251 __fields=['header', 'slot', 'entry', 'pad'] 4252 4253 def __init__(self, *args, **kwargs): 4254 dict={} 4255 # What was supplied to this function 4256 dict.update(kwargs) 4257 # Parent constructor 4258 super(addressresponse,self).__init__(**dict) 4259 if self.__class__ is addressresponse: 4260 self._update(args,dict) 4261 4262 4263 def getfields(self): 4264 return self.__fields 4265 4266 4267 def _update(self, args, kwargs): 4268 super(addressresponse,self)._update(args,kwargs) 4269 keys=kwargs.keys() 4270 for key in keys: 4271 if key in self.__fields: 4272 setattr(self, key, kwargs[key]) 4273 del kwargs[key] 4274 # Were any unrecognized kwargs passed in? 4275 if __debug__: 4276 self._complainaboutunusedargs(addressresponse,kwargs) 4277 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 4278 # Make all P fields that haven't already been constructed 4279 4280 4281 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 4282 'Writes this packet to the supplied buffer' 4283 self._bufferstartoffset=buf.getcurrentoffset() 4284 self.__field_header.writetobuffer(buf) 4285 self.__field_slot.writetobuffer(buf) 4286 self.__field_entry.writetobuffer(buf) 4287 self.__field_pad.writetobuffer(buf) 4288 self._bufferendoffset=buf.getcurrentoffset() 4289 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 4290 4291 4292 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 4293 'Reads this packet from the supplied buffer' 4294 self._bufferstartoffset=buf.getcurrentoffset() 4295 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 4296 self.__field_header=sanyoheader() 4297 self.__field_header.readfrombuffer(buf) 4298 self.__field_slot=UINT(**{'sizeinbytes': 2}) 4299 self.__field_slot.readfrombuffer(buf) 4300 self.__field_entry=addressentry() 4301 self.__field_entry.readfrombuffer(buf) 4302 self.__field_pad=UNKNOWN() 4303 self.__field_pad.readfrombuffer(buf) 4304 self._bufferendoffset=buf.getcurrentoffset() 4305 4306 4307 def __getfield_header(self): 4308 return self.__field_header.getvalue() 4309 4310 def __setfield_header(self, value): 4311 if isinstance(value,sanyoheader): 4312 self.__field_header=value 4313 else: 4314 self.__field_header=sanyoheader(value,) 4315 4316 def __delfield_header(self): del self.__field_header 4317 4318 header=property(__getfield_header, __setfield_header, __delfield_header, None) 4319 4320 def __getfield_slot(self): 4321 return self.__field_slot.getvalue() 4322 4323 def __setfield_slot(self, value): 4324 if isinstance(value,UINT): 4325 self.__field_slot=value 4326 else: 4327 self.__field_slot=UINT(value,**{'sizeinbytes': 2}) 4328 4329 def __delfield_slot(self): del self.__field_slot 4330 4331 slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None) 4332 4333 def __getfield_entry(self): 4334 return self.__field_entry.getvalue() 4335 4336 def __setfield_entry(self, value): 4337 if isinstance(value,addressentry): 4338 self.__field_entry=value 4339 else: 4340 self.__field_entry=addressentry(value,) 4341 4342 def __delfield_entry(self): del self.__field_entry 4343 4344 entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None) 4345 4346 def __getfield_pad(self): 4347 return self.__field_pad.getvalue() 4348 4349 def __setfield_pad(self, value): 4350 if isinstance(value,UNKNOWN): 4351 self.__field_pad=value 4352 else: 4353 self.__field_pad=UNKNOWN(value,) 4354 4355 def __delfield_pad(self): del self.__field_pad 4356 4357 pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None) 4358 4359 def iscontainer(self): 4360 return True 4361 4362 def containerelements(self): 4363 yield ('header', self.__field_header, None) 4364 yield ('slot', self.__field_slot, None) 4365 yield ('entry', self.__field_entry, None) 4366 yield ('pad', self.__field_pad, None) 4367 4368 4369 4370 4371 class addressupdaterequest(BaseProtogenClass): 4372 __fields=['header', 'slot', 'entry'] 4373 4374 def __init__(self, *args, **kwargs): 4375 dict={} 4376 # What was supplied to this function 4377 dict.update(kwargs) 4378 # Parent constructor 4379 super(addressupdaterequest,self).__init__(**dict) 4380 if self.__class__ is addressupdaterequest: 4381 self._update(args,dict) 4382 4383 4384 def getfields(self): 4385 return self.__fields 4386 4387 4388 def _update(self, args, kwargs): 4389 super(addressupdaterequest,self)._update(args,kwargs) 4390 keys=kwargs.keys() 4391 for key in keys: 4392 if key in self.__fields: 4393 setattr(self, key, kwargs[key]) 4394 del kwargs[key] 4395 # Were any unrecognized kwargs passed in? 4396 if __debug__: 4397 self._complainaboutunusedargs(addressupdaterequest,kwargs) 4398 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 4399 # Make all P fields that haven't already been constructed 4400 4401 4402 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 4403 'Writes this packet to the supplied buffer' 4404 self._bufferstartoffset=buf.getcurrentoffset() 4405 try: self.__field_header 4406 except: 4407 self.__field_header=sanyowriteheader(**{'packettype': 0x16, 'command': 0x9b}) 4408 self.__field_header.writetobuffer(buf) 4409 self.__field_slot.writetobuffer(buf) 4410 try: self.__field_entry 4411 except: 4412 self.__field_entry=addressentry() 4413 self.__field_entry.writetobuffer(buf) 4414 self._bufferendoffset=buf.getcurrentoffset() 4415 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 4416 4417 4418 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 4419 'Reads this packet from the supplied buffer' 4420 self._bufferstartoffset=buf.getcurrentoffset() 4421 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 4422 self.__field_header=sanyowriteheader(**{'packettype': 0x16, 'command': 0x9b}) 4423 self.__field_header.readfrombuffer(buf) 4424 self.__field_slot=UINT(**{'sizeinbytes': 2}) 4425 self.__field_slot.readfrombuffer(buf) 4426 self.__field_entry=addressentry() 4427 self.__field_entry.readfrombuffer(buf) 4428 self._bufferendoffset=buf.getcurrentoffset() 4429 4430 4431 def __getfield_header(self): 4432 try: self.__field_header 4433 except: 4434 self.__field_header=sanyowriteheader(**{'packettype': 0x16, 'command': 0x9b}) 4435 return self.__field_header.getvalue() 4436 4437 def __setfield_header(self, value): 4438 if isinstance(value,sanyowriteheader): 4439 self.__field_header=value 4440 else: 4441 self.__field_header=sanyowriteheader(value,**{'packettype': 0x16, 'command': 0x9b}) 4442 4443 def __delfield_header(self): del self.__field_header 4444 4445 header=property(__getfield_header, __setfield_header, __delfield_header, None) 4446 4447 def __getfield_slot(self): 4448 return self.__field_slot.getvalue() 4449 4450 def __setfield_slot(self, value): 4451 if isinstance(value,UINT): 4452 self.__field_slot=value 4453 else: 4454 self.__field_slot=UINT(value,**{'sizeinbytes': 2}) 4455 4456 def __delfield_slot(self): del self.__field_slot 4457 4458 slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None) 4459 4460 def __getfield_entry(self): 4461 try: self.__field_entry 4462 except: 4463 self.__field_entry=addressentry() 4464 return self.__field_entry.getvalue() 4465 4466 def __setfield_entry(self, value): 4467 if isinstance(value,addressentry): 4468 self.__field_entry=value 4469 else: 4470 self.__field_entry=addressentry(value,) 4471 4472 def __delfield_entry(self): del self.__field_entry 4473 4474 entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None) 4475 4476 def iscontainer(self): 4477 return True 4478 4479 def containerelements(self): 4480 yield ('header', self.__field_header, None) 4481 yield ('slot', self.__field_slot, None) 4482 yield ('entry', self.__field_entry, None) 4483 4484 4485 4486 4487 class memorequest(BaseProtogenClass): 4488 __fields=['header', 'slot'] 4489 4490 def __init__(self, *args, **kwargs): 4491 dict={} 4492 # What was supplied to this function 4493 dict.update(kwargs) 4494 # Parent constructor 4495 super(memorequest,self).__init__(**dict) 4496 if self.__class__ is memorequest: 4497 self._update(args,dict) 4498 4499 4500 def getfields(self): 4501 return self.__fields 4502 4503 4504 def _update(self, args, kwargs): 4505 super(memorequest,self)._update(args,kwargs) 4506 keys=kwargs.keys() 4507 for key in keys: 4508 if key in self.__fields: 4509 setattr(self, key, kwargs[key]) 4510 del kwargs[key] 4511 # Were any unrecognized kwargs passed in? 4512 if __debug__: 4513 self._complainaboutunusedargs(memorequest,kwargs) 4514 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 4515 # Make all P fields that haven't already been constructed 4516 4517 4518 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 4519 'Writes this packet to the supplied buffer' 4520 self._bufferstartoffset=buf.getcurrentoffset() 4521 try: self.__field_header 4522 except: 4523 self.__field_header=sanyoheader(**{'packettype': 0x16, 'command': 0x9e}) 4524 self.__field_header.writetobuffer(buf) 4525 self.__field_slot.writetobuffer(buf) 4526 self._bufferendoffset=buf.getcurrentoffset() 4527 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 4528 4529 4530 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 4531 'Reads this packet from the supplied buffer' 4532 self._bufferstartoffset=buf.getcurrentoffset() 4533 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 4534 self.__field_header=sanyoheader(**{'packettype': 0x16, 'command': 0x9e}) 4535 self.__field_header.readfrombuffer(buf) 4536 self.__field_slot=UINT(**{'sizeinbytes': 2}) 4537 self.__field_slot.readfrombuffer(buf) 4538 self._bufferendoffset=buf.getcurrentoffset() 4539 4540 4541 def __getfield_header(self): 4542 try: self.__field_header 4543 except: 4544 self.__field_header=sanyoheader(**{'packettype': 0x16, 'command': 0x9e}) 4545 return self.__field_header.getvalue() 4546 4547 def __setfield_header(self, value): 4548 if isinstance(value,sanyoheader): 4549 self.__field_header=value 4550 else: 4551 self.__field_header=sanyoheader(value,**{'packettype': 0x16, 'command': 0x9e}) 4552 4553 def __delfield_header(self): del self.__field_header 4554 4555 header=property(__getfield_header, __setfield_header, __delfield_header, None) 4556 4557 def __getfield_slot(self): 4558 return self.__field_slot.getvalue() 4559 4560 def __setfield_slot(self, value): 4561 if isinstance(value,UINT): 4562 self.__field_slot=value 4563 else: 4564 self.__field_slot=UINT(value,**{'sizeinbytes': 2}) 4565 4566 def __delfield_slot(self): del self.__field_slot 4567 4568 slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None) 4569 4570 def iscontainer(self): 4571 return True 4572 4573 def containerelements(self): 4574 yield ('header', self.__field_header, None) 4575 yield ('slot', self.__field_slot, None) 4576 4577 4578 4579 4580 class memoentry(BaseProtogenClass): 4581 __fields=['contactp', 'memo_len', 'memo'] 4582 4583 def __init__(self, *args, **kwargs): 4584 dict={} 4585 # What was supplied to this function 4586 dict.update(kwargs) 4587 # Parent constructor 4588 super(memoentry,self).__init__(**dict) 4589 if self.__class__ is memoentry: 4590 self._update(args,dict) 4591 4592 4593 def getfields(self): 4594 return self.__fields 4595 4596 4597 def _update(self, args, kwargs): 4598 super(memoentry,self)._update(args,kwargs) 4599 keys=kwargs.keys() 4600 for key in keys: 4601 if key in self.__fields: 4602 setattr(self, key, kwargs[key]) 4603 del kwargs[key] 4604 # Were any unrecognized kwargs passed in? 4605 if __debug__: 4606 self._complainaboutunusedargs(memoentry,kwargs) 4607 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 4608 # Make all P fields that haven't already been constructed 4609 4610 4611 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 4612 'Writes this packet to the supplied buffer' 4613 self._bufferstartoffset=buf.getcurrentoffset() 4614 self.__field_contactp.writetobuffer(buf) 4615 self.__field_memo_len.writetobuffer(buf) 4616 try: self.__field_memo 4617 except: 4618 self.__field_memo=USTRING(**{'sizeinbytes': 256, 'default': "", 'raiseonunterminatedread': False, 'raiseontruncate': False, 'terminator': None}) 4619 self.__field_memo.writetobuffer(buf) 4620 self._bufferendoffset=buf.getcurrentoffset() 4621 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 4622 4623 4624 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 4625 'Reads this packet from the supplied buffer' 4626 self._bufferstartoffset=buf.getcurrentoffset() 4627 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 4628 self.__field_contactp=UINT(**{'sizeinbytes': 2}) 4629 self.__field_contactp.readfrombuffer(buf) 4630 self.__field_memo_len=UINT(**{'sizeinbytes': 2}) 4631 self.__field_memo_len.readfrombuffer(buf) 4632 self.__field_memo=USTRING(**{'sizeinbytes': 256, 'default': "", 'raiseonunterminatedread': False, 'raiseontruncate': False, 'terminator': None}) 4633 self.__field_memo.readfrombuffer(buf) 4634 self._bufferendoffset=buf.getcurrentoffset() 4635 4636 4637 def __getfield_contactp(self): 4638 return self.__field_contactp.getvalue() 4639 4640 def __setfield_contactp(self, value): 4641 if isinstance(value,UINT): 4642 self.__field_contactp=value 4643 else: 4644 self.__field_contactp=UINT(value,**{'sizeinbytes': 2}) 4645 4646 def __delfield_contactp(self): del self.__field_contactp 4647 4648 contactp=property(__getfield_contactp, __setfield_contactp, __delfield_contactp, "Pointer to contact number belongs") 4649 4650 def __getfield_memo_len(self): 4651 return self.__field_memo_len.getvalue() 4652 4653 def __setfield_memo_len(self, value): 4654 if isinstance(value,UINT): 4655 self.__field_memo_len=value 4656 else: 4657 self.__field_memo_len=UINT(value,**{'sizeinbytes': 2}) 4658 4659 def __delfield_memo_len(self): del self.__field_memo_len 4660 4661 memo_len=property(__getfield_memo_len, __setfield_memo_len, __delfield_memo_len, None) 4662 4663 def __getfield_memo(self): 4664 try: self.__field_memo 4665 except: 4666 self.__field_memo=USTRING(**{'sizeinbytes': 256, 'default': "", 'raiseonunterminatedread': False, 'raiseontruncate': False, 'terminator': None}) 4667 return self.__field_memo.getvalue() 4668 4669 def __setfield_memo(self, value): 4670 if isinstance(value,USTRING): 4671 self.__field_memo=value 4672 else: 4673 self.__field_memo=USTRING(value,**{'sizeinbytes': 256, 'default': "", 'raiseonunterminatedread': False, 'raiseontruncate': False, 'terminator': None}) 4674 4675 def __delfield_memo(self): del self.__field_memo 4676 4677 memo=property(__getfield_memo, __setfield_memo, __delfield_memo, None) 4678 4679 def iscontainer(self): 4680 return True 4681 4682 def containerelements(self): 4683 yield ('contactp', self.__field_contactp, "Pointer to contact number belongs") 4684 yield ('memo_len', self.__field_memo_len, None) 4685 yield ('memo', self.__field_memo, None) 4686 4687 4688 4689 4690 class memoresponse(BaseProtogenClass): 4691 __fields=['header', 'slot', 'entry', 'pad'] 4692 4693 def __init__(self, *args, **kwargs): 4694 dict={} 4695 # What was supplied to this function 4696 dict.update(kwargs) 4697 # Parent constructor 4698 super(memoresponse,self).__init__(**dict) 4699 if self.__class__ is memoresponse: 4700 self._update(args,dict) 4701 4702 4703 def getfields(self): 4704 return self.__fields 4705 4706 4707 def _update(self, args, kwargs): 4708 super(memoresponse,self)._update(args,kwargs) 4709 keys=kwargs.keys() 4710 for key in keys: 4711 if key in self.__fields: 4712 setattr(self, key, kwargs[key]) 4713 del kwargs[key] 4714 # Were any unrecognized kwargs passed in? 4715 if __debug__: 4716 self._complainaboutunusedargs(memoresponse,kwargs) 4717 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 4718 # Make all P fields that haven't already been constructed 4719 4720 4721 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 4722 'Writes this packet to the supplied buffer' 4723 self._bufferstartoffset=buf.getcurrentoffset() 4724 self.__field_header.writetobuffer(buf) 4725 self.__field_slot.writetobuffer(buf) 4726 self.__field_entry.writetobuffer(buf) 4727 self.__field_pad.writetobuffer(buf) 4728 self._bufferendoffset=buf.getcurrentoffset() 4729 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 4730 4731 4732 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 4733 'Reads this packet from the supplied buffer' 4734 self._bufferstartoffset=buf.getcurrentoffset() 4735 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 4736 self.__field_header=sanyoheader() 4737 self.__field_header.readfrombuffer(buf) 4738 self.__field_slot=UINT(**{'sizeinbytes': 2}) 4739 self.__field_slot.readfrombuffer(buf) 4740 self.__field_entry=memoentry() 4741 self.__field_entry.readfrombuffer(buf) 4742 self.__field_pad=UNKNOWN() 4743 self.__field_pad.readfrombuffer(buf) 4744 self._bufferendoffset=buf.getcurrentoffset() 4745 4746 4747 def __getfield_header(self): 4748 return self.__field_header.getvalue() 4749 4750 def __setfield_header(self, value): 4751 if isinstance(value,sanyoheader): 4752 self.__field_header=value 4753 else: 4754 self.__field_header=sanyoheader(value,) 4755 4756 def __delfield_header(self): del self.__field_header 4757 4758 header=property(__getfield_header, __setfield_header, __delfield_header, None) 4759 4760 def __getfield_slot(self): 4761 return self.__field_slot.getvalue() 4762 4763 def __setfield_slot(self, value): 4764 if isinstance(value,UINT): 4765 self.__field_slot=value 4766 else: 4767 self.__field_slot=UINT(value,**{'sizeinbytes': 2}) 4768 4769 def __delfield_slot(self): del self.__field_slot 4770 4771 slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None) 4772 4773 def __getfield_entry(self): 4774 return self.__field_entry.getvalue() 4775 4776 def __setfield_entry(self, value): 4777 if isinstance(value,memoentry): 4778 self.__field_entry=value 4779 else: 4780 self.__field_entry=memoentry(value,) 4781 4782 def __delfield_entry(self): del self.__field_entry 4783 4784 entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None) 4785 4786 def __getfield_pad(self): 4787 return self.__field_pad.getvalue() 4788 4789 def __setfield_pad(self, value): 4790 if isinstance(value,UNKNOWN): 4791 self.__field_pad=value 4792 else: 4793 self.__field_pad=UNKNOWN(value,) 4794 4795 def __delfield_pad(self): del self.__field_pad 4796 4797 pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None) 4798 4799 def iscontainer(self): 4800 return True 4801 4802 def containerelements(self): 4803 yield ('header', self.__field_header, None) 4804 yield ('slot', self.__field_slot, None) 4805 yield ('entry', self.__field_entry, None) 4806 yield ('pad', self.__field_pad, None) 4807 4808 4809 4810 4811 class memoupdaterequest(BaseProtogenClass): 4812 __fields=['header', 'slot', 'entry'] 4813 4814 def __init__(self, *args, **kwargs): 4815 dict={} 4816 # What was supplied to this function 4817 dict.update(kwargs) 4818 # Parent constructor 4819 super(memoupdaterequest,self).__init__(**dict) 4820 if self.__class__ is memoupdaterequest: 4821 self._update(args,dict) 4822 4823 4824 def getfields(self): 4825 return self.__fields 4826 4827 4828 def _update(self, args, kwargs): 4829 super(memoupdaterequest,self)._update(args,kwargs) 4830 keys=kwargs.keys() 4831 for key in keys: 4832 if key in self.__fields: 4833 setattr(self, key, kwargs[key]) 4834 del kwargs[key] 4835 # Were any unrecognized kwargs passed in? 4836 if __debug__: 4837 self._complainaboutunusedargs(memoupdaterequest,kwargs) 4838 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 4839 # Make all P fields that haven't already been constructed 4840 4841 4842 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 4843 'Writes this packet to the supplied buffer' 4844 self._bufferstartoffset=buf.getcurrentoffset() 4845 try: self.__field_header 4846 except: 4847 self.__field_header=sanyowriteheader(**{'packettype': 0x16, 'command': 0x9e}) 4848 self.__field_header.writetobuffer(buf) 4849 self.__field_slot.writetobuffer(buf) 4850 try: self.__field_entry 4851 except: 4852 self.__field_entry=memoentry() 4853 self.__field_entry.writetobuffer(buf) 4854 self._bufferendoffset=buf.getcurrentoffset() 4855 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 4856 4857 4858 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 4859 'Reads this packet from the supplied buffer' 4860 self._bufferstartoffset=buf.getcurrentoffset() 4861 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 4862 self.__field_header=sanyowriteheader(**{'packettype': 0x16, 'command': 0x9e}) 4863 self.__field_header.readfrombuffer(buf) 4864 self.__field_slot=UINT(**{'sizeinbytes': 2}) 4865 self.__field_slot.readfrombuffer(buf) 4866 self.__field_entry=memoentry() 4867 self.__field_entry.readfrombuffer(buf) 4868 self._bufferendoffset=buf.getcurrentoffset() 4869 4870 4871 def __getfield_header(self): 4872 try: self.__field_header 4873 except: 4874 self.__field_header=sanyowriteheader(**{'packettype': 0x16, 'command': 0x9e}) 4875 return self.__field_header.getvalue() 4876 4877 def __setfield_header(self, value): 4878 if isinstance(value,sanyowriteheader): 4879 self.__field_header=value 4880 else: 4881 self.__field_header=sanyowriteheader(value,**{'packettype': 0x16, 'command': 0x9e}) 4882 4883 def __delfield_header(self): del self.__field_header 4884 4885 header=property(__getfield_header, __setfield_header, __delfield_header, None) 4886 4887 def __getfield_slot(self): 4888 return self.__field_slot.getvalue() 4889 4890 def __setfield_slot(self, value): 4891 if isinstance(value,UINT): 4892 self.__field_slot=value 4893 else: 4894 self.__field_slot=UINT(value,**{'sizeinbytes': 2}) 4895 4896 def __delfield_slot(self): del self.__field_slot 4897 4898 slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None) 4899 4900 def __getfield_entry(self): 4901 try: self.__field_entry 4902 except: 4903 self.__field_entry=memoentry() 4904 return self.__field_entry.getvalue() 4905 4906 def __setfield_entry(self, value): 4907 if isinstance(value,memoentry): 4908 self.__field_entry=value 4909 else: 4910 self.__field_entry=memoentry(value,) 4911 4912 def __delfield_entry(self): del self.__field_entry 4913 4914 entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None) 4915 4916 def iscontainer(self): 4917 return True 4918 4919 def containerelements(self): 4920 yield ('header', self.__field_header, None) 4921 yield ('slot', self.__field_slot, None) 4922 yield ('entry', self.__field_entry, None) 4923 4924 4925 4926 4927 class emailrequest(BaseProtogenClass): 4928 __fields=['header', 'slot'] 4929 4930 def __init__(self, *args, **kwargs): 4931 dict={} 4932 # What was supplied to this function 4933 dict.update(kwargs) 4934 # Parent constructor 4935 super(emailrequest,self).__init__(**dict) 4936 if self.__class__ is emailrequest: 4937 self._update(args,dict) 4938 4939 4940 def getfields(self): 4941 return self.__fields 4942 4943 4944 def _update(self, args, kwargs): 4945 super(emailrequest,self)._update(args,kwargs) 4946 keys=kwargs.keys() 4947 for key in keys: 4948 if key in self.__fields: 4949 setattr(self, key, kwargs[key]) 4950 del kwargs[key] 4951 # Were any unrecognized kwargs passed in? 4952 if __debug__: 4953 self._complainaboutunusedargs(emailrequest,kwargs) 4954 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 4955 # Make all P fields that haven't already been constructed 4956 4957 4958 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 4959 'Writes this packet to the supplied buffer' 4960 self._bufferstartoffset=buf.getcurrentoffset() 4961 try: self.__field_header 4962 except: 4963 self.__field_header=sanyoheader(**{'packettype': 0x16, 'command': 0x93}) 4964 self.__field_header.writetobuffer(buf) 4965 self.__field_slot.writetobuffer(buf) 4966 self._bufferendoffset=buf.getcurrentoffset() 4967 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 4968 4969 4970 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 4971 'Reads this packet from the supplied buffer' 4972 self._bufferstartoffset=buf.getcurrentoffset() 4973 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 4974 self.__field_header=sanyoheader(**{'packettype': 0x16, 'command': 0x93}) 4975 self.__field_header.readfrombuffer(buf) 4976 self.__field_slot=UINT(**{'sizeinbytes': 2}) 4977 self.__field_slot.readfrombuffer(buf) 4978 self._bufferendoffset=buf.getcurrentoffset() 4979 4980 4981 def __getfield_header(self): 4982 try: self.__field_header 4983 except: 4984 self.__field_header=sanyoheader(**{'packettype': 0x16, 'command': 0x93}) 4985 return self.__field_header.getvalue() 4986 4987 def __setfield_header(self, value): 4988 if isinstance(value,sanyoheader): 4989 self.__field_header=value 4990 else: 4991 self.__field_header=sanyoheader(value,**{'packettype': 0x16, 'command': 0x93}) 4992 4993 def __delfield_header(self): del self.__field_header 4994 4995 header=property(__getfield_header, __setfield_header, __delfield_header, None) 4996 4997 def __getfield_slot(self): 4998 return self.__field_slot.getvalue() 4999 5000 def __setfield_slot(self, value): 5001 if isinstance(value,UINT): 5002 self.__field_slot=value 5003 else: 5004 self.__field_slot=UINT(value,**{'sizeinbytes': 2}) 5005 5006 def __delfield_slot(self): del self.__field_slot 5007 5008 slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None) 5009 5010 def iscontainer(self): 5011 return True 5012 5013 def containerelements(self): 5014 yield ('header', self.__field_header, None) 5015 yield ('slot', self.__field_slot, None) 5016 5017 5018 5019 5020 class emailentry(BaseProtogenClass): 5021 __fields=['contactp', 'email_len', 'email', 'pad', 'type'] 5022 5023 def __init__(self, *args, **kwargs): 5024 dict={} 5025 # What was supplied to this function 5026 dict.update(kwargs) 5027 # Parent constructor 5028 super(emailentry,self).__init__(**dict) 5029 if self.__class__ is emailentry: 5030 self._update(args,dict) 5031 5032 5033 def getfields(self): 5034 return self.__fields 5035 5036 5037 def _update(self, args, kwargs): 5038 super(emailentry,self)._update(args,kwargs) 5039 keys=kwargs.keys() 5040 for key in keys: 5041 if key in self.__fields: 5042 setattr(self, key, kwargs[key]) 5043 del kwargs[key] 5044 # Were any unrecognized kwargs passed in? 5045 if __debug__: 5046 self._complainaboutunusedargs(emailentry,kwargs) 5047 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 5048 # Make all P fields that haven't already been constructed 5049 5050 5051 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 5052 'Writes this packet to the supplied buffer' 5053 self._bufferstartoffset=buf.getcurrentoffset() 5054 self.__field_contactp.writetobuffer(buf) 5055 self.__field_email_len.writetobuffer(buf) 5056 try: self.__field_email 5057 except: 5058 self.__field_email=USTRING(**{'sizeinbytes': 96, 'default': "", 'raiseonunterminatedread': False, 'raiseontruncate': False, 'terminator': None}) 5059 self.__field_email.writetobuffer(buf) 5060 try: self.__field_pad 5061 except: 5062 self.__field_pad=UNKNOWN(**{'sizeinbytes': 1}) 5063 self.__field_pad.writetobuffer(buf) 5064 try: self.__field_type 5065 except: 5066 self.__field_type=UINT(**{'sizeinbytes': 1, 'default': 8}) 5067 self.__field_type.writetobuffer(buf) 5068 self._bufferendoffset=buf.getcurrentoffset() 5069 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 5070 5071 5072 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 5073 'Reads this packet from the supplied buffer' 5074 self._bufferstartoffset=buf.getcurrentoffset() 5075 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 5076 self.__field_contactp=UINT(**{'sizeinbytes': 2}) 5077 self.__field_contactp.readfrombuffer(buf) 5078 self.__field_email_len=UINT(**{'sizeinbytes': 1}) 5079 self.__field_email_len.readfrombuffer(buf) 5080 self.__field_email=USTRING(**{'sizeinbytes': 96, 'default': "", 'raiseonunterminatedread': False, 'raiseontruncate': False, 'terminator': None}) 5081 self.__field_email.readfrombuffer(buf) 5082 self.__field_pad=UNKNOWN(**{'sizeinbytes': 1}) 5083 self.__field_pad.readfrombuffer(buf) 5084 self.__field_type=UINT(**{'sizeinbytes': 1, 'default': 8}) 5085 self.__field_type.readfrombuffer(buf) 5086 self._bufferendoffset=buf.getcurrentoffset() 5087 5088 5089 def __getfield_contactp(self): 5090 return self.__field_contactp.getvalue() 5091 5092 def __setfield_contactp(self, value): 5093 if isinstance(value,UINT): 5094 self.__field_contactp=value 5095 else: 5096 self.__field_contactp=UINT(value,**{'sizeinbytes': 2}) 5097 5098 def __delfield_contactp(self): del self.__field_contactp 5099 5100 contactp=property(__getfield_contactp, __setfield_contactp, __delfield_contactp, "Pointer to contact number belongs") 5101 5102 def __getfield_email_len(self): 5103 return self.__field_email_len.getvalue() 5104 5105 def __setfield_email_len(self, value): 5106 if isinstance(value,UINT): 5107 self.__field_email_len=value 5108 else: 5109 self.__field_email_len=UINT(value,**{'sizeinbytes': 1}) 5110 5111 def __delfield_email_len(self): del self.__field_email_len 5112 5113 email_len=property(__getfield_email_len, __setfield_email_len, __delfield_email_len, None) 5114 5115 def __getfield_email(self): 5116 try: self.__field_email 5117 except: 5118 self.__field_email=USTRING(**{'sizeinbytes': 96, 'default': "", 'raiseonunterminatedread': False, 'raiseontruncate': False, 'terminator': None}) 5119 return self.__field_email.getvalue() 5120 5121 def __setfield_email(self, value): 5122 if isinstance(value,USTRING): 5123 self.__field_email=value 5124 else: 5125 self.__field_email=USTRING(value,**{'sizeinbytes': 96, 'default': "", 'raiseonunterminatedread': False, 'raiseontruncate': False, 'terminator': None}) 5126 5127 def __delfield_email(self): del self.__field_email 5128 5129 email=property(__getfield_email, __setfield_email, __delfield_email, None) 5130 5131 def __getfield_pad(self): 5132 try: self.__field_pad 5133 except: 5134 self.__field_pad=UNKNOWN(**{'sizeinbytes': 1}) 5135 return self.__field_pad.getvalue() 5136 5137 def __setfield_pad(self, value): 5138 if isinstance(value,UNKNOWN): 5139 self.__field_pad=value 5140 else: 5141 self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 1}) 5142 5143 def __delfield_pad(self): del self.__field_pad 5144 5145 pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None) 5146 5147 def __getfield_type(self): 5148 try: self.__field_type 5149 except: 5150 self.__field_type=UINT(**{'sizeinbytes': 1, 'default': 8}) 5151 return self.__field_type.getvalue() 5152 5153 def __setfield_type(self, value): 5154 if isinstance(value,UINT): 5155 self.__field_type=value 5156 else: 5157 self.__field_type=UINT(value,**{'sizeinbytes': 1, 'default': 8}) 5158 5159 def __delfield_type(self): del self.__field_type 5160 5161 type=property(__getfield_type, __setfield_type, __delfield_type, "7: Mobile, 8: Internet") 5162 5163 def iscontainer(self): 5164 return True 5165 5166 def containerelements(self): 5167 yield ('contactp', self.__field_contactp, "Pointer to contact number belongs") 5168 yield ('email_len', self.__field_email_len, None) 5169 yield ('email', self.__field_email, None) 5170 yield ('pad', self.__field_pad, None) 5171 yield ('type', self.__field_type, "7: Mobile, 8: Internet") 5172 5173 5174 5175 5176 class emailresponse(BaseProtogenClass): 5177 __fields=['header', 'slot', 'entry'] 5178 5179 def __init__(self, *args, **kwargs): 5180 dict={} 5181 # What was supplied to this function 5182 dict.update(kwargs) 5183 # Parent constructor 5184 super(emailresponse,self).__init__(**dict) 5185 if self.__class__ is emailresponse: 5186 self._update(args,dict) 5187 5188 5189 def getfields(self): 5190 return self.__fields 5191 5192 5193 def _update(self, args, kwargs): 5194 super(emailresponse,self)._update(args,kwargs) 5195 keys=kwargs.keys() 5196 for key in keys: 5197 if key in self.__fields: 5198 setattr(self, key, kwargs[key]) 5199 del kwargs[key] 5200 # Were any unrecognized kwargs passed in? 5201 if __debug__: 5202 self._complainaboutunusedargs(emailresponse,kwargs) 5203 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 5204 # Make all P fields that haven't already been constructed 5205 5206 5207 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 5208 'Writes this packet to the supplied buffer' 5209 self._bufferstartoffset=buf.getcurrentoffset() 5210 self.__field_header.writetobuffer(buf) 5211 self.__field_slot.writetobuffer(buf) 5212 self.__field_entry.writetobuffer(buf) 5213 self._bufferendoffset=buf.getcurrentoffset() 5214 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 5215 5216 5217 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 5218 'Reads this packet from the supplied buffer' 5219 self._bufferstartoffset=buf.getcurrentoffset() 5220 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 5221 self.__field_header=sanyoheader() 5222 self.__field_header.readfrombuffer(buf) 5223 self.__field_slot=UINT(**{'sizeinbytes': 2}) 5224 self.__field_slot.readfrombuffer(buf) 5225 self.__field_entry=emailentry() 5226 self.__field_entry.readfrombuffer(buf) 5227 self._bufferendoffset=buf.getcurrentoffset() 5228 5229 5230 def __getfield_header(self): 5231 return self.__field_header.getvalue() 5232 5233 def __setfield_header(self, value): 5234 if isinstance(value,sanyoheader): 5235 self.__field_header=value 5236 else: 5237 self.__field_header=sanyoheader(value,) 5238 5239 def __delfield_header(self): del self.__field_header 5240 5241 header=property(__getfield_header, __setfield_header, __delfield_header, None) 5242 5243 def __getfield_slot(self): 5244 return self.__field_slot.getvalue() 5245 5246 def __setfield_slot(self, value): 5247 if isinstance(value,UINT): 5248 self.__field_slot=value 5249 else: 5250 self.__field_slot=UINT(value,**{'sizeinbytes': 2}) 5251 5252 def __delfield_slot(self): del self.__field_slot 5253 5254 slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None) 5255 5256 def __getfield_entry(self): 5257 return self.__field_entry.getvalue() 5258 5259 def __setfield_entry(self, value): 5260 if isinstance(value,emailentry): 5261 self.__field_entry=value 5262 else: 5263 self.__field_entry=emailentry(value,) 5264 5265 def __delfield_entry(self): del self.__field_entry 5266 5267 entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None) 5268 5269 def iscontainer(self): 5270 return True 5271 5272 def containerelements(self): 5273 yield ('header', self.__field_header, None) 5274 yield ('slot', self.__field_slot, None) 5275 yield ('entry', self.__field_entry, None) 5276 5277 5278 5279 5280 class emailupdaterequest(BaseProtogenClass): 5281 __fields=['header', 'slot', 'entry'] 5282 5283 def __init__(self, *args, **kwargs): 5284 dict={} 5285 # What was supplied to this function 5286 dict.update(kwargs) 5287 # Parent constructor 5288 super(emailupdaterequest,self).__init__(**dict) 5289 if self.__class__ is emailupdaterequest: 5290 self._update(args,dict) 5291 5292 5293 def getfields(self): 5294 return self.__fields 5295 5296 5297 def _update(self, args, kwargs): 5298 super(emailupdaterequest,self)._update(args,kwargs) 5299 keys=kwargs.keys() 5300 for key in keys: 5301 if key in self.__fields: 5302 setattr(self, key, kwargs[key]) 5303 del kwargs[key] 5304 # Were any unrecognized kwargs passed in? 5305 if __debug__: 5306 self._complainaboutunusedargs(emailupdaterequest,kwargs) 5307 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 5308 # Make all P fields that haven't already been constructed 5309 5310 5311 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 5312 'Writes this packet to the supplied buffer' 5313 self._bufferstartoffset=buf.getcurrentoffset() 5314 try: self.__field_header 5315 except: 5316 self.__field_header=sanyowriteheader(**{'packettype': 0x16, 'command': 0x93}) 5317 self.__field_header.writetobuffer(buf) 5318 self.__field_slot.writetobuffer(buf) 5319 try: self.__field_entry 5320 except: 5321 self.__field_entry=emailentry() 5322 self.__field_entry.writetobuffer(buf) 5323 self._bufferendoffset=buf.getcurrentoffset() 5324 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 5325 5326 5327 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 5328 'Reads this packet from the supplied buffer' 5329 self._bufferstartoffset=buf.getcurrentoffset() 5330 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 5331 self.__field_header=sanyowriteheader(**{'packettype': 0x16, 'command': 0x93}) 5332 self.__field_header.readfrombuffer(buf) 5333 self.__field_slot=UINT(**{'sizeinbytes': 2}) 5334 self.__field_slot.readfrombuffer(buf) 5335 self.__field_entry=emailentry() 5336 self.__field_entry.readfrombuffer(buf) 5337 self._bufferendoffset=buf.getcurrentoffset() 5338 5339 5340 def __getfield_header(self): 5341 try: self.__field_header 5342 except: 5343 self.__field_header=sanyowriteheader(**{'packettype': 0x16, 'command': 0x93}) 5344 return self.__field_header.getvalue() 5345 5346 def __setfield_header(self, value): 5347 if isinstance(value,sanyowriteheader): 5348 self.__field_header=value 5349 else: 5350 self.__field_header=sanyowriteheader(value,**{'packettype': 0x16, 'command': 0x93}) 5351 5352 def __delfield_header(self): del self.__field_header 5353 5354 header=property(__getfield_header, __setfield_header, __delfield_header, None) 5355 5356 def __getfield_slot(self): 5357 return self.__field_slot.getvalue() 5358 5359 def __setfield_slot(self, value): 5360 if isinstance(value,UINT): 5361 self.__field_slot=value 5362 else: 5363 self.__field_slot=UINT(value,**{'sizeinbytes': 2}) 5364 5365 def __delfield_slot(self): del self.__field_slot 5366 5367 slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None) 5368 5369 def __getfield_entry(self): 5370 try: self.__field_entry 5371 except: 5372 self.__field_entry=emailentry() 5373 return self.__field_entry.getvalue() 5374 5375 def __setfield_entry(self, value): 5376 if isinstance(value,emailentry): 5377 self.__field_entry=value 5378 else: 5379 self.__field_entry=emailentry(value,) 5380 5381 def __delfield_entry(self): del self.__field_entry 5382 5383 entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None) 5384 5385 def iscontainer(self): 5386 return True 5387 5388 def containerelements(self): 5389 yield ('header', self.__field_header, None) 5390 yield ('slot', self.__field_slot, None) 5391 yield ('entry', self.__field_entry, None) 5392 5393 5394 5395 5396 class grouprequest(BaseProtogenClass): 5397 __fields=['header', 'slot'] 5398 5399 def __init__(self, *args, **kwargs): 5400 dict={} 5401 # What was supplied to this function 5402 dict.update(kwargs) 5403 # Parent constructor 5404 super(grouprequest,self).__init__(**dict) 5405 if self.__class__ is grouprequest: 5406 self._update(args,dict) 5407 5408 5409 def getfields(self): 5410 return self.__fields 5411 5412 5413 def _update(self, args, kwargs): 5414 super(grouprequest,self)._update(args,kwargs) 5415 keys=kwargs.keys() 5416 for key in keys: 5417 if key in self.__fields: 5418 setattr(self, key, kwargs[key]) 5419 del kwargs[key] 5420 # Were any unrecognized kwargs passed in? 5421 if __debug__: 5422 self._complainaboutunusedargs(grouprequest,kwargs) 5423 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 5424 # Make all P fields that haven't already been constructed 5425 5426 5427 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 5428 'Writes this packet to the supplied buffer' 5429 self._bufferstartoffset=buf.getcurrentoffset() 5430 try: self.__field_header 5431 except: 5432 self.__field_header=sanyoheader(**{'packettype': 0x16, 'command': 0x87}) 5433 self.__field_header.writetobuffer(buf) 5434 self.__field_slot.writetobuffer(buf) 5435 self._bufferendoffset=buf.getcurrentoffset() 5436 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 5437 5438 5439 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 5440 'Reads this packet from the supplied buffer' 5441 self._bufferstartoffset=buf.getcurrentoffset() 5442 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 5443 self.__field_header=sanyoheader(**{'packettype': 0x16, 'command': 0x87}) 5444 self.__field_header.readfrombuffer(buf) 5445 self.__field_slot=UINT(**{'sizeinbytes': 1}) 5446 self.__field_slot.readfrombuffer(buf) 5447 self._bufferendoffset=buf.getcurrentoffset() 5448 5449 5450 def __getfield_header(self): 5451 try: self.__field_header 5452 except: 5453 self.__field_header=sanyoheader(**{'packettype': 0x16, 'command': 0x87}) 5454 return self.__field_header.getvalue() 5455 5456 def __setfield_header(self, value): 5457 if isinstance(value,sanyoheader): 5458 self.__field_header=value 5459 else: 5460 self.__field_header=sanyoheader(value,**{'packettype': 0x16, 'command': 0x87}) 5461 5462 def __delfield_header(self): del self.__field_header 5463 5464 header=property(__getfield_header, __setfield_header, __delfield_header, None) 5465 5466 def __getfield_slot(self): 5467 return self.__field_slot.getvalue() 5468 5469 def __setfield_slot(self, value): 5470 if isinstance(value,UINT): 5471 self.__field_slot=value 5472 else: 5473 self.__field_slot=UINT(value,**{'sizeinbytes': 1}) 5474 5475 def __delfield_slot(self): del self.__field_slot 5476 5477 slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None) 5478 5479 def iscontainer(self): 5480 return True 5481 5482 def containerelements(self): 5483 yield ('header', self.__field_header, None) 5484 yield ('slot', self.__field_slot, None) 5485 5486 5487 5488 5489 class groupentry(BaseProtogenClass): 5490 __fields=['slot', 'groupname_len', 'groupname', 'ringer', 'picture'] 5491 5492 def __init__(self, *args, **kwargs): 5493 dict={} 5494 # What was supplied to this function 5495 dict.update(kwargs) 5496 # Parent constructor 5497 super(groupentry,self).__init__(**dict) 5498 if self.__class__ is groupentry: 5499 self._update(args,dict) 5500 5501 5502 def getfields(self): 5503 return self.__fields 5504 5505 5506 def _update(self, args, kwargs): 5507 super(groupentry,self)._update(args,kwargs) 5508 keys=kwargs.keys() 5509 for key in keys: 5510 if key in self.__fields: 5511 setattr(self, key, kwargs[key]) 5512 del kwargs[key] 5513 # Were any unrecognized kwargs passed in? 5514 if __debug__: 5515 self._complainaboutunusedargs(groupentry,kwargs) 5516 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 5517 # Make all P fields that haven't already been constructed 5518 5519 5520 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 5521 'Writes this packet to the supplied buffer' 5522 self._bufferstartoffset=buf.getcurrentoffset() 5523 self.__field_slot.writetobuffer(buf) 5524 self.__field_groupname_len.writetobuffer(buf) 5525 try: self.__field_groupname 5526 except: 5527 self.__field_groupname=USTRING(**{'sizeinbytes': 16, 'default': ""}) 5528 self.__field_groupname.writetobuffer(buf) 5529 try: self.__field_ringer 5530 except: 5531 self.__field_ringer=UINT(**{'sizeinbytes': 2, 'default': 0xfff0}) 5532 self.__field_ringer.writetobuffer(buf) 5533 try: self.__field_picture 5534 except: 5535 self.__field_picture=UINT(**{'sizeinbytes': 2, 'default': 0xfffe}) 5536 self.__field_picture.writetobuffer(buf) 5537 self._bufferendoffset=buf.getcurrentoffset() 5538 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 5539 5540 5541 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 5542 'Reads this packet from the supplied buffer' 5543 self._bufferstartoffset=buf.getcurrentoffset() 5544 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 5545 self.__field_slot=UINT(**{'sizeinbytes': 1}) 5546 self.__field_slot.readfrombuffer(buf) 5547 self.__field_groupname_len=UINT(**{'sizeinbytes': 1}) 5548 self.__field_groupname_len.readfrombuffer(buf) 5549 self.__field_groupname=USTRING(**{'sizeinbytes': 16, 'default': ""}) 5550 self.__field_groupname.readfrombuffer(buf) 5551 self.__field_ringer=UINT(**{'sizeinbytes': 2, 'default': 0xfff0}) 5552 self.__field_ringer.readfrombuffer(buf) 5553 self.__field_picture=UINT(**{'sizeinbytes': 2, 'default': 0xfffe}) 5554 self.__field_picture.readfrombuffer(buf) 5555 self._bufferendoffset=buf.getcurrentoffset() 5556 5557 5558 def __getfield_slot(self): 5559 return self.__field_slot.getvalue() 5560 5561 def __setfield_slot(self, value): 5562 if isinstance(value,UINT): 5563 self.__field_slot=value 5564 else: 5565 self.__field_slot=UINT(value,**{'sizeinbytes': 1}) 5566 5567 def __delfield_slot(self): del self.__field_slot 5568 5569 slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None) 5570 5571 def __getfield_groupname_len(self): 5572 return self.__field_groupname_len.getvalue() 5573 5574 def __setfield_groupname_len(self, value): 5575 if isinstance(value,UINT): 5576 self.__field_groupname_len=value 5577 else: 5578 self.__field_groupname_len=UINT(value,**{'sizeinbytes': 1}) 5579 5580 def __delfield_groupname_len(self): del self.__field_groupname_len 5581 5582 groupname_len=property(__getfield_groupname_len, __setfield_groupname_len, __delfield_groupname_len, None) 5583 5584 def __getfield_groupname(self): 5585 try: self.__field_groupname 5586 except: 5587 self.__field_groupname=USTRING(**{'sizeinbytes': 16, 'default': ""}) 5588 return self.__field_groupname.getvalue() 5589 5590 def __setfield_groupname(self, value): 5591 if isinstance(value,USTRING): 5592 self.__field_groupname=value 5593 else: 5594 self.__field_groupname=USTRING(value,**{'sizeinbytes': 16, 'default': ""}) 5595 5596 def __delfield_groupname(self): del self.__field_groupname 5597 5598 groupname=property(__getfield_groupname, __setfield_groupname, __delfield_groupname, None) 5599 5600 def __getfield_ringer(self): 5601 try: self.__field_ringer 5602 except: 5603 self.__field_ringer=UINT(**{'sizeinbytes': 2, 'default': 0xfff0}) 5604 return self.__field_ringer.getvalue() 5605 5606 def __setfield_ringer(self, value): 5607 if isinstance(value,UINT): 5608 self.__field_ringer=value 5609 else: 5610 self.__field_ringer=UINT(value,**{'sizeinbytes': 2, 'default': 0xfff0}) 5611 5612 def __delfield_ringer(self): del self.__field_ringer 5613 5614 ringer=property(__getfield_ringer, __setfield_ringer, __delfield_ringer, None) 5615 5616 def __getfield_picture(self): 5617 try: self.__field_picture 5618 except: 5619 self.__field_picture=UINT(**{'sizeinbytes': 2, 'default': 0xfffe}) 5620 return self.__field_picture.getvalue() 5621 5622 def __setfield_picture(self, value): 5623 if isinstance(value,UINT): 5624 self.__field_picture=value 5625 else: 5626 self.__field_picture=UINT(value,**{'sizeinbytes': 2, 'default': 0xfffe}) 5627 5628 def __delfield_picture(self): del self.__field_picture 5629 5630 picture=property(__getfield_picture, __setfield_picture, __delfield_picture, None) 5631 5632 def iscontainer(self): 5633 return True 5634 5635 def containerelements(self): 5636 yield ('slot', self.__field_slot, None) 5637 yield ('groupname_len', self.__field_groupname_len, None) 5638 yield ('groupname', self.__field_groupname, None) 5639 yield ('ringer', self.__field_ringer, None) 5640 yield ('picture', self.__field_picture, None) 5641 5642 5643 5644 5645 class groupresponse(BaseProtogenClass): 5646 __fields=['header', 'slot', 'entry', 'pad'] 5647 5648 def __init__(self, *args, **kwargs): 5649 dict={} 5650 # What was supplied to this function 5651 dict.update(kwargs) 5652 # Parent constructor 5653 super(groupresponse,self).__init__(**dict) 5654 if self.__class__ is groupresponse: 5655 self._update(args,dict) 5656 5657 5658 def getfields(self): 5659 return self.__fields 5660 5661 5662 def _update(self, args, kwargs): 5663 super(groupresponse,self)._update(args,kwargs) 5664 keys=kwargs.keys() 5665 for key in keys: 5666 if key in self.__fields: 5667 setattr(self, key, kwargs[key]) 5668 del kwargs[key] 5669 # Were any unrecognized kwargs passed in? 5670 if __debug__: 5671 self._complainaboutunusedargs(groupresponse,kwargs) 5672 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 5673 # Make all P fields that haven't already been constructed 5674 5675 5676 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 5677 'Writes this packet to the supplied buffer' 5678 self._bufferstartoffset=buf.getcurrentoffset() 5679 self.__field_header.writetobuffer(buf) 5680 self.__field_slot.writetobuffer(buf) 5681 self.__field_entry.writetobuffer(buf) 5682 self.__field_pad.writetobuffer(buf) 5683 self._bufferendoffset=buf.getcurrentoffset() 5684 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 5685 5686 5687 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 5688 'Reads this packet from the supplied buffer' 5689 self._bufferstartoffset=buf.getcurrentoffset() 5690 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 5691 self.__field_header=sanyoheader() 5692 self.__field_header.readfrombuffer(buf) 5693 self.__field_slot=UINT(**{'sizeinbytes': 1}) 5694 self.__field_slot.readfrombuffer(buf) 5695 self.__field_entry=groupentry() 5696 self.__field_entry.readfrombuffer(buf) 5697 self.__field_pad=UNKNOWN() 5698 self.__field_pad.readfrombuffer(buf) 5699 self._bufferendoffset=buf.getcurrentoffset() 5700 5701 5702 def __getfield_header(self): 5703 return self.__field_header.getvalue() 5704 5705 def __setfield_header(self, value): 5706 if isinstance(value,sanyoheader): 5707 self.__field_header=value 5708 else: 5709 self.__field_header=sanyoheader(value,) 5710 5711 def __delfield_header(self): del self.__field_header 5712 5713 header=property(__getfield_header, __setfield_header, __delfield_header, None) 5714 5715 def __getfield_slot(self): 5716 return self.__field_slot.getvalue() 5717 5718 def __setfield_slot(self, value): 5719 if isinstance(value,UINT): 5720 self.__field_slot=value 5721 else: 5722 self.__field_slot=UINT(value,**{'sizeinbytes': 1}) 5723 5724 def __delfield_slot(self): del self.__field_slot 5725 5726 slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None) 5727 5728 def __getfield_entry(self): 5729 return self.__field_entry.getvalue() 5730 5731 def __setfield_entry(self, value): 5732 if isinstance(value,groupentry): 5733 self.__field_entry=value 5734 else: 5735 self.__field_entry=groupentry(value,) 5736 5737 def __delfield_entry(self): del self.__field_entry 5738 5739 entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None) 5740 5741 def __getfield_pad(self): 5742 return self.__field_pad.getvalue() 5743 5744 def __setfield_pad(self, value): 5745 if isinstance(value,UNKNOWN): 5746 self.__field_pad=value 5747 else: 5748 self.__field_pad=UNKNOWN(value,) 5749 5750 def __delfield_pad(self): del self.__field_pad 5751 5752 pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None) 5753 5754 def iscontainer(self): 5755 return True 5756 5757 def containerelements(self): 5758 yield ('header', self.__field_header, None) 5759 yield ('slot', self.__field_slot, None) 5760 yield ('entry', self.__field_entry, None) 5761 yield ('pad', self.__field_pad, None) 5762 5763 5764 5765 5766 class groupupdaterequest(BaseProtogenClass): 5767 __fields=['header', 'slot', 'entry', 'pad'] 5768 5769 def __init__(self, *args, **kwargs): 5770 dict={} 5771 # What was supplied to this function 5772 dict.update(kwargs) 5773 # Parent constructor 5774 super(groupupdaterequest,self).__init__(**dict) 5775 if self.__class__ is groupupdaterequest: 5776 self._update(args,dict) 5777 5778 5779 def getfields(self): 5780 return self.__fields 5781 5782 5783 def _update(self, args, kwargs): 5784 super(groupupdaterequest,self)._update(args,kwargs) 5785 keys=kwargs.keys() 5786 for key in keys: 5787 if key in self.__fields: 5788 setattr(self, key, kwargs[key]) 5789 del kwargs[key] 5790 # Were any unrecognized kwargs passed in? 5791 if __debug__: 5792 self._complainaboutunusedargs(groupupdaterequest,kwargs) 5793 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 5794 # Make all P fields that haven't already been constructed 5795 5796 5797 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 5798 'Writes this packet to the supplied buffer' 5799 self._bufferstartoffset=buf.getcurrentoffset() 5800 try: self.__field_header 5801 except: 5802 self.__field_header=sanyowriteheader(**{'packettype': 0x16, 'command': 0x87}) 5803 self.__field_header.writetobuffer(buf) 5804 self.__field_slot.writetobuffer(buf) 5805 self.__field_entry.writetobuffer(buf) 5806 self.__field_pad.writetobuffer(buf) 5807 self._bufferendoffset=buf.getcurrentoffset() 5808 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 5809 5810 5811 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 5812 'Reads this packet from the supplied buffer' 5813 self._bufferstartoffset=buf.getcurrentoffset() 5814 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 5815 self.__field_header=sanyowriteheader(**{'packettype': 0x16, 'command': 0x87}) 5816 self.__field_header.readfrombuffer(buf) 5817 self.__field_slot=UINT(**{'sizeinbytes': 1}) 5818 self.__field_slot.readfrombuffer(buf) 5819 self.__field_entry=groupentry() 5820 self.__field_entry.readfrombuffer(buf) 5821 self.__field_pad=UNKNOWN() 5822 self.__field_pad.readfrombuffer(buf) 5823 self._bufferendoffset=buf.getcurrentoffset() 5824 5825 5826 def __getfield_header(self): 5827 try: self.__field_header 5828 except: 5829 self.__field_header=sanyowriteheader(**{'packettype': 0x16, 'command': 0x87}) 5830 return self.__field_header.getvalue() 5831 5832 def __setfield_header(self, value): 5833 if isinstance(value,sanyowriteheader): 5834 self.__field_header=value 5835 else: 5836 self.__field_header=sanyowriteheader(value,**{'packettype': 0x16, 'command': 0x87}) 5837 5838 def __delfield_header(self): del self.__field_header 5839 5840 header=property(__getfield_header, __setfield_header, __delfield_header, None) 5841 5842 def __getfield_slot(self): 5843 return self.__field_slot.getvalue() 5844 5845 def __setfield_slot(self, value): 5846 if isinstance(value,UINT): 5847 self.__field_slot=value 5848 else: 5849 self.__field_slot=UINT(value,**{'sizeinbytes': 1}) 5850 5851 def __delfield_slot(self): del self.__field_slot 5852 5853 slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None) 5854 5855 def __getfield_entry(self): 5856 return self.__field_entry.getvalue() 5857 5858 def __setfield_entry(self, value): 5859 if isinstance(value,groupentry): 5860 self.__field_entry=value 5861 else: 5862 self.__field_entry=groupentry(value,) 5863 5864 def __delfield_entry(self): del self.__field_entry 5865 5866 entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None) 5867 5868 def __getfield_pad(self): 5869 return self.__field_pad.getvalue() 5870 5871 def __setfield_pad(self, value): 5872 if isinstance(value,UNKNOWN): 5873 self.__field_pad=value 5874 else: 5875 self.__field_pad=UNKNOWN(value,) 5876 5877 def __delfield_pad(self): del self.__field_pad 5878 5879 pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None) 5880 5881 def iscontainer(self): 5882 return True 5883 5884 def containerelements(self): 5885 yield ('header', self.__field_header, None) 5886 yield ('slot', self.__field_slot, None) 5887 yield ('entry', self.__field_entry, None) 5888 yield ('pad', self.__field_pad, None) 5889 5890 5891 5892 5893 class evententry(BaseProtogenClass): 5894 __fields=['alarm', 'slot', 'eventname', 'pad1', 'eventname_len', 'start', 'end', 'location', 'pad2', 'location_len', 'alarmdiff', 'period', 'dom', 'timestamp', 'pad3', 'serial', 'pad4', 'ringtone'] 5895 5896 def __init__(self, *args, **kwargs): 5897 dict={} 5898 # What was supplied to this function 5899 dict.update(kwargs) 5900 # Parent constructor 5901 super(evententry,self).__init__(**dict) 5902 if self.__class__ is evententry: 5903 self._update(args,dict) 5904 5905 5906 def getfields(self): 5907 return self.__fields 5908 5909 5910 def _update(self, args, kwargs): 5911 super(evententry,self)._update(args,kwargs) 5912 keys=kwargs.keys() 5913 for key in keys: 5914 if key in self.__fields: 5915 setattr(self, key, kwargs[key]) 5916 del kwargs[key] 5917 # Were any unrecognized kwargs passed in? 5918 if __debug__: 5919 self._complainaboutunusedargs(evententry,kwargs) 5920 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 5921 # Make all P fields that haven't already been constructed 5922 try: self.__field_alarm 5923 except: 5924 self.__field_alarm=UINT(**{'default': 0xffffffff}) 5925 5926 5927 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 5928 'Writes this packet to the supplied buffer' 5929 self._bufferstartoffset=buf.getcurrentoffset() 5930 self.__field_slot.writetobuffer(buf) 5931 self.__field_eventname.writetobuffer(buf) 5932 try: self.__field_pad1 5933 except: 5934 self.__field_pad1=UNKNOWN(**{'sizeinbytes': 7}) 5935 self.__field_pad1.writetobuffer(buf) 5936 self.__field_eventname_len.writetobuffer(buf) 5937 self.__field_start.writetobuffer(buf) 5938 self.__field_end.writetobuffer(buf) 5939 self.__field_location.writetobuffer(buf) 5940 try: self.__field_pad2 5941 except: 5942 self.__field_pad2=UNKNOWN(**{'sizeinbytes': 7}) 5943 self.__field_pad2.writetobuffer(buf) 5944 self.__field_location_len.writetobuffer(buf) 5945 self.__field_alarmdiff.writetobuffer(buf) 5946 self.__field_period.writetobuffer(buf) 5947 self.__field_dom.writetobuffer(buf) 5948 try: self.__field_timestamp 5949 except: 5950 self.__field_timestamp=UINT(**{'sizeinbytes': 4, 'default': 0}) 5951 self.__field_timestamp.writetobuffer(buf) 5952 try: self.__field_pad3 5953 except: 5954 self.__field_pad3=UNKNOWN(**{'sizeinbytes': 1}) 5955 self.__field_pad3.writetobuffer(buf) 5956 try: self.__field_serial 5957 except: 5958 self.__field_serial=UINT(**{'sizeinbytes': 1, 'default': 0}) 5959 self.__field_serial.writetobuffer(buf) 5960 try: self.__field_pad4 5961 except: 5962 self.__field_pad4=UNKNOWN(**{'sizeinbytes': 3}) 5963 self.__field_pad4.writetobuffer(buf) 5964 self.__field_ringtone.writetobuffer(buf) 5965 self._bufferendoffset=buf.getcurrentoffset() 5966 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 5967 5968 5969 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 5970 'Reads this packet from the supplied buffer' 5971 self._bufferstartoffset=buf.getcurrentoffset() 5972 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 5973 self.__field_slot=UINT(**{'sizeinbytes': 1}) 5974 self.__field_slot.readfrombuffer(buf) 5975 self.__field_eventname=USTRING(**{'sizeinbytes': 14, 'raiseonunterminatedread': False, 'raiseontruncate': False, 'terminator': None}) 5976 self.__field_eventname.readfrombuffer(buf) 5977 self.__field_pad1=UNKNOWN(**{'sizeinbytes': 7}) 5978 self.__field_pad1.readfrombuffer(buf) 5979 self.__field_eventname_len=UINT(**{'sizeinbytes': 1}) 5980 self.__field_eventname_len.readfrombuffer(buf) 5981 self.__field_start=UINT(**{'sizeinbytes': 4}) 5982 self.__field_start.readfrombuffer(buf) 5983 self.__field_end=UINT(**{'sizeinbytes': 4}) 5984 self.__field_end.readfrombuffer(buf) 5985 self.__field_location=USTRING(**{'sizeinbytes': 14, 'raiseonunterminatedread': False, 'raiseontruncate': False, 'terminator': None}) 5986 self.__field_location.readfrombuffer(buf) 5987 self.__field_pad2=UNKNOWN(**{'sizeinbytes': 7}) 5988 self.__field_pad2.readfrombuffer(buf) 5989 self.__field_location_len=UINT(**{'sizeinbytes': 1}) 5990 self.__field_location_len.readfrombuffer(buf) 5991 self.__field_alarmdiff=UINT(**{'sizeinbytes': 4}) 5992 self.__field_alarmdiff.readfrombuffer(buf) 5993 self.__field_period=UINT(**{'sizeinbytes': 1}) 5994 self.__field_period.readfrombuffer(buf) 5995 self.__field_dom=UINT(**{'sizeinbytes': 1}) 5996 self.__field_dom.readfrombuffer(buf) 5997 self.__field_timestamp=UINT(**{'sizeinbytes': 4, 'default': 0}) 5998 self.__field_timestamp.readfrombuffer(buf) 5999 self.__field_pad3=UNKNOWN(**{'sizeinbytes': 1}) 6000 self.__field_pad3.readfrombuffer(buf) 6001 self.__field_serial=UINT(**{'sizeinbytes': 1, 'default': 0}) 6002 self.__field_serial.readfrombuffer(buf) 6003 self.__field_pad4=UNKNOWN(**{'sizeinbytes': 3}) 6004 self.__field_pad4.readfrombuffer(buf) 6005 self.__field_ringtone=UINT(**{'sizeinbytes': 2}) 6006 self.__field_ringtone.readfrombuffer(buf) 6007 self._bufferendoffset=buf.getcurrentoffset() 6008 6009 6010 def __getfield_alarm(self): 6011 try: self.__field_alarm 6012 except: 6013 self.__field_alarm=UINT(**{'default': 0xffffffff}) 6014 return self.__field_alarm.getvalue() 6015 6016 def __setfield_alarm(self, value): 6017 if isinstance(value,UINT): 6018 self.__field_alarm=value 6019 else: 6020 self.__field_alarm=UINT(value,**{'default': 0xffffffff}) 6021 6022 def __delfield_alarm(self): del self.__field_alarm 6023 6024 alarm=property(__getfield_alarm, __setfield_alarm, __delfield_alarm, None) 6025 6026 def __getfield_slot(self): 6027 return self.__field_slot.getvalue() 6028 6029 def __setfield_slot(self, value): 6030 if isinstance(value,UINT): 6031 self.__field_slot=value 6032 else: 6033 self.__field_slot=UINT(value,**{'sizeinbytes': 1}) 6034 6035 def __delfield_slot(self): del self.__field_slot 6036 6037 slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None) 6038 6039 def __getfield_eventname(self): 6040 return self.__field_eventname.getvalue() 6041 6042 def __setfield_eventname(self, value): 6043 if isinstance(value,USTRING): 6044 self.__field_eventname=value 6045 else: 6046 self.__field_eventname=USTRING(value,**{'sizeinbytes': 14, 'raiseonunterminatedread': False, 'raiseontruncate': False, 'terminator': None}) 6047 6048 def __delfield_eventname(self): del self.__field_eventname 6049 6050 eventname=property(__getfield_eventname, __setfield_eventname, __delfield_eventname, None) 6051 6052 def __getfield_pad1(self): 6053 try: self.__field_pad1 6054 except: 6055 self.__field_pad1=UNKNOWN(**{'sizeinbytes': 7}) 6056 return self.__field_pad1.getvalue() 6057 6058 def __setfield_pad1(self, value): 6059 if isinstance(value,UNKNOWN): 6060 self.__field_pad1=value 6061 else: 6062 self.__field_pad1=UNKNOWN(value,**{'sizeinbytes': 7}) 6063 6064 def __delfield_pad1(self): del self.__field_pad1 6065 6066 pad1=property(__getfield_pad1, __setfield_pad1, __delfield_pad1, None) 6067 6068 def __getfield_eventname_len(self): 6069 return self.__field_eventname_len.getvalue() 6070 6071 def __setfield_eventname_len(self, value): 6072 if isinstance(value,UINT): 6073 self.__field_eventname_len=value 6074 else: 6075 self.__field_eventname_len=UINT(value,**{'sizeinbytes': 1}) 6076 6077 def __delfield_eventname_len(self): del self.__field_eventname_len 6078 6079 eventname_len=property(__getfield_eventname_len, __setfield_eventname_len, __delfield_eventname_len, None) 6080 6081 def __getfield_start(self): 6082 return self.__field_start.getvalue() 6083 6084 def __setfield_start(self, value): 6085 if isinstance(value,UINT): 6086 self.__field_start=value 6087 else: 6088 self.__field_start=UINT(value,**{'sizeinbytes': 4}) 6089 6090 def __delfield_start(self): del self.__field_start 6091 6092 start=property(__getfield_start, __setfield_start, __delfield_start, "# seconds since Jan 1, 1980 approximately") 6093 6094 def __getfield_end(self): 6095 return self.__field_end.getvalue() 6096 6097 def __setfield_end(self, value): 6098 if isinstance(value,UINT): 6099 self.__field_end=value 6100 else: 6101 self.__field_end=UINT(value,**{'sizeinbytes': 4}) 6102 6103 def __delfield_end(self): del self.__field_end 6104 6105 end=property(__getfield_end, __setfield_end, __delfield_end, None) 6106 6107 def __getfield_location(self): 6108 return self.__field_location.getvalue() 6109 6110 def __setfield_location(self, value): 6111 if isinstance(value,USTRING): 6112 self.__field_location=value 6113 else: 6114 self.__field_location=USTRING(value,**{'sizeinbytes': 14, 'raiseonunterminatedread': False, 'raiseontruncate': False, 'terminator': None}) 6115 6116 def __delfield_location(self): del self.__field_location 6117 6118 location=property(__getfield_location, __setfield_location, __delfield_location, None) 6119 6120 def __getfield_pad2(self): 6121 try: self.__field_pad2 6122 except: 6123 self.__field_pad2=UNKNOWN(**{'sizeinbytes': 7}) 6124 return self.__field_pad2.getvalue() 6125 6126 def __setfield_pad2(self, value): 6127 if isinstance(value,UNKNOWN): 6128 self.__field_pad2=value 6129 else: 6130 self.__field_pad2=UNKNOWN(value,**{'sizeinbytes': 7}) 6131 6132 def __delfield_pad2(self): del self.__field_pad2 6133 6134 pad2=property(__getfield_pad2, __setfield_pad2, __delfield_pad2, None) 6135 6136 def __getfield_location_len(self): 6137 return self.__field_location_len.getvalue() 6138 6139 def __setfield_location_len(self, value): 6140 if isinstance(value,UINT): 6141 self.__field_location_len=value 6142 else: 6143 self.__field_location_len=UINT(value,**{'sizeinbytes': 1}) 6144 6145 def __delfield_location_len(self): del self.__field_location_len 6146 6147 location_len=property(__getfield_location_len, __setfield_location_len, __delfield_location_len, None) 6148 6149 def __getfield_alarmdiff(self): 6150 return self.__field_alarmdiff.getvalue() 6151 6152 def __setfield_alarmdiff(self, value): 6153 if isinstance(value,UINT): 6154 self.__field_alarmdiff=value 6155 else: 6156 self.__field_alarmdiff=UINT(value,**{'sizeinbytes': 4}) 6157 6158 def __delfield_alarmdiff(self): del self.__field_alarmdiff 6159 6160 alarmdiff=property(__getfield_alarmdiff, __setfield_alarmdiff, __delfield_alarmdiff, "Displayed alarm time") 6161 6162 def __getfield_period(self): 6163 return self.__field_period.getvalue() 6164 6165 def __setfield_period(self, value): 6166 if isinstance(value,UINT): 6167 self.__field_period=value 6168 else: 6169 self.__field_period=UINT(value,**{'sizeinbytes': 1}) 6170 6171 def __delfield_period(self): del self.__field_period 6172 6173 period=property(__getfield_period, __setfield_period, __delfield_period, "No, Daily, Weekly, Monthly, Yearly") 6174 6175 def __getfield_dom(self): 6176 return self.__field_dom.getvalue() 6177 6178 def __setfield_dom(self, value): 6179 if isinstance(value,UINT): 6180 self.__field_dom=value 6181 else: 6182 self.__field_dom=UINT(value,**{'sizeinbytes': 1}) 6183 6184 def __delfield_dom(self): del self.__field_dom 6185 6186 dom=property(__getfield_dom, __setfield_dom, __delfield_dom, "Day of month for the event") 6187 6188 def __getfield_timestamp(self): 6189 try: self.__field_timestamp 6190 except: 6191 self.__field_timestamp=UINT(**{'sizeinbytes': 4, 'default': 0}) 6192 return self.__field_timestamp.getvalue() 6193 6194 def __setfield_timestamp(self, value): 6195 if isinstance(value,UINT): 6196 self.__field_timestamp=value 6197 else: 6198 self.__field_timestamp=UINT(value,**{'sizeinbytes': 4, 'default': 0}) 6199 6200 def __delfield_timestamp(self): del self.__field_timestamp 6201 6202 timestamp=property(__getfield_timestamp, __setfield_timestamp, __delfield_timestamp, None) 6203 6204 def __getfield_pad3(self): 6205 try: self.__field_pad3 6206 except: 6207 self.__field_pad3=UNKNOWN(**{'sizeinbytes': 1}) 6208 return self.__field_pad3.getvalue() 6209 6210 def __setfield_pad3(self, value): 6211 if isinstance(value,UNKNOWN): 6212 self.__field_pad3=value 6213 else: 6214 self.__field_pad3=UNKNOWN(value,**{'sizeinbytes': 1}) 6215 6216 def __delfield_pad3(self): del self.__field_pad3 6217 6218 pad3=property(__getfield_pad3, __setfield_pad3, __delfield_pad3, None) 6219 6220 def __getfield_serial(self): 6221 try: self.__field_serial 6222 except: 6223 self.__field_serial=UINT(**{'sizeinbytes': 1, 'default': 0}) 6224 return self.__field_serial.getvalue() 6225 6226 def __setfield_serial(self, value): 6227 if isinstance(value,UINT): 6228 self.__field_serial=value 6229 else: 6230 self.__field_serial=UINT(value,**{'sizeinbytes': 1, 'default': 0}) 6231 6232 def __delfield_serial(self): del self.__field_serial 6233 6234 serial=property(__getfield_serial, __setfield_serial, __delfield_serial, "Some kind of serial number") 6235 6236 def __getfield_pad4(self): 6237 try: self.__field_pad4 6238 except: 6239 self.__field_pad4=UNKNOWN(**{'sizeinbytes': 3}) 6240 return self.__field_pad4.getvalue() 6241 6242 def __setfield_pad4(self, value): 6243 if isinstance(value,UNKNOWN): 6244 self.__field_pad4=value 6245 else: 6246 self.__field_pad4=UNKNOWN(value,**{'sizeinbytes': 3}) 6247 6248 def __delfield_pad4(self): del self.__field_pad4 6249 6250 pad4=property(__getfield_pad4, __setfield_pad4, __delfield_pad4, None) 6251 6252 def __getfield_ringtone(self): 6253 return self.__field_ringtone.getvalue() 6254 6255 def __setfield_ringtone(self, value): 6256 if isinstance(value,UINT): 6257 self.__field_ringtone=value 6258 else: 6259 self.__field_ringtone=UINT(value,**{'sizeinbytes': 2}) 6260 6261 def __delfield_ringtone(self): del self.__field_ringtone 6262 6263 ringtone=property(__getfield_ringtone, __setfield_ringtone, __delfield_ringtone, None) 6264 6265 def iscontainer(self): 6266 return True 6267 6268 def containerelements(self): 6269 yield ('alarm', self.__field_alarm, None) 6270 yield ('slot', self.__field_slot, None) 6271 yield ('eventname', self.__field_eventname, None) 6272 yield ('pad1', self.__field_pad1, None) 6273 yield ('eventname_len', self.__field_eventname_len, None) 6274 yield ('start', self.__field_start, "# seconds since Jan 1, 1980 approximately") 6275 yield ('end', self.__field_end, None) 6276 yield ('location', self.__field_location, None) 6277 yield ('pad2', self.__field_pad2, None) 6278 yield ('location_len', self.__field_location_len, None) 6279 yield ('alarmdiff', self.__field_alarmdiff, "Displayed alarm time") 6280 yield ('period', self.__field_period, "No, Daily, Weekly, Monthly, Yearly") 6281 yield ('dom', self.__field_dom, "Day of month for the event") 6282 yield ('timestamp', self.__field_timestamp, None) 6283 yield ('pad3', self.__field_pad3, None) 6284 yield ('serial', self.__field_serial, "Some kind of serial number") 6285 yield ('pad4', self.__field_pad4, None) 6286 yield ('ringtone', self.__field_ringtone, None) 6287 6288 6289 6290 6291 class eventresponse(BaseProtogenClass): 6292 __fields=['header', 'entry', 'pad'] 6293 6294 def __init__(self, *args, **kwargs): 6295 dict={} 6296 # What was supplied to this function 6297 dict.update(kwargs) 6298 # Parent constructor 6299 super(eventresponse,self).__init__(**dict) 6300 if self.__class__ is eventresponse: 6301 self._update(args,dict) 6302 6303 6304 def getfields(self): 6305 return self.__fields 6306 6307 6308 def _update(self, args, kwargs): 6309 super(eventresponse,self)._update(args,kwargs) 6310 keys=kwargs.keys() 6311 for key in keys: 6312 if key in self.__fields: 6313 setattr(self, key, kwargs[key]) 6314 del kwargs[key] 6315 # Were any unrecognized kwargs passed in? 6316 if __debug__: 6317 self._complainaboutunusedargs(eventresponse,kwargs) 6318 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 6319 # Make all P fields that haven't already been constructed 6320 6321 6322 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 6323 'Writes this packet to the supplied buffer' 6324 self._bufferstartoffset=buf.getcurrentoffset() 6325 self.__field_header.writetobuffer(buf) 6326 self.__field_entry.writetobuffer(buf) 6327 self.__field_pad.writetobuffer(buf) 6328 self._bufferendoffset=buf.getcurrentoffset() 6329 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 6330 6331 6332 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 6333 'Reads this packet from the supplied buffer' 6334 self._bufferstartoffset=buf.getcurrentoffset() 6335 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 6336 self.__field_header=qcpheader() 6337 self.__field_header.readfrombuffer(buf) 6338 self.__field_entry=evententry() 6339 self.__field_entry.readfrombuffer(buf) 6340 self.__field_pad=UNKNOWN() 6341 self.__field_pad.readfrombuffer(buf) 6342 self._bufferendoffset=buf.getcurrentoffset() 6343 6344 6345 def __getfield_header(self): 6346 return self.__field_header.getvalue() 6347 6348 def __setfield_header(self, value): 6349 if isinstance(value,qcpheader): 6350 self.__field_header=value 6351 else: 6352 self.__field_header=qcpheader(value,) 6353 6354 def __delfield_header(self): del self.__field_header 6355 6356 header=property(__getfield_header, __setfield_header, __delfield_header, None) 6357 6358 def __getfield_entry(self): 6359 return self.__field_entry.getvalue() 6360 6361 def __setfield_entry(self, value): 6362 if isinstance(value,evententry): 6363 self.__field_entry=value 6364 else: 6365 self.__field_entry=evententry(value,) 6366 6367 def __delfield_entry(self): del self.__field_entry 6368 6369 entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None) 6370 6371 def __getfield_pad(self): 6372 return self.__field_pad.getvalue() 6373 6374 def __setfield_pad(self, value): 6375 if isinstance(value,UNKNOWN): 6376 self.__field_pad=value 6377 else: 6378 self.__field_pad=UNKNOWN(value,) 6379 6380 def __delfield_pad(self): del self.__field_pad 6381 6382 pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None) 6383 6384 def iscontainer(self): 6385 return True 6386 6387 def containerelements(self): 6388 yield ('header', self.__field_header, None) 6389 yield ('entry', self.__field_entry, None) 6390 yield ('pad', self.__field_pad, None) 6391 6392 6393 6394 6395 class eventupdaterequest(BaseProtogenClass): 6396 __fields=['header', 'entry', 'pad'] 6397 6398 def __init__(self, *args, **kwargs): 6399 dict={} 6400 # What was supplied to this function 6401 dict.update(kwargs) 6402 # Parent constructor 6403 super(eventupdaterequest,self).__init__(**dict) 6404 if self.__class__ is eventupdaterequest: 6405 self._update(args,dict) 6406 6407 6408 def getfields(self): 6409 return self.__fields 6410 6411 6412 def _update(self, args, kwargs): 6413 super(eventupdaterequest,self)._update(args,kwargs) 6414 keys=kwargs.keys() 6415 for key in keys: 6416 if key in self.__fields: 6417 setattr(self, key, kwargs[key]) 6418 del kwargs[key] 6419 # Were any unrecognized kwargs passed in? 6420 if __debug__: 6421 self._complainaboutunusedargs(eventupdaterequest,kwargs) 6422 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 6423 # Make all P fields that haven't already been constructed 6424 6425 6426 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 6427 'Writes this packet to the supplied buffer' 6428 self._bufferstartoffset=buf.getcurrentoffset() 6429 try: self.__field_header 6430 except: 6431 self.__field_header=qcpwriteheader(**{'packettype': 0x0c, 'command':0x23}) 6432 self.__field_header.writetobuffer(buf) 6433 self.__field_entry.writetobuffer(buf) 6434 try: self.__field_pad 6435 except: 6436 self.__field_pad=UNKNOWN(**{'sizeinbytes': 56}) 6437 self.__field_pad.writetobuffer(buf) 6438 self._bufferendoffset=buf.getcurrentoffset() 6439 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 6440 6441 6442 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 6443 'Reads this packet from the supplied buffer' 6444 self._bufferstartoffset=buf.getcurrentoffset() 6445 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 6446 self.__field_header=qcpwriteheader(**{'packettype': 0x0c, 'command':0x23}) 6447 self.__field_header.readfrombuffer(buf) 6448 self.__field_entry=evententry() 6449 self.__field_entry.readfrombuffer(buf) 6450 self.__field_pad=UNKNOWN(**{'sizeinbytes': 56}) 6451 self.__field_pad.readfrombuffer(buf) 6452 self._bufferendoffset=buf.getcurrentoffset() 6453 6454 6455 def __getfield_header(self): 6456 try: self.__field_header 6457 except: 6458 self.__field_header=qcpwriteheader(**{'packettype': 0x0c, 'command':0x23}) 6459 return self.__field_header.getvalue() 6460 6461 def __setfield_header(self, value): 6462 if isinstance(value,qcpwriteheader): 6463 self.__field_header=value 6464 else: 6465 self.__field_header=qcpwriteheader(value,**{'packettype': 0x0c, 'command':0x23}) 6466 6467 def __delfield_header(self): del self.__field_header 6468 6469 header=property(__getfield_header, __setfield_header, __delfield_header, None) 6470 6471 def __getfield_entry(self): 6472 return self.__field_entry.getvalue() 6473 6474 def __setfield_entry(self, value): 6475 if isinstance(value,evententry): 6476 self.__field_entry=value 6477 else: 6478 self.__field_entry=evententry(value,) 6479 6480 def __delfield_entry(self): del self.__field_entry 6481 6482 entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None) 6483 6484 def __getfield_pad(self): 6485 try: self.__field_pad 6486 except: 6487 self.__field_pad=UNKNOWN(**{'sizeinbytes': 56}) 6488 return self.__field_pad.getvalue() 6489 6490 def __setfield_pad(self, value): 6491 if isinstance(value,UNKNOWN): 6492 self.__field_pad=value 6493 else: 6494 self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 56}) 6495 6496 def __delfield_pad(self): del self.__field_pad 6497 6498 pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None) 6499 6500 def iscontainer(self): 6501 return True 6502 6503 def containerelements(self): 6504 yield ('header', self.__field_header, None) 6505 yield ('entry', self.__field_entry, None) 6506 yield ('pad', self.__field_pad, None) 6507 6508 6509 6510 6511 class messagesententry(BaseProtogenClass): 6512 __fields=['slot', 'read', 'counter', 'pad1', 'dunno1', 'dunno2', 'dunno3', 'pad2', 'dunno4', 'dunno5', 'pad3', 'message_len', 'message', 'pad4', 'pad5', 'year', 'month', 'day', 'hour', 'minute', 'second', 'callback_len', 'callback', 'phonenum_len', 'phonenum', 'dunno6', 'priority', 'pad6', 'dunno7', 'dunno8'] 6513 6514 def __init__(self, *args, **kwargs): 6515 dict={} 6516 # What was supplied to this function 6517 dict.update(kwargs) 6518 # Parent constructor 6519 super(messagesententry,self).__init__(**dict) 6520 if self.__class__ is messagesententry: 6521 self._update(args,dict) 6522 6523 6524 def getfields(self): 6525 return self.__fields 6526 6527 6528 def _update(self, args, kwargs): 6529 super(messagesententry,self)._update(args,kwargs) 6530 keys=kwargs.keys() 6531 for key in keys: 6532 if key in self.__fields: 6533 setattr(self, key, kwargs[key]) 6534 del kwargs[key] 6535 # Were any unrecognized kwargs passed in? 6536 if __debug__: 6537 self._complainaboutunusedargs(messagesententry,kwargs) 6538 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 6539 # Make all P fields that haven't already been constructed 6540 6541 6542 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 6543 'Writes this packet to the supplied buffer' 6544 self._bufferstartoffset=buf.getcurrentoffset() 6545 self.__field_slot.writetobuffer(buf) 6546 self.__field_read.writetobuffer(buf) 6547 self.__field_counter.writetobuffer(buf) 6548 self.__field_pad1.writetobuffer(buf) 6549 self.__field_dunno1.writetobuffer(buf) 6550 self.__field_dunno2.writetobuffer(buf) 6551 self.__field_dunno3.writetobuffer(buf) 6552 self.__field_pad2.writetobuffer(buf) 6553 self.__field_dunno4.writetobuffer(buf) 6554 self.__field_dunno5.writetobuffer(buf) 6555 self.__field_pad3.writetobuffer(buf) 6556 self.__field_message_len.writetobuffer(buf) 6557 self.__field_message.writetobuffer(buf) 6558 self.__field_pad4.writetobuffer(buf) 6559 self.__field_pad5.writetobuffer(buf) 6560 self.__field_year.writetobuffer(buf) 6561 self.__field_month.writetobuffer(buf) 6562 self.__field_day.writetobuffer(buf) 6563 self.__field_hour.writetobuffer(buf) 6564 self.__field_minute.writetobuffer(buf) 6565 self.__field_second.writetobuffer(buf) 6566 self.__field_callback_len.writetobuffer(buf) 6567 self.__field_callback.writetobuffer(buf) 6568 self.__field_phonenum_len.writetobuffer(buf) 6569 self.__field_phonenum.writetobuffer(buf) 6570 self.__field_dunno6.writetobuffer(buf) 6571 self.__field_priority.writetobuffer(buf) 6572 self.__field_pad6.writetobuffer(buf) 6573 self.__field_dunno7.writetobuffer(buf) 6574 self.__field_dunno8.writetobuffer(buf) 6575 self._bufferendoffset=buf.getcurrentoffset() 6576 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 6577 6578 6579 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 6580 'Reads this packet from the supplied buffer' 6581 self._bufferstartoffset=buf.getcurrentoffset() 6582 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 6583 self.__field_slot=UINT(**{'sizeinbytes': 1}) 6584 self.__field_slot.readfrombuffer(buf) 6585 self.__field_read=UINT(**{'sizeinbytes': 1}) 6586 self.__field_read.readfrombuffer(buf) 6587 self.__field_counter=UINT(**{'sizeinbytes': 1}) 6588 self.__field_counter.readfrombuffer(buf) 6589 self.__field_pad1=UNKNOWN(**{'sizeinbytes': 3}) 6590 self.__field_pad1.readfrombuffer(buf) 6591 self.__field_dunno1=UINT(**{'sizeinbytes': 1}) 6592 self.__field_dunno1.readfrombuffer(buf) 6593 self.__field_dunno2=UINT(**{'sizeinbytes': 1}) 6594 self.__field_dunno2.readfrombuffer(buf) 6595 self.__field_dunno3=UINT(**{'sizeinbytes': 1}) 6596 self.__field_dunno3.readfrombuffer(buf) 6597 self.__field_pad2=UNKNOWN(**{'sizeinbytes': 1}) 6598 self.__field_pad2.readfrombuffer(buf) 6599 self.__field_dunno4=UINT(**{'sizeinbytes': 1}) 6600 self.__field_dunno4.readfrombuffer(buf) 6601 self.__field_dunno5=UINT(**{'sizeinbytes': 1}) 6602 self.__field_dunno5.readfrombuffer(buf) 6603 self.__field_pad3=UNKNOWN(**{'sizeinbytes': 1}) 6604 self.__field_pad3.readfrombuffer(buf) 6605 self.__field_message_len=UINT(**{'sizeinbytes': 1}) 6606 self.__field_message_len.readfrombuffer(buf) 6607 self.__field_message=USTRING(**{'sizeinbytes': 255}) 6608 self.__field_message.readfrombuffer(buf) 6609 self.__field_pad4=UNKNOWN(**{'sizeinbytes': 1}) 6610 self.__field_pad4.readfrombuffer(buf) 6611 self.__field_pad5=UINT(**{'sizeinbytes': 1}) 6612 self.__field_pad5.readfrombuffer(buf) 6613 self.__field_year=UINT(**{'sizeinbytes': 1}) 6614 self.__field_year.readfrombuffer(buf) 6615 self.__field_month=UINT(**{'sizeinbytes': 1}) 6616 self.__field_month.readfrombuffer(buf) 6617 self.__field_day=UINT(**{'sizeinbytes': 1}) 6618 self.__field_day.readfrombuffer(buf) 6619 self.__field_hour=UINT(**{'sizeinbytes': 1}) 6620 self.__field_hour.readfrombuffer(buf) 6621 self.__field_minute=UINT(**{'sizeinbytes': 1}) 6622 self.__field_minute.readfrombuffer(buf) 6623 self.__field_second=UINT(**{'sizeinbytes': 1}) 6624 self.__field_second.readfrombuffer(buf) 6625 self.__field_callback_len=UINT(**{'sizeinbytes': 1}) 6626 self.__field_callback_len.readfrombuffer(buf) 6627 self.__field_callback=USTRING(**{'sizeinbytes': 34}) 6628 self.__field_callback.readfrombuffer(buf) 6629 self.__field_phonenum_len=UINT(**{'sizeinbytes': 1}) 6630 self.__field_phonenum_len.readfrombuffer(buf) 6631 self.__field_phonenum=USTRING(**{'sizeinbytes': 36}) 6632 self.__field_phonenum.readfrombuffer(buf) 6633 self.__field_dunno6=UINT(**{'sizeinbytes': 1}) 6634 self.__field_dunno6.readfrombuffer(buf) 6635 self.__field_priority=UINT(**{'sizeinbytes': 1}) 6636 self.__field_priority.readfrombuffer(buf) 6637 self.__field_pad6=UNKNOWN(**{'sizeinbytes': 3}) 6638 self.__field_pad6.readfrombuffer(buf) 6639 self.__field_dunno7=UINT(**{'sizeinbytes': 1}) 6640 self.__field_dunno7.readfrombuffer(buf) 6641 self.__field_dunno8=UINT(**{'sizeinbytes': 1}) 6642 self.__field_dunno8.readfrombuffer(buf) 6643 self._bufferendoffset=buf.getcurrentoffset() 6644 6645 6646 def __getfield_slot(self): 6647 return self.__field_slot.getvalue() 6648 6649 def __setfield_slot(self, value): 6650 if isinstance(value,UINT): 6651 self.__field_slot=value 6652 else: 6653 self.__field_slot=UINT(value,**{'sizeinbytes': 1}) 6654 6655 def __delfield_slot(self): del self.__field_slot 6656 6657 slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None) 6658 6659 def __getfield_read(self): 6660 return self.__field_read.getvalue() 6661 6662 def __setfield_read(self, value): 6663 if isinstance(value,UINT): 6664 self.__field_read=value 6665 else: 6666 self.__field_read=UINT(value,**{'sizeinbytes': 1}) 6667 6668 def __delfield_read(self): del self.__field_read 6669 6670 read=property(__getfield_read, __setfield_read, __delfield_read, None) 6671 6672 def __getfield_counter(self): 6673 return self.__field_counter.getvalue() 6674 6675 def __setfield_counter(self, value): 6676 if isinstance(value,UINT): 6677 self.__field_counter=value 6678 else: 6679 self.__field_counter=UINT(value,**{'sizeinbytes': 1}) 6680 6681 def __delfield_counter(self): del self.__field_counter 6682 6683 counter=property(__getfield_counter, __setfield_counter, __delfield_counter, None) 6684 6685 def __getfield_pad1(self): 6686 return self.__field_pad1.getvalue() 6687 6688 def __setfield_pad1(self, value): 6689 if isinstance(value,UNKNOWN): 6690 self.__field_pad1=value 6691 else: 6692 self.__field_pad1=UNKNOWN(value,**{'sizeinbytes': 3}) 6693 6694 def __delfield_pad1(self): del self.__field_pad1 6695 6696 pad1=property(__getfield_pad1, __setfield_pad1, __delfield_pad1, None) 6697 6698 def __getfield_dunno1(self): 6699 return self.__field_dunno1.getvalue() 6700 6701 def __setfield_dunno1(self, value): 6702 if isinstance(value,UINT): 6703 self.__field_dunno1=value 6704 else: 6705 self.__field_dunno1=UINT(value,**{'sizeinbytes': 1}) 6706 6707 def __delfield_dunno1(self): del self.__field_dunno1 6708 6709 dunno1=property(__getfield_dunno1, __setfield_dunno1, __delfield_dunno1, None) 6710 6711 def __getfield_dunno2(self): 6712 return self.__field_dunno2.getvalue() 6713 6714 def __setfield_dunno2(self, value): 6715 if isinstance(value,UINT): 6716 self.__field_dunno2=value 6717 else: 6718 self.__field_dunno2=UINT(value,**{'sizeinbytes': 1}) 6719 6720 def __delfield_dunno2(self): del self.__field_dunno2 6721 6722 dunno2=property(__getfield_dunno2, __setfield_dunno2, __delfield_dunno2, None) 6723 6724 def __getfield_dunno3(self): 6725 return self.__field_dunno3.getvalue() 6726 6727 def __setfield_dunno3(self, value): 6728 if isinstance(value,UINT): 6729 self.__field_dunno3=value 6730 else: 6731 self.__field_dunno3=UINT(value,**{'sizeinbytes': 1}) 6732 6733 def __delfield_dunno3(self): del self.__field_dunno3 6734 6735 dunno3=property(__getfield_dunno3, __setfield_dunno3, __delfield_dunno3, None) 6736 6737 def __getfield_pad2(self): 6738 return self.__field_pad2.getvalue() 6739 6740 def __setfield_pad2(self, value): 6741 if isinstance(value,UNKNOWN): 6742 self.__field_pad2=value 6743 else: 6744 self.__field_pad2=UNKNOWN(value,**{'sizeinbytes': 1}) 6745 6746 def __delfield_pad2(self): del self.__field_pad2 6747 6748 pad2=property(__getfield_pad2, __setfield_pad2, __delfield_pad2, None) 6749 6750 def __getfield_dunno4(self): 6751 return self.__field_dunno4.getvalue() 6752 6753 def __setfield_dunno4(self, value): 6754 if isinstance(value,UINT): 6755 self.__field_dunno4=value 6756 else: 6757 self.__field_dunno4=UINT(value,**{'sizeinbytes': 1}) 6758 6759 def __delfield_dunno4(self): del self.__field_dunno4 6760 6761 dunno4=property(__getfield_dunno4, __setfield_dunno4, __delfield_dunno4, None) 6762 6763 def __getfield_dunno5(self): 6764 return self.__field_dunno5.getvalue() 6765 6766 def __setfield_dunno5(self, value): 6767 if isinstance(value,UINT): 6768 self.__field_dunno5=value 6769 else: 6770 self.__field_dunno5=UINT(value,**{'sizeinbytes': 1}) 6771 6772 def __delfield_dunno5(self): del self.__field_dunno5 6773 6774 dunno5=property(__getfield_dunno5, __setfield_dunno5, __delfield_dunno5, None) 6775 6776 def __getfield_pad3(self): 6777 return self.__field_pad3.getvalue() 6778 6779 def __setfield_pad3(self, value): 6780 if isinstance(value,UNKNOWN): 6781 self.__field_pad3=value 6782 else: 6783 self.__field_pad3=UNKNOWN(value,**{'sizeinbytes': 1}) 6784 6785 def __delfield_pad3(self): del self.__field_pad3 6786 6787 pad3=property(__getfield_pad3, __setfield_pad3, __delfield_pad3, None) 6788 6789 def __getfield_message_len(self): 6790 return self.__field_message_len.getvalue() 6791 6792 def __setfield_message_len(self, value): 6793 if isinstance(value,UINT): 6794 self.__field_message_len=value 6795 else: 6796 self.__field_message_len=UINT(value,**{'sizeinbytes': 1}) 6797 6798 def __delfield_message_len(self): del self.__field_message_len 6799 6800 message_len=property(__getfield_message_len, __setfield_message_len, __delfield_message_len, None) 6801 6802 def __getfield_message(self): 6803 return self.__field_message.getvalue() 6804 6805 def __setfield_message(self, value): 6806 if isinstance(value,USTRING): 6807 self.__field_message=value 6808 else: 6809 self.__field_message=USTRING(value,**{'sizeinbytes': 255}) 6810 6811 def __delfield_message(self): del self.__field_message 6812 6813 message=property(__getfield_message, __setfield_message, __delfield_message, "Text of the notification") 6814 6815 def __getfield_pad4(self): 6816 return self.__field_pad4.getvalue() 6817 6818 def __setfield_pad4(self, value): 6819 if isinstance(value,UNKNOWN): 6820 self.__field_pad4=value 6821 else: 6822 self.__field_pad4=UNKNOWN(value,**{'sizeinbytes': 1}) 6823 6824 def __delfield_pad4(self): del self.__field_pad4 6825 6826 pad4=property(__getfield_pad4, __setfield_pad4, __delfield_pad4, None) 6827 6828 def __getfield_pad5(self): 6829 return self.__field_pad5.getvalue() 6830 6831 def __setfield_pad5(self, value): 6832 if isinstance(value,UINT): 6833 self.__field_pad5=value 6834 else: 6835 self.__field_pad5=UINT(value,**{'sizeinbytes': 1}) 6836 6837 def __delfield_pad5(self): del self.__field_pad5 6838 6839 pad5=property(__getfield_pad5, __setfield_pad5, __delfield_pad5, None) 6840 6841 def __getfield_year(self): 6842 return self.__field_year.getvalue() 6843 6844 def __setfield_year(self, value): 6845 if isinstance(value,UINT): 6846 self.__field_year=value 6847 else: 6848 self.__field_year=UINT(value,**{'sizeinbytes': 1}) 6849 6850 def __delfield_year(self): del self.__field_year 6851 6852 year=property(__getfield_year, __setfield_year, __delfield_year, None) 6853 6854 def __getfield_month(self): 6855 return self.__field_month.getvalue() 6856 6857 def __setfield_month(self, value): 6858 if isinstance(value,UINT): 6859 self.__field_month=value 6860 else: 6861 self.__field_month=UINT(value,**{'sizeinbytes': 1}) 6862 6863 def __delfield_month(self): del self.__field_month 6864 6865 month=property(__getfield_month, __setfield_month, __delfield_month, None) 6866 6867 def __getfield_day(self): 6868 return self.__field_day.getvalue() 6869 6870 def __setfield_day(self, value): 6871 if isinstance(value,UINT): 6872 self.__field_day=value 6873 else: 6874 self.__field_day=UINT(value,**{'sizeinbytes': 1}) 6875 6876 def __delfield_day(self): del self.__field_day 6877 6878 day=property(__getfield_day, __setfield_day, __delfield_day, None) 6879 6880 def __getfield_hour(self): 6881 return self.__field_hour.getvalue() 6882 6883 def __setfield_hour(self, value): 6884 if isinstance(value,UINT): 6885 self.__field_hour=value 6886 else: 6887 self.__field_hour=UINT(value,**{'sizeinbytes': 1}) 6888 6889 def __delfield_hour(self): del self.__field_hour 6890 6891 hour=property(__getfield_hour, __setfield_hour, __delfield_hour, None) 6892 6893 def __getfield_minute(self): 6894 return self.__field_minute.getvalue() 6895 6896 def __setfield_minute(self, value): 6897 if isinstance(value,UINT): 6898 self.__field_minute=value 6899 else: 6900 self.__field_minute=UINT(value,**{'sizeinbytes': 1}) 6901 6902 def __delfield_minute(self): del self.__field_minute 6903 6904 minute=property(__getfield_minute, __setfield_minute, __delfield_minute, None) 6905 6906 def __getfield_second(self): 6907 return self.__field_second.getvalue() 6908 6909 def __setfield_second(self, value): 6910 if isinstance(value,UINT): 6911 self.__field_second=value 6912 else: 6913 self.__field_second=UINT(value,**{'sizeinbytes': 1}) 6914 6915 def __delfield_second(self): del self.__field_second 6916 6917 second=property(__getfield_second, __setfield_second, __delfield_second, None) 6918 6919 def __getfield_callback_len(self): 6920 return self.__field_callback_len.getvalue() 6921 6922 def __setfield_callback_len(self, value): 6923 if isinstance(value,UINT): 6924 self.__field_callback_len=value 6925 else: 6926 self.__field_callback_len=UINT(value,**{'sizeinbytes': 1}) 6927 6928 def __delfield_callback_len(self): del self.__field_callback_len 6929 6930 callback_len=property(__getfield_callback_len, __setfield_callback_len, __delfield_callback_len, None) 6931 6932 def __getfield_callback(self): 6933 return self.__field_callback.getvalue() 6934 6935 def __setfield_callback(self, value): 6936 if isinstance(value,USTRING): 6937 self.__field_callback=value 6938 else: 6939 self.__field_callback=USTRING(value,**{'sizeinbytes': 34}) 6940 6941 def __delfield_callback(self): del self.__field_callback 6942 6943 callback=property(__getfield_callback, __setfield_callback, __delfield_callback, None) 6944 6945 def __getfield_phonenum_len(self): 6946 return self.__field_phonenum_len.getvalue() 6947 6948 def __setfield_phonenum_len(self, value): 6949 if isinstance(value,UINT): 6950 self.__field_phonenum_len=value 6951 else: 6952 self.__field_phonenum_len=UINT(value,**{'sizeinbytes': 1}) 6953 6954 def __delfield_phonenum_len(self): del self.__field_phonenum_len 6955 6956 phonenum_len=property(__getfield_phonenum_len, __setfield_phonenum_len, __delfield_phonenum_len, None) 6957 6958 def __getfield_phonenum(self): 6959 return self.__field_phonenum.getvalue() 6960 6961 def __setfield_phonenum(self, value): 6962 if isinstance(value,USTRING): 6963 self.__field_phonenum=value 6964 else: 6965 self.__field_phonenum=USTRING(value,**{'sizeinbytes': 36}) 6966 6967 def __delfield_phonenum(self): del self.__field_phonenum 6968 6969 phonenum=property(__getfield_phonenum, __setfield_phonenum, __delfield_phonenum, None) 6970 6971 def __getfield_dunno6(self): 6972 return self.__field_dunno6.getvalue() 6973 6974 def __setfield_dunno6(self, value): 6975 if isinstance(value,UINT): 6976 self.__field_dunno6=value 6977 else: 6978 self.__field_dunno6=UINT(value,**{'sizeinbytes': 1}) 6979 6980 def __delfield_dunno6(self): del self.__field_dunno6 6981 6982 dunno6=property(__getfield_dunno6, __setfield_dunno6, __delfield_dunno6, None) 6983 6984 def __getfield_priority(self): 6985 return self.__field_priority.getvalue() 6986 6987 def __setfield_priority(self, value): 6988 if isinstance(value,UINT): 6989 self.__field_priority=value 6990 else: 6991 self.__field_priority=UINT(value,**{'sizeinbytes': 1}) 6992 6993 def __delfield_priority(self): del self.__field_priority 6994 6995 priority=property(__getfield_priority, __setfield_priority, __delfield_priority, None) 6996 6997 def __getfield_pad6(self): 6998 return self.__field_pad6.getvalue() 6999 7000 def __setfield_pad6(self, value): 7001 if isinstance(value,UNKNOWN): 7002 self.__field_pad6=value 7003 else: 7004 self.__field_pad6=UNKNOWN(value,**{'sizeinbytes': 3}) 7005 7006 def __delfield_pad6(self): del self.__field_pad6 7007 7008 pad6=property(__getfield_pad6, __setfield_pad6, __delfield_pad6, None) 7009 7010 def __getfield_dunno7(self): 7011 return self.__field_dunno7.getvalue() 7012 7013 def __setfield_dunno7(self, value): 7014 if isinstance(value,UINT): 7015 self.__field_dunno7=value 7016 else: 7017 self.__field_dunno7=UINT(value,**{'sizeinbytes': 1}) 7018 7019 def __delfield_dunno7(self): del self.__field_dunno7 7020 7021 dunno7=property(__getfield_dunno7, __setfield_dunno7, __delfield_dunno7, None) 7022 7023 def __getfield_dunno8(self): 7024 return self.__field_dunno8.getvalue() 7025 7026 def __setfield_dunno8(self, value): 7027 if isinstance(value,UINT): 7028 self.__field_dunno8=value 7029 else: 7030 self.__field_dunno8=UINT(value,**{'sizeinbytes': 1}) 7031 7032 def __delfield_dunno8(self): del self.__field_dunno8 7033 7034 dunno8=property(__getfield_dunno8, __setfield_dunno8, __delfield_dunno8, None) 7035 7036 def iscontainer(self): 7037 return True 7038 7039 def containerelements(self): 7040 yield ('slot', self.__field_slot, None) 7041 yield ('read', self.__field_read, None) 7042 yield ('counter', self.__field_counter, None) 7043 yield ('pad1', self.__field_pad1, None) 7044 yield ('dunno1', self.__field_dunno1, None) 7045 yield ('dunno2', self.__field_dunno2, None) 7046 yield ('dunno3', self.__field_dunno3, None) 7047 yield ('pad2', self.__field_pad2, None) 7048 yield ('dunno4', self.__field_dunno4, None) 7049 yield ('dunno5', self.__field_dunno5, None) 7050 yield ('pad3', self.__field_pad3, None) 7051 yield ('message_len', self.__field_message_len, None) 7052 yield ('message', self.__field_message, "Text of the notification") 7053 yield ('pad4', self.__field_pad4, None) 7054 yield ('pad5', self.__field_pad5, None) 7055 yield ('year', self.__field_year, None) 7056 yield ('month', self.__field_month, None) 7057 yield ('day', self.__field_day, None) 7058 yield ('hour', self.__field_hour, None) 7059 yield ('minute', self.__field_minute, None) 7060 yield ('second', self.__field_second, None) 7061 yield ('callback_len', self.__field_callback_len, None) 7062 yield ('callback', self.__field_callback, None) 7063 yield ('phonenum_len', self.__field_phonenum_len, None) 7064 yield ('phonenum', self.__field_phonenum, None) 7065 yield ('dunno6', self.__field_dunno6, None) 7066 yield ('priority', self.__field_priority, None) 7067 yield ('pad6', self.__field_pad6, None) 7068 yield ('dunno7', self.__field_dunno7, None) 7069 yield ('dunno8', self.__field_dunno8, None) 7070 7071 7072 7073 7074 class messagesentresponse(BaseProtogenClass): 7075 __fields=['header', 'entry', 'pad'] 7076 7077 def __init__(self, *args, **kwargs): 7078 dict={} 7079 # What was supplied to this function 7080 dict.update(kwargs) 7081 # Parent constructor 7082 super(messagesentresponse,self).__init__(**dict) 7083 if self.__class__ is messagesentresponse: 7084 self._update(args,dict) 7085 7086 7087 def getfields(self): 7088 return self.__fields 7089 7090 7091 def _update(self, args, kwargs): 7092 super(messagesentresponse,self)._update(args,kwargs) 7093 keys=kwargs.keys() 7094 for key in keys: 7095 if key in self.__fields: 7096 setattr(self, key, kwargs[key]) 7097 del kwargs[key] 7098 # Were any unrecognized kwargs passed in? 7099 if __debug__: 7100 self._complainaboutunusedargs(messagesentresponse,kwargs) 7101 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 7102 # Make all P fields that haven't already been constructed 7103 7104 7105 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 7106 'Writes this packet to the supplied buffer' 7107 self._bufferstartoffset=buf.getcurrentoffset() 7108 self.__field_header.writetobuffer(buf) 7109 self.__field_entry.writetobuffer(buf) 7110 self.__field_pad.writetobuffer(buf) 7111 self._bufferendoffset=buf.getcurrentoffset() 7112 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 7113 7114 7115 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 7116 'Reads this packet from the supplied buffer' 7117 self._bufferstartoffset=buf.getcurrentoffset() 7118 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 7119 self.__field_header=sanyoheader() 7120 self.__field_header.readfrombuffer(buf) 7121 self.__field_entry=messagesententry() 7122 self.__field_entry.readfrombuffer(buf) 7123 self.__field_pad=UNKNOWN() 7124 self.__field_pad.readfrombuffer(buf) 7125 self._bufferendoffset=buf.getcurrentoffset() 7126 7127 7128 def __getfield_header(self): 7129 return self.__field_header.getvalue() 7130 7131 def __setfield_header(self, value): 7132 if isinstance(value,sanyoheader): 7133 self.__field_header=value 7134 else: 7135 self.__field_header=sanyoheader(value,) 7136 7137 def __delfield_header(self): del self.__field_header 7138 7139 header=property(__getfield_header, __setfield_header, __delfield_header, None) 7140 7141 def __getfield_entry(self): 7142 return self.__field_entry.getvalue() 7143 7144 def __setfield_entry(self, value): 7145 if isinstance(value,messagesententry): 7146 self.__field_entry=value 7147 else: 7148 self.__field_entry=messagesententry(value,) 7149 7150 def __delfield_entry(self): del self.__field_entry 7151 7152 entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None) 7153 7154 def __getfield_pad(self): 7155 return self.__field_pad.getvalue() 7156 7157 def __setfield_pad(self, value): 7158 if isinstance(value,UNKNOWN): 7159 self.__field_pad=value 7160 else: 7161 self.__field_pad=UNKNOWN(value,) 7162 7163 def __delfield_pad(self): del self.__field_pad 7164 7165 pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None) 7166 7167 def iscontainer(self): 7168 return True 7169 7170 def containerelements(self): 7171 yield ('header', self.__field_header, None) 7172 yield ('entry', self.__field_entry, None) 7173 yield ('pad', self.__field_pad, None) 7174 7175 7176 7177 7178
Generated by PyXR 0.9.4