phones.p_sanyo6650

1 # THIS FILE IS AUTOMATICALLY GENERATED. EDIT THE SOURCE FILE NOT THIS ONE 2 3 """Various descriptions of data specific to Sanyo Katana-II (SCP-6650)""" 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 from p_sanyonewer import * 11 from p_sanyo4930 import * 12 from p_sanyo6600 import * 13 14 # We use LSB for all integer like fields 15 UINT=UINTlsb 16 BOOL=BOOLlsb 17 NUMPHONEBOOKENTRIES=300 18 MAXNUMBERS=500 19 MAXEMAILS=600 20 MAXURLS=300 21 MAXMEMOS=300 22 MAXADDRESSES=300 23 _NUMSPEEDDIALS=8 24 _NUMLONGNUMBERS=5 25 _LONGPHONENUMBERLEN=30 26 _NUMEVENTSLOTS=100 27 _NUMCALLALARMSLOTS=15 28 29 MAXNUMBERLEN=32 30 MAXEMAILLEN=96 31 MAXURLLEN=96 32 MAXMEMOLEN=96 33 HASRINGPICBUF=0 34 NUMGROUPS=20 35 NUMPHONENUMBERS=7 36 NUMEMAILS=2 37 FIRSTSPEEDDIAL=2 38 LASTSPEEDDIAL=9 39 40

41 -class pbsortbuffer(BaseProtogenClass):

42 "Various arrays for sorting the phone book, speed dial, determining which" 43 __fields=['startcommand', 'bufsize', 'comment', 'groupslotsused', 'pad', 'groupslotusedflags', 'slotsused', 'usedflags', 'speeddialindex', 'nameslotsused', 'nameusedflags', 'sortorder', 'pbfirstletters', 'numslotsused', 'numusedflags', 'emailslotsused', 'emailusedflags', 'urlslotsused', 'urlusedflags', 'num_address', 'addressusedflags', 'num_memo', 'memousedflags', 'junk'] 44

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

46 dict={} 47 # What was supplied to this function 48 dict.update(kwargs) 49 # Parent constructor 50 super(pbsortbuffer,self).__init__(**dict) 51 if self.__class__ is pbsortbuffer: 52 self._update(args,dict)

53 54

55 - def getfields(self):

56 return self.__fields

57 58

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

60 super(pbsortbuffer,self)._update(args,kwargs) 61 keys=kwargs.keys() 62 for key in keys: 63 if key in self.__fields: 64 setattr(self, key, kwargs[key]) 65 del kwargs[key] 66 # Were any unrecognized kwargs passed in? 67 if __debug__: 68 self._complainaboutunusedargs(pbsortbuffer,kwargs) 69 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 70 # Make all P fields that haven't already been constructed 71 try: self.__field_startcommand 72 except: 73 self.__field_startcommand=UINT(**{'constant': 0x76}) 74 try: self.__field_bufsize 75 except: 76 self.__field_bufsize=UINT(**{'constant': 4096}) 77 try: self.__field_comment 78 except: 79 self.__field_comment=USTRING(**{'default': "sort buffer"})

80 81

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

83 'Writes this packet to the supplied buffer' 84 self._bufferstartoffset=buf.getcurrentoffset() 85 self.__field_groupslotsused.writetobuffer(buf) 86 try: self.__field_pad 87 except: 88 self.__field_pad=UNKNOWN(**{'sizeinbytes': 2}) 89 self.__field_pad.writetobuffer(buf) 90 try: self.__field_groupslotusedflags 91 except: 92 self.__field_groupslotusedflags=LIST(**{'elementclass': _gen_p_sanyo6650_67, 'length': NUMGROUPS, 'createdefault': True}) 93 self.__field_groupslotusedflags.writetobuffer(buf) 94 self.__field_slotsused.writetobuffer(buf) 95 try: self.__field_usedflags 96 except: 97 self.__field_usedflags=LIST(**{'elementclass': _gen_p_sanyo6650_71, 'length': NUMPHONEBOOKENTRIES, 'createdefault': True}) 98 self.__field_usedflags.writetobuffer(buf) 99 try: self.__field_speeddialindex 100 except: 101 self.__field_speeddialindex=LIST(**{'elementclass': _gen_p_sanyo6650_73, 'length': _NUMSPEEDDIALS}) 102 self.__field_speeddialindex.writetobuffer(buf) 103 self.__field_nameslotsused.writetobuffer(buf) 104 try: self.__field_nameusedflags 105 except: 106 self.__field_nameusedflags=LIST(**{'elementclass': _gen_p_sanyo6650_77, 'length': NUMPHONEBOOKENTRIES, 'createdefault': True}) 107 self.__field_nameusedflags.writetobuffer(buf) 108 try: self.__field_sortorder 109 except: 110 self.__field_sortorder=LIST(**{'elementclass': _gen_p_sanyo6650_79, 'length': NUMPHONEBOOKENTRIES}) 111 self.__field_sortorder.writetobuffer(buf) 112 self.__field_pbfirstletters.writetobuffer(buf) 113 self.__field_numslotsused.writetobuffer(buf) 114 try: self.__field_numusedflags 115 except: 116 self.__field_numusedflags=LIST(**{'elementclass': _gen_p_sanyo6650_84, 'length': MAXNUMBERS, 'createdefault': True}) 117 self.__field_numusedflags.writetobuffer(buf) 118 self.__field_emailslotsused.writetobuffer(buf) 119 try: self.__field_emailusedflags 120 except: 121 self.__field_emailusedflags=LIST(**{'elementclass': _gen_p_sanyo6650_88, 'length': MAXEMAILS, 'createdefault': True}) 122 self.__field_emailusedflags.writetobuffer(buf) 123 self.__field_urlslotsused.writetobuffer(buf) 124 try: self.__field_urlusedflags 125 except: 126 self.__field_urlusedflags=LIST(**{'elementclass': _gen_p_sanyo6650_91, 'length': MAXURLS, 'createdefault': True}) 127 self.__field_urlusedflags.writetobuffer(buf) 128 self.__field_num_address.writetobuffer(buf) 129 try: self.__field_addressusedflags 130 except: 131 self.__field_addressusedflags=LIST(**{'elementclass': _gen_p_sanyo6650_95, 'length': NUMPHONEBOOKENTRIES, 'createdefault': True}) 132 self.__field_addressusedflags.writetobuffer(buf) 133 self.__field_num_memo.writetobuffer(buf) 134 try: self.__field_memousedflags 135 except: 136 self.__field_memousedflags=LIST(**{'elementclass': _gen_p_sanyo6650_99, 'length': NUMPHONEBOOKENTRIES, 'createdefault': True}) 137 self.__field_memousedflags.writetobuffer(buf) 138 try: self.__field_junk 139 except: 140 self.__field_junk=UNKNOWN(**{'sizeinbytes': 543}) 141 self.__field_junk.writetobuffer(buf) 142 self._bufferendoffset=buf.getcurrentoffset() 143 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)

