phones.p_lgvx8000

1 # THIS FILE IS AUTOMATICALLY GENERATED. EDIT THE SOURCE FILE NOT THIS ONE 2 3 """Various descriptions of data specific to LG VX8000""" 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 are the same as lgvx7000 except as noted 11 # below 12 from p_lgvx7000 import * 13 14 # We use LSB for all integer like fields 15 UINT=UINTlsb 16 BOOL=BOOLlsb 17

18 -class indexentry(BaseProtogenClass):

19 __fields=['index', 'type', 'filename', 'date', 'dunno'] 20

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

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

29 30

31 - def getfields(self):

32 return self.__fields

33 34

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

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

46 # Make all P fields that haven't already been constructed 47 48

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

50 'Writes this packet to the supplied buffer' 51 self._bufferstartoffset=buf.getcurrentoffset() 52 self.__field_index.writetobuffer(buf) 53 self.__field_type.writetobuffer(buf) 54 self.__field_filename.writetobuffer(buf) 55 try: self.__field_date 56 except: 57 self.__field_date=UINT(**{'sizeinbytes': 4, 'default': 0}) 58 self.__field_date.writetobuffer(buf) 59 self.__field_dunno.writetobuffer(buf) 60 self._bufferendoffset=buf.getcurrentoffset() 61 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)

62 63

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

65 'Reads this packet from the supplied buffer' 66 self._bufferstartoffset=buf.getcurrentoffset() 67 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 68 self.__field_index=UINT(**{'sizeinbytes': 2}) 69 self.__field_index.readfrombuffer(buf) 70 self.__field_type=UINT(**{'sizeinbytes': 2}) 71 self.__field_type.readfrombuffer(buf) 72 self.__field_filename=USTRING(**{'sizeinbytes': 64}) 73 self.__field_filename.readfrombuffer(buf) 74 self.__field_date=UINT(**{'sizeinbytes': 4, 'default': 0}) 75 self.__field_date.readfrombuffer(buf) 76 self.__field_dunno=UINT(**{'sizeinbytes': 4}) 77 self.__field_dunno.readfrombuffer(buf) 78 self._bufferendoffset=buf.getcurrentoffset()

79 80

81 - def __getfield_index(self):

82 return self.__field_index.getvalue()

83

84 - def __setfield_index(self, value):

85 if isinstance(value,UINT): 86 self.__field_index=value 87 else: 88 self.__field_index=UINT(value,**{'sizeinbytes': 2})

89

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

91 92 index=property(__getfield_index, __setfield_index, __delfield_index, None) 93

94 - def __getfield_type(self):

95 return self.__field_type.getvalue()

96

97 - def __setfield_type(self, value):

98 if isinstance(value,UINT): 99 self.__field_type=value 100 else: 101 self.__field_type=UINT(value,**{'sizeinbytes': 2})

102

103 - def __delfield_type(self): del self.__field_type

104 105 type=property(__getfield_type, __setfield_type, __delfield_type, None) 106

107 - def __getfield_filename(self):

108 return self.__field_filename.getvalue()

109

110 - def __setfield_filename(self, value):

111 if isinstance(value,USTRING): 112 self.__field_filename=value 113 else: 114 self.__field_filename=USTRING(value,**{'sizeinbytes': 64})

115

116 - def __delfield_filename(self): del self.__field_filename

117 118 filename=property(__getfield_filename, __setfield_filename, __delfield_filename, "includes full pathname") 119

120 - def __getfield_date(self):

121 try: self.__field_date 122 except: 123 self.__field_date=UINT(**{'sizeinbytes': 4, 'default': 0}) 124 return self.__field_date.getvalue()

125

126 - def __setfield_date(self, value):

127 if isinstance(value,UINT): 128 self.__field_date=value 129 else: 130 self.__field_date=UINT(value,**{'sizeinbytes': 4, 'default': 0})

131

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

133 134 date=property(__getfield_date, __setfield_date, __delfield_date, "i think this is bitfield of the date") 135

136 - def __getfield_dunno(self):

137 return self.__field_dunno.getvalue()

138

139 - def __setfield_dunno(self, value):

140 if isinstance(value,UINT): 141 self.__field_dunno=value 142 else: 143 self.__field_dunno=UINT(value,**{'sizeinbytes': 4})

144

145 - def __delfield_dunno(self): del self.__field_dunno

146 147 dunno=property(__getfield_dunno, __setfield_dunno, __delfield_dunno, None) 148

149 - def iscontainer(self):

150 return True

151

152 - def containerelements(self):

153 yield ('index', self.__field_index, None) 154 yield ('type', self.__field_type, None) 155 yield ('filename', self.__field_filename, "includes full pathname") 156 yield ('date', self.__field_date, "i think this is bitfield of the date") 157 yield ('dunno', self.__field_dunno, None)

158 159 160 161

162 -class indexfile(BaseProtogenClass):

163 "Used for tracking wallpaper and ringtones" 164 __fields=['items'] 165

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

167 dict={} 168 # What was supplied to this function 169 dict.update(kwargs) 170 # Parent constructor 171 super(indexfile,self).__init__(**dict) 172 if self.__class__ is indexfile: 173 self._update(args,dict)

174 175

176 - def getfields(self):

177 return self.__fields

178 179

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

181 super(indexfile,self)._update(args,kwargs) 182 keys=kwargs.keys() 183 for key in keys: 184 if key in self.__fields: 185 setattr(self, key, kwargs[key]) 186 del kwargs[key] 187 # Were any unrecognized kwargs passed in? 188 if __debug__: 189 self._complainaboutunusedargs(indexfile,kwargs) 190 if len(args): 191 dict2={'elementclass': indexentry, 'createdefault': True} 192 dict2.update(kwargs) 193 kwargs=dict2 194 self.__field_items=LIST(*args,**dict2)

195 # Make all P fields that haven't already been constructed 196 197

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

199 'Writes this packet to the supplied buffer' 200 self._bufferstartoffset=buf.getcurrentoffset() 201 try: self.__field_items 202 except: 203 self.__field_items=LIST(**{'elementclass': indexentry, 'createdefault': True}) 204 self.__field_items.writetobuffer(buf) 205 self._bufferendoffset=buf.getcurrentoffset() 206 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)

207 208

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

210 'Reads this packet from the supplied buffer' 211 self._bufferstartoffset=buf.getcurrentoffset() 212 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 213 self.__field_items=LIST(**{'elementclass': indexentry, 'createdefault': True}) 214 self.__field_items.readfrombuffer(buf) 215 self._bufferendoffset=buf.getcurrentoffset()

216 217

218 - def __getfield_items(self):

219 try: self.__field_items 220 except: 221 self.__field_items=LIST(**{'elementclass': indexentry, 'createdefault': True}) 222 return self.__field_items.getvalue()

223

224 - def __setfield_items(self, value):

225 if isinstance(value,LIST): 226 self.__field_items=value 227 else: 228 self.__field_items=LIST(value,**{'elementclass': indexentry, 'createdefault': True})

229

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

231 232 items=property(__getfield_items, __setfield_items, __delfield_items, None) 233

234 - def iscontainer(self):

235 return True

236

237 - def containerelements(self):

238 yield ('items', self.__field_items, None)

239 240 241 242

243 -class msg_record(BaseProtogenClass):

244 __fields=['binary', 'unknown3', 'unknown4', 'unknown6', 'length', 'msg'] 245

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

247 dict={} 248 # What was supplied to this function 249 dict.update(kwargs) 250 # Parent constructor 251 super(msg_record,self).__init__(**dict) 252 if self.__class__ is msg_record: 253 self._update(args,dict)

254 255

256 - def getfields(self):

257 return self.__fields

258 259

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

261 super(msg_record,self)._update(args,kwargs) 262 keys=kwargs.keys() 263 for key in keys: 264 if key in self.__fields: 265 setattr(self, key, kwargs[key]) 266 del kwargs[key] 267 # Were any unrecognized kwargs passed in? 268 if __debug__: 269 self._complainaboutunusedargs(msg_record,kwargs) 270 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)

271 # Make all P fields that haven't already been constructed 272 273

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

275 'Writes this packet to the supplied buffer' 276 self._bufferstartoffset=buf.getcurrentoffset() 277 self.__field_binary.writetobuffer(buf) 278 self.__field_unknown3.writetobuffer(buf) 279 self.__field_unknown4.writetobuffer(buf) 280 self.__field_unknown6.writetobuffer(buf) 281 self.__field_length.writetobuffer(buf) 282 try: self.__field_msg 283 except: 284 self.__field_msg=LIST(**{'elementclass': _gen_p_lgvx8000_79, 'length': 220}) 285 self.__field_msg.writetobuffer(buf) 286 self._bufferendoffset=buf.getcurrentoffset() 287 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)

288 289

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

