phones.p_lgvi5225

1 # THIS FILE IS AUTOMATICALLY GENERATED. EDIT THE SOURCE FILE NOT THIS ONE 2 3 """Various descriptions of data specific to LG VI5225""" 4 5 from prototypes import * 6 from prototypeslg import * 7 8 # Make all lg stuff available in this module as well 9 from p_lg import * 10 11 # we are the same as lgvx4400 except as noted 12 # below 13 from p_lgvx4400 import * 14 15 # We use LSB for all integer like fields 16 UINT=UINTlsb 17 BOOL=BOOLlsb 18 19 NUMSPEEDDIALS=100 20 FIRSTSPEEDDIAL=2 21 LASTSPEEDDIAL=99 22 NUMPHONEBOOKENTRIES=500 23 MAXCALENDARDESCRIPTION=38 24 25 NUMEMAILS=1 26 NUMPHONENUMBERS=5 27 MEMOLENGTH=48 28 29 pb_file_name='pim/pbentry.dat' 30 31 # Calendar parameters 32 NUMCALENDARENTRIES=300 33 CAL_REP_NONE=0x10 34 CAL_REP_DAILY=0x11 35 CAL_REP_MONFRI=0x12 36 CAL_REP_WEEKLY=0x13 37 CAL_REP_MONTHLY=0x14 38 CAL_REP_YEARLY=0x15 39 CAL_DOW_SUN=0x0800 40 CAL_DOW_MON=0x0400 41 CAL_DOW_TUE=0x0200 42 CAL_DOW_WED=0x0100 43 CAL_DOW_THU=0x0080 44 CAL_DOW_FRI=0x0040 45 CAL_DOW_SAT=0x0020 46 CAL_DOW_EXCEPTIONS=0x0010 47 CAL_REMINDER_NONE=0 48 CAL_REMINDER_ONTIME=1 49 CAL_REMINDER_5MIN=2 50 CAL_REMINDER_10MIN=3 51 CAL_REMINDER_1HOUR=4 52 CAL_REMINDER_1DAY=5 53 CAL_REMINDER_2DAYS=6 54 CAL_REPEAT_DATE=(2100, 12, 31) 55 56 cal_dir='sch' 57 cal_data_file_name='sch/schedule.dat' 58 cal_exception_file_name='sch/schexception.dat' 59 cal_has_voice_id=False 60

61 -class ffpacket(BaseProtogenClass):

62 __fields=['header', 'command', 'dunno1', 'dunno2', 'pad', 'dunno3', 'dunno4'] 63

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

65 dict={} 66 # What was supplied to this function 67 dict.update(kwargs) 68 # Parent constructor 69 super(ffpacket,self).__init__(**dict) 70 if self.__class__ is ffpacket: 71 self._update(args,dict)

72 73

74 - def getfields(self):

75 return self.__fields

76 77

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

79 super(ffpacket,self)._update(args,kwargs) 80 keys=kwargs.keys() 81 for key in keys: 82 if key in self.__fields: 83 setattr(self, key, kwargs[key]) 84 del kwargs[key] 85 # Were any unrecognized kwargs passed in? 86 if __debug__: 87 self._complainaboutunusedargs(ffpacket,kwargs) 88 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)

89 # Make all P fields that haven't already been constructed 90 91

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

93 'Writes this packet to the supplied buffer' 94 self._bufferstartoffset=buf.getcurrentoffset() 95 try: self.__field_header 96 except: 97 self.__field_header=UINT(**{'sizeinbytes': 1, 'constant': 0xff}) 98 self.__field_header.writetobuffer(buf) 99 self.__field_command.writetobuffer(buf) 100 self.__field_dunno1.writetobuffer(buf) 101 self.__field_dunno2.writetobuffer(buf) 102 self.__field_pad.writetobuffer(buf) 103 self.__field_dunno3.writetobuffer(buf) 104 self.__field_dunno4.writetobuffer(buf) 105 self._bufferendoffset=buf.getcurrentoffset() 106 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)

107 108

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

110 'Reads this packet from the supplied buffer' 111 self._bufferstartoffset=buf.getcurrentoffset() 112 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 113 self.__field_header=UINT(**{'sizeinbytes': 1, 'constant': 0xff}) 114 self.__field_header.readfrombuffer(buf) 115 self.__field_command=UINT(**{'sizeinbytes': 1}) 116 self.__field_command.readfrombuffer(buf) 117 self.__field_dunno1=UINT(**{'sizeinbytes': 1}) 118 self.__field_dunno1.readfrombuffer(buf) 119 self.__field_dunno2=UINT(**{'sizeinbytes': 1}) 120 self.__field_dunno2.readfrombuffer(buf) 121 self.__field_pad=UKNOWN(**{'sizeinbytes': 4}) 122 self.__field_pad.readfrombuffer(buf) 123 self.__field_dunno3=UINT(**{'sizeinbytes': 1}) 124 self.__field_dunno3.readfrombuffer(buf) 125 self.__field_dunno4=UINT(**{'sizeinbytes': 1}) 126 self.__field_dunno4.readfrombuffer(buf) 127 self._bufferendoffset=buf.getcurrentoffset()

128 129

130 - def __getfield_header(self):

131 try: self.__field_header 132 except: 133 self.__field_header=UINT(**{'sizeinbytes': 1, 'constant': 0xff}) 134 return self.__field_header.getvalue()

135

136 - def __setfield_header(self, value):

137 if isinstance(value,UINT): 138 self.__field_header=value 139 else: 140 self.__field_header=UINT(value,**{'sizeinbytes': 1, 'constant': 0xff})

141

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

143 144 header=property(__getfield_header, __setfield_header, __delfield_header, None) 145