144 145

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

147 'Reads this packet from the supplied buffer' 148 self._bufferstartoffset=buf.getcurrentoffset() 149 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 150 self.__field_groupslotsused=UINT(**{'sizeinbytes': 1}) 151 self.__field_groupslotsused.readfrombuffer(buf) 152 self.__field_pad=UNKNOWN(**{'sizeinbytes': 2}) 153 self.__field_pad.readfrombuffer(buf) 154 self.__field_groupslotusedflags=LIST(**{'elementclass': _gen_p_sanyo6650_67, 'length': NUMGROUPS, 'createdefault': True}) 155 self.__field_groupslotusedflags.readfrombuffer(buf) 156 self.__field_slotsused=UINT(**{'sizeinbytes': 2}) 157 self.__field_slotsused.readfrombuffer(buf) 158 self.__field_usedflags=LIST(**{'elementclass': _gen_p_sanyo6650_71, 'length': NUMPHONEBOOKENTRIES, 'createdefault': True}) 159 self.__field_usedflags.readfrombuffer(buf) 160 self.__field_speeddialindex=LIST(**{'elementclass': _gen_p_sanyo6650_73, 'length': _NUMSPEEDDIALS}) 161 self.__field_speeddialindex.readfrombuffer(buf) 162 self.__field_nameslotsused=UINT(**{'sizeinbytes': 2}) 163 self.__field_nameslotsused.readfrombuffer(buf) 164 self.__field_nameusedflags=LIST(**{'elementclass': _gen_p_sanyo6650_77, 'length': NUMPHONEBOOKENTRIES, 'createdefault': True}) 165 self.__field_nameusedflags.readfrombuffer(buf) 166 self.__field_sortorder=LIST(**{'elementclass': _gen_p_sanyo6650_79, 'length': NUMPHONEBOOKENTRIES}) 167 self.__field_sortorder.readfrombuffer(buf) 168 self.__field_pbfirstletters=USTRING(**{'terminator': None, 'sizeinbytes': NUMPHONEBOOKENTRIES}) 169 self.__field_pbfirstletters.readfrombuffer(buf) 170 self.__field_numslotsused=UINT(**{'sizeinbytes': 2}) 171 self.__field_numslotsused.readfrombuffer(buf) 172 self.__field_numusedflags=LIST(**{'elementclass': _gen_p_sanyo6650_84, 'length': MAXNUMBERS, 'createdefault': True}) 173 self.__field_numusedflags.readfrombuffer(buf) 174 self.__field_emailslotsused=UINT(**{'sizeinbytes': 2}) 175 self.__field_emailslotsused.readfrombuffer(buf) 176 self.__field_emailusedflags=LIST(**{'elementclass': _gen_p_sanyo6650_88, 'length': MAXEMAILS, 'createdefault': True}) 177 self.__field_emailusedflags.readfrombuffer(buf) 178 self.__field_urlslotsused=UINT(**{'sizeinbytes': 2}) 179 self.__field_urlslotsused.readfrombuffer(buf) 180 self.__field_urlusedflags=LIST(**{'elementclass': _gen_p_sanyo6650_91, 'length': MAXURLS, 'createdefault': True}) 181 self.__field_urlusedflags.readfrombuffer(buf) 182 self.__field_num_address=UINT(**{'sizeinbytes': 2}) 183 self.__field_num_address.readfrombuffer(buf) 184 self.__field_addressusedflags=LIST(**{'elementclass': _gen_p_sanyo6650_95, 'length': NUMPHONEBOOKENTRIES, 'createdefault': True}) 185 self.__field_addressusedflags.readfrombuffer(buf) 186 self.__field_num_memo=UINT(**{'sizeinbytes': 2}) 187 self.__field_num_memo.readfrombuffer(buf) 188 self.__field_memousedflags=LIST(**{'elementclass': _gen_p_sanyo6650_99, 'length': NUMPHONEBOOKENTRIES, 'createdefault': True}) 189 self.__field_memousedflags.readfrombuffer(buf) 190 self.__field_junk=UNKNOWN(**{'sizeinbytes': 543}) 191 self.__field_junk.readfrombuffer(buf) 192 self._bufferendoffset=buf.getcurrentoffset()

193 194

195 - def __getfield_startcommand(self):

196 return self.__field_startcommand.getvalue()

197

198 - def __setfield_startcommand(self, value):

199 if isinstance(value,UINT): 200 self.__field_startcommand=value 201 else: 202 self.__field_startcommand=UINT(value,**{'constant': 0x76})

203

204 - def __delfield_startcommand(self): del self.__field_startcommand

205 206 startcommand=property(__getfield_startcommand, __setfield_startcommand, __delfield_startcommand, "Starting command for R/W buf parts") 207

208 - def __getfield_bufsize(self):

209 return self.__field_bufsize.getvalue()

210

211 - def __setfield_bufsize(self, value):

212 if isinstance(value,UINT): 213 self.__field_bufsize=value 214 else: 215 self.__field_bufsize=UINT(value,**{'constant': 4096})

216

217 - def __delfield_bufsize(self): del self.__field_bufsize

218 219 bufsize=property(__getfield_bufsize, __setfield_bufsize, __delfield_bufsize, None) 220

221 - def __getfield_comment(self):

222 try: self.__field_comment 223 except: 224 self.__field_comment=USTRING(**{'default': "sort buffer"}) 225 return self.__field_comment.getvalue()

226

227 - def __setfield_comment(self, value):

228 if isinstance(value,USTRING): 229 self.__field_comment=value 230 else: 231 self.__field_comment=USTRING(value,**{'default': "sort buffer"})

232

233 - def __delfield_comment(self): del self.__field_comment

234 235 comment=property(__getfield_comment, __setfield_comment, __delfield_comment, None) 236

237 - def __getfield_groupslotsused(self):

238 return self.__field_groupslotsused.getvalue()

239

240 - def __setfield_groupslotsused(self, value):

