phones.p_lgtm520

1 # THIS FILE IS AUTOMATICALLY GENERATED. EDIT THE SOURCE FILE NOT THIS ONE 2 3 """Various descriptions of data specific to LG TM520""" 4 5 from prototypes import * 6 7 # Make all lg stuff available in this module as well 8 from p_lg import * 9 10 # We use LSB for all integer like fields 11 UINT=UINTlsb 12 BOOL=BOOLlsb 13

14 -class pbreadentryresponse(BaseProtogenClass):

15 "Results of reading one entry" 16 __fields=['header', 'entry'] 17

18 - def __init__(self, *args, **kwargs):

19 dict={} 20 # What was supplied to this function 21 dict.update(kwargs) 22 # Parent constructor 23 super(pbreadentryresponse,self).__init__(**dict) 24 if self.__class__ is pbreadentryresponse: 25 self._update(args,dict)

26 27

28 - def getfields(self):

29 return self.__fields

30 31

32 - def _update(self, args, kwargs):

33 super(pbreadentryresponse,self)._update(args,kwargs) 34 keys=kwargs.keys() 35 for key in keys: 36 if key in self.__fields: 37 setattr(self, key, kwargs[key]) 38 del kwargs[key] 39 # Were any unrecognized kwargs passed in? 40 if __debug__: 41 self._complainaboutunusedargs(pbreadentryresponse,kwargs) 42 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)

43 # Make all P fields that haven't already been constructed 44 45

46 - def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):

47 'Writes this packet to the supplied buffer' 48 self._bufferstartoffset=buf.getcurrentoffset() 49 self.__field_header.writetobuffer(buf) 50 self.__field_entry.writetobuffer(buf) 51 self._bufferendoffset=buf.getcurrentoffset() 52 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)

53 54

55 - def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):

56 'Reads this packet from the supplied buffer' 57 self._bufferstartoffset=buf.getcurrentoffset() 58 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 59 self.__field_header=pbheader() 60 self.__field_header.readfrombuffer(buf) 61 self.__field_entry=pbentry() 62 self.__field_entry.readfrombuffer(buf) 63 self._bufferendoffset=buf.getcurrentoffset()

64 65

66 - def __getfield_header(self):

67 return self.__field_header.getvalue()

68

69 - def __setfield_header(self, value):

70 if isinstance(value,pbheader): 71 self.__field_header=value 72 else: 73 self.__field_header=pbheader(value,)

74

75 - def __delfield_header(self): del self.__field_header

76 77 header=property(__getfield_header, __setfield_header, __delfield_header, None) 78

79 - def __getfield_entry(self):

80 return self.__field_entry.getvalue()

81

82 - def __setfield_entry(self, value):

83 if isinstance(value,pbentry): 84 self.__field_entry=value 85 else: 86 self.__field_entry=pbentry(value,)

87

88 - def __delfield_entry(self): del self.__field_entry

89 90 entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None) 91

92 - def iscontainer(self):

93 return True

94

95 - def containerelements(self):

96 yield ('header', self.__field_header, None) 97 yield ('entry', self.__field_entry, None)

98 99 100 101

102 -class pbupdateentryrequest(BaseProtogenClass):

103 __fields=['header', 'entry'] 104

105 - def __init__(self, *args, **kwargs):

106 dict={} 107 # What was supplied to this function 108 dict.update(kwargs) 109 # Parent constructor 110 super(pbupdateentryrequest,self).__init__(**dict) 111 if self.__class__ is pbupdateentryrequest: 112 self._update(args,dict)

113 114

115 - def getfields(self):

116 return self.__fields

117 118

119 - def _update(self, args, kwargs):

120 super(pbupdateentryrequest,self)._update(args,kwargs) 121 keys=kwargs.keys() 122 for key in keys: 123 if key in self.__fields: 124 setattr(self, key, kwargs[key]) 125 del kwargs[key] 126 # Were any unrecognized kwargs passed in? 127 if __debug__: 128 self._complainaboutunusedargs(pbupdateentryrequest,kwargs) 129 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)

130 # Make all P fields that haven't already been constructed 131 132

133 - def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):

134 'Writes this packet to the supplied buffer' 135 self._bufferstartoffset=buf.getcurrentoffset() 136 try: self.__field_header 137 except: 138 self.__field_header=pbheader(**{'command': 0x04, 'flag': 0x01}) 139 self.__field_header.writetobuffer(buf) 140 self.__field_entry.writetobuffer(buf) 141 self._bufferendoffset=buf.getcurrentoffset() 142 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)

143 144

145 - def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):

146 'Reads this packet from the supplied buffer' 147 self._bufferstartoffset=buf.getcurrentoffset() 148 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 149 self.__field_header=pbheader(**{'command': 0x04, 'flag': 0x01}) 150 self.__field_header.readfrombuffer(buf) 151 self.__field_entry=pbentry() 152 self.__field_entry.readfrombuffer(buf) 153 self._bufferendoffset=buf.getcurrentoffset()

