phones.p_lgvx9600

1 # THIS FILE IS AUTOMATICALLY GENERATED. EDIT THE SOURCE FILE NOT THIS ONE 2 3 """Various descriptions of data specific to LG VX9700""" 4 5 # groups - same as VX-8700 6 # phonebook - LG Phonebook v1.0 (same as VX-8550) 7 # schedule - same as VX-8550 8 # sms - same as VX-9700 9 # memos - same as VX-8550 10 # call history - same as VX-9700 11 from p_lgvx9700 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 # Phonebook favorites 19 favorites_file_name = "pim/pbFavorite.dat" 20 NUMFAVORITES=10 21

22 -class call(BaseProtogenClass):

23 __fields=['GPStime', 'unk0', 'duration', 'number', 'name', 'numberlength', 'status', 'pbnumbertype', 'unk1', 'pbentrynum', 'unk2'] 24

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

26 dict={} 27 # What was supplied to this function 28 dict.update(kwargs) 29 # Parent constructor 30 super(call,self).__init__(**dict) 31 if self.__class__ is call: 32 self._update(args,dict)

33 34

35 - def getfields(self):

36 return self.__fields

37 38

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

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

50 # Make all P fields that haven't already been constructed 51 52

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

54 'Writes this packet to the supplied buffer' 55 self._bufferstartoffset=buf.getcurrentoffset() 56 self.__field_GPStime.writetobuffer(buf) 57 self.__field_unk0.writetobuffer(buf) 58 self.__field_duration.writetobuffer(buf) 59 self.__field_number.writetobuffer(buf) 60 self.__field_name.writetobuffer(buf) 61 self.__field_numberlength.writetobuffer(buf) 62 self.__field_status.writetobuffer(buf) 63 self.__field_pbnumbertype.writetobuffer(buf) 64 self.__field_unk1.writetobuffer(buf) 65 self.__field_pbentrynum.writetobuffer(buf) 66 self.__field_unk2.writetobuffer(buf) 67 self._bufferendoffset=buf.getcurrentoffset() 68 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)

69 70

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

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

98 99

100 - def __getfield_GPStime(self):

101 return self.__field_GPStime.getvalue()

102

103 - def __setfield_GPStime(self, value):

104 if isinstance(value,GPSDATE): 105 self.__field_GPStime=value 106 else: 107 self.__field_GPStime=GPSDATE(value,**{'sizeinbytes': 4})

108

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

110 111 GPStime=property(__getfield_GPStime, __setfield_GPStime, __delfield_GPStime, None) 112

113 - def __getfield_unk0(self):

114 return self.__field_unk0.getvalue()

115

116 - def __setfield_unk0(self, value):

117 if isinstance(value,UINT): 118 self.__field_unk0=value 119 else: 120 self.__field_unk0=UINT(value,**{'sizeinbytes': 4})

121

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

123 124 unk0=property(__getfield_unk0, __setfield_unk0, __delfield_unk0, None) 125

126 - def __getfield_duration(self):

127 return self.__field_duration.getvalue()

128

129 - def __setfield_duration(self, value):

130 if isinstance(value,UINT): 131 self.__field_duration=value 132 else: 133 self.__field_duration=UINT(value,**{'sizeinbytes': 4})

134

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

136 137 duration=property(__getfield_duration, __setfield_duration, __delfield_duration, None) 138

139 - def __getfield_number(self):

140 return self.__field_number.getvalue()

141

142 - def __setfield_number(self, value):

143 if isinstance(value,USTRING): 144 self.__field_number=value 145 else: 146 self.__field_number=USTRING(value,**{'sizeinbytes': 49, 'raiseonunterminatedread': False})

147

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

149 150 number=property(__getfield_number, __setfield_number, __delfield_number, None) 151

152 - def __getfield_name(self):

153 return self.__field_name.getvalue()

154

155 - def __setfield_name(self, value):

156 if isinstance(value,USTRING): 157 self.__field_name=value 158 else: 159 self.__field_name=USTRING(value,**{'sizeinbytes': 36, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False})

160

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

162 163 name=property(__getfield_name, __setfield_name, __delfield_name, None) 164

165 - def __getfield_numberlength(self):

166 return self.__field_numberlength.getvalue()

167

168 - def __setfield_numberlength(self, value):

169 if isinstance(value,UINT): 170 self.__field_numberlength=value 171 else: 172 self.__field_numberlength=UINT(value,**{'sizeinbytes': 1})

