phones.p_lgvx9200

1 # THIS FILE IS AUTOMATICALLY GENERATED. EDIT THE SOURCE FILE NOT THIS ONE 2 3 """Various descriptions of data specific to LG VX9200""" 4 5 # groups - same as VX-8700 6 # phonebook - LG Phonebook v1.0 Extended (same as VX-11K) 7 # schedule - same as VX-8550 8 # memos - same as VX-8550 9 # sms - same as VX-9100 10 # index file - same as VX-9700 11 from p_lgvx11000 import * 12 13 # SMS index files 14 inbox_index = "dload/inbox.dat" 15 outbox_index = "dload/outbox.dat" 16 drafts_index = "dload/drafts.dat" 17

18 -class call(BaseProtogenClass):

19 __fields=['GPStime', 'unk0', 'duration', 'number', 'name', 'numberlength', 'status', 'pbnumbertype', 'unk1', 'pbentrynum', 'number_location'] 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(call,self).__init__(**dict) 27 if self.__class__ is call: 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(call,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(call,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_GPStime.writetobuffer(buf) 53 self.__field_unk0.writetobuffer(buf) 54 self.__field_duration.writetobuffer(buf) 55 self.__field_number.writetobuffer(buf) 56 self.__field_name.writetobuffer(buf) 57 self.__field_numberlength.writetobuffer(buf) 58 self.__field_status.writetobuffer(buf) 59 self.__field_pbnumbertype.writetobuffer(buf) 60 self.__field_unk1.writetobuffer(buf) 61 self.__field_pbentrynum.writetobuffer(buf) 62 self.__field_number_location.writetobuffer(buf) 63 self._bufferendoffset=buf.getcurrentoffset() 64 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)

65 66

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

68 'Reads this packet from the supplied buffer' 69 self._bufferstartoffset=buf.getcurrentoffset() 70 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 71 self.__field_GPStime=GPSDATE(**{'sizeinbytes': 4}) 72 self.__field_GPStime.readfrombuffer(buf) 73 self.__field_unk0=UINT(**{'sizeinbytes': 4}) 74 self.__field_unk0.readfrombuffer(buf) 75 self.__field_duration=UINT(**{'sizeinbytes': 4}) 76 self.__field_duration.readfrombuffer(buf) 77 self.__field_number=USTRING(**{'sizeinbytes': 49, 'raiseonunterminatedread': False}) 78 self.__field_number.readfrombuffer(buf) 79 self.__field_name=USTRING(**{'sizeinbytes': 36, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False}) 80 self.__field_name.readfrombuffer(buf) 81 self.__field_numberlength=UINT(**{'sizeinbytes': 1}) 82 self.__field_numberlength.readfrombuffer(buf) 83 self.__field_status=UINT(**{'sizeinbytes': 1}) 84 self.__field_status.readfrombuffer(buf) 85 self.__field_pbnumbertype=UINT(**{'sizeinbytes': 1}) 86 self.__field_pbnumbertype.readfrombuffer(buf) 87 self.__field_unk1=UINT(**{'sizeinbytes': 4}) 88 self.__field_unk1.readfrombuffer(buf) 89 self.__field_pbentrynum=UINT(**{'sizeinbytes': 2}) 90 self.__field_pbentrynum.readfrombuffer(buf) 91 self.__field_number_location=DATA(**{'sizeinbytes': 75}) 92 self.__field_number_location.readfrombuffer(buf) 93 self._bufferendoffset=buf.getcurrentoffset()

94 95

96 - def __getfield_GPStime(self):

97 return self.__field_GPStime.getvalue()

98

99 - def __setfield_GPStime(self, value):

100 if isinstance(value,GPSDATE): 101 self.__field_GPStime=value 102 else: 103 self.__field_GPStime=GPSDATE(value,**{'sizeinbytes': 4})

104

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

106 107 GPStime=property(__getfield_GPStime, __setfield_GPStime, __delfield_GPStime, None) 108

109 - def __getfield_unk0(self):

110 return self.__field_unk0.getvalue()

111

112 - def __setfield_unk0(self, value):

113 if isinstance(value,UINT): 114 self.__field_unk0=value 115 else: 116 self.__field_unk0=UINT(value,**{'sizeinbytes': 4})

117

118 - def __delfield_unk0(self): del self.__field_unk0

119 120 unk0=property(__getfield_unk0, __setfield_unk0, __delfield_unk0, None) 121

122 - def __getfield_duration(self):

123 return self.__field_duration.getvalue()

124

125 - def __setfield_duration(self, value):

126 if isinstance(value,UINT): 127 self.__field_duration=value 128 else: 129 self.__field_duration=UINT(value,**{'sizeinbytes': 4})

130

131 - def __delfield_duration(self): del self.__field_duration

132 133 duration=property(__getfield_duration, __setfield_duration, __delfield_duration, None) 134

135 - def __getfield_number(self):

136 return self.__field_number.getvalue()

137

138 - def __setfield_number(self, value):

139 if isinstance(value,USTRING): 140 self.__field_number=value 141 else: 142 self.__field_number=USTRING(value,**{'sizeinbytes': 49, 'raiseonunterminatedread': False})

143

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

145 146 number=property(__getfield_number, __setfield_number, __delfield_number, None) 147

148 - def __getfield_name(self):

149 return self.__field_name.getvalue()

150

151 - def __setfield_name(self, value):

152 if isinstance(value,USTRING): 153 self.__field_name=value 154 else: 155 self.__field_name=USTRING(value,**{'sizeinbytes': 36, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False})

156

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

158 159 name=property(__getfield_name, __setfield_name, __delfield_name, None) 160

161 - def __getfield_numberlength(self):

162 return self.__field_numberlength.getvalue()

163

164 - def __setfield_numberlength(self, value):

165 if isinstance(value,UINT): 166 self.__field_numberlength=value 167 else: 168 self.__field_numberlength=UINT(value,**{'sizeinbytes': 1})

169

170 - def __delfield_numberlength(self): del self.__field_numberlength

171 172 numberlength=property(__getfield_numberlength, __setfield_numberlength, __delfield_numberlength, None) 173

174 - def __getfield_status(self):

175 return self.__field_status.getvalue()

176

177 - def __setfield_status(self, value):

178 if isinstance(value,UINT): 179 self.__field_status=value 180 else: 181 self.__field_status=UINT(value,**{'sizeinbytes': 1})

182

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

184 185 status=property(__getfield_status, __setfield_status, __delfield_status, None) 186

187 - def __getfield_pbnumbertype(self):

188 return self.__field_pbnumbertype.getvalue()

189

190 - def __setfield_pbnumbertype(self, value):

191 if isinstance(value,UINT): 192 self.__field_pbnumbertype=value 193 else: 194 self.__field_pbnumbertype=UINT(value,**{'sizeinbytes': 1})

195

196 - def __delfield_pbnumbertype(self): del self.__field_pbnumbertype

197 198 pbnumbertype=property(__getfield_pbnumbertype, __setfield_pbnumbertype, __delfield_pbnumbertype, None) 199

200 - def __getfield_unk1(self):

201 return self.__field_unk1.getvalue()

202

203 - def __setfield_unk1(self, value):

204 if isinstance(value,UINT): 205 self.__field_unk1=value 206 else: 207 self.__field_unk1=UINT(value,**{'sizeinbytes': 4})

208

209 - def __delfield_unk1(self): del self.__field_unk1

210 211 unk1=property(__getfield_unk1, __setfield_unk1, __delfield_unk1, None) 212

213 - def __getfield_pbentrynum(self):

214 return self.__field_pbentrynum.getvalue()

215

216 - def __setfield_pbentrynum(self, value):

217 if isinstance(value,UINT): 218 self.__field_pbentrynum=value 219 else: 220 self.__field_pbentrynum=UINT(value,**{'sizeinbytes': 2})

221

222 - def __delfield_pbentrynum(self): del self.__field_pbentrynum

223 224 pbentrynum=property(__getfield_pbentrynum, __setfield_pbentrynum, __delfield_pbentrynum, None) 225

226 - def __getfield_number_location(self):

227 return self.__field_number_location.getvalue()

228

229 - def __setfield_number_location(self, value):

230 if isinstance(value,DATA): 231 self.__field_number_location=value 232 else: 233 self.__field_number_location=DATA(value,**{'sizeinbytes': 75})

234

235 - def __delfield_number_location(self): del self.__field_number_location

236 237 number_location=property(__getfield_number_location, __setfield_number_location, __delfield_number_location, None) 238

239 - def iscontainer(self):

240 return True

241

242 - def containerelements(self):

243 yield ('GPStime', self.__field_GPStime, None) 244 yield ('unk0', self.__field_unk0, None) 245 yield ('duration', self.__field_duration, None) 246 yield ('number', self.__field_number, None) 247 yield ('name', self.__field_name, None) 248 yield ('numberlength', self.__field_numberlength, None) 249 yield ('status', self.__field_status, None) 250 yield ('pbnumbertype', self.__field_pbnumbertype, None) 251 yield ('unk1', self.__field_unk1, None) 252 yield ('pbentrynum', self.__field_pbentrynum, None) 253 yield ('number_location', self.__field_number_location, None)

254 255 256 257

258 -class callhistory(BaseProtogenClass):

259 __fields=['unk0', 'numcalls', 'unk1', 'calls'] 260

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

262 dict={} 263 # What was supplied to this function 264 dict.update(kwargs) 265 # Parent constructor 266 super(callhistory,self).__init__(**dict) 267 if self.__class__ is callhistory: 268 self._update(args,dict)

269 270

271 - def getfields(self):

272 return self.__fields

273 274

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

276 super(callhistory,self)._update(args,kwargs) 277 keys=kwargs.keys() 278 for key in keys: 279 if key in self.__fields: 280 setattr(self, key, kwargs[key]) 281 del kwargs[key] 282 # Were any unrecognized kwargs passed in? 283 if __debug__: 284 self._complainaboutunusedargs(callhistory,kwargs) 285 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)

286 # Make all P fields that haven't already been constructed 287 288

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

290 'Writes this packet to the supplied buffer' 291 self._bufferstartoffset=buf.getcurrentoffset() 292 self.__field_unk0.writetobuffer(buf) 293 self.__field_numcalls.writetobuffer(buf) 294 self.__field_unk1.writetobuffer(buf) 295 try: self.__field_calls 296 except: 297 self.__field_calls=LIST(**{'elementclass': call, 'length': self.numcalls}) 298 self.__field_calls.writetobuffer(buf) 299 self._bufferendoffset=buf.getcurrentoffset() 300 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)