154 155

156 - def __getfield_header(self):

157 try: self.__field_header 158 except: 159 self.__field_header=pbheader(**{'command': 0x04, 'flag': 0x01}) 160 return self.__field_header.getvalue()

161

162 - def __setfield_header(self, value):

163 if isinstance(value,pbheader): 164 self.__field_header=value 165 else: 166 self.__field_header=pbheader(value,**{'command': 0x04, 'flag': 0x01})

167

168 - def __delfield_header(self): del self.__field_header

169 170 header=property(__getfield_header, __setfield_header, __delfield_header, None) 171

172 - def __getfield_entry(self):

173 return self.__field_entry.getvalue()

174

175 - def __setfield_entry(self, value):

176 if isinstance(value,pbentry): 177 self.__field_entry=value 178 else: 179 self.__field_entry=pbentry(value,)

180

181 - def __delfield_entry(self): del self.__field_entry

182 183 entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None) 184

185 - def iscontainer(self):

186 return True

187

188 - def containerelements(self):

189 yield ('header', self.__field_header, None) 190 yield ('entry', self.__field_entry, None)

191 192 193 194

195 -class pbappendentryrequest(BaseProtogenClass):

196 __fields=['header', 'entry'] 197

198 - def __init__(self, *args, **kwargs):

199 dict={} 200 # What was supplied to this function 201 dict.update(kwargs) 202 # Parent constructor 203 super(pbappendentryrequest,self).__init__(**dict) 204 if self.__class__ is pbappendentryrequest: 205 self._update(args,dict)

206 207

208 - def getfields(self):

209 return self.__fields

210 211

212 - def _update(self, args, kwargs):

213 super(pbappendentryrequest,self)._update(args,kwargs) 214 keys=kwargs.keys() 215 for key in keys: 216 if key in self.__fields: 217 setattr(self, key, kwargs[key]) 218 del kwargs[key] 219 # Were any unrecognized kwargs passed in? 220 if __debug__: 221 self._complainaboutunusedargs(pbappendentryrequest,kwargs) 222 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)

223 # Make all P fields that haven't already been constructed 224 225

226 - def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):

227 'Writes this packet to the supplied buffer' 228 self._bufferstartoffset=buf.getcurrentoffset() 229 try: self.__field_header 230 except: 231 self.__field_header=pbheader(**{'command': 0x03, 'flag': 0x01}) 232 self.__field_header.writetobuffer(buf) 233 self.__field_entry.writetobuffer(buf) 234 self._bufferendoffset=buf.getcurrentoffset() 235 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)

236 237

238 - def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):

239 'Reads this packet from the supplied buffer' 240 self._bufferstartoffset=buf.getcurrentoffset() 241 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 242 self.__field_header=pbheader(**{'command': 0x03, 'flag': 0x01}) 243 self.__field_header.readfrombuffer(buf) 244 self.__field_entry=pbentry() 245 self.__field_entry.readfrombuffer(buf) 246 self._bufferendoffset=buf.getcurrentoffset()

247 248

249 - def __getfield_header(self):

250 try: self.__field_header 251 except: 252 self.__field_header=pbheader(**{'command': 0x03, 'flag': 0x01}) 253 return self.__field_header.getvalue()

254

255 - def __setfield_header(self, value):

256 if isinstance(value,pbheader): 257 self.__field_header=value 258 else: 259 self.__field_header=pbheader(value,**{'command': 0x03, 'flag': 0x01})

260

261 - def __delfield_header(self): del self.__field_header

262 263 header=property(__getfield_header, __setfield_header, __delfield_header, None) 264

265 - def __getfield_entry(self):

266 return self.__field_entry.getvalue()

267

268 - def __setfield_entry(self, value):

269 if isinstance(value,pbentry): 270 self.__field_entry=value 271 else: 272 self.__field_entry=pbentry(value,)

273

274 - def __delfield_entry(self): del self.__field_entry

275 276 entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None) 277

278 - def iscontainer(self):

279 return True

280

281 - def containerelements(self):

282 yield ('header', self.__field_header, None) 283 yield ('entry', self.__field_entry, None)

284 285 286 287

288 -class numentry(BaseProtogenClass):

289 __fields=['number', 'chksum'] 290

291 - def __init__(self, *args, **kwargs):

292 dict={} 293 # What was supplied to this function 294 dict.update(kwargs) 295 # Parent constructor 296 super(numentry,self).__init__(**dict) 297 if self.__class__ is numentry: 298 self._update(args,dict)

299 300

301 - def getfields(self):

302 return self.__fields

303 304

305 - def _update(self, args, kwargs):

306 super(numentry,self)._update(args,kwargs) 307 keys=kwargs.keys() 308 for key in keys: 309 if key in self.__fields: 310 setattr(self, key, kwargs[key]) 311 del kwargs[key] 312 # Were any unrecognized kwargs passed in? 313 if __debug__: 314 self._complainaboutunusedargs(numentry,kwargs) 315 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)