241 if isinstance(value,UINT): 242 self.__field_groupslotsused=value 243 else: 244 self.__field_groupslotsused=UINT(value,**{'sizeinbytes': 1})

245

246 - def __delfield_groupslotsused(self): del self.__field_groupslotsused

247 248 groupslotsused=property(__getfield_groupslotsused, __setfield_groupslotsused, __delfield_groupslotsused, None) 249

250 - def __getfield_pad(self):

251 try: self.__field_pad 252 except: 253 self.__field_pad=UNKNOWN(**{'sizeinbytes': 2}) 254 return self.__field_pad.getvalue()

255

256 - def __setfield_pad(self, value):

257 if isinstance(value,UNKNOWN): 258 self.__field_pad=value 259 else: 260 self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 2})

261

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

263 264 pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None) 265

266 - def __getfield_groupslotusedflags(self):

267 try: self.__field_groupslotusedflags 268 except: 269 self.__field_groupslotusedflags=LIST(**{'elementclass': _gen_p_sanyo6650_67, 'length': NUMGROUPS, 'createdefault': True}) 270 return self.__field_groupslotusedflags.getvalue()

271

272 - def __setfield_groupslotusedflags(self, value):

273 if isinstance(value,LIST): 274 self.__field_groupslotusedflags=value 275 else: 276 self.__field_groupslotusedflags=LIST(value,**{'elementclass': _gen_p_sanyo6650_67, 'length': NUMGROUPS, 'createdefault': True})

277

278 - def __delfield_groupslotusedflags(self): del self.__field_groupslotusedflags

279 280 groupslotusedflags=property(__getfield_groupslotusedflags, __setfield_groupslotusedflags, __delfield_groupslotusedflags, None) 281

282 - def __getfield_slotsused(self):

283 return self.__field_slotsused.getvalue()

284

285 - def __setfield_slotsused(self, value):

286 if isinstance(value,UINT): 287 self.__field_slotsused=value 288 else: 289 self.__field_slotsused=UINT(value,**{'sizeinbytes': 2})

290

291 - def __delfield_slotsused(self): del self.__field_slotsused

292 293 slotsused=property(__getfield_slotsused, __setfield_slotsused, __delfield_slotsused, None) 294

295 - def __getfield_usedflags(self):

296 try: self.__field_usedflags 297 except: 298 self.__field_usedflags=LIST(**{'elementclass': _gen_p_sanyo6650_71, 'length': NUMPHONEBOOKENTRIES, 'createdefault': True}) 299 return self.__field_usedflags.getvalue()

300

301 - def __setfield_usedflags(self, value):

302 if isinstance(value,LIST): 303 self.__field_usedflags=value 304 else: 305 self.__field_usedflags=LIST(value,**{'elementclass': _gen_p_sanyo6650_71, 'length': NUMPHONEBOOKENTRIES, 'createdefault': True})

306

307 - def __delfield_usedflags(self): del self.__field_usedflags

308 309 usedflags=property(__getfield_usedflags, __setfield_usedflags, __delfield_usedflags, None) 310

311 - def __getfield_speeddialindex(self):

312 try: self.__field_speeddialindex 313 except: 314 self.__field_speeddialindex=LIST(**{'elementclass': _gen_p_sanyo6650_73, 'length': _NUMSPEEDDIALS}) 315 return self.__field_speeddialindex.getvalue()

316

317 - def __setfield_speeddialindex(self, value):

318 if isinstance(value,LIST): 319 self.__field_speeddialindex=value 320 else: 321 self.__field_speeddialindex=LIST(value,**{'elementclass': _gen_p_sanyo6650_73, 'length': _NUMSPEEDDIALS})

322

323 - def __delfield_speeddialindex(self): del self.__field_speeddialindex

324 325 speeddialindex=property(__getfield_speeddialindex, __setfield_speeddialindex, __delfield_speeddialindex, None) 326

327 - def __getfield_nameslotsused(self):

328 return self.__field_nameslotsused.getvalue()

329

330 - def __setfield_nameslotsused(self, value):

331 if isinstance(value,UINT): 332 self.__field_nameslotsused=value 333 else: 334 self.__field_nameslotsused=UINT(value,**{'sizeinbytes': 2})

335

336 - def __delfield_nameslotsused(self): del self.__field_nameslotsused

337 338 nameslotsused=property(__getfield_nameslotsused, __setfield_nameslotsused, __delfield_nameslotsused, "Always seems to be the same. Why duplicated?") 339

340 - def __getfield_nameusedflags(self):

341 try: self.__field_nameusedflags 342 except: 343 self.__field_nameusedflags=LIST(**{'elementclass': _gen_p_sanyo6650_77, 'length': NUMPHONEBOOKENTRIES, 'createdefault': True}) 344 return self.__field_nameusedflags.getvalue()

345

346 - def __setfield_nameusedflags(self, value):

347 if isinstance(value,LIST): 348 self.__field_nameusedflags=value 349 else: 350 self.__field_nameusedflags=LIST(value,**{'elementclass': _gen_p_sanyo6650_77, 'length': NUMPHONEBOOKENTRIES, 'createdefault': True})

351

352 - def __delfield_nameusedflags(self): del self.__field_nameusedflags

353 354 nameusedflags=property(__getfield_nameusedflags, __setfield_nameusedflags, __delfield_nameusedflags, None) 355

356 - def __getfield_sortorder(self):

357 try: self.__field_sortorder 358 except: 359 self.__field_sortorder=LIST(**{'elementclass': _gen_p_sanyo6650_79, 'length': NUMPHONEBOOKENTRIES}) 360 return self.__field_sortorder.getvalue()

361

362 - def __setfield_sortorder(self, value):

363 if isinstance(value,LIST): 364 self.__field_sortorder=value 365 else: 366 self.__field_sortorder=LIST(value,**{'elementclass': _gen_p_sanyo6650_79, 'length': NUMPHONEBOOKENTRIES})

367

368 - def __delfield_sortorder(self): del self.__field_sortorder

369 370 sortorder=property(__getfield_sortorder, __setfield_sortorder, __delfield_sortorder, None) 371

372 - def __getfield_pbfirstletters(self):

373 return self.__field_pbfirstletters.getvalue()

374

375 - def __setfield_pbfirstletters(self, value):

376 if isinstance(value,USTRING): 377 self.__field_pbfirstletters=value 378 else: 379 self.__field_pbfirstletters=USTRING(value,**{'terminator': None, 'sizeinbytes': NUMPHONEBOOKENTRIES})