301 302

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

304 'Reads this packet from the supplied buffer' 305 self._bufferstartoffset=buf.getcurrentoffset() 306 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 307 self.__field_unk0=UINT(**{'sizeinbytes': 4, 'default': 0x00020000 }) 308 self.__field_unk0.readfrombuffer(buf) 309 self.__field_numcalls=UINT(**{'sizeinbytes': 4}) 310 self.__field_numcalls.readfrombuffer(buf) 311 self.__field_unk1=UINT(**{'sizeinbytes': 1}) 312 self.__field_unk1.readfrombuffer(buf) 313 self.__field_calls=LIST(**{'elementclass': call, 'length': self.numcalls}) 314 self.__field_calls.readfrombuffer(buf) 315 self._bufferendoffset=buf.getcurrentoffset()

316 317

318 - def __getfield_unk0(self):

319 return self.__field_unk0.getvalue()

320

321 - def __setfield_unk0(self, value):

322 if isinstance(value,UINT): 323 self.__field_unk0=value 324 else: 325 self.__field_unk0=UINT(value,**{'sizeinbytes': 4, 'default': 0x00020000 })

326

327 - def __delfield_unk0(self): del self.__field_unk0

328 329 unk0=property(__getfield_unk0, __setfield_unk0, __delfield_unk0, None) 330

331 - def __getfield_numcalls(self):

332 return self.__field_numcalls.getvalue()

333

334 - def __setfield_numcalls(self, value):

335 if isinstance(value,UINT): 336 self.__field_numcalls=value 337 else: 338 self.__field_numcalls=UINT(value,**{'sizeinbytes': 4})

339

340 - def __delfield_numcalls(self): del self.__field_numcalls