291 'Reads this packet from the supplied buffer' 292 self._bufferstartoffset=buf.getcurrentoffset() 293 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 294 self.__field_binary=UINT(**{'sizeinbytes': 1}) 295 self.__field_binary.readfrombuffer(buf) 296 self.__field_unknown3=UINT(**{'sizeinbytes': 1}) 297 self.__field_unknown3.readfrombuffer(buf) 298 self.__field_unknown4=UINT(**{'sizeinbytes': 1}) 299 self.__field_unknown4.readfrombuffer(buf) 300 self.__field_unknown6=UINT(**{'sizeinbytes': 1}) 301 self.__field_unknown6.readfrombuffer(buf) 302 self.__field_length=UINT(**{'sizeinbytes': 1}) 303 self.__field_length.readfrombuffer(buf) 304 self.__field_msg=LIST(**{'elementclass': _gen_p_lgvx8000_79, 'length': 220}) 305 self.__field_msg.readfrombuffer(buf) 306 self._bufferendoffset=buf.getcurrentoffset()

307 308

309 - def __getfield_binary(self):

310 return self.__field_binary.getvalue()

311

312 - def __setfield_binary(self, value):

313 if isinstance(value,UINT): 314 self.__field_binary=value 315 else: 316 self.__field_binary=UINT(value,**{'sizeinbytes': 1})

317

318 - def __delfield_binary(self): del self.__field_binary

319 320 binary=property(__getfield_binary, __setfield_binary, __delfield_binary, None) 321

322 - def __getfield_unknown3(self):

323 return self.__field_unknown3.getvalue()

324

325 - def __setfield_unknown3(self, value):

326 if isinstance(value,UINT): 327 self.__field_unknown3=value 328 else: 329 self.__field_unknown3=UINT(value,**{'sizeinbytes': 1})

330

331 - def __delfield_unknown3(self): del self.__field_unknown3

332 333 unknown3=property(__getfield_unknown3, __setfield_unknown3, __delfield_unknown3, None) 334

335 - def __getfield_unknown4(self):

336 return self.__field_unknown4.getvalue()

337

338 - def __setfield_unknown4(self, value):

339 if isinstance(value,UINT): 340 self.__field_unknown4=value 341 else: 342 self.__field_unknown4=UINT(value,**{'sizeinbytes': 1})

343

344 - def __delfield_unknown4(self): del self.__field_unknown4

345 346 unknown4=property(__getfield_unknown4, __setfield_unknown4, __delfield_unknown4, None) 347

348 - def __getfield_unknown6(self):

349 return self.__field_unknown6.getvalue()

350

351 - def __setfield_unknown6(self, value):

352 if isinstance(value,UINT): 353 self.__field_unknown6=value 354 else: 355 self.__field_unknown6=UINT(value,**{'sizeinbytes': 1})

356

357 - def __delfield_unknown6(self): del self.__field_unknown6

358 359 unknown6=property(__getfield_unknown6, __setfield_unknown6, __delfield_unknown6, None) 360

361 - def __getfield_length(self):

362 return self.__field_length.getvalue()

363

364 - def __setfield_length(self, value):

365 if isinstance(value,UINT): 366 self.__field_length=value 367 else: 368 self.__field_length=UINT(value,**{'sizeinbytes': 1})

369

370 - def __delfield_length(self): del self.__field_length

371 372 length=property(__getfield_length, __setfield_length, __delfield_length, None) 373

374 - def __getfield_msg(self):

375 try: self.__field_msg 376 except: 377 self.__field_msg=LIST(**{'elementclass': _gen_p_lgvx8000_79, 'length': 220}) 378 return self.__field_msg.getvalue()

379

380 - def __setfield_msg(self, value):

381 if isinstance(value,LIST): 382 self.__field_msg=value 383 else: 384 self.__field_msg=LIST(value,**{'elementclass': _gen_p_lgvx8000_79, 'length': 220})

385

386 - def __delfield_msg(self): del self.__field_msg

387 388 msg=property(__getfield_msg, __setfield_msg, __delfield_msg, None) 389

390 - def iscontainer(self):

391 return True

392

393 - def containerelements(self):

394 yield ('binary', self.__field_binary, None) 395 yield ('unknown3', self.__field_unknown3, None) 396 yield ('unknown4', self.__field_unknown4, None) 397 yield ('unknown6', self.__field_unknown6, None) 398 yield ('length', self.__field_length, None) 399 yield ('msg', self.__field_msg, None)

400 401 402 403

404 -class _gen_p_lgvx8000_79(BaseProtogenClass):

405 'Anonymous inner class' 406 __fields=['byte'] 407

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

409 dict={} 410 # What was supplied to this function 411 dict.update(kwargs) 412 # Parent constructor 413 super(_gen_p_lgvx8000_79,self).__init__(**dict) 414 if self.__class__ is _gen_p_lgvx8000_79: 415 self._update(args,dict)

416 417

418 - def getfields(self):

419 return self.__fields

420 421

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

423 super(_gen_p_lgvx8000_79,self)._update(args,kwargs) 424 keys=kwargs.keys() 425 for key in keys: 426 if key in self.__fields: 427 setattr(self, key, kwargs[key]) 428 del kwargs[key] 429 # Were any unrecognized kwargs passed in? 430 if __debug__: 431 self._complainaboutunusedargs(_gen_p_lgvx8000_79,kwargs) 432 if len(args): 433 dict2={'sizeinbytes': 1} 434 dict2.update(kwargs) 435 kwargs=dict2 436 self.__field_byte=UINT(*args,**dict2)

437 # Make all P fields that haven't already been constructed 438 439

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

441 'Writes this packet to the supplied buffer' 442 self._bufferstartoffset=buf.getcurrentoffset() 443 self.__field_byte.writetobuffer(buf) 444 self._bufferendoffset=buf.getcurrentoffset() 445 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)

446 447

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

449 'Reads this packet from the supplied buffer' 450 self._bufferstartoffset=buf.getcurrentoffset() 451 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 452 self.__field_byte=UINT(**{'sizeinbytes': 1}) 453 self.__field_byte.readfrombuffer(buf) 454 self._bufferendoffset=buf.getcurrentoffset()

455 456

457 - def __getfield_byte(self):

458 return self.__field_byte.getvalue()

459

460 - def __setfield_byte(self, value):

461 if isinstance(value,UINT): 462 self.__field_byte=value 463 else: 464 self.__field_byte=UINT(value,**{'sizeinbytes': 1})

465

466 - def __delfield_byte(self): del self.__field_byte

467 468 byte=property(__getfield_byte, __setfield_byte, __delfield_byte, "individual byte of message") 469

470 - def iscontainer(self):

471 return True

472

473 - def containerelements(self):

474 yield ('byte', self.__field_byte, "individual byte of message")

475 476 477 478

479 -class recipient_record(BaseProtogenClass):

480 __fields=['unknown1', 'number', 'status', 'timesent', 'timereceived', 'unknown2', 'unknown3'] 481

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

483 dict={} 484 # What was supplied to this function 485 dict.update(kwargs) 486 # Parent constructor 487 super(recipient_record,self).__init__(**dict) 488 if self.__class__ is recipient_record: 489 self._update(args,dict)

490 491

492 - def getfields(self):

493 return self.__fields

494 495

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

497 super(recipient_record,self)._update(args,kwargs) 498 keys=kwargs.keys() 499 for key in keys: 500 if key in self.__fields: 501 setattr(self, key, kwargs[key]) 502 del kwargs[key] 503 # Were any unrecognized kwargs passed in? 504 if __debug__: 505 self._complainaboutunusedargs(recipient_record,kwargs) 506 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)

507 # Make all P fields that haven't already been constructed 508 509

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

511 'Writes this packet to the supplied buffer' 512 self._bufferstartoffset=buf.getcurrentoffset() 513 self.__field_unknown1.writetobuffer(buf) 514 self.__field_number.writetobuffer(buf) 515 self.__field_status.writetobuffer(buf) 516 self.__field_timesent.writetobuffer(buf) 517 self.__field_timereceived.writetobuffer(buf) 518 self.__field_unknown2.writetobuffer(buf) 519 self.__field_unknown3.writetobuffer(buf) 520 self._bufferendoffset=buf.getcurrentoffset() 521 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)

522 523

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

525 'Reads this packet from the supplied buffer' 526 self._bufferstartoffset=buf.getcurrentoffset() 527 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 528 self.__field_unknown1=DATA(**{'sizeinbytes': 33}) 529 self.__field_unknown1.readfrombuffer(buf) 530 self.__field_number=USTRING(**{'sizeinbytes': 49}) 531 self.__field_number.readfrombuffer(buf) 532 self.__field_status=UINT(**{'sizeinbytes': 1}) 533 self.__field_status.readfrombuffer(buf) 534 self.__field_timesent=LGCALDATE(**{'sizeinbytes': 4}) 535 self.__field_timesent.readfrombuffer(buf) 536 self.__field_timereceived=LGCALDATE(**{'sizeinbytes': 4}) 537 self.__field_timereceived.readfrombuffer(buf) 538 self.__field_unknown2=UINT(**{'sizeinbytes': 1}) 539 self.__field_unknown2.readfrombuffer(buf) 540 self.__field_unknown3=DATA(**{'sizeinbytes': 40}) 541 self.__field_unknown3.readfrombuffer(buf) 542 self._bufferendoffset=buf.getcurrentoffset()

543 544

545 - def __getfield_unknown1(self):

546 return self.__field_unknown1.getvalue()

547

548 - def __setfield_unknown1(self, value):

549 if isinstance(value,DATA): 550 self.__field_unknown1=value 551 else: 552 self.__field_unknown1=DATA(value,**{'sizeinbytes': 33})

553

554 - def __delfield_unknown1(self): del self.__field_unknown1