146 - def __getfield_command(self):

147 return self.__field_command.getvalue()

148

149 - def __setfield_command(self, value):

150 if isinstance(value,UINT): 151 self.__field_command=value 152 else: 153 self.__field_command=UINT(value,**{'sizeinbytes': 1})

154

155 - def __delfield_command(self): del self.__field_command

156 157 command=property(__getfield_command, __setfield_command, __delfield_command, None) 158

159 - def __getfield_dunno1(self):

160 return self.__field_dunno1.getvalue()

161

162 - def __setfield_dunno1(self, value):

163 if isinstance(value,UINT): 164 self.__field_dunno1=value 165 else: 166 self.__field_dunno1=UINT(value,**{'sizeinbytes': 1})

167

168 - def __delfield_dunno1(self): del self.__field_dunno1

169 170 dunno1=property(__getfield_dunno1, __setfield_dunno1, __delfield_dunno1, None) 171

172 - def __getfield_dunno2(self):

173 return self.__field_dunno2.getvalue()

174

175 - def __setfield_dunno2(self, value):

176 if isinstance(value,UINT): 177 self.__field_dunno2=value 178 else: 179 self.__field_dunno2=UINT(value,**{'sizeinbytes': 1})

180

181 - def __delfield_dunno2(self): del self.__field_dunno2

182 183 dunno2=property(__getfield_dunno2, __setfield_dunno2, __delfield_dunno2, None) 184

185 - def __getfield_pad(self):

186 return self.__field_pad.getvalue()

187

188 - def __setfield_pad(self, value):

189 if isinstance(value,UKNOWN): 190 self.__field_pad=value 191 else: 192 self.__field_pad=UKNOWN(value,**{'sizeinbytes': 4})

193

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

195 196 pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None) 197

198 - def __getfield_dunno3(self):

199 return self.__field_dunno3.getvalue()

200

201 - def __setfield_dunno3(self, value):

202 if isinstance(value,UINT): 203 self.__field_dunno3=value 204 else: 205 self.__field_dunno3=UINT(value,**{'sizeinbytes': 1})

206

207 - def __delfield_dunno3(self): del self.__field_dunno3

208 209 dunno3=property(__getfield_dunno3, __setfield_dunno3, __delfield_dunno3, None) 210

211 - def __getfield_dunno4(self):

212 return self.__field_dunno4.getvalue()

213

214 - def __setfield_dunno4(self, value):

215 if isinstance(value,UINT): 216 self.__field_dunno4=value 217 else: 218 self.__field_dunno4=UINT(value,**{'sizeinbytes': 1})

219

220 - def __delfield_dunno4(self): del self.__field_dunno4

221 222 dunno4=property(__getfield_dunno4, __setfield_dunno4, __delfield_dunno4, None) 223

224 - def iscontainer(self):

225 return True

226

227 - def containerelements(self):

228 yield ('header', self.__field_header, None) 229 yield ('command', self.__field_command, None) 230 yield ('dunno1', self.__field_dunno1, None) 231 yield ('dunno2', self.__field_dunno2, None) 232 yield ('pad', self.__field_pad, None) 233 yield ('dunno3', self.__field_dunno3, None) 234 yield ('dunno4', self.__field_dunno4, None)

235 236 237 238

239 -class speeddial(BaseProtogenClass):

240 __fields=['entry', 'number'] 241

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

243 dict={} 244 # What was supplied to this function 245 dict.update(kwargs) 246 # Parent constructor 247 super(speeddial,self).__init__(**dict) 248 if self.__class__ is speeddial: 249 self._update(args,dict)

250 251

252 - def getfields(self):

253 return self.__fields

254 255

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

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

267 # Make all P fields that haven't already been constructed 268 269

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

271 'Writes this packet to the supplied buffer' 272 self._bufferstartoffset=buf.getcurrentoffset() 273 try: self.__field_entry 274 except: 275 self.__field_entry=UINT(**{'sizeinbytes': 1, 'default': 0xff}) 276 self.__field_entry.writetobuffer(buf) 277 try: self.__field_number 278 except: 279 self.__field_number=UINT(**{'sizeinbytes': 1, 'default': 0xff}) 280 self.__field_number.writetobuffer(buf) 281 self._bufferendoffset=buf.getcurrentoffset() 282 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)

283 284

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

286 'Reads this packet from the supplied buffer' 287 self._bufferstartoffset=buf.getcurrentoffset() 288 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 289 self.__field_entry=UINT(**{'sizeinbytes': 1, 'default': 0xff}) 290 self.__field_entry.readfrombuffer(buf) 291 self.__field_number=UINT(**{'sizeinbytes': 1, 'default': 0xff}) 292 self.__field_number.readfrombuffer(buf) 293 self._bufferendoffset=buf.getcurrentoffset()

294 295

296 - def __getfield_entry(self):

297 try: self.__field_entry 298 except: 299 self.__field_entry=UINT(**{'sizeinbytes': 1, 'default': 0xff}) 300 return self.__field_entry.getvalue()

301

302 - def __setfield_entry(self, value):

303 if isinstance(value,UINT): 304 self.__field_entry=value 305 else: 306 self.__field_entry=UINT(value,**{'sizeinbytes': 1, 'default': 0xff})

307

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

309 310 entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None) 311

312 - def __getfield_number(self):

313 try: self.__field_number 314 except: 315 self.__field_number=UINT(**{'sizeinbytes': 1, 'default': 0xff}) 316 return self.__field_number.getvalue()

317

318 - def __setfield_number(self, value):

319 if isinstance(value,UINT): 320 self.__field_number=value 321 else: 322 self.__field_number=UINT(value,**{'sizeinbytes': 1, 'default': 0xff})

323

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

