0001
0003 """Various descriptions of data specific to the Samsung SCH-A870 Phone"""
0004
0005 from prototypes import *
0006 from prototypes_samsung import *
0007 from p_brew import *
0008 from p_samsungscha950 import *
0009 from common import basename
0010
0011 UINT=UINTlsb
0013 BOOL=BOOLlsb
0014
0015 CAL_PATH='sch_event'
0017 CAL_INDEX_FILE_NAME=CAL_PATH+'/usr_tsk'
0018 CAL_FILE_NAME_PREFIX=CAL_PATH+'/usr_tsk_'
0019 CAL_MAX_EVENTS=100
0020
0021 CAL_REMINDER_OFF=0
0022 CAL_REMINDER_ONCE=1
0023 CAL_REMINDER_2MIN=2
0024 CAL_REMINDER_15MIN=3
0025
0026 GROUP_INDEX_FILE_NAME='pb/group_name.dat'
0027
0028 CL_MAX_ENTRIES=90
0030
0031 PB_FLG_CRINGTONE=0X4000
0032
0033 PIC_INDEX_HDR='0|/brew/16452/mp|\x0A'
0034
0035 class PictureIndexEntry(BaseProtogenClass):
0036 __fields=['filename', 'name', 'pathname', 'dunno1', 'filesize']
0037
0038 def __init__(self, *args, **kwargs):
0039 dict={}
0040 dict.update(kwargs)
0042 super(PictureIndexEntry,self).__init__(**dict)
0044 if self.__class__ is PictureIndexEntry:
0045 self._update(args,dict)
0046
0047
0048 def getfields(self):
0049 return self.__fields
0050
0051
0052 def _update(self, args, kwargs):
0053 super(PictureIndexEntry,self)._update(args,kwargs)
0054 keys=kwargs.keys()
0055 for key in keys:
0056 if key in self.__fields:
0057 setattr(self, key, kwargs[key])
0058 del kwargs[key]
0059 if __debug__:
0061 self._complainaboutunusedargs(PictureIndexEntry,kwargs)
0062 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0063 try: self.__field_filename
0065 except:
0066 self.__field_filename=STRING(**{ 'default': '' })
0067
0068
0069 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0070 'Writes this packet to the supplied buffer'
0071 self._bufferstartoffset=buf.getcurrentoffset()
0072 try: self.__field_name
0073 except:
0074 self.__field_name=STRING(**{'sizeinbytes': 64, 'terminator': 0, 'default': self._name() })
0075 self.__field_name.writetobuffer(buf)
0076 try: self.__field_pathname
0077 except:
0078 self.__field_pathname=STRING(**{'sizeinbytes': 58, 'terminator': 0, 'default': self._pathname() })
0079 self.__field_pathname.writetobuffer(buf)
0080 try: self.__field_dunno1
0081 except:
0082 self.__field_dunno1=UINT(**{'sizeinbytes': 2, 'default': 0x0300 })
0083 self.__field_dunno1.writetobuffer(buf)
0084 self.__field_filesize.writetobuffer(buf)
0085 self._bufferendoffset=buf.getcurrentoffset()
0086 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0087
0088
0089 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0090 'Reads this packet from the supplied buffer'
0091 self._bufferstartoffset=buf.getcurrentoffset()
0092 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0093 self.__field_name=STRING(**{'sizeinbytes': 64, 'terminator': 0, 'default': self._name() })
0094 self.__field_name.readfrombuffer(buf)
0095 self.__field_pathname=STRING(**{'sizeinbytes': 58, 'terminator': 0, 'default': self._pathname() })
0096 self.__field_pathname.readfrombuffer(buf)
0097 self.__field_dunno1=UINT(**{'sizeinbytes': 2, 'default': 0x0300 })
0098 self.__field_dunno1.readfrombuffer(buf)
0099 self.__field_filesize=UINT(**{'sizeinbytes': 4})
0100 self.__field_filesize.readfrombuffer(buf)
0101 self._bufferendoffset=buf.getcurrentoffset()
0102
0103
0104 def __getfield_filename(self):
0105 try: self.__field_filename
0106 except:
0107 self.__field_filename=STRING(**{ 'default': '' })
0108 return self.__field_filename.getvalue()
0109
0110 def __setfield_filename(self, value):
0111 if isinstance(value,STRING):
0112 self.__field_filename=value
0113 else:
0114 self.__field_filename=STRING(value,**{ 'default': '' })
0115
0116 def __delfield_filename(self): del self.__field_filename
0117
0118 filename=property(__getfield_filename, __setfield_filename, __delfield_filename, None)
0119
0120 def __getfield_name(self):
0121 try: self.__field_name
0122 except:
0123 self.__field_name=STRING(**{'sizeinbytes': 64, 'terminator': 0, 'default': self._name() })
0124 return self.__field_name.getvalue()
0125
0126 def __setfield_name(self, value):
0127 if isinstance(value,STRING):
0128 self.__field_name=value
0129 else:
0130 self.__field_name=STRING(value,**{'sizeinbytes': 64, 'terminator': 0, 'default': self._name() })
0131
0132 def __delfield_name(self): del self.__field_name
0133
0134 name=property(__getfield_name, __setfield_name, __delfield_name, None)
0135
0136 def __getfield_pathname(self):
0137 try: self.__field_pathname
0138 except:
0139 self.__field_pathname=STRING(**{'sizeinbytes': 58, 'terminator': 0, 'default': self._pathname() })
0140 return self.__field_pathname.getvalue()
0141
0142 def __setfield_pathname(self, value):
0143 if isinstance(value,STRING):
0144 self.__field_pathname=value
0145 else:
0146 self.__field_pathname=STRING(value,**{'sizeinbytes': 58, 'terminator': 0, 'default': self._pathname() })
0147
0148 def __delfield_pathname(self): del self.__field_pathname
0149
0150 pathname=property(__getfield_pathname, __setfield_pathname, __delfield_pathname, None)
0151
0152 def __getfield_dunno1(self):
0153 try: self.__field_dunno1
0154 except:
0155 self.__field_dunno1=UINT(**{'sizeinbytes': 2, 'default': 0x0300 })
0156 return self.__field_dunno1.getvalue()
0157
0158 def __setfield_dunno1(self, value):
0159 if isinstance(value,UINT):
0160 self.__field_dunno1=value
0161 else:
0162 self.__field_dunno1=UINT(value,**{'sizeinbytes': 2, 'default': 0x0300 })
0163
0164 def __delfield_dunno1(self): del self.__field_dunno1
0165
0166 dunno1=property(__getfield_dunno1, __setfield_dunno1, __delfield_dunno1, None)
0167
0168 def __getfield_filesize(self):
0169 return self.__field_filesize.getvalue()
0170
0171 def __setfield_filesize(self, value):
0172 if isinstance(value,UINT):
0173 self.__field_filesize=value
0174 else:
0175 self.__field_filesize=UINT(value,**{'sizeinbytes': 4})
0176
0177 def __delfield_filesize(self): del self.__field_filesize
0178
0179 filesize=property(__getfield_filesize, __setfield_filesize, __delfield_filesize, None)
0180
0181 def iscontainer(self):
0182 return True
0183
0184 def containerelements(self):
0185 yield ('filename', self.__field_filename, None)
0186 yield ('name', self.__field_name, None)
0187 yield ('pathname', self.__field_pathname, None)
0188 yield ('dunno1', self.__field_dunno1, None)
0189 yield ('filesize', self.__field_filesize, None)
0190
0191 def _name(self):
0192 return '%(base)s.%(ext)s' % {
0193 'base': common.stripext(self.filename)[:10],
0194 'ext': common.getext(self.filename) }
0195 def _pathname(self):
0196 global PIC_PATH
0197 return '/%(path)s/%(filename)s'%{
0198 'path': PIC_PATH,
0199 'filename': self.filename }
0200
0201
0202
0203
0204 class PictureIndexFile(BaseProtogenClass):
0205 __fields=['header', 'items']
0206
0207 def __init__(self, *args, **kwargs):
0208 dict={}
0209 dict.update(kwargs)
0211 super(PictureIndexFile,self).__init__(**dict)
0213 if self.__class__ is PictureIndexFile:
0214 self._update(args,dict)
0215
0216
0217 def getfields(self):
0218 return self.__fields
0219
0220
0221 def _update(self, args, kwargs):
0222 super(PictureIndexFile,self)._update(args,kwargs)
0223 keys=kwargs.keys()
0224 for key in keys:
0225 if key in self.__fields:
0226 setattr(self, key, kwargs[key])
0227 del kwargs[key]
0228 if __debug__:
0230 self._complainaboutunusedargs(PictureIndexFile,kwargs)
0231 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0232
0234
0235 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0236 'Writes this packet to the supplied buffer'
0237 self._bufferstartoffset=buf.getcurrentoffset()
0238 try: self.__field_header
0239 except:
0240 self.__field_header=STRING(**{'sizeinbytes': 128, 'terminator': 0, 'default': PIC_INDEX_HDR })
0241 self.__field_header.writetobuffer(buf)
0242 try: self.__field_items
0243 except:
0244 self.__field_items=LIST(**{ 'elementclass': PictureIndexEntry })
0245 self.__field_items.writetobuffer(buf)
0246 self._bufferendoffset=buf.getcurrentoffset()
0247 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0248
0249
0250 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0251 'Reads this packet from the supplied buffer'
0252 self._bufferstartoffset=buf.getcurrentoffset()
0253 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0254 self.__field_header=STRING(**{'sizeinbytes': 128, 'terminator': 0, 'default': PIC_INDEX_HDR })
0255 self.__field_header.readfrombuffer(buf)
0256 self.__field_items=LIST(**{ 'elementclass': PictureIndexEntry })
0257 self.__field_items.readfrombuffer(buf)
0258 self._bufferendoffset=buf.getcurrentoffset()
0259
0260
0261 def __getfield_header(self):
0262 try: self.__field_header
0263 except:
0264 self.__field_header=STRING(**{'sizeinbytes': 128, 'terminator': 0, 'default': PIC_INDEX_HDR })
0265 return self.__field_header.getvalue()
0266
0267 def __setfield_header(self, value):
0268 if isinstance(value,STRING):
0269 self.__field_header=value
0270 else:
0271 self.__field_header=STRING(value,**{'sizeinbytes': 128, 'terminator': 0, 'default': PIC_INDEX_HDR })
0272
0273 def __delfield_header(self): del self.__field_header
0274
0275 header=property(__getfield_header, __setfield_header, __delfield_header, None)
0276
0277 def __getfield_items(self):
0278 try: self.__field_items
0279 except:
0280 self.__field_items=LIST(**{ 'elementclass': PictureIndexEntry })
0281 return self.__field_items.getvalue()
0282
0283 def __setfield_items(self, value):
0284 if isinstance(value,LIST):
0285 self.__field_items=value
0286 else:
0287 self.__field_items=LIST(value,**{ 'elementclass': PictureIndexEntry })
0288
0289 def __delfield_items(self): del self.__field_items
0290
0291 items=property(__getfield_items, __setfield_items, __delfield_items, None)
0292
0293 def iscontainer(self):
0294 return True
0295
0296 def containerelements(self):
0297 yield ('header', self.__field_header, None)
0298 yield ('items', self.__field_items, None)
0299
0300
0301
0302
0303 class GroupEntry(BaseProtogenClass):
0304 __fields=['name', 'index', 'numofmembers', 'dunno1']
0305
0306 def __init__(self, *args, **kwargs):
0307 dict={}
0308 dict.update(kwargs)
0310 super(GroupEntry,self).__init__(**dict)
0312 if self.__class__ is GroupEntry:
0313 self._update(args,dict)
0314
0315
0316 def getfields(self):
0317 return self.__fields
0318
0319
0320 def _update(self, args, kwargs):
0321 super(GroupEntry,self)._update(args,kwargs)
0322 keys=kwargs.keys()
0323 for key in keys:
0324 if key in self.__fields:
0325 setattr(self, key, kwargs[key])
0326 del kwargs[key]
0327 if __debug__:
0329 self._complainaboutunusedargs(GroupEntry,kwargs)
0330 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0331
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_name.writetobuffer(buf)
0338 self.__field_index.writetobuffer(buf)
0339 self.__field_numofmembers.writetobuffer(buf)
0340 self.__field_dunno1.writetobuffer(buf)
0341 self._bufferendoffset=buf.getcurrentoffset()
0342 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0343
0344
0345 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0346 'Reads this packet from the supplied buffer'
0347 self._bufferstartoffset=buf.getcurrentoffset()
0348 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0349 self.__field_name=USTRING(**{'sizeinbytes': 65, 'encoding': ENCODING, 'terminator': 0 })
0350 self.__field_name.readfrombuffer(buf)
0351 self.__field_index=UINT(**{'sizeinbytes': 3})
0352 self.__field_index.readfrombuffer(buf)
0353 self.__field_numofmembers=UINT(**{'sizeinbytes': 4})
0354 self.__field_numofmembers.readfrombuffer(buf)
0355 self.__field_dunno1=UNKNOWN(**{'sizeinbytes': 4})
0356 self.__field_dunno1.readfrombuffer(buf)
0357 self._bufferendoffset=buf.getcurrentoffset()
0358
0359
0360 def __getfield_name(self):
0361 return self.__field_name.getvalue()
0362
0363 def __setfield_name(self, value):
0364 if isinstance(value,USTRING):
0365 self.__field_name=value
0366 else:
0367 self.__field_name=USTRING(value,**{'sizeinbytes': 65, 'encoding': ENCODING, 'terminator': 0 })
0368
0369 def __delfield_name(self): del self.__field_name
0370
0371 name=property(__getfield_name, __setfield_name, __delfield_name, None)
0372
0373 def __getfield_index(self):
0374 return self.__field_index.getvalue()
0375
0376 def __setfield_index(self, value):
0377 if isinstance(value,UINT):
0378 self.__field_index=value
0379 else:
0380 self.__field_index=UINT(value,**{'sizeinbytes': 3})
0381
0382 def __delfield_index(self): del self.__field_index
0383
0384 index=property(__getfield_index, __setfield_index, __delfield_index, None)
0385
0386 def __getfield_numofmembers(self):
0387 return self.__field_numofmembers.getvalue()
0388
0389 def __setfield_numofmembers(self, value):
0390 if isinstance(value,UINT):
0391 self.__field_numofmembers=value
0392 else:
0393 self.__field_numofmembers=UINT(value,**{'sizeinbytes': 4})
0394
0395 def __delfield_numofmembers(self): del self.__field_numofmembers
0396
0397 numofmembers=property(__getfield_numofmembers, __setfield_numofmembers, __delfield_numofmembers, None)
0398
0399 def __getfield_dunno1(self):
0400 return self.__field_dunno1.getvalue()
0401
0402 def __setfield_dunno1(self, value):
0403 if isinstance(value,UNKNOWN):
0404 self.__field_dunno1=value
0405 else:
0406 self.__field_dunno1=UNKNOWN(value,**{'sizeinbytes': 4})
0407
0408 def __delfield_dunno1(self): del self.__field_dunno1
0409
0410 dunno1=property(__getfield_dunno1, __setfield_dunno1, __delfield_dunno1, None)
0411
0412 def iscontainer(self):
0413 return True
0414
0415 def containerelements(self):
0416 yield ('name', self.__field_name, None)
0417 yield ('index', self.__field_index, None)
0418 yield ('numofmembers', self.__field_numofmembers, None)
0419 yield ('dunno1', self.__field_dunno1, None)
0420
0421
0422
0423
0424 class GroupIndexFile(BaseProtogenClass):
0425 __fields=['items']
0426
0427 def __init__(self, *args, **kwargs):
0428 dict={}
0429 dict.update(kwargs)
0431 super(GroupIndexFile,self).__init__(**dict)
0433 if self.__class__ is GroupIndexFile:
0434 self._update(args,dict)
0435
0436
0437 def getfields(self):
0438 return self.__fields
0439
0440
0441 def _update(self, args, kwargs):
0442 super(GroupIndexFile,self)._update(args,kwargs)
0443 keys=kwargs.keys()
0444 for key in keys:
0445 if key in self.__fields:
0446 setattr(self, key, kwargs[key])
0447 del kwargs[key]
0448 if __debug__:
0450 self._complainaboutunusedargs(GroupIndexFile,kwargs)
0451 if len(args):
0452 dict2={ 'elementclass': GroupEntry }
0453 dict2.update(kwargs)
0454 kwargs=dict2
0455 self.__field_items=LIST(*args,**dict2)
0456
0458
0459 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0460 'Writes this packet to the supplied buffer'
0461 self._bufferstartoffset=buf.getcurrentoffset()
0462 try: self.__field_items
0463 except:
0464 self.__field_items=LIST(**{ 'elementclass': GroupEntry })
0465 self.__field_items.writetobuffer(buf)
0466 self._bufferendoffset=buf.getcurrentoffset()
0467 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0468
0469
0470 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0471 'Reads this packet from the supplied buffer'
0472 self._bufferstartoffset=buf.getcurrentoffset()
0473 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0474 self.__field_items=LIST(**{ 'elementclass': GroupEntry })
0475 self.__field_items.readfrombuffer(buf)
0476 self._bufferendoffset=buf.getcurrentoffset()
0477
0478
0479 def __getfield_items(self):
0480 try: self.__field_items
0481 except:
0482 self.__field_items=LIST(**{ 'elementclass': GroupEntry })
0483 return self.__field_items.getvalue()
0484
0485 def __setfield_items(self, value):
0486 if isinstance(value,LIST):
0487 self.__field_items=value
0488 else:
0489 self.__field_items=LIST(value,**{ 'elementclass': GroupEntry })
0490
0491 def __delfield_items(self): del self.__field_items
0492
0493 items=property(__getfield_items, __setfield_items, __delfield_items, None)
0494
0495 def iscontainer(self):
0496 return True
0497
0498 def containerelements(self):
0499 yield ('items', self.__field_items, None)
0500
0501
0502
0503
0504 class CalIndexEntry(BaseProtogenClass):
0505 __fields=['index']
0506
0507 def __init__(self, *args, **kwargs):
0508 dict={}
0509 dict.update(kwargs)
0511 super(CalIndexEntry,self).__init__(**dict)
0513 if self.__class__ is CalIndexEntry:
0514 self._update(args,dict)
0515
0516
0517 def getfields(self):
0518 return self.__fields
0519
0520
0521 def _update(self, args, kwargs):
0522 super(CalIndexEntry,self)._update(args,kwargs)
0523 keys=kwargs.keys()
0524 for key in keys:
0525 if key in self.__fields:
0526 setattr(self, key, kwargs[key])
0527 del kwargs[key]
0528 if __debug__:
0530 self._complainaboutunusedargs(CalIndexEntry,kwargs)
0531 if len(args):
0532 dict2={'sizeinbytes': 2, 'default': 0 }
0533 dict2.update(kwargs)
0534 kwargs=dict2
0535 self.__field_index=UINT(*args,**dict2)
0536
0538
0539 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0540 'Writes this packet to the supplied buffer'
0541 self._bufferstartoffset=buf.getcurrentoffset()
0542 try: self.__field_index
0543 except:
0544 self.__field_index=UINT(**{'sizeinbytes': 2, 'default': 0 })
0545 self.__field_index.writetobuffer(buf)
0546 self._bufferendoffset=buf.getcurrentoffset()
0547 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0548
0549
0550 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0551 'Reads this packet from the supplied buffer'
0552 self._bufferstartoffset=buf.getcurrentoffset()
0553 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0554 self.__field_index=UINT(**{'sizeinbytes': 2, 'default': 0 })
0555 self.__field_index.readfrombuffer(buf)
0556 self._bufferendoffset=buf.getcurrentoffset()
0557
0558
0559 def __getfield_index(self):
0560 try: self.__field_index
0561 except:
0562 self.__field_index=UINT(**{'sizeinbytes': 2, 'default': 0 })
0563 return self.__field_index.getvalue()
0564
0565 def __setfield_index(self, value):
0566 if isinstance(value,UINT):
0567 self.__field_index=value
0568 else:
0569 self.__field_index=UINT(value,**{'sizeinbytes': 2, 'default': 0 })
0570
0571 def __delfield_index(self): del self.__field_index
0572
0573 index=property(__getfield_index, __setfield_index, __delfield_index, None)
0574
0575 def iscontainer(self):
0576 return True
0577
0578 def containerelements(self):
0579 yield ('index', self.__field_index, None)
0580
0581
0582
0583
0584 class CalIndexFile(BaseProtogenClass):
0585 __fields=['next_index', 'zero1', 'numofevents', 'zero2', 'numofnotes', 'zero3', 'numofactiveevents', 'zero4', 'events', 'notes', 'activeevents']
0586
0587 def __init__(self, *args, **kwargs):
0588 dict={}
0589 dict.update(kwargs)
0591 super(CalIndexFile,self).__init__(**dict)
0593 if self.__class__ is CalIndexFile:
0594 self._update(args,dict)
0595
0596
0597 def getfields(self):
0598 return self.__fields
0599
0600
0601 def _update(self, args, kwargs):
0602 super(CalIndexFile,self)._update(args,kwargs)
0603 keys=kwargs.keys()
0604 for key in keys:
0605 if key in self.__fields:
0606 setattr(self, key, kwargs[key])
0607 del kwargs[key]
0608 if __debug__:
0610 self._complainaboutunusedargs(CalIndexFile,kwargs)
0611 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0612
0614
0615 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0616 'Writes this packet to the supplied buffer'
0617 self._bufferstartoffset=buf.getcurrentoffset()
0618 self.__field_next_index.writetobuffer(buf)
0619 try: self.__field_zero1
0620 except:
0621 self.__field_zero1=UNKNOWN(**{'sizeinbytes': 12, 'pad': 0 })
0622 self.__field_zero1.writetobuffer(buf)
0623 self.__field_numofevents.writetobuffer(buf)
0624 try: self.__field_zero2
0625 except:
0626 self.__field_zero2=UNKNOWN(**{'sizeinbytes': 6, 'pad': 0 })
0627 self.__field_zero2.writetobuffer(buf)
0628 self.__field_numofnotes.writetobuffer(buf)
0629 try: self.__field_zero3
0630 except:
0631 self.__field_zero3=UNKNOWN(**{'sizeinbytes': 2, 'pad': 0 })
0632 self.__field_zero3.writetobuffer(buf)
0633 self.__field_numofactiveevents.writetobuffer(buf)
0634 try: self.__field_zero4
0635 except:
0636 self.__field_zero4=UNKNOWN(**{'sizeinbytes': 112, 'pad': 0 })
0637 self.__field_zero4.writetobuffer(buf)
0638 try: self.__field_events
0639 except:
0640 self.__field_events=LIST(**{ 'elementclass': CalIndexEntry, 'length': 103, 'createdefault': True })
0641 self.__field_events.writetobuffer(buf)
0642 try: self.__field_notes
0643 except:
0644 self.__field_notes=LIST(**{ 'elementclass': CalIndexEntry, 'length': 30, 'createdefault': True })
0645 self.__field_notes.writetobuffer(buf)
0646 try: self.__field_activeevents
0647 except:
0648 self.__field_activeevents=LIST(**{ 'elementclass': CalIndexEntry, 'length': 324, 'createdefault': True })
0649 self.__field_activeevents.writetobuffer(buf)
0650 self._bufferendoffset=buf.getcurrentoffset()
0651 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0652
0653
0654 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0655 'Reads this packet from the supplied buffer'
0656 self._bufferstartoffset=buf.getcurrentoffset()
0657 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0658 self.__field_next_index=UINT(**{'sizeinbytes': 2})
0659 self.__field_next_index.readfrombuffer(buf)
0660 self.__field_zero1=UNKNOWN(**{'sizeinbytes': 12, 'pad': 0 })
0661 self.__field_zero1.readfrombuffer(buf)
0662 self.__field_numofevents=UINT(**{'sizeinbytes': 2})
0663 self.__field_numofevents.readfrombuffer(buf)
0664 self.__field_zero2=UNKNOWN(**{'sizeinbytes': 6, 'pad': 0 })
0665 self.__field_zero2.readfrombuffer(buf)
0666 self.__field_numofnotes=UINT(**{'sizeinbytes': 2})
0667 self.__field_numofnotes.readfrombuffer(buf)
0668 self.__field_zero3=UNKNOWN(**{'sizeinbytes': 2, 'pad': 0 })
0669 self.__field_zero3.readfrombuffer(buf)
0670 self.__field_numofactiveevents=UINT(**{'sizeinbytes': 2})
0671 self.__field_numofactiveevents.readfrombuffer(buf)
0672 self.__field_zero4=UNKNOWN(**{'sizeinbytes': 112, 'pad': 0 })
0673 self.__field_zero4.readfrombuffer(buf)
0674 self.__field_events=LIST(**{ 'elementclass': CalIndexEntry, 'length': 103, 'createdefault': True })
0675 self.__field_events.readfrombuffer(buf)
0676 self.__field_notes=LIST(**{ 'elementclass': CalIndexEntry, 'length': 30, 'createdefault': True })
0677 self.__field_notes.readfrombuffer(buf)
0678 self.__field_activeevents=LIST(**{ 'elementclass': CalIndexEntry, 'length': 324, 'createdefault': True })
0679 self.__field_activeevents.readfrombuffer(buf)
0680 self._bufferendoffset=buf.getcurrentoffset()
0681
0682
0683 def __getfield_next_index(self):
0684 return self.__field_next_index.getvalue()
0685
0686 def __setfield_next_index(self, value):
0687 if isinstance(value,UINT):
0688 self.__field_next_index=value
0689 else:
0690 self.__field_next_index=UINT(value,**{'sizeinbytes': 2})
0691
0692 def __delfield_next_index(self): del self.__field_next_index
0693
0694 next_index=property(__getfield_next_index, __setfield_next_index, __delfield_next_index, None)
0695
0696 def __getfield_zero1(self):
0697 try: self.__field_zero1
0698 except:
0699 self.__field_zero1=UNKNOWN(**{'sizeinbytes': 12, 'pad': 0 })
0700 return self.__field_zero1.getvalue()
0701
0702 def __setfield_zero1(self, value):
0703 if isinstance(value,UNKNOWN):
0704 self.__field_zero1=value
0705 else:
0706 self.__field_zero1=UNKNOWN(value,**{'sizeinbytes': 12, 'pad': 0 })
0707
0708 def __delfield_zero1(self): del self.__field_zero1
0709
0710 zero1=property(__getfield_zero1, __setfield_zero1, __delfield_zero1, None)
0711
0712 def __getfield_numofevents(self):
0713 return self.__field_numofevents.getvalue()
0714
0715 def __setfield_numofevents(self, value):
0716 if isinstance(value,UINT):
0717 self.__field_numofevents=value
0718 else:
0719 self.__field_numofevents=UINT(value,**{'sizeinbytes': 2})
0720
0721 def __delfield_numofevents(self): del self.__field_numofevents
0722
0723 numofevents=property(__getfield_numofevents, __setfield_numofevents, __delfield_numofevents, None)
0724
0725 def __getfield_zero2(self):
0726 try: self.__field_zero2
0727 except:
0728 self.__field_zero2=UNKNOWN(**{'sizeinbytes': 6, 'pad': 0 })
0729 return self.__field_zero2.getvalue()
0730
0731 def __setfield_zero2(self, value):
0732 if isinstance(value,UNKNOWN):
0733 self.__field_zero2=value
0734 else:
0735 self.__field_zero2=UNKNOWN(value,**{'sizeinbytes': 6, 'pad': 0 })
0736
0737 def __delfield_zero2(self): del self.__field_zero2
0738
0739 zero2=property(__getfield_zero2, __setfield_zero2, __delfield_zero2, None)
0740
0741 def __getfield_numofnotes(self):
0742 return self.__field_numofnotes.getvalue()
0743
0744 def __setfield_numofnotes(self, value):
0745 if isinstance(value,UINT):
0746 self.__field_numofnotes=value
0747 else:
0748 self.__field_numofnotes=UINT(value,**{'sizeinbytes': 2})
0749
0750 def __delfield_numofnotes(self): del self.__field_numofnotes
0751
0752 numofnotes=property(__getfield_numofnotes, __setfield_numofnotes, __delfield_numofnotes, None)
0753
0754 def __getfield_zero3(self):
0755 try: self.__field_zero3
0756 except:
0757 self.__field_zero3=UNKNOWN(**{'sizeinbytes': 2, 'pad': 0 })
0758 return self.__field_zero3.getvalue()
0759
0760 def __setfield_zero3(self, value):
0761 if isinstance(value,UNKNOWN):
0762 self.__field_zero3=value
0763 else:
0764 self.__field_zero3=UNKNOWN(value,**{'sizeinbytes': 2, 'pad': 0 })
0765
0766 def __delfield_zero3(self): del self.__field_zero3
0767
0768 zero3=property(__getfield_zero3, __setfield_zero3, __delfield_zero3, None)
0769
0770 def __getfield_numofactiveevents(self):
0771 return self.__field_numofactiveevents.getvalue()
0772
0773 def __setfield_numofactiveevents(self, value):
0774 if isinstance(value,UINT):
0775 self.__field_numofactiveevents=value
0776 else:
0777 self.__field_numofactiveevents=UINT(value,**{'sizeinbytes': 2})
0778
0779 def __delfield_numofactiveevents(self): del self.__field_numofactiveevents
0780
0781 numofactiveevents=property(__getfield_numofactiveevents, __setfield_numofactiveevents, __delfield_numofactiveevents, None)
0782
0783 def __getfield_zero4(self):
0784 try: self.__field_zero4
0785 except:
0786 self.__field_zero4=UNKNOWN(**{'sizeinbytes': 112, 'pad': 0 })
0787 return self.__field_zero4.getvalue()
0788
0789 def __setfield_zero4(self, value):
0790 if isinstance(value,UNKNOWN):
0791 self.__field_zero4=value
0792 else:
0793 self.__field_zero4=UNKNOWN(value,**{'sizeinbytes': 112, 'pad': 0 })
0794
0795 def __delfield_zero4(self): del self.__field_zero4
0796
0797 zero4=property(__getfield_zero4, __setfield_zero4, __delfield_zero4, None)
0798
0799 def __getfield_events(self):
0800 try: self.__field_events
0801 except:
0802 self.__field_events=LIST(**{ 'elementclass': CalIndexEntry, 'length': 103, 'createdefault': True })
0803 return self.__field_events.getvalue()
0804
0805 def __setfield_events(self, value):
0806 if isinstance(value,LIST):
0807 self.__field_events=value
0808 else:
0809 self.__field_events=LIST(value,**{ 'elementclass': CalIndexEntry, 'length': 103, 'createdefault': True })
0810
0811 def __delfield_events(self): del self.__field_events
0812
0813 events=property(__getfield_events, __setfield_events, __delfield_events, None)
0814
0815 def __getfield_notes(self):
0816 try: self.__field_notes
0817 except:
0818 self.__field_notes=LIST(**{ 'elementclass': CalIndexEntry, 'length': 30, 'createdefault': True })
0819 return self.__field_notes.getvalue()
0820
0821 def __setfield_notes(self, value):
0822 if isinstance(value,LIST):
0823 self.__field_notes=value
0824 else:
0825 self.__field_notes=LIST(value,**{ 'elementclass': CalIndexEntry, 'length': 30, 'createdefault': True })
0826
0827 def __delfield_notes(self): del self.__field_notes
0828
0829 notes=property(__getfield_notes, __setfield_notes, __delfield_notes, None)
0830
0831 def __getfield_activeevents(self):
0832 try: self.__field_activeevents
0833 except:
0834 self.__field_activeevents=LIST(**{ 'elementclass': CalIndexEntry, 'length': 324, 'createdefault': True })
0835 return self.__field_activeevents.getvalue()
0836
0837 def __setfield_activeevents(self, value):
0838 if isinstance(value,LIST):
0839 self.__field_activeevents=value
0840 else:
0841 self.__field_activeevents=LIST(value,**{ 'elementclass': CalIndexEntry, 'length': 324, 'createdefault': True })
0842
0843 def __delfield_activeevents(self): del self.__field_activeevents
0844
0845 activeevents=property(__getfield_activeevents, __setfield_activeevents, __delfield_activeevents, None)
0846
0847 def iscontainer(self):
0848 return True
0849
0850 def containerelements(self):
0851 yield ('next_index', self.__field_next_index, None)
0852 yield ('zero1', self.__field_zero1, None)
0853 yield ('numofevents', self.__field_numofevents, None)
0854 yield ('zero2', self.__field_zero2, None)
0855 yield ('numofnotes', self.__field_numofnotes, None)
0856 yield ('zero3', self.__field_zero3, None)
0857 yield ('numofactiveevents', self.__field_numofactiveevents, None)
0858 yield ('zero4', self.__field_zero4, None)
0859 yield ('events', self.__field_events, None)
0860 yield ('notes', self.__field_notes, None)
0861 yield ('activeevents', self.__field_activeevents, None)
0862
0863
0864
0865
0866 class CalEntry(BaseProtogenClass):
0867 __fields=['titlelen', 'title', 'start', 'start2', 'exptime', 'one', 'zero1', 'alert', 'three', 'alarm', 'reminder', 'ringtoneindex', 'zero4', 'duration', 'zero5']
0868
0869 def __init__(self, *args, **kwargs):
0870 dict={}
0871 dict.update(kwargs)
0873 super(CalEntry,self).__init__(**dict)
0875 if self.__class__ is CalEntry:
0876 self._update(args,dict)
0877
0878
0879 def getfields(self):
0880 return self.__fields
0881
0882
0883 def _update(self, args, kwargs):
0884 super(CalEntry,self)._update(args,kwargs)
0885 keys=kwargs.keys()
0886 for key in keys:
0887 if key in self.__fields:
0888 setattr(self, key, kwargs[key])
0889 del kwargs[key]
0890 if __debug__:
0892 self._complainaboutunusedargs(CalEntry,kwargs)
0893 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0894
0896
0897 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0898 'Writes this packet to the supplied buffer'
0899 self._bufferstartoffset=buf.getcurrentoffset()
0900 self.__field_titlelen.writetobuffer(buf)
0901 self.__field_title.writetobuffer(buf)
0902 self.__field_start.writetobuffer(buf)
0903 try: self.__field_start2
0904 except:
0905 self.__field_start2=DateTime(**{'sizeinbytes': 4, 'default': self.start })
0906 self.__field_start2.writetobuffer(buf)
0907 self.__field_exptime.writetobuffer(buf)
0908 try: self.__field_one
0909 except:
0910 self.__field_one=UINT(**{'sizeinbytes': 1, 'default': 1 })
0911 self.__field_one.writetobuffer(buf)
0912 try: self.__field_zero1
0913 except:
0914 self.__field_zero1=UINT(**{'sizeinbytes': 1, 'default': 0 })
0915 self.__field_zero1.writetobuffer(buf)
0916 self.__field_alert.writetobuffer(buf)
0917 try: self.__field_three
0918 except:
0919 self.__field_three=UINT(**{'sizeinbytes': 1, 'default': 3 })
0920 self.__field_three.writetobuffer(buf)
0921 self.__field_alarm.writetobuffer(buf)
0922 try: self.__field_reminder
0923 except:
0924 self.__field_reminder=UINT(**{'sizeinbytes': 1, 'default': CAL_REMINDER_ONCE })
0925 self.__field_reminder.writetobuffer(buf)
0926 self.__field_ringtoneindex.writetobuffer(buf)
0927 try: self.__field_zero4
0928 except:
0929 self.__field_zero4=UNKNOWN(**{'sizeinbytes': 5, 'pad': 0 })
0930 self.__field_zero4.writetobuffer(buf)
0931 self.__field_duration.writetobuffer(buf)
0932 try: self.__field_zero5
0933 except:
0934 self.__field_zero5=UNKNOWN(**{'sizeinbytes': 7, 'pad': 0 })
0935 self.__field_zero5.writetobuffer(buf)
0936 self._bufferendoffset=buf.getcurrentoffset()
0937 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0938
0939
0940 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0941 'Reads this packet from the supplied buffer'
0942 self._bufferstartoffset=buf.getcurrentoffset()
0943 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0944 self.__field_titlelen=UINT(**{'sizeinbytes': 2})
0945 self.__field_titlelen.readfrombuffer(buf)
0946 self.__field_title=USTRING(**{ 'sizeinbytes': self.titlelen, 'encoding': ENCODING, 'terminator': None })
0947 self.__field_title.readfrombuffer(buf)
0948 self.__field_start=DateTime(**{'sizeinbytes': 4})
0949 self.__field_start.readfrombuffer(buf)
0950 self.__field_start2=DateTime(**{'sizeinbytes': 4, 'default': self.start })
0951 self.__field_start2.readfrombuffer(buf)
0952 self.__field_exptime=ExpiringTime(**{'sizeinbytes': 4})
0953 self.__field_exptime.readfrombuffer(buf)
0954 self.__field_one=UINT(**{'sizeinbytes': 1, 'default': 1 })
0955 self.__field_one.readfrombuffer(buf)
0956 self.__field_zero1=UINT(**{'sizeinbytes': 1, 'default': 0 })
0957 self.__field_zero1.readfrombuffer(buf)
0958 self.__field_alert=UINT(**{'sizeinbytes': 1})
0959 self.__field_alert.readfrombuffer(buf)
0960 self.__field_three=UINT(**{'sizeinbytes': 1, 'default': 3 })
0961 self.__field_three.readfrombuffer(buf)
0962 self.__field_alarm=UINT(**{'sizeinbytes': 1})
0963 self.__field_alarm.readfrombuffer(buf)
0964 self.__field_reminder=UINT(**{'sizeinbytes': 1, 'default': CAL_REMINDER_ONCE })
0965 self.__field_reminder.readfrombuffer(buf)
0966 self.__field_ringtoneindex=UINT(**{'sizeinbytes': 1})
0967 self.__field_ringtoneindex.readfrombuffer(buf)
0968 self.__field_zero4=UNKNOWN(**{'sizeinbytes': 5, 'pad': 0 })
0969 self.__field_zero4.readfrombuffer(buf)
0970 self.__field_duration=UINT(**{'sizeinbytes': 4})
0971 self.__field_duration.readfrombuffer(buf)
0972 self.__field_zero5=UNKNOWN(**{'sizeinbytes': 7, 'pad': 0 })
0973 self.__field_zero5.readfrombuffer(buf)
0974 self._bufferendoffset=buf.getcurrentoffset()
0975
0976
0977 def __getfield_titlelen(self):
0978 return self.__field_titlelen.getvalue()
0979
0980 def __setfield_titlelen(self, value):
0981 if isinstance(value,UINT):
0982 self.__field_titlelen=value
0983 else:
0984 self.__field_titlelen=UINT(value,**{'sizeinbytes': 2})
0985
0986 def __delfield_titlelen(self): del self.__field_titlelen
0987
0988 titlelen=property(__getfield_titlelen, __setfield_titlelen, __delfield_titlelen, None)
0989
0990 def __getfield_title(self):
0991 return self.__field_title.getvalue()
0992
0993 def __setfield_title(self, value):
0994 if isinstance(value,USTRING):
0995 self.__field_title=value
0996 else:
0997 self.__field_title=USTRING(value,**{ 'sizeinbytes': self.titlelen, 'encoding': ENCODING, 'terminator': None })
0998
0999 def __delfield_title(self): del self.__field_title
1000
1001 title=property(__getfield_title, __setfield_title, __delfield_title, None)
1002
1003 def __getfield_start(self):
1004 return self.__field_start.getvalue()
1005
1006 def __setfield_start(self, value):
1007 if isinstance(value,DateTime):
1008 self.__field_start=value
1009 else:
1010 self.__field_start=DateTime(value,**{'sizeinbytes': 4})
1011
1012 def __delfield_start(self): del self.__field_start
1013
1014 start=property(__getfield_start, __setfield_start, __delfield_start, None)
1015
1016 def __getfield_start2(self):
1017 try: self.__field_start2
1018 except:
1019 self.__field_start2=DateTime(**{'sizeinbytes': 4, 'default': self.start })
1020 return self.__field_start2.getvalue()
1021
1022 def __setfield_start2(self, value):
1023 if isinstance(value,DateTime):
1024 self.__field_start2=value
1025 else:
1026 self.__field_start2=DateTime(value,**{'sizeinbytes': 4, 'default': self.start })
1027
1028 def __delfield_start2(self): del self.__field_start2
1029
1030 start2=property(__getfield_start2, __setfield_start2, __delfield_start2, None)
1031
1032 def __getfield_exptime(self):
1033 return self.__field_exptime.getvalue()
1034
1035 def __setfield_exptime(self, value):
1036 if isinstance(value,ExpiringTime):
1037 self.__field_exptime=value
1038 else:
1039 self.__field_exptime=ExpiringTime(value,**{'sizeinbytes': 4})
1040
1041 def __delfield_exptime(self): del self.__field_exptime
1042
1043 exptime=property(__getfield_exptime, __setfield_exptime, __delfield_exptime, None)
1044
1045 def __getfield_one(self):
1046 try: self.__field_one
1047 except:
1048 self.__field_one=UINT(**{'sizeinbytes': 1, 'default': 1 })
1049 return self.__field_one.getvalue()
1050
1051 def __setfield_one(self, value):
1052 if isinstance(value,UINT):
1053 self.__field_one=value
1054 else:
1055 self.__field_one=UINT(value,**{'sizeinbytes': 1, 'default': 1 })
1056
1057 def __delfield_one(self): del self.__field_one
1058
1059 one=property(__getfield_one, __setfield_one, __delfield_one, None)
1060
1061 def __getfield_zero1(self):
1062 try: self.__field_zero1
1063 except:
1064 self.__field_zero1=UINT(**{'sizeinbytes': 1, 'default': 0 })
1065 return self.__field_zero1.getvalue()
1066
1067 def __setfield_zero1(self, value):
1068 if isinstance(value,UINT):
1069 self.__field_zero1=value
1070 else:
1071 self.__field_zero1=UINT(value,**{'sizeinbytes': 1, 'default': 0 })
1072
1073 def __delfield_zero1(self): del self.__field_zero1
1074
1075 zero1=property(__getfield_zero1, __setfield_zero1, __delfield_zero1, None)
1076
1077 def __getfield_alert(self):
1078 return self.__field_alert.getvalue()
1079
1080 def __setfield_alert(self, value):
1081 if isinstance(value,UINT):
1082 self.__field_alert=value
1083 else:
1084 self.__field_alert=UINT(value,**{'sizeinbytes': 1})
1085
1086 def __delfield_alert(self): del self.__field_alert
1087
1088 alert=property(__getfield_alert, __setfield_alert, __delfield_alert, None)
1089
1090 def __getfield_three(self):
1091 try: self.__field_three
1092 except:
1093 self.__field_three=UINT(**{'sizeinbytes': 1, 'default': 3 })
1094 return self.__field_three.getvalue()
1095
1096 def __setfield_three(self, value):
1097 if isinstance(value,UINT):
1098 self.__field_three=value
1099 else:
1100 self.__field_three=UINT(value,**{'sizeinbytes': 1, 'default': 3 })
1101
1102 def __delfield_three(self): del self.__field_three
1103
1104 three=property(__getfield_three, __setfield_three, __delfield_three, None)
1105
1106 def __getfield_alarm(self):
1107 return self.__field_alarm.getvalue()
1108
1109 def __setfield_alarm(self, value):
1110 if isinstance(value,UINT):
1111 self.__field_alarm=value
1112 else:
1113 self.__field_alarm=UINT(value,**{'sizeinbytes': 1})
1114
1115 def __delfield_alarm(self): del self.__field_alarm
1116
1117 alarm=property(__getfield_alarm, __setfield_alarm, __delfield_alarm, None)
1118
1119 def __getfield_reminder(self):
1120 try: self.__field_reminder
1121 except:
1122 self.__field_reminder=UINT(**{'sizeinbytes': 1, 'default': CAL_REMINDER_ONCE })
1123 return self.__field_reminder.getvalue()
1124
1125 def __setfield_reminder(self, value):
1126 if isinstance(value,UINT):
1127 self.__field_reminder=value
1128 else:
1129 self.__field_reminder=UINT(value,**{'sizeinbytes': 1, 'default': CAL_REMINDER_ONCE })
1130
1131 def __delfield_reminder(self): del self.__field_reminder
1132
1133 reminder=property(__getfield_reminder, __setfield_reminder, __delfield_reminder, None)
1134
1135 def __getfield_ringtoneindex(self):
1136 return self.__field_ringtoneindex.getvalue()
1137
1138 def __setfield_ringtoneindex(self, value):
1139 if isinstance(value,UINT):
1140 self.__field_ringtoneindex=value
1141 else:
1142 self.__field_ringtoneindex=UINT(value,**{'sizeinbytes': 1})
1143
1144 def __delfield_ringtoneindex(self): del self.__field_ringtoneindex
1145
1146 ringtoneindex=property(__getfield_ringtoneindex, __setfield_ringtoneindex, __delfield_ringtoneindex, None)
1147
1148 def __getfield_zero4(self):
1149 try: self.__field_zero4
1150 except:
1151 self.__field_zero4=UNKNOWN(**{'sizeinbytes': 5, 'pad': 0 })
1152 return self.__field_zero4.getvalue()
1153
1154 def __setfield_zero4(self, value):
1155 if isinstance(value,UNKNOWN):
1156 self.__field_zero4=value
1157 else:
1158 self.__field_zero4=UNKNOWN(value,**{'sizeinbytes': 5, 'pad': 0 })
1159
1160 def __delfield_zero4(self): del self.__field_zero4
1161
1162 zero4=property(__getfield_zero4, __setfield_zero4, __delfield_zero4, None)
1163
1164 def __getfield_duration(self):
1165 return self.__field_duration.getvalue()
1166
1167 def __setfield_duration(self, value):
1168 if isinstance(value,UINT):
1169 self.__field_duration=value
1170 else:
1171 self.__field_duration=UINT(value,**{'sizeinbytes': 4})
1172
1173 def __delfield_duration(self): del self.__field_duration
1174
1175 duration=property(__getfield_duration, __setfield_duration, __delfield_duration, None)
1176
1177 def __getfield_zero5(self):
1178 try: self.__field_zero5
1179 except:
1180 self.__field_zero5=UNKNOWN(**{'sizeinbytes': 7, 'pad': 0 })
1181 return self.__field_zero5.getvalue()
1182
1183 def __setfield_zero5(self, value):
1184 if isinstance(value,UNKNOWN):
1185 self.__field_zero5=value
1186 else:
1187 self.__field_zero5=UNKNOWN(value,**{'sizeinbytes': 7, 'pad': 0 })
1188
1189 def __delfield_zero5(self): del self.__field_zero5
1190
1191 zero5=property(__getfield_zero5, __setfield_zero5, __delfield_zero5, None)
1192
1193 def iscontainer(self):
1194 return True
1195
1196 def containerelements(self):
1197 yield ('titlelen', self.__field_titlelen, None)
1198 yield ('title', self.__field_title, None)
1199 yield ('start', self.__field_start, None)
1200 yield ('start2', self.__field_start2, None)
1201 yield ('exptime', self.__field_exptime, None)
1202 yield ('one', self.__field_one, None)
1203 yield ('zero1', self.__field_zero1, None)
1204 yield ('alert', self.__field_alert, None)
1205 yield ('three', self.__field_three, None)
1206 yield ('alarm', self.__field_alarm, None)
1207 yield ('reminder', self.__field_reminder, None)
1208 yield ('ringtoneindex', self.__field_ringtoneindex, None)
1209 yield ('zero4', self.__field_zero4, None)
1210 yield ('duration', self.__field_duration, None)
1211 yield ('zero5', self.__field_zero5, None)
1212
1213
1214
1215
1216 class NotePadEntry(BaseProtogenClass):
1217 __fields=['textlen', 'text', 'creation', 'creation2', 'zero2', 'five', 'zero3']
1218
1219 def __init__(self, *args, **kwargs):
1220 dict={}
1221 dict.update(kwargs)
1223 super(NotePadEntry,self).__init__(**dict)
1225 if self.__class__ is NotePadEntry:
1226 self._update(args,dict)
1227
1228
1229 def getfields(self):
1230 return self.__fields
1231
1232
1233 def _update(self, args, kwargs):
1234 super(NotePadEntry,self)._update(args,kwargs)
1235 keys=kwargs.keys()
1236 for key in keys:
1237 if key in self.__fields:
1238 setattr(self, key, kwargs[key])
1239 del kwargs[key]
1240 if __debug__:
1242 self._complainaboutunusedargs(NotePadEntry,kwargs)
1243 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
1244
1246
1247 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1248 'Writes this packet to the supplied buffer'
1249 self._bufferstartoffset=buf.getcurrentoffset()
1250 self.__field_textlen.writetobuffer(buf)
1251 self.__field_text.writetobuffer(buf)
1252 self.__field_creation.writetobuffer(buf)
1253 try: self.__field_creation2
1254 except:
1255 self.__field_creation2=DateTime(**{'sizeinbytes': 4, 'default': self.creation })
1256 self.__field_creation2.writetobuffer(buf)
1257 try: self.__field_zero2
1258 except:
1259 self.__field_zero2=UNKNOWN(**{'sizeinbytes': 7, 'pad': 0 })
1260 self.__field_zero2.writetobuffer(buf)
1261 try: self.__field_five
1262 except:
1263 self.__field_five=UINT(**{'sizeinbytes': 1, 'default': 5 })
1264 self.__field_five.writetobuffer(buf)
1265 try: self.__field_zero3
1266 except:
1267 self.__field_zero3=UNKNOWN(**{'sizeinbytes': 19, 'pad': 0 })
1268 self.__field_zero3.writetobuffer(buf)
1269 self._bufferendoffset=buf.getcurrentoffset()
1270 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1271
1272
1273 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1274 'Reads this packet from the supplied buffer'
1275 self._bufferstartoffset=buf.getcurrentoffset()
1276 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1277 self.__field_textlen=UINT(**{'sizeinbytes': 2})
1278 self.__field_textlen.readfrombuffer(buf)
1279 self.__field_text=USTRING(**{ 'terminator': None, 'encoding': ENCODING, 'sizeinbytes': self.textlen })
1280 self.__field_text.readfrombuffer(buf)
1281 self.__field_creation=DateTime(**{'sizeinbytes': 4})
1282 self.__field_creation.readfrombuffer(buf)
1283 self.__field_creation2=DateTime(**{'sizeinbytes': 4, 'default': self.creation })
1284 self.__field_creation2.readfrombuffer(buf)
1285 self.__field_zero2=UNKNOWN(**{'sizeinbytes': 7, 'pad': 0 })
1286 self.__field_zero2.readfrombuffer(buf)
1287 self.__field_five=UINT(**{'sizeinbytes': 1, 'default': 5 })
1288 self.__field_five.readfrombuffer(buf)
1289 self.__field_zero3=UNKNOWN(**{'sizeinbytes': 19, 'pad': 0 })
1290 self.__field_zero3.readfrombuffer(buf)
1291 self._bufferendoffset=buf.getcurrentoffset()
1292
1293
1294 def __getfield_textlen(self):
1295 return self.__field_textlen.getvalue()
1296
1297 def __setfield_textlen(self, value):
1298 if isinstance(value,UINT):
1299 self.__field_textlen=value
1300 else:
1301 self.__field_textlen=UINT(value,**{'sizeinbytes': 2})
1302
1303 def __delfield_textlen(self): del self.__field_textlen
1304
1305 textlen=property(__getfield_textlen, __setfield_textlen, __delfield_textlen, None)
1306
1307 def __getfield_text(self):
1308 return self.__field_text.getvalue()
1309
1310 def __setfield_text(self, value):
1311 if isinstance(value,USTRING):
1312 self.__field_text=value
1313 else:
1314 self.__field_text=USTRING(value,**{ 'terminator': None, 'encoding': ENCODING, 'sizeinbytes': self.textlen })
1315
1316 def __delfield_text(self): del self.__field_text
1317
1318 text=property(__getfield_text, __setfield_text, __delfield_text, None)
1319
1320 def __getfield_creation(self):
1321 return self.__field_creation.getvalue()
1322
1323 def __setfield_creation(self, value):
1324 if isinstance(value,DateTime):
1325 self.__field_creation=value
1326 else:
1327 self.__field_creation=DateTime(value,**{'sizeinbytes': 4})
1328
1329 def __delfield_creation(self): del self.__field_creation
1330
1331 creation=property(__getfield_creation, __setfield_creation, __delfield_creation, None)
1332
1333 def __getfield_creation2(self):
1334 try: self.__field_creation2
1335 except:
1336 self.__field_creation2=DateTime(**{'sizeinbytes': 4, 'default': self.creation })
1337 return self.__field_creation2.getvalue()
1338
1339 def __setfield_creation2(self, value):
1340 if isinstance(value,DateTime):
1341 self.__field_creation2=value
1342 else:
1343 self.__field_creation2=DateTime(value,**{'sizeinbytes': 4, 'default': self.creation })
1344
1345 def __delfield_creation2(self): del self.__field_creation2
1346
1347 creation2=property(__getfield_creation2, __setfield_creation2, __delfield_creation2, None)
1348
1349 def __getfield_zero2(self):
1350 try: self.__field_zero2
1351 except:
1352 self.__field_zero2=UNKNOWN(**{'sizeinbytes': 7, 'pad': 0 })
1353 return self.__field_zero2.getvalue()
1354
1355 def __setfield_zero2(self, value):
1356 if isinstance(value,UNKNOWN):
1357 self.__field_zero2=value
1358 else:
1359 self.__field_zero2=UNKNOWN(value,**{'sizeinbytes': 7, 'pad': 0 })
1360
1361 def __delfield_zero2(self): del self.__field_zero2
1362
1363 zero2=property(__getfield_zero2, __setfield_zero2, __delfield_zero2, None)
1364
1365 def __getfield_five(self):
1366 try: self.__field_five
1367 except:
1368 self.__field_five=UINT(**{'sizeinbytes': 1, 'default': 5 })
1369 return self.__field_five.getvalue()
1370
1371 def __setfield_five(self, value):
1372 if isinstance(value,UINT):
1373 self.__field_five=value
1374 else:
1375 self.__field_five=UINT(value,**{'sizeinbytes': 1, 'default': 5 })
1376
1377 def __delfield_five(self): del self.__field_five
1378
1379 five=property(__getfield_five, __setfield_five, __delfield_five, None)
1380
1381 def __getfield_zero3(self):
1382 try: self.__field_zero3
1383 except:
1384 self.__field_zero3=UNKNOWN(**{'sizeinbytes': 19, 'pad': 0 })
1385 return self.__field_zero3.getvalue()
1386
1387 def __setfield_zero3(self, value):
1388 if isinstance(value,UNKNOWN):
1389 self.__field_zero3=value
1390 else:
1391 self.__field_zero3=UNKNOWN(value,**{'sizeinbytes': 19, 'pad': 0 })
1392
1393 def __delfield_zero3(self): del self.__field_zero3
1394
1395 zero3=property(__getfield_zero3, __setfield_zero3, __delfield_zero3, None)
1396
1397 def iscontainer(self):
1398 return True
1399
1400 def containerelements(self):
1401 yield ('textlen', self.__field_textlen, None)
1402 yield ('text', self.__field_text, None)
1403 yield ('creation', self.__field_creation, None)
1404 yield ('creation2', self.__field_creation2, None)
1405 yield ('zero2', self.__field_zero2, None)
1406 yield ('five', self.__field_five, None)
1407 yield ('zero3', self.__field_zero3, None)
1408
1409
1410
1411
1412 class cl_list(BaseProtogenClass):
1413 __fields=['index']
1414
1415 def __init__(self, *args, **kwargs):
1416 dict={}
1417 dict.update(kwargs)
1419 super(cl_list,self).__init__(**dict)
1421 if self.__class__ is cl_list:
1422 self._update(args,dict)
1423
1424
1425 def getfields(self):
1426 return self.__fields
1427
1428
1429 def _update(self, args, kwargs):
1430 super(cl_list,self)._update(args,kwargs)
1431 keys=kwargs.keys()
1432 for key in keys:
1433 if key in self.__fields:
1434 setattr(self, key, kwargs[key])
1435 del kwargs[key]
1436 if __debug__:
1438 self._complainaboutunusedargs(cl_list,kwargs)
1439 if len(args):
1440 dict2={'sizeinbytes': 2}
1441 dict2.update(kwargs)
1442 kwargs=dict2
1443 self.__field_index=UINT(*args,**dict2)
1444
1446
1447 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1448 'Writes this packet to the supplied buffer'
1449 self._bufferstartoffset=buf.getcurrentoffset()
1450 self.__field_index.writetobuffer(buf)
1451 self._bufferendoffset=buf.getcurrentoffset()
1452 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1453
1454
1455 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1456 'Reads this packet from the supplied buffer'
1457 self._bufferstartoffset=buf.getcurrentoffset()
1458 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1459 self.__field_index=UINT(**{'sizeinbytes': 2})
1460 self.__field_index.readfrombuffer(buf)
1461 self._bufferendoffset=buf.getcurrentoffset()
1462
1463
1464 def __getfield_index(self):
1465 return self.__field_index.getvalue()
1466
1467 def __setfield_index(self, value):
1468 if isinstance(value,UINT):
1469 self.__field_index=value
1470 else:
1471 self.__field_index=UINT(value,**{'sizeinbytes': 2})
1472
1473 def __delfield_index(self): del self.__field_index
1474
1475 index=property(__getfield_index, __setfield_index, __delfield_index, None)
1476
1477 def iscontainer(self):
1478 return True
1479
1480 def containerelements(self):
1481 yield ('index', self.__field_index, None)
1482
1483
1484
1485
1486 class cl_index_file(BaseProtogenClass):
1487 __fields=['incoming', 'outgoing', 'missed', 'dunno1', 'incoming_count', 'outgoing_count', 'missed_count']
1488
1489 def __init__(self, *args, **kwargs):
1490 dict={}
1491 dict.update(kwargs)
1493 super(cl_index_file,self).__init__(**dict)
1495 if self.__class__ is cl_index_file:
1496 self._update(args,dict)
1497
1498
1499 def getfields(self):
1500 return self.__fields
1501
1502
1503 def _update(self, args, kwargs):
1504 super(cl_index_file,self)._update(args,kwargs)
1505 keys=kwargs.keys()
1506 for key in keys:
1507 if key in self.__fields:
1508 setattr(self, key, kwargs[key])
1509 del kwargs[key]
1510 if __debug__:
1512 self._complainaboutunusedargs(cl_index_file,kwargs)
1513 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
1514
1516
1517 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1518 'Writes this packet to the supplied buffer'
1519 self._bufferstartoffset=buf.getcurrentoffset()
1520 self.__field_incoming.writetobuffer(buf)
1521 self.__field_outgoing.writetobuffer(buf)
1522 self.__field_missed.writetobuffer(buf)
1523 self.__field_dunno1.writetobuffer(buf)
1524 self.__field_incoming_count.writetobuffer(buf)
1525 self.__field_outgoing_count.writetobuffer(buf)
1526 self.__field_missed_count.writetobuffer(buf)
1527 self._bufferendoffset=buf.getcurrentoffset()
1528 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1529
1530
1531 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1532 'Reads this packet from the supplied buffer'
1533 self._bufferstartoffset=buf.getcurrentoffset()
1534 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1535 self.__field_incoming=LIST(**{ 'length': CL_MAX_ENTRIES, 'elementclass': cl_list })
1536 self.__field_incoming.readfrombuffer(buf)
1537 self.__field_outgoing=LIST(**{ 'length': CL_MAX_ENTRIES, 'elementclass': cl_list })
1538 self.__field_outgoing.readfrombuffer(buf)
1539 self.__field_missed=LIST(**{ 'length': CL_MAX_ENTRIES, 'elementclass': cl_list })
1540 self.__field_missed.readfrombuffer(buf)
1541 self.__field_dunno1=UNKNOWN(**{'sizeinbytes': 992})
1542 self.__field_dunno1.readfrombuffer(buf)
1543 self.__field_incoming_count=UINT(**{'sizeinbytes': 4})
1544 self.__field_incoming_count.readfrombuffer(buf)
1545 self.__field_outgoing_count=UINT(**{'sizeinbytes': 4})
1546 self.__field_outgoing_count.readfrombuffer(buf)
1547 self.__field_missed_count=UINT(**{'sizeinbytes': 4})
1548 self.__field_missed_count.readfrombuffer(buf)
1549 self._bufferendoffset=buf.getcurrentoffset()
1550
1551
1552 def __getfield_incoming(self):
1553 return self.__field_incoming.getvalue()
1554
1555 def __setfield_incoming(self, value):
1556 if isinstance(value,LIST):
1557 self.__field_incoming=value
1558 else:
1559 self.__field_incoming=LIST(value,**{ 'length': CL_MAX_ENTRIES, 'elementclass': cl_list })
1560
1561 def __delfield_incoming(self): del self.__field_incoming
1562
1563 incoming=property(__getfield_incoming, __setfield_incoming, __delfield_incoming, None)
1564
1565 def __getfield_outgoing(self):
1566 return self.__field_outgoing.getvalue()
1567
1568 def __setfield_outgoing(self, value):
1569 if isinstance(value,LIST):
1570 self.__field_outgoing=value
1571 else:
1572 self.__field_outgoing=LIST(value,**{ 'length': CL_MAX_ENTRIES, 'elementclass': cl_list })
1573
1574 def __delfield_outgoing(self): del self.__field_outgoing
1575
1576 outgoing=property(__getfield_outgoing, __setfield_outgoing, __delfield_outgoing, None)
1577
1578 def __getfield_missed(self):
1579 return self.__field_missed.getvalue()
1580
1581 def __setfield_missed(self, value):
1582 if isinstance(value,LIST):
1583 self.__field_missed=value
1584 else:
1585 self.__field_missed=LIST(value,**{ 'length': CL_MAX_ENTRIES, 'elementclass': cl_list })
1586
1587 def __delfield_missed(self): del self.__field_missed
1588
1589 missed=property(__getfield_missed, __setfield_missed, __delfield_missed, None)
1590
1591 def __getfield_dunno1(self):
1592 return self.__field_dunno1.getvalue()
1593
1594 def __setfield_dunno1(self, value):
1595 if isinstance(value,UNKNOWN):
1596 self.__field_dunno1=value
1597 else:
1598 self.__field_dunno1=UNKNOWN(value,**{'sizeinbytes': 992})
1599
1600 def __delfield_dunno1(self): del self.__field_dunno1
1601
1602 dunno1=property(__getfield_dunno1, __setfield_dunno1, __delfield_dunno1, None)
1603
1604 def __getfield_incoming_count(self):
1605 return self.__field_incoming_count.getvalue()
1606
1607 def __setfield_incoming_count(self, value):
1608 if isinstance(value,UINT):
1609 self.__field_incoming_count=value
1610 else:
1611 self.__field_incoming_count=UINT(value,**{'sizeinbytes': 4})
1612
1613 def __delfield_incoming_count(self): del self.__field_incoming_count
1614
1615 incoming_count=property(__getfield_incoming_count, __setfield_incoming_count, __delfield_incoming_count, None)
1616
1617 def __getfield_outgoing_count(self):
1618 return self.__field_outgoing_count.getvalue()
1619
1620 def __setfield_outgoing_count(self, value):
1621 if isinstance(value,UINT):
1622 self.__field_outgoing_count=value
1623 else:
1624 self.__field_outgoing_count=UINT(value,**{'sizeinbytes': 4})
1625
1626 def __delfield_outgoing_count(self): del self.__field_outgoing_count
1627
1628 outgoing_count=property(__getfield_outgoing_count, __setfield_outgoing_count, __delfield_outgoing_count, None)
1629
1630 def __getfield_missed_count(self):
1631 return self.__field_missed_count.getvalue()
1632
1633 def __setfield_missed_count(self, value):
1634 if isinstance(value,UINT):
1635 self.__field_missed_count=value
1636 else:
1637 self.__field_missed_count=UINT(value,**{'sizeinbytes': 4})
1638
1639 def __delfield_missed_count(self): del self.__field_missed_count
1640
1641 missed_count=property(__getfield_missed_count, __setfield_missed_count, __delfield_missed_count, None)
1642
1643 def iscontainer(self):
1644 return True
1645
1646 def containerelements(self):
1647 yield ('incoming', self.__field_incoming, None)
1648 yield ('outgoing', self.__field_outgoing, None)
1649 yield ('missed', self.__field_missed, None)
1650 yield ('dunno1', self.__field_dunno1, None)
1651 yield ('incoming_count', self.__field_incoming_count, None)
1652 yield ('outgoing_count', self.__field_outgoing_count, None)
1653 yield ('missed_count', self.__field_missed_count, None)
1654
1655
1656
1657
1658 class cl_file(BaseProtogenClass):
1659 __fields=['cl_type', 'number', 'datetime', 'duration']
1660
1661 def __init__(self, *args, **kwargs):
1662 dict={}
1663 dict.update(kwargs)
1665 super(cl_file,self).__init__(**dict)
1667 if self.__class__ is cl_file:
1668 self._update(args,dict)
1669
1670
1671 def getfields(self):
1672 return self.__fields
1673
1674
1675 def _update(self, args, kwargs):
1676 super(cl_file,self)._update(args,kwargs)
1677 keys=kwargs.keys()
1678 for key in keys:
1679 if key in self.__fields:
1680 setattr(self, key, kwargs[key])
1681 del kwargs[key]
1682 if __debug__:
1684 self._complainaboutunusedargs(cl_file,kwargs)
1685 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
1686
1688
1689 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1690 'Writes this packet to the supplied buffer'
1691 self._bufferstartoffset=buf.getcurrentoffset()
1692 self.__field_cl_type.writetobuffer(buf)
1693 self.__field_number.writetobuffer(buf)
1694 self.__field_datetime.writetobuffer(buf)
1695 self.__field_duration.writetobuffer(buf)
1696 self._bufferendoffset=buf.getcurrentoffset()
1697 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1698
1699
1700 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1701 'Reads this packet from the supplied buffer'
1702 self._bufferstartoffset=buf.getcurrentoffset()
1703 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1704 self.__field_cl_type=UINT(**{'sizeinbytes': 1})
1705 self.__field_cl_type.readfrombuffer(buf)
1706 self.__field_number=STRING(**{'sizeinbytes': 35, 'terminator': 0 })
1707 self.__field_number.readfrombuffer(buf)
1708 self.__field_datetime=DateTime1(**{'sizeinbytes': 4})
1709 self.__field_datetime.readfrombuffer(buf)
1710 self.__field_duration=UINT(**{'sizeinbytes': 4})
1711 self.__field_duration.readfrombuffer(buf)
1712 self._bufferendoffset=buf.getcurrentoffset()
1713
1714
1715 def __getfield_cl_type(self):
1716 return self.__field_cl_type.getvalue()
1717
1718 def __setfield_cl_type(self, value):
1719 if isinstance(value,UINT):
1720 self.__field_cl_type=value
1721 else:
1722 self.__field_cl_type=UINT(value,**{'sizeinbytes': 1})
1723
1724 def __delfield_cl_type(self): del self.__field_cl_type
1725
1726 cl_type=property(__getfield_cl_type, __setfield_cl_type, __delfield_cl_type, None)
1727
1728 def __getfield_number(self):
1729 return self.__field_number.getvalue()
1730
1731 def __setfield_number(self, value):
1732 if isinstance(value,STRING):
1733 self.__field_number=value
1734 else:
1735 self.__field_number=STRING(value,**{'sizeinbytes': 35, 'terminator': 0 })
1736
1737 def __delfield_number(self): del self.__field_number
1738
1739 number=property(__getfield_number, __setfield_number, __delfield_number, None)
1740
1741 def __getfield_datetime(self):
1742 return self.__field_datetime.getvalue()
1743
1744 def __setfield_datetime(self, value):
1745 if isinstance(value,DateTime1):
1746 self.__field_datetime=value
1747 else:
1748 self.__field_datetime=DateTime1(value,**{'sizeinbytes': 4})
1749
1750 def __delfield_datetime(self): del self.__field_datetime
1751
1752 datetime=property(__getfield_datetime, __setfield_datetime, __delfield_datetime, None)
1753
1754 def __getfield_duration(self):
1755 return self.__field_duration.getvalue()
1756
1757 def __setfield_duration(self, value):
1758 if isinstance(value,UINT):
1759 self.__field_duration=value
1760 else:
1761 self.__field_duration=UINT(value,**{'sizeinbytes': 4})
1762
1763 def __delfield_duration(self): del self.__field_duration
1764
1765 duration=property(__getfield_duration, __setfield_duration, __delfield_duration, None)
1766
1767 def iscontainer(self):
1768 return True
1769
1770 def containerelements(self):
1771 yield ('cl_type', self.__field_cl_type, None)
1772 yield ('number', self.__field_number, None)
1773 yield ('datetime', self.__field_datetime, None)
1774 yield ('duration', self.__field_duration, None)
1775
1776 def _valid(self):
1777 global CL_VALID_TYPE
1778 return bool(self.cl_type in CL_VALID_TYPE and self.number)
1779 valid=property(fget=_valid)
1780
1781
1782
1783
1784 class NumberEntry(BaseProtogenClass):
1785 __fields=['number', 'option', 'speeddial', 'ringtone']
1786
1787 def __init__(self, *args, **kwargs):
1788 dict={}
1789 dict.update(kwargs)
1791 super(NumberEntry,self).__init__(**dict)
1793 if self.__class__ is NumberEntry:
1794 self._update(args,dict)
1795
1796
1797 def getfields(self):
1798 return self.__fields
1799
1800
1801 def _update(self, args, kwargs):
1802 super(NumberEntry,self)._update(args,kwargs)
1803 keys=kwargs.keys()
1804 for key in keys:
1805 if key in self.__fields:
1806 setattr(self, key, kwargs[key])
1807 del kwargs[key]
1808 if __debug__:
1810 self._complainaboutunusedargs(NumberEntry,kwargs)
1811 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
1812
1814
1815 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1816 'Writes this packet to the supplied buffer'
1817 self._bufferstartoffset=buf.getcurrentoffset()
1818 self.__field_number.writetobuffer(buf)
1819 self.__field_option.writetobuffer(buf)
1820 if self.option & PB_FLG_SPEEDDIAL:
1821 self.__field_speeddial.writetobuffer(buf)
1822 if self.option & PB_FLG_RINGTONE:
1823 self.__field_ringtone.writetobuffer(buf)
1824 self._bufferendoffset=buf.getcurrentoffset()
1825 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1826
1827
1828 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1829 'Reads this packet from the supplied buffer'
1830 self._bufferstartoffset=buf.getcurrentoffset()
1831 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1832 self.__field_number=STRING(**{ 'terminator': None, 'pascal': True })
1833 self.__field_number.readfrombuffer(buf)
1834 self.__field_option=UINT(**{'sizeinbytes': 1})
1835 self.__field_option.readfrombuffer(buf)
1836 if self.option & PB_FLG_SPEEDDIAL:
1837 self.__field_speeddial=UINT(**{'sizeinbytes': 2})
1838 self.__field_speeddial.readfrombuffer(buf)
1839 if self.option & PB_FLG_RINGTONE:
1840 self.__field_ringtone=STRING(**{ 'terminator': None, 'pascal': True })
1841 self.__field_ringtone.readfrombuffer(buf)
1842 self._bufferendoffset=buf.getcurrentoffset()
1843
1844
1845 def __getfield_number(self):
1846 return self.__field_number.getvalue()
1847
1848 def __setfield_number(self, value):
1849 if isinstance(value,STRING):
1850 self.__field_number=value
1851 else:
1852 self.__field_number=STRING(value,**{ 'terminator': None, 'pascal': True })
1853
1854 def __delfield_number(self): del self.__field_number
1855
1856 number=property(__getfield_number, __setfield_number, __delfield_number, None)
1857
1858 def __getfield_option(self):
1859 return self.__field_option.getvalue()
1860
1861 def __setfield_option(self, value):
1862 if isinstance(value,UINT):
1863 self.__field_option=value
1864 else:
1865 self.__field_option=UINT(value,**{'sizeinbytes': 1})
1866
1867 def __delfield_option(self): del self.__field_option
1868
1869 option=property(__getfield_option, __setfield_option, __delfield_option, None)
1870
1871 def __getfield_speeddial(self):
1872 return self.__field_speeddial.getvalue()
1873
1874 def __setfield_speeddial(self, value):
1875 if isinstance(value,UINT):
1876 self.__field_speeddial=value
1877 else:
1878 self.__field_speeddial=UINT(value,**{'sizeinbytes': 2})
1879
1880 def __delfield_speeddial(self): del self.__field_speeddial
1881
1882 speeddial=property(__getfield_speeddial, __setfield_speeddial, __delfield_speeddial, None)
1883
1884 def __getfield_ringtone(self):
1885 return self.__field_ringtone.getvalue()
1886
1887 def __setfield_ringtone(self, value):
1888 if isinstance(value,STRING):
1889 self.__field_ringtone=value
1890 else:
1891 self.__field_ringtone=STRING(value,**{ 'terminator': None, 'pascal': True })
1892
1893 def __delfield_ringtone(self): del self.__field_ringtone
1894
1895 ringtone=property(__getfield_ringtone, __setfield_ringtone, __delfield_ringtone, None)
1896
1897 def iscontainer(self):
1898 return True
1899
1900 def containerelements(self):
1901 yield ('number', self.__field_number, None)
1902 yield ('option', self.__field_option, None)
1903 if self.option & PB_FLG_SPEEDDIAL:
1904 yield ('speeddial', self.__field_speeddial, None)
1905 if self.option & PB_FLG_RINGTONE:
1906 yield ('ringtone', self.__field_ringtone, None)
1907
1908
1909
1910
1911 class PBEntry(BaseProtogenClass):
1912 __fields=['info', 'zero1', 'name', 'email', 'email2', 'home', 'work', 'cell', 'fax', 'cell2', 'datetime', 'group', 'ringtone', 'wallpaper', 'wallpaper_range']
1913
1914 def __init__(self, *args, **kwargs):
1915 dict={}
1916 dict.update(kwargs)
1918 super(PBEntry,self).__init__(**dict)
1920 if self.__class__ is PBEntry:
1921 self._update(args,dict)
1922
1923
1924 def getfields(self):
1925 return self.__fields
1926
1927
1928 def _update(self, args, kwargs):
1929 super(PBEntry,self)._update(args,kwargs)
1930 keys=kwargs.keys()
1931 for key in keys:
1932 if key in self.__fields:
1933 setattr(self, key, kwargs[key])
1934 del kwargs[key]
1935 if __debug__:
1937 self._complainaboutunusedargs(PBEntry,kwargs)
1938 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
1939
1941
1942 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1943 'Writes this packet to the supplied buffer'
1944 self._bufferstartoffset=buf.getcurrentoffset()
1945 self.__field_info.writetobuffer(buf)
1946 try: self.__field_zero1
1947 except:
1948 self.__field_zero1=UINT(**{'sizeinbytes': 2, 'default': 0 })
1949 self.__field_zero1.writetobuffer(buf)
1950 if self.info & PB_FLG_NAME:
1951 self.__field_name.writetobuffer(buf)
1952 if self.info & PB_FLG_EMAIL:
1953 self.__field_email.writetobuffer(buf)
1954 if self.info & PB_FLG_EMAIL2:
1955 self.__field_email2.writetobuffer(buf)
1956 if self.info & PB_FLG_HOME:
1957 self.__field_home.writetobuffer(buf)
1958 if self.info & PB_FLG_WORK:
1959 self.__field_work.writetobuffer(buf)
1960 if self.info & PB_FLG_CELL:
1961 self.__field_cell.writetobuffer(buf)
1962 if self.info & PB_FLG_FAX:
1963 self.__field_fax.writetobuffer(buf)
1964 if self.info & PB_FLG_CELL2:
1965 self.__field_cell2.writetobuffer(buf)
1966 if self.info & PB_FLG_DATE:
1967 self.__field_datetime.writetobuffer(buf)
1968 if self.info & PB_FLG_GROUP:
1969 self.__field_group.writetobuffer(buf)
1970 if self.info & PB_FLG_CRINGTONE:
1971 self.__field_ringtone.writetobuffer(buf)
1972 if self.info & PB_FLG_WP:
1973 self.__field_wallpaper.writetobuffer(buf)
1974 self.__field_wallpaper_range.writetobuffer(buf)
1975 self._bufferendoffset=buf.getcurrentoffset()
1976 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1977
1978
1979 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1980 'Reads this packet from the supplied buffer'
1981 self._bufferstartoffset=buf.getcurrentoffset()
1982 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1983 self.__field_info=UINT(**{'sizeinbytes': 2})
1984 self.__field_info.readfrombuffer(buf)
1985 self.__field_zero1=UINT(**{'sizeinbytes': 2, 'default': 0 })
1986 self.__field_zero1.readfrombuffer(buf)
1987 if self.info & PB_FLG_NAME:
1988 self.__field_name=USTRING(**{ 'terminator': None, 'encoding': ENCODING, 'pascal': True })
1989 self.__field_name.readfrombuffer(buf)
1990 if self.info & PB_FLG_EMAIL:
1991 self.__field_email=USTRING(**{ 'terminator': None, 'encoding': ENCODING, 'pascal': True })
1992 self.__field_email.readfrombuffer(buf)
1993 if self.info & PB_FLG_EMAIL2:
1994 self.__field_email2=USTRING(**{ 'terminator': None, 'encoding': ENCODING, 'pascal': True })
1995 self.__field_email2.readfrombuffer(buf)
1996 if self.info & PB_FLG_HOME:
1997 self.__field_home=NumberEntry()
1998 self.__field_home.readfrombuffer(buf)
1999 if self.info & PB_FLG_WORK:
2000 self.__field_work=NumberEntry()
2001 self.__field_work.readfrombuffer(buf)
2002 if self.info & PB_FLG_CELL:
2003 self.__field_cell=NumberEntry()
2004 self.__field_cell.readfrombuffer(buf)
2005 if self.info & PB_FLG_FAX:
2006 self.__field_fax=NumberEntry()
2007 self.__field_fax.readfrombuffer(buf)
2008 if self.info & PB_FLG_CELL2:
2009 self.__field_cell2=NumberEntry()
2010 self.__field_cell2.readfrombuffer(buf)
2011 if self.info & PB_FLG_DATE:
2012 self.__field_datetime=DateTime(**{'sizeinbytes': 4})
2013 self.__field_datetime.readfrombuffer(buf)
2014 if self.info & PB_FLG_GROUP:
2015 self.__field_group=UINT(**{'sizeinbytes': 1})
2016 self.__field_group.readfrombuffer(buf)
2017 if self.info & PB_FLG_CRINGTONE:
2018 self.__field_ringtone=STRING(**{ 'terminator': None, 'pascal': True })
2019 self.__field_ringtone.readfrombuffer(buf)
2020 if self.info & PB_FLG_WP:
2021 self.__field_wallpaper=STRING(**{ 'terminator': None, 'pascal': True })
2022 self.__field_wallpaper.readfrombuffer(buf)
2023 self.__field_wallpaper_range=UINT(**{'sizeinbytes': 4})
2024 self.__field_wallpaper_range.readfrombuffer(buf)
2025 self._bufferendoffset=buf.getcurrentoffset()
2026
2027
2028 def __getfield_info(self):
2029 return self.__field_info.getvalue()
2030
2031 def __setfield_info(self, value):
2032 if isinstance(value,UINT):
2033 self.__field_info=value
2034 else:
2035 self.__field_info=UINT(value,**{'sizeinbytes': 2})
2036
2037 def __delfield_info(self): del self.__field_info
2038
2039 info=property(__getfield_info, __setfield_info, __delfield_info, None)
2040
2041 def __getfield_zero1(self):
2042 try: self.__field_zero1
2043 except:
2044 self.__field_zero1=UINT(**{'sizeinbytes': 2, 'default': 0 })
2045 return self.__field_zero1.getvalue()
2046
2047 def __setfield_zero1(self, value):
2048 if isinstance(value,UINT):
2049 self.__field_zero1=value
2050 else:
2051 self.__field_zero1=UINT(value,**{'sizeinbytes': 2, 'default': 0 })
2052
2053 def __delfield_zero1(self): del self.__field_zero1
2054
2055 zero1=property(__getfield_zero1, __setfield_zero1, __delfield_zero1, None)
2056
2057 def __getfield_name(self):
2058 return self.__field_name.getvalue()
2059
2060 def __setfield_name(self, value):
2061 if isinstance(value,USTRING):
2062 self.__field_name=value
2063 else:
2064 self.__field_name=USTRING(value,**{ 'terminator': None, 'encoding': ENCODING, 'pascal': True })
2065
2066 def __delfield_name(self): del self.__field_name
2067
2068 name=property(__getfield_name, __setfield_name, __delfield_name, None)
2069
2070 def __getfield_email(self):
2071 return self.__field_email.getvalue()
2072
2073 def __setfield_email(self, value):
2074 if isinstance(value,USTRING):
2075 self.__field_email=value
2076 else:
2077 self.__field_email=USTRING(value,**{ 'terminator': None, 'encoding': ENCODING, 'pascal': True })
2078
2079 def __delfield_email(self): del self.__field_email
2080
2081 email=property(__getfield_email, __setfield_email, __delfield_email, None)
2082
2083 def __getfield_email2(self):
2084 return self.__field_email2.getvalue()
2085
2086 def __setfield_email2(self, value):
2087 if isinstance(value,USTRING):
2088 self.__field_email2=value
2089 else:
2090 self.__field_email2=USTRING(value,**{ 'terminator': None, 'encoding': ENCODING, 'pascal': True })
2091
2092 def __delfield_email2(self): del self.__field_email2
2093
2094 email2=property(__getfield_email2, __setfield_email2, __delfield_email2, None)
2095
2096 def __getfield_home(self):
2097 return self.__field_home.getvalue()
2098
2099 def __setfield_home(self, value):
2100 if isinstance(value,NumberEntry):
2101 self.__field_home=value
2102 else:
2103 self.__field_home=NumberEntry(value,)
2104
2105 def __delfield_home(self): del self.__field_home
2106
2107 home=property(__getfield_home, __setfield_home, __delfield_home, None)
2108
2109 def __getfield_work(self):
2110 return self.__field_work.getvalue()
2111
2112 def __setfield_work(self, value):
2113 if isinstance(value,NumberEntry):
2114 self.__field_work=value
2115 else:
2116 self.__field_work=NumberEntry(value,)
2117
2118 def __delfield_work(self): del self.__field_work
2119
2120 work=property(__getfield_work, __setfield_work, __delfield_work, None)
2121
2122 def __getfield_cell(self):
2123 return self.__field_cell.getvalue()
2124
2125 def __setfield_cell(self, value):
2126 if isinstance(value,NumberEntry):
2127 self.__field_cell=value
2128 else:
2129 self.__field_cell=NumberEntry(value,)
2130
2131 def __delfield_cell(self): del self.__field_cell
2132
2133 cell=property(__getfield_cell, __setfield_cell, __delfield_cell, None)
2134
2135 def __getfield_fax(self):
2136 return self.__field_fax.getvalue()
2137
2138 def __setfield_fax(self, value):
2139 if isinstance(value,NumberEntry):
2140 self.__field_fax=value
2141 else:
2142 self.__field_fax=NumberEntry(value,)
2143
2144 def __delfield_fax(self): del self.__field_fax
2145
2146 fax=property(__getfield_fax, __setfield_fax, __delfield_fax, None)
2147
2148 def __getfield_cell2(self):
2149 return self.__field_cell2.getvalue()
2150
2151 def __setfield_cell2(self, value):
2152 if isinstance(value,NumberEntry):
2153 self.__field_cell2=value
2154 else:
2155 self.__field_cell2=NumberEntry(value,)
2156
2157 def __delfield_cell2(self): del self.__field_cell2
2158
2159 cell2=property(__getfield_cell2, __setfield_cell2, __delfield_cell2, None)
2160
2161 def __getfield_datetime(self):
2162 return self.__field_datetime.getvalue()
2163
2164 def __setfield_datetime(self, value):
2165 if isinstance(value,DateTime):
2166 self.__field_datetime=value
2167 else:
2168 self.__field_datetime=DateTime(value,**{'sizeinbytes': 4})
2169
2170 def __delfield_datetime(self): del self.__field_datetime
2171
2172 datetime=property(__getfield_datetime, __setfield_datetime, __delfield_datetime, None)
2173
2174 def __getfield_group(self):
2175 return self.__field_group.getvalue()
2176
2177 def __setfield_group(self, value):
2178 if isinstance(value,UINT):
2179 self.__field_group=value
2180 else:
2181 self.__field_group=UINT(value,**{'sizeinbytes': 1})
2182
2183 def __delfield_group(self): del self.__field_group
2184
2185 group=property(__getfield_group, __setfield_group, __delfield_group, None)
2186
2187 def __getfield_ringtone(self):
2188 return self.__field_ringtone.getvalue()
2189
2190 def __setfield_ringtone(self, value):
2191 if isinstance(value,STRING):
2192 self.__field_ringtone=value
2193 else:
2194 self.__field_ringtone=STRING(value,**{ 'terminator': None, 'pascal': True })
2195
2196 def __delfield_ringtone(self): del self.__field_ringtone
2197
2198 ringtone=property(__getfield_ringtone, __setfield_ringtone, __delfield_ringtone, None)
2199
2200 def __getfield_wallpaper(self):
2201 return self.__field_wallpaper.getvalue()
2202
2203 def __setfield_wallpaper(self, value):
2204 if isinstance(value,STRING):
2205 self.__field_wallpaper=value
2206 else:
2207 self.__field_wallpaper=STRING(value,**{ 'terminator': None, 'pascal': True })
2208
2209 def __delfield_wallpaper(self): del self.__field_wallpaper
2210
2211 wallpaper=property(__getfield_wallpaper, __setfield_wallpaper, __delfield_wallpaper, None)
2212
2213 def __getfield_wallpaper_range(self):
2214 return self.__field_wallpaper_range.getvalue()
2215
2216 def __setfield_wallpaper_range(self, value):
2217 if isinstance(value,UINT):
2218 self.__field_wallpaper_range=value
2219 else:
2220 self.__field_wallpaper_range=UINT(value,**{'sizeinbytes': 4})
2221
2222 def __delfield_wallpaper_range(self): del self.__field_wallpaper_range
2223
2224 wallpaper_range=property(__getfield_wallpaper_range, __setfield_wallpaper_range, __delfield_wallpaper_range, None)
2225
2226 def iscontainer(self):
2227 return True
2228
2229 def containerelements(self):
2230 yield ('info', self.__field_info, None)
2231 yield ('zero1', self.__field_zero1, None)
2232 if self.info & PB_FLG_NAME:
2233 yield ('name', self.__field_name, None)
2234 if self.info & PB_FLG_EMAIL:
2235 yield ('email', self.__field_email, None)
2236 if self.info & PB_FLG_EMAIL2:
2237 yield ('email2', self.__field_email2, None)
2238 if self.info & PB_FLG_HOME:
2239 yield ('home', self.__field_home, None)
2240 if self.info & PB_FLG_WORK:
2241 yield ('work', self.__field_work, None)
2242 if self.info & PB_FLG_CELL:
2243 yield ('cell', self.__field_cell, None)
2244 if self.info & PB_FLG_FAX:
2245 yield ('fax', self.__field_fax, None)
2246 if self.info & PB_FLG_CELL2:
2247 yield ('cell2', self.__field_cell2, None)
2248 if self.info & PB_FLG_DATE:
2249 yield ('datetime', self.__field_datetime, None)
2250 if self.info & PB_FLG_GROUP:
2251 yield ('group', self.__field_group, None)
2252 if self.info & PB_FLG_CRINGTONE:
2253 yield ('ringtone', self.__field_ringtone, None)
2254 if self.info & PB_FLG_WP:
2255 yield ('wallpaper', self.__field_wallpaper, None)
2256 yield ('wallpaper_range', self.__field_wallpaper_range, None)
2257
2258
2259
2260
2261 class ss_number_entry(BaseProtogenClass):
2262 __fields=['number', 'speeddial', 'primary', 'zero', 'ringtone']
2263
2264 def __init__(self, *args, **kwargs):
2265 dict={}
2266 dict.update(kwargs)
2268 super(ss_number_entry,self).__init__(**dict)
2270 if self.__class__ is ss_number_entry:
2271 self._update(args,dict)
2272
2273
2274 def getfields(self):
2275 return self.__fields
2276
2277
2278 def _update(self, args, kwargs):
2279 super(ss_number_entry,self)._update(args,kwargs)
2280 keys=kwargs.keys()
2281 for key in keys:
2282 if key in self.__fields:
2283 setattr(self, key, kwargs[key])
2284 del kwargs[key]
2285 if __debug__:
2287 self._complainaboutunusedargs(ss_number_entry,kwargs)
2288 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
2289
2291
2292 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
2293 'Writes this packet to the supplied buffer'
2294 self._bufferstartoffset=buf.getcurrentoffset()
2295 try: self.__field_number
2296 except:
2297 self.__field_number=STRING(**{ 'terminator': 0, 'default': '', 'maxsizeinbytes': PB_MAX_NUMBER_LEN, 'raiseontruncate': False })
2298 self.__field_number.writetobuffer(buf)
2299 try: self.__field_speeddial
2300 except:
2301 self.__field_speeddial=UINT(**{'sizeinbytes': 2, 'default': 0 })
2302 self.__field_speeddial.writetobuffer(buf)
2303 try: self.__field_primary
2304 except:
2305 self.__field_primary=UINT(**{'sizeinbytes': 1, 'default': 0 })
2306 self.__field_primary.writetobuffer(buf)
2307 try: self.__field_zero
2308 except:
2309 self.__field_zero=STRING(**{'sizeinbytes': 8, 'pad': 0, 'default': '' })
2310 self.__field_zero.writetobuffer(buf)
2311 try: self.__field_ringtone
2312 except:
2313 self.__field_ringtone=STRING(**{ 'terminator': 0, 'default': '' })
2314 self.__field_ringtone.writetobuffer(buf)
2315 self._bufferendoffset=buf.getcurrentoffset()
2316 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
2317
2318
2319 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
2320 'Reads this packet from the supplied buffer'
2321 self._bufferstartoffset=buf.getcurrentoffset()
2322 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
2323 self.__field_number=STRING(**{ 'terminator': 0, 'default': '', 'maxsizeinbytes': PB_MAX_NUMBER_LEN, 'raiseontruncate': False })
2324 self.__field_number.readfrombuffer(buf)
2325 self.__field_speeddial=UINT(**{'sizeinbytes': 2, 'default': 0 })
2326 self.__field_speeddial.readfrombuffer(buf)
2327 self.__field_primary=UINT(**{'sizeinbytes': 1, 'default': 0 })
2328 self.__field_primary.readfrombuffer(buf)
2329 self.__field_zero=STRING(**{'sizeinbytes': 8, 'pad': 0, 'default': '' })
2330 self.__field_zero.readfrombuffer(buf)
2331 self.__field_ringtone=STRING(**{ 'terminator': 0, 'default': '' })
2332 self.__field_ringtone.readfrombuffer(buf)
2333 self._bufferendoffset=buf.getcurrentoffset()
2334
2335
2336 def __getfield_number(self):
2337 try: self.__field_number
2338 except:
2339 self.__field_number=STRING(**{ 'terminator': 0, 'default': '', 'maxsizeinbytes': PB_MAX_NUMBER_LEN, 'raiseontruncate': False })
2340 return self.__field_number.getvalue()
2341
2342 def __setfield_number(self, value):
2343 if isinstance(value,STRING):
2344 self.__field_number=value
2345 else:
2346 self.__field_number=STRING(value,**{ 'terminator': 0, 'default': '', 'maxsizeinbytes': PB_MAX_NUMBER_LEN, 'raiseontruncate': False })
2347
2348 def __delfield_number(self): del self.__field_number
2349
2350 number=property(__getfield_number, __setfield_number, __delfield_number, None)
2351
2352 def __getfield_speeddial(self):
2353 try: self.__field_speeddial
2354 except:
2355 self.__field_speeddial=UINT(**{'sizeinbytes': 2, 'default': 0 })
2356 return self.__field_speeddial.getvalue()
2357
2358 def __setfield_speeddial(self, value):
2359 if isinstance(value,UINT):
2360 self.__field_speeddial=value
2361 else:
2362 self.__field_speeddial=UINT(value,**{'sizeinbytes': 2, 'default': 0 })
2363
2364 def __delfield_speeddial(self): del self.__field_speeddial
2365
2366 speeddial=property(__getfield_speeddial, __setfield_speeddial, __delfield_speeddial, None)
2367
2368 def __getfield_primary(self):
2369 try: self.__field_primary
2370 except:
2371 self.__field_primary=UINT(**{'sizeinbytes': 1, 'default': 0 })
2372 return self.__field_primary.getvalue()
2373
2374 def __setfield_primary(self, value):
2375 if isinstance(value,UINT):
2376 self.__field_primary=value
2377 else:
2378 self.__field_primary=UINT(value,**{'sizeinbytes': 1, 'default': 0 })
2379
2380 def __delfield_primary(self): del self.__field_primary
2381
2382 primary=property(__getfield_primary, __setfield_primary, __delfield_primary, None)
2383
2384 def __getfield_zero(self):
2385 try: self.__field_zero
2386 except:
2387 self.__field_zero=STRING(**{'sizeinbytes': 8, 'pad': 0, 'default': '' })
2388 return self.__field_zero.getvalue()
2389
2390 def __setfield_zero(self, value):
2391 if isinstance(value,STRING):
2392 self.__field_zero=value
2393 else:
2394 self.__field_zero=STRING(value,**{'sizeinbytes': 8, 'pad': 0, 'default': '' })
2395
2396 def __delfield_zero(self): del self.__field_zero
2397
2398 zero=property(__getfield_zero, __setfield_zero, __delfield_zero, None)
2399
2400 def __getfield_ringtone(self):
2401 try: self.__field_ringtone
2402 except:
2403 self.__field_ringtone=STRING(**{ 'terminator': 0, 'default': '' })
2404 return self.__field_ringtone.getvalue()
2405
2406 def __setfield_ringtone(self, value):
2407 if isinstance(value,STRING):
2408 self.__field_ringtone=value
2409 else:
2410 self.__field_ringtone=STRING(value,**{ 'terminator': 0, 'default': '' })
2411
2412 def __delfield_ringtone(self): del self.__field_ringtone
2413
2414 ringtone=property(__getfield_ringtone, __setfield_ringtone, __delfield_ringtone, None)
2415
2416 def iscontainer(self):
2417 return True
2418
2419 def containerelements(self):
2420 yield ('number', self.__field_number, None)
2421 yield ('speeddial', self.__field_speeddial, None)
2422 yield ('primary', self.__field_primary, None)
2423 yield ('zero', self.__field_zero, None)
2424 yield ('ringtone', self.__field_ringtone, None)
2425
2426
2427
2428
2429 class ss_pb_entry(BaseProtogenClass):
2430 __fields=['name', 'email', 'email2', 'zero1', 'ringtone', 'wallpaper', 'zero2', 'home', 'work', 'cell', 'dummy', 'fax', 'cell2', 'zero3', 'group', 'zero4']
2431
2432 def __init__(self, *args, **kwargs):
2433 dict={}
2434 dict.update(kwargs)
2436 super(ss_pb_entry,self).__init__(**dict)
2438 if self.__class__ is ss_pb_entry:
2439 self._update(args,dict)
2440
2441
2442 def getfields(self):
2443 return self.__fields
2444
2445
2446 def _update(self, args, kwargs):
2447 super(ss_pb_entry,self)._update(args,kwargs)
2448 keys=kwargs.keys()
2449 for key in keys:
2450 if key in self.__fields:
2451 setattr(self, key, kwargs[key])
2452 del kwargs[key]
2453 if __debug__:
2455 self._complainaboutunusedargs(ss_pb_entry,kwargs)
2456 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
2457
2459
2460 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
2461 'Writes this packet to the supplied buffer'
2462 self._bufferstartoffset=buf.getcurrentoffset()
2463 self.__field_name.writetobuffer(buf)
2464 try: self.__field_email
2465 except:
2466 self.__field_email=USTRING(**{ 'terminator': 0, 'encoding': ENCODING, 'default': '', 'maxsizeinbytes': PB_MAX_EMAIL_LEN, 'raiseontruncate': False })
2467 self.__field_email.writetobuffer(buf)
2468 try: self.__field_email2
2469 except:
2470 self.__field_email2=USTRING(**{ 'terminator': 0, 'encoding': ENCODING, 'default': '', 'maxsizeinbytes': PB_MAX_EMAIL_LEN, 'raiseontruncate': False })
2471 self.__field_email2.writetobuffer(buf)
2472 try: self.__field_zero1
2473 except:
2474 self.__field_zero1=UINT(**{'sizeinbytes': 3, 'default': 0 })
2475 self.__field_zero1.writetobuffer(buf)
2476 try: self.__field_ringtone
2477 except:
2478 self.__field_ringtone=STRING(**{ 'terminator': 0, 'default': '' })
2479 self.__field_ringtone.writetobuffer(buf)
2480 try: self.__field_wallpaper
2481 except:
2482 self.__field_wallpaper=STRING(**{ 'terminator': 0, 'default': '' })
2483 self.__field_wallpaper.writetobuffer(buf)
2484 try: self.__field_zero2
2485 except:
2486 self.__field_zero2=UINT(**{'sizeinbytes': 1, 'default': 0 })
2487 self.__field_zero2.writetobuffer(buf)
2488 try: self.__field_home
2489 except:
2490 self.__field_home=ss_number_entry()
2491 self.__field_home.writetobuffer(buf)
2492 try: self.__field_work
2493 except:
2494 self.__field_work=ss_number_entry()
2495 self.__field_work.writetobuffer(buf)
2496 try: self.__field_cell
2497 except:
2498 self.__field_cell=ss_number_entry()
2499 self.__field_cell.writetobuffer(buf)
2500 try: self.__field_dummy
2501 except:
2502 self.__field_dummy=ss_number_entry()
2503 self.__field_dummy.writetobuffer(buf)
2504 try: self.__field_fax
2505 except:
2506 self.__field_fax=ss_number_entry()
2507 self.__field_fax.writetobuffer(buf)
2508 try: self.__field_cell2
2509 except:
2510 self.__field_cell2=ss_number_entry()
2511 self.__field_cell2.writetobuffer(buf)
2512 try: self.__field_zero3
2513 except:
2514 self.__field_zero3=UINT(**{'sizeinbytes': 4, 'default': 0 })
2515 self.__field_zero3.writetobuffer(buf)
2516 try: self.__field_group
2517 except:
2518 self.__field_group=UINT(**{'sizeinbytes': 1, 'default': 0 })
2519 self.__field_group.writetobuffer(buf)
2520 try: self.__field_zero4
2521 except:
2522 self.__field_zero4=UINT(**{'sizeinbytes': 2, 'default': 0 })
2523 self.__field_zero4.writetobuffer(buf)
2524 self._bufferendoffset=buf.getcurrentoffset()
2525 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
2526
2527
2528 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
2529 'Reads this packet from the supplied buffer'
2530 self._bufferstartoffset=buf.getcurrentoffset()
2531 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
2532 self.__field_name=USTRING(**{ 'terminator': 0, 'maxsizeinbytes': PB_MAX_NAME_LEN, 'encoding': ENCODING, 'raiseontruncate': False })
2533 self.__field_name.readfrombuffer(buf)
2534 self.__field_email=USTRING(**{ 'terminator': 0, 'encoding': ENCODING, 'default': '', 'maxsizeinbytes': PB_MAX_EMAIL_LEN, 'raiseontruncate': False })
2535 self.__field_email.readfrombuffer(buf)
2536 self.__field_email2=USTRING(**{ 'terminator': 0, 'encoding': ENCODING, 'default': '', 'maxsizeinbytes': PB_MAX_EMAIL_LEN, 'raiseontruncate': False })
2537 self.__field_email2.readfrombuffer(buf)
2538 self.__field_zero1=UINT(**{'sizeinbytes': 3, 'default': 0 })
2539 self.__field_zero1.readfrombuffer(buf)
2540 self.__field_ringtone=STRING(**{ 'terminator': 0, 'default': '' })
2541 self.__field_ringtone.readfrombuffer(buf)
2542 self.__field_wallpaper=STRING(**{ 'terminator': 0, 'default': '' })
2543 self.__field_wallpaper.readfrombuffer(buf)
2544 self.__field_zero2=UINT(**{'sizeinbytes': 1, 'default': 0 })
2545 self.__field_zero2.readfrombuffer(buf)
2546 self.__field_home=ss_number_entry()
2547 self.__field_home.readfrombuffer(buf)
2548 self.__field_work=ss_number_entry()
2549 self.__field_work.readfrombuffer(buf)
2550 self.__field_cell=ss_number_entry()
2551 self.__field_cell.readfrombuffer(buf)
2552 self.__field_dummy=ss_number_entry()
2553 self.__field_dummy.readfrombuffer(buf)
2554 self.__field_fax=ss_number_entry()
2555 self.__field_fax.readfrombuffer(buf)
2556 self.__field_cell2=ss_number_entry()
2557 self.__field_cell2.readfrombuffer(buf)
2558 self.__field_zero3=UINT(**{'sizeinbytes': 4, 'default': 0 })
2559 self.__field_zero3.readfrombuffer(buf)
2560 self.__field_group=UINT(**{'sizeinbytes': 1, 'default': 0 })
2561 self.__field_group.readfrombuffer(buf)
2562 self.__field_zero4=UINT(**{'sizeinbytes': 2, 'default': 0 })
2563 self.__field_zero4.readfrombuffer(buf)
2564 self._bufferendoffset=buf.getcurrentoffset()
2565
2566
2567 def __getfield_name(self):
2568 return self.__field_name.getvalue()
2569
2570 def __setfield_name(self, value):
2571 if isinstance(value,USTRING):
2572 self.__field_name=value
2573 else:
2574 self.__field_name=USTRING(value,**{ 'terminator': 0, 'maxsizeinbytes': PB_MAX_NAME_LEN, 'encoding': ENCODING, 'raiseontruncate': False })
2575
2576 def __delfield_name(self): del self.__field_name
2577
2578 name=property(__getfield_name, __setfield_name, __delfield_name, None)
2579
2580 def __getfield_email(self):
2581 try: self.__field_email
2582 except:
2583 self.__field_email=USTRING(**{ 'terminator': 0, 'encoding': ENCODING, 'default': '', 'maxsizeinbytes': PB_MAX_EMAIL_LEN, 'raiseontruncate': False })
2584 return self.__field_email.getvalue()
2585
2586 def __setfield_email(self, value):
2587 if isinstance(value,USTRING):
2588 self.__field_email=value
2589 else:
2590 self.__field_email=USTRING(value,**{ 'terminator': 0, 'encoding': ENCODING, 'default': '', 'maxsizeinbytes': PB_MAX_EMAIL_LEN, 'raiseontruncate': False })
2591
2592 def __delfield_email(self): del self.__field_email
2593
2594 email=property(__getfield_email, __setfield_email, __delfield_email, None)
2595
2596 def __getfield_email2(self):
2597 try: self.__field_email2
2598 except:
2599 self.__field_email2=USTRING(**{ 'terminator': 0, 'encoding': ENCODING, 'default': '', 'maxsizeinbytes': PB_MAX_EMAIL_LEN, 'raiseontruncate': False })
2600 return self.__field_email2.getvalue()
2601
2602 def __setfield_email2(self, value):
2603 if isinstance(value,USTRING):
2604 self.__field_email2=value
2605 else:
2606 self.__field_email2=USTRING(value,**{ 'terminator': 0, 'encoding': ENCODING, 'default': '', 'maxsizeinbytes': PB_MAX_EMAIL_LEN, 'raiseontruncate': False })
2607
2608 def __delfield_email2(self): del self.__field_email2
2609
2610 email2=property(__getfield_email2, __setfield_email2, __delfield_email2, None)
2611
2612 def __getfield_zero1(self):
2613 try: self.__field_zero1
2614 except:
2615 self.__field_zero1=UINT(**{'sizeinbytes': 3, 'default': 0 })
2616 return self.__field_zero1.getvalue()
2617
2618 def __setfield_zero1(self, value):
2619 if isinstance(value,UINT):
2620 self.__field_zero1=value
2621 else:
2622 self.__field_zero1=UINT(value,**{'sizeinbytes': 3, 'default': 0 })
2623
2624 def __delfield_zero1(self): del self.__field_zero1
2625
2626 zero1=property(__getfield_zero1, __setfield_zero1, __delfield_zero1, None)
2627
2628 def __getfield_ringtone(self):
2629 try: self.__field_ringtone
2630 except:
2631 self.__field_ringtone=STRING(**{ 'terminator': 0, 'default': '' })
2632 return self.__field_ringtone.getvalue()
2633
2634 def __setfield_ringtone(self, value):
2635 if isinstance(value,STRING):
2636 self.__field_ringtone=value
2637 else:
2638 self.__field_ringtone=STRING(value,**{ 'terminator': 0, 'default': '' })
2639
2640 def __delfield_ringtone(self): del self.__field_ringtone
2641
2642 ringtone=property(__getfield_ringtone, __setfield_ringtone, __delfield_ringtone, None)
2643
2644 def __getfield_wallpaper(self):
2645 try: self.__field_wallpaper
2646 except:
2647 self.__field_wallpaper=STRING(**{ 'terminator': 0, 'default': '' })
2648 return self.__field_wallpaper.getvalue()
2649
2650 def __setfield_wallpaper(self, value):
2651 if isinstance(value,STRING):
2652 self.__field_wallpaper=value
2653 else:
2654 self.__field_wallpaper=STRING(value,**{ 'terminator': 0, 'default': '' })
2655
2656 def __delfield_wallpaper(self): del self.__field_wallpaper
2657
2658 wallpaper=property(__getfield_wallpaper, __setfield_wallpaper, __delfield_wallpaper, None)
2659
2660 def __getfield_zero2(self):
2661 try: self.__field_zero2
2662 except:
2663 self.__field_zero2=UINT(**{'sizeinbytes': 1, 'default': 0 })
2664 return self.__field_zero2.getvalue()
2665
2666 def __setfield_zero2(self, value):
2667 if isinstance(value,UINT):
2668 self.__field_zero2=value
2669 else:
2670 self.__field_zero2=UINT(value,**{'sizeinbytes': 1, 'default': 0 })
2671
2672 def __delfield_zero2(self): del self.__field_zero2
2673
2674 zero2=property(__getfield_zero2, __setfield_zero2, __delfield_zero2, None)
2675
2676 def __getfield_home(self):
2677 try: self.__field_home
2678 except:
2679 self.__field_home=ss_number_entry()
2680 return self.__field_home.getvalue()
2681
2682 def __setfield_home(self, value):
2683 if isinstance(value,ss_number_entry):
2684 self.__field_home=value
2685 else:
2686 self.__field_home=ss_number_entry(value,)
2687
2688 def __delfield_home(self): del self.__field_home
2689
2690 home=property(__getfield_home, __setfield_home, __delfield_home, None)
2691
2692 def __getfield_work(self):
2693 try: self.__field_work
2694 except:
2695 self.__field_work=ss_number_entry()
2696 return self.__field_work.getvalue()
2697
2698 def __setfield_work(self, value):
2699 if isinstance(value,ss_number_entry):
2700 self.__field_work=value
2701 else:
2702 self.__field_work=ss_number_entry(value,)
2703
2704 def __delfield_work(self): del self.__field_work
2705
2706 work=property(__getfield_work, __setfield_work, __delfield_work, None)
2707
2708 def __getfield_cell(self):
2709 try: self.__field_cell
2710 except:
2711 self.__field_cell=ss_number_entry()
2712 return self.__field_cell.getvalue()
2713
2714 def __setfield_cell(self, value):
2715 if isinstance(value,ss_number_entry):
2716 self.__field_cell=value
2717 else:
2718 self.__field_cell=ss_number_entry(value,)
2719
2720 def __delfield_cell(self): del self.__field_cell
2721
2722 cell=property(__getfield_cell, __setfield_cell, __delfield_cell, None)
2723
2724 def __getfield_dummy(self):
2725 try: self.__field_dummy
2726 except:
2727 self.__field_dummy=ss_number_entry()
2728 return self.__field_dummy.getvalue()
2729
2730 def __setfield_dummy(self, value):
2731 if isinstance(value,ss_number_entry):
2732 self.__field_dummy=value
2733 else:
2734 self.__field_dummy=ss_number_entry(value,)
2735
2736 def __delfield_dummy(self): del self.__field_dummy
2737
2738 dummy=property(__getfield_dummy, __setfield_dummy, __delfield_dummy, None)
2739
2740 def __getfield_fax(self):
2741 try: self.__field_fax
2742 except:
2743 self.__field_fax=ss_number_entry()
2744 return self.__field_fax.getvalue()
2745
2746 def __setfield_fax(self, value):
2747 if isinstance(value,ss_number_entry):
2748 self.__field_fax=value
2749 else:
2750 self.__field_fax=ss_number_entry(value,)
2751
2752 def __delfield_fax(self): del self.__field_fax
2753
2754 fax=property(__getfield_fax, __setfield_fax, __delfield_fax, None)
2755
2756 def __getfield_cell2(self):
2757 try: self.__field_cell2
2758 except:
2759 self.__field_cell2=ss_number_entry()
2760 return self.__field_cell2.getvalue()
2761
2762 def __setfield_cell2(self, value):
2763 if isinstance(value,ss_number_entry):
2764 self.__field_cell2=value
2765 else:
2766 self.__field_cell2=ss_number_entry(value,)
2767
2768 def __delfield_cell2(self): del self.__field_cell2
2769
2770 cell2=property(__getfield_cell2, __setfield_cell2, __delfield_cell2, None)
2771
2772 def __getfield_zero3(self):
2773 try: self.__field_zero3
2774 except:
2775 self.__field_zero3=UINT(**{'sizeinbytes': 4, 'default': 0 })
2776 return self.__field_zero3.getvalue()
2777
2778 def __setfield_zero3(self, value):
2779 if isinstance(value,UINT):
2780 self.__field_zero3=value
2781 else:
2782 self.__field_zero3=UINT(value,**{'sizeinbytes': 4, 'default': 0 })
2783
2784 def __delfield_zero3(self): del self.__field_zero3
2785
2786 zero3=property(__getfield_zero3, __setfield_zero3, __delfield_zero3, None)
2787
2788 def __getfield_group(self):
2789 try: self.__field_group
2790 except:
2791 self.__field_group=UINT(**{'sizeinbytes': 1, 'default': 0 })
2792 return self.__field_group.getvalue()
2793
2794 def __setfield_group(self, value):
2795 if isinstance(value,UINT):
2796 self.__field_group=value
2797 else:
2798 self.__field_group=UINT(value,**{'sizeinbytes': 1, 'default': 0 })
2799
2800 def __delfield_group(self): del self.__field_group
2801
2802 group=property(__getfield_group, __setfield_group, __delfield_group, None)
2803
2804 def __getfield_zero4(self):
2805 try: self.__field_zero4
2806 except:
2807 self.__field_zero4=UINT(**{'sizeinbytes': 2, 'default': 0 })
2808 return self.__field_zero4.getvalue()
2809
2810 def __setfield_zero4(self, value):
2811 if isinstance(value,UINT):
2812 self.__field_zero4=value
2813 else:
2814 self.__field_zero4=UINT(value,**{'sizeinbytes': 2, 'default': 0 })
2815
2816 def __delfield_zero4(self): del self.__field_zero4
2817
2818 zero4=property(__getfield_zero4, __setfield_zero4, __delfield_zero4, None)
2819
2820 def iscontainer(self):
2821 return True
2822
2823 def containerelements(self):
2824 yield ('name', self.__field_name, None)
2825 yield ('email', self.__field_email, None)
2826 yield ('email2', self.__field_email2, None)
2827 yield ('zero1', self.__field_zero1, None)
2828 yield ('ringtone', self.__field_ringtone, None)
2829 yield ('wallpaper', self.__field_wallpaper, None)
2830 yield ('zero2', self.__field_zero2, None)
2831 yield ('home', self.__field_home, None)
2832 yield ('work', self.__field_work, None)
2833 yield ('cell', self.__field_cell, None)
2834 yield ('dummy', self.__field_dummy, None)
2835 yield ('fax', self.__field_fax, None)
2836 yield ('cell2', self.__field_cell2, None)
2837 yield ('zero3', self.__field_zero3, None)
2838 yield ('group', self.__field_group, None)
2839 yield ('zero4', self.__field_zero4, None)
2840
2841
2842
2843
2844 class ss_pb_write_req(BaseProtogenClass):
2845 __fields=['hdr', 'zero', 'entry']
2846
2847 def __init__(self, *args, **kwargs):
2848 dict={}
2849 dict.update(kwargs)
2851 super(ss_pb_write_req,self).__init__(**dict)
2853 if self.__class__ is ss_pb_write_req:
2854 self._update(args,dict)
2855
2856
2857 def getfields(self):
2858 return self.__fields
2859
2860
2861 def _update(self, args, kwargs):
2862 super(ss_pb_write_req,self)._update(args,kwargs)
2863 keys=kwargs.keys()
2864 for key in keys:
2865 if key in self.__fields:
2866 setattr(self, key, kwargs[key])
2867 del kwargs[key]
2868 if __debug__:
2870 self._complainaboutunusedargs(ss_pb_write_req,kwargs)
2871 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
2872
2874
2875 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
2876 'Writes this packet to the supplied buffer'
2877 self._bufferstartoffset=buf.getcurrentoffset()
2878 try: self.__field_hdr
2879 except:
2880 self.__field_hdr=ss_cmd_hdr(**{ 'command': SS_CMD_PB_WRITE })
2881 self.__field_hdr.writetobuffer(buf)
2882 try: self.__field_zero
2883 except:
2884 self.__field_zero=UINT(**{'sizeinbytes': 1, 'default': 0 })
2885 self.__field_zero.writetobuffer(buf)
2886 self.__field_entry.writetobuffer(buf)
2887 self._bufferendoffset=buf.getcurrentoffset()
2888 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
2889
2890
2891 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
2892 'Reads this packet from the supplied buffer'
2893 self._bufferstartoffset=buf.getcurrentoffset()
2894 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
2895 self.__field_hdr=ss_cmd_hdr(**{ 'command': SS_CMD_PB_WRITE })
2896 self.__field_hdr.readfrombuffer(buf)
2897 self.__field_zero=UINT(**{'sizeinbytes': 1, 'default': 0 })
2898 self.__field_zero.readfrombuffer(buf)
2899 self.__field_entry=ss_pb_entry()
2900 self.__field_entry.readfrombuffer(buf)
2901 self._bufferendoffset=buf.getcurrentoffset()
2902
2903
2904 def __getfield_hdr(self):
2905 try: self.__field_hdr
2906 except:
2907 self.__field_hdr=ss_cmd_hdr(**{ 'command': SS_CMD_PB_WRITE })
2908 return self.__field_hdr.getvalue()
2909
2910 def __setfield_hdr(self, value):
2911 if isinstance(value,ss_cmd_hdr):
2912 self.__field_hdr=value
2913 else:
2914 self.__field_hdr=ss_cmd_hdr(value,**{ 'command': SS_CMD_PB_WRITE })
2915
2916 def __delfield_hdr(self): del self.__field_hdr
2917
2918 hdr=property(__getfield_hdr, __setfield_hdr, __delfield_hdr, None)
2919
2920 def __getfield_zero(self):
2921 try: self.__field_zero
2922 except:
2923 self.__field_zero=UINT(**{'sizeinbytes': 1, 'default': 0 })
2924 return self.__field_zero.getvalue()
2925
2926 def __setfield_zero(self, value):
2927 if isinstance(value,UINT):
2928 self.__field_zero=value
2929 else:
2930 self.__field_zero=UINT(value,**{'sizeinbytes': 1, 'default': 0 })
2931
2932 def __delfield_zero(self): del self.__field_zero
2933
2934 zero=property(__getfield_zero, __setfield_zero, __delfield_zero, None)
2935
2936 def __getfield_entry(self):
2937 return self.__field_entry.getvalue()
2938
2939 def __setfield_entry(self, value):
2940 if isinstance(value,ss_pb_entry):
2941 self.__field_entry=value
2942 else:
2943 self.__field_entry=ss_pb_entry(value,)
2944
2945 def __delfield_entry(self): del self.__field_entry
2946
2947 entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None)
2948
2949 def iscontain