555 556 unknown1=property(__getfield_unknown1, __setfield_unknown1, __delfield_unknown1, None) 557

558 - def __getfield_number(self):

559 return self.__field_number.getvalue()

560

561 - def __setfield_number(self, value):

562 if isinstance(value,USTRING): 563 self.__field_number=value 564 else: 565 self.__field_number=USTRING(value,**{'sizeinbytes': 49})

566

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

568 569 number=property(__getfield_number, __setfield_number, __delfield_number, None) 570

571 - def __getfield_status(self):

572 return self.__field_status.getvalue()

573

574 - def __setfield_status(self, value):

575 if isinstance(value,UINT): 576 self.__field_status=value 577 else: 578 self.__field_status=UINT(value,**{'sizeinbytes': 1})

579

580 - def __delfield_status(self): del self.__field_status

581 582 status=property(__getfield_status, __setfield_status, __delfield_status, None) 583

584 - def __getfield_timesent(self):

585 return self.__field_timesent.getvalue()

586

587 - def __setfield_timesent(self, value):

588 if isinstance(value,LGCALDATE): 589 self.__field_timesent=value 590 else: 591 self.__field_timesent=LGCALDATE(value,**{'sizeinbytes': 4})

592

593 - def __delfield_timesent(self): del self.__field_timesent

594 595 timesent=property(__getfield_timesent, __setfield_timesent, __delfield_timesent, None) 596

597 - def __getfield_timereceived(self):

598 return self.__field_timereceived.getvalue()

599

600 - def __setfield_timereceived(self, value):

601 if isinstance(value,LGCALDATE): 602 self.__field_timereceived=value 603 else: 604 self.__field_timereceived=LGCALDATE(value,**{'sizeinbytes': 4})

605

606 - def __delfield_timereceived(self): del self.__field_timereceived

607 608 timereceived=property(__getfield_timereceived, __setfield_timereceived, __delfield_timereceived, None) 609

610 - def __getfield_unknown2(self):

611 return self.__field_unknown2.getvalue()

612

613 - def __setfield_unknown2(self, value):

614 if isinstance(value,UINT): 615 self.__field_unknown2=value 616 else: 617 self.__field_unknown2=UINT(value,**{'sizeinbytes': 1})

618

619 - def __delfield_unknown2(self): del self.__field_unknown2

620 621 unknown2=property(__getfield_unknown2, __setfield_unknown2, __delfield_unknown2, None) 622

623 - def __getfield_unknown3(self):

624 return self.__field_unknown3.getvalue()

625

626 - def __setfield_unknown3(self, value):

627 if isinstance(value,DATA): 628 self.__field_unknown3=value 629 else: 630 self.__field_unknown3=DATA(value,**{'sizeinbytes': 40})

631

632 - def __delfield_unknown3(self): del self.__field_unknown3

633 634 unknown3=property(__getfield_unknown3, __setfield_unknown3, __delfield_unknown3, None) 635

636 - def iscontainer(self):

637 return True

638

639 - def containerelements(self):

640 yield ('unknown1', self.__field_unknown1, None) 641 yield ('number', self.__field_number, None) 642 yield ('status', self.__field_status, None) 643 yield ('timesent', self.__field_timesent, None) 644 yield ('timereceived', self.__field_timereceived, None) 645 yield ('unknown2', self.__field_unknown2, None) 646 yield ('unknown3', self.__field_unknown3, None)

647 648 649 650

651 -class sms_saved(BaseProtogenClass):

652 __fields=['outboxmsg', 'pad', 'outbox', 'inbox'] 653

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

655 dict={} 656 # What was supplied to this function 657 dict.update(kwargs) 658 # Parent constructor 659 super(sms_saved,self).__init__(**dict) 660 if self.__class__ is sms_saved: 661 self._update(args,dict)

662 663

664 - def getfields(self):

665 return self.__fields

666 667

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

669 super(sms_saved,self)._update(args,kwargs) 670 keys=kwargs.keys() 671 for key in keys: 672 if key in self.__fields: 673 setattr(self, key, kwargs[key]) 674 del kwargs[key] 675 # Were any unrecognized kwargs passed in? 676 if __debug__: 677 self._complainaboutunusedargs(sms_saved,kwargs) 678 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)

679 # Make all P fields that haven't already been constructed 680 681

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

683 'Writes this packet to the supplied buffer' 684 self._bufferstartoffset=buf.getcurrentoffset() 685 self.__field_outboxmsg.writetobuffer(buf) 686 self.__field_pad.writetobuffer(buf) 687 if self.outboxmsg: 688 self.__field_outbox.writetobuffer(buf) 689 if not self.outboxmsg: 690 self.__field_inbox.writetobuffer(buf) 691 self._bufferendoffset=buf.getcurrentoffset() 692 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)

693 694

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

696 'Reads this packet from the supplied buffer' 697 self._bufferstartoffset=buf.getcurrentoffset() 698 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 699 self.__field_outboxmsg=UINT(**{'sizeinbytes': 4}) 700 self.__field_outboxmsg.readfrombuffer(buf) 701 self.__field_pad=UNKNOWN(**{'sizeinbytes': 4}) 702 self.__field_pad.readfrombuffer(buf) 703 if self.outboxmsg: 704 self.__field_outbox=sms_out() 705 self.__field_outbox.readfrombuffer(buf) 706 if not self.outboxmsg: 707 self.__field_inbox=sms_in() 708 self.__field_inbox.readfrombuffer(buf) 709 self._bufferendoffset=buf.getcurrentoffset()

710 711

712 - def __getfield_outboxmsg(self):

713 return self.__field_outboxmsg.getvalue()

714

715 - def __setfield_outboxmsg(self, value):

716 if isinstance(value,UINT): 717 self.__field_outboxmsg=value 718 else: 719 self.__field_outboxmsg=UINT(value,**{'sizeinbytes': 4})

720

721 - def __delfield_outboxmsg(self): del self.__field_outboxmsg

722 723 outboxmsg=property(__getfield_outboxmsg, __setfield_outboxmsg, __delfield_outboxmsg, None) 724

725 - def __getfield_pad(self):

726 return self.__field_pad.getvalue()

727

728 - def __setfield_pad(self, value):

729 if isinstance(value,UNKNOWN): 730 self.__field_pad=value 731 else: 732 self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 4})

733

734 - def __delfield_pad(self): del self.__field_pad

735 736 pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None) 737

738 - def __getfield_outbox(self):

739 return self.__field_outbox.getvalue()

740

741 - def __setfield_outbox(self, value):

742 if isinstance(value,sms_out): 743 self.__field_outbox=value 744 else: 745 self.__field_outbox=sms_out(value,)

746

747 - def __delfield_outbox(self): del self.__field_outbox

748 749 outbox=property(__getfield_outbox, __setfield_outbox, __delfield_outbox, None) 750

751 - def __getfield_inbox(self):

752 return self.__field_inbox.getvalue()

753

754 - def __setfield_inbox(self, value):

755 if isinstance(value,sms_in): 756 self.__field_inbox=value 757 else: 758 self.__field_inbox=sms_in(value,)

759

760 - def __delfield_inbox(self): del self.__field_inbox

761 762 inbox=property(__getfield_inbox, __setfield_inbox, __delfield_inbox, None) 763

764 - def iscontainer(self):

765 return True

766

767 - def containerelements(self):

768 yield ('outboxmsg', self.__field_outboxmsg, None) 769 yield ('pad', self.__field_pad, None) 770 if self.outboxmsg: 771 yield ('outbox', self.__field_outbox, None) 772 if not self.outboxmsg: 773 yield ('inbox', self.__field_inbox, None)

774 775 776 777

778 -class sms_out(BaseProtogenClass):

779 __fields=['index', 'locked', 'unknown2', 'timesent', 'unknown2', 'subject', 'unknown4', 'num_msg_elements', 'messages', 'unknown1', 'priority', 'unknown5', 'callback', 'recipients', 'pad'] 780

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

782 dict={} 783 # What was supplied to this function 784 dict.update(kwargs) 785 # Parent constructor 786 super(sms_out,self).__init__(**dict) 787 if self.__class__ is sms_out: 788 self._update(args,dict)

789 790

791 - def getfields(self):

792 return self.__fields

793 794

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

796 super(sms_out,self)._update(args,kwargs) 797 keys=kwargs.keys() 798 for key in keys: 799 if key in self.__fields: 800 setattr(self, key, kwargs[key]) 801 del kwargs[key] 802 # Were any unrecognized kwargs passed in? 803 if __debug__: 804 self._complainaboutunusedargs(sms_out,kwargs) 805 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)

806 # Make all P fields that haven't already been constructed 807 808

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

