phones.p_sanyo8100

1 # THIS FILE IS AUTOMATICALLY GENERATED. EDIT THE SOURCE FILE NOT THIS ONE 2 3 """Various descriptions of data specific to Sanyo SCP-8100""" 4 5 from prototypes import * 6 7 # Make all sanyo stuff available in this module as well 8 from p_sanyo import * 9 from p_sanyomedia import * 10 11 # We use LSB for all integer like fields 12 UINT=UINTlsb 13 BOOL=BOOLlsb 14 _NUMPBSLOTS=300 15 _NUMSPEEDDIALS=8 16 _NUMLONGNUMBERS=5 17 _LONGPHONENUMBERLEN=30 18 _NUMEVENTSLOTS=100 19 _NUMCALLALARMSLOTS=15 20 _NUMCALLHISTORY=20 21 _MAXNUMBERLEN=48 22 _MAXEMAILLEN=48 23

24 -class evententry(BaseProtogenClass):

25 __fields=['slot', 'flag', 'eventname', 'pad1', 'eventname_len', 'start', 'end', 'location', 'pad2', 'location_len', 'pad3', 'alarmdiff', 'period', 'dom', 'alarm', 'serial', 'pad4', 'ringtone'] 26

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

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

35 36

37 - def getfields(self):

38 return self.__fields

39 40

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

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

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

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

56 'Writes this packet to the supplied buffer' 57 self._bufferstartoffset=buf.getcurrentoffset() 58 self.__field_slot.writetobuffer(buf) 59 self.__field_flag.writetobuffer(buf) 60 self.__field_eventname.writetobuffer(buf) 61 try: self.__field_pad1 62 except: 63 self.__field_pad1=UNKNOWN(**{'sizeinbytes': 7}) 64 self.__field_pad1.writetobuffer(buf) 65 self.__field_eventname_len.writetobuffer(buf) 66 self.__field_start.writetobuffer(buf) 67 self.__field_end.writetobuffer(buf) 68 self.__field_location.writetobuffer(buf) 69 try: self.__field_pad2 70 except: 71 self.__field_pad2=UNKNOWN(**{'sizeinbytes': 7}) 72 self.__field_pad2.writetobuffer(buf) 73 self.__field_location_len.writetobuffer(buf) 74 try: self.__field_pad3 75 except: 76 self.__field_pad3=UNKNOWN(**{'sizeinbytes': 1}) 77 self.__field_pad3.writetobuffer(buf) 78 self.__field_alarmdiff.writetobuffer(buf) 79 self.__field_period.writetobuffer(buf) 80 self.__field_dom.writetobuffer(buf) 81 self.__field_alarm.writetobuffer(buf) 82 try: self.__field_serial 83 except: 84 self.__field_serial=UINT(**{'sizeinbytes': 1, 'default': 0}) 85 self.__field_serial.writetobuffer(buf) 86 try: self.__field_pad4 87 except: 88 self.__field_pad4=UNKNOWN(**{'sizeinbytes': 3}) 89 self.__field_pad4.writetobuffer(buf) 90 self.__field_ringtone.writetobuffer(buf) 91 self._bufferendoffset=buf.getcurrentoffset() 92 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)

93 94

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

96 'Reads this packet from the supplied buffer' 97 self._bufferstartoffset=buf.getcurrentoffset() 98 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 99 self.__field_slot=UINT(**{'sizeinbytes': 1}) 100 self.__field_slot.readfrombuffer(buf) 101 self.__field_flag=UINT(**{'sizeinbytes': 1}) 102 self.__field_flag.readfrombuffer(buf) 103 self.__field_eventname=USTRING(**{'sizeinbytes': 14, 'raiseonunterminatedread': False, 'raiseontruncate': False, 'terminator': None}) 104 self.__field_eventname.readfrombuffer(buf) 105 self.__field_pad1=UNKNOWN(**{'sizeinbytes': 7}) 106 self.__field_pad1.readfrombuffer(buf) 107 self.__field_eventname_len=UINT(**{'sizeinbytes': 1}) 108 self.__field_eventname_len.readfrombuffer(buf) 109 self.__field_start=UINT(**{'sizeinbytes': 4}) 110 self.__field_start.readfrombuffer(buf) 111 self.__field_end=UINT(**{'sizeinbytes': 4}) 112 self.__field_end.readfrombuffer(buf) 113 self.__field_location=USTRING(**{'sizeinbytes': 14, 'raiseonunterminatedread': False, 'raiseontruncate': False, 'terminator': None}) 114 self.__field_location.readfrombuffer(buf) 115 self.__field_pad2=UNKNOWN(**{'sizeinbytes': 7}) 116 self.__field_pad2.readfrombuffer(buf) 117 self.__field_location_len=UINT(**{'sizeinbytes': 1}) 118 self.__field_location_len.readfrombuffer(buf) 119 self.__field_pad3=UNKNOWN(**{'sizeinbytes': 1}) 120 self.__field_pad3.readfrombuffer(buf) 121 self.__field_alarmdiff=UINT(**{'sizeinbytes': 4}) 122 self.__field_alarmdiff.readfrombuffer(buf) 123 self.__field_period=UINT(**{'sizeinbytes': 1}) 124 self.__field_period.readfrombuffer(buf) 125 self.__field_dom=UINT(**{'sizeinbytes': 1}) 126 self.__field_dom.readfrombuffer(buf) 127 self.__field_alarm=UINT(**{'sizeinbytes': 4}) 128 self.__field_alarm.readfrombuffer(buf) 129 self.__field_serial=UINT(**{'sizeinbytes': 1, 'default': 0}) 130 self.__field_serial.readfrombuffer(buf) 131 self.__field_pad4=UNKNOWN(**{'sizeinbytes': 3}) 132 self.__field_pad4.readfrombuffer(buf) 133 self.__field_ringtone=UINT(**{'sizeinbytes': 1}) 134 self.__field_ringtone.readfrombuffer(buf) 135 self._bufferendoffset=buf.getcurrentoffset()