341 342 numcalls=property(__getfield_numcalls, __setfield_numcalls, __delfield_numcalls, None) 343

344 - def __getfield_unk1(self):

345 return self.__field_unk1.getvalue()

346

347 - def __setfield_unk1(self, value):

348 if isinstance(value,UINT): 349 self.__field_unk1=value 350 else: 351 self.__field_unk1=UINT(value,**{'sizeinbytes': 1})

352

353 - def __delfield_unk1(self): del self.__field_unk1

354 355 unk1=property(__getfield_unk1, __setfield_unk1, __delfield_unk1, None) 356

357 - def __getfield_calls(self):

358 try: self.__field_calls 359 except: 360 self.__field_calls=LIST(**{'elementclass': call, 'length': self.numcalls}) 361 return self.__field_calls.getvalue()

362

363 - def __setfield_calls(self, value):

364 if isinstance(value,LIST): 365 self.__field_calls=value 366 else: 367 self.__field_calls=LIST(value,**{'elementclass': call, 'length': self.numcalls})

368

369 - def __delfield_calls(self): del self.__field_calls

370 371 calls=property(__getfield_calls, __setfield_calls, __delfield_calls, None) 372

373 - def iscontainer(self):

374 return True

375

376 - def containerelements(self):

377 yield ('unk0', self.__field_unk0, None) 378 yield ('numcalls', self.__field_numcalls, None) 379 yield ('unk1', self.__field_unk1, None) 380 yield ('calls', self.__field_calls, None)

381 382 383 384

385 -class indexentry(BaseProtogenClass):

386 __fields=['filename', 'size', 'date', 'type', 'unk0'] 387

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

389 dict={} 390 # What was supplied to this function 391 dict.update(kwargs) 392 # Parent constructor 393 super(indexentry,self).__init__(**dict) 394 if self.__class__ is indexentry: 395 self._update(args,dict)

396 397

398 - def getfields(self):

399 return self.__fields

400 401

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

403 super(indexentry,self)._update(args,kwargs) 404 keys=kwargs.keys() 405 for key in keys: 406 if key in self.__fields: 407 setattr(self, key, kwargs[key]) 408 del kwargs[key] 409 # Were any unrecognized kwargs passed in? 410 if __debug__: 411 self._complainaboutunusedargs(indexentry,kwargs) 412 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)

413 # Make all P fields that haven't already been constructed 414 415

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

417 'Writes this packet to the supplied buffer' 418 self._bufferstartoffset=buf.getcurrentoffset() 419 self.__field_filename.writetobuffer(buf) 420 self.__field_size.writetobuffer(buf) 421 try: self.__field_date 422 except: 423 self.__field_date=UINT(**{'sizeinbytes': 4, 'default': 0}) 424 self.__field_date.writetobuffer(buf) 425 self.__field_type.writetobuffer(buf) 426 try: self.__field_unk0 427 except: 428 self.__field_unk0=UINT(**{'sizeinbytes': 4, 'default': 0}) 429 self.__field_unk0.writetobuffer(buf) 430 self._bufferendoffset=buf.getcurrentoffset() 431 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)

432 433

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

435 'Reads this packet from the supplied buffer' 436 self._bufferstartoffset=buf.getcurrentoffset() 437 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 438 self.__field_filename=USTRING(**{'sizeinbytes': 256, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False, 'raiseontruncate': False }) 439 self.__field_filename.readfrombuffer(buf) 440 self.__field_size=UINT(**{'sizeinbytes': 4}) 441 self.__field_size.readfrombuffer(buf) 442 self.__field_date=UINT(**{'sizeinbytes': 4, 'default': 0}) 443 self.__field_date.readfrombuffer(buf) 444 self.__field_type=UINT(**{'sizeinbytes': 4}) 445 self.__field_type.readfrombuffer(buf) 446 self.__field_unk0=UINT(**{'sizeinbytes': 4, 'default': 0}) 447 self.__field_unk0.readfrombuffer(buf) 448 self._bufferendoffset=buf.getcurrentoffset()

449 450

451 - def __getfield_filename(self):

452 return self.__field_filename.getvalue()

453

454 - def __setfield_filename(self, value):

455 if isinstance(value,USTRING): 456 self.__field_filename=value 457 else: 458 self.__field_filename=USTRING(value,**{'sizeinbytes': 256, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False, 'raiseontruncate': False })

459

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

461 462 filename=property(__getfield_filename, __setfield_filename, __delfield_filename, "full pathname") 463

464 - def __getfield_size(self):

465 return self.__field_size.getvalue()

466

467 - def __setfield_size(self, value):

468 if isinstance(value,UINT): 469 self.__field_size=value 470 else: 471 self.__field_size=UINT(value,**{'sizeinbytes': 4})

472

473 - def __delfield_size(self): del self.__field_size

474 475 size=property(__getfield_size, __setfield_size, __delfield_size, None) 476

477 - def __getfield_date(self):

478 try: self.__field_date 479 except: 480 self.__field_date=UINT(**{'sizeinbytes': 4, 'default': 0}) 481 return self.__field_date.getvalue()

482

483 - def __setfield_date(self, value):

484 if isinstance(value,UINT): 485 self.__field_date=value 486 else: 487 self.__field_date=UINT(value,**{'sizeinbytes': 4, 'default': 0})

488

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

490 491 date=property(__getfield_date, __setfield_date, __delfield_date, None) 492

493 - def __getfield_type(self):

494 return self.__field_type.getvalue()

495

496 - def __setfield_type(self, value):

497 if isinstance(value,UINT): 498 self.__field_type=value 499 else: 500 self.__field_type=UINT(value,**{'sizeinbytes': 4})

501

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

503 504 type=property(__getfield_type, __setfield_type, __delfield_type, None) 505

506 - def __getfield_unk0(self):

507 try: self.__field_unk0 508 except: 509 self.__field_unk0=UINT(**{'sizeinbytes': 4, 'default': 0}) 510 return self.__field_unk0.getvalue()

511

512 - def __setfield_unk0(self, value):

513 if isinstance(value,UINT): 514 self.__field_unk0=value 515 else: 516 self.__field_unk0=UINT(value,**{'sizeinbytes': 4, 'default': 0})

517