810 'Writes this packet to the supplied buffer' 811 self._bufferstartoffset=buf.getcurrentoffset() 812 self.__field_index.writetobuffer(buf) 813 self.__field_locked.writetobuffer(buf) 814 self.__field_unknown2.writetobuffer(buf) 815 self.__field_timesent.writetobuffer(buf) 816 self.__field_unknown2.writetobuffer(buf) 817 self.__field_subject.writetobuffer(buf) 818 self.__field_unknown4.writetobuffer(buf) 819 self.__field_num_msg_elements.writetobuffer(buf) 820 try: self.__field_messages 821 except: 822 self.__field_messages=LIST(**{'elementclass': msg_record, 'length': 7}) 823 self.__field_messages.writetobuffer(buf) 824 self.__field_unknown1.writetobuffer(buf) 825 self.__field_priority.writetobuffer(buf) 826 self.__field_unknown5.writetobuffer(buf) 827 self.__field_callback.writetobuffer(buf) 828 try: self.__field_recipients 829 except: 830 self.__field_recipients=LIST(**{'elementclass': recipient_record,'length': 9}) 831 self.__field_recipients.writetobuffer(buf) 832 self.__field_pad.writetobuffer(buf) 833 self._bufferendoffset=buf.getcurrentoffset() 834 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)

835 836

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

838 'Reads this packet from the supplied buffer' 839 self._bufferstartoffset=buf.getcurrentoffset() 840 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 841 self.__field_index=UINT(**{'sizeinbytes': 4}) 842 self.__field_index.readfrombuffer(buf) 843 self.__field_locked=UINT(**{'sizeinbytes': 1}) 844 self.__field_locked.readfrombuffer(buf) 845 self.__field_unknown2=UNKNOWN(**{'sizeinbytes': 1}) 846 self.__field_unknown2.readfrombuffer(buf) 847 self.__field_timesent=LGCALDATE(**{'sizeinbytes': 4}) 848 self.__field_timesent.readfrombuffer(buf) 849 self.__field_unknown2=UNKNOWN(**{'sizeinbytes': 6}) 850 self.__field_unknown2.readfrombuffer(buf) 851 self.__field_subject=USTRING(**{'sizeinbytes': 21}) 852 self.__field_subject.readfrombuffer(buf) 853 self.__field_unknown4=UNKNOWN(**{'sizeinbytes': 1}) 854 self.__field_unknown4.readfrombuffer(buf) 855 self.__field_num_msg_elements=UINT(**{'sizeinbytes': 2}) 856 self.__field_num_msg_elements.readfrombuffer(buf) 857 self.__field_messages=LIST(**{'elementclass': msg_record, 'length': 7}) 858 self.__field_messages.readfrombuffer(buf) 859 self.__field_unknown1=UNKNOWN(**{'sizeinbytes': 14}) 860 self.__field_unknown1.readfrombuffer(buf) 861 self.__field_priority=UINT(**{'sizeinbytes': 1}) 862 self.__field_priority.readfrombuffer(buf) 863 self.__field_unknown5=UNKNOWN(**{'sizeinbytes': 1}) 864 self.__field_unknown5.readfrombuffer(buf) 865 self.__field_callback=USTRING(**{'sizeinbytes': 35}) 866 self.__field_callback.readfrombuffer(buf) 867 self.__field_recipients=LIST(**{'elementclass': recipient_record,'length': 9}) 868 self.__field_recipients.readfrombuffer(buf) 869 self.__field_pad=UNKNOWN() 870 self.__field_pad.readfrombuffer(buf) 871 self._bufferendoffset=buf.getcurrentoffset()

872 873

874 - def __getfield_index(self):

875 return self.__field_index.getvalue()

876

877 - def __setfield_index(self, value):

878 if isinstance(value,UINT): 879 self.__field_index=value 880 else: 881 self.__field_index=UINT(value,**{'sizeinbytes': 4})

882

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

884 885 index=property(__getfield_index, __setfield_index, __delfield_index, None) 886

887 - def __getfield_locked(self):

888 return self.__field_locked.getvalue()

889

890 - def __setfield_locked(self, value):

891 if isinstance(value,UINT): 892 self.__field_locked=value 893 else: 894 self.__field_locked=UINT(value,**{'sizeinbytes': 1})

895

896 - def __delfield_locked(self): del self.__field_locked

897 898 locked=property(__getfield_locked, __setfield_locked, __delfield_locked, None) 899

900 - def __getfield_unknown2(self):

901 return self.__field_unknown2.getvalue()

902

903 - def __setfield_unknown2(self, value):

904 if isinstance(value,UNKNOWN): 905 self.__field_unknown2=value 906 else: 907 self.__field_unknown2=UNKNOWN(value,**{'sizeinbytes': 1})

908

909 - def __delfield_unknown2(self): del self.__field_unknown2

910 911 unknown2=property(__getfield_unknown2, __setfield_unknown2, __delfield_unknown2, None) 912

913 - def __getfield_timesent(self):

914 return self.__field_timesent.getvalue()

915

916 - def __setfield_timesent(self, value):

917 if isinstance(value,LGCALDATE): 918 self.__field_timesent=value 919 else: 920 self.__field_timesent=LGCALDATE(value,**{'sizeinbytes': 4})

921

922 - def __delfield_timesent(self): del self.__field_timesent

923 924 timesent=property(__getfield_timesent, __setfield_timesent, __delfield_timesent, None) 925

926 - def __getfield_unknown2(self):

927 return self.__field_unknown2.getvalue()

928

929 - def __setfield_unknown2(self, value):

930 if isinstance(value,UNKNOWN): 931 self.__field_unknown2=value 932 else: 933 self.__field_unknown2=UNKNOWN(value,**{'sizeinbytes': 6})

934

935 - def __delfield_unknown2(self): del self.__field_unknown2

936 937 unknown2=property(__getfield_unknown2, __setfield_unknown2, __delfield_unknown2, None) 938

939 - def __getfield_subject(self):

940 return self.__field_subject.getvalue()

941

942 - def __setfield_subject(self, value):

943 if isinstance(value,USTRING): 944 self.__field_subject=value 945 else: 946 self.__field_subject=USTRING(value,**{'sizeinbytes': 21})

947

948 - def __delfield_subject(self): del self.__field_subject

949 950 subject=property(__getfield_subject, __setfield_subject, __delfield_subject, None) 951

952 - def __getfield_unknown4(self):

953 return self.__field_unknown4.getvalue()

954

955 - def __setfield_unknown4(self, value):

956 if isinstance(value,UNKNOWN): 957 self.__field_unknown4=value 958 else: 959 self.__field_unknown4=UNKNOWN(value,**{'sizeinbytes': 1})

960

961 - def __delfield_unknown4(self): del self.__field_unknown4

962 963 unknown4=property(__getfield_unknown4, __setfield_unknown4, __delfield_unknown4, None) 964

965 - def __getfield_num_msg_elements(self):

966 return self.__field_num_msg_elements.getvalue()

967

968 - def __setfield_num_msg_elements(self, value):

969 if isinstance(value,UINT): 970 self.__field_num_msg_elements=value 971 else: 972 self.__field_num_msg_elements=UINT(value,**{'sizeinbytes': 2})

973

974 - def __delfield_num_msg_elements(self): del self.__field_num_msg_elements

975 976 num_msg_elements=property(__getfield_num_msg_elements, __setfield_num_msg_elements, __delfield_num_msg_elements, None) 977

978 - def __getfield_messages(self):

979 try: self.__field_messages 980 except: 981 self.__field_messages=LIST(**{'elementclass': msg_record, 'length': 7}) 982 return self.__field_messages.getvalue()

983

984 - def __setfield_messages(self, value):

985 if isinstance(value,LIST): 986 self.__field_messages=value 987 else: 988 self.__field_messages=LIST(value,**{'elementclass': msg_record, 'length': 7})

989

990 - def __delfield_messages(self): del self.__field_messages

991 992 messages=property(__getfield_messages, __setfield_messages, __delfield_messages, None) 993

994 - def __getfield_unknown1(self):

995 return self.__field_unknown1.getvalue()

996

997 - def __setfield_unknown1(self, value):

998 if isinstance(value,UNKNOWN): 999 self.__field_unknown1=value 1000 else: 1001 self.__field_unknown1=UNKNOWN(value,**{'sizeinbytes': 14})

1002

1003 - def __delfield_unknown1(self): del self.__field_unknown1

1004 1005 unknown1=property(__getfield_unknown1, __setfield_unknown1, __delfield_unknown1, None) 1006

1007 - def __getfield_priority(self):

1008 return self.__field_priority.getvalue()

1009

1010 - def __setfield_priority(self, value):

1011 if isinstance(value,UINT): 1012 self.__field_priority=value 1013 else: 1014 self.__field_priority=UINT(value,**{'sizeinbytes': 1})

1015

1016 - def __delfield_priority(self): del self.__field_priority

1017 1018 priority=property(__getfield_priority, __setfield_priority, __delfield_priority, None) 1019

1020 - def __getfield_unknown5(self):

1021 return self.__field_unknown5.getvalue()

1022

1023 - def __setfield_unknown5(self, value):

1024 if isinstance(value,UNKNOWN): 1025 self.__field_unknown5=value 1026 else: 1027 self.__field_unknown5=UNKNOWN(value,**{'sizeinbytes': 1})

1028

1029 - def __delfield_unknown5(self): del self.__field_unknown5

1030 1031 unknown5=property(__getfield_unknown5, __setfield_unknown5, __delfield_unknown5, None) 1032

1033 - def __getfield_callback(self):

1034 return self.__field_callback.getvalue()

1035

1036 - def __setfield_callback(self, value):

1037 if isinstance(value,USTRING): 1038 self.__field_callback=value 1039 else: 1040 self.__field_callback=USTRING(value,**{'sizeinbytes': 35})