316 # Make all P fields that haven't already been constructed 317 318

319 - def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):

320 'Writes this packet to the supplied buffer' 321 self._bufferstartoffset=buf.getcurrentoffset() 322 self.__field_number.writetobuffer(buf) 323 self.__field_chksum.writetobuffer(buf) 324 self._bufferendoffset=buf.getcurrentoffset() 325 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)

326 327

328 - def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):

329 'Reads this packet from the supplied buffer' 330 self._bufferstartoffset=buf.getcurrentoffset() 331 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 332 self.__field_number=USTRING(**{'sizeinbytes': 33, 'raiseonunterminatedread': False}) 333 self.__field_number.readfrombuffer(buf) 334 self.__field_chksum=UINT(**{'sizeinbytes': 1}) 335 self.__field_chksum.readfrombuffer(buf) 336 self._bufferendoffset=buf.getcurrentoffset()

337 338

339 - def __getfield_number(self):

340 return self.__field_number.getvalue()

341

342 - def __setfield_number(self, value):

343 if isinstance(value,USTRING): 344 self.__field_number=value 345 else: 346 self.__field_number=USTRING(value,**{'sizeinbytes': 33, 'raiseonunterminatedread': False})

347

348 - def __delfield_number(self): del self.__field_number

349 350 number=property(__getfield_number, __setfield_number, __delfield_number, None) 351

352 - def __getfield_chksum(self):

353 return self.__field_chksum.getvalue()

354

355 - def __setfield_chksum(self, value):

356 if isinstance(value,UINT): 357 self.__field_chksum=value 358 else: 359 self.__field_chksum=UINT(value,**{'sizeinbytes': 1})

360

361 - def __delfield_chksum(self): del self.__field_chksum

362 363 chksum=property(__getfield_chksum, __setfield_chksum, __delfield_chksum, None) 364

365 - def iscontainer(self):

366 return True

367

368 - def containerelements(self):

369 yield ('number', self.__field_number, None) 370 yield ('chksum', self.__field_chksum, None)

371 372 373 374

375 -class pbentry(BaseProtogenClass):

376 "Results of reading one entry" 377 __fields=['numberofemails', 'numberofphonenumbers', 'serial1', 'entrysize', 'serial2', 'entrynumber', 'name', 'secret', 'default', 'numbers', 'ringtone', 'voicetag', 'email'] 378

379 - def __init__(self, *args, **kwargs):

380 dict={} 381 # What was supplied to this function 382 dict.update(kwargs) 383 # Parent constructor 384 super(pbentry,self).__init__(**dict) 385 if self.__class__ is pbentry: 386 self._update(args,dict)

387 388

389 - def getfields(self):

390 return self.__fields

391 392

393 - def _update(self, args, kwargs):

394 super(pbentry,self)._update(args,kwargs) 395 keys=kwargs.keys() 396 for key in keys: 397 if key in self.__fields: 398 setattr(self, key, kwargs[key]) 399 del kwargs[key] 400 # Were any unrecognized kwargs passed in? 401 if __debug__: 402 self._complainaboutunusedargs(pbentry,kwargs) 403 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 404 # Make all P fields that haven't already been constructed 405 try: self.__field_numberofemails 406 except: 407 self.__field_numberofemails=UINT(**{'constant': 1}) 408 try: self.__field_numberofphonenumbers 409 except: 410 self.__field_numberofphonenumbers=UINT(**{'constant': 5})

411 412

413 - def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):

414 'Writes this packet to the supplied buffer' 415 self._bufferstartoffset=buf.getcurrentoffset() 416 self.__field_serial1.writetobuffer(buf) 417 try: self.__field_entrysize 418 except: 419 self.__field_entrysize=UINT(**{'sizeinbytes': 2, 'constant': 0xf5}) 420 self.__field_entrysize.writetobuffer(buf) 421 self.__field_serial2.writetobuffer(buf) 422 self.__field_entrynumber.writetobuffer(buf) 423 self.__field_name.writetobuffer(buf) 424 self.__field_secret.writetobuffer(buf) 425 self.__field_default.writetobuffer(buf) 426 try: self.__field_numbers 427 except: 428 self.__field_numbers=LIST(**{'length': self.numberofphonenumbers, 'elementclass': numentry, 'createdefault': True}) 429 self.__field_numbers.writetobuffer(buf) 430 self.__field_ringtone.writetobuffer(buf) 431 self.__field_voicetag.writetobuffer(buf) 432 try: self.__field_email 433 except: 434 self.__field_email=USTRING(**{'sizeinbytes': 49, 'raiseonunterminatedread': False}) 435 self.__field_email.writetobuffer(buf) 436 self._bufferendoffset=buf.getcurrentoffset() 437 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)

438 439

440 - def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):