380

381 - def __delfield_pbfirstletters(self): del self.__field_pbfirstletters

382 383 pbfirstletters=property(__getfield_pbfirstletters, __setfield_pbfirstletters, __delfield_pbfirstletters, None) 384

385 - def __getfield_numslotsused(self):

386 return self.__field_numslotsused.getvalue()

387

388 - def __setfield_numslotsused(self, value):

389 if isinstance(value,UINT): 390 self.__field_numslotsused=value 391 else: 392 self.__field_numslotsused=UINT(value,**{'sizeinbytes': 2})

393

394 - def __delfield_numslotsused(self): del self.__field_numslotsused

395 396 numslotsused=property(__getfield_numslotsused, __setfield_numslotsused, __delfield_numslotsused, "Number of phone number slots used") 397

398 - def __getfield_numusedflags(self):

399 try: self.__field_numusedflags 400 except: 401 self.__field_numusedflags=LIST(**{'elementclass': _gen_p_sanyo6650_84, 'length': MAXNUMBERS, 'createdefault': True}) 402 return self.__field_numusedflags.getvalue()

403

404 - def __setfield_numusedflags(self, value):

405 if isinstance(value,LIST): 406 self.__field_numusedflags=value 407 else: 408 self.__field_numusedflags=LIST(value,**{'elementclass': _gen_p_sanyo6650_84, 'length': MAXNUMBERS, 'createdefault': True})

409

410 - def __delfield_numusedflags(self): del self.__field_numusedflags

411 412 numusedflags=property(__getfield_numusedflags, __setfield_numusedflags, __delfield_numusedflags, None) 413

414 - def __getfield_emailslotsused(self):

415 return self.__field_emailslotsused.getvalue()

416

417 - def __setfield_emailslotsused(self, value):

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

422

423 - def __delfield_emailslotsused(self): del self.__field_emailslotsused

424 425 emailslotsused=property(__getfield_emailslotsused, __setfield_emailslotsused, __delfield_emailslotsused, None) 426

427 - def __getfield_emailusedflags(self):

428 try: self.__field_emailusedflags 429 except: 430 self.__field_emailusedflags=LIST(**{'elementclass': _gen_p_sanyo6650_88, 'length': MAXEMAILS, 'createdefault': True}) 431 return self.__field_emailusedflags.getvalue()

432

433 - def __setfield_emailusedflags(self, value):

434 if isinstance(value,LIST): 435 self.__field_emailusedflags=value 436 else: 437 self.__field_emailusedflags=LIST(value,**{'elementclass': _gen_p_sanyo6650_88, 'length': MAXEMAILS, 'createdefault': True})

438

439 - def __delfield_emailusedflags(self): del self.__field_emailusedflags

440 441 emailusedflags=property(__getfield_emailusedflags, __setfield_emailusedflags, __delfield_emailusedflags, None) 442

443 - def __getfield_urlslotsused(self):

444 return self.__field_urlslotsused.getvalue()

445

446 - def __setfield_urlslotsused(self, value):

447 if isinstance(value,UINT): 448 self.__field_urlslotsused=value 449 else: 450 self.__field_urlslotsused=UINT(value,**{'sizeinbytes': 2})

451

452 - def __delfield_urlslotsused(self): del self.__field_urlslotsused

453 454 urlslotsused=property(__getfield_urlslotsused, __setfield_urlslotsused, __delfield_urlslotsused, None) 455

456 - def __getfield_urlusedflags(self):

457 try: self.__field_urlusedflags 458 except: 459 self.__field_urlusedflags=LIST(**{'elementclass': _gen_p_sanyo6650_91, 'length': MAXURLS, 'createdefault': True}) 460 return self.__field_urlusedflags.getvalue()

461

462 - def __setfield_urlusedflags(self, value):

463 if isinstance(value,LIST): 464 self.__field_urlusedflags=value 465 else: 466 self.__field_urlusedflags=LIST(value,**{'elementclass': _gen_p_sanyo6650_91, 'length': MAXURLS, 'createdefault': True})

467

468 - def __delfield_urlusedflags(self): del self.__field_urlusedflags

469 470 urlusedflags=property(__getfield_urlusedflags, __setfield_urlusedflags, __delfield_urlusedflags, None) 471

472 - def __getfield_num_address(self):

473 return self.__field_num_address.getvalue()

474

475 - def __setfield_num_address(self, value):

476 if isinstance(value,UINT): 477 self.__field_num_address=value 478 else: 479 self.__field_num_address=UINT(value,**{'sizeinbytes': 2})

480

481 - def __delfield_num_address(self): del self.__field_num_address

482 483 num_address=property(__getfield_num_address, __setfield_num_address, __delfield_num_address, None) 484

485 - def __getfield_addressusedflags(self):

486 try: self.__field_addressusedflags 487 except: 488 self.__field_addressusedflags=LIST(**{'elementclass': _gen_p_sanyo6650_95, 'length': NUMPHONEBOOKENTRIES, 'createdefault': True}) 489 return self.__field_addressusedflags.getvalue()

490

491 - def __setfield_addressusedflags(self, value):

492 if isinstance(value,LIST): 493 self.__field_addressusedflags=value 494 else: 495 self.__field_addressusedflags=LIST(value,**{'elementclass': _gen_p_sanyo6650_95, 'length': NUMPHONEBOOKENTRIES, 'createdefault': True})

496

497 - def __delfield_addressusedflags(self): del self.__field_addressusedflags

498 499 addressusedflags=property(__getfield_addressusedflags, __setfield_addressusedflags, __delfield_addressusedflags, None) 500

501 - def __getfield_num_memo(self):

502 return self.__field_num_memo.getvalue()

503

504 - def __setfield_num_memo(self, value):

505 if isinstance(value,UINT): 506 self.__field_num_memo=value 507 else: 508 self.__field_num_memo=UINT(value,**{'sizeinbytes': 2})

509

510 - def __delfield_num_memo(self): del self.__field_num_memo

511 512 num_memo=property(__getfield_num_memo, __setfield_num_memo, __delfield_num_memo, None) 513

514 - def __getfield_memousedflags(self):

515 try: self.__field_memousedflags 516 except: 517 self.__field_memousedflags=LIST(**{'elementclass': _gen_p_sanyo6650_99, 'length': NUMPHONEBOOKENTRIES, 'createdefault': True}) 518 return self.__field_memousedflags.getvalue()