518 - def __delfield_unk0(self): del self.__field_unk0

519 520 unk0=property(__getfield_unk0, __setfield_unk0, __delfield_unk0, None) 521

522 - def iscontainer(self):

523 return True

524

525 - def containerelements(self):

526 yield ('filename', self.__field_filename, "full pathname") 527 yield ('size', self.__field_size, None) 528 yield ('date', self.__field_date, None) 529 yield ('type', self.__field_type, None) 530 yield ('unk0', self.__field_unk0, None)

531 532 533 534

535 -class indexfile(BaseProtogenClass):

536 "Used for tracking wallpaper and ringtones" 537 __fields=['items'] 538

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

540 dict={} 541 # What was supplied to this function 542 dict.update(kwargs) 543 # Parent constructor 544 super(indexfile,self).__init__(**dict) 545 if self.__class__ is indexfile: 546 self._update(args,dict)

547 548

549 - def getfields(self):

550 return self.__fields

551 552

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

554 super(indexfile,self)._update(args,kwargs) 555 keys=kwargs.keys() 556 for key in keys: 557 if key in self.__fields: 558 setattr(self, key, kwargs[key]) 559 del kwargs[key] 560 # Were any unrecognized kwargs passed in? 561 if __debug__: 562 self._complainaboutunusedargs(indexfile,kwargs) 563 if len(args): 564 dict2={'elementclass': indexentry, 'createdefault': True} 565 dict2.update(kwargs) 566 kwargs=dict2 567 self.__field_items=LIST(*args,**dict2)

568 # Make all P fields that haven't already been constructed 569 570

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

572 'Writes this packet to the supplied buffer' 573 self._bufferstartoffset=buf.getcurrentoffset() 574 try: self.__field_items 575 except: 576 self.__field_items=LIST(**{'elementclass': indexentry, 'createdefault': True}) 577 self.__field_items.writetobuffer(buf) 578 self._bufferendoffset=buf.getcurrentoffset() 579 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)

580 581

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

583 'Reads this packet from the supplied buffer' 584 self._bufferstartoffset=buf.getcurrentoffset() 585 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 586 self.__field_items=LIST(**{'elementclass': indexentry, 'createdefault': True}) 587 self.__field_items.readfrombuffer(buf) 588 self._bufferendoffset=buf.getcurrentoffset()

589 590

591 - def __getfield_items(self):

592 try: self.__field_items 593 except: 594 self.__field_items=LIST(**{'elementclass': indexentry, 'createdefault': True}) 595 return self.__field_items.getvalue()

596

597 - def __setfield_items(self, value):

598 if isinstance(value,LIST): 599 self.__field_items=value 600 else: 601 self.__field_items=LIST(value,**{'elementclass': indexentry, 'createdefault': True})

602

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

604 605 items=property(__getfield_items, __setfield_items, __delfield_items, None) 606

607 - def iscontainer(self):

608 return True

609

610 - def containerelements(self):

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

612 613 614 615

616 -class pnfileentry(BaseProtogenClass):

617 __fields=['entry_tag', 'pad00', 'mod_date', 'unk0', 'pn_id', 'pe_id', 'unknown00', 'pn_order', 'phone_number', 'unknown01', 'ntype', 'unknown02', 'exit_tag', 'blanks'] 618

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

620 dict={} 621 # What was supplied to this function 622 dict.update(kwargs) 623 # Parent constructor 624 super(pnfileentry,self).__init__(**dict) 625 if self.__class__ is pnfileentry: 626 self._update(args,dict)

627 628

629 - def getfields(self):

630 return self.__fields

631 632

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

634 super(pnfileentry,self)._update(args,kwargs) 635 keys=kwargs.keys() 636 for key in keys: 637 if key in self.__fields: 638 setattr(self, key, kwargs[key]) 639 del kwargs[key] 640 # Were any unrecognized kwargs passed in? 641 if __debug__: 642 self._complainaboutunusedargs(pnfileentry,kwargs) 643 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)

644 # Make all P fields that haven't already been constructed 645 646

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

648 'Writes this packet to the supplied buffer' 649 self._bufferstartoffset=buf.getcurrentoffset() 650 try: self.__field_entry_tag 651 except: 652 self.__field_entry_tag=STRING(**{'sizeinbytes': 4, 'terminator': None, 'raiseonunterminatedread': False, 'raiseontruncate': False, 'default': '\xff\xff\xff\xff'}) 653 self.__field_entry_tag.writetobuffer(buf) 654 if self.entry_tag != '\xff\xff\xff\xff': 655 try: self.__field_pad00 656 except: 657 self.__field_pad00=UINT(**{'sizeinbytes': 2, 'default': 0 }) 658 self.__field_pad00.writetobuffer(buf) 659 try: self.__field_mod_date 660 except: 661 self.__field_mod_date=PBDateTime(**{'defaulttocurrenttime': True }) 662 self.__field_mod_date.writetobuffer(buf) 663 try: self.__field_unk0 664 except: 665 self.__field_unk0=STRING(**{'sizeinbytes': 6, 'default': '', 'raiseonunterminatedread': False }) 666 self.__field_unk0.writetobuffer(buf) 667 self.__field_pn_id.writetobuffer(buf) 668 self.__field_pe_id.writetobuffer(buf) 669 try: self.__field_unknown00 670 except: 671 self.__field_unknown00=UINT(**{'sizeinbytes': 1, 'default': 0 }) 672 self.__field_unknown00.writetobuffer(buf) 673 self.__field_pn_order.writetobuffer(buf) 674 self.__field_phone_number.writetobuffer(buf) 675 try: self.__field_unknown01 676 except: 677 self.__field_unknown01=UINT(**{'sizeinbytes': 1, 'default': 1 }) 678 self.__field_unknown01.writetobuffer(buf) 679 self.__field_ntype.writetobuffer(buf) 680 try: self.__field_unknown02 681 except: 682 self.__field_unknown02=UINT(**{'sizeinbytes': 1, 'default': 0 }) 683 self.__field_unknown02.writetobuffer(buf) 684 try: self.__field_exit_tag 685 except: 686 self.__field_exit_tag=USTRING(**{'sizeinbytes': 6, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False, 'raiseontruncate': False, 'default': '</PN>'}) 687 self.__field_exit_tag.writetobuffer(buf) 688 else: 689 try: self.__field_blanks 690 except: 691 self.__field_blanks=DATA(**{'sizeinbytes': 60, 'default': '\xFF'*60 }) 692 self.__field_blanks.writetobuffer(buf) 693 self._bufferendoffset=buf.getcurrentoffset() 694 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)