441 'Reads this packet from the supplied buffer' 442 self._bufferstartoffset=buf.getcurrentoffset() 443 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 444 self.__field_serial1=UINT(**{'sizeinbytes': 4}) 445 self.__field_serial1.readfrombuffer(buf) 446 self.__field_entrysize=UINT(**{'sizeinbytes': 2, 'constant': 0xf5}) 447 self.__field_entrysize.readfrombuffer(buf) 448 self.__field_serial2=UINT(**{'sizeinbytes': 4}) 449 self.__field_serial2.readfrombuffer(buf) 450 self.__field_entrynumber=UINT(**{'sizeinbytes': 1}) 451 self.__field_entrynumber.readfrombuffer(buf) 452 self.__field_name=USTRING(**{'sizeinbytes': 17, 'raiseonunterminatedread': False}) 453 self.__field_name.readfrombuffer(buf) 454 self.__field_secret=BOOL(**{'sizeinbytes': 1}) 455 self.__field_secret.readfrombuffer(buf) 456 self.__field_default=UINT(**{'sizeinbytes': 1}) 457 self.__field_default.readfrombuffer(buf) 458 self.__field_numbers=LIST(**{'length': self.numberofphonenumbers, 'elementclass': numentry, 'createdefault': True}) 459 self.__field_numbers.readfrombuffer(buf) 460 self.__field_ringtone=UINT(**{'sizeinbytes': 1}) 461 self.__field_ringtone.readfrombuffer(buf) 462 self.__field_voicetag=BOOL(**{'sizeinbytes': 1}) 463 self.__field_voicetag.readfrombuffer(buf) 464 self.__field_email=USTRING(**{'sizeinbytes': 49, 'raiseonunterminatedread': False}) 465 self.__field_email.readfrombuffer(buf) 466 self._bufferendoffset=buf.getcurrentoffset()

467 468

469 - def __getfield_numberofemails(self):

470 return self.__field_numberofemails.getvalue()

471

472 - def __setfield_numberofemails(self, value):

473 if isinstance(value,UINT): 474 self.__field_numberofemails=value 475 else: 476 self.__field_numberofemails=UINT(value,**{'constant': 1})

477

478 - def __delfield_numberofemails(self): del self.__field_numberofemails

479 480 numberofemails=property(__getfield_numberofemails, __setfield_numberofemails, __delfield_numberofemails, None) 481

482 - def __getfield_numberofphonenumbers(self):

483 return self.__field_numberofphonenumbers.getvalue()

484

485 - def __setfield_numberofphonenumbers(self, value):

486 if isinstance(value,UINT): 487 self.__field_numberofphonenumbers=value 488 else: 489 self.__field_numberofphonenumbers=UINT(value,**{'constant': 5})

490

491 - def __delfield_numberofphonenumbers(self): del self.__field_numberofphonenumbers

492 493 numberofphonenumbers=property(__getfield_numberofphonenumbers, __setfield_numberofphonenumbers, __delfield_numberofphonenumbers, None) 494

495 - def __getfield_serial1(self):

496 return self.__field_serial1.getvalue()

497

498 - def __setfield_serial1(self, value):

499 if isinstance(value,UINT): 500 self.__field_serial1=value 501 else: 502 self.__field_serial1=UINT(value,**{'sizeinbytes': 4})

503

504 - def __delfield_serial1(self): del self.__field_serial1

505 506 serial1=property(__getfield_serial1, __setfield_serial1, __delfield_serial1, " == order created") 507

508 - def __getfield_entrysize(self):

509 try: self.__field_entrysize 510 except: 511 self.__field_entrysize=UINT(**{'sizeinbytes': 2, 'constant': 0xf5}) 512 return self.__field_entrysize.getvalue()

513

514 - def __setfield_entrysize(self, value):

515 if isinstance(value,UINT): 516 self.__field_entrysize=value 517 else: 518 self.__field_entrysize=UINT(value,**{'sizeinbytes': 2, 'constant': 0xf5})

519

520 - def __delfield_entrysize(self): del self.__field_entrysize

521 522 entrysize=property(__getfield_entrysize, __setfield_entrysize, __delfield_entrysize, None) 523

524 - def __getfield_serial2(self):

525 return self.__field_serial2.getvalue()

526

527 - def __setfield_serial2(self, value):

528 if isinstance(value,UINT): 529 self.__field_serial2=value 530 else: 531 self.__field_serial2=UINT(value,**{'sizeinbytes': 4})

532

533 - def __delfield_serial2(self): del self.__field_serial2

534 535 serial2=property(__getfield_serial2, __setfield_serial2, __delfield_serial2, "Same as serial1") 536

537 - def __getfield_entrynumber(self):

538 return self.__field_entrynumber.getvalue()

539

540 - def __setfield_entrynumber(self, value):

541 if isinstance(value,UINT): 542 self.__field_entrynumber=value 543 else: 544 self.__field_entrynumber=UINT(value,**{'sizeinbytes': 1})

545