325 326 number=property(__getfield_number, __setfield_number, __delfield_number, None) 327

328 - def iscontainer(self):

329 return True

330

331 - def containerelements(self):

332 yield ('entry', self.__field_entry, None) 333 yield ('number', self.__field_number, None)

334 335 336 337

338 -class speeddials(BaseProtogenClass):

339 __fields=['speeddials'] 340

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

342 dict={} 343 # What was supplied to this function 344 dict.update(kwargs) 345 # Parent constructor 346 super(speeddials,self).__init__(**dict) 347 if self.__class__ is speeddials: 348 self._update(args,dict)

349 350

351 - def getfields(self):

352 return self.__fields

353 354

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

356 super(speeddials,self)._update(args,kwargs) 357 keys=kwargs.keys() 358 for key in keys: 359 if key in self.__fields: 360 setattr(self, key, kwargs[key]) 361 del kwargs[key] 362 # Were any unrecognized kwargs passed in? 363 if __debug__: 364 self._complainaboutunusedargs(speeddials,kwargs) 365 if len(args): 366 dict2={'length': NUMSPEEDDIALS, 'elementclass': speeddial} 367 dict2.update(kwargs) 368 kwargs=dict2 369 self.__field_speeddials=LIST(*args,**dict2)

370 # Make all P fields that haven't already been constructed 371 372

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

374 'Writes this packet to the supplied buffer' 375 self._bufferstartoffset=buf.getcurrentoffset() 376 try: self.__field_speeddials 377 except: 378 self.__field_speeddials=LIST(**{'length': NUMSPEEDDIALS, 'elementclass': speeddial}) 379 self.__field_speeddials.writetobuffer(buf) 380 self._bufferendoffset=buf.getcurrentoffset() 381 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)

382 383

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

385 'Reads this packet from the supplied buffer' 386 self._bufferstartoffset=buf.getcurrentoffset() 387 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 388 self.__field_speeddials=LIST(**{'length': NUMSPEEDDIALS, 'elementclass': speeddial}) 389 self.__field_speeddials.readfrombuffer(buf) 390 self._bufferendoffset=buf.getcurrentoffset()

391 392

393 - def __getfield_speeddials(self):

394 try: self.__field_speeddials 395 except: 396 self.__field_speeddials=LIST(**{'length': NUMSPEEDDIALS, 'elementclass': speeddial}) 397 return self.__field_speeddials.getvalue()

398

399 - def __setfield_speeddials(self, value):

400 if isinstance(value,LIST): 401 self.__field_speeddials=value 402 else: 403 self.__field_speeddials=LIST(value,**{'length': NUMSPEEDDIALS, 'elementclass': speeddial})

404

405 - def __delfield_speeddials(self): del self.__field_speeddials

406 407 speeddials=property(__getfield_speeddials, __setfield_speeddials, __delfield_speeddials, None) 408

409 - def iscontainer(self):

410 return True

411

412 - def containerelements(self):

413 yield ('speeddials', self.__field_speeddials, None)

414 415 416 417

418 -class pbreadentryresponse(BaseProtogenClass):

419 "Results of reading one entry" 420 __fields=['header', 'entry'] 421

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

423 dict={} 424 # What was supplied to this function 425 dict.update(kwargs) 426 # Parent constructor 427 super(pbreadentryresponse,self).__init__(**dict) 428 if self.__class__ is pbreadentryresponse: 429 self._update(args,dict)

430 431

432 - def getfields(self):

433 return self.__fields

434 435

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

437 super(pbreadentryresponse,self)._update(args,kwargs) 438 keys=kwargs.keys() 439 for key in keys: 440 if key in self.__fields: 441 setattr(self, key, kwargs[key]) 442 del kwargs[key] 443 # Were any unrecognized kwargs passed in? 444 if __debug__: 445 self._complainaboutunusedargs(pbreadentryresponse,kwargs) 446 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)

447 # Make all P fields that haven't already been constructed 448 449

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

451 'Writes this packet to the supplied buffer' 452 self._bufferstartoffset=buf.getcurrentoffset() 453 self.__field_header.writetobuffer(buf) 454 self.__field_entry.writetobuffer(buf) 455 self._bufferendoffset=buf.getcurrentoffset() 456 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)

457 458

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

460 'Reads this packet from the supplied buffer' 461 self._bufferstartoffset=buf.getcurrentoffset() 462 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 463 self.__field_header=pbheader() 464 self.__field_header.readfrombuffer(buf) 465 self.__field_entry=pbentry() 466 self.__field_entry.readfrombuffer(buf) 467 self._bufferendoffset=buf.getcurrentoffset()

468 469

470 - def __getfield_header(self):

471 return self.__field_header.getvalue()

472

473 - def __setfield_header(self, value):

474 if isinstance(value,pbheader): 475 self.__field_header=value 476 else: 477 self.__field_header=pbheader(value,)

478

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

480 481 header=property(__getfield_header, __setfield_header, __delfield_header, None) 482

483 - def __getfield_entry(self):

484 return self.__field_entry.getvalue()

485

486 - def __setfield_entry(self, value):

487 if isinstance(value,pbentry): 488 self.__field_entry=value 489 else: 490 self.__field_entry=pbentry(value,)

491

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

493 494 entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None) 495

496 - def iscontainer(self):

497 return True

498

499 - def containerelements(self):

500 yield ('header', self.__field_header, None) 501 yield ('entry', self.__field_entry, None)

502 503 504 505

506 -class pbupdateentryrequest(BaseProtogenClass):

507 __fields=['header', 'entry'] 508

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

510 dict={} 511 # What was supplied to this function 512 dict.update(kwargs) 513 # Parent constructor 514 super(pbupdateentryrequest,self).__init__(**dict) 515 if self.__class__ is pbupdateentryrequest: 516 self._update(args,dict)