1041

1042 - def __delfield_callback(self): del self.__field_callback

1043 1044 callback=property(__getfield_callback, __setfield_callback, __delfield_callback, None) 1045

1046 - def __getfield_recipients(self):

1047 try: self.__field_recipients 1048 except: 1049 self.__field_recipients=LIST(**{'elementclass': recipient_record,'length': 9}) 1050 return self.__field_recipients.getvalue()

1051

1052 - def __setfield_recipients(self, value):

1053 if isinstance(value,LIST): 1054 self.__field_recipients=value 1055 else: 1056 self.__field_recipients=LIST(value,**{'elementclass': recipient_record,'length': 9})

1057

1058 - def __delfield_recipients(self): del self.__field_recipients

1059 1060 recipients=property(__getfield_recipients, __setfield_recipients, __delfield_recipients, None) 1061

1062 - def __getfield_pad(self):

1063 return self.__field_pad.getvalue()

1064

1065 - def __setfield_pad(self, value):

1066 if isinstance(value,UNKNOWN): 1067 self.__field_pad=value 1068 else: 1069 self.__field_pad=UNKNOWN(value,)

1070

1071 - def __delfield_pad(self): del self.__field_pad

1072 1073 pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None) 1074

1075 - def iscontainer(self):

1076 return True

1077

1078 - def containerelements(self):

1079 yield ('index', self.__field_index, None) 1080 yield ('locked', self.__field_locked, None) 1081 yield ('unknown2', self.__field_unknown2, None) 1082 yield ('timesent', self.__field_timesent, None) 1083 yield ('unknown2', self.__field_unknown2, None) 1084 yield ('subject', self.__field_subject, None) 1085 yield ('unknown4', self.__field_unknown4, None) 1086 yield ('num_msg_elements', self.__field_num_msg_elements, None) 1087 yield ('messages', self.__field_messages, None) 1088 yield ('unknown1', self.__field_unknown1, None) 1089 yield ('priority', self.__field_priority, None) 1090 yield ('unknown5', self.__field_unknown5, None) 1091 yield ('callback', self.__field_callback, None) 1092 yield ('recipients', self.__field_recipients, None) 1093 yield ('pad', self.__field_pad, None)

1094 1095 1096 1097

1098 -class SMSINBOXMSGFRAGMENT(BaseProtogenClass):

1099 __fields=['msg'] 1100

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

1102 dict={} 1103 # What was supplied to this function 1104 dict.update(kwargs) 1105 # Parent constructor 1106 super(SMSINBOXMSGFRAGMENT,self).__init__(**dict) 1107 if self.__class__ is SMSINBOXMSGFRAGMENT: 1108 self._update(args,dict)

1109 1110

1111 - def getfields(self):

1112 return self.__fields

1113 1114

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

1116 super(SMSINBOXMSGFRAGMENT,self)._update(args,kwargs) 1117 keys=kwargs.keys() 1118 for key in keys: 1119 if key in self.__fields: 1120 setattr(self, key, kwargs[key]) 1121 del kwargs[key] 1122 # Were any unrecognized kwargs passed in? 1123 if __debug__: 1124 self._complainaboutunusedargs(SMSINBOXMSGFRAGMENT,kwargs) 1125 if len(args): 1126 dict2={'elementclass': _gen_p_lgvx8000_117, 'length': 181} 1127 dict2.update(kwargs) 1128 kwargs=dict2 1129 self.__field_msg=LIST(*args,**dict2)

1130 # Make all P fields that haven't already been constructed 1131 1132

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

1134 'Writes this packet to the supplied buffer' 1135 self._bufferstartoffset=buf.getcurrentoffset() 1136 try: self.__field_msg 1137 except: 1138 self.__field_msg=LIST(**{'elementclass': _gen_p_lgvx8000_117, 'length': 181}) 1139 self.__field_msg.writetobuffer(buf) 1140 self._bufferendoffset=buf.getcurrentoffset() 1141 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)

1142 1143

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

1145 'Reads this packet from the supplied buffer' 1146 self._bufferstartoffset=buf.getcurrentoffset() 1147 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 1148 self.__field_msg=LIST(**{'elementclass': _gen_p_lgvx8000_117, 'length': 181}) 1149 self.__field_msg.readfrombuffer(buf) 1150 self._bufferendoffset=buf.getcurrentoffset()

1151 1152

1153 - def __getfield_msg(self):

1154 try: self.__field_msg 1155 except: 1156 self.__field_msg=LIST(**{'elementclass': _gen_p_lgvx8000_117, 'length': 181}) 1157 return self.__field_msg.getvalue()

1158

1159 - def __setfield_msg(self, value):

1160 if isinstance(value,LIST): 1161 self.__field_msg=value 1162 else: 1163 self.__field_msg=LIST(value,**{'elementclass': _gen_p_lgvx8000_117, 'length': 181})

1164

1165 - def __delfield_msg(self): del self.__field_msg

1166 1167 msg=property(__getfield_msg, __setfield_msg, __delfield_msg, None) 1168

1169 - def iscontainer(self):

1170 return True

1171

1172 - def containerelements(self):

1173 yield ('msg', self.__field_msg, None)

1174 1175 1176 1177

1178 -class _gen_p_lgvx8000_117(BaseProtogenClass):

1179 'Anonymous inner class' 1180 __fields=['byte'] 1181

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

1183 dict={} 1184 # What was supplied to this function 1185 dict.update(kwargs) 1186 # Parent constructor 1187 super(_gen_p_lgvx8000_117,self).__init__(**dict) 1188 if self.__class__ is _gen_p_lgvx8000_117: 1189 self._update(args,dict)

1190 1191

1192 - def getfields(self):

1193 return self.__fields

1194 1195

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

1197 super(_gen_p_lgvx8000_117,self)._update(args,kwargs) 1198 keys=kwargs.keys() 1199 for key in keys: 1200 if key in self.__fields: 1201 setattr(self, key, kwargs[key]) 1202 del kwargs[key] 1203 # Were any unrecognized kwargs passed in? 1204 if __debug__: 1205 self._complainaboutunusedargs(_gen_p_lgvx8000_117,kwargs) 1206 if len(args): 1207 dict2={'sizeinbytes': 1} 1208 dict2.update(kwargs) 1209 kwargs=dict2 1210 self.__field_byte=UINT(*args,**dict2)

1211 # Make all P fields that haven't already been constructed 1212 1213

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

1215 'Writes this packet to the supplied buffer' 1216 self._bufferstartoffset=buf.getcurrentoffset() 1217 self.__field_byte.writetobuffer(buf) 1218 self._bufferendoffset=buf.getcurrentoffset() 1219 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)

1220 1221

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

1223 'Reads this packet from the supplied buffer' 1224 self._bufferstartoffset=buf.getcurrentoffset() 1225 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 1226 self.__field_byte=UINT(**{'sizeinbytes': 1}) 1227 self.__field_byte.readfrombuffer(buf) 1228 self._bufferendoffset=buf.getcurrentoffset()

1229 1230

1231 - def __getfield_byte(self):

1232 return self.__field_byte.getvalue()

1233

1234 - def __setfield_byte(self, value):

1235 if isinstance(value,UINT): 1236 self.__field_byte=value 1237 else: 1238 self.__field_byte=UINT(value,**{'sizeinbytes': 1})

1239

1240 - def __delfield_byte(self): del self.__field_byte

1241 1242 byte=property(__getfield_byte, __setfield_byte, __delfield_byte, "individual byte of message") 1243

1244 - def iscontainer(self):

1245 return True

1246

1247 - def containerelements(self):

1248 yield ('byte', self.__field_byte, "individual byte of message")

1249 1250 1251 1252

1253 -class sms_in(BaseProtogenClass):

1254 __fields=['unknown1', 'timesent', 'unknown2', 'callback_length', 'callback', 'sender_length', 'sender', 'unknown3', 'lg_time', 'unknown4', 'GPStime', 'unknown5', 'read', 'locked', 'unknown6', 'priority', 'subject', 'bin_header1', 'bin_header2', 'unknown7', 'multipartID', 'bin_header3', 'num_msg_elements', 'msglengths', 'unknown8', 'msgs', 'unknown9'] 1255

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

1257 dict={} 1258 # What was supplied to this function 1259 dict.update(kwargs) 1260 # Parent constructor 1261 super(sms_in,self).__init__(**dict) 1262 if self.__class__ is sms_in: 1263 self._update(args,dict)

1264 1265

1266 - def getfields(self):

1267 return self.__fields

1268 1269

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

1271 super(sms_in,self)._update(args,kwargs) 1272 keys=kwargs.keys() 1273 for key in keys: 1274 if key in self.__fields: 1275 setattr(self, key, kwargs[key]) 1276 del kwargs[key] 1277 # Were any unrecognized kwargs passed in? 1278 if __debug__: 1279 self._complainaboutunusedargs(sms_in,kwargs) 1280 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)

1281 # Make all P fields that haven't already been constructed 1282 1283

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