519

520 - def __setfield_memousedflags(self, value):

521 if isinstance(value,LIST): 522 self.__field_memousedflags=value 523 else: 524 self.__field_memousedflags=LIST(value,**{'elementclass': _gen_p_sanyo6650_99, 'length': NUMPHONEBOOKENTRIES, 'createdefault': True})

525

526 - def __delfield_memousedflags(self): del self.__field_memousedflags

527 528 memousedflags=property(__getfield_memousedflags, __setfield_memousedflags, __delfield_memousedflags, None) 529

530 - def __getfield_junk(self):

531 try: self.__field_junk 532 except: 533 self.__field_junk=UNKNOWN(**{'sizeinbytes': 543}) 534 return self.__field_junk.getvalue()

535

536 - def __setfield_junk(self, value):

537 if isinstance(value,UNKNOWN): 538 self.__field_junk=value 539 else: 540 self.__field_junk=UNKNOWN(value,**{'sizeinbytes': 543})

541

542 - def __delfield_junk(self): del self.__field_junk

543 544 junk=property(__getfield_junk, __setfield_junk, __delfield_junk, None) 545

546 - def iscontainer(self):

547 return True

548

549 - def containerelements(self):

550 yield ('startcommand', self.__field_startcommand, "Starting command for R/W buf parts") 551 yield ('bufsize', self.__field_bufsize, None) 552 yield ('comment', self.__field_comment, None) 553 yield ('groupslotsused', self.__field_groupslotsused, None) 554 yield ('pad', self.__field_pad, None) 555 yield ('groupslotusedflags', self.__field_groupslotusedflags, None) 556 yield ('slotsused', self.__field_slotsused, None) 557 yield ('usedflags', self.__field_usedflags, None) 558 yield ('speeddialindex', self.__field_speeddialindex, None) 559 yield ('nameslotsused', self.__field_nameslotsused, "Always seems to be the same. Why duplicated?") 560 yield ('nameusedflags', self.__field_nameusedflags, None) 561 yield ('sortorder', self.__field_sortorder, None) 562 yield ('pbfirstletters', self.__field_pbfirstletters, None) 563 yield ('numslotsused', self.__field_numslotsused, "Number of phone number slots used") 564 yield ('numusedflags', self.__field_numusedflags, None) 565 yield ('emailslotsused', self.__field_emailslotsused, None) 566 yield ('emailusedflags', self.__field_emailusedflags, None) 567 yield ('urlslotsused', self.__field_urlslotsused, None) 568 yield ('urlusedflags', self.__field_urlusedflags, None) 569 yield ('num_address', self.__field_num_address, None) 570 yield ('addressusedflags', self.__field_addressusedflags, None) 571 yield ('num_memo', self.__field_num_memo, None) 572 yield ('memousedflags', self.__field_memousedflags, None) 573 yield ('junk', self.__field_junk, None)

574 575 576 577

578 -class _gen_p_sanyo6650_67(BaseProtogenClass):

579 'Anonymous inner class' 580 __fields=['used'] 581

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

583 dict={} 584 # What was supplied to this function 585 dict.update(kwargs) 586 # Parent constructor 587 super(_gen_p_sanyo6650_67,self).__init__(**dict) 588 if self.__class__ is _gen_p_sanyo6650_67: 589 self._update(args,dict)

590 591

592 - def getfields(self):

593 return self.__fields

594 595

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

597 super(_gen_p_sanyo6650_67,self)._update(args,kwargs) 598 keys=kwargs.keys() 599 for key in keys: 600 if key in self.__fields: 601 setattr(self, key, kwargs[key]) 602 del kwargs[key] 603 # Were any unrecognized kwargs passed in? 604 if __debug__: 605 self._complainaboutunusedargs(_gen_p_sanyo6650_67,kwargs) 606 if len(args): 607 dict2={'sizeinbytes': 1} 608 dict2.update(kwargs) 609 kwargs=dict2 610 self.__field_used=UINT(*args,**dict2)

611 # Make all P fields that haven't already been constructed 612 613

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

615 'Writes this packet to the supplied buffer' 616 self._bufferstartoffset=buf.getcurrentoffset() 617 self.__field_used.writetobuffer(buf) 618 self._bufferendoffset=buf.getcurrentoffset() 619 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)

620 621

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

623 'Reads this packet from the supplied buffer' 624 self._bufferstartoffset=buf.getcurrentoffset() 625 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 626 self.__field_used=UINT(**{'sizeinbytes': 1}) 627 self.__field_used.readfrombuffer(buf) 628 self._bufferendoffset=buf.getcurrentoffset()

629 630

631 - def __getfield_used(self):

632 return self.__field_used.getvalue()

633

634 - def __setfield_used(self, value):

635 if isinstance(value,UINT): 636 self.__field_used=value 637 else: 638 self.__field_used=UINT(value,**{'sizeinbytes': 1})

639

640 - def __delfield_used(self): del self.__field_used

641 642 used=property(__getfield_used, __setfield_used, __delfield_used, "1 if slot in use") 643

644 - def iscontainer(self):

645 return True

646

647 - def containerelements(self):

648 yield ('used', self.__field_used, "1 if slot in use")

649 650 651 652

653 -class _gen_p_sanyo6650_71(BaseProtogenClass):

654 'Anonymous inner class' 655 __fields=['used'] 656

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

658 dict={} 659 # What was supplied to this function 660 dict.update(kwargs) 661 # Parent constructor 662 super(_gen_p_sanyo6650_71,self).__init__(**dict) 663 if self.__class__ is _gen_p_sanyo6650_71: 664 self._update(args,dict)

665 666

667 - def getfields(self):

668 return self.__fields

669 670

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

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

686 # Make all P fields that haven't already been constructed 687 688

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

690 'Writes this packet to the supplied buffer' 691 self._bufferstartoffset=buf.getcurrentoffset() 692 self.__field_used.writetobuffer(buf) 693 self._bufferendoffset=buf.getcurrentoffset() 694 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)

695 696

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

698 'Reads this packet from the supplied buffer' 699 self._bufferstartoffset=buf.getcurrentoffset() 700 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 701 self.__field_used=UINT(**{'sizeinbytes': 1}) 702 self.__field_used.readfrombuffer(buf) 703 self._bufferendoffset=buf.getcurrentoffset()

704 705

706 - def __getfield_used(self):

707 return self.__field_used.getvalue()

708