546 - def __delfield_entrynumber(self): del self.__field_entrynumber

547 548 entrynumber=property(__getfield_entrynumber, __setfield_entrynumber, __delfield_entrynumber, None) 549

550 - def __getfield_name(self):

551 return self.__field_name.getvalue()

552

553 - def __setfield_name(self, value):

554 if isinstance(value,USTRING): 555 self.__field_name=value 556 else: 557 self.__field_name=USTRING(value,**{'sizeinbytes': 17, 'raiseonunterminatedread': False})

558

559 - def __delfield_name(self): del self.__field_name

560 561 name=property(__getfield_name, __setfield_name, __delfield_name, None) 562

563 - def __getfield_secret(self):

564 return self.__field_secret.getvalue()

565

566 - def __setfield_secret(self, value):

567 if isinstance(value,BOOL): 568 self.__field_secret=value 569 else: 570 self.__field_secret=BOOL(value,**{'sizeinbytes': 1})

571

572 - def __delfield_secret(self): del self.__field_secret

573 574 secret=property(__getfield_secret, __setfield_secret, __delfield_secret, None) 575

576 - def __getfield_default(self):

577 return self.__field_default.getvalue()

578

579 - def __setfield_default(self, value):

580 if isinstance(value,UINT): 581 self.__field_default=value 582 else: 583 self.__field_default=UINT(value,**{'sizeinbytes': 1})

584

585 - def __delfield_default(self): del self.__field_default

586 587 default=property(__getfield_default, __setfield_default, __delfield_default, "Default number") 588

589 - def __getfield_numbers(self):

590 try: self.__field_numbers 591 except: 592 self.__field_numbers=LIST(**{'length': self.numberofphonenumbers, 'elementclass': numentry, 'createdefault': True}) 593 return self.__field_numbers.getvalue()

594

595 - def __setfield_numbers(self, value):

596 if isinstance(value,LIST): 597 self.__field_numbers=value 598 else: 599 self.__field_numbers=LIST(value,**{'length': self.numberofphonenumbers, 'elementclass': numentry, 'createdefault': True})

600

601 - def __delfield_numbers(self): del self.__field_numbers

602 603 numbers=property(__getfield_numbers, __setfield_numbers, __delfield_numbers, None) 604

605 - def __getfield_ringtone(self):

606 return self.__field_ringtone.getvalue()

607

608 - def __setfield_ringtone(self, value):

609 if isinstance(value,UINT): 610 self.__field_ringtone=value 611 else: 612 self.__field_ringtone=UINT(value,**{'sizeinbytes': 1})

613

614 - def __delfield_ringtone(self): del self.__field_ringtone

615 616 ringtone=property(__getfield_ringtone, __setfield_ringtone, __delfield_ringtone, "ringtone index for a call, 0x17 for custom") 617

618 - def __getfield_voicetag(self):

619 return self.__field_voicetag.getvalue()

620

621 - def __setfield_voicetag(self, value):

622 if isinstance(value,BOOL): 623 self.__field_voicetag=value 624 else: 625 self.__field_voicetag=BOOL(value,**{'sizeinbytes': 1})

626

627 - def __delfield_voicetag(self): del self.__field_voicetag

628 629 voicetag=property(__getfield_voicetag, __setfield_voicetag, __delfield_voicetag, None) 630

631 - def __getfield_email(self):

632 try: self.__field_email 633 except: 634 self.__field_email=USTRING(**{'sizeinbytes': 49, 'raiseonunterminatedread': False}) 635 return self.__field_email.getvalue()

636

637 - def __setfield_email(self, value):

638 if isinstance(value,USTRING): 639 self.__field_email=value 640 else: 641 self.__field_email=USTRING(value,**{'sizeinbytes': 49, 'raiseonunterminatedread': False})

642

643 - def __delfield_email(self): del self.__field_email

644 645 email=property(__getfield_email, __setfield_email, __delfield_email, None) 646

647 - def iscontainer(self):

648 return True

649

650 - def containerelements(self):

651 yield ('numberofemails', self.__field_numberofemails, None) 652 yield ('numberofphonenumbers', self.__field_numberofphonenumbers, None) 653 yield ('serial1', self.__field_serial1, " == order created") 654 yield ('entrysize', self.__field_entrysize, None) 655 yield ('serial2', self.__field_serial2, "Same as serial1") 656 yield ('entrynumber', self.__field_entrynumber, None) 657 yield ('name', self.__field_name, None) 658 yield ('secret', self.__field_secret, None) 659 yield ('default', self.__field_default, "Default number") 660 yield ('numbers', self.__field_numbers, None) 661 yield ('ringtone', self.__field_ringtone, "ringtone index for a call, 0x17 for custom") 662 yield ('voicetag', self.__field_voicetag, None) 663 yield ('email', self.__field_email, None)

664 665 666 667

668 -class ringentry(BaseProtogenClass):

669 __fields=['index', 'name'] 670