695 696

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

698 'Reads this packet from the supplied buffer' 699 self._bufferstartoffset=buf.getcurrentoffset() 700 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 701 self.__field_entry_tag=STRING(**{'sizeinbytes': 4, 'terminator': None, 'raiseonunterminatedread': False, 'raiseontruncate': False, 'default': '\xff\xff\xff\xff'}) 702 self.__field_entry_tag.readfrombuffer(buf) 703 if self.entry_tag != '\xff\xff\xff\xff': 704 self.__field_pad00=UINT(**{'sizeinbytes': 2, 'default': 0 }) 705 self.__field_pad00.readfrombuffer(buf) 706 self.__field_mod_date=PBDateTime(**{'defaulttocurrenttime': True }) 707 self.__field_mod_date.readfrombuffer(buf) 708 self.__field_unk0=STRING(**{'sizeinbytes': 6, 'default': '', 'raiseonunterminatedread': False }) 709 self.__field_unk0.readfrombuffer(buf) 710 self.__field_pn_id=UINT(**{'sizeinbytes': 2}) 711 self.__field_pn_id.readfrombuffer(buf) 712 self.__field_pe_id=UINT(**{'sizeinbytes': 2}) 713 self.__field_pe_id.readfrombuffer(buf) 714 self.__field_unknown00=UINT(**{'sizeinbytes': 1, 'default': 0 }) 715 self.__field_unknown00.readfrombuffer(buf) 716 self.__field_pn_order=UINT(**{'sizeinbytes': 1}) 717 self.__field_pn_order.readfrombuffer(buf) 718 self.__field_phone_number=LGHEXPN(**{'sizeinbytes': 25}) 719 self.__field_phone_number.readfrombuffer(buf) 720 self.__field_unknown01=UINT(**{'sizeinbytes': 1, 'default': 1 }) 721 self.__field_unknown01.readfrombuffer(buf) 722 self.__field_ntype=UINT(**{'sizeinbytes': 1}) 723 self.__field_ntype.readfrombuffer(buf) 724 self.__field_unknown02=UINT(**{'sizeinbytes': 1, 'default': 0 }) 725 self.__field_unknown02.readfrombuffer(buf) 726 self.__field_exit_tag=USTRING(**{'sizeinbytes': 6, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False, 'raiseontruncate': False, 'default': '</PN>'}) 727 self.__field_exit_tag.readfrombuffer(buf) 728 else: 729 self.__field_blanks=DATA(**{'sizeinbytes': 60, 'default': '\xFF'*60 }) 730 self.__field_blanks.readfrombuffer(buf) 731 self._bufferendoffset=buf.getcurrentoffset()

732 733

734 - def __getfield_entry_tag(self):

735 try: self.__field_entry_tag 736 except: 737 self.__field_entry_tag=STRING(**{'sizeinbytes': 4, 'terminator': None, 'raiseonunterminatedread': False, 'raiseontruncate': False, 'default': '\xff\xff\xff\xff'}) 738 return self.__field_entry_tag.getvalue()

739

740 - def __setfield_entry_tag(self, value):

741 if isinstance(value,STRING): 742 self.__field_entry_tag=value 743 else: 744 self.__field_entry_tag=STRING(value,**{'sizeinbytes': 4, 'terminator': None, 'raiseonunterminatedread': False, 'raiseontruncate': False, 'default': '\xff\xff\xff\xff'})

745

746 - def __delfield_entry_tag(self): del self.__field_entry_tag

747 748 entry_tag=property(__getfield_entry_tag, __setfield_entry_tag, __delfield_entry_tag, None) 749

750 - def __getfield_pad00(self):

751 try: self.__field_pad00 752 except: 753 self.__field_pad00=UINT(**{'sizeinbytes': 2, 'default': 0 }) 754 return self.__field_pad00.getvalue()

755

756 - def __setfield_pad00(self, value):

757 if isinstance(value,UINT): 758 self.__field_pad00=value 759 else: 760 self.__field_pad00=UINT(value,**{'sizeinbytes': 2, 'default': 0 })

761

762 - def __delfield_pad00(self): del self.__field_pad00

763 764 pad00=property(__getfield_pad00, __setfield_pad00, __delfield_pad00, None) 765

766 - def __getfield_mod_date(self):

767 try: self.__field_mod_date 768 except: 769 self.__field_mod_date=PBDateTime(**{'defaulttocurrenttime': True }) 770 return self.__field_mod_date.getvalue()

771

772 - def __setfield_mod_date(self, value):

773 if isinstance(value,PBDateTime): 774 self.__field_mod_date=value 775 else: 776 self.__field_mod_date=PBDateTime(value,**{'defaulttocurrenttime': True })

777

778 - def __delfield_mod_date(self): del self.__field_mod_date

779 780 mod_date=property(__getfield_mod_date, __setfield_mod_date, __delfield_mod_date, None) 781

782 - def __getfield_unk0(self):

783 try: self.__field_unk0 784 except: 785 self.__field_unk0=STRING(**{'sizeinbytes': 6, 'default': '', 'raiseonunterminatedread': False }) 786 return self.__field_unk0.getvalue()

787

788 - def __setfield_unk0(self, value):

789 if isinstance(value,STRING): 790 self.__field_unk0=value 791 else: 792 self.__field_unk0=STRING(value,**{'sizeinbytes': 6, 'default': '', 'raiseonunterminatedread': False })

793

794 - def __delfield_unk0(self): del self.__field_unk0

795 796 unk0=property(__getfield_unk0, __setfield_unk0, __delfield_unk0, None) 797

798 - def __getfield_pn_id(self):

799 return self.__field_pn_id.getvalue()

800

801 - def __setfield_pn_id(self, value):

802 if isinstance(value,UINT): 803 self.__field_pn_id=value 804 else: 805 self.__field_pn_id=UINT(value,**{'sizeinbytes': 2})