173

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

175 176 numberlength=property(__getfield_numberlength, __setfield_numberlength, __delfield_numberlength, None) 177

178 - def __getfield_status(self):

179 return self.__field_status.getvalue()

180

181 - def __setfield_status(self, value):

182 if isinstance(value,UINT): 183 self.__field_status=value 184 else: 185 self.__field_status=UINT(value,**{'sizeinbytes': 1})

186

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

188 189 status=property(__getfield_status, __setfield_status, __delfield_status, None) 190

191 - def __getfield_pbnumbertype(self):

192 return self.__field_pbnumbertype.getvalue()

193

194 - def __setfield_pbnumbertype(self, value):

195 if isinstance(value,UINT): 196 self.__field_pbnumbertype=value 197 else: 198 self.__field_pbnumbertype=UINT(value,**{'sizeinbytes': 1})

199

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

201 202 pbnumbertype=property(__getfield_pbnumbertype, __setfield_pbnumbertype, __delfield_pbnumbertype, None) 203

204 - def __getfield_unk1(self):

205 return self.__field_unk1.getvalue()

206

207 - def __setfield_unk1(self, value):

208 if isinstance(value,UINT): 209 self.__field_unk1=value 210 else: 211 self.__field_unk1=UINT(value,**{'sizeinbytes': 4})

212

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

214 215 unk1=property(__getfield_unk1, __setfield_unk1, __delfield_unk1, None) 216

217 - def __getfield_pbentrynum(self):

218 return self.__field_pbentrynum.getvalue()

219

220 - def __setfield_pbentrynum(self, value):

221 if isinstance(value,UINT): 222 self.__field_pbentrynum=value 223 else: 224 self.__field_pbentrynum=UINT(value,**{'sizeinbytes': 2})

225

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

227 228 pbentrynum=property(__getfield_pbentrynum, __setfield_pbentrynum, __delfield_pbentrynum, None) 229

230 - def __getfield_unk2(self):

231 return self.__field_unk2.getvalue()

232

233 - def __setfield_unk2(self, value):

234 if isinstance(value,DATA): 235 self.__field_unk2=value 236 else: 237 self.__field_unk2=DATA(value,**{'sizeinbytes': 27})

238

239 - def __delfield_unk2(self): del self.__field_unk2

240 241 unk2=property(__getfield_unk2, __setfield_unk2, __delfield_unk2, None) 242

243 - def iscontainer(self):

244 return True

245

246 - def containerelements(self):

247 yield ('GPStime', self.__field_GPStime, None) 248 yield ('unk0', self.__field_unk0, None) 249 yield ('duration', self.__field_duration, None) 250 yield ('number', self.__field_number, None) 251 yield ('name', self.__field_name, None) 252 yield ('numberlength', self.__field_numberlength, None) 253 yield ('status', self.__field_status, None) 254 yield ('pbnumbertype', self.__field_pbnumbertype, None) 255 yield ('unk1', self.__field_unk1, None) 256 yield ('pbentrynum', self.__field_pbentrynum, None) 257 yield ('unk2', self.__field_unk2, None)

258 259 260 261

262 -class callhistory(BaseProtogenClass):

263 __fields=['numcalls', 'unk1', 'calls'] 264

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

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

273 274

275 - def getfields(self):

276 return self.__fields

277 278

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

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

290 # Make all P fields that haven't already been constructed 291 292

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

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

304 305

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

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

317 318

319 - def __getfield_numcalls(self):

320 return self.__field_numcalls.getvalue()

321

322 - def __setfield_numcalls(self, value):

323 if isinstance(value,UINT): 324 self.__field_numcalls=value 325 else: 326 self.__field_numcalls=UINT(value,**{'sizeinbytes': 4})

327

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

329 330 numcalls=property(__getfield_numcalls, __setfield_numcalls, __delfield_numcalls, None) 331

332 - def __getfield_unk1(self):

333 return self.__field_unk1.getvalue()

334

335 - def __setfield_unk1(self, value):

336 if isinstance(value,UINT): 337 self.__field_unk1=value 338 else: 339 self.__field_unk1=UINT(value,**{'sizeinbytes': 1})

340

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

342 343 unk1=property(__getfield_unk1, __setfield_unk1, __delfield_unk1, None) 344

345 - def __getfield_calls(self):

346 try: self.__field_calls 347 except: 348 self.__field_calls=LIST(**{'elementclass': call}) 349 return self.__field_calls.getvalue()

350

351 - def __setfield_calls(self, value):

352 if isinstance(value,LIST): 353 self.__field_calls=value 354 else: 355 self.__field_calls=LIST(value,**{'elementclass': call})

356

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

358 359 calls=property(__getfield_calls, __setfield_calls, __delfield_calls, None) 360

361 - def iscontainer(self):

362 return True

363

364 - def containerelements(self):

365 yield ('numcalls', self.__field_numcalls, None) 366 yield ('unk1', self.__field_unk1, None) 367 yield ('calls', self.__field_calls, None)

368 369 370 371

372 -class favorite(BaseProtogenClass):

373 __fields=['unk0', 'pb_index', 'unk1', 'unk2'] 374

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

376 dict={} 377 # What was supplied to this function 378 dict.update(kwargs) 379 # Parent constructor 380 super(favorite,self).__init__(**dict) 381 if self.__class__ is favorite: 382 self._update(args,dict)

383 384

385 - def getfields(self):

386 return self.__fields

387 388

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

390 super(favorite,self)._update(args,kwargs) 391 keys=kwargs.keys() 392 for key in keys: 393 if key in self.__fields: 394 setattr(self, key, kwargs[key]) 395 del kwargs[key] 396 # Were any unrecognized kwargs passed in? 397 if __debug__: 398 self._complainaboutunusedargs(favorite,kwargs) 399 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)

400 # Make all P fields that haven't already been constructed 401 402

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

404 'Writes this packet to the supplied buffer' 405 self._bufferstartoffset=buf.getcurrentoffset() 406 try: self.__field_unk0 407 except: 408 self.__field_unk0=UINT(**{'sizeinbytes': 2, 'default': 0 }) 409 self.__field_unk0.writetobuffer(buf) 410 try: self.__field_pb_index 411 except: 412 self.__field_pb_index=UINT(**{'sizeinbytes': 2, 'default': 0xffff }) 413 self.__field_pb_index.writetobuffer(buf) 414 try: self.__field_unk1 415 except: 416 self.__field_unk1=UINT(**{'sizeinbytes': 4, 'default': 0 }) 417 self.__field_unk1.writetobuffer(buf) 418 try: self.__field_unk2 419 except: 420 self.__field_unk2=UINT(**{'sizeinbytes': 4, 'default': 0x45 }) 421 self.__field_unk2.writetobuffer(buf) 422 self._bufferendoffset=buf.getcurrentoffset() 423 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)

424 425

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

427 'Reads this packet from the supplied buffer' 428 self._bufferstartoffset=buf.getcurrentoffset() 429 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 430 self.__field_unk0=UINT(**{'sizeinbytes': 2, 'default': 0 }) 431 self.__field_unk0.readfrombuffer(buf) 432 self.__field_pb_index=UINT(**{'sizeinbytes': 2, 'default': 0xffff }) 433 self.__field_pb_index.readfrombuffer(buf) 434 self.__field_unk1=UINT(**{'sizeinbytes': 4, 'default': 0 }) 435 self.__field_unk1.readfrombuffer(buf) 436 self.__field_unk2=UINT(**{'sizeinbytes': 4, 'default': 0x45 }) 437 self.__field_unk2.readfrombuffer(buf) 438 self._bufferendoffset=buf.getcurrentoffset()

439 440

441 - def __getfield_unk0(self):

442 try: self.__field_unk0 443 except: 444 self.__field_unk0=UINT(**{'sizeinbytes': 2, 'default': 0 }) 445 return self.__field_unk0.getvalue()

446

447 - def __setfield_unk0(self, value):

448 if isinstance(value,UINT): 449 self.__field_unk0=value 450 else: 451 self.__field_unk0=UINT(value,**{'sizeinbytes': 2, 'default': 0 })

452

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

454 455 unk0=property(__getfield_unk0, __setfield_unk0, __delfield_unk0, None) 456

457 - def __getfield_pb_index(self):

458 try: self.__field_pb_index 459 except: 460 self.__field_pb_index=UINT(**{'sizeinbytes': 2, 'default': 0xffff }) 461 return self.__field_pb_index.getvalue()

462

463 - def __setfield_pb_index(self, value):

464 if isinstance(value,UINT): 465 self.__field_pb_index=value 466 else: 467 self.__field_pb_index=UINT(value,**{'sizeinbytes': 2, 'default': 0xffff })

468

