0001 # THIS FILE IS AUTOMATICALLY GENERATED. EDIT THE SOURCE FILE NOT THIS ONE 0002 0003 """Various descriptions of data specific to Audiovox CDM8900""" 0004 0005 from prototypes import * 0006 0007 # We use LSB for all integer like fields 0008 UINT=UINTlsb 0009 BOOL=BOOLlsb 0010 0011 NUMSLOTS=300 0012 MAXPHONENUMBERLEN=32 0013 MAXPHONENUMBERS=5 0014 MAXNAMELEN=16 0015 MAXEMAILLEN=48 0016 MAXMEMOLEN=48 0017 MAXEMAILS=3 0018 0019 numbertypetab=( 'phone', 'home', 'office','cell', 'pager', 'fax' ) 0020 0021 PHONE_ENCODING='iso8859_1' 0022 0023 class pbnumber(BaseProtogenClass): 0024 __fields=['valid', 'type', 'ringer_group', 'pad0', 'ringer_index', 'pad1', 'secret', 'number', 'pad2'] 0025 0026 def __init__(self, *args, **kwargs): 0027 dict={} 0028 # What was supplied to this function 0029 dict.update(kwargs) 0030 # Parent constructor 0031 super(pbnumber,self).__init__(**dict) 0032 if self.__class__ is pbnumber: 0033 self._update(args,dict) 0034 0035 0036 def getfields(self): 0037 return self.__fields 0038 0039 0040 def _update(self, args, kwargs): 0041 super(pbnumber,self)._update(args,kwargs) 0042 keys=kwargs.keys() 0043 for key in keys: 0044 if key in self.__fields: 0045 setattr(self, key, kwargs[key]) 0046 del kwargs[key] 0047 # Were any unrecognized kwargs passed in? 0048 if __debug__: 0049 self._complainaboutunusedargs(pbnumber,kwargs) 0050 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 0051 # Make all P fields that haven't already been constructed 0052 0053 0054 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 0055 'Writes this packet to the supplied buffer' 0056 self._bufferstartoffset=buf.getcurrentoffset() 0057 try: self.__field_valid 0058 except: 0059 self.__field_valid=UINT(**{'sizeinbytes': 1, 'default': 0}) 0060 self.__field_valid.writetobuffer(buf) 0061 try: self.__field_type 0062 except: 0063 self.__field_type=UINT(**{'sizeinbytes': 1, 'default': 0}) 0064 self.__field_type.writetobuffer(buf) 0065 try: self.__field_ringer_group 0066 except: 0067 self.__field_ringer_group=UINT(**{'sizeinbytes': 1, 'default': 5}) 0068 self.__field_ringer_group.writetobuffer(buf) 0069 try: self.__field_pad0 0070 except: 0071 self.__field_pad0=UINT(**{'sizeinbytes': 1, 'default': 0}) 0072 self.__field_pad0.writetobuffer(buf) 0073 try: self.__field_ringer_index 0074 except: 0075 self.__field_ringer_index=UINT(**{'sizeinbytes': 2, 'default': 0}) 0076 self.__field_ringer_index.writetobuffer(buf) 0077 try: self.__field_pad1 0078 except: 0079 self.__field_pad1=UINT(**{'sizeinbytes': 2, 'default': 0}) 0080 self.__field_pad1.writetobuffer(buf) 0081 try: self.__field_secret 0082 except: 0083 self.__field_secret=UINT(**{'sizeinbytes': 1, 'default': 0}) 0084 self.__field_secret.writetobuffer(buf) 0085 try: self.__field_number 0086 except: 0087 self.__field_number=USTRING(**{'sizeinbytes': 33, 'terminator': None, 'pascal': True, 'default': ""}) 0088 self.__field_number.writetobuffer(buf) 0089 try: self.__field_pad2 0090 except: 0091 self.__field_pad2=UNKNOWN(**{'sizeinbytes': 48}) 0092 self.__field_pad2.writetobuffer(buf) 0093 self._bufferendoffset=buf.getcurrentoffset() 0094 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 0095 0096 0097 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 0098 'Reads this packet from the supplied buffer' 0099 self._bufferstartoffset=buf.getcurrentoffset() 0100 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 0101 self.__field_valid=UINT(**{'sizeinbytes': 1, 'default': 0}) 0102 self.__field_valid.readfrombuffer(buf) 0103 self.__field_type=UINT(**{'sizeinbytes': 1, 'default': 0}) 0104 self.__field_type.readfrombuffer(buf) 0105 self.__field_ringer_group=UINT(**{'sizeinbytes': 1, 'default': 5}) 0106 self.__field_ringer_group.readfrombuffer(buf) 0107 self.__field_pad0=UINT(**{'sizeinbytes': 1, 'default': 0}) 0108 self.__field_pad0.readfrombuffer(buf) 0109 self.__field_ringer_index=UINT(**{'sizeinbytes': 2, 'default': 0}) 0110 self.__field_ringer_index.readfrombuffer(buf) 0111 self.__field_pad1=UINT(**{'sizeinbytes': 2, 'default': 0}) 0112 self.__field_pad1.readfrombuffer(buf) 0113 self.__field_secret=UINT(**{'sizeinbytes': 1, 'default': 0}) 0114 self.__field_secret.readfrombuffer(buf) 0115 self.__field_number=USTRING(**{'sizeinbytes': 33, 'terminator': None, 'pascal': True, 'default': ""}) 0116 self.__field_number.readfrombuffer(buf) 0117 self.__field_pad2=UNKNOWN(**{'sizeinbytes': 48}) 0118 self.__field_pad2.readfrombuffer(buf) 0119 self._bufferendoffset=buf.getcurrentoffset() 0120 0121 0122 def __getfield_valid(self): 0123 try: self.__field_valid 0124 except: 0125 self.__field_valid=UINT(**{'sizeinbytes': 1, 'default': 0}) 0126 return self.__field_valid.getvalue() 0127 0128 def __setfield_valid(self, value): 0129 if isinstance(value,UINT): 0130 self.__field_valid=value 0131 else: 0132 self.__field_valid=UINT(value,**{'sizeinbytes': 1, 'default': 0}) 0133 0134 def __delfield_valid(self): del self.__field_valid 0135 0136 valid=property(__getfield_valid, __setfield_valid, __delfield_valid, None) 0137 0138 def __getfield_type(self): 0139 try: self.__field_type 0140 except: 0141 self.__field_type=UINT(**{'sizeinbytes': 1, 'default': 0}) 0142 return self.__field_type.getvalue() 0143 0144 def __setfield_type(self, value): 0145 if isinstance(value,UINT): 0146 self.__field_type=value 0147 else: 0148 self.__field_type=UINT(value,**{'sizeinbytes': 1, 'default': 0}) 0149 0150 def __delfield_type(self): del self.__field_type 0151 0152 type=property(__getfield_type, __setfield_type, __delfield_type, None) 0153 0154 def __getfield_ringer_group(self): 0155 try: self.__field_ringer_group 0156 except: 0157 self.__field_ringer_group=UINT(**{'sizeinbytes': 1, 'default': 5}) 0158 return self.__field_ringer_group.getvalue() 0159 0160 def __setfield_ringer_group(self, value): 0161 if isinstance(value,UINT): 0162 self.__field_ringer_group=value 0163 else: 0164 self.__field_ringer_group=UINT(value,**{'sizeinbytes': 1, 'default': 5}) 0165 0166 def __delfield_ringer_group(self): del self.__field_ringer_group 0167 0168 ringer_group=property(__getfield_ringer_group, __setfield_ringer_group, __delfield_ringer_group, None) 0169 0170 def __getfield_pad0(self): 0171 try: self.__field_pad0 0172 except: 0173 self.__field_pad0=UINT(**{'sizeinbytes': 1, 'default': 0}) 0174 return self.__field_pad0.getvalue() 0175 0176 def __setfield_pad0(self, value): 0177 if isinstance(value,UINT): 0178 self.__field_pad0=value 0179 else: 0180 self.__field_pad0=UINT(value,**{'sizeinbytes': 1, 'default': 0}) 0181 0182 def __delfield_pad0(self): del self.__field_pad0 0183 0184 pad0=property(__getfield_pad0, __setfield_pad0, __delfield_pad0, None) 0185 0186 def __getfield_ringer_index(self): 0187 try: self.__field_ringer_index 0188 except: 0189 self.__field_ringer_index=UINT(**{'sizeinbytes': 2, 'default': 0}) 0190 return self.__field_ringer_index.getvalue() 0191 0192 def __setfield_ringer_index(self, value): 0193 if isinstance(value,UINT): 0194 self.__field_ringer_index=value 0195 else: 0196 self.__field_ringer_index=UINT(value,**{'sizeinbytes': 2, 'default': 0}) 0197 0198 def __delfield_ringer_index(self): del self.__field_ringer_index 0199 0200 ringer_index=property(__getfield_ringer_index, __setfield_ringer_index, __delfield_ringer_index, None) 0201 0202 def __getfield_pad1(self): 0203 try: self.__field_pad1 0204 except: 0205 self.__field_pad1=UINT(**{'sizeinbytes': 2, 'default': 0}) 0206 return self.__field_pad1.getvalue() 0207 0208 def __setfield_pad1(self, value): 0209 if isinstance(value,UINT): 0210 self.__field_pad1=value 0211 else: 0212 self.__field_pad1=UINT(value,**{'sizeinbytes': 2, 'default': 0}) 0213 0214 def __delfield_pad1(self): del self.__field_pad1 0215 0216 pad1=property(__getfield_pad1, __setfield_pad1, __delfield_pad1, None) 0217 0218 def __getfield_secret(self): 0219 try: self.__field_secret 0220 except: 0221 self.__field_secret=UINT(**{'sizeinbytes': 1, 'default': 0}) 0222 return self.__field_secret.getvalue() 0223 0224 def __setfield_secret(self, value): 0225 if isinstance(value,UINT): 0226 self.__field_secret=value 0227 else: 0228 self.__field_secret=UINT(value,**{'sizeinbytes': 1, 'default': 0}) 0229 0230 def __delfield_secret(self): del self.__field_secret 0231 0232 secret=property(__getfield_secret, __setfield_secret, __delfield_secret, None) 0233 0234 def __getfield_number(self): 0235 try: self.__field_number 0236 except: 0237 self.__field_number=USTRING(**{'sizeinbytes': 33, 'terminator': None, 'pascal': True, 'default': ""}) 0238 return self.__field_number.getvalue() 0239 0240 def __setfield_number(self, value): 0241 if isinstance(value,USTRING): 0242 self.__field_number=value 0243 else: 0244 self.__field_number=USTRING(value,**{'sizeinbytes': 33, 'terminator': None, 'pascal': True, 'default': ""}) 0245 0246 def __delfield_number(self): del self.__field_number 0247 0248 number=property(__getfield_number, __setfield_number, __delfield_number, None) 0249 0250 def __getfield_pad2(self): 0251 try: self.__field_pad2 0252 except: 0253 self.__field_pad2=UNKNOWN(**{'sizeinbytes': 48}) 0254 return self.__field_pad2.getvalue() 0255 0256 def __setfield_pad2(self, value): 0257 if isinstance(value,UNKNOWN): 0258 self.__field_pad2=value 0259 else: 0260 self.__field_pad2=UNKNOWN(value,**{'sizeinbytes': 48}) 0261 0262 def __delfield_pad2(self): del self.__field_pad2 0263 0264 pad2=property(__getfield_pad2, __setfield_pad2, __delfield_pad2, None) 0265 0266 def iscontainer(self): 0267 return True 0268 0269 def containerelements(self): 0270 yield ('valid', self.__field_valid, None) 0271 yield ('type', self.__field_type, None) 0272 yield ('ringer_group', self.__field_ringer_group, None) 0273 yield ('pad0', self.__field_pad0, None) 0274 yield ('ringer_index', self.__field_ringer_index, None) 0275 yield ('pad1', self.__field_pad1, None) 0276 yield ('secret', self.__field_secret, None) 0277 yield ('number', self.__field_number, None) 0278 yield ('pad2', self.__field_pad2, None) 0279 0280 0281 0282 0283 class pbemail(BaseProtogenClass): 0284 __fields=['valid', 'dunno1', 'dunno2', 'dunno3', 'dunno4', 'email'] 0285 0286 def __init__(self, *args, **kwargs): 0287 dict={} 0288 # What was supplied to this function 0289 dict.update(kwargs) 0290 # Parent constructor 0291 super(pbemail,self).__init__(**dict) 0292 if self.__class__ is pbemail: 0293 self._update(args,dict) 0294 0295 0296 def getfields(self): 0297 return self.__fields 0298 0299 0300 def _update(self, args, kwargs): 0301 super(pbemail,self)._update(args,kwargs) 0302 keys=kwargs.keys() 0303 for key in keys: 0304 if key in self.__fields: 0305 setattr(self, key, kwargs[key]) 0306 del kwargs[key] 0307 # Were any unrecognized kwargs passed in? 0308 if __debug__: 0309 self._complainaboutunusedargs(pbemail,kwargs) 0310 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 0311 # Make all P fields that haven't already been constructed 0312 0313 0314 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 0315 'Writes this packet to the supplied buffer' 0316 self._bufferstartoffset=buf.getcurrentoffset() 0317 try: self.__field_valid 0318 except: 0319 self.__field_valid=UINT(**{'sizeinbytes': 1, 'default': 0}) 0320 self.__field_valid.writetobuffer(buf) 0321 try: self.__field_dunno1 0322 except: 0323 self.__field_dunno1=UINT(**{'sizeinbytes': 1, 'default': 1}) 0324 self.__field_dunno1.writetobuffer(buf) 0325 try: self.__field_dunno2 0326 except: 0327 self.__field_dunno2=UINT(**{'sizeinbytes': 2, 'default': 0}) 0328 self.__field_dunno2.writetobuffer(buf) 0329 try: self.__field_dunno3 0330 except: 0331 self.__field_dunno3=UINT(**{'sizeinbytes': 1, 'default': 5}) 0332 self.__field_dunno3.writetobuffer(buf) 0333 try: self.__field_dunno4 0334 except: 0335 self.__field_dunno4=UINT(**{'sizeinbytes': 4, 'default': 0}) 0336 self.__field_dunno4.writetobuffer(buf) 0337 try: self.__field_email 0338 except: 0339 self.__field_email=USTRING(**{'sizeinbytes': 49, 'encoding': PHONE_ENCODING, 'terminator': None, 'pascal': True, 'default': ""}) 0340 self.__field_email.writetobuffer(buf) 0341 self._bufferendoffset=buf.getcurrentoffset() 0342 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 0343 0344 0345 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 0346 'Reads this packet from the supplied buffer' 0347 self._bufferstartoffset=buf.getcurrentoffset() 0348 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 0349 self.__field_valid=UINT(**{'sizeinbytes': 1, 'default': 0}) 0350 self.__field_valid.readfrombuffer(buf) 0351 self.__field_dunno1=UINT(**{'sizeinbytes': 1, 'default': 1}) 0352 self.__field_dunno1.readfrombuffer(buf) 0353 self.__field_dunno2=UINT(**{'sizeinbytes': 2, 'default': 0}) 0354 self.__field_dunno2.readfrombuffer(buf) 0355 self.__field_dunno3=UINT(**{'sizeinbytes': 1, 'default': 5}) 0356 self.__field_dunno3.readfrombuffer(buf) 0357 self.__field_dunno4=UINT(**{'sizeinbytes': 4, 'default': 0}) 0358 self.__field_dunno4.readfrombuffer(buf) 0359 self.__field_email=USTRING(**{'sizeinbytes': 49, 'encoding': PHONE_ENCODING, 'terminator': None, 'pascal': True, 'default': ""}) 0360 self.__field_email.readfrombuffer(buf) 0361 self._bufferendoffset=buf.getcurrentoffset() 0362 0363 0364 def __getfield_valid(self): 0365 try: self.__field_valid 0366 except: 0367 self.__field_valid=UINT(**{'sizeinbytes': 1, 'default': 0}) 0368 return self.__field_valid.getvalue() 0369 0370 def __setfield_valid(self, value): 0371 if isinstance(value,UINT): 0372 self.__field_valid=value 0373 else: 0374 self.__field_valid=UINT(value,**{'sizeinbytes': 1, 'default': 0}) 0375 0376 def __delfield_valid(self): del self.__field_valid 0377 0378 valid=property(__getfield_valid, __setfield_valid, __delfield_valid, None) 0379 0380 def __getfield_dunno1(self): 0381 try: self.__field_dunno1 0382 except: 0383 self.__field_dunno1=UINT(**{'sizeinbytes': 1, 'default': 1}) 0384 return self.__field_dunno1.getvalue() 0385 0386 def __setfield_dunno1(self, value): 0387 if isinstance(value,UINT): 0388 self.__field_dunno1=value 0389 else: 0390 self.__field_dunno1=UINT(value,**{'sizeinbytes': 1, 'default': 1}) 0391 0392 def __delfield_dunno1(self): del self.__field_dunno1 0393 0394 dunno1=property(__getfield_dunno1, __setfield_dunno1, __delfield_dunno1, None) 0395 0396 def __getfield_dunno2(self): 0397 try: self.__field_dunno2 0398 except: 0399 self.__field_dunno2=UINT(**{'sizeinbytes': 2, 'default': 0}) 0400 return self.__field_dunno2.getvalue() 0401 0402 def __setfield_dunno2(self, value): 0403 if isinstance(value,UINT): 0404 self.__field_dunno2=value 0405 else: 0406 self.__field_dunno2=UINT(value,**{'sizeinbytes': 2, 'default': 0}) 0407 0408 def __delfield_dunno2(self): del self.__field_dunno2 0409 0410 dunno2=property(__getfield_dunno2, __setfield_dunno2, __delfield_dunno2, None) 0411 0412 def __getfield_dunno3(self): 0413 try: self.__field_dunno3 0414 except: 0415 self.__field_dunno3=UINT(**{'sizeinbytes': 1, 'default': 5}) 0416 return self.__field_dunno3.getvalue() 0417 0418 def __setfield_dunno3(self, value): 0419 if isinstance(value,UINT): 0420 self.__field_dunno3=value 0421 else: 0422 self.__field_dunno3=UINT(value,**{'sizeinbytes': 1, 'default': 5}) 0423 0424 def __delfield_dunno3(self): del self.__field_dunno3 0425 0426 dunno3=property(__getfield_dunno3, __setfield_dunno3, __delfield_dunno3, None) 0427 0428 def __getfield_dunno4(self): 0429 try: self.__field_dunno4 0430 except: 0431 self.__field_dunno4=UINT(**{'sizeinbytes': 4, 'default': 0}) 0432 return self.__field_dunno4.getvalue() 0433 0434 def __setfield_dunno4(self, value): 0435 if isinstance(value,UINT): 0436 self.__field_dunno4=value 0437 else: 0438 self.__field_dunno4=UINT(value,**{'sizeinbytes': 4, 'default': 0}) 0439 0440 def __delfield_dunno4(self): del self.__field_dunno4 0441 0442 dunno4=property(__getfield_dunno4, __setfield_dunno4, __delfield_dunno4, None) 0443 0444 def __getfield_email(self): 0445 try: self.__field_email 0446 except: 0447 self.__field_email=USTRING(**{'sizeinbytes': 49, 'encoding': PHONE_ENCODING, 'terminator': None, 'pascal': True, 'default': ""}) 0448 return self.__field_email.getvalue() 0449 0450 def __setfield_email(self, value): 0451 if isinstance(value,USTRING): 0452 self.__field_email=value 0453 else: 0454 self.__field_email=USTRING(value,**{'sizeinbytes': 49, 'encoding': PHONE_ENCODING, 'terminator': None, 'pascal': True, 'default': ""}) 0455 0456 def __delfield_email(self): del self.__field_email 0457 0458 email=property(__getfield_email, __setfield_email, __delfield_email, None) 0459 0460 def iscontainer(self): 0461 return True 0462 0463 def containerelements(self): 0464 yield ('valid', self.__field_valid, None) 0465 yield ('dunno1', self.__field_dunno1, None) 0466 yield ('dunno2', self.__field_dunno2, None) 0467 yield ('dunno3', self.__field_dunno3, None) 0468 yield ('dunno4', self.__field_dunno4, None) 0469 yield ('email', self.__field_email, None) 0470 0471 0472 0473 0474 class pbentry(BaseProtogenClass): 0475 __fields=['slot', 'pad2', 'pad3', 'name', 'numbers', 'emails', 'dunno', 'web_page', 'pad5'] 0476 0477 def __init__(self, *args, **kwargs): 0478 dict={} 0479 # What was supplied to this function 0480 dict.update(kwargs) 0481 # Parent constructor 0482 super(pbentry,self).__init__(**dict) 0483 if self.__class__ is pbentry: 0484 self._update(args,dict) 0485 0486 0487 def getfields(self): 0488 return self.__fields 0489 0490 0491 def _update(self, args, kwargs): 0492 super(pbentry,self)._update(args,kwargs) 0493 keys=kwargs.keys() 0494 for key in keys: 0495 if key in self.__fields: 0496 setattr(self, key, kwargs[key]) 0497 del kwargs[key] 0498 # Were any unrecognized kwargs passed in? 0499 if __debug__: 0500 self._complainaboutunusedargs(pbentry,kwargs) 0501 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 0502 # Make all P fields that haven't already been constructed 0503 0504 0505 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 0506 'Writes this packet to the supplied buffer' 0507 self._bufferstartoffset=buf.getcurrentoffset() 0508 self.__field_slot.writetobuffer(buf) 0509 try: self.__field_pad2 0510 except: 0511 self.__field_pad2=UINT(**{'sizeinbytes': 2, 'default': 0x0101}) 0512 self.__field_pad2.writetobuffer(buf) 0513 try: self.__field_pad3 0514 except: 0515 self.__field_pad3=UINT(**{'sizeinbytes': 1, 'default': 0}) 0516 self.__field_pad3.writetobuffer(buf) 0517 self.__field_name.writetobuffer(buf) 0518 try: self.__field_numbers 0519 except: 0520 self.__field_numbers=LIST(**{'length': MAXPHONENUMBERS, 'elementclass': pbnumber, 'createdefault': True}) 0521 self.__field_numbers.writetobuffer(buf) 0522 try: self.__field_emails 0523 except: 0524 self.__field_emails=LIST(**{'length': MAXEMAILS, 'elementclass': pbemail, 'createdefault': True}) 0525 self.__field_emails.writetobuffer(buf) 0526 try: self.__field_dunno 0527 except: 0528 self.__field_dunno=UINT(**{'sizeinbytes': 2, 'default': 0x0001}) 0529 self.__field_dunno.writetobuffer(buf) 0530 try: self.__field_web_page 0531 except: 0532 self.__field_web_page=USTRING(**{'sizeinbytes': 49, 'encoding': PHONE_ENCODING, 'terminator': None, 'pascal': True, 'default': ""}) 0533 self.__field_web_page.writetobuffer(buf) 0534 try: self.__field_pad5 0535 except: 0536 self.__field_pad5=UNKNOWN(**{'sizeinbytes': 81}) 0537 self.__field_pad5.writetobuffer(buf) 0538 self._bufferendoffset=buf.getcurrentoffset() 0539 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 0540 0541 0542 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 0543 'Reads this packet from the supplied buffer' 0544 self._bufferstartoffset=buf.getcurrentoffset() 0545 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 0546 self.__field_slot=UINT(**{'sizeinbytes': 2}) 0547 self.__field_slot.readfrombuffer(buf) 0548 self.__field_pad2=UINT(**{'sizeinbytes': 2, 'default': 0x0101}) 0549 self.__field_pad2.readfrombuffer(buf) 0550 self.__field_pad3=UINT(**{'sizeinbytes': 1, 'default': 0}) 0551 self.__field_pad3.readfrombuffer(buf) 0552 self.__field_name=USTRING(**{'sizeinbytes': 37, 'encoding': PHONE_ENCODING, 'terminator': None, 'pascal': True}) 0553 self.__field_name.readfrombuffer(buf) 0554 self.__field_numbers=LIST(**{'length': MAXPHONENUMBERS, 'elementclass': pbnumber, 'createdefault': True}) 0555 self.__field_numbers.readfrombuffer(buf) 0556 self.__field_emails=LIST(**{'length': MAXEMAILS, 'elementclass': pbemail, 'createdefault': True}) 0557 self.__field_emails.readfrombuffer(buf) 0558 self.__field_dunno=UINT(**{'sizeinbytes': 2, 'default': 0x0001}) 0559 self.__field_dunno.readfrombuffer(buf) 0560 self.__field_web_page=USTRING(**{'sizeinbytes': 49, 'encoding': PHONE_ENCODING, 'terminator': None, 'pascal': True, 'default': ""}) 0561 self.__field_web_page.readfrombuffer(buf) 0562 self.__field_pad5=UNKNOWN(**{'sizeinbytes': 81}) 0563 self.__field_pad5.readfrombuffer(buf) 0564 self._bufferendoffset=buf.getcurrentoffset() 0565 0566 0567 def __getfield_slot(self): 0568 return self.__field_slot.getvalue() 0569 0570 def __setfield_slot(self, value): 0571 if isinstance(value,UINT): 0572 self.__field_slot=value 0573 else: 0574 self.__field_slot=UINT(value,**{'sizeinbytes': 2}) 0575 0576 def __delfield_slot(self): del self.__field_slot 0577 0578 slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None) 0579 0580 def __getfield_pad2(self): 0581 try: self.__field_pad2 0582 except: 0583 self.__field_pad2=UINT(**{'sizeinbytes': 2, 'default': 0x0101}) 0584 return self.__field_pad2.getvalue() 0585 0586 def __setfield_pad2(self, value): 0587 if isinstance(value,UINT): 0588 self.__field_pad2=value 0589 else: 0590 self.__field_pad2=UINT(value,**{'sizeinbytes': 2, 'default': 0x0101}) 0591 0592 def __delfield_pad2(self): del self.__field_pad2 0593 0594 pad2=property(__getfield_pad2, __setfield_pad2, __delfield_pad2, None) 0595 0596 def __getfield_pad3(self): 0597 try: self.__field_pad3 0598 except: 0599 self.__field_pad3=UINT(**{'sizeinbytes': 1, 'default': 0}) 0600 return self.__field_pad3.getvalue() 0601 0602 def __setfield_pad3(self, value): 0603 if isinstance(value,UINT): 0604 self.__field_pad3=value 0605 else: 0606 self.__field_pad3=UINT(value,**{'sizeinbytes': 1, 'default': 0}) 0607 0608 def __delfield_pad3(self): del self.__field_pad3 0609 0610 pad3=property(__getfield_pad3, __setfield_pad3, __delfield_pad3, None) 0611 0612 def __getfield_name(self): 0613 return self.__field_name.getvalue() 0614 0615 def __setfield_name(self, value): 0616 if isinstance(value,USTRING): 0617 self.__field_name=value 0618 else: 0619 self.__field_name=USTRING(value,**{'sizeinbytes': 37, 'encoding': PHONE_ENCODING, 'terminator': None, 'pascal': True}) 0620 0621 def __delfield_name(self): del self.__field_name 0622 0623 name=property(__getfield_name, __setfield_name, __delfield_name, None) 0624 0625 def __getfield_numbers(self): 0626 try: self.__field_numbers 0627 except: 0628 self.__field_numbers=LIST(**{'length': MAXPHONENUMBERS, 'elementclass': pbnumber, 'createdefault': True}) 0629 return self.__field_numbers.getvalue() 0630 0631 def __setfield_numbers(self, value): 0632 if isinstance(value,LIST): 0633 self.__field_numbers=value 0634 else: 0635 self.__field_numbers=LIST(value,**{'length': MAXPHONENUMBERS, 'elementclass': pbnumber, 'createdefault': True}) 0636 0637 def __delfield_numbers(self): del self.__field_numbers 0638 0639 numbers=property(__getfield_numbers, __setfield_numbers, __delfield_numbers, None) 0640 0641 def __getfield_emails(self): 0642 try: self.__field_emails 0643 except: 0644 self.__field_emails=LIST(**{'length': MAXEMAILS, 'elementclass': pbemail, 'createdefault': True}) 0645 return self.__field_emails.getvalue() 0646 0647 def __setfield_emails(self, value): 0648 if isinstance(value,LIST): 0649 self.__field_emails=value 0650 else: 0651 self.__field_emails=LIST(value,**{'length': MAXEMAILS, 'elementclass': pbemail, 'createdefault': True}) 0652 0653 def __delfield_emails(self): del self.__field_emails 0654 0655 emails=property(__getfield_emails, __setfield_emails, __delfield_emails, None) 0656 0657 def __getfield_dunno(self): 0658 try: self.__field_dunno 0659 except: 0660 self.__field_dunno=UINT(**{'sizeinbytes': 2, 'default': 0x0001}) 0661 return self.__field_dunno.getvalue() 0662 0663 def __setfield_dunno(self, value): 0664 if isinstance(value,UINT): 0665 self.__field_dunno=value 0666 else: 0667 self.__field_dunno=UINT(value,**{'sizeinbytes': 2, 'default': 0x0001}) 0668 0669 def __delfield_dunno(self): del self.__field_dunno 0670 0671 dunno=property(__getfield_dunno, __setfield_dunno, __delfield_dunno, None) 0672 0673 def __getfield_web_page(self): 0674 try: self.__field_web_page 0675 except: 0676 self.__field_web_page=USTRING(**{'sizeinbytes': 49, 'encoding': PHONE_ENCODING, 'terminator': None, 'pascal': True, 'default': ""}) 0677 return self.__field_web_page.getvalue() 0678 0679 def __setfield_web_page(self, value): 0680 if isinstance(value,USTRING): 0681 self.__field_web_page=value 0682 else: 0683 self.__field_web_page=USTRING(value,**{'sizeinbytes': 49, 'encoding': PHONE_ENCODING, 'terminator': None, 'pascal': True, 'default': ""}) 0684 0685 def __delfield_web_page(self): del self.__field_web_page 0686 0687 web_page=property(__getfield_web_page, __setfield_web_page, __delfield_web_page, None) 0688 0689 def __getfield_pad5(self): 0690 try: self.__field_pad5 0691 except: 0692 self.__field_pad5=UNKNOWN(**{'sizeinbytes': 81}) 0693 return self.__field_pad5.getvalue() 0694 0695 def __setfield_pad5(self, value): 0696 if isinstance(value,UNKNOWN): 0697 self.__field_pad5=value 0698 else: 0699 self.__field_pad5=UNKNOWN(value,**{'sizeinbytes': 81}) 0700 0701 def __delfield_pad5(self): del self.__field_pad5 0702 0703 pad5=property(__getfield_pad5, __setfield_pad5, __delfield_pad5, None) 0704 0705 def iscontainer(self): 0706 return True 0707 0708 def containerelements(self): 0709 yield ('slot', self.__field_slot, None) 0710 yield ('pad2', self.__field_pad2, None) 0711 yield ('pad3', self.__field_pad3, None) 0712 yield ('name', self.__field_name, None) 0713 yield ('numbers', self.__field_numbers, None) 0714 yield ('emails', self.__field_emails, None) 0715 yield ('dunno', self.__field_dunno, None) 0716 yield ('web_page', self.__field_web_page, None) 0717 yield ('pad5', self.__field_pad5, None) 0718 0719 0720 0721 0722 class setphoneattribrequest(BaseProtogenClass): 0723 __fields=['cmd', 'cmd2', 'cmd3', 'flag', 'data'] 0724 0725 def __init__(self, *args, **kwargs): 0726 dict={} 0727 # What was supplied to this function 0728 dict.update(kwargs) 0729 # Parent constructor 0730 super(setphoneattribrequest,self).__init__(**dict) 0731 if self.__class__ is setphoneattribrequest: 0732 self._update(args,dict) 0733 0734 0735 def getfields(self): 0736 return self.__fields 0737 0738 0739 def _update(self, args, kwargs): 0740 super(setphoneattribrequest,self)._update(args,kwargs) 0741 keys=kwargs.keys() 0742 for key in keys: 0743 if key in self.__fields: 0744 setattr(self, key, kwargs[key]) 0745 del kwargs[key] 0746 # Were any unrecognized kwargs passed in? 0747 if __debug__: 0748 self._complainaboutunusedargs(setphoneattribrequest,kwargs) 0749 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 0750 # Make all P fields that haven't already been constructed 0751 0752 0753 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 0754 'Writes this packet to the supplied buffer' 0755 self._bufferstartoffset=buf.getcurrentoffset() 0756 try: self.__field_cmd 0757 except: 0758 self.__field_cmd=UINT(**{'sizeinbytes': 1, 'constant': 0x27}) 0759 self.__field_cmd.writetobuffer(buf) 0760 try: self.__field_cmd2 0761 except: 0762 self.__field_cmd2=UINT(**{'sizeinbytes': 1, 'constant': 0xF0}) 0763 self.__field_cmd2.writetobuffer(buf) 0764 try: self.__field_cmd3 0765 except: 0766 self.__field_cmd3=UINT(**{'sizeinbytes': 1, 'constant': 0x7F}) 0767 self.__field_cmd3.writetobuffer(buf) 0768 try: self.__field_flag 0769 except: 0770 self.__field_flag=UINT(**{'sizeinbytes': 1, 'constant': 0x01}) 0771 self.__field_flag.writetobuffer(buf) 0772 try: self.__field_data 0773 except: 0774 self.__field_data=UINT(**{'sizeinbytes': 129, 'constant': 0x00}) 0775 self.__field_data.writetobuffer(buf) 0776 self._bufferendoffset=buf.getcurrentoffset() 0777 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 0778 0779 0780 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 0781 'Reads this packet from the supplied buffer' 0782 self._bufferstartoffset=buf.getcurrentoffset() 0783 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 0784 self.__field_cmd=UINT(**{'sizeinbytes': 1, 'constant': 0x27}) 0785 self.__field_cmd.readfrombuffer(buf) 0786 self.__field_cmd2=UINT(**{'sizeinbytes': 1, 'constant': 0xF0}) 0787 self.__field_cmd2.readfrombuffer(buf) 0788 self.__field_cmd3=UINT(**{'sizeinbytes': 1, 'constant': 0x7F}) 0789 self.__field_cmd3.readfrombuffer(buf) 0790 self.__field_flag=UINT(**{'sizeinbytes': 1, 'constant': 0x01}) 0791 self.__field_flag.readfrombuffer(buf) 0792 self.__field_data=UINT(**{'sizeinbytes': 129, 'constant': 0x00}) 0793 self.__field_data.readfrombuffer(buf) 0794 self._bufferendoffset=buf.getcurrentoffset() 0795 0796 0797 def __getfield_cmd(self): 0798 try: self.__field_cmd 0799 except: 0800 self.__field_cmd=UINT(**{'sizeinbytes': 1, 'constant': 0x27}) 0801 return self.__field_cmd.getvalue() 0802 0803 def __setfield_cmd(self, value): 0804 if isinstance(value,UINT): 0805 self.__field_cmd=value 0806 else: 0807 self.__field_cmd=UINT(value,**{'sizeinbytes': 1, 'constant': 0x27}) 0808 0809 def __delfield_cmd(self): del self.__field_cmd 0810 0811 cmd=property(__getfield_cmd, __setfield_cmd, __delfield_cmd, None) 0812 0813 def __getfield_cmd2(self): 0814 try: self.__field_cmd2 0815 except: 0816 self.__field_cmd2=UINT(**{'sizeinbytes': 1, 'constant': 0xF0}) 0817 return self.__field_cmd2.getvalue() 0818 0819 def __setfield_cmd2(self, value): 0820 if isinstance(value,UINT): 0821 self.__field_cmd2=value 0822 else: 0823 self.__field_cmd2=UINT(value,**{'sizeinbytes': 1, 'constant': 0xF0}) 0824 0825 def __delfield_cmd2(self): del self.__field_cmd2 0826 0827 cmd2=property(__getfield_cmd2, __setfield_cmd2, __delfield_cmd2, None) 0828 0829 def __getfield_cmd3(self): 0830 try: self.__field_cmd3 0831 except: 0832 self.__field_cmd3=UINT(**{'sizeinbytes': 1, 'constant': 0x7F}) 0833 return self.__field_cmd3.getvalue() 0834 0835 def __setfield_cmd3(self, value): 0836 if isinstance(value,UINT): 0837 self.__field_cmd3=value 0838 else: 0839 self.__field_cmd3=UINT(value,**{'sizeinbytes': 1, 'constant': 0x7F}) 0840 0841 def __delfield_cmd3(self): del self.__field_cmd3 0842 0843 cmd3=property(__getfield_cmd3, __setfield_cmd3, __delfield_cmd3, None) 0844 0845 def __getfield_flag(self): 0846 try: self.__field_flag 0847 except: 0848 self.__field_flag=UINT(**{'sizeinbytes': 1, 'constant': 0x01}) 0849 return self.__field_flag.getvalue() 0850 0851 def __setfield_flag(self, value): 0852 if isinstance(value,UINT): 0853 self.__field_flag=value 0854 else: 0855 self.__field_flag=UINT(value,**{'sizeinbytes': 1, 'constant': 0x01}) 0856 0857 def __delfield_flag(self): del self.__field_flag 0858 0859 flag=property(__getfield_flag, __setfield_flag, __delfield_flag, None) 0860 0861 def __getfield_data(self): 0862 try: self.__field_data 0863 except: 0864 self.__field_data=UINT(**{'sizeinbytes': 129, 'constant': 0x00}) 0865 return self.__field_data.getvalue() 0866 0867 def __setfield_data(self, value): 0868 if isinstance(value,UINT): 0869 self.__field_data=value 0870 else: 0871 self.__field_data=UINT(value,**{'sizeinbytes': 129, 'constant': 0x00}) 0872 0873 def __delfield_data(self): del self.__field_data 0874 0875 data=property(__getfield_data, __setfield_data, __delfield_data, None) 0876 0877 def iscontainer(self): 0878 return True 0879 0880 def containerelements(self): 0881 yield ('cmd', self.__field_cmd, None) 0882 yield ('cmd2', self.__field_cmd2, None) 0883 yield ('cmd3', self.__field_cmd3, None) 0884 yield ('flag', self.__field_flag, None) 0885 yield ('data', self.__field_data, None) 0886 0887 0888 0889 0890 class setphoneattribresponse(BaseProtogenClass): 0891 __fields=['cmd', 'cmd2', 'cmd3', 'flag', 'pad'] 0892 0893 def __init__(self, *args, **kwargs): 0894 dict={} 0895 # What was supplied to this function 0896 dict.update(kwargs) 0897 # Parent constructor 0898 super(setphoneattribresponse,self).__init__(**dict) 0899 if self.__class__ is setphoneattribresponse: 0900 self._update(args,dict) 0901 0902 0903 def getfields(self): 0904 return self.__fields 0905 0906 0907 def _update(self, args, kwargs): 0908 super(setphoneattribresponse,self)._update(args,kwargs) 0909 keys=kwargs.keys() 0910 for key in keys: 0911 if key in self.__fields: 0912 setattr(self, key, kwargs[key]) 0913 del kwargs[key] 0914 # Were any unrecognized kwargs passed in? 0915 if __debug__: 0916 self._complainaboutunusedargs(setphoneattribresponse,kwargs) 0917 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 0918 # Make all P fields that haven't already been constructed 0919 0920 0921 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 0922 'Writes this packet to the supplied buffer' 0923 self._bufferstartoffset=buf.getcurrentoffset() 0924 try: self.__field_cmd 0925 except: 0926 self.__field_cmd=UINT(**{'sizeinbytes': 1, 'constant': 0x27}) 0927 self.__field_cmd.writetobuffer(buf) 0928 try: self.__field_cmd2 0929 except: 0930 self.__field_cmd2=UINT(**{'sizeinbytes': 1, 'constant': 0xF0}) 0931 self.__field_cmd2.writetobuffer(buf) 0932 try: self.__field_cmd3 0933 except: 0934 self.__field_cmd3=UINT(**{'sizeinbytes': 1, 'constant': 0x7F}) 0935 self.__field_cmd3.writetobuffer(buf) 0936 self.__field_flag.writetobuffer(buf) 0937 try: self.__field_pad 0938 except: 0939 self.__field_pad=DATA() 0940 self.__field_pad.writetobuffer(buf) 0941 self._bufferendoffset=buf.getcurrentoffset() 0942 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 0943 0944 0945 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 0946 'Reads this packet from the supplied buffer' 0947 self._bufferstartoffset=buf.getcurrentoffset() 0948 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 0949 self.__field_cmd=UINT(**{'sizeinbytes': 1, 'constant': 0x27}) 0950 self.__field_cmd.readfrombuffer(buf) 0951 self.__field_cmd2=UINT(**{'sizeinbytes': 1, 'constant': 0xF0}) 0952 self.__field_cmd2.readfrombuffer(buf) 0953 self.__field_cmd3=UINT(**{'sizeinbytes': 1, 'constant': 0x7F}) 0954 self.__field_cmd3.readfrombuffer(buf) 0955 self.__field_flag=UINT(**{'sizeinbytes': 1}) 0956 self.__field_flag.readfrombuffer(buf) 0957 self.__field_pad=DATA() 0958 self.__field_pad.readfrombuffer(buf) 0959 self._bufferendoffset=buf.getcurrentoffset() 0960 0961 0962 def __getfield_cmd(self): 0963 try: self.__field_cmd 0964 except: 0965 self.__field_cmd=UINT(**{'sizeinbytes': 1, 'constant': 0x27}) 0966 return self.__field_cmd.getvalue() 0967 0968 def __setfield_cmd(self, value): 0969 if isinstance(value,UINT): 0970 self.__field_cmd=value 0971 else: 0972 self.__field_cmd=UINT(value,**{'sizeinbytes': 1, 'constant': 0x27}) 0973 0974 def __delfield_cmd(self): del self.__field_cmd 0975 0976 cmd=property(__getfield_cmd, __setfield_cmd, __delfield_cmd, None) 0977 0978 def __getfield_cmd2(self): 0979 try: self.__field_cmd2 0980 except: 0981 self.__field_cmd2=UINT(**{'sizeinbytes': 1, 'constant': 0xF0}) 0982 return self.__field_cmd2.getvalue() 0983 0984 def __setfield_cmd2(self, value): 0985 if isinstance(value,UINT): 0986 self.__field_cmd2=value 0987 else: 0988 self.__field_cmd2=UINT(value,**{'sizeinbytes': 1, 'constant': 0xF0}) 0989 0990 def __delfield_cmd2(self): del self.__field_cmd2 0991 0992 cmd2=property(__getfield_cmd2, __setfield_cmd2, __delfield_cmd2, None) 0993 0994 def __getfield_cmd3(self): 0995 try: self.__field_cmd3 0996 except: 0997 self.__field_cmd3=UINT(**{'sizeinbytes': 1, 'constant': 0x7F}) 0998 return self.__field_cmd3.getvalue() 0999 1000 def __setfield_cmd3(self, value): 1001 if isinstance(value,UINT): 1002 self.__field_cmd3=value 1003 else: 1004 self.__field_cmd3=UINT(value,**{'sizeinbytes': 1, 'constant': 0x7F}) 1005 1006 def __delfield_cmd3(self): del self.__field_cmd3 1007 1008 cmd3=property(__getfield_cmd3, __setfield_cmd3, __delfield_cmd3, None) 1009 1010 def __getfield_flag(self): 1011 return self.__field_flag.getvalue() 1012 1013 def __setfield_flag(self, value): 1014 if isinstance(value,UINT): 1015 self.__field_flag=value 1016 else: 1017 self.__field_flag=UINT(value,**{'sizeinbytes': 1}) 1018 1019 def __delfield_flag(self): del self.__field_flag 1020 1021 flag=property(__getfield_flag, __setfield_flag, __delfield_flag, None) 1022 1023 def __getfield_pad(self): 1024 try: self.__field_pad 1025 except: 1026 self.__field_pad=DATA() 1027 return self.__field_pad.getvalue() 1028 1029 def __setfield_pad(self, value): 1030 if isinstance(value,DATA): 1031 self.__field_pad=value 1032 else: 1033 self.__field_pad=DATA(value,) 1034 1035 def __delfield_pad(self): del self.__field_pad 1036 1037 pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None) 1038 1039 def iscontainer(self): 1040 return True 1041 1042 def containerelements(self): 1043 yield ('cmd', self.__field_cmd, None) 1044 yield ('cmd2', self.__field_cmd2, None) 1045 yield ('cmd3', self.__field_cmd3, None) 1046 yield ('flag', self.__field_flag, None) 1047 yield ('pad', self.__field_pad, None) 1048 1049 1050 1051 1052 class tosh_swapheaderrequest(BaseProtogenClass): 1053 "The bit in front on all toshiba request packets" 1054 __fields=['cmd', 'cmd2', 'command'] 1055 1056 def __init__(self, *args, **kwargs): 1057 dict={} 1058 # What was supplied to this function 1059 dict.update(kwargs) 1060 # Parent constructor 1061 super(tosh_swapheaderrequest,self).__init__(**dict) 1062 if self.__class__ is tosh_swapheaderrequest: 1063 self._update(args,dict) 1064 1065 1066 def getfields(self): 1067 return self.__fields 1068 1069 1070 def _update(self, args, kwargs): 1071 super(tosh_swapheaderrequest,self)._update(args,kwargs) 1072 keys=kwargs.keys() 1073 for key in keys: 1074 if key in self.__fields: 1075 setattr(self, key, kwargs[key]) 1076 del kwargs[key] 1077 # Were any unrecognized kwargs passed in? 1078 if __debug__: 1079 self._complainaboutunusedargs(tosh_swapheaderrequest,kwargs) 1080 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 1081 # Make all P fields that haven't already been constructed 1082 1083 1084 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 1085 'Writes this packet to the supplied buffer' 1086 self._bufferstartoffset=buf.getcurrentoffset() 1087 try: self.__field_cmd 1088 except: 1089 self.__field_cmd=UINT(**{'sizeinbytes': 1, 'constant': 0xF1}) 1090 self.__field_cmd.writetobuffer(buf) 1091 try: self.__field_cmd2 1092 except: 1093 self.__field_cmd2=UINT(**{'sizeinbytes': 1, 'constant': 0x0F}) 1094 self.__field_cmd2.writetobuffer(buf) 1095 self.__field_command.writetobuffer(buf) 1096 self._bufferendoffset=buf.getcurrentoffset() 1097 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 1098 1099 1100 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 1101 'Reads this packet from the supplied buffer' 1102 self._bufferstartoffset=buf.getcurrentoffset() 1103 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 1104 self.__field_cmd=UINT(**{'sizeinbytes': 1, 'constant': 0xF1}) 1105 self.__field_cmd.readfrombuffer(buf) 1106 self.__field_cmd2=UINT(**{'sizeinbytes': 1, 'constant': 0x0F}) 1107 self.__field_cmd2.readfrombuffer(buf) 1108 self.__field_command=UINT(**{'sizeinbytes': 1}) 1109 self.__field_command.readfrombuffer(buf) 1110 self._bufferendoffset=buf.getcurrentoffset() 1111 1112 1113 def __getfield_cmd(self): 1114 try: self.__field_cmd 1115 except: 1116 self.__field_cmd=UINT(**{'sizeinbytes': 1, 'constant': 0xF1}) 1117 return self.__field_cmd.getvalue() 1118 1119 def __setfield_cmd(self, value): 1120 if isinstance(value,UINT): 1121 self.__field_cmd=value 1122 else: 1123 self.__field_cmd=UINT(value,**{'sizeinbytes': 1, 'constant': 0xF1}) 1124 1125 def __delfield_cmd(self): del self.__field_cmd 1126 1127 cmd=property(__getfield_cmd, __setfield_cmd, __delfield_cmd, None) 1128 1129 def __getfield_cmd2(self): 1130 try: self.__field_cmd2 1131 except: 1132 self.__field_cmd2=UINT(**{'sizeinbytes': 1, 'constant': 0x0F}) 1133 return self.__field_cmd2.getvalue() 1134 1135 def __setfield_cmd2(self, value): 1136 if isinstance(value,UINT): 1137 self.__field_cmd2=value 1138 else: 1139 self.__field_cmd2=UINT(value,**{'sizeinbytes': 1, 'constant': 0x0F}) 1140 1141 def __delfield_cmd2(self): del self.__field_cmd2 1142 1143 cmd2=property(__getfield_cmd2, __setfield_cmd2, __delfield_cmd2, None) 1144 1145 def __getfield_command(self): 1146 return self.__field_command.getvalue() 1147 1148 def __setfield_command(self, value): 1149 if isinstance(value,UINT): 1150 self.__field_command=value 1151 else: 1152 self.__field_command=UINT(value,**{'sizeinbytes': 1}) 1153 1154 def __delfield_command(self): del self.__field_command 1155 1156 command=property(__getfield_command, __setfield_command, __delfield_command, None) 1157 1158 def iscontainer(self): 1159 return True 1160 1161 def containerelements(self): 1162 yield ('cmd', self.__field_cmd, None) 1163 yield ('cmd2', self.__field_cmd2, None) 1164 yield ('command', self.__field_command, None) 1165 1166 1167 1168 1169 class tosh_swapheaderresponse(BaseProtogenClass): 1170 "The bit in front on all toshiba request packets" 1171 __fields=['cmd', 'cmd2'] 1172 1173 def __init__(self, *args, **kwargs): 1174 dict={} 1175 # What was supplied to this function 1176 dict.update(kwargs) 1177 # Parent constructor 1178 super(tosh_swapheaderresponse,self).__init__(**dict) 1179 if self.__class__ is tosh_swapheaderresponse: 1180 self._update(args,dict) 1181 1182 1183 def getfields(self): 1184 return self.__fields 1185 1186 1187 def _update(self, args, kwargs): 1188 super(tosh_swapheaderresponse,self)._update(args,kwargs) 1189 keys=kwargs.keys() 1190 for key in keys: 1191 if key in self.__fields: 1192 setattr(self, key, kwargs[key]) 1193 del kwargs[key] 1194 # Were any unrecognized kwargs passed in? 1195 if __debug__: 1196 self._complainaboutunusedargs(tosh_swapheaderresponse,kwargs) 1197 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 1198 # Make all P fields that haven't already been constructed 1199 1200 1201 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 1202 'Writes this packet to the supplied buffer' 1203 self._bufferstartoffset=buf.getcurrentoffset() 1204 try: self.__field_cmd 1205 except: 1206 self.__field_cmd=UINT(**{'sizeinbytes': 1, 'constant': 0xF1}) 1207 self.__field_cmd.writetobuffer(buf) 1208 try: self.__field_cmd2 1209 except: 1210 self.__field_cmd2=UINT(**{'sizeinbytes': 1, 'constant': 0x0F}) 1211 self.__field_cmd2.writetobuffer(buf) 1212 self._bufferendoffset=buf.getcurrentoffset() 1213 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 1214 1215 1216 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 1217 'Reads this packet from the supplied buffer' 1218 self._bufferstartoffset=buf.getcurrentoffset() 1219 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 1220 self.__field_cmd=UINT(**{'sizeinbytes': 1, 'constant': 0xF1}) 1221 self.__field_cmd.readfrombuffer(buf) 1222 self.__field_cmd2=UINT(**{'sizeinbytes': 1, 'constant': 0x0F}) 1223 self.__field_cmd2.readfrombuffer(buf) 1224 self._bufferendoffset=buf.getcurrentoffset() 1225 1226 1227 def __getfield_cmd(self): 1228 try: self.__field_cmd 1229 except: 1230 self.__field_cmd=UINT(**{'sizeinbytes': 1, 'constant': 0xF1}) 1231 return self.__field_cmd.getvalue() 1232 1233 def __setfield_cmd(self, value): 1234 if isinstance(value,UINT): 1235 self.__field_cmd=value 1236 else: 1237 self.__field_cmd=UINT(value,**{'sizeinbytes': 1, 'constant': 0xF1}) 1238 1239 def __delfield_cmd(self): del self.__field_cmd 1240 1241 cmd=property(__getfield_cmd, __setfield_cmd, __delfield_cmd, None) 1242 1243 def __getfield_cmd2(self): 1244 try: self.__field_cmd2 1245 except: 1246 self.__field_cmd2=UINT(**{'sizeinbytes': 1, 'constant': 0x0F}) 1247 return self.__field_cmd2.getvalue() 1248 1249 def __setfield_cmd2(self, value): 1250 if isinstance(value,UINT): 1251 self.__field_cmd2=value 1252 else: 1253 self.__field_cmd2=UINT(value,**{'sizeinbytes': 1, 'constant': 0x0F}) 1254 1255 def __delfield_cmd2(self): del self.__field_cmd2 1256 1257 cmd2=property(__getfield_cmd2, __setfield_cmd2, __delfield_cmd2, None) 1258 1259 def iscontainer(self): 1260 return True 1261 1262 def containerelements(self): 1263 yield ('cmd', self.__field_cmd, None) 1264 yield ('cmd2', self.__field_cmd2, None) 1265 1266 1267 1268 1269 class tosh_getpbentryrequest(BaseProtogenClass): 1270 """ 1271 Read an entry from a slot 1272 """ 1273 __fields=['header', 'cmd', 'pad', 'data_type', 'entry_index', 'pad'] 1274 1275 def __init__(self, *args, **kwargs): 1276 dict={} 1277 # What was supplied to this function 1278 dict.update(kwargs) 1279 # Parent constructor 1280 super(tosh_getpbentryrequest,self).__init__(**dict) 1281 if self.__class__ is tosh_getpbentryrequest: 1282 self._update(args,dict) 1283 1284 1285 def getfields(self): 1286 return self.__fields 1287 1288 1289 def _update(self, args, kwargs): 1290 super(tosh_getpbentryrequest,self)._update(args,kwargs) 1291 keys=kwargs.keys() 1292 for key in keys: 1293 if key in self.__fields: 1294 setattr(self, key, kwargs[key]) 1295 del kwargs[key] 1296 # Were any unrecognized kwargs passed in? 1297 if __debug__: 1298 self._complainaboutunusedargs(tosh_getpbentryrequest,kwargs) 1299 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 1300 # Make all P fields that haven't already been constructed 1301 1302 1303 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 1304 'Writes this packet to the supplied buffer' 1305 self._bufferstartoffset=buf.getcurrentoffset() 1306 try: self.__field_header 1307 except: 1308 self.__field_header=tosh_swapheaderrequest(**{'command': 0x02}) 1309 self.__field_header.writetobuffer(buf) 1310 try: self.__field_cmd 1311 except: 1312 self.__field_cmd=UINT(**{'sizeinbytes': 2, 'constant': 0x03}) 1313 self.__field_cmd.writetobuffer(buf) 1314 try: self.__field_pad 1315 except: 1316 self.__field_pad=UINT(**{'sizeinbytes': 2, 'constant': 0x00}) 1317 self.__field_pad.writetobuffer(buf) 1318 try: self.__field_data_type 1319 except: 1320 self.__field_data_type=UINT(**{'sizeinbytes': 2, 'constant': 0x04}) 1321 self.__field_data_type.writetobuffer(buf) 1322 self.__field_entry_index.writetobuffer(buf) 1323 try: self.__field_pad 1324 except: 1325 self.__field_pad=UINT(**{'sizeinbytes': 2, 'constant': 0x00}) 1326 self.__field_pad.writetobuffer(buf) 1327 self._bufferendoffset=buf.getcurrentoffset() 1328 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 1329 1330 1331 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 1332 'Reads this packet from the supplied buffer' 1333 self._bufferstartoffset=buf.getcurrentoffset() 1334 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 1335 self.__field_header=tosh_swapheaderrequest(**{'command': 0x02}) 1336 self.__field_header.readfrombuffer(buf) 1337 self.__field_cmd=UINT(**{'sizeinbytes': 2, 'constant': 0x03}) 1338 self.__field_cmd.readfrombuffer(buf) 1339 self.__field_pad=UINT(**{'sizeinbytes': 2, 'constant': 0x00}) 1340 self.__field_pad.readfrombuffer(buf) 1341 self.__field_data_type=UINT(**{'sizeinbytes': 2, 'constant': 0x04}) 1342 self.__field_data_type.readfrombuffer(buf) 1343 self.__field_entry_index=UINT(**{'sizeinbytes': 2}) 1344 self.__field_entry_index.readfrombuffer(buf) 1345 self.__field_pad=UINT(**{'sizeinbytes': 2, 'constant': 0x00}) 1346 self.__field_pad.readfrombuffer(buf) 1347 self._bufferendoffset=buf.getcurrentoffset() 1348 1349 1350 def __getfield_header(self): 1351 try: self.__field_header 1352 except: 1353 self.__field_header=tosh_swapheaderrequest(**{'command': 0x02}) 1354 return self.__field_header.getvalue() 1355 1356 def __setfield_header(self, value): 1357 if isinstance(value,tosh_swapheaderrequest): 1358 self.__field_header=value 1359 else: 1360 self.__field_header=tosh_swapheaderrequest(value,**{'command': 0x02}) 1361 1362 def __delfield_header(self): del self.__field_header 1363 1364 header=property(__getfield_header, __setfield_header, __delfield_header, None) 1365 1366 def __getfield_cmd(self): 1367 try: self.__field_cmd 1368 except: 1369 self.__field_cmd=UINT(**{'sizeinbytes': 2, 'constant': 0x03}) 1370 return self.__field_cmd.getvalue() 1371 1372 def __setfield_cmd(self, value): 1373 if isinstance(value,UINT): 1374 self.__field_cmd=value 1375 else: 1376 self.__field_cmd=UINT(value,**{'sizeinbytes': 2, 'constant': 0x03}) 1377 1378 def __delfield_cmd(self): del self.__field_cmd 1379 1380 cmd=property(__getfield_cmd, __setfield_cmd, __delfield_cmd, None) 1381 1382 def __getfield_pad(self): 1383 try: self.__field_pad 1384 except: 1385 self.__field_pad=UINT(**{'sizeinbytes': 2, 'constant': 0x00}) 1386 return self.__field_pad.getvalue() 1387 1388 def __setfield_pad(self, value): 1389 if isinstance(value,UINT): 1390 self.__field_pad=value 1391 else: 1392 self.__field_pad=UINT(value,**{'sizeinbytes': 2, 'constant': 0x00}) 1393 1394 def __delfield_pad(self): del self.__field_pad 1395 1396 pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None) 1397 1398 def __getfield_data_type(self): 1399 try: self.__field_data_type 1400 except: 1401 self.__field_data_type=UINT(**{'sizeinbytes': 2, 'constant': 0x04}) 1402 return self.__field_data_type.getvalue() 1403 1404 def __setfield_data_type(self, value): 1405 if isinstance(value,UINT): 1406 self.__field_data_type=value 1407 else: 1408 self.__field_data_type=UINT(value,**{'sizeinbytes': 2, 'constant': 0x04}) 1409 1410 def __delfield_data_type(self): del self.__field_data_type 1411 1412 data_type=property(__getfield_data_type, __setfield_data_type, __delfield_data_type, None) 1413 1414 def __getfield_entry_index(self): 1415 return self.__field_entry_index.getvalue() 1416 1417 def __setfield_entry_index(self, value): 1418 if isinstance(value,UINT): 1419 self.__field_entry_index=value 1420 else: 1421 self.__field_entry_index=UINT(value,**{'sizeinbytes': 2}) 1422 1423 def __delfield_entry_index(self): del self.__field_entry_index 1424 1425 entry_index=property(__getfield_entry_index, __setfield_entry_index, __delfield_entry_index, None) 1426 1427 def __getfield_pad(self): 1428 try: self.__field_pad 1429 except: 1430 self.__field_pad=UINT(**{'sizeinbytes': 2, 'constant': 0x00}) 1431 return self.__field_pad.getvalue() 1432 1433 def __setfield_pad(self, value): 1434 if isinstance(value,UINT): 1435 self.__field_pad=value 1436 else: 1437 self.__field_pad=UINT(value,**{'sizeinbytes': 2, 'constant': 0x00}) 1438 1439 def __delfield_pad(self): del self.__field_pad 1440 1441 pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None) 1442 1443 def iscontainer(self): 1444 return True 1445 1446 def containerelements(self): 1447 yield ('header', self.__field_header, None) 1448 yield ('cmd', self.__field_cmd, None) 1449 yield ('pad', self.__field_pad, None) 1450 yield ('data_type', self.__field_data_type, None) 1451 yield ('entry_index', self.__field_entry_index, None) 1452 yield ('pad', self.__field_pad, None) 1453 1454 1455 1456 1457 class tosh_getpbentryresponse(BaseProtogenClass): 1458 __fields=['header', 'cmd', 'read', 'data_type', 'swap_ok'] 1459 1460 def __init__(self, *args, **kwargs): 1461 dict={} 1462 # What was supplied to this function 1463 dict.update(kwargs) 1464 # Parent constructor 1465 super(tosh_getpbentryresponse,self).__init__(**dict) 1466 if self.__class__ is tosh_getpbentryresponse: 1467 self._update(args,dict) 1468 1469 1470 def getfields(self): 1471 return self.__fields 1472 1473 1474 def _update(self, args, kwargs): 1475 super(tosh_getpbentryresponse,self)._update(args,kwargs) 1476 keys=kwargs.keys() 1477 for key in keys: 1478 if key in self.__fields: 1479 setattr(self, key, kwargs[key]) 1480 del kwargs[key] 1481 # Were any unrecognized kwargs passed in? 1482 if __debug__: 1483 self._complainaboutunusedargs(tosh_getpbentryresponse,kwargs) 1484 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 1485 # Make all P fields that haven't already been constructed 1486 1487 1488 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 1489 'Writes this packet to the supplied buffer' 1490 self._bufferstartoffset=buf.getcurrentoffset() 1491 try: self.__field_header 1492 except: 1493 self.__field_header=tosh_swapheaderresponse() 1494 self.__field_header.writetobuffer(buf) 1495 try: self.__field_cmd 1496 except: 1497 self.__field_cmd=UINT(**{'sizeinbytes': 1, 'constant': 0x02}) 1498 self.__field_cmd.writetobuffer(buf) 1499 try: self.__field_read 1500 except: 1501 self.__field_read=UINT(**{'sizeinbytes': 2, 'constant': 0x00}) 1502 self.__field_read.writetobuffer(buf) 1503 try: self.__field_data_type 1504 except: 1505 self.__field_data_type=UINT(**{'sizeinbytes': 2, 'constant': 0x04}) 1506 self.__field_data_type.writetobuffer(buf) 1507 self.__field_swap_ok.writetobuffer(buf) 1508 self._bufferendoffset=buf.getcurrentoffset() 1509 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 1510 1511 1512 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 1513 'Reads this packet from the supplied buffer' 1514 self._bufferstartoffset=buf.getcurrentoffset() 1515 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 1516 self.__field_header=tosh_swapheaderresponse() 1517 self.__field_header.readfrombuffer(buf) 1518 self.__field_cmd=UINT(**{'sizeinbytes': 1, 'constant': 0x02}) 1519 self.__field_cmd.readfrombuffer(buf) 1520 self.__field_read=UINT(**{'sizeinbytes': 2, 'constant': 0x00}) 1521 self.__field_read.readfrombuffer(buf) 1522 self.__field_data_type=UINT(**{'sizeinbytes': 2, 'constant': 0x04}) 1523 self.__field_data_type.readfrombuffer(buf) 1524 self.__field_swap_ok=UINT(**{'sizeinbytes': 4}) 1525 self.__field_swap_ok.readfrombuffer(buf) 1526 self._bufferendoffset=buf.getcurrentoffset() 1527 1528 1529 def __getfield_header(self): 1530 try: self.__field_header 1531 except: 1532 self.__field_header=tosh_swapheaderresponse() 1533 return self.__field_header.getvalue() 1534 1535 def __setfield_header(self, value): 1536 if isinstance(value,tosh_swapheaderresponse): 1537 self.__field_header=value 1538 else: 1539 self.__field_header=tosh_swapheaderresponse(value,) 1540 1541 def __delfield_header(self): del self.__field_header 1542 1543 header=property(__getfield_header, __setfield_header, __delfield_header, None) 1544 1545 def __getfield_cmd(self): 1546 try: self.__field_cmd 1547 except: 1548 self.__field_cmd=UINT(**{'sizeinbytes': 1, 'constant': 0x02}) 1549 return self.__field_cmd.getvalue() 1550 1551 def __setfield_cmd(self, value): 1552 if isinstance(value,UINT): 1553 self.__field_cmd=value 1554 else: 1555 self.__field_cmd=UINT(value,**{'sizeinbytes': 1, 'constant': 0x02}) 1556 1557 def __delfield_cmd(self): del self.__field_cmd 1558 1559 cmd=property(__getfield_cmd, __setfield_cmd, __delfield_cmd, None) 1560 1561 def __getfield_read(self): 1562 try: self.__field_read 1563 except: 1564 self.__field_read=UINT(**{'sizeinbytes': 2, 'constant': 0x00}) 1565 return self.__field_read.getvalue() 1566 1567 def __setfield_read(self, value): 1568 if isinstance(value,UINT): 1569 self.__field_read=value 1570 else: 1571 self.__field_read=UINT(value,**{'sizeinbytes': 2, 'constant': 0x00}) 1572 1573 def __delfield_read(self): del self.__field_read 1574 1575 read=property(__getfield_read, __setfield_read, __delfield_read, None) 1576 1577 def __getfield_data_type(self): 1578 try: self.__field_data_type 1579 except: 1580 self.__field_data_type=UINT(**{'sizeinbytes': 2, 'constant': 0x04}) 1581 return self.__field_data_type.getvalue() 1582 1583 def __setfield_data_type(self, value): 1584 if isinstance(value,UINT): 1585 self.__field_data_type=value 1586 else: 1587 self.__field_data_type=UINT(value,**{'sizeinbytes': 2, 'constant': 0x04}) 1588 1589 def __delfield_data_type(self): del self.__field_data_type 1590 1591 data_type=property(__getfield_data_type, __setfield_data_type, __delfield_data_type, None) 1592 1593 def __getfield_swap_ok(self): 1594 return self.__field_swap_ok.getvalue() 1595 1596 def __setfield_swap_ok(self, value): 1597 if isinstance(value,UINT): 1598 self.__field_swap_ok=value 1599 else: 1600 self.__field_swap_ok=UINT(value,**{'sizeinbytes': 4}) 1601 1602 def __delfield_swap_ok(self): del self.__field_swap_ok 1603 1604 swap_ok=property(__getfield_swap_ok, __setfield_swap_ok, __delfield_swap_ok, None) 1605 1606 def iscontainer(self): 1607 return True 1608 1609 def containerelements(self): 1610 yield ('header', self.__field_header, None) 1611 yield ('cmd', self.__field_cmd, None) 1612 yield ('read', self.__field_read, None) 1613 yield ('data_type', self.__field_data_type, None) 1614 yield ('swap_ok', self.__field_swap_ok, None) 1615 1616 1617 1618 1619 class tosh_setpbentryrequest(BaseProtogenClass): 1620 """ 1621 Inserts a new entry into an empty slot 1622 """ 1623 __fields=['header', 'cmd', 'write', 'data_type', 'entry_index', 'pad'] 1624 1625 def __init__(self, *args, **kwargs): 1626 dict={} 1627 # What was supplied to this function 1628 dict.update(kwargs) 1629 # Parent constructor 1630 super(tosh_setpbentryrequest,self).__init__(**dict) 1631 if self.__class__ is tosh_setpbentryrequest: 1632 self._update(args,dict) 1633 1634 1635 def getfields(self): 1636 return self.__fields 1637 1638 1639 def _update(self, args, kwargs): 1640 super(tosh_setpbentryrequest,self)._update(args,kwargs) 1641 keys=kwargs.keys() 1642 for key in keys: 1643 if key in self.__fields: 1644 setattr(self, key, kwargs[key]) 1645 del kwargs[key] 1646 # Were any unrecognized kwargs passed in? 1647 if __debug__: 1648 self._complainaboutunusedargs(tosh_setpbentryrequest,kwargs) 1649 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 1650 # Make all P fields that haven't already been constructed 1651 1652 1653 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 1654 'Writes this packet to the supplied buffer' 1655 self._bufferstartoffset=buf.getcurrentoffset() 1656 try: self.__field_header 1657 except: 1658 self.__field_header=tosh_swapheaderrequest(**{'command': 0x02}) 1659 self.__field_header.writetobuffer(buf) 1660 try: self.__field_cmd 1661 except: 1662 self.__field_cmd=UINT(**{'sizeinbytes': 2, 'constant': 0x03}) 1663 self.__field_cmd.writetobuffer(buf) 1664 try: self.__field_write 1665 except: 1666 self.__field_write=UINT(**{'sizeinbytes': 2, 'constant': 0x100}) 1667 self.__field_write.writetobuffer(buf) 1668 try: self.__field_data_type 1669 except: 1670 self.__field_data_type=UINT(**{'sizeinbytes': 2, 'constant': 0x04}) 1671 self.__field_data_type.writetobuffer(buf) 1672 self.__field_entry_index.writetobuffer(buf) 1673 try: self.__field_pad 1674 except: 1675 self.__field_pad=UINT(**{'sizeinbytes': 2, 'constant': 0x00}) 1676 self.__field_pad.writetobuffer(buf) 1677 self._bufferendoffset=buf.getcurrentoffset() 1678 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 1679 1680 1681 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 1682 'Reads this packet from the supplied buffer' 1683 self._bufferstartoffset=buf.getcurrentoffset() 1684 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 1685 self.__field_header=tosh_swapheaderrequest(**{'command': 0x02}) 1686 self.__field_header.readfrombuffer(buf) 1687 self.__field_cmd=UINT(**{'sizeinbytes': 2, 'constant': 0x03}) 1688 self.__field_cmd.readfrombuffer(buf) 1689 self.__field_write=UINT(**{'sizeinbytes': 2, 'constant': 0x100}) 1690 self.__field_write.readfrombuffer(buf) 1691 self.__field_data_type=UINT(**{'sizeinbytes': 2, 'constant': 0x04}) 1692 self.__field_data_type.readfrombuffer(buf) 1693 self.__field_entry_index=UINT(**{'sizeinbytes': 2}) 1694 self.__field_entry_index.readfrombuffer(buf) 1695 self.__field_pad=UINT(**{'sizeinbytes': 2, 'constant': 0x00}) 1696 self.__field_pad.readfrombuffer(buf) 1697 self._bufferendoffset=buf.getcurrentoffset() 1698 1699 1700 def __getfield_header(self): 1701 try: self.__field_header 1702 except: 1703 self.__field_header=tosh_swapheaderrequest(**{'command': 0x02}) 1704 return self.__field_header.getvalue() 1705 1706 def __setfield_header(self, value): 1707 if isinstance(value,tosh_swapheaderrequest): 1708 self.__field_header=value 1709 else: 1710 self.__field_header=tosh_swapheaderrequest(value,**{'command': 0x02}) 1711 1712 def __delfield_header(self): del self.__field_header 1713 1714 header=property(__getfield_header, __setfield_header, __delfield_header, None) 1715 1716 def __getfield_cmd(self): 1717 try: self.__field_cmd 1718 except: 1719 self.__field_cmd=UINT(**{'sizeinbytes': 2, 'constant': 0x03}) 1720 return self.__field_cmd.getvalue() 1721 1722 def __setfield_cmd(self, value): 1723 if isinstance(value,UINT): 1724 self.__field_cmd=value 1725 else: 1726 self.__field_cmd=UINT(value,**{'sizeinbytes': 2, 'constant': 0x03}) 1727 1728 def __delfield_cmd(self): del self.__field_cmd 1729 1730 cmd=property(__getfield_cmd, __setfield_cmd, __delfield_cmd, None) 1731 1732 def __getfield_write(self): 1733 try: self.__field_write 1734 except: 1735 self.__field_write=UINT(**{'sizeinbytes': 2, 'constant': 0x100}) 1736 return self.__field_write.getvalue() 1737 1738 def __setfield_write(self, value): 1739 if isinstance(value,UINT): 1740 self.__field_write=value 1741 else: 1742 self.__field_write=UINT(value,**{'sizeinbytes': 2, 'constant': 0x100}) 1743 1744 def __delfield_write(self): del self.__field_write 1745 1746 write=property(__getfield_write, __setfield_write, __delfield_write, None) 1747 1748 def __getfield_data_type(self): 1749 try: self.__field_data_type 1750 except: 1751 self.__field_data_type=UINT(**{'sizeinbytes': 2, 'constant': 0x04}) 1752 return self.__field_data_type.getvalue() 1753 1754 def __setfield_data_type(self, value): 1755 if isinstance(value,UINT): 1756 self.__field_data_type=value 1757 else: 1758 self.__field_data_type=UINT(value,**{'sizeinbytes': 2, 'constant': 0x04}) 1759 1760 def __delfield_data_type(self): del self.__field_data_type 1761 1762 data_type=property(__getfield_data_type, __setfield_data_type, __delfield_data_type, None) 1763 1764 def __getfield_entry_index(self): 1765 return self.__field_entry_index.getvalue() 1766 1767 def __setfield_entry_index(self, value): 1768 if isinstance(value,UINT): 1769 self.__field_entry_index=value 1770 else: 1771 self.__field_entry_index=UINT(value,**{'sizeinbytes': 2}) 1772 1773 def __delfield_entry_index(self): del self.__field_entry_index 1774 1775 entry_index=property(__getfield_entry_index, __setfield_entry_index, __delfield_entry_index, None) 1776 1777 def __getfield_pad(self): 1778 try: self.__field_pad 1779 except: 1780 self.__field_pad=UINT(**{'sizeinbytes': 2, 'constant': 0x00}) 1781 return self.__field_pad.getvalue() 1782 1783 def __setfield_pad(self, value): 1784 if isinstance(value,UINT): 1785 self.__field_pad=value 1786 else: 1787 self.__field_pad=UINT(value,**{'sizeinbytes': 2, 'constant': 0x00}) 1788 1789 def __delfield_pad(self): del self.__field_pad 1790 1791 pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None) 1792 1793 def iscontainer(self): 1794 return True 1795 1796 def containerelements(self): 1797 yield ('header', self.__field_header, None) 1798 yield ('cmd', self.__field_cmd, None) 1799 yield ('write', self.__field_write, None) 1800 yield ('data_type', self.__field_data_type, None) 1801 yield ('entry_index', self.__field_entry_index, None) 1802 yield ('pad', self.__field_pad, None) 1803 1804 1805 1806 1807 class tosh_setpbentryresponse(BaseProtogenClass): 1808 __fields=['header', 'cmd', 'swap_ok'] 1809 1810 def __init__(self, *args, **kwargs): 1811 dict={} 1812 # What was supplied to this function 1813 dict.update(kwargs) 1814 # Parent constructor 1815 super(tosh_setpbentryresponse,self).__init__(**dict) 1816 if self.__class__ is tosh_setpbentryresponse: 1817 self._update(args,dict) 1818 1819 1820 def getfields(self): 1821 return self.__fields 1822 1823 1824 def _update(self, args, kwargs): 1825 super(tosh_setpbentryresponse,self)._update(args,kwargs) 1826 keys=kwargs.keys() 1827 for key in keys: 1828 if key in self.__fields: 1829 setattr(self, key, kwargs[key]) 1830 del kwargs[key] 1831 # Were any unrecognized kwargs passed in? 1832 if __debug__: 1833 self._complainaboutunusedargs(tosh_setpbentryresponse,kwargs) 1834 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 1835 # Make all P fields that haven't already been constructed 1836 1837 1838 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 1839 'Writes this packet to the supplied buffer' 1840 self._bufferstartoffset=buf.getcurrentoffset() 1841 try: self.__field_header 1842 except: 1843 self.__field_header=tosh_swapheaderresponse() 1844 self.__field_header.writetobuffer(buf) 1845 try: self.__field_cmd 1846 except: 1847 self.__field_cmd=UINT(**{'sizeinbytes': 1, 'constant': 0x02}) 1848 self.__field_cmd.writetobuffer(buf) 1849 self.__field_swap_ok.writetobuffer(buf) 1850 self._bufferendoffset=buf.getcurrentoffset() 1851 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 1852 1853 1854 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 1855 'Reads this packet from the supplied buffer' 1856 self._bufferstartoffset=buf.getcurrentoffset() 1857 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 1858 self.__field_header=tosh_swapheaderresponse() 1859 self.__field_header.readfrombuffer(buf) 1860 self.__field_cmd=UINT(**{'sizeinbytes': 1, 'constant': 0x02}) 1861 self.__field_cmd.readfrombuffer(buf) 1862 self.__field_swap_ok=UINT(**{'sizeinbytes': 4}) 1863 self.__field_swap_ok.readfrombuffer(buf) 1864 self._bufferendoffset=buf.getcurrentoffset() 1865 1866 1867 def __getfield_header(self): 1868 try: self.__field_header 1869 except: 1870 self.__field_header=tosh_swapheaderresponse() 1871 return self.__field_header.getvalue() 1872 1873 def __setfield_header(self, value): 1874 if isinstance(value,tosh_swapheaderresponse): 1875 self.__field_header=value 1876 else: 1877 self.__field_header=tosh_swapheaderresponse(value,) 1878 1879 def __delfield_header(self): del self.__field_header 1880 1881 header=property(__getfield_header, __setfield_header, __delfield_header, None) 1882 1883 def __getfield_cmd(self): 1884 try: self.__field_cmd 1885 except: 1886 self.__field_cmd=UINT(**{'sizeinbytes': 1, 'constant': 0x02}) 1887 return self.__field_cmd.getvalue() 1888 1889 def __setfield_cmd(self, value): 1890 if isinstance(value,UINT): 1891 self.__field_cmd=value 1892 else: 1893 self.__field_cmd=UINT(value,**{'sizeinbytes': 1, 'constant': 0x02}) 1894 1895 def __delfield_cmd(self): del self.__field_cmd 1896 1897 cmd=property(__getfield_cmd, __setfield_cmd, __delfield_cmd, None) 1898 1899 def __getfield_swap_ok(self): 1900 return self.__field_swap_ok.getvalue() 1901 1902 def __setfield_swap_ok(self, value): 1903 if isinstance(value,UINT): 1904 self.__field_swap_ok=value 1905 else: 1906 self.__field_swap_ok=UINT(value,**{'sizeinbytes': 4}) 1907 1908 def __delfield_swap_ok(self): del self.__field_swap_ok 1909 1910 swap_ok=property(__getfield_swap_ok, __setfield_swap_ok, __delfield_swap_ok, None) 1911 1912 def iscontainer(self): 1913 return True 1914 1915 def containerelements(self): 1916 yield ('header', self.__field_header, None) 1917 yield ('cmd', self.__field_cmd, None) 1918 yield ('swap_ok', self.__field_swap_ok, None) 1919 1920 1921 1922 1923 class tosh_modifypbentryrequest(BaseProtogenClass): 1924 """ 1925 Modifies/deletes an existing entry 1926 delete occurs if the swap file does not exist when this command 1927 is issued 1928 """ 1929 __fields=['header', 'cmd', 'write', 'data_type', 'entry_index', 'pad'] 1930 1931 def __init__(self, *args, **kwargs): 1932 dict={} 1933 # What was supplied to this function 1934 dict.update(kwargs) 1935 # Parent constructor 1936 super(tosh_modifypbentryrequest,self).__init__(**dict) 1937 if self.__class__ is tosh_modifypbentryrequest: 1938 self._update(args,dict) 1939 1940 1941 def getfields(self): 1942 return self.__fields 1943 1944 1945 def _update(self, args, kwargs): 1946 super(tosh_modifypbentryrequest,self)._update(args,kwargs) 1947 keys=kwargs.keys() 1948 for key in keys: 1949 if key in self.__fields: 1950 setattr(self, key, kwargs[key]) 1951 del kwargs[key] 1952 # Were any unrecognized kwargs passed in? 1953 if __debug__: 1954 self._complainaboutunusedargs(tosh_modifypbentryrequest,kwargs) 1955 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 1956 # Make all P fields that haven't already been constructed 1957 1958 1959 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 1960 'Writes this packet to the supplied buffer' 1961 self._bufferstartoffset=buf.getcurrentoffset() 1962 try: self.__field_header 1963 except: 1964 self.__field_header=tosh_swapheaderrequest(**{'command': 0x02}) 1965 self.__field_header.writetobuffer(buf) 1966 try: self.__field_cmd 1967 except: 1968 self.__field_cmd=UINT(**{'sizeinbytes': 2, 'constant': 0x03}) 1969 self.__field_cmd.writetobuffer(buf) 1970 try: self.__field_write 1971 except: 1972 self.__field_write=UINT(**{'sizeinbytes': 2, 'constant': 0x200}) 1973 self.__field_write.writetobuffer(buf) 1974 try: self.__field_data_type 1975 except: 1976 self.__field_data_type=UINT(**{'sizeinbytes': 2, 'constant': 0x04}) 1977 self.__field_data_type.writetobuffer(buf) 1978 self.__field_entry_index.writetobuffer(buf) 1979 try: self.__field_pad 1980 except: 1981 self.__field_pad=UINT(**{'sizeinbytes': 2, 'constant': 0x00}) 1982 self.__field_pad.writetobuffer(buf) 1983 self._bufferendoffset=buf.getcurrentoffset() 1984 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 1985 1986 1987 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 1988 'Reads this packet from the supplied buffer' 1989 self._bufferstartoffset=buf.getcurrentoffset() 1990 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 1991 self.__field_header=tosh_swapheaderrequest(**{'command': 0x02}) 1992 self.__field_header.readfrombuffer(buf) 1993 self.__field_cmd=UINT(**{'sizeinbytes': 2, 'constant': 0x03}) 1994 self.__field_cmd.readfrombuffer(buf) 1995 self.__field_write=UINT(**{'sizeinbytes': 2, 'constant': 0x200}) 1996 self.__field_write.readfrombuffer(buf) 1997 self.__field_data_type=UINT(**{'sizeinbytes': 2, 'constant': 0x04}) 1998 self.__field_data_type.readfrombuffer(buf) 1999 self.__field_entry_index=UINT(**{'sizeinbytes': 2}) 2000 self.__field_entry_index.readfrombuffer(buf) 2001 self.__field_pad=UINT(**{'sizeinbytes': 2, 'constant': 0x00}) 2002 self.__field_pad.readfrombuffer(buf) 2003 self._bufferendoffset=buf.getcurrentoffset() 2004 2005 2006 def __getfield_header(self): 2007 try: self.__field_header 2008 except: 2009 self.__field_header=tosh_swapheaderrequest(**{'command': 0x02}) 2010 return self.__field_header.getvalue() 2011 2012 def __setfield_header(self, value): 2013 if isinstance(value,tosh_swapheaderrequest): 2014 self.__field_header=value 2015 else: 2016 self.__field_header=tosh_swapheaderrequest(value,**{'command': 0x02}) 2017 2018 def __delfield_header(self): del self.__field_header 2019 2020 header=property(__getfield_header, __setfield_header, __delfield_header, None) 2021 2022 def __getfield_cmd(self): 2023 try: self.__field_cmd 2024 except: 2025 self.__field_cmd=UINT(**{'sizeinbytes': 2, 'constant': 0x03}) 2026 return self.__field_cmd.getvalue() 2027 2028 def __setfield_cmd(self, value): 2029 if isinstance(value,UINT): 2030 self.__field_cmd=value 2031 else: 2032 self.__field_cmd=UINT(value,**{'sizeinbytes': 2, 'constant': 0x03}) 2033 2034 def __delfield_cmd(self): del self.__field_cmd 2035 2036 cmd=property(__getfield_cmd, __setfield_cmd, __delfield_cmd, None) 2037 2038 def __getfield_write(self): 2039 try: self.__field_write 2040 except: 2041 self.__field_write=UINT(**{'sizeinbytes': 2, 'constant': 0x200}) 2042 return self.__field_write.getvalue() 2043 2044 def __setfield_write(self, value): 2045 if isinstance(value,UINT): 2046 self.__field_write=value 2047 else: 2048 self.__field_write=UINT(value,**{'sizeinbytes': 2, 'constant': 0x200}) 2049 2050 def __delfield_write(self): del self.__field_write 2051 2052 write=property(__getfield_write, __setfield_write, __delfield_write, None) 2053 2054 def __getfield_data_type(self): 2055 try: self.__field_data_type 2056 except: 2057 self.__field_data_type=UINT(**{'sizeinbytes': 2, 'constant': 0x04}) 2058 return self.__field_data_type.getvalue() 2059 2060 def __setfield_data_type(self, value): 2061 if isinstance(value,UINT): 2062 self.__field_data_type=value 2063 else: 2064 self.__field_data_type=UINT(value,**{'sizeinbytes': 2, 'constant': 0x04}) 2065 2066 def __delfield_data_type(self): del self.__field_data_type 2067 2068 data_type=property(__getfield_data_type, __setfield_data_type, __delfield_data_type, None) 2069 2070 def __getfield_entry_index(self): 2071 return self.__field_entry_index.getvalue() 2072 2073 def __setfield_entry_index(self, value): 2074 if isinstance(value,UINT): 2075 self.__field_entry_index=value 2076 else: 2077 self.__field_entry_index=UINT(value,**{'sizeinbytes': 2}) 2078 2079 def __delfield_entry_index(self): del self.__field_entry_index 2080 2081 entry_index=property(__getfield_entry_index, __setfield_entry_index, __delfield_entry_index, None) 2082 2083 def __getfield_pad(self): 2084 try: self.__field_pad 2085 except: 2086 self.__field_pad=UINT(**{'sizeinbytes': 2, 'constant': 0x00}) 2087 return self.__field_pad.getvalue() 2088 2089 def __setfield_pad(self, value): 2090 if isinstance(value,UINT): 2091 self.__field_pad=value 2092 else: 2093 self.__field_pad=UINT(value,**{'sizeinbytes': 2, 'constant': 0x00}) 2094 2095 def __delfield_pad(self): del self.__field_pad 2096 2097 pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None) 2098 2099 def iscontainer(self): 2100 return True 2101 2102 def containerelements(self): 2103 yield ('header', self.__field_header, None) 2104 yield ('cmd', self.__field_cmd, None) 2105 yield ('write', self.__field_write, None) 2106 yield ('data_type', self.__field_data_type, None) 2107 yield ('entry_index', self.__field_entry_index, None) 2108 yield ('pad', self.__field_pad, None) 2109 2110 2111 2112 2113 class tosh_modifypbentryresponse(BaseProtogenClass): 2114 __fields=['header', 'cmd', 'swap_ok'] 2115 2116 def __init__(self, *args, **kwargs): 2117 dict={} 2118 # What was supplied to this function 2119 dict.update(kwargs) 2120 # Parent constructor 2121 super(tosh_modifypbentryresponse,self).__init__(**dict) 2122 if self.__class__ is tosh_modifypbentryresponse: 2123 self._update(args,dict) 2124 2125 2126 def getfields(self): 2127 return self.__fields 2128 2129 2130 def _update(self, args, kwargs): 2131 super(tosh_modifypbentryresponse,self)._update(args,kwargs) 2132 keys=kwargs.keys() 2133 for key in keys: 2134 if key in self.__fields: 2135 setattr(self, key, kwargs[key]) 2136 del kwargs[key] 2137 # Were any unrecognized kwargs passed in? 2138 if __debug__: 2139 self._complainaboutunusedargs(tosh_modifypbentryresponse,kwargs) 2140 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 2141 # Make all P fields that haven't already been constructed 2142 2143 2144 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 2145 'Writes this packet to the supplied buffer' 2146 self._bufferstartoffset=buf.getcurrentoffset() 2147 try: self.__field_header 2148 except: 2149 self.__field_header=tosh_swapheaderresponse() 2150 self.__field_header.writetobuffer(buf) 2151 try: self.__field_cmd 2152 except: 2153 self.__field_cmd=UINT(**{'sizeinbytes': 1, 'constant': 0x02}) 2154 self.__field_cmd.writetobuffer(buf) 2155 self.__field_swap_ok.writetobuffer(buf) 2156 self._bufferendoffset=buf.getcurrentoffset() 2157 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 2158 2159 2160 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 2161 'Reads this packet from the supplied buffer' 2162 self._bufferstartoffset=buf.getcurrentoffset() 2163 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 2164 self.__field_header=tosh_swapheaderresponse() 2165 self.__field_header.readfrombuffer(buf) 2166 self.__field_cmd=UINT(**{'sizeinbytes': 1, 'constant': 0x02}) 2167 self.__field_cmd.readfrombuffer(buf) 2168 self.__field_swap_ok=UINT(**{'sizeinbytes': 4}) 2169 self.__field_swap_ok.readfrombuffer(buf) 2170 self._bufferendoffset=buf.getcurrentoffset() 2171 2172 2173 def __getfield_header(self): 2174 try: self.__field_header 2175 except: 2176 self.__field_header=tosh_swapheaderresponse() 2177 return self.__field_header.getvalue() 2178 2179 def __setfield_header(self, value): 2180 if isinstance(value,tosh_swapheaderresponse): 2181 self.__field_header=value 2182 else: 2183 self.__field_header=tosh_swapheaderresponse(value,) 2184 2185 def __delfield_header(self): del self.__field_header 2186 2187 header=property(__getfield_header, __setfield_header, __delfield_header, None) 2188 2189 def __getfield_cmd(self): 2190 try: self.__field_cmd 2191 except: 2192 self.__field_cmd=UINT(**{'sizeinbytes': 1, 'constant': 0x02}) 2193 return self.__field_cmd.getvalue() 2194 2195 def __setfield_cmd(self, value): 2196 if isinstance(value,UINT): 2197 self.__field_cmd=value 2198 else: 2199 self.__field_cmd=UINT(value,**{'sizeinbytes': 1, 'constant': 0x02}) 2200 2201 def __delfield_cmd(self): del self.__field_cmd 2202 2203 cmd=property(__getfield_cmd, __setfield_cmd, __delfield_cmd, None) 2204 2205 def __getfield_swap_ok(self): 2206 return self.__field_swap_ok.getvalue() 2207 2208 def __setfield_swap_ok(self, value): 2209 if isinstance(value,UINT): 2210 self.__field_swap_ok=value 2211 else: 2212 self.__field_swap_ok=UINT(value,**{'sizeinbytes': 4}) 2213 2214 def __delfield_swap_ok(self): del self.__field_swap_ok 2215 2216 swap_ok=property(__getfield_swap_ok, __setfield_swap_ok, __delfield_swap_ok, None) 2217 2218 def iscontainer(self): 2219 return True 2220 2221 def containerelements(self): 2222 yield ('header', self.__field_header, None) 2223 yield ('cmd', self.__field_cmd, None) 2224 yield ('swap_ok', self.__field_swap_ok, None) 2225 2226 2227 2228 2229 class tosh_enableswapdatarequest(BaseProtogenClass): 2230 __fields=['header'] 2231 2232 def __init__(self, *args, **kwargs): 2233 dict={} 2234 # What was supplied to this function 2235 dict.update(kwargs) 2236 # Parent constructor 2237 super(tosh_enableswapdatarequest,self).__init__(**dict) 2238 if self.__class__ is tosh_enableswapdatarequest: 2239 self._update(args,dict) 2240 2241 2242 def getfields(self): 2243 return self.__fields 2244 2245 2246 def _update(self, args, kwargs): 2247 super(tosh_enableswapdatarequest,self)._update(args,kwargs) 2248 keys=kwargs.keys() 2249 for key in keys: 2250 if key in self.__fields: 2251 setattr(self, key, kwargs[key]) 2252 del kwargs[key] 2253 # Were any unrecognized kwargs passed in? 2254 if __debug__: 2255 self._complainaboutunusedargs(tosh_enableswapdatarequest,kwargs) 2256 if len(args): 2257 dict2={'command': 0x00} 2258 dict2.update(kwargs) 2259 kwargs=dict2 2260 self.__field_header=tosh_swapheaderrequest(*args,**dict2) 2261 # Make all P fields that haven't already been constructed 2262 2263 2264 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 2265 'Writes this packet to the supplied buffer' 2266 self._bufferstartoffset=buf.getcurrentoffset() 2267 try: self.__field_header 2268 except: 2269 self.__field_header=tosh_swapheaderrequest(**{'command': 0x00}) 2270 self.__field_header.writetobuffer(buf) 2271 self._bufferendoffset=buf.getcurrentoffset() 2272 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 2273 2274 2275 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 2276 'Reads this packet from the supplied buffer' 2277 self._bufferstartoffset=buf.getcurrentoffset() 2278 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 2279 self.__field_header=tosh_swapheaderrequest(**{'command': 0x00}) 2280 self.__field_header.readfrombuffer(buf) 2281 self._bufferendoffset=buf.getcurrentoffset() 2282 2283 2284 def __getfield_header(self): 2285 try: self.__field_header 2286 except: 2287 self.__field_header=tosh_swapheaderrequest(**{'command': 0x00}) 2288 return self.__field_header.getvalue() 2289 2290 def __setfield_header(self, value): 2291 if isinstance(value,tosh_swapheaderrequest): 2292 self.__field_header=value 2293 else: 2294 self.__field_header=tosh_swapheaderrequest(value,**{'command': 0x00}) 2295 2296 def __delfield_header(self): del self.__field_header 2297 2298 header=property(__getfield_header, __setfield_header, __delfield_header, None) 2299 2300 def iscontainer(self): 2301 return True 2302 2303 def containerelements(self): 2304 yield ('header', self.__field_header, None) 2305 2306 2307 2308 2309 class tosh_enableswapdataresponse(BaseProtogenClass): 2310 __fields=['header', 'cmd3', 'cmd4'] 2311 2312 def __init__(self, *args, **kwargs): 2313 dict={} 2314 # What was supplied to this function 2315 dict.update(kwargs) 2316 # Parent constructor 2317 super(tosh_enableswapdataresponse,self).__init__(**dict) 2318 if self.__class__ is tosh_enableswapdataresponse: 2319 self._update(args,dict) 2320 2321 2322 def getfields(self): 2323 return self.__fields 2324 2325 2326 def _update(self, args, kwargs): 2327 super(tosh_enableswapdataresponse,self)._update(args,kwargs) 2328 keys=kwargs.keys() 2329 for key in keys: 2330 if key in self.__fields: 2331 setattr(self, key, kwargs[key]) 2332 del kwargs[key] 2333 # Were any unrecognized kwargs passed in? 2334 if __debug__: 2335 self._complainaboutunusedargs(tosh_enableswapdataresponse,kwargs) 2336 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 2337 # Make all P fields that haven't already been constructed 2338 2339 2340 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 2341 'Writes this packet to the supplied buffer' 2342 self._bufferstartoffset=buf.getcurrentoffset() 2343 try: self.__field_header 2344 except: 2345 self.__field_header=tosh_swapheaderresponse() 2346 self.__field_header.writetobuffer(buf) 2347 try: self.__field_cmd3 2348 except: 2349 self.__field_cmd3=UINT(**{'sizeinbytes': 1, 'constant': 0x00}) 2350 self.__field_cmd3.writetobuffer(buf) 2351 try: self.__field_cmd4 2352 except: 2353 self.__field_cmd4=UINT(**{'sizeinbytes': 2, 'constant': 0x00}) 2354 self.__field_cmd4.writetobuffer(buf) 2355 self._bufferendoffset=buf.getcurrentoffset() 2356 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 2357 2358 2359 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 2360 'Reads this packet from the supplied buffer' 2361 self._bufferstartoffset=buf.getcurrentoffset() 2362 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 2363 self.__field_header=tosh_swapheaderresponse() 2364 self.__field_header.readfrombuffer(buf) 2365 self.__field_cmd3=UINT(**{'sizeinbytes': 1, 'constant': 0x00}) 2366 self.__field_cmd3.readfrombuffer(buf) 2367 self.__field_cmd4=UINT(**{'sizeinbytes': 2, 'constant': 0x00}) 2368 self.__field_cmd4.readfrombuffer(buf) 2369 self._bufferendoffset=buf.getcurrentoffset() 2370 2371 2372 def __getfield_header(self): 2373 try: self.__field_header 2374 except: 2375 self.__field_header=tosh_swapheaderresponse() 2376 return self.__field_header.getvalue() 2377 2378 def __setfield_header(self, value): 2379 if isinstance(value,tosh_swapheaderresponse): 2380 self.__field_header=value 2381 else: 2382 self.__field_header=tosh_swapheaderresponse(value,) 2383 2384 def __delfield_header(self): del self.__field_header 2385 2386 header=property(__getfield_header, __setfield_header, __delfield_header, None) 2387 2388 def __getfield_cmd3(self): 2389 try: self.__field_cmd3 2390 except: 2391 self.__field_cmd3=UINT(**{'sizeinbytes': 1, 'constant': 0x00}) 2392 return self.__field_cmd3.getvalue() 2393 2394 def __setfield_cmd3(self, value): 2395 if isinstance(value,UINT): 2396 self.__field_cmd3=value 2397 else: 2398 self.__field_cmd3=UINT(value,**{'sizeinbytes': 1, 'constant': 0x00}) 2399 2400 def __delfield_cmd3(self): del self.__field_cmd3 2401 2402 cmd3=property(__getfield_cmd3, __setfield_cmd3, __delfield_cmd3, None) 2403 2404 def __getfield_cmd4(self): 2405 try: self.__field_cmd4 2406 except: 2407 self.__field_cmd4=UINT(**{'sizeinbytes': 2, 'constant': 0x00}) 2408 return self.__field_cmd4.getvalue() 2409 2410 def __setfield_cmd4(self, value): 2411 if isinstance(value,UINT): 2412 self.__field_cmd4=value 2413 else: 2414 self.__field_cmd4=UINT(value,**{'sizeinbytes': 2, 'constant': 0x00}) 2415 2416 def __delfield_cmd4(self): del self.__field_cmd4 2417 2418 cmd4=property(__getfield_cmd4, __setfield_cmd4, __delfield_cmd4, None) 2419 2420 def iscontainer(self): 2421 return True 2422 2423 def containerelements(self): 2424 yield ('header', self.__field_header, None) 2425 yield ('cmd3', self.__field_cmd3, None) 2426 yield ('cmd4', self.__field_cmd4, None) 2427 2428 2429 2430 2431 class tosh_disableswapdatarequest(BaseProtogenClass): 2432 __fields=['header'] 2433 2434 def __init__(self, *args, **kwargs): 2435 dict={} 2436 # What was supplied to this function 2437 dict.update(kwargs) 2438 # Parent constructor 2439 super(tosh_disableswapdatarequest,self).__init__(**dict) 2440 if self.__class__ is tosh_disableswapdatarequest: 2441 self._update(args,dict) 2442 2443 2444 def getfields(self): 2445 return self.__fields 2446 2447 2448 def _update(self, args, kwargs): 2449 super(tosh_disableswapdatarequest,self)._update(args,kwargs) 2450 keys=kwargs.keys() 2451 for key in keys: 2452 if key in self.__fields: 2453 setattr(self, key, kwargs[key]) 2454 del kwargs[key] 2455 # Were any unrecognized kwargs passed in? 2456 if __debug__: 2457 self._complainaboutunusedargs(tosh_disableswapdatarequest,kwargs) 2458 if len(args): 2459 dict2={'command': 0x01} 2460 dict2.update(kwargs) 2461 kwargs=dict2 2462 self.__field_header=tosh_swapheaderrequest(*args,**dict2) 2463 # Make all P fields that haven't already been constructed 2464 2465 2466 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 2467 'Writes this packet to the supplied buffer' 2468 self._bufferstartoffset=buf.getcurrentoffset() 2469 try: self.__field_header 2470 except: 2471 self.__field_header=tosh_swapheaderrequest(**{'command': 0x01}) 2472 self.__field_header.writetobuffer(buf) 2473 self._bufferendoffset=buf.getcurrentoffset() 2474 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 2475 2476 2477 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 2478 'Reads this packet from the supplied buffer' 2479 self._bufferstartoffset=buf.getcurrentoffset() 2480 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 2481 self.__field_header=tosh_swapheaderrequest(**{'command': 0x01}) 2482 self.__field_header.readfrombuffer(buf) 2483 self._bufferendoffset=buf.getcurrentoffset() 2484 2485 2486 def __getfield_header(self): 2487 try: self.__field_header 2488 except: 2489 self.__field_header=tosh_swapheaderrequest(**{'command': 0x01}) 2490 return self.__field_header.getvalue() 2491 2492 def __setfield_header(self, value): 2493 if isinstance(value,tosh_swapheaderrequest): 2494 self.__field_header=value 2495 else: 2496 self.__field_header=tosh_swapheaderrequest(value,**{'command': 0x01}) 2497 2498 def __delfield_header(self): del self.__field_header 2499 2500 header=property(__getfield_header, __setfield_header, __delfield_header, None) 2501 2502 def iscontainer(self): 2503 return True 2504 2505 def containerelements(self): 2506 yield ('header', self.__field_header, None) 2507 2508 2509 2510 2511 class tosh_disableswapdataresponse(BaseProtogenClass): 2512 __fields=['header', 'cmd3', 'cmd4'] 2513 2514 def __init__(self, *args, **kwargs): 2515 dict={} 2516 # What was supplied to this function 2517 dict.update(kwargs) 2518 # Parent constructor 2519 super(tosh_disableswapdataresponse,self).__init__(**dict) 2520 if self.__class__ is tosh_disableswapdataresponse: 2521 self._update(args,dict) 2522 2523 2524 def getfields(self): 2525 return self.__fields 2526 2527 2528 def _update(self, args, kwargs): 2529 super(tosh_disableswapdataresponse,self)._update(args,kwargs) 2530 keys=kwargs.keys() 2531 for key in keys: 2532 if key in self.__fields: 2533 setattr(self, key, kwargs[key]) 2534 del kwargs[key] 2535 # Were any unrecognized kwargs passed in? 2536 if __debug__: 2537 self._complainaboutunusedargs(tosh_disableswapdataresponse,kwargs) 2538 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 2539 # Make all P fields that haven't already been constructed 2540 2541 2542 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 2543 'Writes this packet to the supplied buffer' 2544 self._bufferstartoffset=buf.getcurrentoffset() 2545 try: self.__field_header 2546 except: 2547 self.__field_header=tosh_swapheaderresponse() 2548 self.__field_header.writetobuffer(buf) 2549 try: self.__field_cmd3 2550 except: 2551 self.__field_cmd3=UINT(**{'sizeinbytes': 1, 'constant': 0x01}) 2552 self.__field_cmd3.writetobuffer(buf) 2553 try: self.__field_cmd4 2554 except: 2555 self.__field_cmd4=UINT(**{'sizeinbytes': 2, 'constant': 0x00}) 2556 self.__field_cmd4.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=tosh_swapheaderresponse() 2566 self.__field_header.readfrombuffer(buf) 2567 self.__field_cmd3=UINT(**{'sizeinbytes': 1, 'constant': 0x01}) 2568 self.__field_cmd3.readfrombuffer(buf) 2569 self.__field_cmd4=UINT(**{'sizeinbytes': 2, 'constant': 0x00}) 2570 self.__field_cmd4.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=tosh_swapheaderresponse() 2578 return self.__field_header.getvalue() 2579 2580 def __setfield_header(self, value): 2581 if isinstance(value,tosh_swapheaderresponse): 2582 self.__field_header=value 2583 else: 2584 self.__field_header=tosh_swapheaderresponse(value,) 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_cmd3(self): 2591 try: self.__field_cmd3 2592 except: 2593 self.__field_cmd3=UINT(**{'sizeinbytes': 1, 'constant': 0x01}) 2594 return self.__field_cmd3.getvalue() 2595 2596 def __setfield_cmd3(self, value): 2597 if isinstance(value,UINT): 2598 self.__field_cmd3=value 2599 else: 2600 self.__field_cmd3=UINT(value,**{'sizeinbytes': 1, 'constant': 0x01}) 2601 2602 def __delfield_cmd3(self): del self.__field_cmd3 2603 2604 cmd3=property(__getfield_cmd3, __setfield_cmd3, __delfield_cmd3, None) 2605 2606 def __getfield_cmd4(self): 2607 try: self.__field_cmd4 2608 except: 2609 self.__field_cmd4=UINT(**{'sizeinbytes': 2, 'constant': 0x00}) 2610 return self.__field_cmd4.getvalue() 2611 2612 def __setfield_cmd4(self, value): 2613 if isinstance(value,UINT): 2614 self.__field_cmd4=value 2615 else: 2616 self.__field_cmd4=UINT(value,**{'sizeinbytes': 2, 'constant': 0x00}) 2617 2618 def __delfield_cmd4(self): del self.__field_cmd4 2619 2620 cmd4=property(__getfield_cmd4, __setfield_cmd4, __delfield_cmd4, None) 2621 2622 def iscontainer(self): 2623 return True 2624 2625 def containerelements(self): 2626 yield ('header', self.__field_header, None) 2627 yield ('cmd3', self.__field_cmd3, None) 2628 yield ('cmd4', self.__field_cmd4, None) 2629 2630 2631 2632 2633 class tosh_getunknownrecordrequest(BaseProtogenClass): 2634 __fields=['header', 'data_type', 'pad', 'cmd', 'data_index', 'pad'] 2635 2636 def __init__(self, *args, **kwargs): 2637 dict={} 2638 # What was supplied to this function 2639 dict.update(kwargs) 2640 # Parent constructor 2641 super(tosh_getunknownrecordrequest,self).__init__(**dict) 2642 if self.__class__ is tosh_getunknownrecordrequest: 2643 self._update(args,dict) 2644 2645 2646 def getfields(self): 2647 return self.__fields 2648 2649 2650 def _update(self, args, kwargs): 2651 super(tosh_getunknownrecordrequest,self)._update(args,kwargs) 2652 keys=kwargs.keys() 2653 for key in keys: 2654 if key in self.__fields: 2655 setattr(self, key, kwargs[key]) 2656 del kwargs[key] 2657 # Were any unrecognized kwargs passed in? 2658 if __debug__: 2659 self._complainaboutunusedargs(tosh_getunknownrecordrequest,kwargs) 2660 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 2661 # Make all P fields that haven't already been constructed 2662 2663 2664 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 2665 'Writes this packet to the supplied buffer' 2666 self._bufferstartoffset=buf.getcurrentoffset() 2667 try: self.__field_header 2668 except: 2669 self.__field_header=tosh_swapheaderrequest(**{'command': 0x02}) 2670 self.__field_header.writetobuffer(buf) 2671 self.__field_data_type.writetobuffer(buf) 2672 try: self.__field_pad 2673 except: 2674 self.__field_pad=UINT(**{'sizeinbytes': 2, 'constant': 0x00}) 2675 self.__field_pad.writetobuffer(buf) 2676 try: self.__field_cmd 2677 except: 2678 self.__field_cmd=UINT(**{'sizeinbytes': 2, 'constant': 0x00}) 2679 self.__field_cmd.writetobuffer(buf) 2680 self.__field_data_index.writetobuffer(buf) 2681 try: self.__field_pad 2682 except: 2683 self.__field_pad=UINT(**{'sizeinbytes': 2, 'constant': 0x00}) 2684 self.__field_pad.writetobuffer(buf) 2685 self._bufferendoffset=buf.getcurrentoffset() 2686 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 2687 2688 2689 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 2690 'Reads this packet from the supplied buffer' 2691 self._bufferstartoffset=buf.getcurrentoffset() 2692 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 2693 self.__field_header=tosh_swapheaderrequest(**{'command': 0x02}) 2694 self.__field_header.readfrombuffer(buf) 2695 self.__field_data_type=UINT(**{'sizeinbytes': 2}) 2696 self.__field_data_type.readfrombuffer(buf) 2697 self.__field_pad=UINT(**{'sizeinbytes': 2, 'constant': 0x00}) 2698 self.__field_pad.readfrombuffer(buf) 2699 self.__field_cmd=UINT(**{'sizeinbytes': 2, 'constant': 0x00}) 2700 self.__field_cmd.readfrombuffer(buf) 2701 self.__field_data_index=UINT(**{'sizeinbytes': 2}) 2702 self.__field_data_index.readfrombuffer(buf) 2703 self.__field_pad=UINT(**{'sizeinbytes': 2, 'constant': 0x00}) 2704 self.__field_pad.readfrombuffer(buf) 2705 self._bufferendoffset=buf.getcurrentoffset() 2706 2707 2708 def __getfield_header(self): 2709 try: self.__field_header 2710 except: 2711 self.__field_header=tosh_swapheaderrequest(**{'command': 0x02}) 2712 return self.__field_header.getvalue() 2713 2714 def __setfield_header(self, value): 2715 if isinstance(value,tosh_swapheaderrequest): 2716 self.__field_header=value 2717 else: 2718 self.__field_header=tosh_swapheaderrequest(value,**{'command': 0x02}) 2719 2720 def __delfield_header(self): del self.__field_header 2721 2722 header=property(__getfield_header, __setfield_header, __delfield_header, None) 2723 2724 def __getfield_data_type(self): 2725 return self.__field_data_type.getvalue() 2726 2727 def __setfield_data_type(self, value): 2728 if isinstance(value,UINT): 2729 self.__field_data_type=value 2730 else: 2731 self.__field_data_type=UINT(value,**{'sizeinbytes': 2}) 2732 2733 def __delfield_data_type(self): del self.__field_data_type 2734 2735 data_type=property(__getfield_data_type, __setfield_data_type, __delfield_data_type, None) 2736 2737 def __getfield_pad(self): 2738 try: self.__field_pad 2739 except: 2740 self.__field_pad=UINT(**{'sizeinbytes': 2, 'constant': 0x00}) 2741 return self.__field_pad.getvalue() 2742 2743 def __setfield_pad(self, value): 2744 if isinstance(value,UINT): 2745 self.__field_pad=value 2746 else: 2747 self.__field_pad=UINT(value,**{'sizeinbytes': 2, 'constant': 0x00}) 2748 2749 def __delfield_pad(self): del self.__field_pad 2750 2751 pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None) 2752 2753 def __getfield_cmd(self): 2754 try: self.__field_cmd 2755 except: 2756 self.__field_cmd=UINT(**{'sizeinbytes': 2, 'constant': 0x00}) 2757 return self.__field_cmd.getvalue() 2758 2759 def __setfield_cmd(self, value): 2760 if isinstance(value,UINT): 2761 self.__field_cmd=value 2762 else: 2763 self.__field_cmd=UINT(value,**{'sizeinbytes': 2, 'constant': 0x00}) 2764 2765 def __delfield_cmd(self): del self.__field_cmd 2766 2767 cmd=property(__getfield_cmd, __setfield_cmd, __delfield_cmd, None) 2768 2769 def __getfield_data_index(self): 2770 return self.__field_data_index.getvalue() 2771 2772 def __setfield_data_index(self, value): 2773 if isinstance(value,UINT): 2774 self.__field_data_index=value 2775 else: 2776 self.__field_data_index=UINT(value,**{'sizeinbytes': 2}) 2777 2778 def __delfield_data_index(self): del self.__field_data_index 2779 2780 data_index=property(__getfield_data_index, __setfield_data_index, __delfield_data_index, None) 2781 2782 def __getfield_pad(self): 2783 try: self.__field_pad 2784 except: 2785 self.__field_pad=UINT(**{'sizeinbytes': 2, 'constant': 0x00}) 2786 return self.__field_pad.getvalue() 2787 2788 def __setfield_pad(self, value): 2789 if isinstance(value,UINT): 2790 self.__field_pad=value 2791 else: 2792 self.__field_pad=UINT(value,**{'sizeinbytes': 2, 'constant': 0x00}) 2793 2794 def __delfield_pad(self): del self.__field_pad 2795 2796 pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None) 2797 2798 def iscontainer(self): 2799 return True 2800 2801 def containerelements(self): 2802 yield ('header', self.__field_header, None) 2803 yield ('data_type', self.__field_data_type, None) 2804 yield ('pad', self.__field_pad, None) 2805 yield ('cmd', self.__field_cmd, None) 2806 yield ('data_index', self.__field_data_index, None) 2807 yield ('pad', self.__field_pad, None) 2808 2809 2810 2811 2812 class tosh_getunknownrecordresponse(BaseProtogenClass): 2813 __fields=['header', 'data'] 2814 2815 def __init__(self, *args, **kwargs): 2816 dict={} 2817 # What was supplied to this function 2818 dict.update(kwargs) 2819 # Parent constructor 2820 super(tosh_getunknownrecordresponse,self).__init__(**dict) 2821 if self.__class__ is tosh_getunknownrecordresponse: 2822 self._update(args,dict) 2823 2824 2825 def getfields(self): 2826 return self.__fields 2827 2828 2829 def _update(self, args, kwargs): 2830 super(tosh_getunknownrecordresponse,self)._update(args,kwargs) 2831 keys=kwargs.keys() 2832 for key in keys: 2833 if key in self.__fields: 2834 setattr(self, key, kwargs[key]) 2835 del kwargs[key] 2836 # Were any unrecognized kwargs passed in? 2837 if __debug__: 2838 self._complainaboutunusedargs(tosh_getunknownrecordresponse,kwargs) 2839 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 2840 # Make all P fields that haven't already been constructed 2841 2842 2843 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 2844 'Writes this packet to the supplied buffer' 2845 self._bufferstartoffset=buf.getcurrentoffset() 2846 try: self.__field_header 2847 except: 2848 self.__field_header=tosh_swapheaderresponse() 2849 self.__field_header.writetobuffer(buf) 2850 try: self.__field_data 2851 except: 2852 self.__field_data=DATA() 2853 self.__field_data.writetobuffer(buf) 2854 self._bufferendoffset=buf.getcurrentoffset() 2855 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 2856 2857 2858 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 2859 'Reads this packet from the supplied buffer' 2860 self._bufferstartoffset=buf.getcurrentoffset() 2861 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 2862 self.__field_header=tosh_swapheaderresponse() 2863 self.__field_header.readfrombuffer(buf) 2864 self.__field_data=DATA() 2865 self.__field_data.readfrombuffer(buf) 2866 self._bufferendoffset=buf.getcurrentoffset() 2867 2868 2869 def __getfield_header(self): 2870 try: self.__field_header 2871 except: 2872 self.__field_header=tosh_swapheaderresponse() 2873 return self.__field_header.getvalue() 2874 2875 def __setfield_header(self, value): 2876 if isinstance(value,tosh_swapheaderresponse): 2877 self.__field_header=value 2878 else: 2879 self.__field_header=tosh_swapheaderresponse(value,) 2880 2881 def __delfield_header(self): del self.__field_header 2882 2883 header=property(__getfield_header, __setfield_header, __delfield_header, None) 2884 2885 def __getfield_data(self): 2886 try: self.__field_data 2887 except: 2888 self.__field_data=DATA() 2889 return self.__field_data.getvalue() 2890 2891 def __setfield_data(self, value): 2892 if isinstance(value,DATA): 2893 self.__field_data=value 2894 else: 2895 self.__field_data=DATA(value,) 2896 2897 def __delfield_data(self): del self.__field_data 2898 2899 data=property(__getfield_data, __setfield_data, __delfield_data, None) 2900 2901 def iscontainer(self): 2902 return True 2903 2904 def containerelements(self): 2905 yield ('header', self.__field_header, None) 2906 yield ('data', self.__field_data, None) 2907 2908 2909 2910 2911
Generated by PyXR 0.9.4