0001 # THIS FILE IS AUTOMATICALLY GENERATED. EDIT THE SOURCE FILE NOT THIS ONE 0002 0003 """Various descriptions of data specific to Sanyo phones""" 0004 0005 from prototypes import * 0006 0007 # We use LSB for all integer like fields 0008 0009 UINT=UINTlsb 0010 BOOL=BOOLlsb 0011 0012 class getphonestatus(BaseProtogenClass): 0013 __fields=['command'] 0014 0015 def __init__(self, *args, **kwargs): 0016 dict={} 0017 # What was supplied to this function 0018 dict.update(kwargs) 0019 # Parent constructor 0020 super(getphonestatus,self).__init__(**dict) 0021 if self.__class__ is getphonestatus: 0022 self._update(args,dict) 0023 0024 0025 def getfields(self): 0026 return self.__fields 0027 0028 0029 def _update(self, args, kwargs): 0030 super(getphonestatus,self)._update(args,kwargs) 0031 keys=kwargs.keys() 0032 for key in keys: 0033 if key in self.__fields: 0034 setattr(self, key, kwargs[key]) 0035 del kwargs[key] 0036 # Were any unrecognized kwargs passed in? 0037 if __debug__: 0038 self._complainaboutunusedargs(getphonestatus,kwargs) 0039 if len(args): 0040 dict2={'sizeinbytes': 1, 'constant': 0x0c} 0041 dict2.update(kwargs) 0042 kwargs=dict2 0043 self.__field_command=UINT(*args,**dict2) 0044 # Make all P fields that haven't already been constructed 0045 0046 0047 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 0048 'Writes this packet to the supplied buffer' 0049 self._bufferstartoffset=buf.getcurrentoffset() 0050 try: self.__field_command 0051 except: 0052 self.__field_command=UINT(**{'sizeinbytes': 1, 'constant': 0x0c}) 0053 self.__field_command.writetobuffer(buf) 0054 self._bufferendoffset=buf.getcurrentoffset() 0055 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 0056 0057 0058 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 0059 'Reads this packet from the supplied buffer' 0060 self._bufferstartoffset=buf.getcurrentoffset() 0061 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 0062 self.__field_command=UINT(**{'sizeinbytes': 1, 'constant': 0x0c}) 0063 self.__field_command.readfrombuffer(buf) 0064 self._bufferendoffset=buf.getcurrentoffset() 0065 0066 0067 def __getfield_command(self): 0068 try: self.__field_command 0069 except: 0070 self.__field_command=UINT(**{'sizeinbytes': 1, 'constant': 0x0c}) 0071 return self.__field_command.getvalue() 0072 0073 def __setfield_command(self, value): 0074 if isinstance(value,UINT): 0075 self.__field_command=value 0076 else: 0077 self.__field_command=UINT(value,**{'sizeinbytes': 1, 'constant': 0x0c}) 0078 0079 def __delfield_command(self): del self.__field_command 0080 0081 command=property(__getfield_command, __setfield_command, __delfield_command, None) 0082 0083 def iscontainer(self): 0084 return True 0085 0086 def containerelements(self): 0087 yield ('command', self.__field_command, None) 0088 0089 0090 0091 0092 class getphoneresponse(BaseProtogenClass): 0093 __fields=['pad'] 0094 0095 def __init__(self, *args, **kwargs): 0096 dict={} 0097 # What was supplied to this function 0098 dict.update(kwargs) 0099 # Parent constructor 0100 super(getphoneresponse,self).__init__(**dict) 0101 if self.__class__ is getphoneresponse: 0102 self._update(args,dict) 0103 0104 0105 def getfields(self): 0106 return self.__fields 0107 0108 0109 def _update(self, args, kwargs): 0110 super(getphoneresponse,self)._update(args,kwargs) 0111 keys=kwargs.keys() 0112 for key in keys: 0113 if key in self.__fields: 0114 setattr(self, key, kwargs[key]) 0115 del kwargs[key] 0116 # Were any unrecognized kwargs passed in? 0117 if __debug__: 0118 self._complainaboutunusedargs(getphoneresponse,kwargs) 0119 if len(args): 0120 dict2={} 0121 dict2.update(kwargs) 0122 kwargs=dict2 0123 self.__field_pad=UNKNOWN(*args,**dict2) 0124 # Make all P fields that haven't already been constructed 0125 0126 0127 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 0128 'Writes this packet to the supplied buffer' 0129 self._bufferstartoffset=buf.getcurrentoffset() 0130 self.__field_pad.writetobuffer(buf) 0131 self._bufferendoffset=buf.getcurrentoffset() 0132 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 0133 0134 0135 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 0136 'Reads this packet from the supplied buffer' 0137 self._bufferstartoffset=buf.getcurrentoffset() 0138 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 0139 self.__field_pad=UNKNOWN() 0140 self.__field_pad.readfrombuffer(buf) 0141 self._bufferendoffset=buf.getcurrentoffset() 0142 0143 0144 def __getfield_pad(self): 0145 return self.__field_pad.getvalue() 0146 0147 def __setfield_pad(self, value): 0148 if isinstance(value,UNKNOWN): 0149 self.__field_pad=value 0150 else: 0151 self.__field_pad=UNKNOWN(value,) 0152 0153 def __delfield_pad(self): del self.__field_pad 0154 0155 pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None) 0156 0157 def iscontainer(self): 0158 return True 0159 0160 def containerelements(self): 0161 yield ('pad', self.__field_pad, None) 0162 0163 0164 0165 0166 class firmwarerequest(BaseProtogenClass): 0167 __fields=['command'] 0168 0169 def __init__(self, *args, **kwargs): 0170 dict={} 0171 # What was supplied to this function 0172 dict.update(kwargs) 0173 # Parent constructor 0174 super(firmwarerequest,self).__init__(**dict) 0175 if self.__class__ is firmwarerequest: 0176 self._update(args,dict) 0177 0178 0179 def getfields(self): 0180 return self.__fields 0181 0182 0183 def _update(self, args, kwargs): 0184 super(firmwarerequest,self)._update(args,kwargs) 0185 keys=kwargs.keys() 0186 for key in keys: 0187 if key in self.__fields: 0188 setattr(self, key, kwargs[key]) 0189 del kwargs[key] 0190 # Were any unrecognized kwargs passed in? 0191 if __debug__: 0192 self._complainaboutunusedargs(firmwarerequest,kwargs) 0193 if len(args): 0194 dict2={'sizeinbytes': 1, 'constant': 0x00} 0195 dict2.update(kwargs) 0196 kwargs=dict2 0197 self.__field_command=UINT(*args,**dict2) 0198 # Make all P fields that haven't already been constructed 0199 0200 0201 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 0202 'Writes this packet to the supplied buffer' 0203 self._bufferstartoffset=buf.getcurrentoffset() 0204 try: self.__field_command 0205 except: 0206 self.__field_command=UINT(**{'sizeinbytes': 1, 'constant': 0x00}) 0207 self.__field_command.writetobuffer(buf) 0208 self._bufferendoffset=buf.getcurrentoffset() 0209 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 0210 0211 0212 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 0213 'Reads this packet from the supplied buffer' 0214 self._bufferstartoffset=buf.getcurrentoffset() 0215 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 0216 self.__field_command=UINT(**{'sizeinbytes': 1, 'constant': 0x00}) 0217 self.__field_command.readfrombuffer(buf) 0218 self._bufferendoffset=buf.getcurrentoffset() 0219 0220 0221 def __getfield_command(self): 0222 try: self.__field_command 0223 except: 0224 self.__field_command=UINT(**{'sizeinbytes': 1, 'constant': 0x00}) 0225 return self.__field_command.getvalue() 0226 0227 def __setfield_command(self, value): 0228 if isinstance(value,UINT): 0229 self.__field_command=value 0230 else: 0231 self.__field_command=UINT(value,**{'sizeinbytes': 1, 'constant': 0x00}) 0232 0233 def __delfield_command(self): del self.__field_command 0234 0235 command=property(__getfield_command, __setfield_command, __delfield_command, None) 0236 0237 def iscontainer(self): 0238 return True 0239 0240 def containerelements(self): 0241 yield ('command', self.__field_command, None) 0242 0243 0244 0245 0246 class firmwareresponse(BaseProtogenClass): 0247 __fields=['command', 'date1', 'time1', 'date2', 'time2', 'string1', 'dunno1'] 0248 0249 def __init__(self, *args, **kwargs): 0250 dict={} 0251 # What was supplied to this function 0252 dict.update(kwargs) 0253 # Parent constructor 0254 super(firmwareresponse,self).__init__(**dict) 0255 if self.__class__ is firmwareresponse: 0256 self._update(args,dict) 0257 0258 0259 def getfields(self): 0260 return self.__fields 0261 0262 0263 def _update(self, args, kwargs): 0264 super(firmwareresponse,self)._update(args,kwargs) 0265 keys=kwargs.keys() 0266 for key in keys: 0267 if key in self.__fields: 0268 setattr(self, key, kwargs[key]) 0269 del kwargs[key] 0270 # Were any unrecognized kwargs passed in? 0271 if __debug__: 0272 self._complainaboutunusedargs(firmwareresponse,kwargs) 0273 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 0274 # Make all P fields that haven't already been constructed 0275 0276 0277 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 0278 'Writes this packet to the supplied buffer' 0279 self._bufferstartoffset=buf.getcurrentoffset() 0280 self.__field_command.writetobuffer(buf) 0281 self.__field_date1.writetobuffer(buf) 0282 self.__field_time1.writetobuffer(buf) 0283 self.__field_date2.writetobuffer(buf) 0284 self.__field_time2.writetobuffer(buf) 0285 self.__field_string1.writetobuffer(buf) 0286 self.__field_dunno1.writetobuffer(buf) 0287 self._bufferendoffset=buf.getcurrentoffset() 0288 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 0289 0290 0291 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 0292 'Reads this packet from the supplied buffer' 0293 self._bufferstartoffset=buf.getcurrentoffset() 0294 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 0295 self.__field_command=UINT(**{'sizeinbytes': 1}) 0296 self.__field_command.readfrombuffer(buf) 0297 self.__field_date1=USTRING(**{'sizeinbytes': 11, 'terminator': None}) 0298 self.__field_date1.readfrombuffer(buf) 0299 self.__field_time1=USTRING(**{'sizeinbytes': 8, 'terminator': None}) 0300 self.__field_time1.readfrombuffer(buf) 0301 self.__field_date2=USTRING(**{'sizeinbytes': 11, 'terminator': None}) 0302 self.__field_date2.readfrombuffer(buf) 0303 self.__field_time2=USTRING(**{'sizeinbytes': 8, 'terminator': None}) 0304 self.__field_time2.readfrombuffer(buf) 0305 self.__field_string1=USTRING(**{'sizeinbytes': 8, 'terminator': None}) 0306 self.__field_string1.readfrombuffer(buf) 0307 self.__field_dunno1=UNKNOWN(**{'sizeinbytes': 8}) 0308 self.__field_dunno1.readfrombuffer(buf) 0309 self._bufferendoffset=buf.getcurrentoffset() 0310 0311 0312 def __getfield_command(self): 0313 return self.__field_command.getvalue() 0314 0315 def __setfield_command(self, value): 0316 if isinstance(value,UINT): 0317 self.__field_command=value 0318 else: 0319 self.__field_command=UINT(value,**{'sizeinbytes': 1}) 0320 0321 def __delfield_command(self): del self.__field_command 0322 0323 command=property(__getfield_command, __setfield_command, __delfield_command, None) 0324 0325 def __getfield_date1(self): 0326 return self.__field_date1.getvalue() 0327 0328 def __setfield_date1(self, value): 0329 if isinstance(value,USTRING): 0330 self.__field_date1=value 0331 else: 0332 self.__field_date1=USTRING(value,**{'sizeinbytes': 11, 'terminator': None}) 0333 0334 def __delfield_date1(self): del self.__field_date1 0335 0336 date1=property(__getfield_date1, __setfield_date1, __delfield_date1, None) 0337 0338 def __getfield_time1(self): 0339 return self.__field_time1.getvalue() 0340 0341 def __setfield_time1(self, value): 0342 if isinstance(value,USTRING): 0343 self.__field_time1=value 0344 else: 0345 self.__field_time1=USTRING(value,**{'sizeinbytes': 8, 'terminator': None}) 0346 0347 def __delfield_time1(self): del self.__field_time1 0348 0349 time1=property(__getfield_time1, __setfield_time1, __delfield_time1, None) 0350 0351 def __getfield_date2(self): 0352 return self.__field_date2.getvalue() 0353 0354 def __setfield_date2(self, value): 0355 if isinstance(value,USTRING): 0356 self.__field_date2=value 0357 else: 0358 self.__field_date2=USTRING(value,**{'sizeinbytes': 11, 'terminator': None}) 0359 0360 def __delfield_date2(self): del self.__field_date2 0361 0362 date2=property(__getfield_date2, __setfield_date2, __delfield_date2, None) 0363 0364 def __getfield_time2(self): 0365 return self.__field_time2.getvalue() 0366 0367 def __setfield_time2(self, value): 0368 if isinstance(value,USTRING): 0369 self.__field_time2=value 0370 else: 0371 self.__field_time2=USTRING(value,**{'sizeinbytes': 8, 'terminator': None}) 0372 0373 def __delfield_time2(self): del self.__field_time2 0374 0375 time2=property(__getfield_time2, __setfield_time2, __delfield_time2, None) 0376 0377 def __getfield_string1(self): 0378 return self.__field_string1.getvalue() 0379 0380 def __setfield_string1(self, value): 0381 if isinstance(value,USTRING): 0382 self.__field_string1=value 0383 else: 0384 self.__field_string1=USTRING(value,**{'sizeinbytes': 8, 'terminator': None}) 0385 0386 def __delfield_string1(self): del self.__field_string1 0387 0388 string1=property(__getfield_string1, __setfield_string1, __delfield_string1, None) 0389 0390 def __getfield_dunno1(self): 0391 return self.__field_dunno1.getvalue() 0392 0393 def __setfield_dunno1(self, value): 0394 if isinstance(value,UNKNOWN): 0395 self.__field_dunno1=value 0396 else: 0397 self.__field_dunno1=UNKNOWN(value,**{'sizeinbytes': 8}) 0398 0399 def __delfield_dunno1(self): del self.__field_dunno1 0400 0401 dunno1=property(__getfield_dunno1, __setfield_dunno1, __delfield_dunno1, None) 0402 0403 def iscontainer(self): 0404 return True 0405 0406 def containerelements(self): 0407 yield ('command', self.__field_command, None) 0408 yield ('date1', self.__field_date1, None) 0409 yield ('time1', self.__field_time1, None) 0410 yield ('date2', self.__field_date2, None) 0411 yield ('time2', self.__field_time2, None) 0412 yield ('string1', self.__field_string1, None) 0413 yield ('dunno1', self.__field_dunno1, None) 0414 0415 0416 0417 0418 class esnrequest(BaseProtogenClass): 0419 __fields=['command'] 0420 0421 def __init__(self, *args, **kwargs): 0422 dict={} 0423 # What was supplied to this function 0424 dict.update(kwargs) 0425 # Parent constructor 0426 super(esnrequest,self).__init__(**dict) 0427 if self.__class__ is esnrequest: 0428 self._update(args,dict) 0429 0430 0431 def getfields(self): 0432 return self.__fields 0433 0434 0435 def _update(self, args, kwargs): 0436 super(esnrequest,self)._update(args,kwargs) 0437 keys=kwargs.keys() 0438 for key in keys: 0439 if key in self.__fields: 0440 setattr(self, key, kwargs[key]) 0441 del kwargs[key] 0442 # Were any unrecognized kwargs passed in? 0443 if __debug__: 0444 self._complainaboutunusedargs(esnrequest,kwargs) 0445 if len(args): 0446 dict2={'sizeinbytes': 1, 'constant': 0x01} 0447 dict2.update(kwargs) 0448 kwargs=dict2 0449 self.__field_command=UINT(*args,**dict2) 0450 # Make all P fields that haven't already been constructed 0451 0452 0453 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 0454 'Writes this packet to the supplied buffer' 0455 self._bufferstartoffset=buf.getcurrentoffset() 0456 try: self.__field_command 0457 except: 0458 self.__field_command=UINT(**{'sizeinbytes': 1, 'constant': 0x01}) 0459 self.__field_command.writetobuffer(buf) 0460 self._bufferendoffset=buf.getcurrentoffset() 0461 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 0462 0463 0464 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 0465 'Reads this packet from the supplied buffer' 0466 self._bufferstartoffset=buf.getcurrentoffset() 0467 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 0468 self.__field_command=UINT(**{'sizeinbytes': 1, 'constant': 0x01}) 0469 self.__field_command.readfrombuffer(buf) 0470 self._bufferendoffset=buf.getcurrentoffset() 0471 0472 0473 def __getfield_command(self): 0474 try: self.__field_command 0475 except: 0476 self.__field_command=UINT(**{'sizeinbytes': 1, 'constant': 0x01}) 0477 return self.__field_command.getvalue() 0478 0479 def __setfield_command(self, value): 0480 if isinstance(value,UINT): 0481 self.__field_command=value 0482 else: 0483 self.__field_command=UINT(value,**{'sizeinbytes': 1, 'constant': 0x01}) 0484 0485 def __delfield_command(self): del self.__field_command 0486 0487 command=property(__getfield_command, __setfield_command, __delfield_command, None) 0488 0489 def iscontainer(self): 0490 return True 0491 0492 def containerelements(self): 0493 yield ('command', self.__field_command, None) 0494 0495 0496 0497 0498 class beginendupdaterequest(BaseProtogenClass): 0499 __fields=['command', 'beginend'] 0500 0501 def __init__(self, *args, **kwargs): 0502 dict={} 0503 # What was supplied to this function 0504 dict.update(kwargs) 0505 # Parent constructor 0506 super(beginendupdaterequest,self).__init__(**dict) 0507 if self.__class__ is beginendupdaterequest: 0508 self._update(args,dict) 0509 0510 0511 def getfields(self): 0512 return self.__fields 0513 0514 0515 def _update(self, args, kwargs): 0516 super(beginendupdaterequest,self)._update(args,kwargs) 0517 keys=kwargs.keys() 0518 for key in keys: 0519 if key in self.__fields: 0520 setattr(self, key, kwargs[key]) 0521 del kwargs[key] 0522 # Were any unrecognized kwargs passed in? 0523 if __debug__: 0524 self._complainaboutunusedargs(beginendupdaterequest,kwargs) 0525 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 0526 # Make all P fields that haven't already been constructed 0527 0528 0529 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 0530 'Writes this packet to the supplied buffer' 0531 self._bufferstartoffset=buf.getcurrentoffset() 0532 try: self.__field_command 0533 except: 0534 self.__field_command=UINT(**{'sizeinbytes': 1, 'constant': 0x29}) 0535 self.__field_command.writetobuffer(buf) 0536 self.__field_beginend.writetobuffer(buf) 0537 self._bufferendoffset=buf.getcurrentoffset() 0538 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 0539 0540 0541 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 0542 'Reads this packet from the supplied buffer' 0543 self._bufferstartoffset=buf.getcurrentoffset() 0544 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 0545 self.__field_command=UINT(**{'sizeinbytes': 1, 'constant': 0x29}) 0546 self.__field_command.readfrombuffer(buf) 0547 self.__field_beginend=UINT(**{'sizeinbytes': 1}) 0548 self.__field_beginend.readfrombuffer(buf) 0549 self._bufferendoffset=buf.getcurrentoffset() 0550 0551 0552 def __getfield_command(self): 0553 try: self.__field_command 0554 except: 0555 self.__field_command=UINT(**{'sizeinbytes': 1, 'constant': 0x29}) 0556 return self.__field_command.getvalue() 0557 0558 def __setfield_command(self, value): 0559 if isinstance(value,UINT): 0560 self.__field_command=value 0561 else: 0562 self.__field_command=UINT(value,**{'sizeinbytes': 1, 'constant': 0x29}) 0563 0564 def __delfield_command(self): del self.__field_command 0565 0566 command=property(__getfield_command, __setfield_command, __delfield_command, None) 0567 0568 def __getfield_beginend(self): 0569 return self.__field_beginend.getvalue() 0570 0571 def __setfield_beginend(self, value): 0572 if isinstance(value,UINT): 0573 self.__field_beginend=value 0574 else: 0575 self.__field_beginend=UINT(value,**{'sizeinbytes': 1}) 0576 0577 def __delfield_beginend(self): del self.__field_beginend 0578 0579 beginend=property(__getfield_beginend, __setfield_beginend, __delfield_beginend, None) 0580 0581 def iscontainer(self): 0582 return True 0583 0584 def containerelements(self): 0585 yield ('command', self.__field_command, None) 0586 yield ('beginend', self.__field_beginend, None) 0587 0588 0589 0590 0591 class samheader(BaseProtogenClass): 0592 __fields=['readwrite', 'attribute'] 0593 0594 def __init__(self, *args, **kwargs): 0595 dict={} 0596 # User specified arguments in the packet description 0597 dict.update({'readwrite': 0x26}) 0598 # What was supplied to this function 0599 dict.update(kwargs) 0600 # Parent constructor 0601 super(samheader,self).__init__(**dict) 0602 if self.__class__ is samheader: 0603 self._update(args,dict) 0604 0605 0606 def getfields(self): 0607 return self.__fields 0608 0609 0610 def _update(self, args, kwargs): 0611 super(samheader,self)._update(args,kwargs) 0612 keys=kwargs.keys() 0613 for key in keys: 0614 if key in self.__fields: 0615 setattr(self, key, kwargs[key]) 0616 del kwargs[key] 0617 # Were any unrecognized kwargs passed in? 0618 if __debug__: 0619 self._complainaboutunusedargs(samheader,kwargs) 0620 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 0621 # Make all P fields that haven't already been constructed 0622 0623 0624 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 0625 'Writes this packet to the supplied buffer' 0626 self._bufferstartoffset=buf.getcurrentoffset() 0627 self.__field_readwrite.writetobuffer(buf) 0628 self.__field_attribute.writetobuffer(buf) 0629 self._bufferendoffset=buf.getcurrentoffset() 0630 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 0631 0632 0633 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 0634 'Reads this packet from the supplied buffer' 0635 self._bufferstartoffset=buf.getcurrentoffset() 0636 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 0637 self.__field_readwrite=UINT(**{'sizeinbytes': 1}) 0638 self.__field_readwrite.readfrombuffer(buf) 0639 self.__field_attribute=UINT(**{'sizeinbytes': 2}) 0640 self.__field_attribute.readfrombuffer(buf) 0641 self._bufferendoffset=buf.getcurrentoffset() 0642 0643 0644 def __getfield_readwrite(self): 0645 return self.__field_readwrite.getvalue() 0646 0647 def __setfield_readwrite(self, value): 0648 if isinstance(value,UINT): 0649 self.__field_readwrite=value 0650 else: 0651 self.__field_readwrite=UINT(value,**{'sizeinbytes': 1}) 0652 0653 def __delfield_readwrite(self): del self.__field_readwrite 0654 0655 readwrite=property(__getfield_readwrite, __setfield_readwrite, __delfield_readwrite, None) 0656 0657 def __getfield_attribute(self): 0658 return self.__field_attribute.getvalue() 0659 0660 def __setfield_attribute(self, value): 0661 if isinstance(value,UINT): 0662 self.__field_attribute=value 0663 else: 0664 self.__field_attribute=UINT(value,**{'sizeinbytes': 2}) 0665 0666 def __delfield_attribute(self): del self.__field_attribute 0667 0668 attribute=property(__getfield_attribute, __setfield_attribute, __delfield_attribute, None) 0669 0670 def iscontainer(self): 0671 return True 0672 0673 def containerelements(self): 0674 yield ('readwrite', self.__field_readwrite, None) 0675 yield ('attribute', self.__field_attribute, None) 0676 0677 0678 0679 0680 class phonebooknamerequest(BaseProtogenClass): 0681 __fields=['header', 'slot', 'pad'] 0682 0683 def __init__(self, *args, **kwargs): 0684 dict={} 0685 # What was supplied to this function 0686 dict.update(kwargs) 0687 # Parent constructor 0688 super(phonebooknamerequest,self).__init__(**dict) 0689 if self.__class__ is phonebooknamerequest: 0690 self._update(args,dict) 0691 0692 0693 def getfields(self): 0694 return self.__fields 0695 0696 0697 def _update(self, args, kwargs): 0698 super(phonebooknamerequest,self)._update(args,kwargs) 0699 keys=kwargs.keys() 0700 for key in keys: 0701 if key in self.__fields: 0702 setattr(self, key, kwargs[key]) 0703 del kwargs[key] 0704 # Were any unrecognized kwargs passed in? 0705 if __debug__: 0706 self._complainaboutunusedargs(phonebooknamerequest,kwargs) 0707 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 0708 # Make all P fields that haven't already been constructed 0709 0710 0711 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 0712 'Writes this packet to the supplied buffer' 0713 self._bufferstartoffset=buf.getcurrentoffset() 0714 try: self.__field_header 0715 except: 0716 self.__field_header=samheader(**{'attribute': 0x026B}) 0717 self.__field_header.writetobuffer(buf) 0718 self.__field_slot.writetobuffer(buf) 0719 try: self.__field_pad 0720 except: 0721 self.__field_pad=UNKNOWN(**{'sizeinbytes': 129}) 0722 self.__field_pad.writetobuffer(buf) 0723 self._bufferendoffset=buf.getcurrentoffset() 0724 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 0725 0726 0727 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 0728 'Reads this packet from the supplied buffer' 0729 self._bufferstartoffset=buf.getcurrentoffset() 0730 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 0731 self.__field_header=samheader(**{'attribute': 0x026B}) 0732 self.__field_header.readfrombuffer(buf) 0733 self.__field_slot=UINT(**{'sizeinbytes': 1}) 0734 self.__field_slot.readfrombuffer(buf) 0735 self.__field_pad=UNKNOWN(**{'sizeinbytes': 129}) 0736 self.__field_pad.readfrombuffer(buf) 0737 self._bufferendoffset=buf.getcurrentoffset() 0738 0739 0740 def __getfield_header(self): 0741 try: self.__field_header 0742 except: 0743 self.__field_header=samheader(**{'attribute': 0x026B}) 0744 return self.__field_header.getvalue() 0745 0746 def __setfield_header(self, value): 0747 if isinstance(value,samheader): 0748 self.__field_header=value 0749 else: 0750 self.__field_header=samheader(value,**{'attribute': 0x026B}) 0751 0752 def __delfield_header(self): del self.__field_header 0753 0754 header=property(__getfield_header, __setfield_header, __delfield_header, None) 0755 0756 def __getfield_slot(self): 0757 return self.__field_slot.getvalue() 0758 0759 def __setfield_slot(self, value): 0760 if isinstance(value,UINT): 0761 self.__field_slot=value 0762 else: 0763 self.__field_slot=UINT(value,**{'sizeinbytes': 1}) 0764 0765 def __delfield_slot(self): del self.__field_slot 0766 0767 slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None) 0768 0769 def __getfield_pad(self): 0770 try: self.__field_pad 0771 except: 0772 self.__field_pad=UNKNOWN(**{'sizeinbytes': 129}) 0773 return self.__field_pad.getvalue() 0774 0775 def __setfield_pad(self, value): 0776 if isinstance(value,UNKNOWN): 0777 self.__field_pad=value 0778 else: 0779 self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 129}) 0780 0781 def __delfield_pad(self): del self.__field_pad 0782 0783 pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None) 0784 0785 def iscontainer(self): 0786 return True 0787 0788 def containerelements(self): 0789 yield ('header', self.__field_header, None) 0790 yield ('slot', self.__field_slot, None) 0791 yield ('pad', self.__field_pad, None) 0792 0793 0794 0795 0796 class phonebookname(BaseProtogenClass): 0797 __fields=['pad1', 'nonzeroifused', 'pspeed', 'numbers', 'pemail', 'purl', 'dunno2', 'name', 'pad2', 'pad2', 'sometimesfive'] 0798 0799 def __init__(self, *args, **kwargs): 0800 dict={} 0801 # What was supplied to this function 0802 dict.update(kwargs) 0803 # Parent constructor 0804 super(phonebookname,self).__init__(**dict) 0805 if self.__class__ is phonebookname: 0806 self._update(args,dict) 0807 0808 0809 def getfields(self): 0810 return self.__fields 0811 0812 0813 def _update(self, args, kwargs): 0814 super(phonebookname,self)._update(args,kwargs) 0815 keys=kwargs.keys() 0816 for key in keys: 0817 if key in self.__fields: 0818 setattr(self, key, kwargs[key]) 0819 del kwargs[key] 0820 # Were any unrecognized kwargs passed in? 0821 if __debug__: 0822 self._complainaboutunusedargs(phonebookname,kwargs) 0823 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 0824 # Make all P fields that haven't already been constructed 0825 0826 0827 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 0828 'Writes this packet to the supplied buffer' 0829 self._bufferstartoffset=buf.getcurrentoffset() 0830 self.__field_pad1.writetobuffer(buf) 0831 self.__field_nonzeroifused.writetobuffer(buf) 0832 self.__field_pspeed.writetobuffer(buf) 0833 self.__field_numbers.writetobuffer(buf) 0834 self.__field_pemail.writetobuffer(buf) 0835 self.__field_purl.writetobuffer(buf) 0836 self.__field_dunno2.writetobuffer(buf) 0837 self.__field_name.writetobuffer(buf) 0838 self.__field_pad2.writetobuffer(buf) 0839 self.__field_pad2.writetobuffer(buf) 0840 self.__field_sometimesfive.writetobuffer(buf) 0841 self._bufferendoffset=buf.getcurrentoffset() 0842 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 0843 0844 0845 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 0846 'Reads this packet from the supplied buffer' 0847 self._bufferstartoffset=buf.getcurrentoffset() 0848 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 0849 self.__field_pad1=UNKNOWN(**{'sizeinbytes': 1}) 0850 self.__field_pad1.readfrombuffer(buf) 0851 self.__field_nonzeroifused=UINT(**{'sizeinbytes': 2}) 0852 self.__field_nonzeroifused.readfrombuffer(buf) 0853 self.__field_pspeed=UINT(**{'sizeinbytes': 2}) 0854 self.__field_pspeed.readfrombuffer(buf) 0855 self.__field_numbers=LIST(**{'elementclass': _gen_p_samsungsphn400_62, 'length': 7}) 0856 self.__field_numbers.readfrombuffer(buf) 0857 self.__field_pemail=UINT(**{'sizeinbytes': 2}) 0858 self.__field_pemail.readfrombuffer(buf) 0859 self.__field_purl=UINT(**{'sizeinbytes': 2}) 0860 self.__field_purl.readfrombuffer(buf) 0861 self.__field_dunno2=UINT(**{'sizeinbytes': 2}) 0862 self.__field_dunno2.readfrombuffer(buf) 0863 self.__field_name=USTRING(**{'sizeinbytes': 12}) 0864 self.__field_name.readfrombuffer(buf) 0865 self.__field_pad2=UNKNOWN(**{'sizeinbytes': 3}) 0866 self.__field_pad2.readfrombuffer(buf) 0867 self.__field_pad2=UNKNOWN(**{'sizeinbytes': 87}) 0868 self.__field_pad2.readfrombuffer(buf) 0869 self.__field_sometimesfive=UINT(**{'sizeinbytes': 2, 'default': 5}) 0870 self.__field_sometimesfive.readfrombuffer(buf) 0871 self._bufferendoffset=buf.getcurrentoffset() 0872 0873 0874 def __getfield_pad1(self): 0875 return self.__field_pad1.getvalue() 0876 0877 def __setfield_pad1(self, value): 0878 if isinstance(value,UNKNOWN): 0879 self.__field_pad1=value 0880 else: 0881 self.__field_pad1=UNKNOWN(value,**{'sizeinbytes': 1}) 0882 0883 def __delfield_pad1(self): del self.__field_pad1 0884 0885 pad1=property(__getfield_pad1, __setfield_pad1, __delfield_pad1, None) 0886 0887 def __getfield_nonzeroifused(self): 0888 return self.__field_nonzeroifused.getvalue() 0889 0890 def __setfield_nonzeroifused(self, value): 0891 if isinstance(value,UINT): 0892 self.__field_nonzeroifused=value 0893 else: 0894 self.__field_nonzeroifused=UINT(value,**{'sizeinbytes': 2}) 0895 0896 def __delfield_nonzeroifused(self): del self.__field_nonzeroifused 0897 0898 nonzeroifused=property(__getfield_nonzeroifused, __setfield_nonzeroifused, __delfield_nonzeroifused, None) 0899 0900 def __getfield_pspeed(self): 0901 return self.__field_pspeed.getvalue() 0902 0903 def __setfield_pspeed(self, value): 0904 if isinstance(value,UINT): 0905 self.__field_pspeed=value 0906 else: 0907 self.__field_pspeed=UINT(value,**{'sizeinbytes': 2}) 0908 0909 def __delfield_pspeed(self): del self.__field_pspeed 0910 0911 pspeed=property(__getfield_pspeed, __setfield_pspeed, __delfield_pspeed, None) 0912 0913 def __getfield_numbers(self): 0914 return self.__field_numbers.getvalue() 0915 0916 def __setfield_numbers(self, value): 0917 if isinstance(value,LIST): 0918 self.__field_numbers=value 0919 else: 0920 self.__field_numbers=LIST(value,**{'elementclass': _gen_p_samsungsphn400_62, 'length': 7}) 0921 0922 def __delfield_numbers(self): del self.__field_numbers 0923 0924 numbers=property(__getfield_numbers, __setfield_numbers, __delfield_numbers, None) 0925 0926 def __getfield_pemail(self): 0927 return self.__field_pemail.getvalue() 0928 0929 def __setfield_pemail(self, value): 0930 if isinstance(value,UINT): 0931 self.__field_pemail=value 0932 else: 0933 self.__field_pemail=UINT(value,**{'sizeinbytes': 2}) 0934 0935 def __delfield_pemail(self): del self.__field_pemail 0936 0937 pemail=property(__getfield_pemail, __setfield_pemail, __delfield_pemail, None) 0938 0939 def __getfield_purl(self): 0940 return self.__field_purl.getvalue() 0941 0942 def __setfield_purl(self, value): 0943 if isinstance(value,UINT): 0944 self.__field_purl=value 0945 else: 0946 self.__field_purl=UINT(value,**{'sizeinbytes': 2}) 0947 0948 def __delfield_purl(self): del self.__field_purl 0949 0950 purl=property(__getfield_purl, __setfield_purl, __delfield_purl, None) 0951 0952 def __getfield_dunno2(self): 0953 return self.__field_dunno2.getvalue() 0954 0955 def __setfield_dunno2(self, value): 0956 if isinstance(value,UINT): 0957 self.__field_dunno2=value 0958 else: 0959 self.__field_dunno2=UINT(value,**{'sizeinbytes': 2}) 0960 0961 def __delfield_dunno2(self): del self.__field_dunno2 0962 0963 dunno2=property(__getfield_dunno2, __setfield_dunno2, __delfield_dunno2, None) 0964 0965 def __getfield_name(self): 0966 return self.__field_name.getvalue() 0967 0968 def __setfield_name(self, value): 0969 if isinstance(value,USTRING): 0970 self.__field_name=value 0971 else: 0972 self.__field_name=USTRING(value,**{'sizeinbytes': 12}) 0973 0974 def __delfield_name(self): del self.__field_name 0975 0976 name=property(__getfield_name, __setfield_name, __delfield_name, None) 0977 0978 def __getfield_pad2(self): 0979 return self.__field_pad2.getvalue() 0980 0981 def __setfield_pad2(self, value): 0982 if isinstance(value,UNKNOWN): 0983 self.__field_pad2=value 0984 else: 0985 self.__field_pad2=UNKNOWN(value,**{'sizeinbytes': 3}) 0986 0987 def __delfield_pad2(self): del self.__field_pad2 0988 0989 pad2=property(__getfield_pad2, __setfield_pad2, __delfield_pad2, None) 0990 0991 def __getfield_pad2(self): 0992 return self.__field_pad2.getvalue() 0993 0994 def __setfield_pad2(self, value): 0995 if isinstance(value,UNKNOWN): 0996 self.__field_pad2=value 0997 else: 0998 self.__field_pad2=UNKNOWN(value,**{'sizeinbytes': 87}) 0999 1000 def __delfield_pad2(self): del self.__field_pad2 1001 1002 pad2=property(__getfield_pad2, __setfield_pad2, __delfield_pad2, None) 1003 1004 def __getfield_sometimesfive(self): 1005 return self.__field_sometimesfive.getvalue() 1006 1007 def __setfield_sometimesfive(self, value): 1008 if isinstance(value,UINT): 1009 self.__field_sometimesfive=value 1010 else: 1011 self.__field_sometimesfive=UINT(value,**{'sizeinbytes': 2, 'default': 5}) 1012 1013 def __delfield_sometimesfive(self): del self.__field_sometimesfive 1014 1015 sometimesfive=property(__getfield_sometimesfive, __setfield_sometimesfive, __delfield_sometimesfive, None) 1016 1017 def iscontainer(self): 1018 return True 1019 1020 def containerelements(self): 1021 yield ('pad1', self.__field_pad1, None) 1022 yield ('nonzeroifused', self.__field_nonzeroifused, None) 1023 yield ('pspeed', self.__field_pspeed, None) 1024 yield ('numbers', self.__field_numbers, None) 1025 yield ('pemail', self.__field_pemail, None) 1026 yield ('purl', self.__field_purl, None) 1027 yield ('dunno2', self.__field_dunno2, None) 1028 yield ('name', self.__field_name, None) 1029 yield ('pad2', self.__field_pad2, None) 1030 yield ('pad2', self.__field_pad2, None) 1031 yield ('sometimesfive', self.__field_sometimesfive, None) 1032 1033 1034 1035 1036 class _gen_p_samsungsphn400_62(BaseProtogenClass): 1037 'Anonymous inner class' 1038 __fields=['pnumber'] 1039 1040 def __init__(self, *args, **kwargs): 1041 dict={} 1042 # What was supplied to this function 1043 dict.update(kwargs) 1044 # Parent constructor 1045 super(_gen_p_samsungsphn400_62,self).__init__(**dict) 1046 if self.__class__ is _gen_p_samsungsphn400_62: 1047 self._update(args,dict) 1048 1049 1050 def getfields(self): 1051 return self.__fields 1052 1053 1054 def _update(self, args, kwargs): 1055 super(_gen_p_samsungsphn400_62,self)._update(args,kwargs) 1056 keys=kwargs.keys() 1057 for key in keys: 1058 if key in self.__fields: 1059 setattr(self, key, kwargs[key]) 1060 del kwargs[key] 1061 # Were any unrecognized kwargs passed in? 1062 if __debug__: 1063 self._complainaboutunusedargs(_gen_p_samsungsphn400_62,kwargs) 1064 if len(args): 1065 dict2={'sizeinbytes': 2} 1066 dict2.update(kwargs) 1067 kwargs=dict2 1068 self.__field_pnumber=UINT(*args,**dict2) 1069 # Make all P fields that haven't already been constructed 1070 1071 1072 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 1073 'Writes this packet to the supplied buffer' 1074 self._bufferstartoffset=buf.getcurrentoffset() 1075 self.__field_pnumber.writetobuffer(buf) 1076 self._bufferendoffset=buf.getcurrentoffset() 1077 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 1078 1079 1080 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 1081 'Reads this packet from the supplied buffer' 1082 self._bufferstartoffset=buf.getcurrentoffset() 1083 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 1084 self.__field_pnumber=UINT(**{'sizeinbytes': 2}) 1085 self.__field_pnumber.readfrombuffer(buf) 1086 self._bufferendoffset=buf.getcurrentoffset() 1087 1088 1089 def __getfield_pnumber(self): 1090 return self.__field_pnumber.getvalue() 1091 1092 def __setfield_pnumber(self, value): 1093 if isinstance(value,UINT): 1094 self.__field_pnumber=value 1095 else: 1096 self.__field_pnumber=UINT(value,**{'sizeinbytes': 2}) 1097 1098 def __delfield_pnumber(self): del self.__field_pnumber 1099 1100 pnumber=property(__getfield_pnumber, __setfield_pnumber, __delfield_pnumber, None) 1101 1102 def iscontainer(self): 1103 return True 1104 1105 def containerelements(self): 1106 yield ('pnumber', self.__field_pnumber, None) 1107 1108 1109 1110 1111 class phonebooknameresponse(BaseProtogenClass): 1112 __fields=['header', 'slot', 'entry', 'pad'] 1113 1114 def __init__(self, *args, **kwargs): 1115 dict={} 1116 # What was supplied to this function 1117 dict.update(kwargs) 1118 # Parent constructor 1119 super(phonebooknameresponse,self).__init__(**dict) 1120 if self.__class__ is phonebooknameresponse: 1121 self._update(args,dict) 1122 1123 1124 def getfields(self): 1125 return self.__fields 1126 1127 1128 def _update(self, args, kwargs): 1129 super(phonebooknameresponse,self)._update(args,kwargs) 1130 keys=kwargs.keys() 1131 for key in keys: 1132 if key in self.__fields: 1133 setattr(self, key, kwargs[key]) 1134 del kwargs[key] 1135 # Were any unrecognized kwargs passed in? 1136 if __debug__: 1137 self._complainaboutunusedargs(phonebooknameresponse,kwargs) 1138 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 1139 # Make all P fields that haven't already been constructed 1140 1141 1142 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 1143 'Writes this packet to the supplied buffer' 1144 self._bufferstartoffset=buf.getcurrentoffset() 1145 self.__field_header.writetobuffer(buf) 1146 self.__field_slot.writetobuffer(buf) 1147 self.__field_entry.writetobuffer(buf) 1148 self.__field_pad.writetobuffer(buf) 1149 self._bufferendoffset=buf.getcurrentoffset() 1150 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 1151 1152 1153 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 1154 'Reads this packet from the supplied buffer' 1155 self._bufferstartoffset=buf.getcurrentoffset() 1156 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 1157 self.__field_header=samheader() 1158 self.__field_header.readfrombuffer(buf) 1159 self.__field_slot=UINT(**{'sizeinbytes': 1}) 1160 self.__field_slot.readfrombuffer(buf) 1161 self.__field_entry=phonebookname() 1162 self.__field_entry.readfrombuffer(buf) 1163 self.__field_pad=UNKNOWN() 1164 self.__field_pad.readfrombuffer(buf) 1165 self._bufferendoffset=buf.getcurrentoffset() 1166 1167 1168 def __getfield_header(self): 1169 return self.__field_header.getvalue() 1170 1171 def __setfield_header(self, value): 1172 if isinstance(value,samheader): 1173 self.__field_header=value 1174 else: 1175 self.__field_header=samheader(value,) 1176 1177 def __delfield_header(self): del self.__field_header 1178 1179 header=property(__getfield_header, __setfield_header, __delfield_header, None) 1180 1181 def __getfield_slot(self): 1182 return self.__field_slot.getvalue() 1183 1184 def __setfield_slot(self, value): 1185 if isinstance(value,UINT): 1186 self.__field_slot=value 1187 else: 1188 self.__field_slot=UINT(value,**{'sizeinbytes': 1}) 1189 1190 def __delfield_slot(self): del self.__field_slot 1191 1192 slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None) 1193 1194 def __getfield_entry(self): 1195 return self.__field_entry.getvalue() 1196 1197 def __setfield_entry(self, value): 1198 if isinstance(value,phonebookname): 1199 self.__field_entry=value 1200 else: 1201 self.__field_entry=phonebookname(value,) 1202 1203 def __delfield_entry(self): del self.__field_entry 1204 1205 entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None) 1206 1207 def __getfield_pad(self): 1208 return self.__field_pad.getvalue() 1209 1210 def __setfield_pad(self, value): 1211 if isinstance(value,UNKNOWN): 1212 self.__field_pad=value 1213 else: 1214 self.__field_pad=UNKNOWN(value,) 1215 1216 def __delfield_pad(self): del self.__field_pad 1217 1218 pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None) 1219 1220 def iscontainer(self): 1221 return True 1222 1223 def containerelements(self): 1224 yield ('header', self.__field_header, None) 1225 yield ('slot', self.__field_slot, None) 1226 yield ('entry', self.__field_entry, None) 1227 yield ('pad', self.__field_pad, None) 1228 1229 1230 1231 1232 class phonebooknumbersrequest(BaseProtogenClass): 1233 __fields=['header', 'slot', 'pad'] 1234 1235 def __init__(self, *args, **kwargs): 1236 dict={} 1237 # What was supplied to this function 1238 dict.update(kwargs) 1239 # Parent constructor 1240 super(phonebooknumbersrequest,self).__init__(**dict) 1241 if self.__class__ is phonebooknumbersrequest: 1242 self._update(args,dict) 1243 1244 1245 def getfields(self): 1246 return self.__fields 1247 1248 1249 def _update(self, args, kwargs): 1250 super(phonebooknumbersrequest,self)._update(args,kwargs) 1251 keys=kwargs.keys() 1252 for key in keys: 1253 if key in self.__fields: 1254 setattr(self, key, kwargs[key]) 1255 del kwargs[key] 1256 # Were any unrecognized kwargs passed in? 1257 if __debug__: 1258 self._complainaboutunusedargs(phonebooknumbersrequest,kwargs) 1259 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 1260 # Make all P fields that haven't already been constructed 1261 1262 1263 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 1264 'Writes this packet to the supplied buffer' 1265 self._bufferstartoffset=buf.getcurrentoffset() 1266 try: self.__field_header 1267 except: 1268 self.__field_header=samheader(**{'attribute': 0x026A}) 1269 self.__field_header.writetobuffer(buf) 1270 self.__field_slot.writetobuffer(buf) 1271 try: self.__field_pad 1272 except: 1273 self.__field_pad=UNKNOWN(**{'sizeinbytes': 129}) 1274 self.__field_pad.writetobuffer(buf) 1275 self._bufferendoffset=buf.getcurrentoffset() 1276 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 1277 1278 1279 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 1280 'Reads this packet from the supplied buffer' 1281 self._bufferstartoffset=buf.getcurrentoffset() 1282 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 1283 self.__field_header=samheader(**{'attribute': 0x026A}) 1284 self.__field_header.readfrombuffer(buf) 1285 self.__field_slot=UINT(**{'sizeinbytes': 1}) 1286 self.__field_slot.readfrombuffer(buf) 1287 self.__field_pad=UNKNOWN(**{'sizeinbytes': 129}) 1288 self.__field_pad.readfrombuffer(buf) 1289 self._bufferendoffset=buf.getcurrentoffset() 1290 1291 1292 def __getfield_header(self): 1293 try: self.__field_header 1294 except: 1295 self.__field_header=samheader(**{'attribute': 0x026A}) 1296 return self.__field_header.getvalue() 1297 1298 def __setfield_header(self, value): 1299 if isinstance(value,samheader): 1300 self.__field_header=value 1301 else: 1302 self.__field_header=samheader(value,**{'attribute': 0x026A}) 1303 1304 def __delfield_header(self): del self.__field_header 1305 1306 header=property(__getfield_header, __setfield_header, __delfield_header, None) 1307 1308 def __getfield_slot(self): 1309 return self.__field_slot.getvalue() 1310 1311 def __setfield_slot(self, value): 1312 if isinstance(value,UINT): 1313 self.__field_slot=value 1314 else: 1315 self.__field_slot=UINT(value,**{'sizeinbytes': 1}) 1316 1317 def __delfield_slot(self): del self.__field_slot 1318 1319 slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None) 1320 1321 def __getfield_pad(self): 1322 try: self.__field_pad 1323 except: 1324 self.__field_pad=UNKNOWN(**{'sizeinbytes': 129}) 1325 return self.__field_pad.getvalue() 1326 1327 def __setfield_pad(self, value): 1328 if isinstance(value,UNKNOWN): 1329 self.__field_pad=value 1330 else: 1331 self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 129}) 1332 1333 def __delfield_pad(self): del self.__field_pad 1334 1335 pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None) 1336 1337 def iscontainer(self): 1338 return True 1339 1340 def containerelements(self): 1341 yield ('header', self.__field_header, None) 1342 yield ('slot', self.__field_slot, None) 1343 yield ('pad', self.__field_pad, None) 1344 1345 1346 1347 1348 class phonebooknumbers(BaseProtogenClass): 1349 __fields=['pad', 'number_len', 'number'] 1350 1351 def __init__(self, *args, **kwargs): 1352 dict={} 1353 # What was supplied to this function 1354 dict.update(kwargs) 1355 # Parent constructor 1356 super(phonebooknumbers,self).__init__(**dict) 1357 if self.__class__ is phonebooknumbers: 1358 self._update(args,dict) 1359 1360 1361 def getfields(self): 1362 return self.__fields 1363 1364 1365 def _update(self, args, kwargs): 1366 super(phonebooknumbers,self)._update(args,kwargs) 1367 keys=kwargs.keys() 1368 for key in keys: 1369 if key in self.__fields: 1370 setattr(self, key, kwargs[key]) 1371 del kwargs[key] 1372 # Were any unrecognized kwargs passed in? 1373 if __debug__: 1374 self._complainaboutunusedargs(phonebooknumbers,kwargs) 1375 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 1376 # Make all P fields that haven't already been constructed 1377 1378 1379 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 1380 'Writes this packet to the supplied buffer' 1381 self._bufferstartoffset=buf.getcurrentoffset() 1382 self.__field_pad.writetobuffer(buf) 1383 self.__field_number_len.writetobuffer(buf) 1384 self.__field_number.writetobuffer(buf) 1385 self._bufferendoffset=buf.getcurrentoffset() 1386 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 1387 1388 1389 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 1390 'Reads this packet from the supplied buffer' 1391 self._bufferstartoffset=buf.getcurrentoffset() 1392 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 1393 self.__field_pad=UNKNOWN(**{'sizeinbytes': 2}) 1394 self.__field_pad.readfrombuffer(buf) 1395 self.__field_number_len=UINT(**{'sizeinbytes': 1}) 1396 self.__field_number_len.readfrombuffer(buf) 1397 self.__field_number=USTRING(**{'sizeinbytes': 32, 'raiseonunterminatedread': False}) 1398 self.__field_number.readfrombuffer(buf) 1399 self._bufferendoffset=buf.getcurrentoffset() 1400 1401 1402 def __getfield_pad(self): 1403 return self.__field_pad.getvalue() 1404 1405 def __setfield_pad(self, value): 1406 if isinstance(value,UNKNOWN): 1407 self.__field_pad=value 1408 else: 1409 self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 2}) 1410 1411 def __delfield_pad(self): del self.__field_pad 1412 1413 pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None) 1414 1415 def __getfield_number_len(self): 1416 return self.__field_number_len.getvalue() 1417 1418 def __setfield_number_len(self, value): 1419 if isinstance(value,UINT): 1420 self.__field_number_len=value 1421 else: 1422 self.__field_number_len=UINT(value,**{'sizeinbytes': 1}) 1423 1424 def __delfield_number_len(self): del self.__field_number_len 1425 1426 number_len=property(__getfield_number_len, __setfield_number_len, __delfield_number_len, None) 1427 1428 def __getfield_number(self): 1429 return self.__field_number.getvalue() 1430 1431 def __setfield_number(self, value): 1432 if isinstance(value,USTRING): 1433 self.__field_number=value 1434 else: 1435 self.__field_number=USTRING(value,**{'sizeinbytes': 32, 'raiseonunterminatedread': False}) 1436 1437 def __delfield_number(self): del self.__field_number 1438 1439 number=property(__getfield_number, __setfield_number, __delfield_number, None) 1440 1441 def iscontainer(self): 1442 return True 1443 1444 def containerelements(self): 1445 yield ('pad', self.__field_pad, None) 1446 yield ('number_len', self.__field_number_len, None) 1447 yield ('number', self.__field_number, None) 1448 1449 1450 1451 1452 class phonebooknumbersresponse(BaseProtogenClass): 1453 __fields=['header', 'slot', 'entry', 'pad'] 1454 1455 def __init__(self, *args, **kwargs): 1456 dict={} 1457 # What was supplied to this function 1458 dict.update(kwargs) 1459 # Parent constructor 1460 super(phonebooknumbersresponse,self).__init__(**dict) 1461 if self.__class__ is phonebooknumbersresponse: 1462 self._update(args,dict) 1463 1464 1465 def getfields(self): 1466 return self.__fields 1467 1468 1469 def _update(self, args, kwargs): 1470 super(phonebooknumbersresponse,self)._update(args,kwargs) 1471 keys=kwargs.keys() 1472 for key in keys: 1473 if key in self.__fields: 1474 setattr(self, key, kwargs[key]) 1475 del kwargs[key] 1476 # Were any unrecognized kwargs passed in? 1477 if __debug__: 1478 self._complainaboutunusedargs(phonebooknumbersresponse,kwargs) 1479 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 1480 # Make all P fields that haven't already been constructed 1481 1482 1483 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 1484 'Writes this packet to the supplied buffer' 1485 self._bufferstartoffset=buf.getcurrentoffset() 1486 self.__field_header.writetobuffer(buf) 1487 self.__field_slot.writetobuffer(buf) 1488 self.__field_entry.writetobuffer(buf) 1489 self.__field_pad.writetobuffer(buf) 1490 self._bufferendoffset=buf.getcurrentoffset() 1491 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 1492 1493 1494 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 1495 'Reads this packet from the supplied buffer' 1496 self._bufferstartoffset=buf.getcurrentoffset() 1497 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 1498 self.__field_header=samheader() 1499 self.__field_header.readfrombuffer(buf) 1500 self.__field_slot=UINT(**{'sizeinbytes': 1}) 1501 self.__field_slot.readfrombuffer(buf) 1502 self.__field_entry=phonebooknumbers() 1503 self.__field_entry.readfrombuffer(buf) 1504 self.__field_pad=UNKNOWN() 1505 self.__field_pad.readfrombuffer(buf) 1506 self._bufferendoffset=buf.getcurrentoffset() 1507 1508 1509 def __getfield_header(self): 1510 return self.__field_header.getvalue() 1511 1512 def __setfield_header(self, value): 1513 if isinstance(value,samheader): 1514 self.__field_header=value 1515 else: 1516 self.__field_header=samheader(value,) 1517 1518 def __delfield_header(self): del self.__field_header 1519 1520 header=property(__getfield_header, __setfield_header, __delfield_header, None) 1521 1522 def __getfield_slot(self): 1523 return self.__field_slot.getvalue() 1524 1525 def __setfield_slot(self, value): 1526 if isinstance(value,UINT): 1527 self.__field_slot=value 1528 else: 1529 self.__field_slot=UINT(value,**{'sizeinbytes': 1}) 1530 1531 def __delfield_slot(self): del self.__field_slot 1532 1533 slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None) 1534 1535 def __getfield_entry(self): 1536 return self.__field_entry.getvalue() 1537 1538 def __setfield_entry(self, value): 1539 if isinstance(value,phonebooknumbers): 1540 self.__field_entry=value 1541 else: 1542 self.__field_entry=phonebooknumbers(value,) 1543 1544 def __delfield_entry(self): del self.__field_entry 1545 1546 entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None) 1547 1548 def __getfield_pad(self): 1549 return self.__field_pad.getvalue() 1550 1551 def __setfield_pad(self, value): 1552 if isinstance(value,UNKNOWN): 1553 self.__field_pad=value 1554 else: 1555 self.__field_pad=UNKNOWN(value,) 1556 1557 def __delfield_pad(self): del self.__field_pad 1558 1559 pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None) 1560 1561 def iscontainer(self): 1562 return True 1563 1564 def containerelements(self): 1565 yield ('header', self.__field_header, None) 1566 yield ('slot', self.__field_slot, None) 1567 yield ('entry', self.__field_entry, None) 1568 yield ('pad', self.__field_pad, None) 1569 1570 1571 1572 1573 class attributerequest(BaseProtogenClass): 1574 __fields=['command', 'attribute', 'pad'] 1575 1576 def __init__(self, *args, **kwargs): 1577 dict={} 1578 # What was supplied to this function 1579 dict.update(kwargs) 1580 # Parent constructor 1581 super(attributerequest,self).__init__(**dict) 1582 if self.__class__ is attributerequest: 1583 self._update(args,dict) 1584 1585 1586 def getfields(self): 1587 return self.__fields 1588 1589 1590 def _update(self, args, kwargs): 1591 super(attributerequest,self)._update(args,kwargs) 1592 keys=kwargs.keys() 1593 for key in keys: 1594 if key in self.__fields: 1595 setattr(self, key, kwargs[key]) 1596 del kwargs[key] 1597 # Were any unrecognized kwargs passed in? 1598 if __debug__: 1599 self._complainaboutunusedargs(attributerequest,kwargs) 1600 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 1601 # Make all P fields that haven't already been constructed 1602 1603 1604 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 1605 'Writes this packet to the supplied buffer' 1606 self._bufferstartoffset=buf.getcurrentoffset() 1607 try: self.__field_command 1608 except: 1609 self.__field_command=UINT(**{'sizeinbytes': 1, 'constant': 0x26}) 1610 self.__field_command.writetobuffer(buf) 1611 self.__field_attribute.writetobuffer(buf) 1612 try: self.__field_pad 1613 except: 1614 self.__field_pad=UNKNOWN(**{'sizeinbytes': 259}) 1615 self.__field_pad.writetobuffer(buf) 1616 self._bufferendoffset=buf.getcurrentoffset() 1617 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 1618 1619 1620 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 1621 'Reads this packet from the supplied buffer' 1622 self._bufferstartoffset=buf.getcurrentoffset() 1623 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 1624 self.__field_command=UINT(**{'sizeinbytes': 1, 'constant': 0x26}) 1625 self.__field_command.readfrombuffer(buf) 1626 self.__field_attribute=UINT(**{'sizeinbytes': 2}) 1627 self.__field_attribute.readfrombuffer(buf) 1628 self.__field_pad=UNKNOWN(**{'sizeinbytes': 259}) 1629 self.__field_pad.readfrombuffer(buf) 1630 self._bufferendoffset=buf.getcurrentoffset() 1631 1632 1633 def __getfield_command(self): 1634 try: self.__field_command 1635 except: 1636 self.__field_command=UINT(**{'sizeinbytes': 1, 'constant': 0x26}) 1637 return self.__field_command.getvalue() 1638 1639 def __setfield_command(self, value): 1640 if isinstance(value,UINT): 1641 self.__field_command=value 1642 else: 1643 self.__field_command=UINT(value,**{'sizeinbytes': 1, 'constant': 0x26}) 1644 1645 def __delfield_command(self): del self.__field_command 1646 1647 command=property(__getfield_command, __setfield_command, __delfield_command, None) 1648 1649 def __getfield_attribute(self): 1650 return self.__field_attribute.getvalue() 1651 1652 def __setfield_attribute(self, value): 1653 if isinstance(value,UINT): 1654 self.__field_attribute=value 1655 else: 1656 self.__field_attribute=UINT(value,**{'sizeinbytes': 2}) 1657 1658 def __delfield_attribute(self): del self.__field_attribute 1659 1660 attribute=property(__getfield_attribute, __setfield_attribute, __delfield_attribute, None) 1661 1662 def __getfield_pad(self): 1663 try: self.__field_pad 1664 except: 1665 self.__field_pad=UNKNOWN(**{'sizeinbytes': 259}) 1666 return self.__field_pad.getvalue() 1667 1668 def __setfield_pad(self, value): 1669 if isinstance(value,UNKNOWN): 1670 self.__field_pad=value 1671 else: 1672 self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 259}) 1673 1674 def __delfield_pad(self): del self.__field_pad 1675 1676 pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None) 1677 1678 def iscontainer(self): 1679 return True 1680 1681 def containerelements(self): 1682 yield ('command', self.__field_command, None) 1683 yield ('attribute', self.__field_attribute, None) 1684 yield ('pad', self.__field_pad, None) 1685 1686 1687 1688 1689
Generated by PyXR 0.9.4