136 137

138 - def __getfield_slot(self):

139 return self.__field_slot.getvalue()

140

141 - def __setfield_slot(self, value):

142 if isinstance(value,UINT): 143 self.__field_slot=value 144 else: 145 self.__field_slot=UINT(value,**{'sizeinbytes': 1})

146

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

148 149 slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None) 150

151 - def __getfield_flag(self):

152 return self.__field_flag.getvalue()

153

154 - def __setfield_flag(self, value):

155 if isinstance(value,UINT): 156 self.__field_flag=value 157 else: 158 self.__field_flag=UINT(value,**{'sizeinbytes': 1})

159

160 - def __delfield_flag(self): del self.__field_flag

161 162 flag=property(__getfield_flag, __setfield_flag, __delfield_flag, "0: Not used, 1: Scheduled, 2: Already Happened") 163

164 - def __getfield_eventname(self):

165 return self.__field_eventname.getvalue()

166

167 - def __setfield_eventname(self, value):

168 if isinstance(value,USTRING): 169 self.__field_eventname=value 170 else: 171 self.__field_eventname=USTRING(value,**{'sizeinbytes': 14, 'raiseonunterminatedread': False, 'raiseontruncate': False, 'terminator': None})

172

173 - def __delfield_eventname(self): del self.__field_eventname

174 175 eventname=property(__getfield_eventname, __setfield_eventname, __delfield_eventname, None) 176

177 - def __getfield_pad1(self):

178 try: self.__field_pad1 179 except: 180 self.__field_pad1=UNKNOWN(**{'sizeinbytes': 7}) 181 return self.__field_pad1.getvalue()

182

183 - def __setfield_pad1(self, value):

184 if isinstance(value,UNKNOWN): 185 self.__field_pad1=value 186 else: 187 self.__field_pad1=UNKNOWN(value,**{'sizeinbytes': 7})

188

189 - def __delfield_pad1(self): del self.__field_pad1

190 191 pad1=property(__getfield_pad1, __setfield_pad1, __delfield_pad1, None) 192

193 - def __getfield_eventname_len(self):

194 return self.__field_eventname_len.getvalue()

195

196 - def __setfield_eventname_len(self, value):

197 if isinstance(value,UINT): 198 self.__field_eventname_len=value 199 else: 200 self.__field_eventname_len=UINT(value,**{'sizeinbytes': 1})

201

202 - def __delfield_eventname_len(self): del self.__field_eventname_len

203 204 eventname_len=property(__getfield_eventname_len, __setfield_eventname_len, __delfield_eventname_len, None) 205

206 - def __getfield_start(self):

207 return self.__field_start.getvalue()

208

209 - def __setfield_start(self, value):

210 if isinstance(value,UINT): 211 self.__field_start=value 212 else: 213 self.__field_start=UINT(value,**{'sizeinbytes': 4})

214

215 - def __delfield_start(self): del self.__field_start

216 217 start=property(__getfield_start, __setfield_start, __delfield_start, "# seconds since Jan 1, 1980 approximately") 218

219 - def __getfield_end(self):

220 return self.__field_end.getvalue()

221

222 - def __setfield_end(self, value):

223 if isinstance(value,UINT): 224 self.__field_end=value 225 else: 226 self.__field_end=UINT(value,**{'sizeinbytes': 4})

227

228 - def __delfield_end(self): del self.__field_end

229 230 end=property(__getfield_end, __setfield_end, __delfield_end, None) 231

232 - def __getfield_location(self):

233 return self.__field_location.getvalue()

234

235 - def __setfield_location(self, value):

236 if isinstance(value,USTRING): 237 self.__field_location=value 238 else: 239 self.__field_location=USTRING(value,**{'sizeinbytes': 14, 'raiseonunterminatedread': False, 'raiseontruncate': False, 'terminator': None})

240

241 - def __delfield_location(self): del self.__field_location

242 243 location=property(__getfield_location, __setfield_location, __delfield_location, None) 244

245 - def __getfield_pad2(self):

246 try: self.__field_pad2 247 except: 248 self.__field_pad2=UNKNOWN(**{'sizeinbytes': 7}) 249 return self.__field_pad2.getvalue()

250

251 - def __setfield_pad2(self, value):

252 if isinstance(value,UNKNOWN): 253 self.__field_pad2=value 254 else: 255 self.__field_pad2=UNKNOWN(value,**{'sizeinbytes': 7})

256

257 - def __delfield_pad2(self): del self.__field_pad2

258 259 pad2=property(__getfield_pad2, __setfield_pad2, __delfield_pad2, None) 260

261 - def __getfield_location_len(self):

262 return self.__field_location_len.getvalue()

263

264 - def __setfield_location_len(self, value):

265 if isinstance(value,UINT): 266 self.__field_location_len=value 267 else: 268 self.__field_location_len=UINT(value,**{'sizeinbytes': 1})

269

270 - def __delfield_location_len(self): del self.__field_location_len

271 272 location_len=property(__getfield_location_len, __setfield_location_len, __delfield_location_len, None) 273

274 - def __getfield_pad3(self):

275 try: self.__field_pad3 276 except: 277 self.__field_pad3=UNKNOWN(**{'sizeinbytes': 1}) 278 return self.__field_pad3.getvalue()

279

280 - def __setfield_pad3(self, value):

281 if isinstance(value,UNKNOWN): 282 self.__field_pad3=value 283 else: 284 self.__field_pad3=UNKNOWN(value,**{'sizeinbytes': 1})