671 - def __init__(self, *args, **kwargs):

672 dict={} 673 # What was supplied to this function 674 dict.update(kwargs) 675 # Parent constructor 676 super(ringentry,self).__init__(**dict) 677 if self.__class__ is ringentry: 678 self._update(args,dict)

679 680

681 - def getfields(self):

682 return self.__fields

683 684

685 - def _update(self, args, kwargs):

686 super(ringentry,self)._update(args,kwargs) 687 keys=kwargs.keys() 688 for key in keys: 689 if key in self.__fields: 690 setattr(self, key, kwargs[key]) 691 del kwargs[key] 692 # Were any unrecognized kwargs passed in? 693 if __debug__: 694 self._complainaboutunusedargs(ringentry,kwargs) 695 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)

696 # Make all P fields that haven't already been constructed 697 698

699 - def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):

700 'Writes this packet to the supplied buffer' 701 self._bufferstartoffset=buf.getcurrentoffset() 702 self.__field_index.writetobuffer(buf) 703 self.__field_name.writetobuffer(buf) 704 self._bufferendoffset=buf.getcurrentoffset() 705 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)

706 707

708 - def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):

709 'Reads this packet from the supplied buffer' 710 self._bufferstartoffset=buf.getcurrentoffset() 711 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 712 self.__field_index=UINT(**{'sizeinbytes': 1}) 713 self.__field_index.readfrombuffer(buf) 714 self.__field_name=USTRING(**{'sizeinbytes': 40, 'raiseonunterminatedread': False}) 715 self.__field_name.readfrombuffer(buf) 716 self._bufferendoffset=buf.getcurrentoffset()

717 718

719 - def __getfield_index(self):

720 return self.__field_index.getvalue()

721

722 - def __setfield_index(self, value):

723 if isinstance(value,UINT): 724 self.__field_index=value 725 else: 726 self.__field_index=UINT(value,**{'sizeinbytes': 1})

727

728 - def __delfield_index(self): del self.__field_index

729 730 index=property(__getfield_index, __setfield_index, __delfield_index, "Phonebook entry number") 731

732 - def __getfield_name(self):

733 return self.__field_name.getvalue()

734

735 - def __setfield_name(self, value):

736 if isinstance(value,USTRING): 737 self.__field_name=value 738 else: 739 self.__field_name=USTRING(value,**{'sizeinbytes': 40, 'raiseonunterminatedread': False})

740

741 - def __delfield_name(self): del self.__field_name

742 743 name=property(__getfield_name, __setfield_name, __delfield_name, "Path of custom ringer, or default") 744

745 - def iscontainer(self):

746 return True

747

748 - def containerelements(self):

749 yield ('index', self.__field_index, "Phonebook entry number") 750 yield ('name', self.__field_name, "Path of custom ringer, or default")

751 752 753 754

755 -class ringindex(BaseProtogenClass):

756 __fields=['maxitems', 'items'] 757

758 - def __init__(self, *args, **kwargs):

759 dict={} 760 # What was supplied to this function 761 dict.update(kwargs) 762 # Parent constructor 763 super(ringindex,self).__init__(**dict) 764 if self.__class__ is ringindex: 765 self._update(args,dict)

766 767

768 - def getfields(self):

769 return self.__fields

770 771

772 - def _update(self, args, kwargs):

773 super(ringindex,self)._update(args,kwargs) 774 keys=kwargs.keys() 775 for key in keys: 776 if key in self.__fields: 777 setattr(self, key, kwargs[key]) 778 del kwargs[key] 779 # Were any unrecognized kwargs passed in? 780 if __debug__: 781 self._complainaboutunusedargs(ringindex,kwargs) 782 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 783 # Make all P fields that haven't already been constructed 784 try: self.__field_maxitems 785 except: 786 self.__field_maxitems=UINT(**{'constant': 199})

787 788

789 - def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):

790 'Writes this packet to the supplied buffer' 791 self._bufferstartoffset=buf.getcurrentoffset() 792 try: self.__field_items 793 except: 794 self.__field_items=LIST(**{'length': self.maxitems, 'elementclass': ringentry, 'createdefault': True}) 795 self.__field_items.writetobuffer(buf) 796 self._bufferendoffset=buf.getcurrentoffset() 797 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)

798 799

800 - def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):

801 'Reads this packet from the supplied buffer' 802 self._bufferstartoffset=buf.getcurrentoffset() 803 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 804 self.__field_items=LIST(**{'length': self.maxitems, 'elementclass': ringentry, 'createdefault': True}) 805 self.__field_items.readfrombuffer(buf) 806 self._bufferendoffset=buf.getcurrentoffset()

807 808

809 - def __getfield_maxitems(self):

810 return self.__field_maxitems.getvalue()

811

812 - def __setfield_maxitems(self, value):

813 if isinstance(value,UINT): 814 self.__field_maxitems=value 815 else: 816 self.__field_maxitems=UINT(value,**{'constant': 199})