1285 'Writes this packet to the supplied buffer' 1286 self._bufferstartoffset=buf.getcurrentoffset() 1287 self.__field_unknown1.writetobuffer(buf) 1288 self.__field_timesent.writetobuffer(buf) 1289 self.__field_unknown2.writetobuffer(buf) 1290 self.__field_callback_length.writetobuffer(buf) 1291 self.__field_callback.writetobuffer(buf) 1292 self.__field_sender_length.writetobuffer(buf) 1293 try: self.__field_sender 1294 except: 1295 self.__field_sender=LIST(**{'elementclass': _gen_p_lgvx8000_127, 'length': 38}) 1296 self.__field_sender.writetobuffer(buf) 1297 self.__field_unknown3.writetobuffer(buf) 1298 self.__field_lg_time.writetobuffer(buf) 1299 self.__field_unknown4.writetobuffer(buf) 1300 self.__field_GPStime.writetobuffer(buf) 1301 self.__field_unknown5.writetobuffer(buf) 1302 self.__field_read.writetobuffer(buf) 1303 self.__field_locked.writetobuffer(buf) 1304 self.__field_unknown6.writetobuffer(buf) 1305 self.__field_priority.writetobuffer(buf) 1306 self.__field_subject.writetobuffer(buf) 1307 self.__field_bin_header1.writetobuffer(buf) 1308 self.__field_bin_header2.writetobuffer(buf) 1309 self.__field_unknown7.writetobuffer(buf) 1310 self.__field_multipartID.writetobuffer(buf) 1311 self.__field_bin_header3.writetobuffer(buf) 1312 self.__field_num_msg_elements.writetobuffer(buf) 1313 try: self.__field_msglengths 1314 except: 1315 self.__field_msglengths=LIST(**{'elementclass': _gen_p_lgvx8000_145, 'length': 10}) 1316 self.__field_msglengths.writetobuffer(buf) 1317 self.__field_unknown8.writetobuffer(buf) 1318 try: self.__field_msgs 1319 except: 1320 self.__field_msgs=LIST(**{'length': 10, 'elementclass': SMSINBOXMSGFRAGMENT}) 1321 self.__field_msgs.writetobuffer(buf) 1322 self.__field_unknown9.writetobuffer(buf) 1323 self._bufferendoffset=buf.getcurrentoffset() 1324 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)

1325 1326

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

1328 'Reads this packet from the supplied buffer' 1329 self._bufferstartoffset=buf.getcurrentoffset() 1330 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 1331 self.__field_unknown1=UNKNOWN(**{'sizeinbytes': 10}) 1332 self.__field_unknown1.readfrombuffer(buf) 1333 self.__field_timesent=SMSDATE(**{'sizeinbytes': 6}) 1334 self.__field_timesent.readfrombuffer(buf) 1335 self.__field_unknown2=UINT(**{'sizeinbytes': 3}) 1336 self.__field_unknown2.readfrombuffer(buf) 1337 self.__field_callback_length=UINT(**{'sizeinbytes': 1}) 1338 self.__field_callback_length.readfrombuffer(buf) 1339 self.__field_callback=USTRING(**{'sizeinbytes': 38}) 1340 self.__field_callback.readfrombuffer(buf) 1341 self.__field_sender_length=UINT(**{'sizeinbytes': 1}) 1342 self.__field_sender_length.readfrombuffer(buf) 1343 self.__field_sender=LIST(**{'elementclass': _gen_p_lgvx8000_127, 'length': 38}) 1344 self.__field_sender.readfrombuffer(buf) 1345 self.__field_unknown3=DATA(**{'sizeinbytes': 12}) 1346 self.__field_unknown3.readfrombuffer(buf) 1347 self.__field_lg_time=LGCALDATE(**{'sizeinbytes': 4}) 1348 self.__field_lg_time.readfrombuffer(buf) 1349 self.__field_unknown4=UNKNOWN(**{'sizeinbytes': 3}) 1350 self.__field_unknown4.readfrombuffer(buf) 1351 self.__field_GPStime=GPSDATE(**{'sizeinbytes': 4}) 1352 self.__field_GPStime.readfrombuffer(buf) 1353 self.__field_unknown5=UINT(**{'sizeinbytes': 4}) 1354 self.__field_unknown5.readfrombuffer(buf) 1355 self.__field_read=UINT(**{'sizeinbytes': 1}) 1356 self.__field_read.readfrombuffer(buf) 1357 self.__field_locked=UINT(**{'sizeinbytes': 1}) 1358 self.__field_locked.readfrombuffer(buf) 1359 self.__field_unknown6=UINT(**{'sizeinbytes': 8}) 1360 self.__field_unknown6.readfrombuffer(buf) 1361 self.__field_priority=UINT(**{'sizeinbytes': 1}) 1362 self.__field_priority.readfrombuffer(buf) 1363 self.__field_subject=USTRING(**{'sizeinbytes': 21}) 1364 self.__field_subject.readfrombuffer(buf) 1365 self.__field_bin_header1=UINT(**{'sizeinbytes': 1}) 1366 self.__field_bin_header1.readfrombuffer(buf) 1367 self.__field_bin_header2=UINT(**{'sizeinbytes': 1}) 1368 self.__field_bin_header2.readfrombuffer(buf) 1369 self.__field_unknown7=UINT(**{'sizeinbytes': 4}) 1370 self.__field_unknown7.readfrombuffer(buf) 1371 self.__field_multipartID=UINT(**{'sizeinbytes': 2}) 1372 self.__field_multipartID.readfrombuffer(buf) 1373 self.__field_bin_header3=UINT(**{'sizeinbytes': 1}) 1374 self.__field_bin_header3.readfrombuffer(buf) 1375 self.__field_num_msg_elements=UINT(**{'sizeinbytes': 1}) 1376 self.__field_num_msg_elements.readfrombuffer(buf) 1377 self.__field_msglengths=LIST(**{'elementclass': _gen_p_lgvx8000_145, 'length': 10}) 1378 self.__field_msglengths.readfrombuffer(buf) 1379 self.__field_unknown8=UNKNOWN(**{'sizeinbytes': 10}) 1380 self.__field_unknown8.readfrombuffer(buf) 1381 self.__field_msgs=LIST(**{'length': 10, 'elementclass': SMSINBOXMSGFRAGMENT}) 1382 self.__field_msgs.readfrombuffer(buf) 1383 self.__field_unknown9=UNKNOWN() 1384 self.__field_unknown9.readfrombuffer(buf) 1385 self._bufferendoffset=buf.getcurrentoffset()

1386 1387

1388 - def __getfield_unknown1(self):

1389 return self.__field_unknown1.getvalue()

1390

1391 - def __setfield_unknown1(self, value):

1392 if isinstance(value,UNKNOWN): 1393 self.__field_unknown1=value 1394 else: 1395 self.__field_unknown1=UNKNOWN(value,**{'sizeinbytes': 10})

1396

1397 - def __delfield_unknown1(self): del self.__field_unknown1

1398 1399 unknown1=property(__getfield_unknown1, __setfield_unknown1, __delfield_unknown1, None) 1400

1401 - def __getfield_timesent(self):

1402 return self.__field_timesent.getvalue()

1403

1404 - def __setfield_timesent(self, value):

1405 if isinstance(value,SMSDATE): 1406 self.__field_timesent=value 1407 else: 1408 self.__field_timesent=SMSDATE(value,**{'sizeinbytes': 6})

1409

1410 - def __delfield_timesent(self): del self.__field_timesent

1411 1412 timesent=property(__getfield_timesent, __setfield_timesent, __delfield_timesent, None) 1413

1414 - def __getfield_unknown2(self):

1415 return self.__field_unknown2.getvalue()

1416

1417 - def __setfield_unknown2(self, value):

1418 if isinstance(value,UINT): 1419 self.__field_unknown2=value 1420 else: 1421 self.__field_unknown2=UINT(value,**{'sizeinbytes': 3})

1422

1423 - def __delfield_unknown2(self): del self.__field_unknown2

1424 1425 unknown2=property(__getfield_unknown2, __setfield_unknown2, __delfield_unknown2, None) 1426

1427 - def __getfield_callback_length(self):

1428 return self.__field_callback_length.getvalue()

1429

1430 - def __setfield_callback_length(self, value):

1431 if isinstance(value,UINT): 1432 self.__field_callback_length=value 1433 else: 1434 self.__field_callback_length=UINT(value,**{'sizeinbytes': 1})

1435

1436 - def __delfield_callback_length(self): del self.__field_callback_length

1437 1438 callback_length=property(__getfield_callback_length, __setfield_callback_length, __delfield_callback_length, None) 1439

1440 - def __getfield_callback(self):

1441 return self.__field_callback.getvalue()

1442

1443 - def __setfield_callback(self, value):

1444 if isinstance(value,USTRING): 1445 self.__field_callback=value 1446 else: 1447 self.__field_callback=USTRING(value,**{'sizeinbytes': 38})

1448

1449 - def __delfield_callback(self): del self.__field_callback

1450 1451 callback=property(__getfield_callback, __setfield_callback, __delfield_callback, None) 1452

1453 - def __getfield_sender_length(self):

1454 return self.__field_sender_length.getvalue()

1455

1456 - def __setfield_sender_length(self, value):

1457 if isinstance(value,UINT): 1458 self.__field_sender_length=value 1459 else: 1460 self.__field_sender_length=UINT(value,**{'sizeinbytes': 1})

1461

1462 - def __delfield_sender_length(self): del self.__field_sender_length