285

286 - def __delfield_pad3(self): del self.__field_pad3

287 288 pad3=property(__getfield_pad3, __setfield_pad3, __delfield_pad3, None) 289

290 - def __getfield_alarmdiff(self):

291 return self.__field_alarmdiff.getvalue()

292

293 - def __setfield_alarmdiff(self, value):

294 if isinstance(value,UINT): 295 self.__field_alarmdiff=value 296 else: 297 self.__field_alarmdiff=UINT(value,**{'sizeinbytes': 4})

298

299 - def __delfield_alarmdiff(self): del self.__field_alarmdiff

300 301 alarmdiff=property(__getfield_alarmdiff, __setfield_alarmdiff, __delfield_alarmdiff, "Displayed alarm time") 302

303 - def __getfield_period(self):

304 return self.__field_period.getvalue()

305

306 - def __setfield_period(self, value):

307 if isinstance(value,UINT): 308 self.__field_period=value 309 else: 310 self.__field_period=UINT(value,**{'sizeinbytes': 1})

311

312 - def __delfield_period(self): del self.__field_period

313 314 period=property(__getfield_period, __setfield_period, __delfield_period, "No, Daily, Weekly, Monthly, Yearly") 315

316 - def __getfield_dom(self):

317 return self.__field_dom.getvalue()

318

319 - def __setfield_dom(self, value):

320 if isinstance(value,UINT): 321 self.__field_dom=value 322 else: 323 self.__field_dom=UINT(value,**{'sizeinbytes': 1})

324

325 - def __delfield_dom(self): del self.__field_dom

326 327 dom=property(__getfield_dom, __setfield_dom, __delfield_dom, "Day of month for the event") 328

329 - def __getfield_alarm(self):

330 return self.__field_alarm.getvalue()

331

332 - def __setfield_alarm(self, value):

333 if isinstance(value,UINT): 334 self.__field_alarm=value 335 else: 336 self.__field_alarm=UINT(value,**{'sizeinbytes': 4})

337

338 - def __delfield_alarm(self): del self.__field_alarm

339 340 alarm=property(__getfield_alarm, __setfield_alarm, __delfield_alarm, None) 341

342 - def __getfield_serial(self):

343 try: self.__field_serial 344 except: 345 self.__field_serial=UINT(**{'sizeinbytes': 1, 'default': 0}) 346 return self.__field_serial.getvalue()

347

348 - def __setfield_serial(self, value):

349 if isinstance(value,UINT): 350 self.__field_serial=value 351 else: 352 self.__field_serial=UINT(value,**{'sizeinbytes': 1, 'default': 0})

353

354 - def __delfield_serial(self): del self.__field_serial

355 356 serial=property(__getfield_serial, __setfield_serial, __delfield_serial, "Some kind of serial number") 357

358 - def __getfield_pad4(self):

359 try: self.__field_pad4 360 except: 361 self.__field_pad4=UNKNOWN(**{'sizeinbytes': 3}) 362 return self.__field_pad4.getvalue()

363

364 - def __setfield_pad4(self, value):

365 if isinstance(value,UNKNOWN): 366 self.__field_pad4=value 367 else: 368 self.__field_pad4=UNKNOWN(value,**{'sizeinbytes': 3})

369

370 - def __delfield_pad4(self): del self.__field_pad4

371 372 pad4=property(__getfield_pad4, __setfield_pad4, __delfield_pad4, None) 373

374 - def __getfield_ringtone(self):

375 return self.__field_ringtone.getvalue()

376

377 - def __setfield_ringtone(self, value):

378 if isinstance(value,UINT): 379 self.__field_ringtone=value 380 else: 381 self.__field_ringtone=UINT(value,**{'sizeinbytes': 1})

382

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

384 385 ringtone=property(__getfield_ringtone, __setfield_ringtone, __delfield_ringtone, None) 386

387 - def iscontainer(self):

388 return True

389

390 - def containerelements(self):

391 yield ('slot', self.__field_slot, None) 392 yield ('flag', self.__field_flag, "0: Not used, 1: Scheduled, 2: Already Happened") 393 yield ('eventname', self.__field_eventname, None) 394 yield ('pad1', self.__field_pad1, None) 395 yield ('eventname_len', self.__field_eventname_len, None) 396 yield ('start', self.__field_start, "# seconds since Jan 1, 1980 approximately") 397 yield ('end', self.__field_end, None) 398 yield ('location', self.__field_location, None) 399 yield ('pad2', self.__field_pad2, None) 400 yield ('location_len', self.__field_location_len, None) 401 yield ('pad3', self.__field_pad3, None) 402 yield ('alarmdiff', self.__field_alarmdiff, "Displayed alarm time") 403 yield ('period', self.__field_period, "No, Daily, Weekly, Monthly, Yearly") 404 yield ('dom', self.__field_dom, "Day of month for the event") 405 yield ('alarm', self.__field_alarm, None) 406 yield ('serial', self.__field_serial, "Some kind of serial number") 407 yield ('pad4', self.__field_pad4, None) 408 yield ('ringtone', self.__field_ringtone, None)

409 410 411 412

413 -class eventresponse(BaseProtogenClass):

414 __fields=['header', 'entry', 'pad'] 415

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

417 dict={} 418 # What was supplied to this function 419 dict.update(kwargs) 420 # Parent constructor 421 super(eventresponse,self).__init__(**dict) 422 if self.__class__ is eventresponse: 423 self._update(args,dict)

424 425

426 - def getfields(self):

427 return self.__fields

428 429

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

431 super(eventresponse,self)._update(args,kwargs) 432 keys=kwargs.keys() 433 for key in keys: 434 if key in self.__fields: 435 setattr(self, key, kwargs[key]) 436 del kwargs[key] 437 # Were any unrecognized kwargs passed in? 438 if __debug__: 439 self._complainaboutunusedargs(eventresponse,kwargs) 440 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)

441 # Make all P fields that haven't already been constructed 442 443

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

445 'Writes this packet to the supplied buffer' 446 self._bufferstartoffset=buf.getcurrentoffset() 447 self.__field_header.writetobuffer(buf) 448 self.__field_entry.writetobuffer(buf) 449 self.__field_pad.writetobuffer(buf) 450 self._bufferendoffset=buf.getcurrentoffset() 451 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)

452 453

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

455 'Reads this packet from the supplied buffer' 456 self._bufferstartoffset=buf.getcurrentoffset() 457 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 458 self.__field_header=sanyoheader() 459 self.__field_header.readfrombuffer(buf) 460 self.__field_entry=evententry() 461 self.__field_entry.readfrombuffer(buf) 462 self.__field_pad=UNKNOWN(**{'sizeinbytes': 432}) 463 self.__field_pad.readfrombuffer(buf) 464 self._bufferendoffset=buf.getcurrentoffset()

465 466

467 - def __getfield_header(self):

468 return self.__field_header.getvalue()

469

470 - def __setfield_header(self, value):

471 if isinstance(value,sanyoheader): 472 self.__field_header=value 473 else: 474 self.__field_header=sanyoheader(value,)

475

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

477 478 header=property(__getfield_header, __setfield_header, __delfield_header, None) 479

480 - def __getfield_entry(self):

481 return self.__field_entry.getvalue()

482

483 - def __setfield_entry(self, value):

484 if isinstance(value,evententry): 485 self.__field_entry=value 486 else: 487 self.__field_entry=evententry(value,)

488

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

490 491 entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None) 492

493 - def __getfield_pad(self):

494 return self.__field_pad.getvalue()

495

496 - def __setfield_pad(self, value):

497 if isinstance(value,UNKNOWN): 498 self.__field_pad=value 499 else: 500 self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 432})

501

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

503 504 pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None) 505

506 - def iscontainer(self):

507 return True

508

509 - def containerelements(self):

510 yield ('header', self.__field_header, None) 511 yield ('entry', self.__field_entry, None) 512 yield ('pad', self.__field_pad, None)

513 514 515 516

517 -class eventupdaterequest(BaseProtogenClass):

518 __fields=['header', 'entry', 'pad'] 519

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

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

528 529

530 - def getfields(self):

531 return self.__fields

532 533

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

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

545 # Make all P fields that haven't already been constructed 546 547

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

549 'Writes this packet to the supplied buffer' 550 self._bufferstartoffset=buf.getcurrentoffset() 551 try: self.__field_header 552 except: 553 self.__field_header=sanyoheader(**{'readwrite': 0x0e, 'packettype': 0x0c, 'command':0x23}) 554 self.__field_header.writetobuffer(buf) 555 self.__field_entry.writetobuffer(buf) 556 try: self.__field_pad 557 except: 558 self.__field_pad=UNKNOWN(**{'sizeinbytes': 432}) 559 self.__field_pad.writetobuffer(buf) 560 self._bufferendoffset=buf.getcurrentoffset() 561 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)

562 563

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

565 'Reads this packet from the supplied buffer' 566 self._bufferstartoffset=buf.getcurrentoffset() 567 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 568 self.__field_header=sanyoheader(**{'readwrite': 0x0e, 'packettype': 0x0c, 'command':0x23}) 569 self.__field_header.readfrombuffer(buf) 570 self.__field_entry=evententry() 571 self.__field_entry.readfrombuffer(buf) 572 self.__field_pad=UNKNOWN(**{'sizeinbytes': 432}) 573 self.__field_pad.readfrombuffer(buf) 574 self._bufferendoffset=buf.getcurrentoffset()

575 576

577 - def __getfield_header(self):

578 try: self.__field_header 579 except: 580 self.__field_header=sanyoheader(**{'readwrite': 0x0e, 'packettype': 0x0c, 'command':0x23}) 581 return self.__field_header.getvalue()

582

583 - def __setfield_header(self, value):

584 if isinstance(value,sanyoheader): 585 self.__field_header=value 586 else: 587 self.__field_header=sanyoheader(value,**{'readwrite': 0x0e, 'packettype': 0x0c, 'command':0x23})

588

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

590 591 header=property(__getfield_header, __setfield_header, __delfield_header, None) 592

593 - def __getfield_entry(self):

594 return self.__field_entry.getvalue()

595

596 - def __setfield_entry(self, value):

597 if isinstance(value,evententry): 598 self.__field_entry=value 599 else: 600 self.__field_entry=evententry(value,)

601

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

603 604 entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None) 605

606 - def __getfield_pad(self):

607 try: self.__field_pad 608 except: 609 self.__field_pad=UNKNOWN(**{'sizeinbytes': 432}) 610 return self.__field_pad.getvalue()

611

612 - def __setfield_pad(self, value):

613 if isinstance(value,UNKNOWN): 614 self.__field_pad=value 615 else: 616 self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 432})

617

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

619 620 pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None) 621

622 - def iscontainer(self):

623 return True

624

625 - def containerelements(self):

626 yield ('header', self.__field_header, None) 627 yield ('entry', self.__field_entry, None) 628 yield ('pad', self.__field_pad, None)

629 630 631 632

633 -class callalarmentry(BaseProtogenClass):

634 __fields=['slot', 'flag', 'dunno1', 'phonenum', 'phonenum_len', 'date', 'period', 'dom', 'datedup', 'name', 'pad1', 'name_len', 'phonenumbertype', 'phonenumberslot', 'serial', 'pad2', 'ringtone'] 635

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

