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