517 518

519 - def getfields(self):

520 return self.__fields

521 522

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

524 super(pbupdateentryrequest,self)._update(args,kwargs) 525 keys=kwargs.keys() 526 for key in keys: 527 if key in self.__fields: 528 setattr(self, key, kwargs[key]) 529 del kwargs[key] 530 # Were any unrecognized kwargs passed in? 531 if __debug__: 532 self._complainaboutunusedargs(pbupdateentryrequest,kwargs) 533 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)

534 # Make all P fields that haven't already been constructed 535 536

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

538 'Writes this packet to the supplied buffer' 539 self._bufferstartoffset=buf.getcurrentoffset() 540 try: self.__field_header 541 except: 542 self.__field_header=pbheader(**{'command': 0x04, 'flag': 0x01}) 543 self.__field_header.writetobuffer(buf) 544 self.__field_entry.writetobuffer(buf) 545 self._bufferendoffset=buf.getcurrentoffset() 546 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)

547 548

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

550 'Reads this packet from the supplied buffer' 551 self._bufferstartoffset=buf.getcurrentoffset() 552 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 553 self.__field_header=pbheader(**{'command': 0x04, 'flag': 0x01}) 554 self.__field_header.readfrombuffer(buf) 555 self.__field_entry=pbentry() 556 self.__field_entry.readfrombuffer(buf) 557 self._bufferendoffset=buf.getcurrentoffset()

558 559

560 - def __getfield_header(self):

561 try: self.__field_header 562 except: 563 self.__field_header=pbheader(**{'command': 0x04, 'flag': 0x01}) 564 return self.__field_header.getvalue()

565

566 - def __setfield_header(self, value):

567 if isinstance(value,pbheader): 568 self.__field_header=value 569 else: 570 self.__field_header=pbheader(value,**{'command': 0x04, 'flag': 0x01})

571

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

573 574 header=property(__getfield_header, __setfield_header, __delfield_header, None) 575

576 - def __getfield_entry(self):

577 return self.__field_entry.getvalue()

578

579 - def __setfield_entry(self, value):

580 if isinstance(value,pbentry): 581 self.__field_entry=value 582 else: 583 self.__field_entry=pbentry(value,)

584

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

586 587 entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None) 588

589 - def iscontainer(self):

590 return True

591

592 - def containerelements(self):

593 yield ('header', self.__field_header, None) 594 yield ('entry', self.__field_entry, None)

595 596 597 598

599 -class pbappendentryrequest(BaseProtogenClass):

600 __fields=['header', 'entry'] 601

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

603 dict={} 604 # What was supplied to this function 605 dict.update(kwargs) 606 # Parent constructor 607 super(pbappendentryrequest,self).__init__(**dict) 608 if self.__class__ is pbappendentryrequest: 609 self._update(args,dict)

610 611

612 - def getfields(self):

613 return self.__fields

614 615

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

617 super(pbappendentryrequest,self)._update(args,kwargs) 618 keys=kwargs.keys() 619 for key in keys: 620 if key in self.__fields: 621 setattr(self, key, kwargs[key]) 622 del kwargs[key] 623 # Were any unrecognized kwargs passed in? 624 if __debug__: 625 self._complainaboutunusedargs(pbappendentryrequest,kwargs) 626 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)

627 # Make all P fields that haven't already been constructed 628 629

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

631 'Writes this packet to the supplied buffer' 632 self._bufferstartoffset=buf.getcurrentoffset() 633 try: self.__field_header 634 except: 635 self.__field_header=pbheader(**{'command': 0x03, 'flag': 0x01}) 636 self.__field_header.writetobuffer(buf) 637 self.__field_entry.writetobuffer(buf) 638 self._bufferendoffset=buf.getcurrentoffset() 639 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)

640 641

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

643 'Reads this packet from the supplied buffer' 644 self._bufferstartoffset=buf.getcurrentoffset() 645 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 646 self.__field_header=pbheader(**{'command': 0x03, 'flag': 0x01}) 647 self.__field_header.readfrombuffer(buf) 648 self.__field_entry=pbentry() 649 self.__field_entry.readfrombuffer(buf) 650 self._bufferendoffset=buf.getcurrentoffset()

651 652

653 - def __getfield_header(self):

654 try: self.__field_header 655 except: 656 self.__field_header=pbheader(**{'command': 0x03, 'flag': 0x01}) 657 return self.__field_header.getvalue()

658

659 - def __setfield_header(self, value):

660 if isinstance(value,pbheader): 661 self.__field_header=value 662 else: 663 self.__field_header=pbheader(value,**{'command': 0x03, 'flag': 0x01})

664

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

666 667 header=property(__getfield_header, __setfield_header, __delfield_header, None) 668

669 - def __getfield_entry(self):

670 return self.__field_entry.getvalue()

671

672 - def __setfield_entry(self, value):

673 if isinstance(value,pbentry): 674 self.__field_entry=value 675 else: 676 self.__field_entry=pbentry(value,)

677

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

679 680 entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None) 681

682 - def iscontainer(self):

683 return True

684

685 - def containerelements(self):

686 yield ('header', self.__field_header, None) 687 yield ('entry', self.__field_entry, None)

688 689 690 691

692 -class pbentry(BaseProtogenClass):

693 __fields=['wallpaper', 'serial1', 'entrysize', 'serial2', 'entrynumber', 'name', 'group', 'emails', 'url', 'ringtone', 'secret', 'memo', 'dunno1', 'dunno2', 'numbertypes', 'numbers'] 694

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