637 dict={} 638 # What was supplied to this function 639 dict.update(kwargs) 640 # Parent constructor 641 super(callalarmentry,self).__init__(**dict) 642 if self.__class__ is callalarmentry: 643 self._update(args,dict)

644 645

646 - def getfields(self):

647 return self.__fields

648 649

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

651 super(callalarmentry,self)._update(args,kwargs) 652 keys=kwargs.keys() 653 for key in keys: 654 if key in self.__fields: 655 setattr(self, key, kwargs[key]) 656 del kwargs[key] 657 # Were any unrecognized kwargs passed in? 658 if __debug__: 659 self._complainaboutunusedargs(callalarmentry,kwargs) 660 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)

661 # Make all P fields that haven't already been constructed 662 663

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

665 'Writes this packet to the supplied buffer' 666 self._bufferstartoffset=buf.getcurrentoffset() 667 self.__field_slot.writetobuffer(buf) 668 self.__field_flag.writetobuffer(buf) 669 try: self.__field_dunno1 670 except: 671 self.__field_dunno1=UINT(**{'sizeinbytes': 1, 'default': 0}) 672 self.__field_dunno1.writetobuffer(buf) 673 self.__field_phonenum.writetobuffer(buf) 674 self.__field_phonenum_len.writetobuffer(buf) 675 self.__field_date.writetobuffer(buf) 676 self.__field_period.writetobuffer(buf) 677 self.__field_dom.writetobuffer(buf) 678 self.__field_datedup.writetobuffer(buf) 679 self.__field_name.writetobuffer(buf) 680 try: self.__field_pad1 681 except: 682 self.__field_pad1=UNKNOWN(**{'sizeinbytes': 1}) 683 self.__field_pad1.writetobuffer(buf) 684 self.__field_name_len.writetobuffer(buf) 685 self.__field_phonenumbertype.writetobuffer(buf) 686 self.__field_phonenumberslot.writetobuffer(buf) 687 try: self.__field_serial 688 except: 689 self.__field_serial=UINT(**{'sizeinbytes': 1, 'default': 0}) 690 self.__field_serial.writetobuffer(buf) 691 try: self.__field_pad2 692 except: 693 self.__field_pad2=UNKNOWN(**{'sizeinbytes': 3}) 694 self.__field_pad2.writetobuffer(buf) 695 try: self.__field_ringtone 696 except: 697 self.__field_ringtone=UINT(**{'sizeinbytes': 1}) 698 self.__field_ringtone.writetobuffer(buf) 699 self._bufferendoffset=buf.getcurrentoffset() 700 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)

701 702

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

704 'Reads this packet from the supplied buffer' 705 self._bufferstartoffset=buf.getcurrentoffset() 706 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 707 self.__field_slot=UINT(**{'sizeinbytes': 1}) 708 self.__field_slot.readfrombuffer(buf) 709 self.__field_flag=UINT(**{'sizeinbytes': 1}) 710 self.__field_flag.readfrombuffer(buf) 711 self.__field_dunno1=UINT(**{'sizeinbytes': 1, 'default': 0}) 712 self.__field_dunno1.readfrombuffer(buf) 713 self.__field_phonenum=USTRING(**{'sizeinbytes': 49, 'raiseonunterminatedread': False}) 714 self.__field_phonenum.readfrombuffer(buf) 715 self.__field_phonenum_len=UINT(**{'sizeinbytes': 1}) 716 self.__field_phonenum_len.readfrombuffer(buf) 717 self.__field_date=UINT(**{'sizeinbytes': 4}) 718 self.__field_date.readfrombuffer(buf) 719 self.__field_period=UINT(**{'sizeinbytes': 1}) 720 self.__field_period.readfrombuffer(buf) 721 self.__field_dom=UINT(**{'sizeinbytes': 1}) 722 self.__field_dom.readfrombuffer(buf) 723 self.__field_datedup=UINT(**{'sizeinbytes': 4}) 724 self.__field_datedup.readfrombuffer(buf) 725 self.__field_name=USTRING(**{'sizeinbytes': 16, 'raiseonunterminatedread': False, 'raiseontruncate': False, 'terminator': None}) 726 self.__field_name.readfrombuffer(buf) 727 self.__field_pad1=UNKNOWN(**{'sizeinbytes': 1}) 728 self.__field_pad1.readfrombuffer(buf) 729 self.__field_name_len=UINT(**{'sizeinbytes': 1}) 730 self.__field_name_len.readfrombuffer(buf) 731 self.__field_phonenumbertype=UINT(**{'sizeinbytes': 1}) 732 self.__field_phonenumbertype.readfrombuffer(buf) 733 self.__field_phonenumberslot=UINT(**{'sizeinbytes': 2}) 734 self.__field_phonenumberslot.readfrombuffer(buf) 735 self.__field_serial=UINT(**{'sizeinbytes': 1, 'default': 0}) 736 self.__field_serial.readfrombuffer(buf) 737 self.__field_pad2=UNKNOWN(**{'sizeinbytes': 3}) 738 self.__field_pad2.readfrombuffer(buf) 739 self.__field_ringtone=UINT(**{'sizeinbytes': 1}) 740 self.__field_ringtone.readfrombuffer(buf) 741 self._bufferendoffset=buf.getcurrentoffset()

742 743

744 - def __getfield_slot(self):

745 return self.__field_slot.getvalue()

746

747 - def __setfield_slot(self, value):

748 if isinstance(value,UINT): 749 self.__field_slot=value 750 else: 751 self.__field_slot=UINT(value,**{'sizeinbytes': 1})

752

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

754 755 slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None) 756

757 - def __getfield_flag(self):

758 return self.__field_flag.getvalue()

759

760 - def __setfield_flag(self, value):

761 if isinstance(value,UINT): 762 self.__field_flag=value 763 else: 764 self.__field_flag=UINT(value,**{'sizeinbytes': 1})

765

766 - def __delfield_flag(self): del self.__field_flag

767 768 flag=property(__getfield_flag, __setfield_flag, __delfield_flag, "0: Not used, 1: Scheduled, 2: Already Happened") 769

770 - def __getfield_dunno1(self):

771 try: self.__field_dunno1 772 except: 773 self.__field_dunno1=UINT(**{'sizeinbytes': 1, 'default': 0}) 774 return self.__field_dunno1.getvalue()

775

776 - def __setfield_dunno1(self, value):

777 if isinstance(value,UINT): 778 self.__field_dunno1=value 779 else: 780 self.__field_dunno1=UINT(value,**{'sizeinbytes': 1, 'default': 0})

781

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

783 784 dunno1=property(__getfield_dunno1, __setfield_dunno1, __delfield_dunno1, "Related to Snooze?") 785

786 - def __getfield_phonenum(self):

787 return self.__field_phonenum.getvalue()

788

789 - def __setfield_phonenum(self, value):

790 if isinstance(value,USTRING): 791 self.__field_phonenum=value 792 else: 793 self.__field_phonenum=USTRING(value,**{'sizeinbytes': 49, 'raiseonunterminatedread': False})

794

795 - def __delfield_phonenum(self): del self.__field_phonenum

796 797 phonenum=property(__getfield_phonenum, __setfield_phonenum, __delfield_phonenum, None) 798

799 - def __getfield_phonenum_len(self):

800 return self.__field_phonenum_len.getvalue()

801

802 - def __setfield_phonenum_len(self, value):

803 if isinstance(value,UINT): 804 self.__field_phonenum_len=value 805 else: 806 self.__field_phonenum_len=UINT(value,**{'sizeinbytes': 1})

807

808 - def __delfield_phonenum_len(self): del self.__field_phonenum_len

809 810 phonenum_len=property(__getfield_phonenum_len, __setfield_phonenum_len, __delfield_phonenum_len, None) 811

812 - def __getfield_date(self):

813 return self.__field_date.getvalue()

814

815 - def __setfield_date(self, value):

816 if isinstance(value,UINT): 817 self.__field_date=value 818 else: 819 self.__field_date=UINT(value,**{'sizeinbytes': 4})

820

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

822 823 date=property(__getfield_date, __setfield_date, __delfield_date, "# seconds since Jan 1, 1980 approximately") 824

825 - def __getfield_period(self):

826 return self.__field_period.getvalue()

827

828 - def __setfield_period(self, value):

829 if isinstance(value,UINT): 830 self.__field_period=value 831 else: 832 self.__field_period=UINT(value,**{'sizeinbytes': 1})

833

834 - def __delfield_period(self): del self.__field_period

835 836 period=property(__getfield_period, __setfield_period, __delfield_period, "No, Daily, Weekly, Monthly, Yearly") 837

838 - def __getfield_dom(self):

839 return self.__field_dom.getvalue()

840

841 - def __setfield_dom(self, value):

842 if isinstance(value,UINT): 843 self.__field_dom=value 844 else: 845 self.__field_dom=UINT(value,**{'sizeinbytes': 1})

846

847 - def __delfield_dom(self): del self.__field_dom

848 849 dom=property(__getfield_dom, __setfield_dom, __delfield_dom, "Day of month for the event") 850

851 - def __getfield_datedup(self):

852 return self.__field_datedup.getvalue()

853

854 - def __setfield_datedup(self, value):

855 if isinstance(value,UINT): 856 self.__field_datedup=value 857 else: 858 self.__field_datedup=UINT(value,**{'sizeinbytes': 4})

859

860 - def __delfield_datedup(self): del self.__field_datedup

861 862 datedup=property(__getfield_datedup, __setfield_datedup, __delfield_datedup, "Copy of the date. Always the same???") 863

864 - def __getfield_name(self):

865 return self.__field_name.getvalue()

866

867 - def __setfield_name(self, value):

868 if isinstance(value,USTRING): 869 self.__field_name=value 870 else: 871 self.__field_name=USTRING(value,**{'sizeinbytes': 16, 'raiseonunterminatedread': False, 'raiseontruncate': False, 'terminator': None})

872

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

874 875 name=property(__getfield_name, __setfield_name, __delfield_name, None) 876

877 - def __getfield_pad1(self):

878 try: self.__field_pad1 879 except: 880 self.__field_pad1=UNKNOWN(**{'sizeinbytes': 1}) 881 return self.__field_pad1.getvalue()

882

883 - def __setfield_pad1(self, value):

884 if isinstance(value,UNKNOWN): 885 self.__field_pad1=value 886 else: 887 self.__field_pad1=UNKNOWN(value,**{'sizeinbytes': 1})

888

889 - def __delfield_pad1(self): del self.__field_pad1

890 891 pad1=property(__getfield_pad1, __setfield_pad1, __delfield_pad1, None) 892

893 - def __getfield_name_len(self):

894 return self.__field_name_len.getvalue()

895

896 - def __setfield_name_len(self, value):

897 if isinstance(value,UINT): 898 self.__field_name_len=value 899 else: 900 self.__field_name_len=UINT(value,**{'sizeinbytes': 1})

901

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

903 904 name_len=property(__getfield_name_len, __setfield_name_len, __delfield_name_len, None) 905

906 - def __getfield_phonenumbertype(self):

907 return self.__field_phonenumbertype.getvalue()

908

909 - def __setfield_phonenumbertype(self, value):