469 - def __delfield_pb_index(self): del self.__field_pb_index

470 471 pb_index=property(__getfield_pb_index, __setfield_pb_index, __delfield_pb_index, None) 472

473 - def __getfield_unk1(self):

474 try: self.__field_unk1 475 except: 476 self.__field_unk1=UINT(**{'sizeinbytes': 4, 'default': 0 }) 477 return self.__field_unk1.getvalue()

478

479 - def __setfield_unk1(self, value):

480 if isinstance(value,UINT): 481 self.__field_unk1=value 482 else: 483 self.__field_unk1=UINT(value,**{'sizeinbytes': 4, 'default': 0 })

484

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

486 487 unk1=property(__getfield_unk1, __setfield_unk1, __delfield_unk1, None) 488

489 - def __getfield_unk2(self):

490 try: self.__field_unk2 491 except: 492 self.__field_unk2=UINT(**{'sizeinbytes': 4, 'default': 0x45 }) 493 return self.__field_unk2.getvalue()

494

495 - def __setfield_unk2(self, value):

496 if isinstance(value,UINT): 497 self.__field_unk2=value 498 else: 499 self.__field_unk2=UINT(value,**{'sizeinbytes': 4, 'default': 0x45 })

500

501 - def __delfield_unk2(self): del self.__field_unk2

502 503 unk2=property(__getfield_unk2, __setfield_unk2, __delfield_unk2, None) 504

505 - def iscontainer(self):

506 return True

507

508 - def containerelements(self):

509 yield ('unk0', self.__field_unk0, None) 510 yield ('pb_index', self.__field_pb_index, None) 511 yield ('unk1', self.__field_unk1, None) 512 yield ('unk2', self.__field_unk2, None)

513

514 - def has_pbentry(self):

515 return self.pb_index != 0xffff

516 517 518 519

520 -class favorites(BaseProtogenClass):

521 __fields=['count', 'items', 'pad'] 522

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

524 dict={} 525 # What was supplied to this function 526 dict.update(kwargs) 527 # Parent constructor 528 super(favorites,self).__init__(**dict) 529 if self.__class__ is favorites: 530 self._update(args,dict)

531 532

533 - def getfields(self):

534 return self.__fields

535 536

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

538 super(favorites,self)._update(args,kwargs) 539 keys=kwargs.keys() 540 for key in keys: 541 if key in self.__fields: 542 setattr(self, key, kwargs[key]) 543 del kwargs[key] 544 # Were any unrecognized kwargs passed in? 545 if __debug__: 546 self._complainaboutunusedargs(favorites,kwargs) 547 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)

548 # Make all P fields that haven't already been constructed 549 550

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

552 'Writes this packet to the supplied buffer' 553 self._bufferstartoffset=buf.getcurrentoffset() 554 try: self.__field_count 555 except: 556 self.__field_count=UINT(**{'sizeinbytes': 2, 'default': 0 }) 557 self.__field_count.writetobuffer(buf) 558 try: self.__field_items 559 except: 560 self.__field_items=LIST(**{ 'elementclass': favorite, 'length': self.count }) 561 self.__field_items.writetobuffer(buf) 562 self.__field_pad.writetobuffer(buf) 563 self._bufferendoffset=buf.getcurrentoffset() 564 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)

565 566

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

568 'Reads this packet from the supplied buffer' 569 self._bufferstartoffset=buf.getcurrentoffset() 570 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 571 self.__field_count=UINT(**{'sizeinbytes': 2, 'default': 0 }) 572 self.__field_count.readfrombuffer(buf) 573 self.__field_items=LIST(**{ 'elementclass': favorite, 'length': self.count }) 574 self.__field_items.readfrombuffer(buf) 575 self.__field_pad=LIST(**{'elementclass': _gen_p_lgvx9600_68, 'length': NUMFAVORITES - self.count }) 576 self.__field_pad.readfrombuffer(buf) 577 self._bufferendoffset=buf.getcurrentoffset()

578 579

580 - def __getfield_count(self):

581 try: self.__field_count 582 except: 583 self.__field_count=UINT(**{'sizeinbytes': 2, 'default': 0 }) 584 return self.__field_count.getvalue()

585

586 - def __setfield_count(self, value):

587 if isinstance(value,UINT): 588 self.__field_count=value 589 else: 590 self.__field_count=UINT(value,**{'sizeinbytes': 2, 'default': 0 })

591

592 - def __delfield_count(self): del self.__field_count