1463 1464 sender_length=property(__getfield_sender_length, __setfield_sender_length, __delfield_sender_length, None) 1465

1466 - def __getfield_sender(self):

1467 try: self.__field_sender 1468 except: 1469 self.__field_sender=LIST(**{'elementclass': _gen_p_lgvx8000_127, 'length': 38}) 1470 return self.__field_sender.getvalue()

1471

1472 - def __setfield_sender(self, value):

1473 if isinstance(value,LIST): 1474 self.__field_sender=value 1475 else: 1476 self.__field_sender=LIST(value,**{'elementclass': _gen_p_lgvx8000_127, 'length': 38})

1477

1478 - def __delfield_sender(self): del self.__field_sender

1479 1480 sender=property(__getfield_sender, __setfield_sender, __delfield_sender, None) 1481

1482 - def __getfield_unknown3(self):

1483 return self.__field_unknown3.getvalue()

1484

1485 - def __setfield_unknown3(self, value):

1486 if isinstance(value,DATA): 1487 self.__field_unknown3=value 1488 else: 1489 self.__field_unknown3=DATA(value,**{'sizeinbytes': 12})

1490

1491 - def __delfield_unknown3(self): del self.__field_unknown3

1492 1493 unknown3=property(__getfield_unknown3, __setfield_unknown3, __delfield_unknown3, None) 1494

1495 - def __getfield_lg_time(self):

1496 return self.__field_lg_time.getvalue()

1497

1498 - def __setfield_lg_time(self, value):

1499 if isinstance(value,LGCALDATE): 1500 self.__field_lg_time=value 1501 else: 1502 self.__field_lg_time=LGCALDATE(value,**{'sizeinbytes': 4})

1503

1504 - def __delfield_lg_time(self): del self.__field_lg_time

1505 1506 lg_time=property(__getfield_lg_time, __setfield_lg_time, __delfield_lg_time, None) 1507

1508 - def __getfield_unknown4(self):

1509 return self.__field_unknown4.getvalue()

1510

1511 - def __setfield_unknown4(self, value):

1512 if isinstance(value,UNKNOWN): 1513 self.__field_unknown4=value 1514 else: 1515 self.__field_unknown4=UNKNOWN(value,**{'sizeinbytes': 3})

1516

1517 - def __delfield_unknown4(self): del self.__field_unknown4

1518 1519 unknown4=property(__getfield_unknown4, __setfield_unknown4, __delfield_unknown4, None) 1520

1521 - def __getfield_GPStime(self):

1522 return self.__field_GPStime.getvalue()

1523

1524 - def __setfield_GPStime(self, value):

1525 if isinstance(value,GPSDATE): 1526 self.__field_GPStime=value 1527 else: 1528 self.__field_GPStime=GPSDATE(value,**{'sizeinbytes': 4})

1529

1530 - def __delfield_GPStime(self): del self.__field_GPStime

1531 1532 GPStime=property(__getfield_GPStime, __setfield_GPStime, __delfield_GPStime, None) 1533

1534 - def __getfield_unknown5(self):

1535 return self.__field_unknown5.getvalue()

1536

1537 - def __setfield_unknown5(self, value):

1538 if isinstance(value,UINT): 1539 self.__field_unknown5=value 1540 else: 1541 self.__field_unknown5=UINT(value,**{'sizeinbytes': 4})

1542

1543 - def __delfield_unknown5(self): del self.__field_unknown5

1544 1545 unknown5=property(__getfield_unknown5, __setfield_unknown5, __delfield_unknown5, None) 1546

1547 - def __getfield_read(self):

1548 return self.__field_read.getvalue()

1549

1550 - def __setfield_read(self, value):

1551 if isinstance(value,UINT): 1552 self.__field_read=value 1553 else: 1554 self.__field_read=UINT(value,**{'sizeinbytes': 1})

1555

1556 - def __delfield_read(self): del self.__field_read

1557 1558 read=property(__getfield_read, __setfield_read, __delfield_read, None) 1559

1560 - def __getfield_locked(self):

1561 return self.__field_locked.getvalue()

1562

1563 - def __setfield_locked(self, value):

1564 if isinstance(value,UINT): 1565 self.__field_locked=value 1566 else: 1567 self.__field_locked=UINT(value,**{'sizeinbytes': 1})

1568

1569 - def __delfield_locked(self): del self.__field_locked

1570 1571 locked=property(__getfield_locked, __setfield_locked, __delfield_locked, None) 1572

1573 - def __getfield_unknown6(self):

1574 return self.__field_unknown6.getvalue()

1575

1576 - def __setfield_unknown6(self, value):

1577 if isinstance(value,UINT): 1578 self.__field_unknown6=value 1579 else: 1580 self.__field_unknown6=UINT(value,**{'sizeinbytes': 8})

1581

1582 - def __delfield_unknown6(self): del self.__field_unknown6

1583 1584 unknown6=property(__getfield_unknown6, __setfield_unknown6, __delfield_unknown6, None) 1585

1586 - def __getfield_priority(self):

1587 return self.__field_priority.getvalue()

1588

1589 - def __setfield_priority(self, value):

1590 if isinstance(value,UINT): 1591 self.__field_priority=value 1592 else: 1593 self.__field_priority=UINT(value,**{'sizeinbytes': 1})

1594

1595 - def __delfield_priority(self): del self.__field_priority

1596 1597 priority=property(__getfield_priority, __setfield_priority, __delfield_priority, None) 1598

1599 - def __getfield_subject(self):

1600 return self.__field_subject.getvalue()

1601

1602 - def __setfield_subject(self, value):

1603 if isinstance(value,USTRING): 1604 self.__field_subject=value 1605 else: 1606 self.__field_subject=USTRING(value,**{'sizeinbytes': 21})

1607

1608 - def __delfield_subject(self): del self.__field_subject

1609 1610 subject=property(__getfield_subject, __setfield_subject, __delfield_subject, None) 1611

1612 - def __getfield_bin_header1(self):

1613 return self.__field_bin_header1.getvalue()

1614

1615 - def __setfield_bin_header1(self, value):

1616 if isinstance(value,UINT): 1617 self.__field_bin_header1=value 1618 else: 1619 self.__field_bin_header1=UINT(value,**{'sizeinbytes': 1})

1620

1621 - def __delfield_bin_header1(self): del self.__field_bin_header1

1622 1623 bin_header1=property(__getfield_bin_header1, __setfield_bin_header1, __delfield_bin_header1, None) 1624

1625 - def __getfield_bin_header2(self):

1626 return self.__field_bin_header2.getvalue()

1627

1628 - def __setfield_bin_header2(self, value):

1629 if isinstance(value,UINT): 1630 self.__field_bin_header2=value 1631 else: 1632 self.__field_bin_header2=UINT(value,**{'sizeinbytes': 1})

1633

1634 - def __delfield_bin_header2(self): del self.__field_bin_header2

1635 1636 bin_header2=property(__getfield_bin_header2, __setfield_bin_header2, __delfield_bin_header2, None) 1637

1638 - def __getfield_unknown7(self):

1639 return self.__field_unknown7.getvalue()

1640

1641 - def __setfield_unknown7(self, value):

1642 if isinstance(value,UINT): 1643 self.__field_unknown7=value 1644 else: 1645 self.__field_unknown7=UINT(value,**{'sizeinbytes': 4})

1646

1647 - def __delfield_unknown7(self): del self.__field_unknown7

1648 1649 unknown7=property(__getfield_unknown7, __setfield_unknown7, __delfield_unknown7, None) 1650

1651 - def __getfield_multipartID(self):

1652 return self.__field_multipartID.getvalue()

1653

1654 - def __setfield_multipartID(self, value):

1655 if isinstance(value,UINT): 1656 self.__field_multipartID=value 1657 else: 1658 self.__field_multipartID=UINT(value,**{'sizeinbytes': 2})

1659

1660 - def __delfield_multipartID(self): del self.__field_multipartID

1661 1662 multipartID=property(__getfield_multipartID, __setfield_multipartID, __delfield_multipartID, None) 1663

1664 - def __getfield_bin_header3(self):

1665 return self.__field_bin_header3.getvalue()

1666

1667 - def __setfield_bin_header3(self, value):

1668 if isinstance(value,UINT): 1669 self.__field_bin_header3=value 1670 else: 1671 self.__field_bin_header3=UINT(value,**{'sizeinbytes': 1})

1672

1673 - def __delfield_bin_header3(self): del self.__field_bin_header3

1674 1675 bin_header3=property(__getfield_bin_header3, __setfield_bin_header3, __delfield_bin_header3, None) 1676

1677 - def __getfield_num_msg_elements(self):

1678 return self.__field_num_msg_elements.getvalue()

1679

1680 - def __setfield_num_msg_elements(self, value):

1681 if isinstance(value,UINT): 1682 self.__field_num_msg_elements=value 1683 else: 1684 self.__field_num_msg_elements=UINT(value,**{'sizeinbytes': 1})

1685

1686 - def __delfield_num_msg_elements(self): del self.__field_num_msg_elements

1687 1688 num_msg_elements=property(__getfield_num_msg_elements, __setfield_num_msg_elements, __delfield_num_msg_elements, None) 1689

1690 - def __getfield_msglengths(self):