910 if isinstance(value,UINT): 911 self.__field_phonenumbertype=value 912 else: 913 self.__field_phonenumbertype=UINT(value,**{'sizeinbytes': 1})

914

915 - def __delfield_phonenumbertype(self): del self.__field_phonenumbertype

916 917 phonenumbertype=property(__getfield_phonenumbertype, __setfield_phonenumbertype, __delfield_phonenumbertype, "1: Home, 2: Work, ...") 918

919 - def __getfield_phonenumberslot(self):

920 return self.__field_phonenumberslot.getvalue()

921

922 - def __setfield_phonenumberslot(self, value):

923 if isinstance(value,UINT): 924 self.__field_phonenumberslot=value 925 else: 926 self.__field_phonenumberslot=UINT(value,**{'sizeinbytes': 2})

927

928 - def __delfield_phonenumberslot(self): del self.__field_phonenumberslot

929 930 phonenumberslot=property(__getfield_phonenumberslot, __setfield_phonenumberslot, __delfield_phonenumberslot, None) 931

932 - def __getfield_serial(self):

933 try: self.__field_serial 934 except: 935 self.__field_serial=UINT(**{'sizeinbytes': 1, 'default': 0}) 936 return self.__field_serial.getvalue()

937

938 - def __setfield_serial(self, value):

939 if isinstance(value,UINT): 940 self.__field_serial=value 941 else: 942 self.__field_serial=UINT(value,**{'sizeinbytes': 1, 'default': 0})

943

944 - def __delfield_serial(self): del self.__field_serial

945 946 serial=property(__getfield_serial, __setfield_serial, __delfield_serial, None) 947

948 - def __getfield_pad2(self):

949 try: self.__field_pad2 950 except: 951 self.__field_pad2=UNKNOWN(**{'sizeinbytes': 3}) 952 return self.__field_pad2.getvalue()

953

954 - def __setfield_pad2(self, value):

955 if isinstance(value,UNKNOWN): 956 self.__field_pad2=value 957 else: 958 self.__field_pad2=UNKNOWN(value,**{'sizeinbytes': 3})

959

960 - def __delfield_pad2(self): del self.__field_pad2

961 962 pad2=property(__getfield_pad2, __setfield_pad2, __delfield_pad2, None) 963

964 - def __getfield_ringtone(self):

965 try: self.__field_ringtone 966 except: 967 self.__field_ringtone=UINT(**{'sizeinbytes': 1}) 968 return self.__field_ringtone.getvalue()

969

970 - def __setfield_ringtone(self, value):

971 if isinstance(value,UINT): 972 self.__field_ringtone=value 973 else: 974 self.__field_ringtone=UINT(value,**{'sizeinbytes': 1})

975

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

977 978 ringtone=property(__getfield_ringtone, __setfield_ringtone, __delfield_ringtone, None) 979

980 - def iscontainer(self):

981 return True

982

983 - def containerelements(self):

984 yield ('slot', self.__field_slot, None) 985 yield ('flag', self.__field_flag, "0: Not used, 1: Scheduled, 2: Already Happened") 986 yield ('dunno1', self.__field_dunno1, "Related to Snooze?") 987 yield ('phonenum', self.__field_phonenum, None) 988 yield ('phonenum_len', self.__field_phonenum_len, None) 989 yield ('date', self.__field_date, "# seconds since Jan 1, 1980 approximately") 990 yield ('period', self.__field_period, "No, Daily, Weekly, Monthly, Yearly") 991 yield ('dom', self.__field_dom, "Day of month for the event") 992 yield ('datedup', self.__field_datedup, "Copy of the date. Always the same???") 993 yield ('name', self.__field_name, None) 994 yield ('pad1', self.__field_pad1, None) 995 yield ('name_len', self.__field_name_len, None) 996 yield ('phonenumbertype', self.__field_phonenumbertype, "1: Home, 2: Work, ...") 997 yield ('phonenumberslot', self.__field_phonenumberslot, None) 998 yield ('serial', self.__field_serial, None) 999 yield ('pad2', self.__field_pad2, None) 1000 yield ('ringtone', self.__field_ringtone, None)

1001 1002 1003 1004

1005 -class callalarmresponse(BaseProtogenClass):

1006 __fields=['header', 'entry', 'pad'] 1007

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

1009 dict={} 1010 # What was supplied to this function 1011 dict.update(kwargs) 1012 # Parent constructor 1013 super(callalarmresponse,self).__init__(**dict) 1014 if self.__class__ is callalarmresponse: 1015 self._update(args,dict)

1016 1017

1018 - def getfields(self):

1019 return self.__fields

1020 1021

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

1023 super(callalarmresponse,self)._update(args,kwargs) 1024 keys=kwargs.keys() 1025 for key in keys: 1026 if key in self.__fields: 1027 setattr(self, key, kwargs[key]) 1028 del kwargs[key] 1029 # Were any unrecognized kwargs passed in? 1030 if __debug__: 1031 self._complainaboutunusedargs(callalarmresponse,kwargs) 1032 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)

1033 # Make all P fields that haven't already been constructed 1034 1035

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

1037 'Writes this packet to the supplied buffer' 1038 self._bufferstartoffset=buf.getcurrentoffset() 1039 self.__field_header.writetobuffer(buf) 1040 self.__field_entry.writetobuffer(buf) 1041 self.__field_pad.writetobuffer(buf) 1042 self._bufferendoffset=buf.getcurrentoffset() 1043 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)

1044 1045

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

