0001
0004 from prototypes import *
0005 from prototypes_samsung import *
0006 from p_samsung_packet import *
0007
0008 NUMPHONENUMBERS=5
0009 NUMPHONEBOOKENTRIES=300
0010 NUMGROUPS=5
0011 MAXNUMBERLEN=32
0012 NUMMEMOENTRIES=9
0013 NUMTODOENTRIES=9
0014 NUMCALENDAREVENTS=70
0015 NUMSMSINENTRIES=211
0016
0017 max_pb_slots=312
0018 max_pb_entries=312
0019 user_pb_entry_range=xrange(1, 301)
0020 max_number_entries=312
0021 max_media_index_entries=302
0022 max_group_entries=6
0023
0024 slot_file_name='nvm/nvm/pclink_tbl'
0025 pb_file_name='nvm/nvm/dial_tbl'
0026 number_file_name='nvm/nvm/dial'
0027 ringer_index_file_name='nvm/nvm/name_ring'
0028 wallpaper_index_file_name='nvm/nvm/avatar'
0029 group_file_name='nvm/nvm/group'
0030 camera_dir='cam/jpeg'
0031 savedtophone_dir='cam/dldJpeg'
0032
0033 camera_index=100
0034 camera_origin='camera-fullsize'
0035 savedtophone_index=200
0036 savedtophone_origin='camera'
0037 ams_index=300
0038
0039 CELLTYPE=1
0041 HOMETYPE=2
0042 WORKTYPE=3
0043 PAGERTYPE=4
0044 OTHERTYPE=5
0045 MAILTYPE=7
0046 URLTYPE=8
0047
0048 UINT=UINTlsb
0050 BOOL=BOOLlsb
0051
0052 AMSREGISTRY="ams/AmsRegistry"
0053 ENDTRANSACTION="ams/EndTransaction"
0054 RINGERPREFIX="ams/Ringers/cnts"
0055 WALLPAPERPREFIX="ams/Screen Savers/cnts"
0056
0057 FILETYPE_RINGER=12
0058 FILETYPE_WALLPAPER=13
0059 FILETYPE_APP=16
0060 exts={
0061 'audio/vnd.qcelp': '.qcp',
0062 'audio/midi': '.mid',
0063 'application/x-pmd': '.pmd',
0064 'audio/mpeg': '.mp3',
0065 'image/jpeg': '.jpeg',
0066 'image/png': '.png',
0067 'image/gif': '.gif',
0068 'image/bmp': '.bmp',
0069 }
0070
0071 origins={
0072 FILETYPE_RINGER: 'ringers',
0073 FILETYPE_WALLPAPER: 'images',
0074 }
0075 class groupnameentry(BaseProtogenClass):
0076 __fields=['gid', 'groupname', 'ringtone', 'dunno2', 'timestamp']
0077
0078 def __init__(self, *args, **kwargs):
0079 dict={}
0080 dict.update(kwargs)
0082 super(groupnameentry,self).__init__(**dict)
0084 if self.__class__ is groupnameentry:
0085 self._update(args,dict)
0086
0087
0088 def getfields(self):
0089 return self.__fields
0090
0091
0092 def _update(self, args, kwargs):
0093 super(groupnameentry,self)._update(args,kwargs)
0094 keys=kwargs.keys()
0095 for key in keys:
0096 if key in self.__fields:
0097 setattr(self, key, kwargs[key])
0098 del kwargs[key]
0099 if __debug__:
0101 self._complainaboutunusedargs(groupnameentry,kwargs)
0102 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0103
0105
0106 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0107 'Writes this packet to the supplied buffer'
0108 self._bufferstartoffset=buf.getcurrentoffset()
0109 self.__field_gid.writetobuffer(buf)
0110 self.__field_groupname.writetobuffer(buf)
0111 self.__field_ringtone.writetobuffer(buf)
0112 self.__field_dunno2.writetobuffer(buf)
0113 self.__field_timestamp.writetobuffer(buf)
0114 self._bufferendoffset=buf.getcurrentoffset()
0115 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0116
0117
0118 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0119 'Reads this packet from the supplied buffer'
0120 self._bufferstartoffset=buf.getcurrentoffset()
0121 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0122 self.__field_gid=CSVINT()
0123 self.__field_gid.readfrombuffer(buf)
0124 self.__field_groupname=CSVSTRING()
0125 self.__field_groupname.readfrombuffer(buf)
0126 self.__field_ringtone=CSVINT()
0127 self.__field_ringtone.readfrombuffer(buf)
0128 self.__field_dunno2=CSVSTRING(**{'quotechar': None})
0129 self.__field_dunno2.readfrombuffer(buf)
0130 self.__field_timestamp=CSVTIME(**{'terminator': None})
0131 self.__field_timestamp.readfrombuffer(buf)
0132 self._bufferendoffset=buf.getcurrentoffset()
0133
0134
0135 def __getfield_gid(self):
0136 return self.__field_gid.getvalue()
0137
0138 def __setfield_gid(self, value):
0139 if isinstance(value,CSVINT):
0140 self.__field_gid=value
0141 else:
0142 self.__field_gid=CSVINT(value,)
0143
0144 def __delfield_gid(self): del self.__field_gid
0145
0146 gid=property(__getfield_gid, __setfield_gid, __delfield_gid, None)
0147
0148 def __getfield_groupname(self):
0149 return self.__field_groupname.getvalue()
0150
0151 def __setfield_groupname(self, value):
0152 if isinstance(value,CSVSTRING):
0153 self.__field_groupname=value
0154 else:
0155 self.__field_groupname=CSVSTRING(value,)
0156
0157 def __delfield_groupname(self): del self.__field_groupname
0158
0159 groupname=property(__getfield_groupname, __setfield_groupname, __delfield_groupname, None)
0160
0161 def __getfield_ringtone(self):
0162 return self.__field_ringtone.getvalue()
0163
0164 def __setfield_ringtone(self, value):
0165 if isinstance(value,CSVINT):
0166 self.__field_ringtone=value
0167 else:
0168 self.__field_ringtone=CSVINT(value,)
0169
0170 def __delfield_ringtone(self): del self.__field_ringtone
0171
0172 ringtone=property(__getfield_ringtone, __setfield_ringtone, __delfield_ringtone, "Ringtone assignment?")
0173
0174 def __getfield_dunno2(self):
0175 return self.__field_dunno2.getvalue()
0176
0177 def __setfield_dunno2(self, value):
0178 if isinstance(value,CSVSTRING):
0179 self.__field_dunno2=value
0180 else:
0181 self.__field_dunno2=CSVSTRING(value,**{'quotechar': None})
0182
0183 def __delfield_dunno2(self): del self.__field_dunno2
0184
0185 dunno2=property(__getfield_dunno2, __setfield_dunno2, __delfield_dunno2, "A single character C or S")
0186
0187 def __getfield_timestamp(self):
0188 return self.__field_timestamp.getvalue()
0189
0190 def __setfield_timestamp(self, value):
0191 if isinstance(value,CSVTIME):
0192 self.__field_timestamp=value
0193 else:
0194 self.__field_timestamp=CSVTIME(value,**{'terminator': None})
0195
0196 def __delfield_timestamp(self): del self.__field_timestamp
0197
0198 timestamp=property(__getfield_timestamp, __setfield_timestamp, __delfield_timestamp, None)
0199
0200 def iscontainer(self):
0201 return True
0202
0203 def containerelements(self):
0204 yield ('gid', self.__field_gid, None)
0205 yield ('groupname', self.__field_groupname, None)
0206 yield ('ringtone', self.__field_ringtone, "Ringtone assignment?")
0207 yield ('dunno2', self.__field_dunno2, "A single character C or S")
0208 yield ('timestamp', self.__field_timestamp, None)
0209
0210
0211
0212
0213 class groupnameresponse(BaseProtogenClass):
0214 __fields=['command', 'entry']
0215
0216 def __init__(self, *args, **kwargs):
0217 dict={}
0218 dict.update(kwargs)
0220 super(groupnameresponse,self).__init__(**dict)
0222 if self.__class__ is groupnameresponse:
0223 self._update(args,dict)
0224
0225
0226 def getfields(self):
0227 return self.__fields
0228
0229
0230 def _update(self, args, kwargs):
0231 super(groupnameresponse,self)._update(args,kwargs)
0232 keys=kwargs.keys()
0233 for key in keys:
0234 if key in self.__fields:
0235 setattr(self, key, kwargs[key])
0236 del kwargs[key]
0237 if __debug__:
0239 self._complainaboutunusedargs(groupnameresponse,kwargs)
0240 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0241
0243
0244 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0245 'Writes this packet to the supplied buffer'
0246 self._bufferstartoffset=buf.getcurrentoffset()
0247 self.__field_command.writetobuffer(buf)
0248 self.__field_entry.writetobuffer(buf)
0249 self._bufferendoffset=buf.getcurrentoffset()
0250 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0251
0252
0253 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0254 'Reads this packet from the supplied buffer'
0255 self._bufferstartoffset=buf.getcurrentoffset()
0256 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0257 self.__field_command=CSVSTRING(**{'quotechar': None, 'terminator': ord(' '), 'constant': '#PBGRR:'})
0258 self.__field_command.readfrombuffer(buf)
0259 self.__field_entry=groupnameentry()
0260 self.__field_entry.readfrombuffer(buf)
0261 self._bufferendoffset=buf.getcurrentoffset()
0262
0263
0264 def __getfield_command(self):
0265 return self.__field_command.getvalue()
0266
0267 def __setfield_command(self, value):
0268 if isinstance(value,CSVSTRING):
0269 self.__field_command=value
0270 else:
0271 self.__field_command=CSVSTRING(value,**{'quotechar': None, 'terminator': ord(' '), 'constant': '#PBGRR:'})
0272
0273 def __delfield_command(self): del self.__field_command
0274
0275 command=property(__getfield_command, __setfield_command, __delfield_command, None)
0276
0277 def __getfield_entry(self):
0278 return self.__field_entry.getvalue()
0279
0280 def __setfield_entry(self, value):
0281 if isinstance(value,groupnameentry):
0282 self.__field_entry=value
0283 else:
0284 self.__field_entry=groupnameentry(value,)
0285
0286 def __delfield_entry(self): del self.__field_entry
0287
0288 entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None)
0289
0290 def iscontainer(self):
0291 return True
0292
0293 def containerelements(self):
0294 yield ('command', self.__field_command, None)
0295 yield ('entry', self.__field_entry, None)
0296
0297
0298
0299
0300 class pbentry(BaseProtogenClass):
0301 __fields=['writeflg', 'slot', 'uslot', 'group', 'ringtone', 'name', 'speeddial', 'dunno1', 'numbers', 'extranumber', 'dunno3', 'dunno4', 'email', 'url', 'birthday', 'wallpaper', 'timestamp']
0302
0303 def __init__(self, *args, **kwargs):
0304 dict={}
0305 dict.update(kwargs)
0307 super(pbentry,self).__init__(**dict)
0309 if self.__class__ is pbentry:
0310 self._update(args,dict)
0311
0312
0313 def getfields(self):
0314 return self.__fields
0315
0316
0317 def _update(self, args, kwargs):
0318 super(pbentry,self)._update(args,kwargs)
0319 keys=kwargs.keys()
0320 for key in keys:
0321 if key in self.__fields:
0322 setattr(self, key, kwargs[key])
0323 del kwargs[key]
0324 if __debug__:
0326 self._complainaboutunusedargs(pbentry,kwargs)
0327 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0328 try: self.__field_writeflg
0330 except:
0331 self.__field_writeflg=BOOL(**{ 'default': False })
0332
0333
0334 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0335 'Writes this packet to the supplied buffer'
0336 self._bufferstartoffset=buf.getcurrentoffset()
0337 self.__field_slot.writetobuffer(buf)
0338 self.__field_uslot.writetobuffer(buf)
0339 self.__field_group.writetobuffer(buf)
0340 try: self.__field_ringtone
0341 except:
0342 self.__field_ringtone=CSVINT(**{'default': 20})
0343 self.__field_ringtone.writetobuffer(buf)
0344 self.__field_name.writetobuffer(buf)
0345 self.__field_speeddial.writetobuffer(buf)
0346 try: self.__field_dunno1
0347 except:
0348 self.__field_dunno1=CSVINT(**{'default': 0})
0349 self.__field_dunno1.writetobuffer(buf)
0350 try: self.__field_numbers
0351 except:
0352 self.__field_numbers=LIST(**{'length': NUMPHONENUMBERS, 'createdefault': True, 'elementclass': phonenumber})
0353 self.__field_numbers.writetobuffer(buf)
0354 if self.writeflg:
0355 try: self.__field_extranumber
0356 except:
0357 self.__field_extranumber=phonenumber()
0358 self.__field_extranumber.writetobuffer(buf)
0359 try: self.__field_dunno3
0360 except:
0361 self.__field_dunno3=CSVSTRING(**{'quotechar': None, 'default': ""})
0362 self.__field_dunno3.writetobuffer(buf)
0363 try: self.__field_dunno4
0364 except:
0365 self.__field_dunno4=CSVSTRING(**{'quotechar': None, 'default': ""})
0366 self.__field_dunno4.writetobuffer(buf)
0367 self.__field_email.writetobuffer(buf)
0368 self.__field_url.writetobuffer(buf)
0369 try: self.__field_birthday
0370 except:
0371 self.__field_birthday=CSVSTRING(**{'quotechar': None, 'default': ""})
0372 self.__field_birthday.writetobuffer(buf)
0373 try: self.__field_wallpaper
0374 except:
0375 self.__field_wallpaper=CSVINT(**{'default': 20})
0376 self.__field_wallpaper.writetobuffer(buf)
0377 try: self.__field_timestamp
0378 except:
0379 self.__field_timestamp=CSVTIME(**{'terminator': None, 'default': DateTime.now()+(0,) })
0380 self.__field_timestamp.writetobuffer(buf)
0381 self._bufferendoffset=buf.getcurrentoffset()
0382 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0383
0384
0385 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0386 'Reads this packet from the supplied buffer'
0387 self._bufferstartoffset=buf.getcurrentoffset()
0388 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0389 self.__field_slot=CSVINT()
0390 self.__field_slot.readfrombuffer(buf)
0391 self.__field_uslot=CSVINT()
0392 self.__field_uslot.readfrombuffer(buf)
0393 self.__field_group=CSVINT()
0394 self.__field_group.readfrombuffer(buf)
0395 self.__field_ringtone=CSVINT(**{'default': 20})
0396 self.__field_ringtone.readfrombuffer(buf)
0397 self.__field_name=CSVSTRING()
0398 self.__field_name.readfrombuffer(buf)
0399 self.__field_speeddial=CSVINT()
0400 self.__field_speeddial.readfrombuffer(buf)
0401 self.__field_dunno1=CSVINT(**{'default': 0})
0402 self.__field_dunno1.readfrombuffer(buf)
0403 self.__field_numbers=LIST(**{'length': NUMPHONENUMBERS, 'createdefault': True, 'elementclass': phonenumber})
0404 self.__field_numbers.readfrombuffer(buf)
0405 if self.writeflg:
0406 self.__field_extranumber=phonenumber()
0407 self.__field_extranumber.readfrombuffer(buf)
0408 self.__field_dunno3=CSVSTRING(**{'quotechar': None, 'default': ""})
0409 self.__field_dunno3.readfrombuffer(buf)
0410 self.__field_dunno4=CSVSTRING(**{'quotechar': None, 'default': ""})
0411 self.__field_dunno4.readfrombuffer(buf)
0412 self.__field_email=CSVSTRING()
0413 self.__field_email.readfrombuffer(buf)
0414 self.__field_url=CSVSTRING()
0415 self.__field_url.readfrombuffer(buf)
0416 self.__field_birthday=CSVSTRING(**{'quotechar': None, 'default': ""})
0417 self.__field_birthday.readfrombuffer(buf)
0418 self.__field_wallpaper=CSVINT(**{'default': 20})
0419 self.__field_wallpaper.readfrombuffer(buf)
0420 self.__field_timestamp=CSVTIME(**{'terminator': None, 'default': DateTime.now()+(0,) })
0421 self.__field_timestamp.readfrombuffer(buf)
0422 self._bufferendoffset=buf.getcurrentoffset()
0423
0424
0425 def __getfield_writeflg(self):
0426 try: self.__field_writeflg
0427 except:
0428 self.__field_writeflg=BOOL(**{ 'default': False })
0429 return self.__field_writeflg.getvalue()
0430
0431 def __setfield_writeflg(self, value):
0432 if isinstance(value,BOOL):
0433 self.__field_writeflg=value
0434 else:
0435 self.__field_writeflg=BOOL(value,**{ 'default': False })
0436
0437 def __delfield_writeflg(self): del self.__field_writeflg
0438
0439 writeflg=property(__getfield_writeflg, __setfield_writeflg, __delfield_writeflg, "Set to True when writing to phone")
0440
0441 def __getfield_slot(self):
0442 return self.__field_slot.getvalue()
0443
0444 def __setfield_slot(self, value):
0445 if isinstance(value,CSVINT):
0446 self.__field_slot=value
0447 else:
0448 self.__field_slot=CSVINT(value,)
0449
0450 def __delfield_slot(self): del self.__field_slot
0451
0452 slot=property(__getfield_slot, __setfield_slot, __delfield_slot, "Internal Slot")
0453
0454 def __getfield_uslot(self):
0455 return self.__field_uslot.getvalue()
0456
0457 def __setfield_uslot(self, value):
0458 if isinstance(value,CSVINT):
0459 self.__field_uslot=value
0460 else:
0461 self.__field_uslot=CSVINT(value,)
0462
0463 def __delfield_uslot(self): del self.__field_uslot
0464
0465 uslot=property(__getfield_uslot, __setfield_uslot, __delfield_uslot, "User Slot, Speed dial")
0466
0467 def __getfield_group(self):
0468 return self.__field_group.getvalue()
0469
0470 def __setfield_group(self, value):
0471 if isinstance(value,CSVINT):
0472 self.__field_group=value
0473 else:
0474 self.__field_group=CSVINT(value,)
0475
0476 def __delfield_group(self): del self.__field_group
0477
0478 group=property(__getfield_group, __setfield_group, __delfield_group, None)
0479
0480 def __getfield_ringtone(self):
0481 try: self.__field_ringtone
0482 except:
0483 self.__field_ringtone=CSVINT(**{'default': 20})
0484 return self.__field_ringtone.getvalue()
0485
0486 def __setfield_ringtone(self, value):
0487 if isinstance(value,CSVINT):
0488 self.__field_ringtone=value
0489 else:
0490 self.__field_ringtone=CSVINT(value,**{'default': 20})
0491
0492 def __delfield_ringtone(self): del self.__field_ringtone
0493
0494 ringtone=property(__getfield_ringtone, __setfield_ringtone, __delfield_ringtone, None)
0495
0496 def __getfield_name(self):
0497 return self.__field_name.getvalue()
0498
0499 def __setfield_name(self, value):
0500 if isinstance(value,CSVSTRING):
0501 self.__field_name=value
0502 else:
0503 self.__field_name=CSVSTRING(value,)
0504
0505 def __delfield_name(self): del self.__field_name
0506
0507 name=property(__getfield_name, __setfield_name, __delfield_name, None)
0508
0509 def __getfield_speeddial(self):
0510 return self.__field_speeddial.getvalue()
0511
0512 def __setfield_speeddial(self, value):
0513 if isinstance(value,CSVINT):
0514 self.__field_speeddial=value
0515 else:
0516 self.__field_speeddial=CSVINT(value,)
0517
0518 def __delfield_speeddial(self): del self.__field_speeddial
0519
0520 speeddial=property(__getfield_speeddial, __setfield_speeddial, __delfield_speeddial, "Which phone number assigned to speed dial uslot")
0521
0522 def __getfield_dunno1(self):
0523 try: self.__field_dunno1
0524 except:
0525 self.__field_dunno1=CSVINT(**{'default': 0})
0526 return self.__field_dunno1.getvalue()
0527
0528 def __setfield_dunno1(self, value):
0529 if isinstance(value,CSVINT):
0530 self.__field_dunno1=value
0531 else:
0532 self.__field_dunno1=CSVINT(value,**{'default': 0})
0533
0534 def __delfield_dunno1(self): del self.__field_dunno1
0535
0536 dunno1=property(__getfield_dunno1, __setfield_dunno1, __delfield_dunno1, None)
0537
0538 def __getfield_numbers(self):
0539 try: self.__field_numbers
0540 except:
0541 self.__field_numbers=LIST(**{'length': NUMPHONENUMBERS, 'createdefault': True, 'elementclass': phonenumber})
0542 return self.__field_numbers.getvalue()
0543
0544 def __setfield_numbers(self, value):
0545 if isinstance(value,LIST):
0546 self.__field_numbers=value
0547 else:
0548 self.__field_numbers=LIST(value,**{'length': NUMPHONENUMBERS, 'createdefault': True, 'elementclass': phonenumber})
0549
0550 def __delfield_numbers(self): del self.__field_numbers
0551
0552 numbers=property(__getfield_numbers, __setfield_numbers, __delfield_numbers, None)
0553
0554 def __getfield_extranumber(self):
0555 try: self.__field_extranumber
0556 except:
0557 self.__field_extranumber=phonenumber()
0558 return self.__field_extranumber.getvalue()
0559
0560 def __setfield_extranumber(self, value):
0561 if isinstance(value,phonenumber):
0562 self.__field_extranumber=value
0563 else:
0564 self.__field_extranumber=phonenumber(value,)
0565
0566 def __delfield_extranumber(self): del self.__field_extranumber
0567
0568 extranumber=property(__getfield_extranumber, __setfield_extranumber, __delfield_extranumber, None)
0569
0570 def __getfield_dunno3(self):
0571 try: self.__field_dunno3
0572 except:
0573 self.__field_dunno3=CSVSTRING(**{'quotechar': None, 'default': ""})
0574 return self.__field_dunno3.getvalue()
0575
0576 def __setfield_dunno3(self, value):
0577 if isinstance(value,CSVSTRING):
0578 self.__field_dunno3=value
0579 else:
0580 self.__field_dunno3=CSVSTRING(value,**{'quotechar': None, 'default': ""})
0581
0582 def __delfield_dunno3(self): del self.__field_dunno3
0583
0584 dunno3=property(__getfield_dunno3, __setfield_dunno3, __delfield_dunno3, None)
0585
0586 def __getfield_dunno4(self):
0587 try: self.__field_dunno4
0588 except:
0589 self.__field_dunno4=CSVSTRING(**{'quotechar': None, 'default': ""})
0590 return self.__field_dunno4.getvalue()
0591
0592 def __setfield_dunno4(self, value):
0593 if isinstance(value,CSVSTRING):
0594 self.__field_dunno4=value
0595 else:
0596 self.__field_dunno4=CSVSTRING(value,**{'quotechar': None, 'default': ""})
0597
0598 def __delfield_dunno4(self): del self.__field_dunno4
0599
0600 dunno4=property(__getfield_dunno4, __setfield_dunno4, __delfield_dunno4, None)
0601
0602 def __getfield_email(self):
0603 return self.__field_email.getvalue()
0604
0605 def __setfield_email(self, value):
0606 if isinstance(value,CSVSTRING):
0607 self.__field_email=value
0608 else:
0609 self.__field_email=CSVSTRING(value,)
0610
0611 def __delfield_email(self): del self.__field_email
0612
0613 email=property(__getfield_email, __setfield_email, __delfield_email, None)
0614
0615 def __getfield_url(self):
0616 return self.__field_url.getvalue()
0617
0618 def __setfield_url(self, value):
0619 if isinstance(value,CSVSTRING):
0620 self.__field_url=value
0621 else:
0622 self.__field_url=CSVSTRING(value,)
0623
0624 def __delfield_url(self): del self.__field_url
0625
0626 url=property(__getfield_url, __setfield_url, __delfield_url, None)
0627
0628 def __getfield_birthday(self):
0629 try: self.__field_birthday
0630 except:
0631 self.__field_birthday=CSVSTRING(**{'quotechar': None, 'default': ""})
0632 return self.__field_birthday.getvalue()
0633
0634 def __setfield_birthday(self, value):
0635 if isinstance(value,CSVSTRING):
0636 self.__field_birthday=value
0637 else:
0638 self.__field_birthday=CSVSTRING(value,**{'quotechar': None, 'default': ""})
0639
0640 def __delfield_birthday(self): del self.__field_birthday
0641
0642 birthday=property(__getfield_birthday, __setfield_birthday, __delfield_birthday, None)
0643
0644 def __getfield_wallpaper(self):
0645 try: self.__field_wallpaper
0646 except:
0647 self.__field_wallpaper=CSVINT(**{'default': 20})
0648 return self.__field_wallpaper.getvalue()
0649
0650 def __setfield_wallpaper(self, value):
0651 if isinstance(value,CSVINT):
0652 self.__field_wallpaper=value
0653 else:
0654 self.__field_wallpaper=CSVINT(value,**{'default': 20})
0655
0656 def __delfield_wallpaper(self): del self.__field_wallpaper
0657
0658 wallpaper=property(__getfield_wallpaper, __setfield_wallpaper, __delfield_wallpaper, None)
0659
0660 def __getfield_timestamp(self):
0661 try: self.__field_timestamp
0662 except:
0663 self.__field_timestamp=CSVTIME(**{'terminator': None, 'default': DateTime.now()+(0,) })
0664 return self.__field_timestamp.getvalue()
0665
0666 def __setfield_timestamp(self, value):
0667 if isinstance(value,CSVTIME):
0668 self.__field_timestamp=value
0669 else:
0670 self.__field_timestamp=CSVTIME(value,**{'terminator': None, 'default': DateTime.now()+(0,) })
0671
0672 def __delfield_timestamp(self): del self.__field_timestamp
0673
0674 timestamp=property(__getfield_timestamp, __setfield_timestamp, __delfield_timestamp, "Use terminator None for last item")
0675
0676 def iscontainer(self):
0677 return True
0678
0679 def containerelements(self):
0680 yield ('writeflg', self.__field_writeflg, "Set to True when writing to phone")
0681 yield ('slot', self.__field_slot, "Internal Slot")
0682 yield ('uslot', self.__field_uslot, "User Slot, Speed dial")
0683 yield ('group', self.__field_group, None)
0684 yield ('ringtone', self.__field_ringtone, None)
0685 yield ('name', self.__field_name, None)
0686 yield ('speeddial', self.__field_speeddial, "Which phone number assigned to speed dial uslot")
0687 yield ('dunno1', self.__field_dunno1, None)
0688 yield ('numbers', self.__field_numbers, None)
0689 if self.writeflg:
0690 yield ('extranumber', self.__field_extranumber, None)
0691 yield ('dunno3', self.__field_dunno3, None)
0692 yield ('dunno4', self.__field_dunno4, None)
0693 yield ('email', self.__field_email, None)
0694 yield ('url', self.__field_url, None)
0695 yield ('birthday', self.__field_birthday, None)
0696 yield ('wallpaper', self.__field_wallpaper, None)
0697 yield ('timestamp', self.__field_timestamp, "Use terminator None for last item")
0698
0699
0700
0701
0702 class phonebookslotresponse(BaseProtogenClass):
0703 __fields=['command', 'entry']
0704
0705 def __init__(self, *args, **kwargs):
0706 dict={}
0707 dict.update(kwargs)
0709 super(phonebookslotresponse,self).__init__(**dict)
0711 if self.__class__ is phonebookslotresponse:
0712 self._update(args,dict)
0713
0714
0715 def getfields(self):
0716 return self.__fields
0717
0718
0719 def _update(self, args, kwargs):
0720 super(phonebookslotresponse,self)._update(args,kwargs)
0721 keys=kwargs.keys()
0722 for key in keys:
0723 if key in self.__fields:
0724 setattr(self, key, kwargs[key])
0725 del kwargs[key]
0726 if __debug__:
0728 self._complainaboutunusedargs(phonebookslotresponse,kwargs)
0729 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0730
0732
0733 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0734 'Writes this packet to the supplied buffer'
0735 self._bufferstartoffset=buf.getcurrentoffset()
0736 self.__field_command.writetobuffer(buf)
0737 self.__field_entry.writetobuffer(buf)
0738 self._bufferendoffset=buf.getcurrentoffset()
0739 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0740
0741
0742 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0743 'Reads this packet from the supplied buffer'
0744 self._bufferstartoffset=buf.getcurrentoffset()
0745 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0746 self.__field_command=CSVSTRING(**{'quotechar': None, 'terminator': ord(' '), 'constant': '#PBOKR:'})
0747 self.__field_command.readfrombuffer(buf)
0748 self.__field_entry=pbentry()
0749 self.__field_entry.readfrombuffer(buf)
0750 self._bufferendoffset=buf.getcurrentoffset()
0751
0752
0753 def __getfield_command(self):
0754 return self.__field_command.getvalue()
0755
0756 def __setfield_command(self, value):
0757 if isinstance(value,CSVSTRING):
0758 self.__field_command=value
0759 else:
0760 self.__field_command=CSVSTRING(value,**{'quotechar': None, 'terminator': ord(' '), 'constant': '#PBOKR:'})
0761
0762 def __delfield_command(self): del self.__field_command
0763
0764 command=property(__getfield_command, __setfield_command, __delfield_command, None)
0765
0766 def __getfield_entry(self):
0767 return self.__field_entry.getvalue()
0768
0769 def __setfield_entry(self, value):
0770 if isinstance(value,pbentry):
0771 self.__field_entry=value
0772 else:
0773 self.__field_entry=pbentry(value,)
0774
0775 def __delfield_entry(self): del self.__field_entry
0776
0777 entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None)
0778
0779 def iscontainer(self):
0780 return True
0781
0782 def containerelements(self):
0783 yield ('command', self.__field_command, None)
0784 yield ('entry', self.__field_entry, None)
0785
0786
0787
0788
0789 class phonebookslotupdaterequest(BaseProtogenClass):
0790 __fields=['command', 'entry']
0791
0792 def __init__(self, *args, **kwargs):
0793 dict={}
0794 dict.update(kwargs)
0796 super(phonebookslotupdaterequest,self).__init__(**dict)
0798 if self.__class__ is phonebookslotupdaterequest:
0799 self._update(args,dict)
0800
0801
0802 def getfields(self):
0803 return self.__fields
0804
0805
0806 def _update(self, args, kwargs):
0807 super(phonebookslotupdaterequest,self)._update(args,kwargs)
0808 keys=kwargs.keys()
0809 for key in keys:
0810 if key in self.__fields:
0811 setattr(self, key, kwargs[key])
0812 del kwargs[key]
0813 if __debug__:
0815 self._complainaboutunusedargs(phonebookslotupdaterequest,kwargs)
0816 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0817
0819
0820 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0821 'Writes this packet to the supplied buffer'
0822 self._bufferstartoffset=buf.getcurrentoffset()
0823 try: self.__field_command
0824 except:
0825 self.__field_command=CSVSTRING(**{'quotechar': None, 'terminator': None, 'default': '#PBOKW=0,'})
0826 self.__field_command.writetobuffer(buf)
0827 self.__field_entry.writetobuffer(buf)
0828 self._bufferendoffset=buf.getcurrentoffset()
0829 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0830
0831
0832 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0833 'Reads this packet from the supplied buffer'
0834 self._bufferstartoffset=buf.getcurrentoffset()
0835 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0836 self.__field_command=CSVSTRING(**{'quotechar': None, 'terminator': None, 'default': '#PBOKW=0,'})
0837 self.__field_command.readfrombuffer(buf)
0838 self.__field_entry=pbentry()
0839 self.__field_entry.readfrombuffer(buf)
0840 self._bufferendoffset=buf.getcurrentoffset()
0841
0842
0843 def __getfield_command(self):
0844 try: self.__field_command
0845 except:
0846 self.__field_command=CSVSTRING(**{'quotechar': None, 'terminator': None, 'default': '#PBOKW=0,'})
0847 return self.__field_command.getvalue()
0848
0849 def __setfield_command(self, value):
0850 if isinstance(value,CSVSTRING):
0851 self.__field_command=value
0852 else:
0853 self.__field_command=CSVSTRING(value,**{'quotechar': None, 'terminator': None, 'default': '#PBOKW=0,'})
0854
0855 def __delfield_command(self): del self.__field_command
0856
0857 command=property(__getfield_command, __setfield_command, __delfield_command, None)
0858
0859 def __getfield_entry(self):
0860 return self.__field_entry.getvalue()
0861
0862 def __setfield_entry(self, value):
0863 if isinstance(value,pbentry):
0864 self.__field_entry=value
0865 else:
0866 self.__field_entry=pbentry(value,)
0867
0868 def __delfield_entry(self): del self.__field_entry
0869
0870 entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None)
0871
0872 def iscontainer(self):
0873 return True
0874
0875 def containerelements(self):
0876 yield ('command', self.__field_command, None)
0877 yield ('entry', self.__field_entry, None)
0878
0879
0880
0881
0882 class smsinrequest(BaseProtogenClass):
0883 __fields=['command', 'slot']
0884
0885 def __init__(self, *args, **kwargs):
0886 dict={}
0887 dict.update(kwargs)
0889 super(smsinrequest,self).__init__(**dict)
0891 if self.__class__ is smsinrequest:
0892 self._update(args,dict)
0893
0894
0895 def getfields(self):
0896 return self.__fields
0897
0898
0899 def _update(self, args, kwargs):
0900 super(smsinrequest,self)._update(args,kwargs)
0901 keys=kwargs.keys()
0902 for key in keys:
0903 if key in self.__fields:
0904 setattr(self, key, kwargs[key])
0905 del kwargs[key]
0906 if __debug__:
0908 self._complainaboutunusedargs(smsinrequest,kwargs)
0909 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0910
0912
0913 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0914 'Writes this packet to the supplied buffer'
0915 self._bufferstartoffset=buf.getcurrentoffset()
0916 try: self.__field_command
0917 except:
0918 self.__field_command=CSVSTRING(**{'quotechar': None, 'terminator': None, 'default': '#PSRMR='})
0919 self.__field_command.writetobuffer(buf)
0920 self.__field_slot.writetobuffer(buf)
0921 self._bufferendoffset=buf.getcurrentoffset()
0922 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0923
0924
0925 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0926 'Reads this packet from the supplied buffer'
0927 self._bufferstartoffset=buf.getcurrentoffset()
0928 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0929 self.__field_command=CSVSTRING(**{'quotechar': None, 'terminator': None, 'default': '#PSRMR='})
0930 self.__field_command.readfrombuffer(buf)
0931 self.__field_slot=CSVINT(**{'terminator': None})
0932 self.__field_slot.readfrombuffer(buf)
0933 self._bufferendoffset=buf.getcurrentoffset()
0934
0935
0936 def __getfield_command(self):
0937 try: self.__field_command
0938 except:
0939 self.__field_command=CSVSTRING(**{'quotechar': None, 'terminator': None, 'default': '#PSRMR='})
0940 return self.__field_command.getvalue()
0941
0942 def __setfield_command(self, value):
0943 if isinstance(value,CSVSTRING):
0944 self.__field_command=value
0945 else:
0946 self.__field_command=CSVSTRING(value,**{'quotechar': None, 'terminator': None, 'default': '#PSRMR='})
0947
0948 def __delfield_command(self): del self.__field_command
0949
0950 command=property(__getfield_command, __setfield_command, __delfield_command, None)
0951
0952 def __getfield_slot(self):
0953 return self.__field_slot.getvalue()
0954
0955 def __setfield_slot(self, value):
0956 if isinstance(value,CSVINT):
0957 self.__field_slot=value
0958 else:
0959 self.__field_slot=CSVINT(value,**{'terminator': None})
0960
0961 def __delfield_slot(self): del self.__field_slot
0962
0963 slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None)
0964
0965 def iscontainer(self):
0966 return True
0967
0968 def containerelements(self):
0969 yield ('command', self.__field_command, None)
0970 yield ('slot', self.__field_slot, None)
0971
0972
0973
0974
0975 class smsinresponse(BaseProtogenClass):
0976 __fields=['bytes']
0977
0978 def __init__(self, *args, **kwargs):
0979 dict={}
0980 dict.update(kwargs)
0982 super(smsinresponse,self).__init__(**dict)
0984 if self.__class__ is smsinresponse:
0985 self._update(args,dict)
0986
0987
0988 def getfields(self):
0989 return self.__fields
0990
0991
0992 def _update(self, args, kwargs):
0993 super(smsinresponse,self)._update(args,kwargs)
0994 keys=kwargs.keys()
0995 for key in keys:
0996 if key in self.__fields:
0997 setattr(self, key, kwargs[key])
0998 del kwargs[key]
0999 if __debug__:
1001 self._complainaboutunusedargs(smsinresponse,kwargs)
1002 if len(args):
1003 dict2={}
1004 dict2.update(kwargs)
1005 kwargs=dict2
1006 self.__field_bytes=DATA(*args,**dict2)
1007
1009
1010 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1011 'Writes this packet to the supplied buffer'
1012 self._bufferstartoffset=buf.getcurrentoffset()
1013 self.__field_bytes.writetobuffer(buf)
1014 self._bufferendoffset=buf.getcurrentoffset()
1015 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1016
1017
1018 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1019 'Reads this packet from the supplied buffer'
1020 self._bufferstartoffset=buf.getcurrentoffset()
1021 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1022 self.__field_bytes=DATA()
1023 self.__field_bytes.readfrombuffer(buf)
1024 self._bufferendoffset=buf.getcurrentoffset()
1025
1026
1027 def __getfield_bytes(self):
1028 return self.__field_bytes.getvalue()
1029
1030 def __setfield_bytes(self, value):
1031 if isinstance(value,DATA):
1032 self.__field_bytes=value
1033 else:
1034 self.__field_bytes=DATA(value,)
1035
1036 def __delfield_bytes(self): del self.__field_bytes
1037
1038 bytes=property(__getfield_bytes, __setfield_bytes, __delfield_bytes, None)
1039
1040 def iscontainer(self):
1041 return True
1042
1043 def containerelements(self):
1044 yield ('bytes', self.__field_bytes, None)
1045
1046
1047
1048
1049 class fspbslot(BaseProtogenClass):
1050 __fields=['valid', 'pbbook_index', 'c0', 'timestamp', 'pad']
1051
1052 def __init__(self, *args, **kwargs):
1053 dict={}
1054 dict.update(kwargs)
1056 super(fspbslot,self).__init__(**dict)
1058 if self.__class__ is fspbslot:
1059 self._update(args,dict)
1060
1061
1062 def getfields(self):
1063 return self.__fields
1064
1065
1066 def _update(self, args, kwargs):
1067 super(fspbslot,self)._update(args,kwargs)
1068 keys=kwargs.keys()
1069 for key in keys:
1070 if key in self.__fields:
1071 setattr(self, key, kwargs[key])
1072 del kwargs[key]
1073 if __debug__:
1075 self._complainaboutunusedargs(fspbslot,kwargs)
1076 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
1077
1079
1080 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1081 'Writes this packet to the supplied buffer'
1082 self._bufferstartoffset=buf.getcurrentoffset()
1083 try: self.__field_valid
1084 except:
1085 self.__field_valid=UINT(**{'sizeinbytes': 1, 'default': 0 })
1086 self.__field_valid.writetobuffer(buf)
1087 try: self.__field_pbbook_index
1088 except:
1089 self.__field_pbbook_index=UINT(**{'sizeinbytes': 2, 'default': 0 })
1090 self.__field_pbbook_index.writetobuffer(buf)
1091 if self.valid:
1092 try: self.__field_c0
1093 except:
1094 self.__field_c0=UINT(**{'sizeinbytes': 2, 'default': 0x0101 })
1095 self.__field_c0.writetobuffer(buf)
1096 try: self.__field_timestamp
1097 except:
1098 self.__field_timestamp=DateTime(**{'sizeinbytes': 4, 'default': DateTime.now() })
1099 self.__field_timestamp.writetobuffer(buf)
1100 else:
1101 try: self.__field_pad
1102 except:
1103 self.__field_pad=DATA(**{'sizeinbytes': 6, 'default': '\x00'*6 })
1104 self.__field_pad.writetobuffer(buf)
1105 self._bufferendoffset=buf.getcurrentoffset()
1106 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1107
1108
1109 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1110 'Reads this packet from the supplied buffer'
1111 self._bufferstartoffset=buf.getcurrentoffset()
1112 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1113 self.__field_valid=UINT(**{'sizeinbytes': 1, 'default': 0 })
1114 self.__field_valid.readfrombuffer(buf)
1115 self.__field_pbbook_index=UINT(**{'sizeinbytes': 2, 'default': 0 })
1116 self.__field_pbbook_index.readfrombuffer(buf)
1117 if self.valid:
1118 self.__field_c0=UINT(**{'sizeinbytes': 2, 'default': 0x0101 })
1119 self.__field_c0.readfrombuffer(buf)
1120 self.__field_timestamp=DateTime(**{'sizeinbytes': 4, 'default': DateTime.now() })
1121 self.__field_timestamp.readfrombuffer(buf)
1122 else:
1123 self.__field_pad=DATA(**{'sizeinbytes': 6, 'default': '\x00'*6 })
1124 self.__field_pad.readfrombuffer(buf)
1125 self._bufferendoffset=buf.getcurrentoffset()
1126
1127
1128 def __getfield_valid(self):
1129 try: self.__field_valid
1130 except:
1131 self.__field_valid=UINT(**{'sizeinbytes': 1, 'default': 0 })
1132 return self.__field_valid.getvalue()
1133
1134 def __setfield_valid(self, value):
1135 if isinstance(value,UINT):
1136 self.__field_valid=value
1137 else:
1138 self.__field_valid=UINT(value,**{'sizeinbytes': 1, 'default': 0 })
1139
1140 def __delfield_valid(self): del self.__field_valid
1141
1142 valid=property(__getfield_valid, __setfield_valid, __delfield_valid, "1=valid entry")
1143
1144 def __getfield_pbbook_index(self):
1145 try: self.__field_pbbook_index
1146 except:
1147 self.__field_pbbook_index=UINT(**{'sizeinbytes': 2, 'default': 0 })
1148 return self.__field_pbbook_index.getvalue()
1149
1150 def __setfield_pbbook_index(self, value):
1151 if isinstance(value,UINT):
1152 self.__field_pbbook_index=value
1153 else:
1154 self.__field_pbbook_index=UINT(value,**{'sizeinbytes': 2, 'default': 0 })
1155
1156 def __delfield_pbbook_index(self): del self.__field_pbbook_index
1157
1158 pbbook_index=property(__getfield_pbbook_index, __setfield_pbbook_index, __delfield_pbbook_index, "index into pbbook")
1159
1160 def __getfield_c0(self):
1161 try: self.__field_c0
1162 except:
1163 self.__field_c0=UINT(**{'sizeinbytes': 2, 'default': 0x0101 })
1164 return self.__field_c0.getvalue()
1165
1166 def __setfield_c0(self, value):
1167 if isinstance(value,UINT):
1168 self.__field_c0=value
1169 else:
1170 self.__field_c0=UINT(value,**{'sizeinbytes': 2, 'default': 0x0101 })
1171
1172 def __delfield_c0(self): del self.__field_c0
1173
1174 c0=property(__getfield_c0, __setfield_c0, __delfield_c0, None)
1175
1176 def __getfield_timestamp(self):
1177 try: self.__field_timestamp
1178 except:
1179 self.__field_timestamp=DateTime(**{'sizeinbytes': 4, 'default': DateTime.now() })
1180 return self.__field_timestamp.getvalue()
1181
1182 def __setfield_timestamp(self, value):
1183 if isinstance(value,DateTime):
1184 self.__field_timestamp=value
1185 else:
1186 self.__field_timestamp=DateTime(value,**{'sizeinbytes': 4, 'default': DateTime.now() })
1187
1188 def __delfield_timestamp(self): del self.__field_timestamp
1189
1190 timestamp=property(__getfield_timestamp, __setfield_timestamp, __delfield_timestamp, "Last modified date/time")
1191
1192 def __getfield_pad(self):
1193 try: self.__field_pad
1194 except:
1195 self.__field_pad=DATA(**{'sizeinbytes': 6, 'default': '\x00'*6 })
1196 return self.__field_pad.getvalue()
1197
1198 def __setfield_pad(self, value):
1199 if isinstance(value,DATA):
1200 self.__field_pad=value
1201 else:
1202 self.__field_pad=DATA(value,**{'sizeinbytes': 6, 'default': '\x00'*6 })
1203
1204 def __delfield_pad(self): del self.__field_pad
1205
1206 pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None)
1207
1208 def iscontainer(self):
1209 return True
1210
1211 def containerelements(self):
1212 yield ('valid', self.__field_valid, "1=valid entry")
1213 yield ('pbbook_index', self.__field_pbbook_index, "index into pbbook")
1214 if self.valid:
1215 yield ('c0', self.__field_c0, None)
1216 yield ('timestamp', self.__field_timestamp, "Last modified date/time")
1217 else:
1218 yield ('pad', self.__field_pad, None)
1219
1220
1221
1222
1223 class fspbslots(BaseProtogenClass):
1224 __fields=['slot']
1225
1226 def __init__(self, *args, **kwargs):
1227 dict={}
1228 dict.update(kwargs)
1230 super(fspbslots,self).__init__(**dict)
1232 if self.__class__ is fspbslots:
1233 self._update(args,dict)
1234
1235
1236 def getfields(self):
1237 return self.__fields
1238
1239
1240 def _update(self, args, kwargs):
1241 super(fspbslots,self)._update(args,kwargs)
1242 keys=kwargs.keys()
1243 for key in keys:
1244 if key in self.__fields:
1245 setattr(self, key, kwargs[key])
1246 del kwargs[key]
1247 if __debug__:
1249 self._complainaboutunusedargs(fspbslots,kwargs)
1250 if len(args):
1251 dict2={ 'length': max_pb_slots, 'elementclass': fspbslot }
1252 dict2.update(kwargs)
1253 kwargs=dict2
1254 self.__field_slot=LIST(*args,**dict2)
1255
1257
1258 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1259 'Writes this packet to the supplied buffer'
1260 self._bufferstartoffset=buf.getcurrentoffset()
1261 try: self.__field_slot
1262 except:
1263 self.__field_slot=LIST(**{ 'length': max_pb_slots, 'elementclass': fspbslot })
1264 self.__field_slot.writetobuffer(buf)
1265 self._bufferendoffset=buf.getcurrentoffset()
1266 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1267
1268
1269 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1270 'Reads this packet from the supplied buffer'
1271 self._bufferstartoffset=buf.getcurrentoffset()
1272 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1273 self.__field_slot=LIST(**{ 'length': max_pb_slots, 'elementclass': fspbslot })
1274 self.__field_slot.readfrombuffer(buf)
1275 self._bufferendoffset=buf.getcurrentoffset()
1276
1277
1278 def __getfield_slot(self):
1279 try: self.__field_slot
1280 except:
1281 self.__field_slot=LIST(**{ 'length': max_pb_slots, 'elementclass': fspbslot })
1282 return self.__field_slot.getvalue()
1283
1284 def __setfield_slot(self, value):
1285 if isinstance(value,LIST):
1286 self.__field_slot=value
1287 else:
1288 self.__field_slot=LIST(value,**{ 'length': max_pb_slots, 'elementclass': fspbslot })
1289
1290 def __delfield_slot(self): del self.__field_slot
1291
1292 slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None)
1293
1294 def iscontainer(self):
1295 return True
1296
1297 def containerelements(self):
1298 yield ('slot', self.__field_slot, None)
1299
1300
1301
1302
1303 class fspbentry(BaseProtogenClass):
1304 __fields=['valid', 'c1', 'c1', 'main_num_index', 'mobile_num_index', 'home_num_index', 'office_num_index', 'pager_num_index', 'fax_num_index', 'unused_index', 'email_index', 'url_index', 'name', 'group_num', 'nick', 'memo', 'pad']
1305
1306 def __init__(self, *args, **kwargs):
1307 dict={}
1308 dict.update(kwargs)
1310 super(fspbentry,self).__init__(**dict)
1312 if self.__class__ is fspbentry:
1313 self._update(args,dict)
1314
1315
1316 def getfields(self):
1317 return self.__fields
1318
1319
1320 def _update(self, args, kwargs):
1321 super(fspbentry,self)._update(args,kwargs)
1322 keys=kwargs.keys()
1323 for key in keys:
1324 if key in self.__fields:
1325 setattr(self, key, kwargs[key])
1326 del kwargs[key]
1327 if __debug__:
1329 self._complainaboutunusedargs(fspbentry,kwargs)
1330 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
1331
1333
1334 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1335 'Writes this packet to the supplied buffer'
1336 self._bufferstartoffset=buf.getcurrentoffset()
1337 try: self.__field_valid
1338 except:
1339 self.__field_valid=UINT(**{'sizeinbytes': 1, 'default': 0 })
1340 self.__field_valid.writetobuffer(buf)
1341 if self.valid:
1342 try: self.__field_c1
1343 except:
1344 self.__field_c1=UINT(**{'sizeinbytes': 2, 'default': 0x01BF })
1345 self.__field_c1.writetobuffer(buf)
1346 else:
1347 try: self.__field_c1
1348 except:
1349 self.__field_c1=UINT(**{'sizeinbytes': 2, 'default': 0 })
1350 self.__field_c1.writetobuffer(buf)
1351 try: self.__field_main_num_index
1352 except:
1353 self.__field_main_num_index=UINT(**{'sizeinbytes': 2, 'default': self.mobile_num_index })
1354 self.__field_main_num_index.writetobuffer(buf)
1355 try: self.__field_mobile_num_index
1356 except:
1357 self.__field_mobile_num_index=UINT(**{'sizeinbytes': 2, 'default': 0 })
1358 self.__field_mobile_num_index.writetobuffer(buf)
1359 try: self.__field_home_num_index
1360 except:
1361 self.__field_home_num_index=UINT(**{'sizeinbytes': 2, 'default': 0 })
1362 self.__field_home_num_index.writetobuffer(buf)
1363 try: self.__field_office_num_index
1364 except:
1365 self.__field_office_num_index=UINT(**{'sizeinbytes': 2, 'default': 0 })
1366 self.__field_office_num_index.writetobuffer(buf)
1367 try: self.__field_pager_num_index
1368 except:
1369 self.__field_pager_num_index=UINT(**{'sizeinbytes': 2, 'default': 0 })
1370 self.__field_pager_num_index.writetobuffer(buf)
1371 try: self.__field_fax_num_index
1372 except:
1373 self.__field_fax_num_index=UINT(**{'sizeinbytes': 2, 'default': 0 })
1374 self.__field_fax_num_index.writetobuffer(buf)
1375 try: self.__field_unused_index
1376 except:
1377 self.__field_unused_index=UINT(**{'sizeinbytes': 2, 'default': 0 })
1378 self.__field_unused_index.writetobuffer(buf)
1379 try: self.__field_email_index
1380 except:
1381 self.__field_email_index=UINT(**{'sizeinbytes': 2, 'default': 0 })
1382 self.__field_email_index.writetobuffer(buf)
1383 try: self.__field_url_index
1384 except:
1385 self.__field_url_index=UINT(**{'sizeinbytes': 2, 'default': 0 })
1386 self.__field_url_index.writetobuffer(buf)
1387 try: self.__field_name
1388 except:
1389 self.__field_name=USTRING(**{'sizeinbytes': 31, 'pascal': True, 'terminator': None, 'default': '' })
1390 self.__field_name.writetobuffer(buf)
1391 try: self.__field_group_num
1392 except:
1393 self.__field_group_num=UINT(**{'sizeinbytes': 1, 'default': 0 })
1394 self.__field_group_num.writetobuffer(buf)
1395 try: self.__field_nick
1396 except:
1397 self.__field_nick=USTRING(**{'sizeinbytes': 22, 'pascal': True, 'terminator': None, 'default': '' })
1398 self.__field_nick.writetobuffer(buf)
1399 try: self.__field_memo
1400 except:
1401 self.__field_memo=USTRING(**{'sizeinbytes': 73, 'pascal': True, 'terminator': None, 'default': '' })
1402 self.__field_memo.writetobuffer(buf)
1403 try: self.__field_pad
1404 except:
1405 self.__field_pad=DATA(**{'sizeinbytes': 13, 'default': '\x00'*13 })
1406 self.__field_pad.writetobuffer(buf)
1407 self._bufferendoffset=buf.getcurrentoffset()
1408 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1409
1410
1411 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1412 'Reads this packet from the supplied buffer'
1413 self._bufferstartoffset=buf.getcurrentoffset()
1414 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1415 self.__field_valid=UINT(**{'sizeinbytes': 1, 'default': 0 })
1416 self.__field_valid.readfrombuffer(buf)
1417 if self.valid:
1418 self.__field_c1=UINT(**{'sizeinbytes': 2, 'default': 0x01BF })
1419 self.__field_c1.readfrombuffer(buf)
1420 else:
1421 self.__field_c1=UINT(**{'sizeinbytes': 2, 'default': 0 })
1422 self.__field_c1.readfrombuffer(buf)
1423 self.__field_main_num_index=UINT(**{'sizeinbytes': 2, 'default': self.mobile_num_index })
1424 self.__field_main_num_index.readfrombuffer(buf)
1425 self.__field_mobile_num_index=UINT(**{'sizeinbytes': 2, 'default': 0 })
1426 self.__field_mobile_num_index.readfrombuffer(buf)
1427 self.__field_home_num_index=UINT(**{'sizeinbytes': 2, 'default': 0 })
1428 self.__field_home_num_index.readfrombuffer(buf)
1429 self.__field_office_num_index=UINT(**{'sizeinbytes': 2, 'default': 0 })
1430 self.__field_office_num_index.readfrombuffer(buf)
1431 self.__field_pager_num_index=UINT(**{'sizeinbytes': 2, 'default': 0 })
1432 self.__field_pager_num_index.readfrombuffer(buf)
1433 self.__field_fax_num_index=UINT(**{'sizeinbytes': 2, 'default': 0 })
1434 self.__field_fax_num_index.readfrombuffer(buf)
1435 self.__field_unused_index=UINT(**{'sizeinbytes': 2, 'default': 0 })
1436 self.__field_unused_index.readfrombuffer(buf)
1437 self.__field_email_index=UINT(**{'sizeinbytes': 2, 'default': 0 })
1438 self.__field_email_index.readfrombuffer(buf)
1439 self.__field_url_index=UINT(**{'sizeinbytes': 2, 'default': 0 })
1440 self.__field_url_index.readfrombuffer(buf)
1441 self.__field_name=USTRING(**{'sizeinbytes': 31, 'pascal': True, 'terminator': None, 'default': '' })
1442 self.__field_name.readfrombuffer(buf)
1443 self.__field_group_num=UINT(**{'sizeinbytes': 1, 'default': 0 })
1444 self.__field_group_num.readfrombuffer(buf)
1445 self.__field_nick=USTRING(**{'sizeinbytes': 22, 'pascal': True, 'terminator': None, 'default': '' })
1446 self.__field_nick.readfrombuffer(buf)
1447 self.__field_memo=USTRING(**{'sizeinbytes': 73, 'pascal': True, 'terminator': None, 'default': '' })
1448 self.__field_memo.readfrombuffer(buf)
1449 self.__field_pad=DATA(**{'sizeinbytes': 13, 'default': '\x00'*13 })
1450 self.__field_pad.readfrombuffer(buf)
1451 self._bufferendoffset=buf.getcurrentoffset()
1452
1453
1454 def __getfield_valid(self):
1455 try: self.__field_valid
1456 except:
1457 self.__field_valid=UINT(**{'sizeinbytes': 1, 'default': 0 })
1458 return self.__field_valid.getvalue()
1459
1460 def __setfield_valid(self, value):
1461 if isinstance(value,UINT):
1462 self.__field_valid=value
1463 else:
1464 self.__field_valid=UINT(value,**{'sizeinbytes': 1, 'default': 0 })
1465
1466 def __delfield_valid(self): del self.__field_valid
1467
1468 valid=property(__getfield_valid, __setfield_valid, __delfield_valid, "1=valid entry")
1469
1470 def __getfield_c1(self):
1471 try: self.__field_c1
1472 except:
1473 self.__field_c1=UINT(**{'sizeinbytes': 2, 'default': 0x01BF })
1474 return self.__field_c1.getvalue()
1475
1476 def __setfield_c1(self, value):
1477 if isinstance(value,UINT):
1478 self.__field_c1=value
1479 else:
1480 self.__field_c1=UINT(value,**{'sizeinbytes': 2, 'default': 0x01BF })
1481
1482 def __delfield_c1(self): del self.__field_c1
1483
1484 c1=property(__getfield_c1, __setfield_c1, __delfield_c1, None)
1485
1486 def __getfield_c1(self):
1487 try: self.__field_c1
1488 except:
1489 self.__field_c1=UINT(**{'sizeinbytes': 2, 'default': 0 })
1490 return self.__field_c1.getvalue()
1491
1492 def __setfield_c1(self, value):
1493 if isinstance(value,UINT):
1494 self.__field_c1=value
1495 else:
1496 self.__field_c1=UINT(value,**{'sizeinbytes': 2, 'default': 0 })
1497
1498 def __delfield_c1(self): del self.__field_c1
1499
1500 c1=property(__getfield_c1, __setfield_c1, __delfield_c1, None)
1501
1502 def __getfield_main_num_index(self):
1503 try: self.__field_main_num_index
1504 except:
1505 self.__field_main_num_index=UINT(**{'sizeinbytes': 2, 'default': self.mobile_num_index })
1506 return self.__field_main_num_index.getvalue()
1507
1508 def __setfield_main_num_index(self, value):
1509 if isinstance(value,UINT):
1510 self.__field_main_num_index=value
1511 else:
1512 self.__field_main_num_index=UINT(value,**{'sizeinbytes': 2, 'default': self.mobile_num_index })
1513
1514 def __delfield_main_num_index(self): del self.__field_main_num_index
1515
1516 main_num_index=property(__getfield_main_num_index, __setfield_main_num_index, __delfield_main_num_index, None)
1517
1518 def __getfield_mobile_num_index(self):
1519 try: self.__field_mobile_num_index
1520 except:
1521 self.__field_mobile_num_index=UINT(**{'sizeinbytes': 2, 'default': 0 })
1522 return self.__field_mobile_num_index.getvalue()
1523
1524 def __setfield_mobile_num_index(self, value):
1525 if isinstance(value,UINT):
1526 self.__field_mobile_num_index=value
1527 else:
1528 self.__field_mobile_num_index=UINT(value,**{'sizeinbytes': 2, 'default': 0 })
1529
1530 def __delfield_mobile_num_index(self): del self.__field_mobile_num_index
1531
1532 mobile_num_index=property(__getfield_mobile_num_index, __setfield_mobile_num_index, __delfield_mobile_num_index, None)
1533
1534 def __getfield_home_num_index(self):
1535 try: self.__field_home_num_index
1536 except:
1537 self.__field_home_num_index=UINT(**{'sizeinbytes': 2, 'default': 0 })
1538 return self.__field_home_num_index.getvalue()
1539
1540 def __setfield_home_num_index(self, value):
1541 if isinstance(value,UINT):
1542 self.__field_home_num_index=value
1543 else:
1544 self.__field_home_num_index=UINT(value,**{'sizeinbytes': 2, 'default': 0 })
1545
1546 def __delfield_home_num_index(self): del self.__field_home_num_index
1547
1548 home_num_index=property(__getfield_home_num_index, __setfield_home_num_index, __delfield_home_num_index, None)
1549
1550 def __getfield_office_num_index(self):
1551 try: self.__field_office_num_index
1552 except:
1553 self.__field_office_num_index=UINT(**{'sizeinbytes': 2, 'default': 0 })
1554 return self.__field_office_num_index.getvalue()
1555
1556 def __setfield_office_num_index(self, value):
1557 if isinstance(value,UINT):
1558 self.__field_office_num_index=value
1559 else:
1560 self.__field_office_num_index=UINT(value,**{'sizeinbytes': 2, 'default': 0 })
1561
1562 def __delfield_office_num_index(self): del self.__field_office_num_index
1563
1564 office_num_index=property(__getfield_office_num_index, __setfield_office_num_index, __delfield_office_num_index, None)
1565
1566 def __getfield_pager_num_index(self):
1567 try: self.__field_pager_num_index
1568 except:
1569 self.__field_pager_num_index=UINT(**{'sizeinbytes': 2, 'default': 0 })
1570 return self.__field_pager_num_index.getvalue()
1571
1572 def __setfield_pager_num_index(self, value):
1573 if isinstance(value,UINT):
1574 self.__field_pager_num_index=value
1575 else:
1576 self.__field_pager_num_index=UINT(value,**{'sizeinbytes': 2, 'default': 0 })
1577
1578 def __delfield_pager_num_index(self): del self.__field_pager_num_index
1579
1580 pager_num_index=property(__getfield_pager_num_index, __setfield_pager_num_index, __delfield_pager_num_index, None)
1581
1582 def __getfield_fax_num_index(self):
1583 try: self.__field_fax_num_index
1584 except:
1585 self.__field_fax_num_index=UINT(**{'sizeinbytes': 2, 'default': 0 })
1586 return self.__field_fax_num_index.getvalue()
1587
1588 def __setfield_fax_num_index(self, value):
1589 if isinstance(value,UINT):
1590 self.__field_fax_num_index=value
1591 else:
1592 self.__field_fax_num_index=UINT(value,**{'sizeinbytes': 2, 'default': 0 })
1593
1594 def __delfield_fax_num_index(self): del self.__field_fax_num_index
1595
1596 fax_num_index=property(__getfield_fax_num_index, __setfield_fax_num_index, __delfield_fax_num_index, None)
1597
1598 def __getfield_unused_index(self):
1599 try: self.__field_unused_index
1600 except:
1601 self.__field_unused_index=UINT(**{'sizeinbytes': 2, 'default': 0 })
1602 return self.__field_unused_index.getvalue()
1603
1604 def __setfield_unused_index(self, value):
1605 if isinstance(value,UINT):
1606 self.__field_unused_index=value
1607 else:
1608 self.__field_unused_index=UINT(value,**{'sizeinbytes': 2, 'default': 0 })
1609
1610 def __delfield_unused_index(self): del self.__field_unused_index
1611
1612 unused_index=property(__getfield_unused_index, __setfield_unused_index, __delfield_unused_index, None)
1613
1614 def __getfield_email_index(self):
1615 try: self.__field_email_index
1616 except:
1617 self.__field_email_index=UINT(**{'sizeinbytes': 2, 'default': 0 })
1618 return self.__field_email_index.getvalue()
1619
1620 def __setfield_email_index(self, value):
1621 if isinstance(value,UINT):
1622 self.__field_email_index=value
1623 else:
1624 self.__field_email_index=UINT(value,**{'sizeinbytes': 2, 'default': 0 })
1625
1626 def __delfield_email_index(self): del self.__field_email_index
1627
1628 email_index=property(__getfield_email_index, __setfield_email_index, __delfield_email_index, None)
1629
1630 def __getfield_url_index(self):
1631 try: self.__field_url_index
1632 except:
1633 self.__field_url_index=UINT(**{'sizeinbytes': 2, 'default': 0 })
1634 return self.__field_url_index.getvalue()
1635
1636 def __setfield_url_index(self, value):
1637 if isinstance(value,UINT):
1638 self.__field_url_index=value
1639 else:
1640 self.__field_url_index=UINT(value,**{'sizeinbytes': 2, 'default': 0 })
1641
1642 def __delfield_url_index(self): del self.__field_url_index
1643
1644 url_index=property(__getfield_url_index, __setfield_url_index, __delfield_url_index, None)
1645
1646 def __getfield_name(self):
1647 try: self.__field_name
1648 except:
1649 self.__field_name=USTRING(**{'sizeinbytes': 31, 'pascal': True, 'terminator': None, 'default': '' })
1650 return self.__field_name.getvalue()
1651
1652 def __setfield_name(self, value):
1653 if isinstance(value,USTRING):
1654 self.__field_name=value
1655 else:
1656 self.__field_name=USTRING(value,**{'sizeinbytes': 31, 'pascal': True, 'terminator': None, 'default': '' })
1657
1658 def __delfield_name(self): del self.__field_name
1659
1660 name=property(__getfield_name, __setfield_name, __delfield_name, None)
1661
1662 def __getfield_group_num(self):
1663 try: self.__field_group_num
1664 except:
1665 self.__field_group_num=UINT(**{'sizeinbytes': 1, 'default': 0 })
1666 return self.__field_group_num.getvalue()
1667
1668 def __setfield_group_num(self, value):
1669 if isinstance(value,UINT):
1670 self.__field_group_num=value
1671 else:
1672 self.__field_group_num=UINT(value,**{'sizeinbytes': 1, 'default': 0 })
1673
1674 def __delfield_group_num(self): del self.__field_group_num
1675
1676 group_num=property(__getfield_group_num, __setfield_group_num, __delfield_group_num, None)
1677
1678 def __getfield_nick(self):
1679 try: self.__field_nick
1680 except:
1681 self.__field_nick=USTRING(**{'sizeinbytes': 22, 'pascal': True, 'terminator': None, 'default': '' })
1682 return self.__field_nick.getvalue()
1683
1684 def __setfield_nick(self, value):
1685 if isinstance(value,USTRING):
1686 self.__field_nick=value
1687 else:
1688 self.__field_nick=USTRING(value,**{'sizeinbytes': 22, 'pascal': True, 'terminator': None, 'default': '' })
1689
1690 def __delfield_nick(self): del self.__field_nick
1691
1692 nick=property(__getfield_nick, __setfield_nick, __delfield_nick, None)
1693
1694 def __getfield_memo(self):
1695 try: self.__field_memo
1696 except:
1697 self.__field_memo=USTRING(**{'sizeinbytes': 73, 'pascal': True, 'terminator': None, 'default': '' })
1698 return self.__field_memo.getvalue()
1699
1700 def __setfield_memo(self, value):
1701 if isinstance(value,USTRING):
1702 self.__field_memo=value
1703 else:
1704 self.__field_memo=USTRING(value,**{'sizeinbytes': 73, 'pascal': True, 'terminator': None, 'default': '' })
1705
1706 def __delfield_memo(self): del self.__field_memo
1707
1708 memo=property(__getfield_memo, __setfield_memo, __delfield_memo, None)
1709
1710 def __getfield_pad(self):
1711 try: self.__field_pad
1712 except:
1713 self.__field_pad=DATA(**{'sizeinbytes': 13, 'default': '\x00'*13 })
1714 return self.__field_pad.getvalue()
1715
1716 def __setfield_pad(self, value):
1717 if isinstance(value,DATA):
1718 self.__field_pad=value
1719 else:
1720 self.__field_pad=DATA(value,**{'sizeinbytes': 13, 'default': '\x00'*13 })
1721
1722 def __delfield_pad(self): del self.__field_pad
1723
1724 pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None)
1725
1726 def iscontainer(self):
1727 return True
1728
1729 def containerelements(self):
1730 yield ('valid', self.__field_valid, "1=valid entry")
1731 if self.valid:
1732 yield ('c1', self.__field_c1, None)
1733 else:
1734 yield ('c1', self.__field_c1, None)
1735 yield ('main_num_index', self.__field_main_num_index, None)
1736 yield ('mobile_num_index', self.__field_mobile_num_index, None)
1737 yield ('home_num_index', self.__field_home_num_index, None)
1738 yield ('office_num_index', self.__field_office_num_index, None)
1739 yield ('pager_num_index', self.__field_pager_num_index, None)
1740 yield ('fax_num_index', self.__field_fax_num_index, None)
1741 yield ('unused_index', self.__field_unused_index, None)
1742 yield ('email_index', self.__field_email_index, None)
1743 yield ('url_index', self.__field_url_index, None)
1744 yield ('name', self.__field_name, None)
1745 yield ('group_num', self.__field_group_num, None)
1746 yield ('nick', self.__field_nick, None)
1747 yield ('memo', self.__field_memo, None)
1748 yield ('pad', self.__field_pad, None)
1749
1750
1751
1752
1753 class fspbbook(BaseProtogenClass):
1754 __fields=['entry']
1755
1756 def __init__(self, *args, **kwargs):
1757 dict={}
1758 dict.update(kwargs)
1760 super(fspbbook,self).__init__(**dict)
1762 if self.__class__ is fspbbook:
1763 self._update(args,dict)
1764
1765
1766 def getfields(self):
1767 return self.__fields
1768
1769
1770 def _update(self, args, kwargs):
1771 super(fspbbook,self)._update(args,kwargs)
1772 keys=kwargs.keys()
1773 for key in keys:
1774 if key in self.__fields:
1775 setattr(self, key, kwargs[key])
1776 del kwargs[key]
1777 if __debug__:
1779 self._complainaboutunusedargs(fspbbook,kwargs)
1780 if len(args):
1781 dict2={ 'length': max_pb_entries, 'elementclass': fspbentry, 'createdefault': True }
1782 dict2.update(kwargs)
1783 kwargs=dict2
1784 self.__field_entry=LIST(*args,**dict2)
1785
1787
1788 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1789 'Writes this packet to the supplied buffer'
1790 self._bufferstartoffset=buf.getcurrentoffset()
1791 try: self.__field_entry
1792 except:
1793 self.__field_entry=LIST(**{ 'length': max_pb_entries, 'elementclass': fspbentry, 'createdefault': True })
1794 self.__field_entry.writetobuffer(buf)
1795 self._bufferendoffset=buf.getcurrentoffset()
1796 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1797
1798
1799 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1800 'Reads this packet from the supplied buffer'
1801 self._bufferstartoffset=buf.getcurrentoffset()
1802 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1803 self.__field_entry=LIST(**{ 'length': max_pb_entries, 'elementclass': fspbentry, 'createdefault': True })
1804 self.__field_entry.readfrombuffer(buf)
1805 self._bufferendoffset=buf.getcurrentoffset()
1806
1807
1808 def __getfield_entry(self):
1809 try: self.__field_entry
1810 except:
1811 self.__field_entry=LIST(**{ 'length': max_pb_entries, 'elementclass': fspbentry, 'createdefault': True })
1812 return self.__field_entry.getvalue()
1813
1814 def __setfield_entry(self, value):
1815 if isinstance(value,LIST):
1816 self.__field_entry=value
1817 else:
1818 self.__field_entry=LIST(value,**{ 'length': max_pb_entries, 'elementclass': fspbentry, 'createdefault': True })
1819
1820 def __delfield_entry(self): del self.__field_entry
1821
1822 entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None)
1823
1824 def iscontainer(self):
1825 return True
1826
1827 def containerelements(self):
1828 yield ('entry', self.__field_entry, None)
1829
1830
1831
1832
1833 class fsnumber(BaseProtogenClass):
1834 __fields=['valid', 'c0', 'name', 'number_type']
1835
1836 def __init__(self, *args, **kwargs):
1837 dict={}
1838 dict.update(kwargs)
1840 super(fsnumber,self).__init__(**dict)
1842 if self.__class__ is fsnumber:
1843 self._update(args,dict)
1844
1845
1846 def getfields(self):
1847 return self.__fields
1848
1849
1850 def _update(self, args, kwargs):
1851 super(fsnumber,self)._update(args,kwargs)
1852 keys=kwargs.keys()
1853 for key in keys:
1854 if key in self.__fields:
1855 setattr(self, key, kwargs[key])
1856 del kwargs[key]
1857 if __debug__:
1859 self._complainaboutunusedargs(fsnumber,kwargs)
1860 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
1861
1863
1864 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1865 'Writes this packet to the supplied buffer'
1866 self._bufferstartoffset=buf.getcurrentoffset()
1867 try: self.__field_valid
1868 except:
1869 self.__field_valid=UINT(**{'sizeinbytes': 2, 'default': 0 })
1870 self.__field_valid.writetobuffer(buf)
1871 try: self.__field_c0
1872 except:
1873 self.__field_c0=UINT(**{'sizeinbytes': 4, 'default': 0 })
1874 self.__field_c0.writetobuffer(buf)
1875 try: self.__field_name
1876 except:
1877 self.__field_name=USTRING(**{'sizeinbytes': 74, 'pascal': True, 'terminator': None, 'default': '' })
1878 self.__field_name.writetobuffer(buf)
1879 try: self.__field_number_type
1880 except:
1881 self.__field_number_type=UINT(**{'sizeinbytes': 1, 'default': 0 })
1882 self.__field_number_type.writetobuffer(buf)
1883 self._bufferendoffset=buf.getcurrentoffset()
1884 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1885
1886
1887 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1888 'Reads this packet from the supplied buffer'
1889 self._bufferstartoffset=buf.getcurrentoffset()
1890 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1891 self.__field_valid=UINT(**{'sizeinbytes': 2, 'default': 0 })
1892 self.__field_valid.readfrombuffer(buf)
1893 self.__field_c0=UINT(**{'sizeinbytes': 4, 'default': 0 })
1894 self.__field_c0.readfrombuffer(buf)
1895 self.__field_name=USTRING(**{'sizeinbytes': 74, 'pascal': True, 'terminator': None, 'default': '' })
1896 self.__field_name.readfrombuffer(buf)
1897 self.__field_number_type=UINT(**{'sizeinbytes': 1, 'default': 0 })
1898 self.__field_number_type.readfrombuffer(buf)
1899 self._bufferendoffset=buf.getcurrentoffset()
1900
1901
1902 def __getfield_valid(self):
1903 try: self.__field_valid
1904 except:
1905 self.__field_valid=UINT(**{'sizeinbytes': 2, 'default': 0 })
1906 return self.__field_valid.getvalue()
1907
1908 def __setfield_valid(self, value):
1909 if isinstance(value,UINT):
1910 self.__field_valid=value
1911 else:
1912 self.__field_valid=UINT(value,**{'sizeinbytes': 2, 'default': 0 })
1913
1914 def __delfield_valid(self): del self.__field_valid
1915
1916 valid=property(__getfield_valid, __setfield_valid, __delfield_valid, "1=valid entry")
1917
1918 def __getfield_c0(self):
1919 try: self.__field_c0
1920 except:
1921 self.__field_c0=UINT(**{'sizeinbytes': 4, 'default': 0 })
1922 return self.__field_c0.getvalue()
1923
1924 def __setfield_c0(self, value):
1925 if isinstance(value,UINT):
1926 self.__field_c0=value
1927 else:
1928 self.__field_c0=UINT(value,**{'sizeinbytes': 4, 'default': 0 })
1929
1930 def __delfield_c0(self): del self.__field_c0
1931
1932 c0=property(__getfield_c0, __setfield_c0, __delfield_c0, None)
1933
1934 def __getfield_name(self):
1935 try: self.__field_name
1936 except:
1937 self.__field_name=USTRING(**{'sizeinbytes': 74, 'pascal': True, 'terminator': None, 'default': '' })
1938 return self.__field_name.getvalue()
1939
1940 def __setfield_name(self, value):
1941 if isinstance(value,USTRING):
1942 self.__field_name=value
1943 else:
1944 self.__field_name=USTRING(value,**{'sizeinbytes': 74, 'pascal': True, 'terminator': None, 'default': '' })
1945
1946 def __delfield_name(self): del self.__field_name
1947
1948 name=property(__getfield_name, __setfield_name, __delfield_name, None)
1949
1950 def __getfield_number_type(self):
1951 try: self.__field_number_type
1952 except:
1953 self.__field_number_type=UINT(**{'sizeinbytes': 1, 'default': 0 })
1954 return self.__field_number_type.getvalue()
1955
1956 def __setfield_number_type(self, value):
1957 if isinstance(value,UINT):
1958 self.__field_number_type=value
1959 else:
1960 self.__field_number_type=UINT(value,**{'sizeinbytes': 1, 'default': 0 })
1961
1962 def __delfield_number_type(self): del self.__field_number_type
1963
1964 number_type=property(__getfield_number_type, __setfield_number_type, __delfield_number_type, None)
1965
1966 def iscontainer(self):
1967 return True
1968
1969 def containerelements(self):
1970 yield ('valid', self.__field_valid, "1=valid entry")
1971 yield ('c0', self.__field_c0, None)
1972 yield ('name', self.__field_name, None)
1973 yield ('number_type', self.__field_number_type, None)
1974
1975
1976
1977
1978 class fsnumbers(BaseProtogenClass):
1979 __fields=['entry']
1980
1981 def __init__(self, *args, **kwargs):
1982 dict={}
1983 dict.update(kwargs)
1985 super(fsnumbers,self).__init__(**dict)
1987 if self.__class__ is fsnumbers:
1988 self._update(args,dict)
1989
1990
1991 def getfields(self):
1992 return self.__fields
1993
1994
1995 def _update(self, args, kwargs):
1996 super(fsnumbers,self)._update(args,kwargs)
1997 keys=kwargs.keys()
1998 for key in keys:
1999 if key in self.__fields:
2000 setattr(self, key, kwargs[key])
2001 del kwargs[key]
2002 if __debug__:
2004 self._complainaboutunusedargs(fsnumbers,kwargs)
2005 if len(args):
2006 dict2={ 'length': max_number_entries, 'elementclass': fsnumber, 'createdefault': True }
2007 dict2.update(kwargs)
2008 kwargs=dict2
2009 self.__field_entry=LIST(*args,**dict2)
2010
2012
2013 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
2014 'Writes this packet to the supplied buffer'
2015 self._bufferstartoffset=buf.getcurrentoffset()
2016 try: self.__field_entry
2017 except:
2018 self.__field_entry=LIST(**{ 'length': max_number_entries, 'elementclass': fsnumber, 'createdefault': True })
2019 self.__field_entry.writetobuffer(buf)
2020 self._bufferendoffset=buf.getcurrentoffset()
2021 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
2022
2023
2024 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
2025 'Reads this packet from the supplied buffer'
2026 self._bufferstartoffset=buf.getcurrentoffset()
2027 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
2028 self.__field_entry=LIST(**{ 'length': max_number_entries, 'elementclass': fsnumber, 'createdefault': True })
2029 self.__field_entry.readfrombuffer(buf)
2030 self._bufferendoffset=buf.getcurrentoffset()
2031
2032
2033 def __getfield_entry(self):
2034 try: self.__field_entry
2035 except:
2036 self.__field_entry=LIST(**{ 'length': max_number_entries, 'elementclass': fsnumber, 'createdefault': True })
2037 return self.__field_entry.getvalue()
2038
2039 def __setfield_entry(self, value):
2040 if isinstance(value,LIST):
2041 self.__field_entry=value
2042 else:
2043 self.__field_entry=LIST(value,**{ 'length': max_number_entries, 'elementclass': fsnumber, 'createdefault': True })
2044
2045 def __delfield_entry(self): del self.__field_entry
2046
2047 entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None)
2048
2049 def iscontainer(self):
2050 return True
2051
2052 def containerelements(self):
2053 yield ('entry', self.__field_entry, None)
2054
2055
2056
2057
2058 class amsregistry(BaseProtogenClass):
2059 __fields=['dunno0', 'info', 'dunno1', 'strings', 'dunno2', 'nfiles', 'dunno3']
2060
2061 def __init__(self, *args, **kwargs):
2062 dict={}
2063 dict.update(kwargs)
2065 super(amsregistry,self).__init__(**dict)
2067 if self.__class__ is amsregistry:
2068 self._update(args,dict)
2069
2070
2071 def getfields(self):
2072 return self.__fields
2073
2074
2075 def _update(self, args, kwargs):
2076 super(amsregistry,self)._update(args,kwargs)
2077 keys=kwargs.keys()
2078 for key in keys:
2079 if key in self.__fields:
2080 setattr(self, key, kwargs[key])
2081 del kwargs[key]
2082 if __debug__:
2084 self._complainaboutunusedargs(amsregistry,kwargs)
2085 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
2086
2088
2089 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
2090 'Writes this packet to the supplied buffer'
2091 self._bufferstartoffset=buf.getcurrentoffset()
2092 self.__field_dunno0.writetobuffer(buf)
2093 self.__field_info.writetobuffer(buf)
2094 self.__field_dunno1.writetobuffer(buf)
2095 self.__field_strings.writetobuffer(buf)
2096 self.__field_dunno2.writetobuffer(buf)
2097 self.__field_nfiles.writetobuffer(buf)
2098 self.__field_dunno3.writetobuffer(buf)
2099 self._bufferendoffset=buf.getcurrentoffset()
2100 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
2101
2102
2103 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
2104 'Reads this packet from the supplied buffer'
2105 self._bufferstartoffset=buf.getcurrentoffset()
2106 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
2107 self.__field_dunno0=DATA(**{'sizeinbytes': 900})
2108 self.__field_dunno0.readfrombuffer(buf)
2109 self.__field_info=LIST(**{'elementclass': _gen_p_samsungsphm300_197, 'length': 320})
2110 self.__field_info.readfrombuffer(buf)
2111 self.__field_dunno1=DATA(**{'sizeinbytes': 2000})
2112 self.__field_dunno1.readfrombuffer(buf)
2113 self.__field_strings=DATA(**{'sizeinbytes': 23000})
2114 self.__field_strings.readfrombuffer(buf)
2115 self.__field_dunno2=UINT(**{'sizeinbytes': 4})
2116 self.__field_dunno2.readfrombuffer(buf)
2117 self.__field_nfiles=UINT(**{'sizeinbytes': 2})
2118 self.__field_nfiles.readfrombuffer(buf)
2119 self.__field_dunno3=DATA()
2120 self.__field_dunno3.readfrombuffer(buf)
2121 self._bufferendoffset=buf.getcurrentoffset()
2122
2123
2124 def __getfield_dunno0(self):
2125 return self.__field_dunno0.getvalue()
2126
2127 def __setfield_dunno0(self, value):
2128 if isinstance(value,DATA):
2129 self.__field_dunno0=value
2130 else:
2131 self.__field_dunno0=DATA(value,**{'sizeinbytes': 900})
2132
2133 def __delfield_dunno0(self): del self.__field_dunno0
2134
2135 dunno0=property(__getfield_dunno0, __setfield_dunno0, __delfield_dunno0, None)
2136
2137 def __getfield_info(self):
2138 return self.__field_info.getvalue()
2139
2140 def __setfield_info(self, value):
2141 if isinstance(value,LIST):
2142 self.__field_info=value
2143 else:
2144 self.__field_info=LIST(value,**{'elementclass': _gen_p_samsungsphm300_197, 'length': 320})
2145
2146 def __delfield_info(self): del self.__field_info
2147
2148 info=property(__getfield_info, __setfield_info, __delfield_info, None)
2149
2150 def __getfield_dunno1(self):
2151 return self.__field_dunno1.getvalue()
2152
2153 def __setfield_dunno1(self, value):
2154 if isinstance(value,DATA):
2155 self.__field_dunno1=value
2156 else:
2157 self.__field_dunno1=DATA(value,**{'sizeinbytes': 2000})
2158
2159 def __delfield_dunno1(self): del self.__field_dunno1
2160
2161 dunno1=property(__getfield_dunno1, __setfield_dunno1, __delfield_dunno1, None)
2162
2163 def __getfield_strings(self):
2164 return self.__field_strings.getvalue()
2165
2166 def __setfield_strings(self, value):
2167 if isinstance(value,DATA):
2168 self.__field_strings=value
2169 else:
2170 self.__field_strings=DATA(value,**{'sizeinbytes': 23000})
2171
2172 def __delfield_strings(self): del self.__field_strings
2173
2174 strings=property(__getfield_strings, __setfield_strings, __delfield_strings, None)
2175
2176 def __getfield_dunno2(self):
2177 return self.__field_dunno2.getvalue()
2178
2179 def __setfield_dunno2(self, value):
2180 if isinstance(value,UINT):
2181 self.__field_dunno2=value
2182 else:
2183 self.__field_dunno2=UINT(value,**{'sizeinbytes': 4})
2184
2185 def __delfield_dunno2(self): del self.__field_dunno2
2186
2187 dunno2=property(__getfield_dunno2, __setfield_dunno2, __delfield_dunno2, None)
2188
2189 def __getfield_nfiles(self):
2190 return self.__field_nfiles.getvalue()
2191
2192 def __setfield_nfiles(self, value):
2193 if isinstance(value,UINT):
2194 self.__field_nfiles=value
2195 else:
2196 self.__field_nfiles=UINT(value,**{'sizeinbytes': 2})
2197
2198 def __delfield_nfiles(self): del self.__field_nfiles
2199
2200 nfiles=property(__getfield_nfiles, __setfield_nfiles, __delfield_nfiles, None)
2201
2202 def __getfield_dunno3(self):
2203 return self.__field_dunno3.getvalue()
2204
2205 def __setfield_dunno3(self, value):
2206 if isinstance(value,DATA):
2207 self.__field_dunno3=value
2208 else:
2209 self.__field_dunno3=DATA(value,)
2210
2211 def __delfield_dunno3(self): del self.__field_dunno3
2212
2213 dunno3=property(__getfield_dunno3, __setfield_dunno3, __delfield_dunno3, None)
2214
2215 def iscontainer(self):
2216 return True
2217
2218 def containerelements(self):
2219 yield ('dunno0', self.__field_dunno0, None)
2220 yield ('info', self.__field_info, None)
2221 yield ('dunno1', self.__field_dunno1, None)
2222 yield ('strings', self.__field_strings, None)
2223 yield ('dunno2', self.__field_dunno2, None)
2224 yield ('nfiles', self.__field_nfiles, None)
2225 yield ('dunno3', self.__field_dunno3, None)
2226
2227 def getstring(self, ptr):
2228 try:
2230 return self.strings[ptr:self.strings.index('\x00', ptr)]
2231 except ValueError:
2232 return ''
2233 def dir(self, idx):
2234 return self.getstring(self.info[idx].dir_ptr)
2235 def name(self, idx):
2236 return self.getstring(self.info[idx].name_ptr)
2237 def mimetype(self, idx):
2238 return self.getstring(self.info[idx].mimetype_ptr)
2239 def version(self, idx):
2240 return self.getstring(self.info[idx].version_ptr)
2241 def vendor(self, idx):
2242 return self.getstring(self.info[idx].vendor_ptr)
2243 def filename(self, idx):
2244 global exts
2246 return self.name(idx)+exts.get(self.mimetype(idx), '')
2247 def filepath(self, idx):
2248 return 'ams/'+self.dir(idx)
2250 def origin(self, idx):
2251 global origins
2253 return origins.get(self.info[idx].filetype, None)
2254
2255
2256
2257
2258 class _gen_p_samsungsphm300_197(BaseProtogenClass):
2259 'Anonymous inner class'
2260 __fields=['dir_ptr', 'num2', 'name_ptr', 'version_ptr', 'vendor_ptr', 'downloaddomain_ptr', 'num7', 'filetype', 'num8', 'mimetype_ptr', 'num12']
2261
2262 def __init__(self, *args, **kwargs):
2263 dict={}
2264 dict.update(kwargs)
2266 super(_gen_p_samsungsphm300_197,self).__init__(**dict)
2268 if self.__class__ is _gen_p_samsungsphm300_197:
2269 self._update(args,dict)
2270
2271
2272 def getfields(self):
2273 return self.__fields
2274
2275
2276 def _update(self, args, kwargs):
2277 super(_gen_p_samsungsphm300_197,self)._update(args,kwargs)
2278 keys=kwargs.keys()
2279 for key in keys:
2280 if key in self.__fields:
2281 setattr(self, key, kwargs[key])
2282 del kwargs[key]
2283 if __debug__:
2285 self._complainaboutunusedargs(_gen_p_samsungsphm300_197,kwargs)
2286 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
2287
2289
2290 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
2291 'Writes this packet to the supplied buffer'
2292 self._bufferstartoffset=buf.getcurrentoffset()
2293 self.__field_dir_ptr.writetobuffer(buf)
2294 self.__field_num2.writetobuffer(buf)
2295 self.__field_name_ptr.writetobuffer(buf)
2296 self.__field_version_ptr.writetobuffer(buf)
2297 self.__field_vendor_ptr.writetobuffer(buf)
2298 self.__field_downloaddomain_ptr.writetobuffer(buf)
2299 self.__field_num7.writetobuffer(buf)
2300 self.__field_filetype.writetobuffer(buf)
2301 self.__field_num8.writetobuffer(buf)
2302 self.__field_mimetype_ptr.writetobuffer(buf)
2303 self.__field_num12.writetobuffer(buf)
2304 self._bufferendoffset=buf.getcurrentoffset()
2305 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
2306
2307
2308 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
2309 'Reads this packet from the supplied buffer'
2310 self._bufferstartoffset=buf.getcurrentoffset()
2311 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
2312 self.__field_dir_ptr=UINT(**{'sizeinbytes': 2})
2313 self.__field_dir_ptr.readfrombuffer(buf)
2314 self.__field_num2=UINT(**{'sizeinbytes': 2})
2315 self.__field_num2.readfrombuffer(buf)
2316 self.__field_name_ptr=UINT(**{'sizeinbytes': 2})
2317 self.__field_name_ptr.readfrombuffer(buf)
2318 self.__field_version_ptr=UINT(**{'sizeinbytes': 2})
2319 self.__field_version_ptr.readfrombuffer(buf)
2320 self.__field_vendor_ptr=UINT(**{'sizeinbytes': 2})
2321 self.__field_vendor_ptr.readfrombuffer(buf)
2322 self.__field_downloaddomain_ptr=UINT(**{'sizeinbytes': 2})
2323 self.__field_downloaddomain_ptr.readfrombuffer(buf)
2324 self.__field_num7=DATA(**{'sizeinbytes': 8})
2325 self.__field_num7.readfrombuffer(buf)
2326 self.__field_filetype=UINT(**{'sizeinbytes': 2})
2327 self.__field_filetype.readfrombuffer(buf)
2328 self.__field_num8=DATA(**{'sizeinbytes': 2})
2329 self.__field_num8.readfrombuffer(buf)
2330 self.__field_mimetype_ptr=UINT(**{'sizeinbytes': 2})
2331 self.__field_mimetype_ptr.readfrombuffer(buf)
2332 self.__field_num12=DATA(**{'sizeinbytes': 10})
2333 self.__field_num12.readfrombuffer(buf)
2334 self._bufferendoffset=buf.getcurrentoffset()
2335
2336
2337 def __getfield_dir_ptr(self):
2338 return self.__field_dir_ptr.getvalue()
2339
2340 def __setfield_dir_ptr(self, value):
2341 if isinstance(value,UINT):
2342 self.__field_dir_ptr=value
2343 else:
2344 self.__field_dir_ptr=UINT(value,**{'sizeinbytes': 2})
2345
2346 def __delfield_dir_ptr(self): del self.__field_dir_ptr
2347
2348 dir_ptr=property(__getfield_dir_ptr, __setfield_dir_ptr, __delfield_dir_ptr, None)
2349
2350 def __getfield_num2(self):
2351 return self.__field_num2.getvalue()
2352
2353 def __setfield_num2(self, value):
2354 if isinstance(value,UINT):
2355 self.__field_num2=value
2356 else:
2357 self.__field_num2=UINT(value,**{'sizeinbytes': 2})
2358
2359 def __delfield_num2(self): del self.__field_num2
2360
2361 num2=property(__getfield_num2, __setfield_num2, __delfield_num2, None)
2362
2363 def __getfield_name_ptr(self):
2364 return self.__field_name_ptr.getvalue()
2365
2366 def __setfield_name_ptr(self, value):
2367 if isinstance(value,UINT):
2368 self.__field_name_ptr=value
2369 else:
2370 self.__field_name_ptr=UINT(value,**{'sizeinbytes': 2})
2371
2372 def __delfield_name_ptr(self): del self.__field_name_ptr
2373
2374 name_ptr=property(__getfield_name_ptr, __setfield_name_ptr, __delfield_name_ptr, None)
2375
2376 def __getfield_version_ptr(self):
2377 return self.__field_version_ptr.getvalue()
2378
2379 def __setfield_version_ptr(self, value):
2380 if isinstance(value,UINT):
2381 self.__field_version_ptr=value
2382 else:
2383 self.__field_version_ptr=UINT(value,**{'sizeinbytes': 2})
2384
2385 def __delfield_version_ptr(self): del self.__field_version_ptr
2386
2387 version_ptr=property(__getfield_version_ptr, __setfield_version_ptr, __delfield_version_ptr, None)
2388
2389 def __getfield_vendor_ptr(self):
2390 return self.__field_vendor_ptr.getvalue()
2391
2392 def __setfield_vendor_ptr(self, value):
2393 if isinstance(value,UINT):
2394 self.__field_vendor_ptr=value
2395 else:
2396 self.__field_vendor_ptr=UINT(value,**{'sizeinbytes': 2})
2397
2398 def __delfield_vendor_ptr(self): del self.__field_vendor_ptr
2399
2400 vendor_ptr=property(__getfield_vendor_ptr, __setfield_vendor_ptr, __delfield_vendor_ptr, None)
2401
2402 def __getfield_downloaddomain_ptr(self):
2403 return self.__field_downloaddomain_ptr.getvalue()
2404
2405 def __setfield_downloaddomain_ptr(self, value):
2406 if isinstance(value,UINT):
2407 self.__field_downloaddomain_ptr=value
2408 else:
2409 self.__field_downloaddomain_ptr=UINT(value,**{'sizeinbytes': 2})
2410
2411 def __delfield_downloaddomain_ptr(self): del self.__field_downloaddomain_ptr
2412
2413 downloaddomain_ptr=property(__getfield_downloaddomain_ptr, __setfield_downloaddomain_ptr, __delfield_downloaddomain_ptr, None)
2414
2415 def __getfield_num7(self):
2416 return self.__field_num7.getvalue()
2417
2418 def __setfield_num7(self, value):
2419 if isinstance(value,DATA):
2420 self.__field_num7=value
2421 else:
2422 self.__field_num7=DATA(value,**{'sizeinbytes': 8})
2423
2424 def __delfield_num7(self): del self.__field_num7
2425
2426 num7=property(__getfield_num7, __setfield_num7, __delfield_num7, None)
2427
2428 def __getfield_filetype(self):
2429 return self.__field_filetype.getvalue()
2430
2431 def __setfield_filetype(self, value):
2432 if isinstance(value,UINT):
2433 self.__field_filetype=value
2434 else:
2435 self.__field_filetype=UINT(value,**{'sizeinbytes': 2})
2436
2437 def __delfield_filetype(self): del self.__field_filetype
2438
2439 filetype=property(__getfield_filetype, __setfield_filetype, __delfield_filetype, "12: Ringer, 13 Screen Saver, 15 Apps")
2440
2441 def __getfield_num8(self):
2442 return self.__field_num8.getvalue()
2443
2444 def __setfield_num8(self, value):
2445 if isinstance(value,DATA):
2446 self.__field_num8=value
2447 else:
2448 self.__field_num8=DATA(value,**{'sizeinbytes': 2})
2449
2450 def __delfield_num8(self): del self.__field_num8
2451
2452 num8=property(__getfield_num8, __setfield_num8, __delfield_num8, None)
2453
2454 def __getfield_mimetype_ptr(self):
2455 return self.__field_mimetype_ptr.getvalue()
2456
2457 def __setfield_mimetype_ptr(self, value):
2458 if isinstance(value,UINT):
2459 self.__field_mimetype_ptr=value
2460 else:
2461 self.__field_mimetype_ptr=UINT(value,**{'sizeinbytes': 2})
2462
2463 def __delfield_mimetype_ptr(self): del self.__field_mimetype_ptr
2464
2465 mimetype_ptr=property(__getfield_mimetype_ptr, __setfield_mimetype_ptr, __delfield_mimetype_ptr, None)
2466
2467 def __getfield_num12(self):
2468 return self.__field_num12.getvalue()
2469
2470 def __setfield_num12(self, value):
2471 if isinstance(value,DATA):
2472 self.__field_num12=value
2473 else:
2474 self.__field_num12=DATA(value,**{'sizeinbytes': 10})
2475
2476 def __delfield_num12(self): del self.__field_num12
2477
2478 num12=property(__getfield_num12, __setfield_num12, __delfield_num12, None)
2479
2480 def iscontainer(self):
2481 return True
2482
2483 def containerelements(self):
2484 yield ('dir_ptr', self.__field_dir_ptr, None)
2485 yield ('num2', self.__field_num2, None)
2486 yield ('name_ptr', self.__field_name_ptr, None)
2487 yield ('version_ptr', self.__field_version_ptr, None)
2488 yield ('vendor_ptr', self.__field_vendor_ptr, None)
2489 yield ('downloaddomain_ptr', self.__field_downloaddomain_ptr, None)
2490 yield ('num7', self.__field_num7, None)
2491 yield ('filetype', self.__field_filetype, "12: Ringer, 13 Screen Saver, 15 Apps")
2492 yield ('num8', self.__field_num8, None)
2493 yield ('mimetype_ptr', self.__field_mimetype_ptr, None)
2494 yield ('num12', self.__field_num12, None)
2495
2496
2497
2498
2499 class CamFile(BaseProtogenClass):
2500 __fields=['dunno0', 'dunno1', 'caption', 'dunno2', 'dunno3', 'datetime', 'dunno4', 'pad', 'jpeg']
2501
2502 def __init__(self, *args, **kwargs):
2503 dict={}
2504 dict.update(kwargs)
2506 super(CamFile,self).__init__(**dict)
2508 if self.__class__ is CamFile:
2509 self._update(args,dict)
2510
2511
2512 def getfields(self):
2513 return self.__fields
2514
2515
2516 def _update(self, args, kwargs):
2517 super(CamFile,self)._update(args,kwargs)
2518 keys=kwargs.keys()
2519 for key in keys:
2520 if key in self.__fields:
2521 setattr(self, key, kwargs[key])
2522 del kwargs[key]
2523 if __debug__:
2525 self._complainaboutunusedargs(CamFile,kwargs)
2526 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
2527
2529
2530 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
2531 'Writes this packet to the supplied buffer'
2532 self._bufferstartoffset=buf.getcurrentoffset()
2533 self.__field_dunno0.writetobuffer(buf)
2534 self.__field_dunno1.writetobuffer(buf)
2535 self.__field_caption.writetobuffer(buf)
2536 self.__field_dunno2.writetobuffer(buf)
2537 self.__field_dunno3.writetobuffer(buf)
2538 self.__field_datetime.writetobuffer(buf)
2539 self.__field_dunno4.writetobuffer(buf)
2540 self.__field_pad.writetobuffer(buf)
2541 self.__field_jpeg.writetobuffer(buf)
2542 self._bufferendoffset=buf.getcurrentoffset()
2543 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
2544
2545
2546 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
2547 'Reads this packet from the supplied buffer'
2548 self._bufferstartoffset=buf.getcurrentoffset()
2549 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
2550 self.__field_dunno0=UINT(**{'sizeinbytes': 4})
2551 self.__field_dunno0.readfrombuffer(buf)
2552 self.__field_dunno1=UINT(**{'sizeinbytes': 1})
2553 self.__field_dunno1.readfrombuffer(buf)
2554 self.__field_caption=USTRING(**{'sizeinbytes': 16, 'pascal': True, 'terminator': None})
2555 self.__field_caption.readfrombuffer(buf)
2556 self.__field_dunno2=UINT(**{'sizeinbytes': 1})
2557 self.__field_dunno2.readfrombuffer(buf)
2558 self.__field_dunno3=DATA(**{'sizeinbytes': 2})
2559 self.__field_dunno3.readfrombuffer(buf)
2560 self.__field_datetime=DateTime(**{'sizeinbytes': 4})
2561 self.__field_datetime.readfrombuffer(buf)
2562 self.__field_dunno4=UINT(**{'sizeinbytes': 1})
2563 self.__field_dunno4.readfrombuffer(buf)
2564 self.__field_pad=DATA(**{'sizeinbytes': 99})
2565 self.__field_pad.readfrombuffer(buf)
2566 self.__field_jpeg=DATA()
2567 self.__field_jpeg.readfrombuffer(buf)
2568 self._bufferendoffset=buf.getcurrentoffset()
2569
2570
2571 def __getfield_dunno0(self):
2572 return self.__field_dunno0.getvalue()
2573
2574 def __setfield_dunno0(self, value):
2575 if isinstance(value,UINT):
2576 self.__field_dunno0=value
2577 else:
2578 self.__field_dunno0=UINT(value,**{'sizeinbytes': 4})
2579
2580 def __delfield_dunno0(self): del self.__field_dunno0
2581
2582 dunno0=property(__getfield_dunno0, __setfield_dunno0, __delfield_dunno0, None)
2583
2584 def __getfield_dunno1(self):
2585 return self.__field_dunno1.getvalue()
2586
2587 def __setfield_dunno1(self, value):
2588 if isinstance(value,UINT):
2589 self.__field_dunno1=value
2590 else:
2591 self.__field_dunno1=UINT(value,**{'sizeinbytes': 1})
2592
2593 def __delfield_dunno1(self): del self.__field_dunno1
2594
2595 dunno1=property(__getfield_dunno1, __setfield_dunno1, __delfield_dunno1, None)
2596
2597 def __getfield_caption(self):
2598 return self.__field_caption.getvalue()
2599
2600 def __setfield_caption(self, value):
2601 if isinstance(value,USTRING):
2602 self.__field_caption=value
2603 else:
2604 self.__field_caption=USTRING(value,**{'sizeinbytes': 16, 'pascal': True, 'terminator': None})
2605
2606 def __delfield_caption(self): del self.__field_caption
2607
2608 caption=property(__getfield_caption, __setfield_caption, __delfield_caption, None)
2609
2610 def __getfield_dunno2(self):
2611 return self.__field_dunno2.getvalue()
2612
2613 def __setfield_dunno2(self, value):
2614 if isinstance(value,UINT):
2615 self.__field_dunno2=value
2616 else:
2617 self.__field_dunno2=UINT(value,**{'sizeinbytes': 1})
2618
2619 def __delfield_dunno2(self): del self.__field_dunno2
2620
2621 dunno2=property(__getfield_dunno2, __setfield_dunno2, __delfield_dunno2, None)
2622
2623 def __getfield_dunno3(self):
2624 return self.__field_dunno3.getvalue()
2625
2626 def __setfield_dunno3(self, value):
2627 if isinstance(value,DATA):
2628 self.__field_dunno3=value
2629 else:
2630 self.__field_dunno3=DATA(value,**{'sizeinbytes': 2})
2631
2632 def __delfield_dunno3(self): del self.__field_dunno3
2633
2634 dunno3=property(__getfield_dunno3, __setfield_dunno3, __delfield_dunno3, None)
2635
2636 def __getfield_datetime(self):
2637 return self.__field_datetime.getvalue()
2638
2639 def __setfield_datetime(self, value):
2640 if isinstance(value,DateTime):
2641 self.__field_datetime=value
2642 else:
2643 self.__field_datetime=DateTime(value,**{'sizeinbytes': 4})
2644
2645 def __delfield_datetime(self): del self.__field_datetime
2646
2647 datetime=property(__getfield_datetime, __setfield_datetime, __delfield_datetime, None)
2648
2649 def __getfield_dunno4(self):
2650 return self.__field_dunno4.getvalue()
2651
2652 def __setfield_dunno4(self, value):
2653 if isinstance(value,UINT):
2654 self.__field_dunno4=value
2655 else:
2656 self.__field_dunno4=UINT(value,**{'sizeinbytes': 1})
2657
2658 def __delfield_dunno4(self): del self.__field_dunno4
2659
2660 dunno4=property(__getfield_dunno4, __setfield_dunno4, __delfield_dunno4, None)
2661
2662 def __getfield_pad(self):
2663 return self.__field_pad.getvalue()
2664
2665 def __setfield_pad(self, value):
2666 if isinstance(value,DATA):
2667 self.__field_pad=value
2668 else:
2669 self.__field_pad=DATA(value,**{'sizeinbytes': 99})
2670
2671 def __delfield_pad(self): del self.__field_pad
2672
2673 pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None)
2674
2675 def __getfield_jpeg(self):
2676 return self.__field_jpeg.getvalue()
2677
2678 def __setfield_jpeg(self, value):
2679 if isinstance(value,DATA):
2680 self.__field_jpeg=value
2681 else:
2682 self.__field_jpeg=DATA(value,)
2683
2684 def __delfield_jpeg(self): del self.__field_jpeg
2685
2686 jpeg=property(__getfield_jpeg, __setfield_jpeg, __delfield_jpeg, None)
2687
2688 def iscontainer(self):
2689 return True
2690
2691 def containerelements(self):
2692 yield ('dunno0', self.__field_dunno0, None)
2693 yield ('dunno1', self.__field_dunno1, None)
2694 yield ('caption', self.__field_caption, None)
2695 yield ('dunno2', self.__field_dunno2, None)
2696 yield ('dunno3', self.__field_dunno3, None)
2697 yield ('datetime', self.__field_datetime, None)
2698 yield ('dunno4', self.__field_dunno4, None)
2699 yield ('pad', self.__field_pad, None)
2700 yield ('jpeg', self.__field_jpeg, None)
2701
2702 def _filename(self):
2703 return '%(year)04d%(month)02d%(day)02d_%(name)s.jpg'%\
2704 { 'year': self.datetime[0],
2705 'month': self.datetime[1],
2706 'day': self.datetime[2],
2707 'name': self.caption,
2708 }
2709 filename=property(fget=_filename)
2710 def save(self, filename=None):
2711 return file(filename if filename else self.filename, 'wb').write(self.jpeg)
2713
2714
2715
2716
2717 class IndexSlot(BaseProtogenClass):
2718 __fields=['valid', 'group', 'index']
2719
2720 def __init__(self, *args, **kwargs):
2721 dict={}
2722 dict.update(kwargs)
2724 super(IndexSlot,self).__init__(**dict)
2726 if self.__class__ is IndexSlot:
2727 self._update(args,dict)
2728
2729
2730 def getfields(self):
2731 return self.__fields
2732
2733
2734 def _update(self, args, kwargs):
2735 super(IndexSlot,self)._update(args,kwargs)
2736 keys=kwargs.keys()
2737 for key in keys:
2738 if key in self.__fields:
2739 setattr(self, key, kwargs[key])
2740 del kwargs[key]
2741 if __debug__:
2743 self._complainaboutunusedargs(IndexSlot,kwargs)
2744 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
2745
2747
2748 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
2749 'Writes this packet to the supplied buffer'
2750 self._bufferstartoffset=buf.getcurrentoffset()
2751 try: self.__field_valid
2752 except:
2753 self.__field_valid=UINT(**{'sizeinbytes': 1, 'default': 0 })
2754 self.__field_valid.writetobuffer(buf)
2755 try: self.__field_group
2756 except:
2757 self.__field_group=UINT(**{'sizeinbytes': 1, 'default': 0 })
2758 self.__field_group.writetobuffer(buf)
2759 try: self.__field_index
2760 except:
2761 self.__field_index=UINT(**{'sizeinbytes': 1, 'default': 0 })
2762 self.__field_index.writetobuffer(buf)
2763 self._bufferendoffset=buf.getcurrentoffset()
2764 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
2765
2766
2767 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
2768 'Reads this packet from the supplied buffer'
2769 self._bufferstartoffset=buf.getcurrentoffset()
2770 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
2771 self.__field_valid=UINT(**{'sizeinbytes': 1, 'default': 0 })
2772 self.__field_valid.readfrombuffer(buf)
2773 self.__field_group=UINT(**{'sizeinbytes': 1, 'default': 0 })
2774 self.__field_group.readfrombuffer(buf)
2775 self.__field_index=UINT(**{'sizeinbytes': 1, 'default': 0 })
2776 self.__field_index.readfrombuffer(buf)
2777 self._bufferendoffset=buf.getcurrentoffset()
2778
2779
2780 def __getfield_valid(self):
2781 try: self.__field_valid
2782 except:
2783 self.__field_valid=UINT(**{'sizeinbytes': 1, 'default': 0 })
2784 return self.__field_valid.getvalue()
2785
2786 def __setfield_valid(self, value):
2787 if isinstance(value,UINT):
2788 self.__field_valid=value
2789 else:
2790 self.__field_valid=UINT(value,**{'sizeinbytes': 1, 'default': 0 })
2791
2792 def __delfield_valid(self): del self.__field_valid
2793
2794 valid=property(__getfield_valid, __setfield_valid, __delfield_valid, "=1 if valid slot")
2795
2796 def __getfield_group(self):
2797 try: self.__field_group
2798 except:
2799 self.__field_group=UINT(**{'sizeinbytes': 1, 'default': 0 })
2800 return self.__field_group.getvalue()
2801
2802 def __setfield_group(self, value):
2803 if isinstance(value,UINT):
2804 self.__field_group=value
2805 else:
2806 self.__field_group=UINT(value,**{'sizeinbytes': 1, 'default': 0 })
2807
2808 def __delfield_group(self): del self.__field_group
2809
2810 group=property(__getfield_group, __setfield_group, __delfield_group, "Group Index")
2811
2812 def __getfield_index(self):
2813 try: self.__field_index
2814 except:
2815 self.__field_index=UINT(**{'sizeinbytes': 1, 'default': 0 })
2816 return self.__field_index.getvalue()
2817
2818 def __setfield_index(self, value):
2819 if isinstance(value,UINT):
2820 self.__field_index=value
2821 else:
2822 self.__field_index=UINT(value,**{'sizeinbytes': 1, 'default': 0 })
2823
2824 def __delfield_index(self): del self.__field_index
2825
2826 index=property(__getfield_index, __setfield_index, __delfield_index, "Media Index")
2827
2828 def iscontainer(self):
2829 return True
2830
2831 def containerelements(self):
2832 yield ('valid', self.__field_valid, "=1 if valid slot")
2833 yield ('group', self.__field_group, "Group Index")
2834 yield ('index', self.__field_index, "Media Index")
2835
2836
2837
2838
2839 class IndexFile(BaseProtogenClass):
2840 __fields=['entry']
2841
2842 def __init__(self, *args, **kwargs):
2843 dict={}
2844 dict.update(kwargs)
2846 super(IndexFile,self).__init__(**dict)
2848 if self.__class__ is IndexFile:
2849 self._update(args,dict)
2850
2851
2852 def getfields(self):
2853 return self.__fields
2854
2855
2856 def _update(self, args, kwargs):
2857 super(IndexFile,self)._update(args,kwargs)
2858 keys=kwargs.keys()
2859 for key in keys:
2860 if key in self.__fields:
2861 setattr(self, key, kwargs[key])
2862 del kwargs[key]
2863 if __debug__:
2865 self._complainaboutunusedargs(IndexFile,kwargs)
2866 if len(args):
2867 dict2={ 'elementclass': IndexSlot, 'length': max_media_index_entries, 'createdefault': True }
2868 dict2.update(kwargs)
2869 kwargs=dict2
2870 self.__field_entry=LIST(*args,**dict2)
2871
2873
2874 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
2875 'Writes this packet to the supplied buffer'
2876 self._bufferstartoffset=buf.getcurrentoffset()
2877 try: self.__field_entry
2878 except:
2879 self.__field_entry=LIST(**{ 'elementclass': IndexSlot, 'length': max_media_index_entries, 'createdefault': True })
2880 self.__field_entry.writetobuffer(buf)
2881 self._bufferendoffset=buf.getcurrentoffset()
2882 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
2883
2884
2885 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
2886 'Reads this packet from the supplied buffer'
2887 self._bufferstartoffset=buf.getcurrentoffset()
2888 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
2889 self.__field_entry=LIST(**{ 'elementclass': IndexSlot, 'length': max_media_index_entries, 'createdefault': True })
2890 self.__field_entry.readfrombuffer(buf)
2891 self._bufferendoffset=buf.getcurrentoffset()
2892
2893
2894 def __getfield_entry(self):
2895 try: self.__field_entry
2896 except:
2897 self.__field_entry=LIST(**{ 'elementclass': IndexSlot, 'length': max_media_index_entries, 'createdefault': True })
2898 return self.__field_entry.getvalue()
2899
2900 def __setfield_entry(self, value):
2901 if isinstance(value,LIST):
2902 self.__field_entry=value
2903 else:
2904 self.__field_entry=LIST(value,**{ 'elementclass': IndexSlot, 'length': max_media_index_entries, 'createdefault': True })
2905
2906 def __delfield_entry(self): del self.__field_entry
2907
2908 entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None)
2909
2910 def iscontainer(self):
2911 return True
2912
2913 def containerelements(self):
2914 yield ('entry', self.__field_entry, None)
2915
2916
2917
2918
2919 class Group(BaseProtogenClass):
2920 __fields=['num0', 'num1', 'namelen', 'namestr', 'num5', 'dunno', 'nume3', 'datetime', 'num4']
2921
2922 def __init__(self, *args, **kwargs):
2923 dict={}
2924 dict.update(kwargs)
2926 super(Group,self).__init__(**dict)
2928 if self.__class__ is Group:
2929 self._update(args,dict)
2930
2931
2932 def getfields(self):
2933 return self.__fields
2934
2935
2936 def _update(self, args, kwargs):
2937 super(Group,self)._update(args,kwargs)
2938 keys=kwargs.keys()
2939 for key in keys:
2940 if key in self.__fields:
2941 setattr(self, key, kwargs[key])
2942 del kwargs[key]
2943 if __debug__:
2945 self._complainaboutunusedargs(Group,kwargs)
2946 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
2947
2949
2950 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
2951 'Writes this packet to the supplied buffer'
2952 self._bufferstartoffset=buf.getcurrentoffset()
2953 try: self.__field_num0
2954 except:
2955 self.__field_num0=UINT(**{'sizeinbytes': 1, 'default': 0 })
2956 self.__field_num0.writetobuffer(buf)
2957 try: self.__field_num1
2958 except:
2959 self.__field_num1=UINT(**{'sizeinbytes': 1, 'default': 1 if self.num0 else 0 })
2960 self.__field_num1.writetobuffer(buf)
2961 try: self.__field_namelen
2962 except:
2963 self.__field_namelen=UINT(**{'sizeinbytes': 2, 'default': 0 })
2964 self.__field_namelen.writetobuffer(buf)
2965 try: self.__field_namestr
2966 except:
2967 self.__field_namestr=USTRING(**{'sizeinbytes': 12, 'terminator': None, 'default': '' })
2968 self.__field_namestr.writetobuffer(buf)
2969 try: self.__field_num5
2970 except:
2971 self.__field_num5=UINT(**{'sizeinbytes': 1, 'default': 0x30 if self.num0 else 0 })
2972 self.__field_num5.writetobuffer(buf)
2973 try: self.__field_dunno
2974 except: