phones.p_samsungscha650

1 # THIS FILE IS AUTOMATICALLY GENERATED. EDIT THE SOURCE FILE NOT THIS ONE 2 # Text in this block is placed in the output file 3 4 from prototypes import * 5 6 max_pb_slots=501 7 max_pb_entries=534 8 user_pb_entry_range=xrange(1, 501) 9 max_number_entries=501 10 max_ringtone_entries=20 11 max_image_entries=10 12 13 slot_file_name='nvm/nvm/pclink_tbl' 14 pb_file_name='nvm/nvm/dial_tbl' 15 number_file_name='nvm/nvm/dial' 16 ringtone_index_file_name='nvm/nvm/brew_melody' 17 ringtone_file_path='user/sound/ringer' 18 image_index_file_name='nvm/nvm/brew_image' 19 image_file_path='nvm/brew/shared' 20 21 # map all UINT fields to lsb version 22 UINT=UINTlsb 23 BOOL=BOOLlsb 24

25 -class pbslot(BaseProtogenClass):

26 __fields=['c0', 'pbbook_index', 'status', 'timestamp'] 27

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

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

36 37

38 - def getfields(self):

39 return self.__fields

40 41

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

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

53 # Make all P fields that haven't already been constructed 54 55

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

57 'Writes this packet to the supplied buffer' 58 self._bufferstartoffset=buf.getcurrentoffset() 59 self.__field_c0.writetobuffer(buf) 60 self.__field_pbbook_index.writetobuffer(buf) 61 self.__field_status.writetobuffer(buf) 62 self.__field_timestamp.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_c0=UINT(**{'sizeinbytes': 1}) 72 self.__field_c0.readfrombuffer(buf) 73 self.__field_pbbook_index=UINT(**{'sizeinbytes': 2}) 74 self.__field_pbbook_index.readfrombuffer(buf) 75 self.__field_status=UINT(**{'sizeinbytes': 1}) 76 self.__field_status.readfrombuffer(buf) 77 self.__field_timestamp=LIST(**{'elementclass': _gen_p_samsungscha650_41, 'length': 4 }) 78 self.__field_timestamp.readfrombuffer(buf) 79 self._bufferendoffset=buf.getcurrentoffset()

80 81

82 - def __getfield_c0(self):

83 return self.__field_c0.getvalue()

84

85 - def __setfield_c0(self, value):

86 if isinstance(value,UINT): 87 self.__field_c0=value 88 else: 89 self.__field_c0=UINT(value,**{'sizeinbytes': 1})

90

91 - def __delfield_c0(self): del self.__field_c0

92 93 c0=property(__getfield_c0, __setfield_c0, __delfield_c0, None) 94

95 - def __getfield_pbbook_index(self):

96 return self.__field_pbbook_index.getvalue()

97

98 - def __setfield_pbbook_index(self, value):

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

103

104 - def __delfield_pbbook_index(self): del self.__field_pbbook_index

105 106 pbbook_index=property(__getfield_pbbook_index, __setfield_pbbook_index, __delfield_pbbook_index, None) 107

108 - def __getfield_status(self):

109 return self.__field_status.getvalue()

110

111 - def __setfield_status(self, value):

112 if isinstance(value,UINT): 113 self.__field_status=value 114 else: 115 self.__field_status=UINT(value,**{'sizeinbytes': 1})

116

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

118 119 status=property(__getfield_status, __setfield_status, __delfield_status, None) 120

121 - def __getfield_timestamp(self):

122 return self.__field_timestamp.getvalue()

123

124 - def __setfield_timestamp(self, value):

125 if isinstance(value,LIST): 126 self.__field_timestamp=value 127 else: 128 self.__field_timestamp=LIST(value,**{'elementclass': _gen_p_samsungscha650_41, 'length': 4 })

129

130 - def __delfield_timestamp(self): del self.__field_timestamp

131 132 timestamp=property(__getfield_timestamp, __setfield_timestamp, __delfield_timestamp, None) 133

134 - def iscontainer(self):

135 return True

136

137 - def containerelements(self):

138 yield ('c0', self.__field_c0, None) 139 yield ('pbbook_index', self.__field_pbbook_index, None) 140 yield ('status', self.__field_status, None) 141 yield ('timestamp', self.__field_timestamp, None)

142 143 144 145

146 -class _gen_p_samsungscha650_41(BaseProtogenClass):

147 'Anonymous inner class' 148 __fields=['t'] 149

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

151 dict={} 152 # What was supplied to this function 153 dict.update(kwargs) 154 # Parent constructor 155 super(_gen_p_samsungscha650_41,self).__init__(**dict) 156 if self.__class__ is _gen_p_samsungscha650_41: 157 self._update(args,dict)

158 159

160 - def getfields(self):

161 return self.__fields

162 163

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

165 super(_gen_p_samsungscha650_41,self)._update(args,kwargs) 166 keys=kwargs.keys() 167 for key in keys: 168 if key in self.__fields: 169 setattr(self, key, kwargs[key]) 170 del kwargs[key] 171 # Were any unrecognized kwargs passed in? 172 if __debug__: 173 self._complainaboutunusedargs(_gen_p_samsungscha650_41,kwargs) 174 if len(args): 175 dict2={'sizeinbytes': 1} 176 dict2.update(kwargs) 177 kwargs=dict2 178 self.__field_t=UINT(*args,**dict2)

179 # Make all P fields that haven't already been constructed 180 181

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

183 'Writes this packet to the supplied buffer' 184 self._bufferstartoffset=buf.getcurrentoffset() 185 self.__field_t.writetobuffer(buf) 186 self._bufferendoffset=buf.getcurrentoffset() 187 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)

188 189

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

191 'Reads this packet from the supplied buffer' 192 self._bufferstartoffset=buf.getcurrentoffset() 193 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 194 self.__field_t=UINT(**{'sizeinbytes': 1}) 195 self.__field_t.readfrombuffer(buf) 196 self._bufferendoffset=buf.getcurrentoffset()

197 198

199 - def __getfield_t(self):

200 return self.__field_t.getvalue()

201

202 - def __setfield_t(self, value):

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

207

208 - def __delfield_t(self): del self.__field_t

209 210 t=property(__getfield_t, __setfield_t, __delfield_t, None) 211

212 - def iscontainer(self):

213 return True

214

215 - def containerelements(self):

216 yield ('t', self.__field_t, None)

217 218 219 220

221 -class pbslots(BaseProtogenClass):

222 __fields=['slot'] 223

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

225 dict={} 226 # What was supplied to this function 227 dict.update(kwargs) 228 # Parent constructor 229 super(pbslots,self).__init__(**dict) 230 if self.__class__ is pbslots: 231 self._update(args,dict)

232 233

234 - def getfields(self):

235 return self.__fields

236 237

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

239 super(pbslots,self)._update(args,kwargs) 240 keys=kwargs.keys() 241 for key in keys: 242 if key in self.__fields: 243 setattr(self, key, kwargs[key]) 244 del kwargs[key] 245 # Were any unrecognized kwargs passed in? 246 if __debug__: 247 self._complainaboutunusedargs(pbslots,kwargs) 248 if len(args): 249 dict2={ 'length': max_pb_slots, 'elementclass': pbslot } 250 dict2.update(kwargs) 251 kwargs=dict2 252 self.__field_slot=LIST(*args,**dict2)

253 # Make all P fields that haven't already been constructed 254 255

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

257 'Writes this packet to the supplied buffer' 258 self._bufferstartoffset=buf.getcurrentoffset() 259 try: self.__field_slot 260 except: 261 self.__field_slot=LIST(**{ 'length': max_pb_slots, 'elementclass': pbslot }) 262 self.__field_slot.writetobuffer(buf) 263 self._bufferendoffset=buf.getcurrentoffset() 264 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)

265 266

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

268 'Reads this packet from the supplied buffer' 269 self._bufferstartoffset=buf.getcurrentoffset() 270 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 271 self.__field_slot=LIST(**{ 'length': max_pb_slots, 'elementclass': pbslot }) 272 self.__field_slot.readfrombuffer(buf) 273 self._bufferendoffset=buf.getcurrentoffset()

274 275

276 - def __getfield_slot(self):

277 try: self.__field_slot 278 except: 279 self.__field_slot=LIST(**{ 'length': max_pb_slots, 'elementclass': pbslot }) 280 return self.__field_slot.getvalue()

281

282 - def __setfield_slot(self, value):

283 if isinstance(value,LIST): 284 self.__field_slot=value 285 else: 286 self.__field_slot=LIST(value,**{ 'length': max_pb_slots, 'elementclass': pbslot })

287

288 - def __delfield_slot(self): del self.__field_slot

289 290 slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None) 291

292 - def iscontainer(self):

293 return True

294

295 - def containerelements(self):

296 yield ('slot', self.__field_slot, None)

297 298 299 300

301 -class pbentry(BaseProtogenClass):

302 __fields=['c0', 'mem_index', 'c3', 'speed_dial_index', 'home_num_index', 'office_num_index', 'mobile_num_index', 'pager_num_index', 'fax_num_index', 'alias_num_index', 'unused_index', 'email_index', 'name', 'c4', 'ringer_type', 'group_num', 'c5'] 303

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

305 dict={} 306 # What was supplied to this function 307 dict.update(kwargs) 308 # Parent constructor 309 super(pbentry,self).__init__(**dict) 310 if self.__class__ is pbentry: 311 self._update(args,dict)

312 313

314 - def getfields(self):

315 return self.__fields

316 317

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

319 super(pbentry,self)._update(args,kwargs) 320 keys=kwargs.keys() 321 for key in keys: 322 if key in self.__fields: 323 setattr(self, key, kwargs[key]) 324 del kwargs[key] 325 # Were any unrecognized kwargs passed in? 326 if __debug__: 327 self._complainaboutunusedargs(pbentry,kwargs) 328 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)

329 # Make all P fields that haven't already been constructed 330 331

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

333 'Writes this packet to the supplied buffer' 334 self._bufferstartoffset=buf.getcurrentoffset() 335 self.__field_c0.writetobuffer(buf) 336 self.__field_mem_index.writetobuffer(buf) 337 self.__field_c3.writetobuffer(buf) 338 self.__field_speed_dial_index.writetobuffer(buf) 339 self.__field_home_num_index.writetobuffer(buf) 340 self.__field_office_num_index.writetobuffer(buf) 341 self.__field_mobile_num_index.writetobuffer(buf) 342 self.__field_pager_num_index.writetobuffer(buf) 343 self.__field_fax_num_index.writetobuffer(buf) 344 self.__field_alias_num_index.writetobuffer(buf) 345 self.__field_unused_index.writetobuffer(buf) 346 self.__field_email_index.writetobuffer(buf) 347 self.__field_name.writetobuffer(buf) 348 self.__field_c4.writetobuffer(buf) 349 self.__field_ringer_type.writetobuffer(buf) 350 self.__field_group_num.writetobuffer(buf) 351 try: self.__field_c5 352 except: 353 self.__field_c5=LIST(**{'elementclass': _gen_p_samsungscha650_64, 'length': 7 }) 354 self.__field_c5.writetobuffer(buf) 355 self._bufferendoffset=buf.getcurrentoffset() 356 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)

357 358

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

360 'Reads this packet from the supplied buffer' 361 self._bufferstartoffset=buf.getcurrentoffset() 362 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 363 self.__field_c0=UINT(**{'sizeinbytes': 1}) 364 self.__field_c0.readfrombuffer(buf) 365 self.__field_mem_index=UINT(**{'sizeinbytes': 2}) 366 self.__field_mem_index.readfrombuffer(buf) 367 self.__field_c3=UINT(**{'sizeinbytes': 1}) 368 self.__field_c3.readfrombuffer(buf) 369 self.__field_speed_dial_index=UINT(**{'sizeinbytes': 2}) 370 self.__field_speed_dial_index.readfrombuffer(buf) 371 self.__field_home_num_index=UINT(**{'sizeinbytes': 2}) 372 self.__field_home_num_index.readfrombuffer(buf) 373 self.__field_office_num_index=UINT(**{'sizeinbytes': 2}) 374 self.__field_office_num_index.readfrombuffer(buf) 375 self.__field_mobile_num_index=UINT(**{'sizeinbytes': 2}) 376 self.__field_mobile_num_index.readfrombuffer(buf) 377 self.__field_pager_num_index=UINT(**{'sizeinbytes': 2}) 378 self.__field_pager_num_index.readfrombuffer(buf) 379 self.__field_fax_num_index=UINT(**{'sizeinbytes': 2}) 380 self.__field_fax_num_index.readfrombuffer(buf) 381 self.__field_alias_num_index=UINT(**{'sizeinbytes': 2}) 382 self.__field_alias_num_index.readfrombuffer(buf) 383 self.__field_unused_index=UINT(**{'sizeinbytes': 2}) 384 self.__field_unused_index.readfrombuffer(buf) 385 self.__field_email_index=UINT(**{'sizeinbytes': 2}) 386 self.__field_email_index.readfrombuffer(buf) 387 self.__field_name=USTRING(**{'sizeinbytes': 22, 'raiseonunterminatedread': False }) 388 self.__field_name.readfrombuffer(buf) 389 self.__field_c4=UINT(**{'sizeinbytes': 1}) 390 self.__field_c4.readfrombuffer(buf) 391 self.__field_ringer_type=UINT(**{'sizeinbytes': 1}) 392 self.__field_ringer_type.readfrombuffer(buf) 393 self.__field_group_num=UINT(**{'sizeinbytes': 1}) 394 self.__field_group_num.readfrombuffer(buf) 395 self.__field_c5=LIST(**{'elementclass': _gen_p_samsungscha650_64, 'length': 7 }) 396 self.__field_c5.readfrombuffer(buf) 397 self._bufferendoffset=buf.getcurrentoffset()

398 399

400 - def __getfield_c0(self):

401 return self.__field_c0.getvalue()

402

403 - def __setfield_c0(self, value):

404 if isinstance(value,UINT): 405 self.__field_c0=value 406 else: 407 self.__field_c0=UINT(value,**{'sizeinbytes': 1})

408

409 - def __delfield_c0(self): del self.__field_c0

410 411 c0=property(__getfield_c0, __setfield_c0, __delfield_c0, None) 412

413 - def __getfield_mem_index(self):

414 return self.__field_mem_index.getvalue()

415

416 - def __setfield_mem_index(self, value):

417 if isinstance(value,UINT): 418 self.__field_mem_index=value 419 else: 420 self.__field_mem_index=UINT(value,**{'sizeinbytes': 2})

421

422 - def __delfield_mem_index(self): del self.__field_mem_index

423 424 mem_index=property(__getfield_mem_index, __setfield_mem_index, __delfield_mem_index, None) 425

426 - def __getfield_c3(self):

427 return self.__field_c3.getvalue()

428

429 - def __setfield_c3(self, value):

430 if isinstance(value,UINT): 431 self.__field_c3=value 432 else: 433 self.__field_c3=UINT(value,**{'sizeinbytes': 1})

434

435 - def __delfield_c3(self): del self.__field_c3

436 437 c3=property(__getfield_c3, __setfield_c3, __delfield_c3, None) 438

439 - def __getfield_speed_dial_index(self):

440 return self.__field_speed_dial_index.getvalue()

441

442 - def __setfield_speed_dial_index(self, value):

443 if isinstance(value,UINT): 444 self.__field_speed_dial_index=value 445 else: 446 self.__field_speed_dial_index=UINT(value,**{'sizeinbytes': 2})

447

448 - def __delfield_speed_dial_index(self): del self.__field_speed_dial_index

449 450 speed_dial_index=property(__getfield_speed_dial_index, __setfield_speed_dial_index, __delfield_speed_dial_index, None) 451

452 - def __getfield_home_num_index(self):

453 return self.__field_home_num_index.getvalue()

454

455 - def __setfield_home_num_index(self, value):

456 if isinstance(value,UINT): 457 self.__field_home_num_index=value 458 else: 459 self.__field_home_num_index=UINT(value,**{'sizeinbytes': 2})

460

461 - def __delfield_home_num_index(self): del self.__field_home_num_index

462 463 home_num_index=property(__getfield_home_num_index, __setfield_home_num_index, __delfield_home_num_index, None) 464

465 - def __getfield_office_num_index(self):

466 return self.__field_office_num_index.getvalue()

467

468 - def __setfield_office_num_index(self, value):

469 if isinstance(value,UINT): 470 self.__field_office_num_index=value 471 else: 472 self.__field_office_num_index=UINT(value,**{'sizeinbytes': 2})

473

474 - def __delfield_office_num_index(self): del self.__field_office_num_index

475 476 office_num_index=property(__getfield_office_num_index, __setfield_office_num_index, __delfield_office_num_index, None) 477

478 - def __getfield_mobile_num_index(self):

479 return self.__field_mobile_num_index.getvalue()

480

481 - def __setfield_mobile_num_index(self, value):

482 if isinstance(value,UINT): 483 self.__field_mobile_num_index=value 484 else: 485 self.__field_mobile_num_index=UINT(value,**{'sizeinbytes': 2})

486

487 - def __delfield_mobile_num_index(self): del self.__field_mobile_num_index

488 489 mobile_num_index=property(__getfield_mobile_num_index, __setfield_mobile_num_index, __delfield_mobile_num_index, None) 490

491 - def __getfield_pager_num_index(self):

492 return self.__field_pager_num_index.getvalue()

493

494 - def __setfield_pager_num_index(self, value):

495 if isinstance(value,UINT): 496 self.__field_pager_num_index=value 497 else: 498 self.__field_pager_num_index=UINT(value,**{'sizeinbytes': 2})

499

500 - def __delfield_pager_num_index(self): del self.__field_pager_num_index

501 502 pager_num_index=property(__getfield_pager_num_index, __setfield_pager_num_index, __delfield_pager_num_index, None) 503

504 - def __getfield_fax_num_index(self):

505 return self.__field_fax_num_index.getvalue()

506

507 - def __setfield_fax_num_index(self, value):

508 if isinstance(value,UINT): 509 self.__field_fax_num_index=value 510 else: 511 self.__field_fax_num_index=UINT(value,**{'sizeinbytes': 2})

512

513 - def __delfield_fax_num_index(self): del self.__field_fax_num_index

514 515 fax_num_index=property(__getfield_fax_num_index, __setfield_fax_num_index, __delfield_fax_num_index, None) 516

517 - def __getfield_alias_num_index(self):

518 return self.__field_alias_num_index.getvalue()

519

520 - def __setfield_alias_num_index(self, value):

521 if isinstance(value,UINT): 522 self.__field_alias_num_index=value 523 else: 524 self.__field_alias_num_index=UINT(value,**{'sizeinbytes': 2})

525

526 - def __delfield_alias_num_index(self): del self.__field_alias_num_index

527 528 alias_num_index=property(__getfield_alias_num_index, __setfield_alias_num_index, __delfield_alias_num_index, None) 529

530 - def __getfield_unused_index(self):

531 return self.__field_unused_index.getvalue()

532

533 - def __setfield_unused_index(self, value):

534 if isinstance(value,UINT): 535 self.__field_unused_index=value 536 else: 537 self.__field_unused_index=UINT(value,**{'sizeinbytes': 2})

538

539 - def __delfield_unused_index(self): del self.__field_unused_index

540 541 unused_index=property(__getfield_unused_index, __setfield_unused_index, __delfield_unused_index, None) 542

543 - def __getfield_email_index(self):

544 return self.__field_email_index.getvalue()

545

546 - def __setfield_email_index(self, value):

547 if isinstance(value,UINT): 548 self.__field_email_index=value 549 else: 550 self.__field_email_index=UINT(value,**{'sizeinbytes': 2})

551

552 - def __delfield_email_index(self): del self.__field_email_index

553 554 email_index=property(__getfield_email_index, __setfield_email_index, __delfield_email_index, None) 555

556 - def __getfield_name(self):

557 return self.__field_name.getvalue()

558

559 - def __setfield_name(self, value):

560 if isinstance(value,USTRING): 561 self.__field_name=value 562 else: 563 self.__field_name=USTRING(value,**{'sizeinbytes': 22, 'raiseonunterminatedread': False })

564

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

566 567 name=property(__getfield_name, __setfield_name, __delfield_name, None) 568

569 - def __getfield_c4(self):

570 return self.__field_c4.getvalue()

571

572 - def __setfield_c4(self, value):

573 if isinstance(value,UINT): 574 self.__field_c4=value 575 else: 576 self.__field_c4=UINT(value,**{'sizeinbytes': 1})

577

578 - def __delfield_c4(self): del self.__field_c4

579 580 c4=property(__getfield_c4, __setfield_c4, __delfield_c4, None) 581

582 - def __getfield_ringer_type(self):

583 return self.__field_ringer_type.getvalue()

584

585 - def __setfield_ringer_type(self, value):

586 if isinstance(value,UINT): 587 self.__field_ringer_type=value 588 else: 589 self.__field_ringer_type=UINT(value,**{'sizeinbytes': 1})

590

591 - def __delfield_ringer_type(self): del self.__field_ringer_type

592 593 ringer_type=property(__getfield_ringer_type, __setfield_ringer_type, __delfield_ringer_type, None) 594

595 - def __getfield_group_num(self):

596 return self.__field_group_num.getvalue()

597

598 - def __setfield_group_num(self, value):

599 if isinstance(value,UINT): 600 self.__field_group_num=value 601 else: 602 self.__field_group_num=UINT(value,**{'sizeinbytes': 1})

603

604 - def __delfield_group_num(self): del self.__field_group_num

605 606 group_num=property(__getfield_group_num, __setfield_group_num, __delfield_group_num, None) 607

608 - def __getfield_c5(self):

609 try: self.__field_c5 610 except: 611 self.__field_c5=LIST(**{'elementclass': _gen_p_samsungscha650_64, 'length': 7 }) 612 return self.__field_c5.getvalue()

613

614 - def __setfield_c5(self, value):

615 if isinstance(value,LIST): 616 self.__field_c5=value 617 else: 618 self.__field_c5=LIST(value,**{'elementclass': _gen_p_samsungscha650_64, 'length': 7 })

619

620 - def __delfield_c5(self): del self.__field_c5

621 622 c5=property(__getfield_c5, __setfield_c5, __delfield_c5, None) 623

624 - def iscontainer(self):

625 return True

626

627 - def containerelements(self):

628 yield ('c0', self.__field_c0, None) 629 yield ('mem_index', self.__field_mem_index, None) 630 yield ('c3', self.__field_c3, None) 631 yield ('speed_dial_index', self.__field_speed_dial_index, None) 632 yield ('home_num_index', self.__field_home_num_index, None) 633 yield ('office_num_index', self.__field_office_num_index, None) 634 yield ('mobile_num_index', self.__field_mobile_num_index, None) 635 yield ('pager_num_index', self.__field_pager_num_index, None) 636 yield ('fax_num_index', self.__field_fax_num_index, None) 637 yield ('alias_num_index', self.__field_alias_num_index, None) 638 yield ('unused_index', self.__field_unused_index, None) 639 yield ('email_index', self.__field_email_index, None) 640 yield ('name', self.__field_name, None) 641 yield ('c4', self.__field_c4, None) 642 yield ('ringer_type', self.__field_ringer_type, None) 643 yield ('group_num', self.__field_group_num, None) 644 yield ('c5', self.__field_c5, None)

645 646 647 648

649 -class _gen_p_samsungscha650_64(BaseProtogenClass):

650 'Anonymous inner class' 651 __fields=['c5'] 652

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

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

661 662

663 - def getfields(self):

664 return self.__fields

665 666

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

668 super(_gen_p_samsungscha650_64,self)._update(args,kwargs) 669 keys=kwargs.keys() 670 for key in keys: 671 if key in self.__fields: 672 setattr(self, key, kwargs[key]) 673 del kwargs[key] 674 # Were any unrecognized kwargs passed in? 675 if __debug__: 676 self._complainaboutunusedargs(_gen_p_samsungscha650_64,kwargs) 677 if len(args): 678 dict2={'sizeinbytes': 1} 679 dict2.update(kwargs) 680 kwargs=dict2 681 self.__field_c5=UINT(*args,**dict2)

682 # Make all P fields that haven't already been constructed 683 684

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

686 'Writes this packet to the supplied buffer' 687 self._bufferstartoffset=buf.getcurrentoffset() 688 self.__field_c5.writetobuffer(buf) 689 self._bufferendoffset=buf.getcurrentoffset() 690 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)

691 692

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

694 'Reads this packet from the supplied buffer' 695 self._bufferstartoffset=buf.getcurrentoffset() 696 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 697 self.__field_c5=UINT(**{'sizeinbytes': 1}) 698 self.__field_c5.readfrombuffer(buf) 699 self._bufferendoffset=buf.getcurrentoffset()

700 701

702 - def __getfield_c5(self):

703 return self.__field_c5.getvalue()

704

705 - def __setfield_c5(self, value):

706 if isinstance(value,UINT): 707 self.__field_c5=value 708 else: 709 self.__field_c5=UINT(value,**{'sizeinbytes': 1})

710

711 - def __delfield_c5(self): del self.__field_c5

712 713 c5=property(__getfield_c5, __setfield_c5, __delfield_c5, None) 714

715 - def iscontainer(self):

716 return True

717

718 - def containerelements(self):

719 yield ('c5', self.__field_c5, None)

720 721 722 723

724 -class pbbook(BaseProtogenClass):

725 __fields=['entry'] 726

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

728 dict={} 729 # What was supplied to this function 730 dict.update(kwargs) 731 # Parent constructor 732 super(pbbook,self).__init__(**dict) 733 if self.__class__ is pbbook: 734 self._update(args,dict)

735 736

737 - def getfields(self):

738 return self.__fields

739 740

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

742 super(pbbook,self)._update(args,kwargs) 743 keys=kwargs.keys() 744 for key in keys: 745 if key in self.__fields: 746 setattr(self, key, kwargs[key]) 747 del kwargs[key] 748 # Were any unrecognized kwargs passed in? 749 if __debug__: 750 self._complainaboutunusedargs(pbbook,kwargs) 751 if len(args): 752 dict2={ 'length': max_pb_entries, 'elementclass': pbentry } 753 dict2.update(kwargs) 754 kwargs=dict2 755 self.__field_entry=LIST(*args,**dict2)

756 # Make all P fields that haven't already been constructed 757 758

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

760 'Writes this packet to the supplied buffer' 761 self._bufferstartoffset=buf.getcurrentoffset() 762 try: self.__field_entry 763 except: 764 self.__field_entry=LIST(**{ 'length': max_pb_entries, 'elementclass': pbentry }) 765 self.__field_entry.writetobuffer(buf) 766 self._bufferendoffset=buf.getcurrentoffset() 767 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)

768 769

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

771 'Reads this packet from the supplied buffer' 772 self._bufferstartoffset=buf.getcurrentoffset() 773 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 774 self.__field_entry=LIST(**{ 'length': max_pb_entries, 'elementclass': pbentry }) 775 self.__field_entry.readfrombuffer(buf) 776 self._bufferendoffset=buf.getcurrentoffset()

777 778

779 - def __getfield_entry(self):

780 try: self.__field_entry 781 except: 782 self.__field_entry=LIST(**{ 'length': max_pb_entries, 'elementclass': pbentry }) 783 return self.__field_entry.getvalue()

784

785 - def __setfield_entry(self, value):

786 if isinstance(value,LIST): 787 self.__field_entry=value 788 else: 789 self.__field_entry=LIST(value,**{ 'length': max_pb_entries, 'elementclass': pbentry })

790

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

792 793 entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None) 794

795 - def iscontainer(self):

796 return True

797

798 - def containerelements(self):

799 yield ('entry', self.__field_entry, None)

800 801 802 803

804 -class number(BaseProtogenClass):

805 __fields=['valid', 'type', 'length', 'name', 'pb_index'] 806

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

808 dict={} 809 # What was supplied to this function 810 dict.update(kwargs) 811 # Parent constructor 812 super(number,self).__init__(**dict) 813 if self.__class__ is number: 814 self._update(args,dict)

815 816

817 - def getfields(self):

818 return self.__fields

819 820

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

822 super(number,self)._update(args,kwargs) 823 keys=kwargs.keys() 824 for key in keys: 825 if key in self.__fields: 826 setattr(self, key, kwargs[key]) 827 del kwargs[key] 828 # Were any unrecognized kwargs passed in? 829 if __debug__: 830 self._complainaboutunusedargs(number,kwargs) 831 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)

832 # Make all P fields that haven't already been constructed 833 834

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

836 'Writes this packet to the supplied buffer' 837 self._bufferstartoffset=buf.getcurrentoffset() 838 self.__field_valid.writetobuffer(buf) 839 self.__field_type.writetobuffer(buf) 840 self.__field_length.writetobuffer(buf) 841 self.__field_name.writetobuffer(buf) 842 self.__field_pb_index.writetobuffer(buf) 843 self._bufferendoffset=buf.getcurrentoffset() 844 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)

845 846

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

848 'Reads this packet from the supplied buffer' 849 self._bufferstartoffset=buf.getcurrentoffset() 850 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 851 self.__field_valid=UINT(**{'sizeinbytes': 2}) 852 self.__field_valid.readfrombuffer(buf) 853 self.__field_type=UINT(**{'sizeinbytes': 2}) 854 self.__field_type.readfrombuffer(buf) 855 self.__field_length=UINT(**{'sizeinbytes': 1}) 856 self.__field_length.readfrombuffer(buf) 857 self.__field_name=USTRING(**{'sizeinbytes': 49, 'raiseonunterminatedread': False }) 858 self.__field_name.readfrombuffer(buf) 859 self.__field_pb_index=UINT(**{'sizeinbytes': 2}) 860 self.__field_pb_index.readfrombuffer(buf) 861 self._bufferendoffset=buf.getcurrentoffset()

862 863

864 - def __getfield_valid(self):

865 return self.__field_valid.getvalue()

866

867 - def __setfield_valid(self, value):

868 if isinstance(value,UINT): 869 self.__field_valid=value 870 else: 871 self.__field_valid=UINT(value,**{'sizeinbytes': 2})

872

873 - def __delfield_valid(self): del self.__field_valid

874 875 valid=property(__getfield_valid, __setfield_valid, __delfield_valid, None) 876

877 - def __getfield_type(self):

878 return self.__field_type.getvalue()

879

880 - def __setfield_type(self, value):

881 if isinstance(value,UINT): 882 self.__field_type=value 883 else: 884 self.__field_type=UINT(value,**{'sizeinbytes': 2})

885

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

887 888 type=property(__getfield_type, __setfield_type, __delfield_type, None) 889

890 - def __getfield_length(self):

891 return self.__field_length.getvalue()

892

893 - def __setfield_length(self, value):

894 if isinstance(value,UINT): 895 self.__field_length=value 896 else: 897 self.__field_length=UINT(value,**{'sizeinbytes': 1})

898

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

900 901 length=property(__getfield_length, __setfield_length, __delfield_length, None) 902

903 - def __getfield_name(self):

904 return self.__field_name.getvalue()

905

906 - def __setfield_name(self, value):

907 if isinstance(value,USTRING): 908 self.__field_name=value 909 else: 910 self.__field_name=USTRING(value,**{'sizeinbytes': 49, 'raiseonunterminatedread': False })

911

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

913 914 name=property(__getfield_name, __setfield_name, __delfield_name, None) 915

916 - def __getfield_pb_index(self):

917 return self.__field_pb_index.getvalue()

918

919 - def __setfield_pb_index(self, value):

920 if isinstance(value,UINT): 921 self.__field_pb_index=value 922 else: 923 self.__field_pb_index=UINT(value,**{'sizeinbytes': 2})

924

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

926 927 pb_index=property(__getfield_pb_index, __setfield_pb_index, __delfield_pb_index, None) 928

929 - def iscontainer(self):

930 return True

931

932 - def containerelements(self):

933 yield ('valid', self.__field_valid, None) 934 yield ('type', self.__field_type, None) 935 yield ('length', self.__field_length, None) 936 yield ('name', self.__field_name, None) 937 yield ('pb_index', self.__field_pb_index, None)

938 939 940 941

942 -class numbers(BaseProtogenClass):

943 __fields=['entry'] 944

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

946 dict={} 947 # What was supplied to this function 948 dict.update(kwargs) 949 # Parent constructor 950 super(numbers,self).__init__(**dict) 951 if self.__class__ is numbers: 952 self._update(args,dict)

953 954

955 - def getfields(self):

956 return self.__fields

957 958

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

960 super(numbers,self)._update(args,kwargs) 961 keys=kwargs.keys() 962 for key in keys: 963 if key in self.__fields: 964 setattr(self, key, kwargs[key]) 965 del kwargs[key] 966 # Were any unrecognized kwargs passed in? 967 if __debug__: 968 self._complainaboutunusedargs(numbers,kwargs) 969 if len(args): 970 dict2={ 'length': max_number_entries, 'elementclass': number } 971 dict2.update(kwargs) 972 kwargs=dict2 973 self.__field_entry=LIST(*args,**dict2)

974 # Make all P fields that haven't already been constructed 975 976

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

978 'Writes this packet to the supplied buffer' 979 self._bufferstartoffset=buf.getcurrentoffset() 980 try: self.__field_entry 981 except: 982 self.__field_entry=LIST(**{ 'length': max_number_entries, 'elementclass': number }) 983 self.__field_entry.writetobuffer(buf) 984 self._bufferendoffset=buf.getcurrentoffset() 985 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)

986 987

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

989 'Reads this packet from the supplied buffer' 990 self._bufferstartoffset=buf.getcurrentoffset() 991 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 992 self.__field_entry=LIST(**{ 'length': max_number_entries, 'elementclass': number }) 993 self.__field_entry.readfrombuffer(buf) 994 self._bufferendoffset=buf.getcurrentoffset()

995 996

997 - def __getfield_entry(self):

998 try: self.__field_entry 999 except: 1000 self.__field_entry=LIST(**{ 'length': max_number_entries, 'elementclass': number }) 1001 return self.__field_entry.getvalue()

1002

1003 - def __setfield_entry(self, value):

1004 if isinstance(value,LIST): 1005 self.__field_entry=value 1006 else: 1007 self.__field_entry=LIST(value,**{ 'length': max_number_entries, 'elementclass': number })

1008

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

1010 1011 entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None) 1012

1013 - def iscontainer(self):

1014 return True

1015

1016 - def containerelements(self):

1017 yield ('entry', self.__field_entry, None)

1018 1019 1020 1021

1022 -class ringtone(BaseProtogenClass):

1023 __fields=['c0', 'index', 'c1', 'assignment', 'c2', 'name', 'name_len', 'file_name', 'file_name_len', 'c3'] 1024

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

1026 dict={} 1027 # What was supplied to this function 1028 dict.update(kwargs) 1029 # Parent constructor 1030 super(ringtone,self).__init__(**dict) 1031 if self.__class__ is ringtone: 1032 self._update(args,dict)

1033 1034

1035 - def getfields(self):

1036 return self.__fields

1037 1038

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

1040 super(ringtone,self)._update(args,kwargs) 1041 keys=kwargs.keys() 1042 for key in keys: 1043 if key in self.__fields: 1044 setattr(self, key, kwargs[key]) 1045 del kwargs[key] 1046 # Were any unrecognized kwargs passed in? 1047 if __debug__: 1048 self._complainaboutunusedargs(ringtone,kwargs) 1049 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)

1050 # Make all P fields that haven't already been constructed 1051 1052

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

1054 'Writes this packet to the supplied buffer' 1055 self._bufferstartoffset=buf.getcurrentoffset() 1056 self.__field_c0.writetobuffer(buf) 1057 self.__field_index.writetobuffer(buf) 1058 self.__field_c1.writetobuffer(buf) 1059 self.__field_assignment.writetobuffer(buf) 1060 self.__field_c2.writetobuffer(buf) 1061 self.__field_name.writetobuffer(buf) 1062 self.__field_name_len.writetobuffer(buf) 1063 self.__field_file_name.writetobuffer(buf) 1064 self.__field_file_name_len.writetobuffer(buf) 1065 self.__field_c3.writetobuffer(buf) 1066 self._bufferendoffset=buf.getcurrentoffset() 1067 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)

1068 1069

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

1071 'Reads this packet from the supplied buffer' 1072 self._bufferstartoffset=buf.getcurrentoffset() 1073 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 1074 self.__field_c0=UINT(**{'sizeinbytes': 1}) 1075 self.__field_c0.readfrombuffer(buf) 1076 self.__field_index=UINT(**{'sizeinbytes': 1}) 1077 self.__field_index.readfrombuffer(buf) 1078 self.__field_c1=UINT(**{'sizeinbytes': 1}) 1079 self.__field_c1.readfrombuffer(buf) 1080 self.__field_assignment=UINT(**{'sizeinbytes': 1}) 1081 self.__field_assignment.readfrombuffer(buf) 1082 self.__field_c2=UINT(**{'sizeinbytes': 1}) 1083 self.__field_c2.readfrombuffer(buf) 1084 self.__field_name=USTRING(**{'sizeinbytes': 17, 'raiseonunterminatedread': False }) 1085 self.__field_name.readfrombuffer(buf) 1086 self.__field_name_len=UINT(**{'sizeinbytes': 1}) 1087 self.__field_name_len.readfrombuffer(buf) 1088 self.__field_file_name=USTRING(**{'sizeinbytes': 46, 'raiseonunterminatedread': False }) 1089 self.__field_file_name.readfrombuffer(buf) 1090 self.__field_file_name_len=UINT(**{'sizeinbytes': 1}) 1091 self.__field_file_name_len.readfrombuffer(buf) 1092 self.__field_c3=UINT(**{'sizeinbytes': 2}) 1093 self.__field_c3.readfrombuffer(buf) 1094 self._bufferendoffset=buf.getcurrentoffset()

1095 1096

1097 - def __getfield_c0(self):

1098 return self.__field_c0.getvalue()

1099

1100 - def __setfield_c0(self, value):

1101 if isinstance(value,UINT): 1102 self.__field_c0=value 1103 else: 1104 self.__field_c0=UINT(value,**{'sizeinbytes': 1})

1105

1106 - def __delfield_c0(self): del self.__field_c0

1107 1108 c0=property(__getfield_c0, __setfield_c0, __delfield_c0, None) 1109

1110 - def __getfield_index(self):

1111 return self.__field_index.getvalue()

1112

1113 - def __setfield_index(self, value):

1114 if isinstance(value,UINT): 1115 self.__field_index=value 1116 else: 1117 self.__field_index=UINT(value,**{'sizeinbytes': 1})

1118

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

1120 1121 index=property(__getfield_index, __setfield_index, __delfield_index, None) 1122

1123 - def __getfield_c1(self):

1124 return self.__field_c1.getvalue()

1125

1126 - def __setfield_c1(self, value):

1127 if isinstance(value,UINT): 1128 self.__field_c1=value 1129 else: 1130 self.__field_c1=UINT(value,**{'sizeinbytes': 1})

1131

1132 - def __delfield_c1(self): del self.__field_c1

1133 1134 c1=property(__getfield_c1, __setfield_c1, __delfield_c1, None) 1135

1136 - def __getfield_assignment(self):

1137 return self.__field_assignment.getvalue()

1138

1139 - def __setfield_assignment(self, value):

1140 if isinstance(value,UINT): 1141 self.__field_assignment=value 1142 else: 1143 self.__field_assignment=UINT(value,**{'sizeinbytes': 1})

1144

1145 - def __delfield_assignment(self): del self.__field_assignment

1146 1147 assignment=property(__getfield_assignment, __setfield_assignment, __delfield_assignment, None) 1148

1149 - def __getfield_c2(self):

1150 return self.__field_c2.getvalue()

1151

1152 - def __setfield_c2(self, value):

1153 if isinstance(value,UINT): 1154 self.__field_c2=value 1155 else: 1156 self.__field_c2=UINT(value,**{'sizeinbytes': 1})

1157

1158 - def __delfield_c2(self): del self.__field_c2

1159 1160 c2=property(__getfield_c2, __setfield_c2, __delfield_c2, None) 1161

1162 - def __getfield_name(self):

1163 return self.__field_name.getvalue()

1164

1165 - def __setfield_name(self, value):

1166 if isinstance(value,USTRING): 1167 self.__field_name=value 1168 else: 1169 self.__field_name=USTRING(value,**{'sizeinbytes': 17, 'raiseonunterminatedread': False })

1170

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

1172 1173 name=property(__getfield_name, __setfield_name, __delfield_name, None) 1174

1175 - def __getfield_name_len(self):

1176 return self.__field_name_len.getvalue()

1177

1178 - def __setfield_name_len(self, value):

1179 if isinstance(value,UINT): 1180 self.__field_name_len=value 1181 else: 1182 self.__field_name_len=UINT(value,**{'sizeinbytes': 1})

1183

1184 - def __delfield_name_len(self): del self.__field_name_len

1185 1186 name_len=property(__getfield_name_len, __setfield_name_len, __delfield_name_len, None) 1187

1188 - def __getfield_file_name(self):

1189 return self.__field_file_name.getvalue()

1190

1191 - def __setfield_file_name(self, value):

1192 if isinstance(value,USTRING): 1193 self.__field_file_name=value 1194 else: 1195 self.__field_file_name=USTRING(value,**{'sizeinbytes': 46, 'raiseonunterminatedread': False })

1196

1197 - def __delfield_file_name(self): del self.__field_file_name

1198 1199 file_name=property(__getfield_file_name, __setfield_file_name, __delfield_file_name, None) 1200

1201 - def __getfield_file_name_len(self):

1202 return self.__field_file_name_len.getvalue()

1203

1204 - def __setfield_file_name_len(self, value):

1205 if isinstance(value,UINT): 1206 self.__field_file_name_len=value 1207 else: 1208 self.__field_file_name_len=UINT(value,**{'sizeinbytes': 1})

1209

1210 - def __delfield_file_name_len(self): del self.__field_file_name_len

1211 1212 file_name_len=property(__getfield_file_name_len, __setfield_file_name_len, __delfield_file_name_len, None) 1213

1214 - def __getfield_c3(self):

1215 return self.__field_c3.getvalue()

1216

1217 - def __setfield_c3(self, value):

1218 if isinstance(value,UINT): 1219 self.__field_c3=value 1220 else: 1221 self.__field_c3=UINT(value,**{'sizeinbytes': 2})

1222

1223 - def __delfield_c3(self): del self.__field_c3

1224 1225 c3=property(__getfield_c3, __setfield_c3, __delfield_c3, None) 1226

1227 - def iscontainer(self):

1228 return True

1229

1230 - def containerelements(self):

1231 yield ('c0', self.__field_c0, None) 1232 yield ('index', self.__field_index, None) 1233 yield ('c1', self.__field_c1, None) 1234 yield ('assignment', self.__field_assignment, None) 1235 yield ('c2', self.__field_c2, None) 1236 yield ('name', self.__field_name, None) 1237 yield ('name_len', self.__field_name_len, None) 1238 yield ('file_name', self.__field_file_name, None) 1239 yield ('file_name_len', self.__field_file_name_len, None) 1240 yield ('c3', self.__field_c3, None)

1241 1242 1243 1244

1245 -class ringtones(BaseProtogenClass):

1246 __fields=['entry'] 1247

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

1249 dict={} 1250 # What was supplied to this function 1251 dict.update(kwargs) 1252 # Parent constructor 1253 super(ringtones,self).__init__(**dict) 1254 if self.__class__ is ringtones: 1255 self._update(args,dict)

1256 1257

1258 - def getfields(self):

1259 return self.__fields

1260 1261

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

1263 super(ringtones,self)._update(args,kwargs) 1264 keys=kwargs.keys() 1265 for key in keys: 1266 if key in self.__fields: 1267 setattr(self, key, kwargs[key]) 1268 del kwargs[key] 1269 # Were any unrecognized kwargs passed in? 1270 if __debug__: 1271 self._complainaboutunusedargs(ringtones,kwargs) 1272 if len(args): 1273 dict2={ 'length': max_ringtone_entries, 'elementclass': ringtone } 1274 dict2.update(kwargs) 1275 kwargs=dict2 1276 self.__field_entry=LIST(*args,**dict2)

1277 # Make all P fields that haven't already been constructed 1278 1279

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

1281 'Writes this packet to the supplied buffer' 1282 self._bufferstartoffset=buf.getcurrentoffset() 1283 self.__field_entry.writetobuffer(buf) 1284 self._bufferendoffset=buf.getcurrentoffset() 1285 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)

1286 1287

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

1289 'Reads this packet from the supplied buffer' 1290 self._bufferstartoffset=buf.getcurrentoffset() 1291 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 1292 self.__field_entry=LIST(**{ 'length': max_ringtone_entries, 'elementclass': ringtone }) 1293 self.__field_entry.readfrombuffer(buf) 1294 self._bufferendoffset=buf.getcurrentoffset()

1295 1296

1297 - def __getfield_entry(self):

1298 return self.__field_entry.getvalue()

1299

1300 - def __setfield_entry(self, value):

1301 if isinstance(value,LIST): 1302 self.__field_entry=value 1303 else: 1304 self.__field_entry=LIST(value,**{ 'length': max_ringtone_entries, 'elementclass': ringtone })

1305

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

1307 1308 entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None) 1309

1310 - def iscontainer(self):

1311 return True

1312

1313 - def containerelements(self):

1314 yield ('entry', self.__field_entry, None)

1315 1316 1317 1318

1319 -class image(BaseProtogenClass):

1320 __fields=['c0', 'index', 'c1', 'assignment', 'name', 'name_len', 'file_name', 'file_name_len', 'c2'] 1321

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

1323 dict={} 1324 # What was supplied to this function 1325 dict.update(kwargs) 1326 # Parent constructor 1327 super(image,self).__init__(**dict) 1328 if self.__class__ is image: 1329 self._update(args,dict)

1330 1331

1332 - def getfields(self):

1333 return self.__fields

1334 1335

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

1337 super(image,self)._update(args,kwargs) 1338 keys=kwargs.keys() 1339 for key in keys: 1340 if key in self.__fields: 1341 setattr(self, key, kwargs[key]) 1342 del kwargs[key] 1343 # Were any unrecognized kwargs passed in? 1344 if __debug__: 1345 self._complainaboutunusedargs(image,kwargs) 1346 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)

1347 # Make all P fields that haven't already been constructed 1348 1349

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

1351 'Writes this packet to the supplied buffer' 1352 self._bufferstartoffset=buf.getcurrentoffset() 1353 self.__field_c0.writetobuffer(buf) 1354 self.__field_index.writetobuffer(buf) 1355 self.__field_c1.writetobuffer(buf) 1356 self.__field_assignment.writetobuffer(buf) 1357 self.__field_name.writetobuffer(buf) 1358 self.__field_name_len.writetobuffer(buf) 1359 self.__field_file_name.writetobuffer(buf) 1360 self.__field_file_name_len.writetobuffer(buf) 1361 self.__field_c2.writetobuffer(buf) 1362 self._bufferendoffset=buf.getcurrentoffset() 1363 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)

1364 1365

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

1367 'Reads this packet from the supplied buffer' 1368 self._bufferstartoffset=buf.getcurrentoffset() 1369 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 1370 self.__field_c0=UINT(**{'sizeinbytes': 1}) 1371 self.__field_c0.readfrombuffer(buf) 1372 self.__field_index=UINT(**{'sizeinbytes': 1}) 1373 self.__field_index.readfrombuffer(buf) 1374 self.__field_c1=UINT(**{'sizeinbytes': 1}) 1375 self.__field_c1.readfrombuffer(buf) 1376 self.__field_assignment=UINT(**{'sizeinbytes': 1}) 1377 self.__field_assignment.readfrombuffer(buf) 1378 self.__field_name=USTRING(**{'sizeinbytes': 17, 'raiseonunterminatedread': False }) 1379 self.__field_name.readfrombuffer(buf) 1380 self.__field_name_len=UINT(**{'sizeinbytes': 1}) 1381 self.__field_name_len.readfrombuffer(buf) 1382 self.__field_file_name=USTRING(**{'sizeinbytes': 46, 'raiseonunterminatedread': False }) 1383 self.__field_file_name.readfrombuffer(buf) 1384 self.__field_file_name_len=UINT(**{'sizeinbytes': 1}) 1385 self.__field_file_name_len.readfrombuffer(buf) 1386 self.__field_c2=UINT(**{'sizeinbytes': 2}) 1387 self.__field_c2.readfrombuffer(buf) 1388 self._bufferendoffset=buf.getcurrentoffset()

1389 1390

1391 - def __getfield_c0(self):

1392 return self.__field_c0.getvalue()

1393

1394 - def __setfield_c0(self, value):

1395 if isinstance(value,UINT): 1396 self.__field_c0=value 1397 else: 1398 self.__field_c0=UINT(value,**{'sizeinbytes': 1})

1399

1400 - def __delfield_c0(self): del self.__field_c0

1401 1402 c0=property(__getfield_c0, __setfield_c0, __delfield_c0, None) 1403

1404 - def __getfield_index(self):

1405 return self.__field_index.getvalue()

1406

1407 - def __setfield_index(self, value):

1408 if isinstance(value,UINT): 1409 self.__field_index=value 1410 else: 1411 self.__field_index=UINT(value,**{'sizeinbytes': 1})

1412

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

1414 1415 index=property(__getfield_index, __setfield_index, __delfield_index, None) 1416

1417 - def __getfield_c1(self):

1418 return self.__field_c1.getvalue()

1419

1420 - def __setfield_c1(self, value):

1421 if isinstance(value,UINT): 1422 self.__field_c1=value 1423 else: 1424 self.__field_c1=UINT(value,**{'sizeinbytes': 1})

1425

1426 - def __delfield_c1(self): del self.__field_c1

1427 1428 c1=property(__getfield_c1, __setfield_c1, __delfield_c1, None) 1429

1430 - def __getfield_assignment(self):

1431 return self.__field_assignment.getvalue()

1432

1433 - def __setfield_assignment(self, value):

1434 if isinstance(value,UINT): 1435 self.__field_assignment=value 1436 else: 1437 self.__field_assignment=UINT(value,**{'sizeinbytes': 1})

1438

1439 - def __delfield_assignment(self): del self.__field_assignment

1440 1441 assignment=property(__getfield_assignment, __setfield_assignment, __delfield_assignment, None) 1442

1443 - def __getfield_name(self):

1444 return self.__field_name.getvalue()

1445

1446 - def __setfield_name(self, value):

1447 if isinstance(value,USTRING): 1448 self.__field_name=value 1449 else: 1450 self.__field_name=USTRING(value,**{'sizeinbytes': 17, 'raiseonunterminatedread': False })

1451

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

1453 1454 name=property(__getfield_name, __setfield_name, __delfield_name, None) 1455

1456 - def __getfield_name_len(self):

1457 return self.__field_name_len.getvalue()

1458

1459 - def __setfield_name_len(self, value):

1460 if isinstance(value,UINT): 1461 self.__field_name_len=value 1462 else: 1463 self.__field_name_len=UINT(value,**{'sizeinbytes': 1})

1464

1465 - def __delfield_name_len(self): del self.__field_name_len

1466 1467 name_len=property(__getfield_name_len, __setfield_name_len, __delfield_name_len, None) 1468

1469 - def __getfield_file_name(self):

1470 return self.__field_file_name.getvalue()

1471

1472 - def __setfield_file_name(self, value):

1473 if isinstance(value,USTRING): 1474 self.__field_file_name=value 1475 else: 1476 self.__field_file_name=USTRING(value,**{'sizeinbytes': 46, 'raiseonunterminatedread': False })

1477

1478 - def __delfield_file_name(self): del self.__field_file_name

1479 1480 file_name=property(__getfield_file_name, __setfield_file_name, __delfield_file_name, None) 1481

1482 - def __getfield_file_name_len(self):

1483 return self.__field_file_name_len.getvalue()

1484

1485 - def __setfield_file_name_len(self, value):

1486 if isinstance(value,UINT): 1487 self.__field_file_name_len=value 1488 else: 1489 self.__field_file_name_len=UINT(value,**{'sizeinbytes': 1})

1490

1491 - def __delfield_file_name_len(self): del self.__field_file_name_len

1492 1493 file_name_len=property(__getfield_file_name_len, __setfield_file_name_len, __delfield_file_name_len, None) 1494

1495 - def __getfield_c2(self):

1496 return self.__field_c2.getvalue()

1497

1498 - def __setfield_c2(self, value):

1499 if isinstance(value,UINT): 1500 self.__field_c2=value 1501 else: 1502 self.__field_c2=UINT(value,**{'sizeinbytes': 2})

1503

1504 - def __delfield_c2(self): del self.__field_c2

1505 1506 c2=property(__getfield_c2, __setfield_c2, __delfield_c2, None) 1507

1508 - def iscontainer(self):

1509 return True

1510

1511 - def containerelements(self):

1512 yield ('c0', self.__field_c0, None) 1513 yield ('index', self.__field_index, None) 1514 yield ('c1', self.__field_c1, None) 1515 yield ('assignment', self.__field_assignment, None) 1516 yield ('name', self.__field_name, None) 1517 yield ('name_len', self.__field_name_len, None) 1518 yield ('file_name', self.__field_file_name, None) 1519 yield ('file_name_len', self.__field_file_name_len, None) 1520 yield ('c2', self.__field_c2, None)

1521 1522 1523 1524

1525 -class images(BaseProtogenClass):

1526 __fields=['entry'] 1527

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

1529 dict={} 1530 # What was supplied to this function 1531 dict.update(kwargs) 1532 # Parent constructor 1533 super(images,self).__init__(**dict) 1534 if self.__class__ is images: 1535 self._update(args,dict)

1536 1537

1538 - def getfields(self):

1539 return self.__fields

1540 1541

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

1543 super(images,self)._update(args,kwargs) 1544 keys=kwargs.keys() 1545 for key in keys: 1546 if key in self.__fields: 1547 setattr(self, key, kwargs[key]) 1548 del kwargs[key] 1549 # Were any unrecognized kwargs passed in? 1550 if __debug__: 1551 self._complainaboutunusedargs(images,kwargs) 1552 if len(args): 1553 dict2={ 'length': max_image_entries, 'elementclass': image } 1554 dict2.update(kwargs) 1555 kwargs=dict2 1556 self.__field_entry=LIST(*args,**dict2)

1557 # Make all P fields that haven't already been constructed 1558 1559

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

1561 'Writes this packet to the supplied buffer' 1562 self._bufferstartoffset=buf.getcurrentoffset() 1563 self.__field_entry.writetobuffer(buf) 1564 self._bufferendoffset=buf.getcurrentoffset() 1565 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)

1566 1567

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

1569 'Reads this packet from the supplied buffer' 1570 self._bufferstartoffset=buf.getcurrentoffset() 1571 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 1572 self.__field_entry=LIST(**{ 'length': max_image_entries, 'elementclass': image }) 1573 self.__field_entry.readfrombuffer(buf) 1574 self._bufferendoffset=buf.getcurrentoffset()

1575 1576

1577 - def __getfield_entry(self):

1578 return self.__field_entry.getvalue()

1579

1580 - def __setfield_entry(self, value):

1581 if isinstance(value,LIST): 1582 self.__field_entry=value 1583 else: 1584 self.__field_entry=LIST(value,**{ 'length': max_image_entries, 'elementclass': image })

1585

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

1587 1588 entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None) 1589

1590 - def iscontainer(self):

1591 return True

1592

1593 - def containerelements(self):

1594 yield ('entry', self.__field_entry, None)

1595

Source Code for Module phones.p_samsungscha650