709 - def __setfield_used(self, value):

710 if isinstance(value,UINT): 711 self.__field_used=value 712 else: 713 self.__field_used=UINT(value,**{'sizeinbytes': 1})

714

715 - def __delfield_used(self): del self.__field_used

716 717 used=property(__getfield_used, __setfield_used, __delfield_used, "1 if slot in use") 718

719 - def iscontainer(self):

720 return True

721

722 - def containerelements(self):

723 yield ('used', self.__field_used, "1 if slot in use")

724 725 726 727

728 -class _gen_p_sanyo6650_73(BaseProtogenClass):

729 'Anonymous inner class' 730 __fields=['numslot'] 731

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

733 dict={} 734 # What was supplied to this function 735 dict.update(kwargs) 736 # Parent constructor 737 super(_gen_p_sanyo6650_73,self).__init__(**dict) 738 if self.__class__ is _gen_p_sanyo6650_73: 739 self._update(args,dict)

740 741

742 - def getfields(self):

743 return self.__fields

744 745

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

747 super(_gen_p_sanyo6650_73,self)._update(args,kwargs) 748 keys=kwargs.keys() 749 for key in keys: 750 if key in self.__fields: 751 setattr(self, key, kwargs[key]) 752 del kwargs[key] 753 # Were any unrecognized kwargs passed in? 754 if __debug__: 755 self._complainaboutunusedargs(_gen_p_sanyo6650_73,kwargs) 756 if len(args): 757 dict2={'sizeinbytes': 2, 'default': 0xffff} 758 dict2.update(kwargs) 759 kwargs=dict2 760 self.__field_numslot=UINT(*args,**dict2)

761 # Make all P fields that haven't already been constructed 762 763

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

765 'Writes this packet to the supplied buffer' 766 self._bufferstartoffset=buf.getcurrentoffset() 767 self.__field_numslot.writetobuffer(buf) 768 self._bufferendoffset=buf.getcurrentoffset() 769 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)

770 771

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

773 'Reads this packet from the supplied buffer' 774 self._bufferstartoffset=buf.getcurrentoffset() 775 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 776 self.__field_numslot=UINT(**{'sizeinbytes': 2, 'default': 0xffff}) 777 self.__field_numslot.readfrombuffer(buf) 778 self._bufferendoffset=buf.getcurrentoffset()

779 780

781 - def __getfield_numslot(self):

782 return self.__field_numslot.getvalue()

783

784 - def __setfield_numslot(self, value):

785 if isinstance(value,UINT): 786 self.__field_numslot=value 787 else: 788 self.__field_numslot=UINT(value,**{'sizeinbytes': 2, 'default': 0xffff})

789

790 - def __delfield_numslot(self): del self.__field_numslot

791 792 numslot=property(__getfield_numslot, __setfield_numslot, __delfield_numslot, None) 793

794 - def iscontainer(self):

795 return True

796

797 - def containerelements(self):

798 yield ('numslot', self.__field_numslot, None)

799 800 801 802

803 -class _gen_p_sanyo6650_77(BaseProtogenClass):

804 'Anonymous inner class' 805 __fields=['used'] 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(_gen_p_sanyo6650_77,self).__init__(**dict) 813 if self.__class__ is _gen_p_sanyo6650_77: 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(_gen_p_sanyo6650_77,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(_gen_p_sanyo6650_77,kwargs) 831 if len(args): 832 dict2={'sizeinbytes': 1} 833 dict2.update(kwargs) 834 kwargs=dict2 835 self.__field_used=UINT(*args,**dict2)

836 # Make all P fields that haven't already been constructed 837 838

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

840 'Writes this packet to the supplied buffer' 841 self._bufferstartoffset=buf.getcurrentoffset() 842 self.__field_used.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_used=UINT(**{'sizeinbytes': 1}) 852 self.__field_used.readfrombuffer(buf) 853 self._bufferendoffset=buf.getcurrentoffset()

854 855

856 - def __getfield_used(self):

857 return self.__field_used.getvalue()

858

859 - def __setfield_used(self, value):

860 if isinstance(value,UINT): 861 self.__field_used=value 862 else: 863 self.__field_used=UINT(value,**{'sizeinbytes': 1})

864

865 - def __delfield_used(self): del self.__field_used

866 867 used=property(__getfield_used, __setfield_used, __delfield_used, "1 if slot in use") 868

869 - def iscontainer(self):

870 return True

871

872 - def containerelements(self):

873 yield ('used', self.__field_used, "1 if slot in use")

874 875 876 877

878 -class _gen_p_sanyo6650_79(BaseProtogenClass):

879 'Anonymous inner class' 880 __fields=['pbslot'] 881

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

883 dict={} 884 # What was supplied to this function 885 dict.update(kwargs) 886 # Parent constructor 887 super(_gen_p_sanyo6650_79,self).__init__(**dict) 888 if self.__class__ is _gen_p_sanyo6650_79: 889 self._update(args,dict)

890 891

892 - def getfields(self):

893 return self.__fields

894 895

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

897 super(_gen_p_sanyo6650_79,self)._update(args,kwargs) 898 keys=kwargs.keys() 899 for key in keys: 900 if key in self.__fields: 901 setattr(self, key, kwargs[key]) 902 del kwargs[key] 903 # Were any unrecognized kwargs passed in? 904 if __debug__: 905 self._complainaboutunusedargs(_gen_p_sanyo6650_79,kwargs) 906 if len(args): 907 dict2={'sizeinbytes': 2, 'default': 0xffff} 908 dict2.update(kwargs) 909 kwargs=dict2 910 self.__field_pbslot=UINT(*args,**dict2)

911 # Make all P fields that haven't already been constructed 912 913

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

915 'Writes this packet to the supplied buffer' 916 self._bufferstartoffset=buf.getcurrentoffset() 917 self.__field_pbslot.writetobuffer(buf) 918 self._bufferendoffset=buf.getcurrentoffset() 919 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)

920 921

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

923 'Reads this packet from the supplied buffer' 924 self._bufferstartoffset=buf.getcurrentoffset() 925 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 926 self.__field_pbslot=UINT(**{'sizeinbytes': 2, 'default': 0xffff}) 927 self.__field_pbslot.readfrombuffer(buf) 928 self._bufferendoffset=buf.getcurrentoffset()

929 930

931 - def __getfield_pbslot(self):

932 return self.__field_pbslot.getvalue()

933

934 - def __setfield_pbslot(self, value):