1047 'Reads this packet from the supplied buffer' 1048 self._bufferstartoffset=buf.getcurrentoffset() 1049 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 1050 self.__field_header=sanyoheader() 1051 self.__field_header.readfrombuffer(buf) 1052 self.__field_entry=callalarmentry() 1053 self.__field_entry.readfrombuffer(buf) 1054 self.__field_pad=UNKNOWN(**{'sizeinbytes': 413}) 1055 self.__field_pad.readfrombuffer(buf) 1056 self._bufferendoffset=buf.getcurrentoffset()

1057 1058

1059 - def __getfield_header(self):

1060 return self.__field_header.getvalue()

1061

1062 - def __setfield_header(self, value):

1063 if isinstance(value,sanyoheader): 1064 self.__field_header=value 1065 else: 1066 self.__field_header=sanyoheader(value,)

1067

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

1069 1070 header=property(__getfield_header, __setfield_header, __delfield_header, None) 1071

1072 - def __getfield_entry(self):

1073 return self.__field_entry.getvalue()

1074

1075 - def __setfield_entry(self, value):

1076 if isinstance(value,callalarmentry): 1077 self.__field_entry=value 1078 else: 1079 self.__field_entry=callalarmentry(value,)

1080

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

1082 1083 entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None) 1084

1085 - def __getfield_pad(self):

1086 return self.__field_pad.getvalue()

1087

1088 - def __setfield_pad(self, value):

1089 if isinstance(value,UNKNOWN): 1090 self.__field_pad=value 1091 else: 1092 self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 413})

1093

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

1095 1096 pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None) 1097

1098 - def iscontainer(self):

1099 return True

1100

1101 - def containerelements(self):

1102 yield ('header', self.__field_header, None) 1103 yield ('entry', self.__field_entry, None) 1104 yield ('pad', self.__field_pad, None)

1105 1106 1107 1108

1109 -class callalarmupdaterequest(BaseProtogenClass):

1110 __fields=['header', 'entry', 'pad'] 1111

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

1113 dict={} 1114 # What was supplied to this function 1115 dict.update(kwargs) 1116 # Parent constructor 1117 super(callalarmupdaterequest,self).__init__(**dict) 1118 if self.__class__ is callalarmupdaterequest: 1119 self._update(args,dict)

1120 1121

1122 - def getfields(self):

1123 return self.__fields

1124 1125

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

1127 super(callalarmupdaterequest,self)._update(args,kwargs) 1128 keys=kwargs.keys() 1129 for key in keys: 1130 if key in self.__fields: 1131 setattr(self, key, kwargs[key]) 1132 del kwargs[key] 1133 # Were any unrecognized kwargs passed in? 1134 if __debug__: 1135 self._complainaboutunusedargs(callalarmupdaterequest,kwargs) 1136 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)

1137 # Make all P fields that haven't already been constructed 1138 1139

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

1141 'Writes this packet to the supplied buffer' 1142 self._bufferstartoffset=buf.getcurrentoffset() 1143 try: self.__field_header 1144 except: 1145 self.__field_header=sanyoheader(**{'readwrite': 0x0e, 'packettype': 0x0c, 'command':0x24}) 1146 self.__field_header.writetobuffer(buf) 1147 self.__field_entry.writetobuffer(buf) 1148 try: self.__field_pad 1149 except: 1150 self.__field_pad=UNKNOWN(**{'sizeinbytes': 413}) 1151 self.__field_pad.writetobuffer(buf) 1152 self._bufferendoffset=buf.getcurrentoffset() 1153 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)

1154 1155

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

1157 'Reads this packet from the supplied buffer' 1158 self._bufferstartoffset=buf.getcurrentoffset() 1159 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 1160 self.__field_header=sanyoheader(**{'readwrite': 0x0e, 'packettype': 0x0c, 'command':0x24}) 1161 self.__field_header.readfrombuffer(buf) 1162 self.__field_entry=callalarmentry() 1163 self.__field_entry.readfrombuffer(buf) 1164 self.__field_pad=UNKNOWN(**{'sizeinbytes': 413}) 1165 self.__field_pad.readfrombuffer(buf) 1166 self._bufferendoffset=buf.getcurrentoffset()

1167 1168

1169 - def __getfield_header(self):

1170 try: self.__field_header 1171 except: 1172 self.__field_header=sanyoheader(**{'readwrite': 0x0e, 'packettype': 0x0c, 'command':0x24}) 1173 return self.__field_header.getvalue()

1174

1175 - def __setfield_header(self, value):

1176 if isinstance(value,sanyoheader): 1177 self.__field_header=value 1178 else: 1179 self.__field_header=sanyoheader(value,**{'readwrite': 0x0e, 'packettype': 0x0c, 'command':0x24})

1180

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

1182 1183 header=property(__getfield_header, __setfield_header, __delfield_header, None) 1184

1185 - def __getfield_entry(self):

1186 return self.__field_entry.getvalue()

1187

1188 - def __setfield_entry(self, value):

1189 if isinstance(value,callalarmentry): 1190 self.__field_entry=value 1191 else: 1192 self.__field_entry=callalarmentry(value,)

1193

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

1195 1196 entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None) 1197

1198 - def __getfield_pad(self):

1199 try: self.__field_pad 1200 except: 1201 self.__field_pad=UNKNOWN(**{'sizeinbytes': 413}) 1202 return self.__field_pad.getvalue()

1203

1204 - def __setfield_pad(self, value):

1205 if isinstance(value,UNKNOWN): 1206 self.__field_pad=value 1207 else: 1208 self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 413})

1209

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

1211 1212 pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None) 1213

1214 - def iscontainer(self):

1215 return True

1216

1217 - def containerelements(self):

1218 yield ('header', self.__field_header, None) 1219 yield ('entry', self.__field_entry, None) 1220 yield ('pad', self.__field_pad, None)

1221

Source Code for Module phones.p_sanyo8100