806

807 - def __delfield_pn_id(self): del self.__field_pn_id

808 809 pn_id=property(__getfield_pn_id, __setfield_pn_id, __delfield_pn_id, None) 810

811 - def __getfield_pe_id(self):

812 return self.__field_pe_id.getvalue()

813

814 - def __setfield_pe_id(self, value):

815 if isinstance(value,UINT): 816 self.__field_pe_id=value 817 else: 818 self.__field_pe_id=UINT(value,**{'sizeinbytes': 2})

819

820 - def __delfield_pe_id(self): del self.__field_pe_id

821 822 pe_id=property(__getfield_pe_id, __setfield_pe_id, __delfield_pe_id, None) 823

824 - def __getfield_unknown00(self):

825 try: self.__field_unknown00 826 except: 827 self.__field_unknown00=UINT(**{'sizeinbytes': 1, 'default': 0 }) 828 return self.__field_unknown00.getvalue()

829

830 - def __setfield_unknown00(self, value):

831 if isinstance(value,UINT): 832 self.__field_unknown00=value 833 else: 834 self.__field_unknown00=UINT(value,**{'sizeinbytes': 1, 'default': 0 })

835

836 - def __delfield_unknown00(self): del self.__field_unknown00

837 838 unknown00=property(__getfield_unknown00, __setfield_unknown00, __delfield_unknown00, None) 839

840 - def __getfield_pn_order(self):

841 return self.__field_pn_order.getvalue()

842

843 - def __setfield_pn_order(self, value):

844 if isinstance(value,UINT): 845 self.__field_pn_order=value 846 else: 847 self.__field_pn_order=UINT(value,**{'sizeinbytes': 1})

848

849 - def __delfield_pn_order(self): del self.__field_pn_order

850 851 pn_order=property(__getfield_pn_order, __setfield_pn_order, __delfield_pn_order, "0-based order of this phone within this contact") 852

853 - def __getfield_phone_number(self):

854 return self.__field_phone_number.getvalue()

855

856 - def __setfield_phone_number(self, value):

857 if isinstance(value,LGHEXPN): 858 self.__field_phone_number=value 859 else: 860 self.__field_phone_number=LGHEXPN(value,**{'sizeinbytes': 25})

861

862 - def __delfield_phone_number(self): del self.__field_phone_number

863 864 phone_number=property(__getfield_phone_number, __setfield_phone_number, __delfield_phone_number, None) 865

866 - def __getfield_unknown01(self):

867 try: self.__field_unknown01 868 except: 869 self.__field_unknown01=UINT(**{'sizeinbytes': 1, 'default': 1 }) 870 return self.__field_unknown01.getvalue()

871

872 - def __setfield_unknown01(self, value):

873 if isinstance(value,UINT): 874 self.__field_unknown01=value 875 else: 876 self.__field_unknown01=UINT(value,**{'sizeinbytes': 1, 'default': 1 })

877

878 - def __delfield_unknown01(self): del self.__field_unknown01

879 880 unknown01=property(__getfield_unknown01, __setfield_unknown01, __delfield_unknown01, None) 881

882 - def __getfield_ntype(self):

883 return self.__field_ntype.getvalue()

884

885 - def __setfield_ntype(self, value):

886 if isinstance(value,UINT): 887 self.__field_ntype=value 888 else: 889 self.__field_ntype=UINT(value,**{'sizeinbytes': 1})

890

891 - def __delfield_ntype(self): del self.__field_ntype

892 893 ntype=property(__getfield_ntype, __setfield_ntype, __delfield_ntype, None) 894

895 - def __getfield_unknown02(self):

896 try: self.__field_unknown02 897 except: 898 self.__field_unknown02=UINT(**{'sizeinbytes': 1, 'default': 0 }) 899 return self.__field_unknown02.getvalue()

900

901 - def __setfield_unknown02(self, value):

902 if isinstance(value,UINT): 903 self.__field_unknown02=value 904 else: 905 self.__field_unknown02=UINT(value,**{'sizeinbytes': 1, 'default': 0 })

906

907 - def __delfield_unknown02(self): del self.__field_unknown02

908 909 unknown02=property(__getfield_unknown02, __setfield_unknown02, __delfield_unknown02, None) 910

911 - def __getfield_exit_tag(self):

912 try: self.__field_exit_tag 913 except: 914 self.__field_exit_tag=USTRING(**{'sizeinbytes': 6, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False, 'raiseontruncate': False, 'default': '</PN>'}) 915 return self.__field_exit_tag.getvalue()

916

917 - def __setfield_exit_tag(self, value):

918 if isinstance(value,USTRING): 919 self.__field_exit_tag=value 920 else: 921 self.__field_exit_tag=USTRING(value,**{'sizeinbytes': 6, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False, 'raiseontruncate': False, 'default': '</PN>'})

922

923 - def __delfield_exit_tag(self): del self.__field_exit_tag

924 925 exit_tag=property(__getfield_exit_tag, __setfield_exit_tag, __delfield_exit_tag, None) 926

927 - def __getfield_blanks(self):

928 try: self.__field_blanks 929 except: 930 self.__field_blanks=DATA(**{'sizeinbytes': 60, 'default': '\xFF'*60 }) 931 return self.__field_blanks.getvalue()

932

933 - def __setfield_blanks(self, value):

934 if isinstance(value,DATA): 935 self.__field_blanks=value 936 else: 937 self.__field_blanks=DATA(value,**{'sizeinbytes': 60, 'default': '\xFF'*60 })

938

939 - def __delfield_blanks(self): del self.__field_blanks

940 941 blanks=property(__getfield_blanks, __setfield_blanks, __delfield_blanks, None) 942

943 - def iscontainer(self):

944 return True

945

946 - def containerelements(self):