696 dict={} 697 # What was supplied to this function 698 dict.update(kwargs) 699 # Parent constructor 700 super(pbentry,self).__init__(**dict) 701 if self.__class__ is pbentry: 702 self._update(args,dict)

703 704

705 - def getfields(self):

706 return self.__fields

707 708

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

710 super(pbentry,self)._update(args,kwargs) 711 keys=kwargs.keys() 712 for key in keys: 713 if key in self.__fields: 714 setattr(self, key, kwargs[key]) 715 del kwargs[key] 716 # Were any unrecognized kwargs passed in? 717 if __debug__: 718 self._complainaboutunusedargs(pbentry,kwargs) 719 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 720 # Make all P fields that haven't already been constructed 721 try: self.__field_wallpaper 722 except: 723 self.__field_wallpaper=UINT(**{'constant': NOWALLPAPER})

724 725

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

727 'Writes this packet to the supplied buffer' 728 self._bufferstartoffset=buf.getcurrentoffset() 729 self.__field_serial1.writetobuffer(buf) 730 try: self.__field_entrysize 731 except: 732 self.__field_entrysize=UINT(**{'sizeinbytes': 2, 'constant': 0x01E0}) 733 self.__field_entrysize.writetobuffer(buf) 734 self.__field_serial2.writetobuffer(buf) 735 self.__field_entrynumber.writetobuffer(buf) 736 self.__field_name.writetobuffer(buf) 737 self.__field_group.writetobuffer(buf) 738 try: self.__field_emails 739 except: 740 self.__field_emails=LIST(**{'elementclass': _gen_p_lgvi5225_116, 'length': NUMEMAILS}) 741 self.__field_emails.writetobuffer(buf) 742 self.__field_url.writetobuffer(buf) 743 self.__field_ringtone.writetobuffer(buf) 744 self.__field_secret.writetobuffer(buf) 745 self.__field_memo.writetobuffer(buf) 746 try: self.__field_dunno1 747 except: 748 self.__field_dunno1=UINT(**{'sizeinbytes': 1, 'default': 0}) 749 self.__field_dunno1.writetobuffer(buf) 750 try: self.__field_dunno2 751 except: 752 self.__field_dunno2=UINT(**{'sizeinbytes': 2, 'default': 0}) 753 self.__field_dunno2.writetobuffer(buf) 754 try: self.__field_numbertypes 755 except: 756 self.__field_numbertypes=LIST(**{'elementclass': _gen_p_lgvi5225_124, 'length': NUMPHONENUMBERS}) 757 self.__field_numbertypes.writetobuffer(buf) 758 try: self.__field_numbers 759 except: 760 self.__field_numbers=LIST(**{'elementclass': _gen_p_lgvi5225_126, 'length': NUMPHONENUMBERS}) 761 self.__field_numbers.writetobuffer(buf) 762 self._bufferendoffset=buf.getcurrentoffset() 763 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)

764 765

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

767 'Reads this packet from the supplied buffer' 768 self._bufferstartoffset=buf.getcurrentoffset() 769 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 770 self.__field_serial1=UINT(**{'sizeinbytes': 4}) 771 self.__field_serial1.readfrombuffer(buf) 772 self.__field_entrysize=UINT(**{'sizeinbytes': 2, 'constant': 0x01E0}) 773 self.__field_entrysize.readfrombuffer(buf) 774 self.__field_serial2=UINT(**{'sizeinbytes': 4}) 775 self.__field_serial2.readfrombuffer(buf) 776 self.__field_entrynumber=UINT(**{'sizeinbytes': 2}) 777 self.__field_entrynumber.readfrombuffer(buf) 778 self.__field_name=USTRING(**{'sizeinbytes': 23, 'raiseonunterminatedread': False}) 779 self.__field_name.readfrombuffer(buf) 780 self.__field_group=UINT(**{'sizeinbytes': 2}) 781 self.__field_group.readfrombuffer(buf) 782 self.__field_emails=LIST(**{'elementclass': _gen_p_lgvi5225_116, 'length': NUMEMAILS}) 783 self.__field_emails.readfrombuffer(buf) 784 self.__field_url=USTRING(**{'sizeinbytes': 73, 'raiseonunterminatedread': False}) 785 self.__field_url.readfrombuffer(buf) 786 self.__field_ringtone=UINT(**{'sizeinbytes': 1}) 787 self.__field_ringtone.readfrombuffer(buf) 788 self.__field_secret=UINT(**{'sizeinbytes': 1}) 789 self.__field_secret.readfrombuffer(buf) 790 self.__field_memo=USTRING(**{'raiseonunterminatedread': False, 'sizeinbytes': MEMOLENGTH}) 791 self.__field_memo.readfrombuffer(buf) 792 self.__field_dunno1=UINT(**{'sizeinbytes': 1, 'default': 0}) 793 self.__field_dunno1.readfrombuffer(buf) 794 self.__field_dunno2=UINT(**{'sizeinbytes': 2, 'default': 0}) 795 self.__field_dunno2.readfrombuffer(buf) 796 self.__field_numbertypes=LIST(**{'elementclass': _gen_p_lgvi5225_124, 'length': NUMPHONENUMBERS}) 797 self.__field_numbertypes.readfrombuffer(buf) 798 self.__field_numbers=LIST(**{'elementclass': _gen_p_lgvi5225_126, 'length': NUMPHONENUMBERS}) 799 self.__field_numbers.readfrombuffer(buf) 800 self._bufferendoffset=buf.getcurrentoffset()

801 802

803 - def __getfield_wallpaper(self):

804 return self.__field_wallpaper.getvalue()

805

806 - def __setfield_wallpaper(self, value):

807 if isinstance(value,UINT): 808 self.__field_wallpaper=value 809 else: 810 self.__field_wallpaper=UINT(value,**{'constant': NOWALLPAPER})