817

818 - def __delfield_maxitems(self): del self.__field_maxitems

819 820 maxitems=property(__getfield_maxitems, __setfield_maxitems, __delfield_maxitems, None) 821

822 - def __getfield_items(self):

823 try: self.__field_items 824 except: 825 self.__field_items=LIST(**{'length': self.maxitems, 'elementclass': ringentry, 'createdefault': True}) 826 return self.__field_items.getvalue()

827

828 - def __setfield_items(self, value):

829 if isinstance(value,LIST): 830 self.__field_items=value 831 else: 832 self.__field_items=LIST(value,**{'length': self.maxitems, 'elementclass': ringentry, 'createdefault': True})

833

834 - def __delfield_items(self): del self.__field_items

835 836 items=property(__getfield_items, __setfield_items, __delfield_items, None) 837

838 - def iscontainer(self):

839 return True

840

841 - def containerelements(self):

842 yield ('maxitems', self.__field_maxitems, None) 843 yield ('items', self.__field_items, None)

844 845 846 847

848 -class scheduleevent(BaseProtogenClass):

849 __fields=['state', 'pos', 'alarm', 'date', 'repeat', 'description'] 850

851 - def __init__(self, *args, **kwargs):

852 dict={} 853 # What was supplied to this function 854 dict.update(kwargs) 855 # Parent constructor 856 super(scheduleevent,self).__init__(**dict) 857 if self.__class__ is scheduleevent: 858 self._update(args,dict)

859 860

861 - def getfields(self):

862 return self.__fields

863 864

865 - def _update(self, args, kwargs):

866 super(scheduleevent,self)._update(args,kwargs) 867 keys=kwargs.keys() 868 for key in keys: 869 if key in self.__fields: 870 setattr(self, key, kwargs[key]) 871 del kwargs[key] 872 # Were any unrecognized kwargs passed in? 873 if __debug__: 874 self._complainaboutunusedargs(scheduleevent,kwargs) 875 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)

876 # Make all P fields that haven't already been constructed 877 878

879 - def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):

880 'Writes this packet to the supplied buffer' 881 self._bufferstartoffset=buf.getcurrentoffset() 882 self.__field_state.writetobuffer(buf) 883 self.__field_pos.writetobuffer(buf) 884 self.__field_alarm.writetobuffer(buf) 885 self.__field_date.writetobuffer(buf) 886 self.__field_repeat.writetobuffer(buf) 887 self.__field_description.writetobuffer(buf) 888 self._bufferendoffset=buf.getcurrentoffset() 889 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)

890 891

892 - def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):

893 'Reads this packet from the supplied buffer' 894 self._bufferstartoffset=buf.getcurrentoffset() 895 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 896 self.__field_state=UINT(**{'sizeinbytes': 1}) 897 self.__field_state.readfrombuffer(buf) 898 self.__field_pos=UINT(**{'sizeinbytes': 1}) 899 self.__field_pos.readfrombuffer(buf) 900 self.__field_alarm=UINT(**{'sizeinbytes': 1}) 901 self.__field_alarm.readfrombuffer(buf) 902 self.__field_date=UINT(**{'sizeinbytes': 4}) 903 self.__field_date.readfrombuffer(buf) 904 self.__field_repeat=UINT(**{'sizeinbytes': 1}) 905 self.__field_repeat.readfrombuffer(buf) 906 self.__field_description=USTRING(**{'sizeinbytes': 32, 'raiseonunterminatedread': False}) 907 self.__field_description.readfrombuffer(buf) 908 self._bufferendoffset=buf.getcurrentoffset()

909 910

911 - def __getfield_state(self):

912 return self.__field_state.getvalue()

913

914 - def __setfield_state(self, value):

915 if isinstance(value,UINT): 916 self.__field_state=value 917 else: 918 self.__field_state=UINT(value,**{'sizeinbytes': 1})

919

920 - def __delfield_state(self): del self.__field_state

921 922 state=property(__getfield_state, __setfield_state, __delfield_state, "02 for an new entry, 01 for a modified entry, 00 for blank entry") 923

924 - def __getfield_pos(self):

925 return self.__field_pos.getvalue()

926

927 - def __setfield_pos(self, value):

928 if isinstance(value,UINT): 929 self.__field_pos=value 930 else: 931 self.__field_pos=UINT(value,**{'sizeinbytes': 1})

932

933 - def __delfield_pos(self): del self.__field_pos

934 935 pos=property(__getfield_pos, __setfield_pos, __delfield_pos, "position within file, used as an event id") 936

937 - def __getfield_alarm(self):

938 return self.__field_alarm.getvalue()

939

940 - def __setfield_alarm(self, value):

941 if isinstance(value,UINT): 942 self.__field_alarm=value 943 else: 944 self.__field_alarm=UINT(value,**{'sizeinbytes': 1})

945

946 - def __delfield_alarm(self): del self.__field_alarm