1691 try: self.__field_msglengths 1692 except: 1693 self.__field_msglengths=LIST(**{'elementclass': _gen_p_lgvx8000_145, 'length': 10}) 1694 return self.__field_msglengths.getvalue()

1695

1696 - def __setfield_msglengths(self, value):

1697 if isinstance(value,LIST): 1698 self.__field_msglengths=value 1699 else: 1700 self.__field_msglengths=LIST(value,**{'elementclass': _gen_p_lgvx8000_145, 'length': 10})

1701

1702 - def __delfield_msglengths(self): del self.__field_msglengths

1703 1704 msglengths=property(__getfield_msglengths, __setfield_msglengths, __delfield_msglengths, None) 1705

1706 - def __getfield_unknown8(self):

1707 return self.__field_unknown8.getvalue()

1708

1709 - def __setfield_unknown8(self, value):

1710 if isinstance(value,UNKNOWN): 1711 self.__field_unknown8=value 1712 else: 1713 self.__field_unknown8=UNKNOWN(value,**{'sizeinbytes': 10})

1714

1715 - def __delfield_unknown8(self): del self.__field_unknown8

1716 1717 unknown8=property(__getfield_unknown8, __setfield_unknown8, __delfield_unknown8, None) 1718

1719 - def __getfield_msgs(self):

1720 try: self.__field_msgs 1721 except: 1722 self.__field_msgs=LIST(**{'length': 10, 'elementclass': SMSINBOXMSGFRAGMENT}) 1723 return self.__field_msgs.getvalue()

1724

1725 - def __setfield_msgs(self, value):

1726 if isinstance(value,LIST): 1727 self.__field_msgs=value 1728 else: 1729 self.__field_msgs=LIST(value,**{'length': 10, 'elementclass': SMSINBOXMSGFRAGMENT})

1730

1731 - def __delfield_msgs(self): del self.__field_msgs

1732 1733 msgs=property(__getfield_msgs, __setfield_msgs, __delfield_msgs, None) 1734

1735 - def __getfield_unknown9(self):

1736 return self.__field_unknown9.getvalue()

1737

1738 - def __setfield_unknown9(self, value):

1739 if isinstance(value,UNKNOWN): 1740 self.__field_unknown9=value 1741 else: 1742 self.__field_unknown9=UNKNOWN(value,)

1743

1744 - def __delfield_unknown9(self): del self.__field_unknown9

1745 1746 unknown9=property(__getfield_unknown9, __setfield_unknown9, __delfield_unknown9, None) 1747

1748 - def iscontainer(self):

1749 return True

1750

1751 - def containerelements(self):

1752 yield ('unknown1', self.__field_unknown1, None) 1753 yield ('timesent', self.__field_timesent, None) 1754 yield ('unknown2', self.__field_unknown2, None) 1755 yield ('callback_length', self.__field_callback_length, None) 1756 yield ('callback', self.__field_callback, None) 1757 yield ('sender_length', self.__field_sender_length, None) 1758 yield ('sender', self.__field_sender, None) 1759 yield ('unknown3', self.__field_unknown3, None) 1760 yield ('lg_time', self.__field_lg_time, None) 1761 yield ('unknown4', self.__field_unknown4, None) 1762 yield ('GPStime', self.__field_GPStime, None) 1763 yield ('unknown5', self.__field_unknown5, None) 1764 yield ('read', self.__field_read, None) 1765 yield ('locked', self.__field_locked, None) 1766 yield ('unknown6', self.__field_unknown6, None) 1767 yield ('priority', self.__field_priority, None) 1768 yield ('subject', self.__field_subject, None) 1769 yield ('bin_header1', self.__field_bin_header1, None) 1770 yield ('bin_header2', self.__field_bin_header2, None) 1771 yield ('unknown7', self.__field_unknown7, None) 1772 yield ('multipartID', self.__field_multipartID, None) 1773 yield ('bin_header3', self.__field_bin_header3, None) 1774 yield ('num_msg_elements', self.__field_num_msg_elements, None) 1775 yield ('msglengths', self.__field_msglengths, None) 1776 yield ('unknown8', self.__field_unknown8, None) 1777 yield ('msgs', self.__field_msgs, None) 1778 yield ('unknown9', self.__field_unknown9, None)

1779 1780 1781 1782

1783 -class _gen_p_lgvx8000_127(BaseProtogenClass):

1784 'Anonymous inner class' 1785 __fields=['byte'] 1786

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

1788 dict={} 1789 # What was supplied to this function 1790 dict.update(kwargs) 1791 # Parent constructor 1792 super(_gen_p_lgvx8000_127,self).__init__(**dict) 1793 if self.__class__ is _gen_p_lgvx8000_127: 1794 self._update(args,dict)

1795 1796

1797 - def getfields(self):

1798 return self.__fields

1799 1800

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

1802 super(_gen_p_lgvx8000_127,self)._update(args,kwargs) 1803 keys=kwargs.keys() 1804 for key in keys: 1805 if key in self.__fields: 1806 setattr(self, key, kwargs[key]) 1807 del kwargs[key] 1808 # Were any unrecognized kwargs passed in? 1809 if __debug__: 1810 self._complainaboutunusedargs(_gen_p_lgvx8000_127,kwargs) 1811 if len(args): 1812 dict2={'sizeinbytes': 1} 1813 dict2.update(kwargs) 1814 kwargs=dict2 1815 self.__field_byte=UINT(*args,**dict2)

1816 # Make all P fields that haven't already been constructed 1817 1818

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

1820 'Writes this packet to the supplied buffer' 1821 self._bufferstartoffset=buf.getcurrentoffset() 1822 self.__field_byte.writetobuffer(buf) 1823 self._bufferendoffset=buf.getcurrentoffset() 1824 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)

1825 1826

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

1828 'Reads this packet from the supplied buffer' 1829 self._bufferstartoffset=buf.getcurrentoffset() 1830 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 1831 self.__field_byte=UINT(**{'sizeinbytes': 1}) 1832 self.__field_byte.readfrombuffer(buf) 1833 self._bufferendoffset=buf.getcurrentoffset()

1834 1835

1836 - def __getfield_byte(self):

1837 return self.__field_byte.getvalue()

1838

1839 - def __setfield_byte(self, value):

1840 if isinstance(value,UINT): 1841 self.__field_byte=value 1842 else: 1843 self.__field_byte=UINT(value,**{'sizeinbytes': 1})

1844

1845 - def __delfield_byte(self): del self.__field_byte

1846 1847 byte=property(__getfield_byte, __setfield_byte, __delfield_byte, "individual byte of senders phone number") 1848

1849 - def iscontainer(self):

1850 return True

1851

1852 - def containerelements(self):

1853 yield ('byte', self.__field_byte, "individual byte of senders phone number")

1854 1855 1856 1857

1858 -class _gen_p_lgvx8000_145(BaseProtogenClass):

1859 'Anonymous inner class' 1860 __fields=['msglength'] 1861

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

1863 dict={} 1864 # What was supplied to this function 1865 dict.update(kwargs) 1866 # Parent constructor 1867 super(_gen_p_lgvx8000_145,self).__init__(**dict) 1868 if self.__class__ is _gen_p_lgvx8000_145: 1869 self._update(args,dict)

1870 1871

1872 - def getfields(self):

1873 return self.__fields

1874 1875

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

1877 super(_gen_p_lgvx8000_145,self)._update(args,kwargs) 1878 keys=kwargs.keys() 1879 for key in keys: 1880 if key in self.__fields: 1881 setattr(self, key, kwargs[key]) 1882 del kwargs[key] 1883 # Were any unrecognized kwargs passed in? 1884 if __debug__: 1885 self._complainaboutunusedargs(_gen_p_lgvx8000_145,kwargs) 1886 if len(args): 1887 dict2={'sizeinbytes': 1} 1888 dict2.update(kwargs) 1889 kwargs=dict2 1890 self.__field_msglength=UINT(*args,**dict2)

1891 # Make all P fields that haven't already been constructed 1892 1893

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

1895 'Writes this packet to the supplied buffer' 1896 self._bufferstartoffset=buf.getcurrentoffset() 1897 self.__field_msglength.writetobuffer(buf) 1898 self._bufferendoffset=buf.getcurrentoffset() 1899 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)

1900 1901

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

1903 'Reads this packet from the supplied buffer' 1904 self._bufferstartoffset=buf.getcurrentoffset() 1905 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 1906 self.__field_msglength=UINT(**{'sizeinbytes': 1}) 1907 self.__field_msglength.readfrombuffer(buf) 1908 self._bufferendoffset=buf.getcurrentoffset()

1909 1910

1911 - def __getfield_msglength(self):

1912 return self.__field_msglength.getvalue()

1913

1914 - def __setfield_msglength(self, value):

1915 if isinstance(value,UINT): 1916 self.__field_msglength=value 1917 else: 1918 self.__field_msglength=UINT(value,**{'sizeinbytes': 1})

1919

1920 - def __delfield_msglength(self): del self.__field_msglength

1921 1922 msglength=property(__getfield_msglength, __setfield_msglength, __delfield_msglength, "lengths of individual messages in septets") 1923

1924 - def iscontainer(self):

1925 return True

1926

1927 - def containerelements(self):

1928 yield ('msglength', self.__field_msglength, "lengths of individual messages in septets")

1929

Source Code for Module phones.p_lgvx8000