593 594 count=property(__getfield_count, __setfield_count, __delfield_count, None) 595

596 - def __getfield_items(self):

597 try: self.__field_items 598 except: 599 self.__field_items=LIST(**{ 'elementclass': favorite, 'length': self.count }) 600 return self.__field_items.getvalue()

601

602 - def __setfield_items(self, value):

603 if isinstance(value,LIST): 604 self.__field_items=value 605 else: 606 self.__field_items=LIST(value,**{ 'elementclass': favorite, 'length': self.count })

607

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

609 610 items=property(__getfield_items, __setfield_items, __delfield_items, None) 611

612 - def __getfield_pad(self):

613 return self.__field_pad.getvalue()

614

615 - def __setfield_pad(self, value):

616 if isinstance(value,LIST): 617 self.__field_pad=value 618 else: 619 self.__field_pad=LIST(value,**{'elementclass': _gen_p_lgvx9600_68, 'length': NUMFAVORITES - self.count })

620

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

622 623 pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None) 624

625 - def iscontainer(self):

626 return True

627

628 - def containerelements(self):

629 yield ('count', self.__field_count, None) 630 yield ('items', self.__field_items, None) 631 yield ('pad', self.__field_pad, None)

632

633 - def set_favorite(self, index, entity_index, ispbentry):

634 # index is not used for the VX-9600 635 if ispbentry and count < NUMFAVORITES: 636 new_favorite = self.favorite () 637 new_favorite.pb_index = entity_index 638 self.items.append (new_favorite) 639 self.count += 1

640 641 642 643

644 -class _gen_p_lgvx9600_68(BaseProtogenClass):

645 'Anonymous inner class' 646 __fields=['dontcare'] 647

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

649 dict={} 650 # What was supplied to this function 651 dict.update(kwargs) 652 # Parent constructor 653 super(_gen_p_lgvx9600_68,self).__init__(**dict) 654 if self.__class__ is _gen_p_lgvx9600_68: 655 self._update(args,dict)

656 657

658 - def getfields(self):

659 return self.__fields

660 661

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

663 super(_gen_p_lgvx9600_68,self)._update(args,kwargs) 664 keys=kwargs.keys() 665 for key in keys: 666 if key in self.__fields: 667 setattr(self, key, kwargs[key]) 668 del kwargs[key] 669 # Were any unrecognized kwargs passed in? 670 if __debug__: 671 self._complainaboutunusedargs(_gen_p_lgvx9600_68,kwargs) 672 if len(args): 673 dict2={'sizeinbytes': 12, 'default': '\xff'*507 } 674 dict2.update(kwargs) 675 kwargs=dict2 676 self.__field_dontcare=DATA(*args,**dict2)

677 # Make all P fields that haven't already been constructed 678 679

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

681 'Writes this packet to the supplied buffer' 682 self._bufferstartoffset=buf.getcurrentoffset() 683 try: self.__field_dontcare 684 except: 685 self.__field_dontcare=DATA(**{'sizeinbytes': 12, 'default': '\xff'*507 }) 686 self.__field_dontcare.writetobuffer(buf) 687 self._bufferendoffset=buf.getcurrentoffset() 688 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)

689 690

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

692 'Reads this packet from the supplied buffer' 693 self._bufferstartoffset=buf.getcurrentoffset() 694 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 695 self.__field_dontcare=DATA(**{'sizeinbytes': 12, 'default': '\xff'*507 }) 696 self.__field_dontcare.readfrombuffer(buf) 697 self._bufferendoffset=buf.getcurrentoffset()

698 699

700 - def __getfield_dontcare(self):

701 try: self.__field_dontcare 702 except: 703 self.__field_dontcare=DATA(**{'sizeinbytes': 12, 'default': '\xff'*507 }) 704 return self.__field_dontcare.getvalue()

705

706 - def __setfield_dontcare(self, value):

707 if isinstance(value,DATA): 708 self.__field_dontcare=value 709 else: 710 self.__field_dontcare=DATA(value,**{'sizeinbytes': 12, 'default': '\xff'*507 })

711

712 - def __delfield_dontcare(self): del self.__field_dontcare

713 714 dontcare=property(__getfield_dontcare, __setfield_dontcare, __delfield_dontcare, None) 715

716 - def iscontainer(self):

717 return True

718

719 - def containerelements(self):

720 yield ('dontcare', self.__field_dontcare, None)

721

Source Code for Module phones.p_lgvx9600