811

812 - def __delfield_wallpaper(self): del self.__field_wallpaper

813 814 wallpaper=property(__getfield_wallpaper, __setfield_wallpaper, __delfield_wallpaper, None) 815

816 - def __getfield_serial1(self):

817 return self.__field_serial1.getvalue()

818

819 - def __setfield_serial1(self, value):

820 if isinstance(value,UINT): 821 self.__field_serial1=value 822 else: 823 self.__field_serial1=UINT(value,**{'sizeinbytes': 4})

824

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

826 827 serial1=property(__getfield_serial1, __setfield_serial1, __delfield_serial1, None) 828

829 - def __getfield_entrysize(self):

830 try: self.__field_entrysize 831 except: 832 self.__field_entrysize=UINT(**{'sizeinbytes': 2, 'constant': 0x01E0}) 833 return self.__field_entrysize.getvalue()

834

835 - def __setfield_entrysize(self, value):

836 if isinstance(value,UINT): 837 self.__field_entrysize=value 838 else: 839 self.__field_entrysize=UINT(value,**{'sizeinbytes': 2, 'constant': 0x01E0})

840

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

842 843 entrysize=property(__getfield_entrysize, __setfield_entrysize, __delfield_entrysize, None) 844

845 - def __getfield_serial2(self):

846 return self.__field_serial2.getvalue()

847

848 - def __setfield_serial2(self, value):

849 if isinstance(value,UINT): 850 self.__field_serial2=value 851 else: 852 self.__field_serial2=UINT(value,**{'sizeinbytes': 4})

853

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

855 856 serial2=property(__getfield_serial2, __setfield_serial2, __delfield_serial2, None) 857

858 - def __getfield_entrynumber(self):

859 return self.__field_entrynumber.getvalue()

860

861 - def __setfield_entrynumber(self, value):

862 if isinstance(value,UINT): 863 self.__field_entrynumber=value 864 else: 865 self.__field_entrynumber=UINT(value,**{'sizeinbytes': 2})

866

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

868 869 entrynumber=property(__getfield_entrynumber, __setfield_entrynumber, __delfield_entrynumber, None) 870

871 - def __getfield_name(self):

872 return self.__field_name.getvalue()

873

874 - def __setfield_name(self, value):

875 if isinstance(value,USTRING): 876 self.__field_name=value 877 else: 878 self.__field_name=USTRING(value,**{'sizeinbytes': 23, 'raiseonunterminatedread': False})

879

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

881 882 name=property(__getfield_name, __setfield_name, __delfield_name, None) 883

884 - def __getfield_group(self):

885 return self.__field_group.getvalue()

886

887 - def __setfield_group(self, value):

888 if isinstance(value,UINT): 889 self.__field_group=value 890 else: 891 self.__field_group=UINT(value,**{'sizeinbytes': 2})

892

893 - def __delfield_group(self): del self.__field_group

894 895 group=property(__getfield_group, __setfield_group, __delfield_group, None) 896

897 - def __getfield_emails(self):

898 try: self.__field_emails 899 except: 900 self.__field_emails=LIST(**{'elementclass': _gen_p_lgvi5225_116, 'length': NUMEMAILS}) 901 return self.__field_emails.getvalue()

902

903 - def __setfield_emails(self, value):

904 if isinstance(value,LIST): 905 self.__field_emails=value 906 else: 907 self.__field_emails=LIST(value,**{'elementclass': _gen_p_lgvi5225_116, 'length': NUMEMAILS})

908

909 - def __delfield_emails(self): del self.__field_emails

910 911 emails=property(__getfield_emails, __setfield_emails, __delfield_emails, None) 912

913 - def __getfield_url(self):

914 return self.__field_url.getvalue()

915

916 - def __setfield_url(self, value):

917 if isinstance(value,USTRING): 918 self.__field_url=value 919 else: 920 self.__field_url=USTRING(value,**{'sizeinbytes': 73, 'raiseonunterminatedread': False})

921

922 - def __delfield_url(self): del self.__field_url

923 924 url=property(__getfield_url, __setfield_url, __delfield_url, None) 925

926 - def __getfield_ringtone(self):

927 return self.__field_ringtone.getvalue()

928

929 - def __setfield_ringtone(self, value):

930 if isinstance(value,UINT): 931 self.__field_ringtone=value 932 else: 933 self.__field_ringtone=UINT(value,**{'sizeinbytes': 1})

934

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

936 937 ringtone=property(__getfield_ringtone, __setfield_ringtone, __delfield_ringtone, "ringtone index for a call") 938

939 - def __getfield_secret(self):

940 return self.__field_secret.getvalue()

941

942 - def __setfield_secret(self, value):

943 if isinstance(value,UINT): 944 self.__field_secret=value 945 else: 946 self.__field_secret=UINT(value,**{'sizeinbytes': 1})

947

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

949 950 secret=property(__getfield_secret, __setfield_secret, __delfield_secret, None) 951

952 - def __getfield_memo(self):

953 return self.__field_memo.getvalue()

954

955 - def __setfield_memo(self, value):

956 if isinstance(value,USTRING): 957 self.__field_memo=value 958 else: 959 self.__field_memo=USTRING(value,**{'raiseonunterminatedread': False, 'sizeinbytes': MEMOLENGTH})

960

961 - def __delfield_memo(self): del self.__field_memo

962 963 memo=property(__getfield_memo, __setfield_memo, __delfield_memo, None) 964

965 - def __getfield_dunno1(self):

966 try: self.__field_dunno1 967 except: 968 self.__field_dunno1=UINT(**{'sizeinbytes': 1, 'default': 0}) 969 return self.__field_dunno1.getvalue()