947 yield ('entry_tag', self.__field_entry_tag, None) 948 if self.entry_tag != '\xff\xff\xff\xff': 949 yield ('pad00', self.__field_pad00, None) 950 yield ('mod_date', self.__field_mod_date, None) 951 yield ('unk0', self.__field_unk0, None) 952 yield ('pn_id', self.__field_pn_id, None) 953 yield ('pe_id', self.__field_pe_id, None) 954 yield ('unknown00', self.__field_unknown00, None) 955 yield ('pn_order', self.__field_pn_order, "0-based order of this phone within this contact") 956 yield ('phone_number', self.__field_phone_number, None) 957 yield ('unknown01', self.__field_unknown01, None) 958 yield ('ntype', self.__field_ntype, None) 959 yield ('unknown02', self.__field_unknown02, None) 960 yield ('exit_tag', self.__field_exit_tag, None) 961 else: 962 yield ('blanks', self.__field_blanks, None)

963

964 - def valid(self):

965 return self.phone_number != None

966 - def malformed(self):

967 # malformed (yet valid) entries have been seen on several phones including the VX-8550 and VX-10000 968 return self.entry_tag != PB_NUMBER_SOR

969 970 971 972

973 -class pnfile(BaseProtogenClass):

974 __fields=['items'] 975

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

977 dict={} 978 # What was supplied to this function 979 dict.update(kwargs) 980 # Parent constructor 981 super(pnfile,self).__init__(**dict) 982 if self.__class__ is pnfile: 983 self._update(args,dict)

984 985

986 - def getfields(self):

987 return self.__fields

988 989

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

991 super(pnfile,self)._update(args,kwargs) 992 keys=kwargs.keys() 993 for key in keys: 994 if key in self.__fields: 995 setattr(self, key, kwargs[key]) 996 del kwargs[key] 997 # Were any unrecognized kwargs passed in? 998 if __debug__: 999 self._complainaboutunusedargs(pnfile,kwargs) 1000 if len(args): 1001 dict2={ 'elementclass': pnfileentry, 'createdefault': True, 'length': NUMPHONENUMBERENTRIES } 1002 dict2.update(kwargs) 1003 kwargs=dict2 1004 self.__field_items=LIST(*args,**dict2)

1005 # Make all P fields that haven't already been constructed 1006 1007

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

1009 'Writes this packet to the supplied buffer' 1010 self._bufferstartoffset=buf.getcurrentoffset() 1011 try: self.__field_items 1012 except: 1013 self.__field_items=LIST(**{ 'elementclass': pnfileentry, 'createdefault': True, 'length': NUMPHONENUMBERENTRIES }) 1014 self.__field_items.writetobuffer(buf) 1015 self._bufferendoffset=buf.getcurrentoffset() 1016 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)

1017 1018

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

1020 'Reads this packet from the supplied buffer' 1021 self._bufferstartoffset=buf.getcurrentoffset() 1022 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 1023 self.__field_items=LIST(**{ 'elementclass': pnfileentry, 'createdefault': True, 'length': NUMPHONENUMBERENTRIES }) 1024 self.__field_items.readfrombuffer(buf) 1025 self._bufferendoffset=buf.getcurrentoffset()

1026 1027

1028 - def __getfield_items(self):

1029 try: self.__field_items 1030 except: 1031 self.__field_items=LIST(**{ 'elementclass': pnfileentry, 'createdefault': True, 'length': NUMPHONENUMBERENTRIES }) 1032 return self.__field_items.getvalue()

1033

1034 - def __setfield_items(self, value):

1035 if isinstance(value,LIST): 1036 self.__field_items=value 1037 else: 1038 self.__field_items=LIST(value,**{ 'elementclass': pnfileentry, 'createdefault': True, 'length': NUMPHONENUMBERENTRIES })

1039

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

1041 1042 items=property(__getfield_items, __setfield_items, __delfield_items, None) 1043

1044 - def iscontainer(self):

1045 return True

1046

1047 - def containerelements(self):

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

1049 1050 1051 1052

1053 -class pbgroup(BaseProtogenClass):

1054 __fields=['name', 'groupid', 'user_added', 'unk0'] 1055

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

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

1064 1065

1066 - def getfields(self):

1067 return self.__fields

1068 1069

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

1071 super(pbgroup,self)._update(args,kwargs) 1072 keys=kwargs.keys() 1073 for key in keys: 1074 if key in self.__fields: 1075 setattr(self, key, kwargs[key]) 1076 del kwargs[key] 1077 # Were any unrecognized kwargs passed in? 1078 if __debug__: 1079 self._complainaboutunusedargs(pbgroup,kwargs) 1080 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)

1081 # Make all P fields that haven't already been constructed 1082 1083

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

1085 'Writes this packet to the supplied buffer' 1086 self._bufferstartoffset=buf.getcurrentoffset() 1087 try: self.__field_name 1088 except: 1089 self.__field_name=USTRING(**{'sizeinbytes': 34, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False, 'raiseontruncate': False, 'default': '' }) 1090 self.__field_name.writetobuffer(buf) 1091 try: self.__field_groupid 1092 except: 1093 self.__field_groupid=UINT(**{'sizeinbytes': 2, 'default': 0 }) 1094 self.__field_groupid.writetobuffer(buf) 1095 try: self.__field_user_added 1096 except: 1097 self.__field_user_added=UINT(**{'sizeinbytes': 1, 'default': 0 }) 1098 self.__field_user_added.writetobuffer(buf) 1099 try: self.__field_unk0 1100 except: 1101 self.__field_unk0=UINT(**{'sizeinbytes': 2, 'default': 0 }) 1102 self.__field_unk0.writetobuffer(buf) 1103 self._bufferendoffset=buf.getcurrentoffset() 1104 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)

1105 1106

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

1108 'Reads this packet from the supplied buffer' 1109 self._bufferstartoffset=buf.getcurrentoffset() 1110 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 1111 self.__field_name=USTRING(**{'sizeinbytes': 34, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False, 'raiseontruncate': False, 'default': '' }) 1112 self.__field_name.readfrombuffer(buf) 1113 self.__field_groupid=UINT(**{'sizeinbytes': 2, 'default': 0 }) 1114 self.__field_groupid.readfrombuffer(buf) 1115 self.__field_user_added=UINT(**{'sizeinbytes': 1, 'default': 0 }) 1116 self.__field_user_added.readfrombuffer(buf) 1117 self.__field_unk0=UINT(**{'sizeinbytes': 2, 'default': 0 }) 1118 self.__field_unk0.readfrombuffer(buf) 1119 self._bufferendoffset=buf.getcurrentoffset()