947 948 alarm=property(__getfield_alarm, __setfield_alarm, __delfield_alarm, "00 => created, 80 => modified/never been used, B0 => alarm") 949

950 - def __getfield_date(self):

951 return self.__field_date.getvalue()

952

953 - def __setfield_date(self, value):

954 if isinstance(value,UINT): 955 self.__field_date=value 956 else: 957 self.__field_date=UINT(value,**{'sizeinbytes': 4})

958

959 - def __delfield_date(self): del self.__field_date

960 961 date=property(__getfield_date, __setfield_date, __delfield_date, None) 962

963 - def __getfield_repeat(self):

964 return self.__field_repeat.getvalue()

965

966 - def __setfield_repeat(self, value):

967 if isinstance(value,UINT): 968 self.__field_repeat=value 969 else: 970 self.__field_repeat=UINT(value,**{'sizeinbytes': 1})

971

972 - def __delfield_repeat(self): del self.__field_repeat

973 974 repeat=property(__getfield_repeat, __setfield_repeat, __delfield_repeat, "01 => used, 02 => daily") 975

976 - def __getfield_description(self):

977 return self.__field_description.getvalue()

978

979 - def __setfield_description(self, value):

980 if isinstance(value,USTRING): 981 self.__field_description=value 982 else: 983 self.__field_description=USTRING(value,**{'sizeinbytes': 32, 'raiseonunterminatedread': False})

984

985 - def __delfield_description(self): del self.__field_description

986 987 description=property(__getfield_description, __setfield_description, __delfield_description, None) 988

989 - def iscontainer(self):

990 return True

991

992 - def containerelements(self):

993 yield ('state', self.__field_state, "02 for an new entry, 01 for a modified entry, 00 for blank entry") 994 yield ('pos', self.__field_pos, "position within file, used as an event id") 995 yield ('alarm', self.__field_alarm, "00 => created, 80 => modified/never been used, B0 => alarm") 996 yield ('date', self.__field_date, None) 997 yield ('repeat', self.__field_repeat, "01 => used, 02 => daily") 998 yield ('description', self.__field_description, None)

999 1000 1001 1002

1003 -class schedulefile(BaseProtogenClass):

1004 __fields=['events'] 1005

1006 - def __init__(self, *args, **kwargs):

1007 dict={} 1008 # What was supplied to this function 1009 dict.update(kwargs) 1010 # Parent constructor 1011 super(schedulefile,self).__init__(**dict) 1012 if self.__class__ is schedulefile: 1013 self._update(args,dict)

1014 1015

1016 - def getfields(self):

1017 return self.__fields

1018 1019

1020 - def _update(self, args, kwargs):

1021 super(schedulefile,self)._update(args,kwargs) 1022 keys=kwargs.keys() 1023 for key in keys: 1024 if key in self.__fields: 1025 setattr(self, key, kwargs[key]) 1026 del kwargs[key] 1027 # Were any unrecognized kwargs passed in? 1028 if __debug__: 1029 self._complainaboutunusedargs(schedulefile,kwargs) 1030 if len(args): 1031 dict2={'length': 50, 'elementclass': scheduleevent} 1032 dict2.update(kwargs) 1033 kwargs=dict2 1034 self.__field_events=LIST(*args,**dict2)

1035 # Make all P fields that haven't already been constructed 1036 1037

1038 - def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):

1039 'Writes this packet to the supplied buffer' 1040 self._bufferstartoffset=buf.getcurrentoffset() 1041 try: self.__field_events 1042 except: 1043 self.__field_events=LIST(**{'length': 50, 'elementclass': scheduleevent}) 1044 self.__field_events.writetobuffer(buf) 1045 self._bufferendoffset=buf.getcurrentoffset() 1046 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)

1047 1048

1049 - def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):

1050 'Reads this packet from the supplied buffer' 1051 self._bufferstartoffset=buf.getcurrentoffset() 1052 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 1053 self.__field_events=LIST(**{'length': 50, 'elementclass': scheduleevent}) 1054 self.__field_events.readfrombuffer(buf) 1055 self._bufferendoffset=buf.getcurrentoffset()

1056 1057

1058 - def __getfield_events(self):

1059 try: self.__field_events 1060 except: 1061 self.__field_events=LIST(**{'length': 50, 'elementclass': scheduleevent}) 1062 return self.__field_events.getvalue()

1063

1064 - def __setfield_events(self, value):

1065 if isinstance(value,LIST): 1066 self.__field_events=value 1067 else: 1068 self.__field_events=LIST(value,**{'length': 50, 'elementclass': scheduleevent})

1069

1070 - def __delfield_events(self): del self.__field_events

1071 1072 events=property(__getfield_events, __setfield_events, __delfield_events, None) 1073

1074 - def iscontainer(self):

1075 return True

1076

1077 - def containerelements(self):

1078 yield ('events', self.__field_events, None)

1079

Source Code for Module phones.p_lgtm520