935 if isinstance(value,UINT): 936 self.__field_pbslot=value 937 else: 938 self.__field_pbslot=UINT(value,**{'sizeinbytes': 2, 'default': 0xffff})

939

940 - def __delfield_pbslot(self): del self.__field_pbslot

941 942 pbslot=property(__getfield_pbslot, __setfield_pbslot, __delfield_pbslot, None) 943

944 - def iscontainer(self):

945 return True

946

947 - def containerelements(self):

948 yield ('pbslot', self.__field_pbslot, None)

949 950 951 952

953 -class _gen_p_sanyo6650_84(BaseProtogenClass):

954 'Anonymous inner class' 955 __fields=['used'] 956

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

958 dict={} 959 # What was supplied to this function 960 dict.update(kwargs) 961 # Parent constructor 962 super(_gen_p_sanyo6650_84,self).__init__(**dict) 963 if self.__class__ is _gen_p_sanyo6650_84: 964 self._update(args,dict)

965 966

967 - def getfields(self):

968 return self.__fields

969 970

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

972 super(_gen_p_sanyo6650_84,self)._update(args,kwargs) 973 keys=kwargs.keys() 974 for key in keys: 975 if key in self.__fields: 976 setattr(self, key, kwargs[key]) 977 del kwargs[key] 978 # Were any unrecognized kwargs passed in? 979 if __debug__: 980 self._complainaboutunusedargs(_gen_p_sanyo6650_84,kwargs) 981 if len(args): 982 dict2={'sizeinbytes': 1} 983 dict2.update(kwargs) 984 kwargs=dict2 985 self.__field_used=UINT(*args,**dict2)

986 # Make all P fields that haven't already been constructed 987 988

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

990 'Writes this packet to the supplied buffer' 991 self._bufferstartoffset=buf.getcurrentoffset() 992 self.__field_used.writetobuffer(buf) 993 self._bufferendoffset=buf.getcurrentoffset() 994 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)

995 996

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

998 'Reads this packet from the supplied buffer' 999 self._bufferstartoffset=buf.getcurrentoffset() 1000 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 1001 self.__field_used=UINT(**{'sizeinbytes': 1}) 1002 self.__field_used.readfrombuffer(buf) 1003 self._bufferendoffset=buf.getcurrentoffset()

1004 1005

1006 - def __getfield_used(self):

1007 return self.__field_used.getvalue()

1008

1009 - def __setfield_used(self, value):

1010 if isinstance(value,UINT): 1011 self.__field_used=value 1012 else: 1013 self.__field_used=UINT(value,**{'sizeinbytes': 1})

1014

1015 - def __delfield_used(self): del self.__field_used

1016 1017 used=property(__getfield_used, __setfield_used, __delfield_used, "1 if slot in use") 1018

1019 - def iscontainer(self):

1020 return True

1021

1022 - def containerelements(self):

1023 yield ('used', self.__field_used, "1 if slot in use")

1024 1025 1026 1027

1028 -class _gen_p_sanyo6650_88(BaseProtogenClass):

1029 'Anonymous inner class' 1030 __fields=['used'] 1031

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

1033 dict={} 1034 # What was supplied to this function 1035 dict.update(kwargs) 1036 # Parent constructor 1037 super(_gen_p_sanyo6650_88,self).__init__(**dict) 1038 if self.__class__ is _gen_p_sanyo6650_88: 1039 self._update(args,dict)

1040 1041

1042 - def getfields(self):

1043 return self.__fields

1044 1045

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

1047 super(_gen_p_sanyo6650_88,self)._update(args,kwargs) 1048 keys=kwargs.keys() 1049 for key in keys: 1050 if key in self.__fields: 1051 setattr(self, key, kwargs[key]) 1052 del kwargs[key] 1053 # Were any unrecognized kwargs passed in? 1054 if __debug__: 1055 self._complainaboutunusedargs(_gen_p_sanyo6650_88,kwargs) 1056 if len(args): 1057 dict2={'sizeinbytes': 1} 1058 dict2.update(kwargs) 1059 kwargs=dict2 1060 self.__field_used=UINT(*args,**dict2)

1061 # Make all P fields that haven't already been constructed 1062 1063

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

1065 'Writes this packet to the supplied buffer' 1066 self._bufferstartoffset=buf.getcurrentoffset() 1067 self.__field_used.writetobuffer(buf) 1068 self._bufferendoffset=buf.getcurrentoffset() 1069 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)

1070 1071

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

1073 'Reads this packet from the supplied buffer' 1074 self._bufferstartoffset=buf.getcurrentoffset() 1075 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 1076 self.__field_used=UINT(**{'sizeinbytes': 1}) 1077 self.__field_used.readfrombuffer(buf) 1078 self._bufferendoffset=buf.getcurrentoffset()

1079 1080

1081 - def __getfield_used(self):

1082 return self.__field_used.getvalue()

1083

1084 - def __setfield_used(self, value):

1085 if isinstance(value,UINT): 1086 self.__field_used=value 1087 else: 1088 self.__field_used=UINT(value,**{'sizeinbytes': 1})

1089

1090 - def __delfield_used(self): del self.__field_used

1091 1092 used=property(__getfield_used, __setfield_used, __delfield_used, "1 if slot in use") 1093

1094 - def iscontainer(self):

1095 return True

1096

1097 - def containerelements(self):

1098 yield ('used', self.__field_used, "1 if slot in use")

1099 1100 1101 1102

1103 -class _gen_p_sanyo6650_91(BaseProtogenClass):

1104 'Anonymous inner class' 1105 __fields=['used'] 1106

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

1108 dict={} 1109 # What was supplied to this function 1110 dict.update(kwargs) 1111 # Parent constructor 1112 super(_gen_p_sanyo6650_91,self).__init__(**dict) 1113 if self.__class__ is _gen_p_sanyo6650_91: 1114 self._update(args,dict)

1115 1116

1117 - def getfields(self):

1118 return self.__fields

1119 1120

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

1122 super(_gen_p_sanyo6650_91,self)._update(args,kwargs) 1123 keys=kwargs.keys() 1124 for key in keys: 1125 if key in self.__fields: 1126 setattr(self, key, kwargs[key]) 1127 del kwargs[key] 1128 # Were any unrecognized kwargs passed in? 1129 if __debug__: 1130 self._complainaboutunusedargs(_gen_p_sanyo6650_91,kwargs) 1131 if len(args): 1132 dict2={'sizeinbytes': 1} 1133 dict2.update(kwargs) 1134 kwargs=dict2 1135 self.__field_used=UINT(*args,**dict2)

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

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