1120 1121

1122 - def __getfield_name(self):

1123 try: self.__field_name 1124 except: 1125 self.__field_name=USTRING(**{'sizeinbytes': 34, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False, 'raiseontruncate': False, 'default': '' }) 1126 return self.__field_name.getvalue()

1127

1128 - def __setfield_name(self, value):

1129 if isinstance(value,USTRING): 1130 self.__field_name=value 1131 else: 1132 self.__field_name=USTRING(value,**{'sizeinbytes': 34, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False, 'raiseontruncate': False, 'default': '' })

1133

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

1135 1136 name=property(__getfield_name, __setfield_name, __delfield_name, None) 1137

1138 - def __getfield_groupid(self):

1139 try: self.__field_groupid 1140 except: 1141 self.__field_groupid=UINT(**{'sizeinbytes': 2, 'default': 0 }) 1142 return self.__field_groupid.getvalue()

1143

1144 - def __setfield_groupid(self, value):

1145 if isinstance(value,UINT): 1146 self.__field_groupid=value 1147 else: 1148 self.__field_groupid=UINT(value,**{'sizeinbytes': 2, 'default': 0 })

1149

1150 - def __delfield_groupid(self): del self.__field_groupid

1151 1152 groupid=property(__getfield_groupid, __setfield_groupid, __delfield_groupid, None) 1153

1154 - def __getfield_user_added(self):

1155 try: self.__field_user_added 1156 except: 1157 self.__field_user_added=UINT(**{'sizeinbytes': 1, 'default': 0 }) 1158 return self.__field_user_added.getvalue()

1159

1160 - def __setfield_user_added(self, value):

1161 if isinstance(value,UINT): 1162 self.__field_user_added=value 1163 else: 1164 self.__field_user_added=UINT(value,**{'sizeinbytes': 1, 'default': 0 })

1165

1166 - def __delfield_user_added(self): del self.__field_user_added

1167 1168 user_added=property(__getfield_user_added, __setfield_user_added, __delfield_user_added, "=1 when was added by user -- not really") 1169

1170 - def __getfield_unk0(self):

1171 try: self.__field_unk0 1172 except: 1173 self.__field_unk0=UINT(**{'sizeinbytes': 2, 'default': 0 }) 1174 return self.__field_unk0.getvalue()

1175

1176 - def __setfield_unk0(self, value):

1177 if isinstance(value,UINT): 1178 self.__field_unk0=value 1179 else: 1180 self.__field_unk0=UINT(value,**{'sizeinbytes': 2, 'default': 0 })

1181

1182 - def __delfield_unk0(self): del self.__field_unk0

1183 1184 unk0=property(__getfield_unk0, __setfield_unk0, __delfield_unk0, None) 1185

1186 - def iscontainer(self):

1187 return True

1188

1189 - def containerelements(self):

1190 yield ('name', self.__field_name, None) 1191 yield ('groupid', self.__field_groupid, None) 1192 yield ('user_added', self.__field_user_added, "=1 when was added by user -- not really") 1193 yield ('unk0', self.__field_unk0, None)

1194 1195 1196 1197

1198 -class pbgroups(BaseProtogenClass):

1199 "Phonebook groups" 1200 __fields=['groups'] 1201

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

1203 dict={} 1204 # What was supplied to this function 1205 dict.update(kwargs) 1206 # Parent constructor 1207 super(pbgroups,self).__init__(**dict) 1208 if self.__class__ is pbgroups: 1209 self._update(args,dict)

1210 1211

1212 - def getfields(self):

1213 return self.__fields

1214 1215

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

1217 super(pbgroups,self)._update(args,kwargs) 1218 keys=kwargs.keys() 1219 for key in keys: 1220 if key in self.__fields: 1221 setattr(self, key, kwargs[key]) 1222 del kwargs[key] 1223 # Were any unrecognized kwargs passed in? 1224 if __debug__: 1225 self._complainaboutunusedargs(pbgroups,kwargs) 1226 if len(args): 1227 dict2={'elementclass': pbgroup, 'length': MAX_PHONEBOOK_GROUPS, 'createdefault': True} 1228 dict2.update(kwargs) 1229 kwargs=dict2 1230 self.__field_groups=LIST(*args,**dict2)

1231 # Make all P fields that haven't already been constructed 1232 1233

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

1235 'Writes this packet to the supplied buffer' 1236 self._bufferstartoffset=buf.getcurrentoffset() 1237 try: self.__field_groups 1238 except: 1239 self.__field_groups=LIST(**{'elementclass': pbgroup, 'length': MAX_PHONEBOOK_GROUPS, 'createdefault': True}) 1240 self.__field_groups.writetobuffer(buf) 1241 self._bufferendoffset=buf.getcurrentoffset() 1242 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)

1243 1244

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

1246 'Reads this packet from the supplied buffer' 1247 self._bufferstartoffset=buf.getcurrentoffset() 1248 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 1249 self.__field_groups=LIST(**{'elementclass': pbgroup, 'length': MAX_PHONEBOOK_GROUPS, 'createdefault': True}) 1250 self.__field_groups.readfrombuffer(buf) 1251 self._bufferendoffset=buf.getcurrentoffset()

1252 1253

1254 - def __getfield_groups(self):

1255 try: self.__field_groups 1256 except: 1257 self.__field_groups=LIST(**{'elementclass': pbgroup, 'length': MAX_PHONEBOOK_GROUPS, 'createdefault': True}) 1258 return self.__field_groups.getvalue()

1259

1260 - def __setfield_groups(self, value):

1261 if isinstance(value,LIST): 1262 self.__field_groups=value 1263 else: 1264 self.__field_groups=LIST(value,**{'elementclass': pbgroup, 'length': MAX_PHONEBOOK_GROUPS, 'createdefault': True})

1265

1266 - def __delfield_groups(self): del self.__field_groups

1267 1268 groups=property(__getfield_groups, __setfield_groups, __delfield_groups, None) 1269

1270 - def iscontainer(self):

1271 return True

1272

1273 - def containerelements(self):

1274 yield ('groups', self.__field_groups, None)

1275

Source Code for Module phones.p_lgvx9200