970

971 - def __setfield_dunno1(self, value):

972 if isinstance(value,UINT): 973 self.__field_dunno1=value 974 else: 975 self.__field_dunno1=UINT(value,**{'sizeinbytes': 1, 'default': 0})

976

977 - def __delfield_dunno1(self): del self.__field_dunno1

978 979 dunno1=property(__getfield_dunno1, __setfield_dunno1, __delfield_dunno1, None) 980

981 - def __getfield_dunno2(self):

982 try: self.__field_dunno2 983 except: 984 self.__field_dunno2=UINT(**{'sizeinbytes': 2, 'default': 0}) 985 return self.__field_dunno2.getvalue()

986

987 - def __setfield_dunno2(self, value):

988 if isinstance(value,UINT): 989 self.__field_dunno2=value 990 else: 991 self.__field_dunno2=UINT(value,**{'sizeinbytes': 2, 'default': 0})

992

993 - def __delfield_dunno2(self): del self.__field_dunno2

994 995 dunno2=property(__getfield_dunno2, __setfield_dunno2, __delfield_dunno2, None) 996

997 - def __getfield_numbertypes(self):

998 try: self.__field_numbertypes 999 except: 1000 self.__field_numbertypes=LIST(**{'elementclass': _gen_p_lgvi5225_124, 'length': NUMPHONENUMBERS}) 1001 return self.__field_numbertypes.getvalue()

1002

1003 - def __setfield_numbertypes(self, value):

1004 if isinstance(value,LIST): 1005 self.__field_numbertypes=value 1006 else: 1007 self.__field_numbertypes=LIST(value,**{'elementclass': _gen_p_lgvi5225_124, 'length': NUMPHONENUMBERS})

1008

1009 - def __delfield_numbertypes(self): del self.__field_numbertypes

1010 1011 numbertypes=property(__getfield_numbertypes, __setfield_numbertypes, __delfield_numbertypes, None) 1012

1013 - def __getfield_numbers(self):

1014 try: self.__field_numbers 1015 except: 1016 self.__field_numbers=LIST(**{'elementclass': _gen_p_lgvi5225_126, 'length': NUMPHONENUMBERS}) 1017 return self.__field_numbers.getvalue()

1018

1019 - def __setfield_numbers(self, value):

1020 if isinstance(value,LIST): 1021 self.__field_numbers=value 1022 else: 1023 self.__field_numbers=LIST(value,**{'elementclass': _gen_p_lgvi5225_126, 'length': NUMPHONENUMBERS})

1024

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

1026 1027 numbers=property(__getfield_numbers, __setfield_numbers, __delfield_numbers, None) 1028

1029 - def iscontainer(self):

1030 return True

1031

1032 - def containerelements(self):

1033 yield ('wallpaper', self.__field_wallpaper, None) 1034 yield ('serial1', self.__field_serial1, None) 1035 yield ('entrysize', self.__field_entrysize, None) 1036 yield ('serial2', self.__field_serial2, None) 1037 yield ('entrynumber', self.__field_entrynumber, None) 1038 yield ('name', self.__field_name, None) 1039 yield ('group', self.__field_group, None) 1040 yield ('emails', self.__field_emails, None) 1041 yield ('url', self.__field_url, None) 1042 yield ('ringtone', self.__field_ringtone, "ringtone index for a call") 1043 yield ('secret', self.__field_secret, None) 1044 yield ('memo', self.__field_memo, None) 1045 yield ('dunno1', self.__field_dunno1, None) 1046 yield ('dunno2', self.__field_dunno2, None) 1047 yield ('numbertypes', self.__field_numbertypes, None) 1048 yield ('numbers', self.__field_numbers, None)

1049 1050 1051 1052

1053 -class _gen_p_lgvi5225_116(BaseProtogenClass):

1054 'Anonymous inner class' 1055 __fields=['email'] 1056

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

1058 dict={} 1059 # What was supplied to this function 1060 dict.update(kwargs) 1061 # Parent constructor 1062 super(_gen_p_lgvi5225_116,self).__init__(**dict) 1063 if self.__class__ is _gen_p_lgvi5225_116: 1064 self._update(args,dict)

1065 1066

1067 - def getfields(self):

1068 return self.__fields

1069 1070

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

1072 super(_gen_p_lgvi5225_116,self)._update(args,kwargs) 1073 keys=kwargs.keys() 1074 for key in keys: 1075 if key in self.__fields: 1076 setattr(self, key, kwargs[key]) 1077 del kwargs[key] 1078 # Were any unrecognized kwargs passed in? 1079 if __debug__: 1080 self._complainaboutunusedargs(_gen_p_lgvi5225_116,kwargs) 1081 if len(args): 1082 dict2={'sizeinbytes': 73, 'raiseonunterminatedread': False} 1083 dict2.update(kwargs) 1084 kwargs=dict2 1085 self.__field_email=USTRING(*args,**dict2)

1086 # Make all P fields that haven't already been constructed 1087 1088

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

1090 'Writes this packet to the supplied buffer' 1091 self._bufferstartoffset=buf.getcurrentoffset() 1092 self.__field_email.writetobuffer(buf) 1093 self._bufferendoffset=buf.getcurrentoffset() 1094 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)

1095 1096

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

1098 'Reads this packet from the supplied buffer' 1099 self._bufferstartoffset=buf.getcurrentoffset() 1100 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 1101 self.__field_email=USTRING(**{'sizeinbytes': 73, 'raiseonunterminatedread': False}) 1102 self.__field_email.readfrombuffer(buf) 1103 self._bufferendoffset=buf.getcurrentoffset()

1104 1105

1106 - def __getfield_email(self):

1107 return self.__field_email.getvalue()