1140 'Writes this packet to the supplied buffer' 1141 self._bufferstartoffset=buf.getcurrentoffset() 1142 self.__field_used.writetobuffer(buf) 1143 self._bufferendoffset=buf.getcurrentoffset() 1144 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)

1145 1146

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

1148 'Reads this packet from the supplied buffer' 1149 self._bufferstartoffset=buf.getcurrentoffset() 1150 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 1151 self.__field_used=UINT(**{'sizeinbytes': 1}) 1152 self.__field_used.readfrombuffer(buf) 1153 self._bufferendoffset=buf.getcurrentoffset()

1154 1155

1156 - def __getfield_used(self):

1157 return self.__field_used.getvalue()

1158

1159 - def __setfield_used(self, value):

1160 if isinstance(value,UINT): 1161 self.__field_used=value 1162 else: 1163 self.__field_used=UINT(value,**{'sizeinbytes': 1})

1164

1165 - def __delfield_used(self): del self.__field_used

1166 1167 used=property(__getfield_used, __setfield_used, __delfield_used, "1 if slot in use") 1168

1169 - def iscontainer(self):

1170 return True

1171

1172 - def containerelements(self):

1173 yield ('used', self.__field_used, "1 if slot in use")

1174 1175 1176 1177

1178 -class _gen_p_sanyo6650_95(BaseProtogenClass):

1179 'Anonymous inner class' 1180 __fields=['used'] 1181

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

1183 dict={} 1184 # What was supplied to this function 1185 dict.update(kwargs) 1186 # Parent constructor 1187 super(_gen_p_sanyo6650_95,self).__init__(**dict) 1188 if self.__class__ is _gen_p_sanyo6650_95: 1189 self._update(args,dict)

1190 1191

1192 - def getfields(self):

1193 return self.__fields

1194 1195

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

1197 super(_gen_p_sanyo6650_95,self)._update(args,kwargs) 1198 keys=kwargs.keys() 1199 for key in keys: 1200 if key in self.__fields: 1201 setattr(self, key, kwargs[key]) 1202 del kwargs[key] 1203 # Were any unrecognized kwargs passed in? 1204 if __debug__: 1205 self._complainaboutunusedargs(_gen_p_sanyo6650_95,kwargs) 1206 if len(args): 1207 dict2={'sizeinbytes': 1} 1208 dict2.update(kwargs) 1209 kwargs=dict2 1210 self.__field_used=UINT(*args,**dict2)

1211 # Make all P fields that haven't already been constructed 1212 1213

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

1215 'Writes this packet to the supplied buffer' 1216 self._bufferstartoffset=buf.getcurrentoffset() 1217 self.__field_used.writetobuffer(buf) 1218 self._bufferendoffset=buf.getcurrentoffset() 1219 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)

1220 1221

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

1223 'Reads this packet from the supplied buffer' 1224 self._bufferstartoffset=buf.getcurrentoffset() 1225 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 1226 self.__field_used=UINT(**{'sizeinbytes': 1}) 1227 self.__field_used.readfrombuffer(buf) 1228 self._bufferendoffset=buf.getcurrentoffset()

1229 1230

1231 - def __getfield_used(self):

1232 return self.__field_used.getvalue()

1233

1234 - def __setfield_used(self, value):

1235 if isinstance(value,UINT): 1236 self.__field_used=value 1237 else: 1238 self.__field_used=UINT(value,**{'sizeinbytes': 1})

1239

1240 - def __delfield_used(self): del self.__field_used

1241 1242 used=property(__getfield_used, __setfield_used, __delfield_used, "1 if slot in use") 1243

1244 - def iscontainer(self):

1245 return True

1246

1247 - def containerelements(self):

1248 yield ('used', self.__field_used, "1 if slot in use")

1249 1250 1251 1252

1253 -class _gen_p_sanyo6650_99(BaseProtogenClass):

1254 'Anonymous inner class' 1255 __fields=['used'] 1256

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

1258 dict={} 1259 # What was supplied to this function 1260 dict.update(kwargs) 1261 # Parent constructor 1262 super(_gen_p_sanyo6650_99,self).__init__(**dict) 1263 if self.__class__ is _gen_p_sanyo6650_99: 1264 self._update(args,dict)

1265 1266

1267 - def getfields(self):

1268 return self.__fields

1269 1270

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

1272 super(_gen_p_sanyo6650_99,self)._update(args,kwargs) 1273 keys=kwargs.keys() 1274 for key in keys: 1275 if key in self.__fields: 1276 setattr(self, key, kwargs[key]) 1277 del kwargs[key] 1278 # Were any unrecognized kwargs passed in? 1279 if __debug__: 1280 self._complainaboutunusedargs(_gen_p_sanyo6650_99,kwargs) 1281 if len(args): 1282 dict2={'sizeinbytes': 1} 1283 dict2.update(kwargs) 1284 kwargs=dict2 1285 self.__field_used=UINT(*args,**dict2)

1286 # Make all P fields that haven't already been constructed 1287 1288

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

1290 'Writes this packet to the supplied buffer' 1291 self._bufferstartoffset=buf.getcurrentoffset() 1292 self.__field_used.writetobuffer(buf) 1293 self._bufferendoffset=buf.getcurrentoffset() 1294 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)

1295 1296

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

1298 'Reads this packet from the supplied buffer' 1299 self._bufferstartoffset=buf.getcurrentoffset() 1300 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 1301 self.__field_used=UINT(**{'sizeinbytes': 1}) 1302 self.__field_used.readfrombuffer(buf) 1303 self._bufferendoffset=buf.getcurrentoffset()

1304 1305

1306 - def __getfield_used(self):

1307 return self.__field_used.getvalue()

1308

1309 - def __setfield_used(self, value):

1310 if isinstance(value,UINT): 1311 self.__field_used=value 1312 else: 1313 self.__field_used=UINT(value,**{'sizeinbytes': 1})

1314

1315 - def __delfield_used(self): del self.__field_used

1316 1317 used=property(__getfield_used, __setfield_used, __delfield_used, "1 if slot in use") 1318

1319 - def iscontainer(self):

1320 return True

1321

1322 - def containerelements(self):

1323 yield ('used', self.__field_used, "1 if slot in use")

1324

Source Code for Module phones.p_sanyo6650