1108

1109 - def __setfield_email(self, value):

1110 if isinstance(value,USTRING): 1111 self.__field_email=value 1112 else: 1113 self.__field_email=USTRING(value,**{'sizeinbytes': 73, 'raiseonunterminatedread': False})

1114

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

1116 1117 email=property(__getfield_email, __setfield_email, __delfield_email, None) 1118

1119 - def iscontainer(self):

1120 return True

1121

1122 - def containerelements(self):

1123 yield ('email', self.__field_email, None)

1124 1125 1126 1127

1128 -class _gen_p_lgvi5225_124(BaseProtogenClass):

1129 'Anonymous inner class' 1130 __fields=['numbertype'] 1131

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

1133 dict={} 1134 # What was supplied to this function 1135 dict.update(kwargs) 1136 # Parent constructor 1137 super(_gen_p_lgvi5225_124,self).__init__(**dict) 1138 if self.__class__ is _gen_p_lgvi5225_124: 1139 self._update(args,dict)

1140 1141

1142 - def getfields(self):

1143 return self.__fields

1144 1145

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

1147 super(_gen_p_lgvi5225_124,self)._update(args,kwargs) 1148 keys=kwargs.keys() 1149 for key in keys: 1150 if key in self.__fields: 1151 setattr(self, key, kwargs[key]) 1152 del kwargs[key] 1153 # Were any unrecognized kwargs passed in? 1154 if __debug__: 1155 self._complainaboutunusedargs(_gen_p_lgvi5225_124,kwargs) 1156 if len(args): 1157 dict2={'sizeinbytes': 1} 1158 dict2.update(kwargs) 1159 kwargs=dict2 1160 self.__field_numbertype=UINT(*args,**dict2)

1161 # Make all P fields that haven't already been constructed 1162 1163

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

1165 'Writes this packet to the supplied buffer' 1166 self._bufferstartoffset=buf.getcurrentoffset() 1167 self.__field_numbertype.writetobuffer(buf) 1168 self._bufferendoffset=buf.getcurrentoffset() 1169 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)

1170 1171

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

1173 'Reads this packet from the supplied buffer' 1174 self._bufferstartoffset=buf.getcurrentoffset() 1175 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 1176 self.__field_numbertype=UINT(**{'sizeinbytes': 1}) 1177 self.__field_numbertype.readfrombuffer(buf) 1178 self._bufferendoffset=buf.getcurrentoffset()

1179 1180

1181 - def __getfield_numbertype(self):

1182 return self.__field_numbertype.getvalue()

1183

1184 - def __setfield_numbertype(self, value):

1185 if isinstance(value,UINT): 1186 self.__field_numbertype=value 1187 else: 1188 self.__field_numbertype=UINT(value,**{'sizeinbytes': 1})

1189

1190 - def __delfield_numbertype(self): del self.__field_numbertype

1191 1192 numbertype=property(__getfield_numbertype, __setfield_numbertype, __delfield_numbertype, None) 1193

1194 - def iscontainer(self):

1195 return True

1196

1197 - def containerelements(self):

1198 yield ('numbertype', self.__field_numbertype, None)

1199 1200 1201 1202

1203 -class _gen_p_lgvi5225_126(BaseProtogenClass):

1204 'Anonymous inner class' 1205 __fields=['number'] 1206

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

1208 dict={} 1209 # What was supplied to this function 1210 dict.update(kwargs) 1211 # Parent constructor 1212 super(_gen_p_lgvi5225_126,self).__init__(**dict) 1213 if self.__class__ is _gen_p_lgvi5225_126: 1214 self._update(args,dict)

1215 1216

1217 - def getfields(self):

1218 return self.__fields

1219 1220

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

1222 super(_gen_p_lgvi5225_126,self)._update(args,kwargs) 1223 keys=kwargs.keys() 1224 for key in keys: 1225 if key in self.__fields: 1226 setattr(self, key, kwargs[key]) 1227 del kwargs[key] 1228 # Were any unrecognized kwargs passed in? 1229 if __debug__: 1230 self._complainaboutunusedargs(_gen_p_lgvi5225_126,kwargs) 1231 if len(args): 1232 dict2={'sizeinbytes': 49, 'raiseonunterminatedread': False} 1233 dict2.update(kwargs) 1234 kwargs=dict2 1235 self.__field_number=USTRING(*args,**dict2)

1236 # Make all P fields that haven't already been constructed 1237 1238

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

1240 'Writes this packet to the supplied buffer' 1241 self._bufferstartoffset=buf.getcurrentoffset() 1242 self.__field_number.writetobuffer(buf) 1243 self._bufferendoffset=buf.getcurrentoffset() 1244 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)

1245 1246

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

1248 'Reads this packet from the supplied buffer' 1249 self._bufferstartoffset=buf.getcurrentoffset() 1250 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 1251 self.__field_number=USTRING(**{'sizeinbytes': 49, 'raiseonunterminatedread': False}) 1252 self.__field_number.readfrombuffer(buf) 1253 self._bufferendoffset=buf.getcurrentoffset()

1254 1255

1256 - def __getfield_number(self):

1257 return self.__field_number.getvalue()

1258

1259 - def __setfield_number(self, value):

1260 if isinstance(value,USTRING): 1261 self.__field_number=value 1262 else: 1263 self.__field_number=USTRING(value,**{'sizeinbytes': 49, 'raiseonunterminatedread': False})

1264

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

1266 1267 number=property(__getfield_number, __setfield_number, __delfield_number, None) 1268

1269 - def iscontainer(self):

1270 return True

1271

1272 - def containerelements(self):

1273 yield ('number', self.__field_number, None)

1274

Source Code for Module phones.p_lgvi5225