0001 # THIS FILE IS AUTOMATICALLY GENERATED. EDIT THE SOURCE FILE NOT THIS ONE 0002 0003 """Various descriptions of data specific to the Samsung SCH-A950 Phone""" 0004 0005 from prototypes import * 0006 from prototypes_samsung import * 0007 from p_brew import * 0008 from p_samsungscha950 import * 0009 0010 RT_PATH='brew/mod/mr' 0011 RT_INDEX_FILE_NAME=RT_PATH+'/MrInfo.db' 0012 RT_EXCLUDED_FILES=('MrInfo.db',) 0013 0014 SND_PATH='brew/mod/18067' 0015 SND_INDEX_FILE_NAME=SND_PATH+'/MsInfo.db' 0016 SND_EXCLUDED_FILES=('MsInfo.db', 'ExInfo.db') 0017 0018 PIC_PATH='brew/mod/10888' 0019 PIC_INDEX_FILE_NAME=PIC_PATH+'/Default Album.alb' 0020 PIC_EXCLUDED_FILES=('Default Album.alb',) 0021 PIC_TYPE_HEADER=0 0022 PIC_TYPE_BUILTIN=4 0023 PIC_TYPE_USERS=3 0024 0025 VIDEO_PATH='brew/mod/10890' 0026 VIDEO_INDEX_FILE_NAME=VIDEO_PATH+'/Default Album.alb' 0027 0028 PB_FLG_NOTE=0x0200 0029 PB_MAX_NOTE_LEN=64 0030 0031 CL_MAX_ENTRIES=90 0032 CL_TYPE_INCOMING=2 0033 CL_TYPE_OUTGOING=1 0034 CL_TYPE_MISSED=3 0035 CL_TYPE_DELETED=5 0036 CL_VALID_TYPE=frozenset((CL_TYPE_INCOMING, CL_TYPE_OUTGOING, CL_TYPE_MISSED)) 0037 0038 class WRingtoneIndexEntry(BaseProtogenClass): 0039 __fields=['name', 'path_prefix', 'pathname', 'eor'] 0040 0041 def __init__(self, *args, **kwargs): 0042 dict={} 0043 # What was supplied to this function 0044 dict.update(kwargs) 0045 # Parent constructor 0046 super(WRingtoneIndexEntry,self).__init__(**dict) 0047 if self.__class__ is WRingtoneIndexEntry: 0048 self._update(args,dict) 0049 0050 0051 def getfields(self): 0052 return self.__fields 0053 0054 0055 def _update(self, args, kwargs): 0056 super(WRingtoneIndexEntry,self)._update(args,kwargs) 0057 keys=kwargs.keys() 0058 for key in keys: 0059 if key in self.__fields: 0060 setattr(self, key, kwargs[key]) 0061 del kwargs[key] 0062 # Were any unrecognized kwargs passed in? 0063 if __debug__: 0064 self._complainaboutunusedargs(WRingtoneIndexEntry,kwargs) 0065 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 0066 # Make all P fields that haven't already been constructed 0067 try: self.__field_name 0068 except: 0069 self.__field_name=STRING() 0070 0071 0072 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 0073 'Writes this packet to the supplied buffer' 0074 self._bufferstartoffset=buf.getcurrentoffset() 0075 try: self.__field_path_prefix 0076 except: 0077 self.__field_path_prefix=STRING(**{ 'terminator': None, 'default': '/ff/' }) 0078 self.__field_path_prefix.writetobuffer(buf) 0079 self.__field_pathname.writetobuffer(buf) 0080 try: self.__field_eor 0081 except: 0082 self.__field_eor=STRING(**{ 'terminator': None, 'default': '|0|3\x0A' }) 0083 self.__field_eor.writetobuffer(buf) 0084 self._bufferendoffset=buf.getcurrentoffset() 0085 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 0086 0087 0088 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 0089 'Reads this packet from the supplied buffer' 0090 self._bufferstartoffset=buf.getcurrentoffset() 0091 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 0092 self.__field_path_prefix=STRING(**{ 'terminator': None, 'default': '/ff/' }) 0093 self.__field_path_prefix.readfrombuffer(buf) 0094 self.__field_pathname=STRING(**{ 'terminator': None }) 0095 self.__field_pathname.readfrombuffer(buf) 0096 self.__field_eor=STRING(**{ 'terminator': None, 'default': '|0|3\x0A' }) 0097 self.__field_eor.readfrombuffer(buf) 0098 self._bufferendoffset=buf.getcurrentoffset() 0099 0100 0101 def __getfield_name(self): 0102 return self.__field_name.getvalue() 0103 0104 def __setfield_name(self, value): 0105 if isinstance(value,STRING): 0106 self.__field_name=value 0107 else: 0108 self.__field_name=STRING(value,) 0109 0110 def __delfield_name(self): del self.__field_name 0111 0112 name=property(__getfield_name, __setfield_name, __delfield_name, None) 0113 0114 def __getfield_path_prefix(self): 0115 try: self.__field_path_prefix 0116 except: 0117 self.__field_path_prefix=STRING(**{ 'terminator': None, 'default': '/ff/' }) 0118 return self.__field_path_prefix.getvalue() 0119 0120 def __setfield_path_prefix(self, value): 0121 if isinstance(value,STRING): 0122 self.__field_path_prefix=value 0123 else: 0124 self.__field_path_prefix=STRING(value,**{ 'terminator': None, 'default': '/ff/' }) 0125 0126 def __delfield_path_prefix(self): del self.__field_path_prefix 0127 0128 path_prefix=property(__getfield_path_prefix, __setfield_path_prefix, __delfield_path_prefix, None) 0129 0130 def __getfield_pathname(self): 0131 return self.__field_pathname.getvalue() 0132 0133 def __setfield_pathname(self, value): 0134 if isinstance(value,STRING): 0135 self.__field_pathname=value 0136 else: 0137 self.__field_pathname=STRING(value,**{ 'terminator': None }) 0138 0139 def __delfield_pathname(self): del self.__field_pathname 0140 0141 pathname=property(__getfield_pathname, __setfield_pathname, __delfield_pathname, None) 0142 0143 def __getfield_eor(self): 0144 try: self.__field_eor 0145 except: 0146 self.__field_eor=STRING(**{ 'terminator': None, 'default': '|0|3\x0A' }) 0147 return self.__field_eor.getvalue() 0148 0149 def __setfield_eor(self, value): 0150 if isinstance(value,STRING): 0151 self.__field_eor=value 0152 else: 0153 self.__field_eor=STRING(value,**{ 'terminator': None, 'default': '|0|3\x0A' }) 0154 0155 def __delfield_eor(self): del self.__field_eor 0156 0157 eor=property(__getfield_eor, __setfield_eor, __delfield_eor, None) 0158 0159 def iscontainer(self): 0160 return True 0161 0162 def containerelements(self): 0163 yield ('name', self.__field_name, None) 0164 yield ('path_prefix', self.__field_path_prefix, None) 0165 yield ('pathname', self.__field_pathname, None) 0166 yield ('eor', self.__field_eor, None) 0167 0168 0169 0170 0171 class WRingtoneIndexFile(BaseProtogenClass): 0172 __fields=['items'] 0173 0174 def __init__(self, *args, **kwargs): 0175 dict={} 0176 # What was supplied to this function 0177 dict.update(kwargs) 0178 # Parent constructor 0179 super(WRingtoneIndexFile,self).__init__(**dict) 0180 if self.__class__ is WRingtoneIndexFile: 0181 self._update(args,dict) 0182 0183 0184 def getfields(self): 0185 return self.__fields 0186 0187 0188 def _update(self, args, kwargs): 0189 super(WRingtoneIndexFile,self)._update(args,kwargs) 0190 keys=kwargs.keys() 0191 for key in keys: 0192 if key in self.__fields: 0193 setattr(self, key, kwargs[key]) 0194 del kwargs[key] 0195 # Were any unrecognized kwargs passed in? 0196 if __debug__: 0197 self._complainaboutunusedargs(WRingtoneIndexFile,kwargs) 0198 if len(args): 0199 dict2={ 'elementclass': WRingtoneIndexEntry } 0200 dict2.update(kwargs) 0201 kwargs=dict2 0202 self.__field_items=LIST(*args,**dict2) 0203 # Make all P fields that haven't already been constructed 0204 0205 0206 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 0207 'Writes this packet to the supplied buffer' 0208 self._bufferstartoffset=buf.getcurrentoffset() 0209 try: self.__field_items 0210 except: 0211 self.__field_items=LIST(**{ 'elementclass': WRingtoneIndexEntry }) 0212 self.__field_items.writetobuffer(buf) 0213 self._bufferendoffset=buf.getcurrentoffset() 0214 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 0215 0216 0217 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 0218 'Reads this packet from the supplied buffer' 0219 self._bufferstartoffset=buf.getcurrentoffset() 0220 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 0221 self.__field_items=LIST(**{ 'elementclass': WRingtoneIndexEntry }) 0222 self.__field_items.readfrombuffer(buf) 0223 self._bufferendoffset=buf.getcurrentoffset() 0224 0225 0226 def __getfield_items(self): 0227 try: self.__field_items 0228 except: 0229 self.__field_items=LIST(**{ 'elementclass': WRingtoneIndexEntry }) 0230 return self.__field_items.getvalue() 0231 0232 def __setfield_items(self, value): 0233 if isinstance(value,LIST): 0234 self.__field_items=value 0235 else: 0236 self.__field_items=LIST(value,**{ 'elementclass': WRingtoneIndexEntry }) 0237 0238 def __delfield_items(self): del self.__field_items 0239 0240 items=property(__getfield_items, __setfield_items, __delfield_items, None) 0241 0242 def iscontainer(self): 0243 return True 0244 0245 def containerelements(self): 0246 yield ('items', self.__field_items, None) 0247 0248 0249 0250 0251 class RRingtoneIndexEntry(BaseProtogenClass): 0252 __fields=['pathname', 'misc'] 0253 0254 def __init__(self, *args, **kwargs): 0255 dict={} 0256 # What was supplied to this function 0257 dict.update(kwargs) 0258 # Parent constructor 0259 super(RRingtoneIndexEntry,self).__init__(**dict) 0260 if self.__class__ is RRingtoneIndexEntry: 0261 self._update(args,dict) 0262 0263 0264 def getfields(self): 0265 return self.__fields 0266 0267 0268 def _update(self, args, kwargs): 0269 super(RRingtoneIndexEntry,self)._update(args,kwargs) 0270 keys=kwargs.keys() 0271 for key in keys: 0272 if key in self.__fields: 0273 setattr(self, key, kwargs[key]) 0274 del kwargs[key] 0275 # Were any unrecognized kwargs passed in? 0276 if __debug__: 0277 self._complainaboutunusedargs(RRingtoneIndexEntry,kwargs) 0278 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 0279 # Make all P fields that haven't already been constructed 0280 0281 0282 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 0283 'Writes this packet to the supplied buffer' 0284 self._bufferstartoffset=buf.getcurrentoffset() 0285 self.__field_pathname.writetobuffer(buf) 0286 self.__field_misc.writetobuffer(buf) 0287 self._bufferendoffset=buf.getcurrentoffset() 0288 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 0289 0290 0291 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 0292 'Reads this packet from the supplied buffer' 0293 self._bufferstartoffset=buf.getcurrentoffset() 0294 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 0295 self.__field_pathname=STRING(**{ 'terminator': 0x7C }) 0296 self.__field_pathname.readfrombuffer(buf) 0297 self.__field_misc=STRING(**{ 'terminator': 0x0A }) 0298 self.__field_misc.readfrombuffer(buf) 0299 self._bufferendoffset=buf.getcurrentoffset() 0300 0301 0302 def __getfield_pathname(self): 0303 return self.__field_pathname.getvalue() 0304 0305 def __setfield_pathname(self, value): 0306 if isinstance(value,STRING): 0307 self.__field_pathname=value 0308 else: 0309 self.__field_pathname=STRING(value,**{ 'terminator': 0x7C }) 0310 0311 def __delfield_pathname(self): del self.__field_pathname 0312 0313 pathname=property(__getfield_pathname, __setfield_pathname, __delfield_pathname, None) 0314 0315 def __getfield_misc(self): 0316 return self.__field_misc.getvalue() 0317 0318 def __setfield_misc(self, value): 0319 if isinstance(value,STRING): 0320 self.__field_misc=value 0321 else: 0322 self.__field_misc=STRING(value,**{ 'terminator': 0x0A }) 0323 0324 def __delfield_misc(self): del self.__field_misc 0325 0326 misc=property(__getfield_misc, __setfield_misc, __delfield_misc, None) 0327 0328 def iscontainer(self): 0329 return True 0330 0331 def containerelements(self): 0332 yield ('pathname', self.__field_pathname, None) 0333 yield ('misc', self.__field_misc, None) 0334 0335 0336 0337 0338 class RRingtoneIndexFile(BaseProtogenClass): 0339 __fields=['items'] 0340 0341 def __init__(self, *args, **kwargs): 0342 dict={} 0343 # What was supplied to this function 0344 dict.update(kwargs) 0345 # Parent constructor 0346 super(RRingtoneIndexFile,self).__init__(**dict) 0347 if self.__class__ is RRingtoneIndexFile: 0348 self._update(args,dict) 0349 0350 0351 def getfields(self): 0352 return self.__fields 0353 0354 0355 def _update(self, args, kwargs): 0356 super(RRingtoneIndexFile,self)._update(args,kwargs) 0357 keys=kwargs.keys() 0358 for key in keys: 0359 if key in self.__fields: 0360 setattr(self, key, kwargs[key]) 0361 del kwargs[key] 0362 # Were any unrecognized kwargs passed in? 0363 if __debug__: 0364 self._complainaboutunusedargs(RRingtoneIndexFile,kwargs) 0365 if len(args): 0366 dict2={ 'elementclass': RRingtoneIndexEntry } 0367 dict2.update(kwargs) 0368 kwargs=dict2 0369 self.__field_items=LIST(*args,**dict2) 0370 # Make all P fields that haven't already been constructed 0371 0372 0373 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 0374 'Writes this packet to the supplied buffer' 0375 self._bufferstartoffset=buf.getcurrentoffset() 0376 try: self.__field_items 0377 except: 0378 self.__field_items=LIST(**{ 'elementclass': RRingtoneIndexEntry }) 0379 self.__field_items.writetobuffer(buf) 0380 self._bufferendoffset=buf.getcurrentoffset() 0381 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 0382 0383 0384 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 0385 'Reads this packet from the supplied buffer' 0386 self._bufferstartoffset=buf.getcurrentoffset() 0387 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 0388 self.__field_items=LIST(**{ 'elementclass': RRingtoneIndexEntry }) 0389 self.__field_items.readfrombuffer(buf) 0390 self._bufferendoffset=buf.getcurrentoffset() 0391 0392 0393 def __getfield_items(self): 0394 try: self.__field_items 0395 except: 0396 self.__field_items=LIST(**{ 'elementclass': RRingtoneIndexEntry }) 0397 return self.__field_items.getvalue() 0398 0399 def __setfield_items(self, value): 0400 if isinstance(value,LIST): 0401 self.__field_items=value 0402 else: 0403 self.__field_items=LIST(value,**{ 'elementclass': RRingtoneIndexEntry }) 0404 0405 def __delfield_items(self): del self.__field_items 0406 0407 items=property(__getfield_items, __setfield_items, __delfield_items, None) 0408 0409 def iscontainer(self): 0410 return True 0411 0412 def containerelements(self): 0413 yield ('items', self.__field_items, None) 0414 0415 0416 0417 0418 class WSoundsIndexEntry(BaseProtogenClass): 0419 __fields=['name', 'path_prefix', 'pathname', 'eor'] 0420 0421 def __init__(self, *args, **kwargs): 0422 dict={} 0423 # What was supplied to this function 0424 dict.update(kwargs) 0425 # Parent constructor 0426 super(WSoundsIndexEntry,self).__init__(**dict) 0427 if self.__class__ is WSoundsIndexEntry: 0428 self._update(args,dict) 0429 0430 0431 def getfields(self): 0432 return self.__fields 0433 0434 0435 def _update(self, args, kwargs): 0436 super(WSoundsIndexEntry,self)._update(args,kwargs) 0437 keys=kwargs.keys() 0438 for key in keys: 0439 if key in self.__fields: 0440 setattr(self, key, kwargs[key]) 0441 del kwargs[key] 0442 # Were any unrecognized kwargs passed in? 0443 if __debug__: 0444 self._complainaboutunusedargs(WSoundsIndexEntry,kwargs) 0445 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 0446 # Make all P fields that haven't already been constructed 0447 try: self.__field_name 0448 except: 0449 self.__field_name=STRING() 0450 0451 0452 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 0453 'Writes this packet to the supplied buffer' 0454 self._bufferstartoffset=buf.getcurrentoffset() 0455 try: self.__field_path_prefix 0456 except: 0457 self.__field_path_prefix=STRING(**{ 'terminator': None, 'default': '/ff/' }) 0458 self.__field_path_prefix.writetobuffer(buf) 0459 self.__field_pathname.writetobuffer(buf) 0460 try: self.__field_eor 0461 except: 0462 self.__field_eor=STRING(**{ 'terminator': None, 'default': '|0|7\x0A' }) 0463 self.__field_eor.writetobuffer(buf) 0464 self._bufferendoffset=buf.getcurrentoffset() 0465 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 0466 0467 0468 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 0469 'Reads this packet from the supplied buffer' 0470 self._bufferstartoffset=buf.getcurrentoffset() 0471 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 0472 self.__field_path_prefix=STRING(**{ 'terminator': None, 'default': '/ff/' }) 0473 self.__field_path_prefix.readfrombuffer(buf) 0474 self.__field_pathname=STRING(**{ 'terminator': None }) 0475 self.__field_pathname.readfrombuffer(buf) 0476 self.__field_eor=STRING(**{ 'terminator': None, 'default': '|0|7\x0A' }) 0477 self.__field_eor.readfrombuffer(buf) 0478 self._bufferendoffset=buf.getcurrentoffset() 0479 0480 0481 def __getfield_name(self): 0482 return self.__field_name.getvalue() 0483 0484 def __setfield_name(self, value): 0485 if isinstance(value,STRING): 0486 self.__field_name=value 0487 else: 0488 self.__field_name=STRING(value,) 0489 0490 def __delfield_name(self): del self.__field_name 0491 0492 name=property(__getfield_name, __setfield_name, __delfield_name, None) 0493 0494 def __getfield_path_prefix(self): 0495 try: self.__field_path_prefix 0496 except: 0497 self.__field_path_prefix=STRING(**{ 'terminator': None, 'default': '/ff/' }) 0498 return self.__field_path_prefix.getvalue() 0499 0500 def __setfield_path_prefix(self, value): 0501 if isinstance(value,STRING): 0502 self.__field_path_prefix=value 0503 else: 0504 self.__field_path_prefix=STRING(value,**{ 'terminator': None, 'default': '/ff/' }) 0505 0506 def __delfield_path_prefix(self): del self.__field_path_prefix 0507 0508 path_prefix=property(__getfield_path_prefix, __setfield_path_prefix, __delfield_path_prefix, None) 0509 0510 def __getfield_pathname(self): 0511 return self.__field_pathname.getvalue() 0512 0513 def __setfield_pathname(self, value): 0514 if isinstance(value,STRING): 0515 self.__field_pathname=value 0516 else: 0517 self.__field_pathname=STRING(value,**{ 'terminator': None }) 0518 0519 def __delfield_pathname(self): del self.__field_pathname 0520 0521 pathname=property(__getfield_pathname, __setfield_pathname, __delfield_pathname, None) 0522 0523 def __getfield_eor(self): 0524 try: self.__field_eor 0525 except: 0526 self.__field_eor=STRING(**{ 'terminator': None, 'default': '|0|7\x0A' }) 0527 return self.__field_eor.getvalue() 0528 0529 def __setfield_eor(self, value): 0530 if isinstance(value,STRING): 0531 self.__field_eor=value 0532 else: 0533 self.__field_eor=STRING(value,**{ 'terminator': None, 'default': '|0|7\x0A' }) 0534 0535 def __delfield_eor(self): del self.__field_eor 0536 0537 eor=property(__getfield_eor, __setfield_eor, __delfield_eor, None) 0538 0539 def iscontainer(self): 0540 return True 0541 0542 def containerelements(self): 0543 yield ('name', self.__field_name, None) 0544 yield ('path_prefix', self.__field_path_prefix, None) 0545 yield ('pathname', self.__field_pathname, None) 0546 yield ('eor', self.__field_eor, None) 0547 0548 0549 0550 0551 class WSoundsIndexFile(BaseProtogenClass): 0552 __fields=['items'] 0553 0554 def __init__(self, *args, **kwargs): 0555 dict={} 0556 # What was supplied to this function 0557 dict.update(kwargs) 0558 # Parent constructor 0559 super(WSoundsIndexFile,self).__init__(**dict) 0560 if self.__class__ is WSoundsIndexFile: 0561 self._update(args,dict) 0562 0563 0564 def getfields(self): 0565 return self.__fields 0566 0567 0568 def _update(self, args, kwargs): 0569 super(WSoundsIndexFile,self)._update(args,kwargs) 0570 keys=kwargs.keys() 0571 for key in keys: 0572 if key in self.__fields: 0573 setattr(self, key, kwargs[key]) 0574 del kwargs[key] 0575 # Were any unrecognized kwargs passed in? 0576 if __debug__: 0577 self._complainaboutunusedargs(WSoundsIndexFile,kwargs) 0578 if len(args): 0579 dict2={ 'elementclass': WSoundsIndexEntry } 0580 dict2.update(kwargs) 0581 kwargs=dict2 0582 self.__field_items=LIST(*args,**dict2) 0583 # Make all P fields that haven't already been constructed 0584 0585 0586 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 0587 'Writes this packet to the supplied buffer' 0588 self._bufferstartoffset=buf.getcurrentoffset() 0589 try: self.__field_items 0590 except: 0591 self.__field_items=LIST(**{ 'elementclass': WSoundsIndexEntry }) 0592 self.__field_items.writetobuffer(buf) 0593 self._bufferendoffset=buf.getcurrentoffset() 0594 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 0595 0596 0597 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 0598 'Reads this packet from the supplied buffer' 0599 self._bufferstartoffset=buf.getcurrentoffset() 0600 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 0601 self.__field_items=LIST(**{ 'elementclass': WSoundsIndexEntry }) 0602 self.__field_items.readfrombuffer(buf) 0603 self._bufferendoffset=buf.getcurrentoffset() 0604 0605 0606 def __getfield_items(self): 0607 try: self.__field_items 0608 except: 0609 self.__field_items=LIST(**{ 'elementclass': WSoundsIndexEntry }) 0610 return self.__field_items.getvalue() 0611 0612 def __setfield_items(self, value): 0613 if isinstance(value,LIST): 0614 self.__field_items=value 0615 else: 0616 self.__field_items=LIST(value,**{ 'elementclass': WSoundsIndexEntry }) 0617 0618 def __delfield_items(self): del self.__field_items 0619 0620 items=property(__getfield_items, __setfield_items, __delfield_items, None) 0621 0622 def iscontainer(self): 0623 return True 0624 0625 def containerelements(self): 0626 yield ('items', self.__field_items, None) 0627 0628 0629 0630 0631 class RSoundIndexEntry(BaseProtogenClass): 0632 __fields=['pathname', 'misc'] 0633 0634 def __init__(self, *args, **kwargs): 0635 dict={} 0636 # What was supplied to this function 0637 dict.update(kwargs) 0638 # Parent constructor 0639 super(RSoundIndexEntry,self).__init__(**dict) 0640 if self.__class__ is RSoundIndexEntry: 0641 self._update(args,dict) 0642 0643 0644 def getfields(self): 0645 return self.__fields 0646 0647 0648 def _update(self, args, kwargs): 0649 super(RSoundIndexEntry,self)._update(args,kwargs) 0650 keys=kwargs.keys() 0651 for key in keys: 0652 if key in self.__fields: 0653 setattr(self, key, kwargs[key]) 0654 del kwargs[key] 0655 # Were any unrecognized kwargs passed in? 0656 if __debug__: 0657 self._complainaboutunusedargs(RSoundIndexEntry,kwargs) 0658 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 0659 # Make all P fields that haven't already been constructed 0660 0661 0662 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 0663 'Writes this packet to the supplied buffer' 0664 self._bufferstartoffset=buf.getcurrentoffset() 0665 self.__field_pathname.writetobuffer(buf) 0666 self.__field_misc.writetobuffer(buf) 0667 self._bufferendoffset=buf.getcurrentoffset() 0668 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 0669 0670 0671 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 0672 'Reads this packet from the supplied buffer' 0673 self._bufferstartoffset=buf.getcurrentoffset() 0674 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 0675 self.__field_pathname=STRING(**{ 'terminator': 0x7C }) 0676 self.__field_pathname.readfrombuffer(buf) 0677 self.__field_misc=STRING(**{ 'terminator': 0x0A }) 0678 self.__field_misc.readfrombuffer(buf) 0679 self._bufferendoffset=buf.getcurrentoffset() 0680 0681 0682 def __getfield_pathname(self): 0683 return self.__field_pathname.getvalue() 0684 0685 def __setfield_pathname(self, value): 0686 if isinstance(value,STRING): 0687 self.__field_pathname=value 0688 else: 0689 self.__field_pathname=STRING(value,**{ 'terminator': 0x7C }) 0690 0691 def __delfield_pathname(self): del self.__field_pathname 0692 0693 pathname=property(__getfield_pathname, __setfield_pathname, __delfield_pathname, None) 0694 0695 def __getfield_misc(self): 0696 return self.__field_misc.getvalue() 0697 0698 def __setfield_misc(self, value): 0699 if isinstance(value,STRING): 0700 self.__field_misc=value 0701 else: 0702 self.__field_misc=STRING(value,**{ 'terminator': 0x0A }) 0703 0704 def __delfield_misc(self): del self.__field_misc 0705 0706 misc=property(__getfield_misc, __setfield_misc, __delfield_misc, None) 0707 0708 def iscontainer(self): 0709 return True 0710 0711 def containerelements(self): 0712 yield ('pathname', self.__field_pathname, None) 0713 yield ('misc', self.__field_misc, None) 0714 0715 0716 0717 0718 class RSoundsIndexFile(BaseProtogenClass): 0719 __fields=['items'] 0720 0721 def __init__(self, *args, **kwargs): 0722 dict={} 0723 # What was supplied to this function 0724 dict.update(kwargs) 0725 # Parent constructor 0726 super(RSoundsIndexFile,self).__init__(**dict) 0727 if self.__class__ is RSoundsIndexFile: 0728 self._update(args,dict) 0729 0730 0731 def getfields(self): 0732 return self.__fields 0733 0734 0735 def _update(self, args, kwargs): 0736 super(RSoundsIndexFile,self)._update(args,kwargs) 0737 keys=kwargs.keys() 0738 for key in keys: 0739 if key in self.__fields: 0740 setattr(self, key, kwargs[key]) 0741 del kwargs[key] 0742 # Were any unrecognized kwargs passed in? 0743 if __debug__: 0744 self._complainaboutunusedargs(RSoundsIndexFile,kwargs) 0745 if len(args): 0746 dict2={ 'elementclass': RSoundIndexEntry } 0747 dict2.update(kwargs) 0748 kwargs=dict2 0749 self.__field_items=LIST(*args,**dict2) 0750 # Make all P fields that haven't already been constructed 0751 0752 0753 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 0754 'Writes this packet to the supplied buffer' 0755 self._bufferstartoffset=buf.getcurrentoffset() 0756 try: self.__field_items 0757 except: 0758 self.__field_items=LIST(**{ 'elementclass': RSoundIndexEntry }) 0759 self.__field_items.writetobuffer(buf) 0760 self._bufferendoffset=buf.getcurrentoffset() 0761 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 0762 0763 0764 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 0765 'Reads this packet from the supplied buffer' 0766 self._bufferstartoffset=buf.getcurrentoffset() 0767 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 0768 self.__field_items=LIST(**{ 'elementclass': RSoundIndexEntry }) 0769 self.__field_items.readfrombuffer(buf) 0770 self._bufferendoffset=buf.getcurrentoffset() 0771 0772 0773 def __getfield_items(self): 0774 try: self.__field_items 0775 except: 0776 self.__field_items=LIST(**{ 'elementclass': RSoundIndexEntry }) 0777 return self.__field_items.getvalue() 0778 0779 def __setfield_items(self, value): 0780 if isinstance(value,LIST): 0781 self.__field_items=value 0782 else: 0783 self.__field_items=LIST(value,**{ 'elementclass': RSoundIndexEntry }) 0784 0785 def __delfield_items(self): del self.__field_items 0786 0787 items=property(__getfield_items, __setfield_items, __delfield_items, None) 0788 0789 def iscontainer(self): 0790 return True 0791 0792 def containerelements(self): 0793 yield ('items', self.__field_items, None) 0794 0795 0796 0797 0798 class WPictureIndexEntry(BaseProtogenClass): 0799 __fields=['path_prefix', 'pathname', 'path_name', 'pictype'] 0800 0801 def __init__(self, *args, **kwargs): 0802 dict={} 0803 # What was supplied to this function 0804 dict.update(kwargs) 0805 # Parent constructor 0806 super(WPictureIndexEntry,self).__init__(**dict) 0807 if self.__class__ is WPictureIndexEntry: 0808 self._update(args,dict) 0809 0810 0811 def getfields(self): 0812 return self.__fields 0813 0814 0815 def _update(self, args, kwargs): 0816 super(WPictureIndexEntry,self)._update(args,kwargs) 0817 keys=kwargs.keys() 0818 for key in keys: 0819 if key in self.__fields: 0820 setattr(self, key, kwargs[key]) 0821 del kwargs[key] 0822 # Were any unrecognized kwargs passed in? 0823 if __debug__: 0824 self._complainaboutunusedargs(WPictureIndexEntry,kwargs) 0825 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 0826 # Make all P fields that haven't already been constructed 0827 try: self.__field_path_prefix 0828 except: 0829 self.__field_path_prefix=STRING(**{ 'default': '/ff/' }) 0830 try: self.__field_pathname 0831 except: 0832 self.__field_pathname=STRING(**{ 'terminator': None }) 0833 0834 0835 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 0836 'Writes this packet to the supplied buffer' 0837 self._bufferstartoffset=buf.getcurrentoffset() 0838 try: self.__field_path_name 0839 except: 0840 self.__field_path_name=STRING(**{'sizeinbytes': 258, 'terminator': 0, 'default': self.path_prefix+self.pathname }) 0841 self.__field_path_name.writetobuffer(buf) 0842 try: self.__field_pictype 0843 except: 0844 self.__field_pictype=UINT(**{'sizeinbytes': 2, 'default': PIC_TYPE_USERS }) 0845 self.__field_pictype.writetobuffer(buf) 0846 self._bufferendoffset=buf.getcurrentoffset() 0847 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 0848 0849 0850 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 0851 'Reads this packet from the supplied buffer' 0852 self._bufferstartoffset=buf.getcurrentoffset() 0853 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 0854 self.__field_path_name=STRING(**{'sizeinbytes': 258, 'terminator': 0, 'default': self.path_prefix+self.pathname }) 0855 self.__field_path_name.readfrombuffer(buf) 0856 self.__field_pictype=UINT(**{'sizeinbytes': 2, 'default': PIC_TYPE_USERS }) 0857 self.__field_pictype.readfrombuffer(buf) 0858 self._bufferendoffset=buf.getcurrentoffset() 0859 0860 0861 def __getfield_path_prefix(self): 0862 try: self.__field_path_prefix 0863 except: 0864 self.__field_path_prefix=STRING(**{ 'default': '/ff/' }) 0865 return self.__field_path_prefix.getvalue() 0866 0867 def __setfield_path_prefix(self, value): 0868 if isinstance(value,STRING): 0869 self.__field_path_prefix=value 0870 else: 0871 self.__field_path_prefix=STRING(value,**{ 'default': '/ff/' }) 0872 0873 def __delfield_path_prefix(self): del self.__field_path_prefix 0874 0875 path_prefix=property(__getfield_path_prefix, __setfield_path_prefix, __delfield_path_prefix, None) 0876 0877 def __getfield_pathname(self): 0878 return self.__field_pathname.getvalue() 0879 0880 def __setfield_pathname(self, value): 0881 if isinstance(value,STRING): 0882 self.__field_pathname=value 0883 else: 0884 self.__field_pathname=STRING(value,**{ 'terminator': None }) 0885 0886 def __delfield_pathname(self): del self.__field_pathname 0887 0888 pathname=property(__getfield_pathname, __setfield_pathname, __delfield_pathname, None) 0889 0890 def __getfield_path_name(self): 0891 try: self.__field_path_name 0892 except: 0893 self.__field_path_name=STRING(**{'sizeinbytes': 258, 'terminator': 0, 'default': self.path_prefix+self.pathname }) 0894 return self.__field_path_name.getvalue() 0895 0896 def __setfield_path_name(self, value): 0897 if isinstance(value,STRING): 0898 self.__field_path_name=value 0899 else: 0900 self.__field_path_name=STRING(value,**{'sizeinbytes': 258, 'terminator': 0, 'default': self.path_prefix+self.pathname }) 0901 0902 def __delfield_path_name(self): del self.__field_path_name 0903 0904 path_name=property(__getfield_path_name, __setfield_path_name, __delfield_path_name, None) 0905 0906 def __getfield_pictype(self): 0907 try: self.__field_pictype 0908 except: 0909 self.__field_pictype=UINT(**{'sizeinbytes': 2, 'default': PIC_TYPE_USERS }) 0910 return self.__field_pictype.getvalue() 0911 0912 def __setfield_pictype(self, value): 0913 if isinstance(value,UINT): 0914 self.__field_pictype=value 0915 else: 0916 self.__field_pictype=UINT(value,**{'sizeinbytes': 2, 'default': PIC_TYPE_USERS }) 0917 0918 def __delfield_pictype(self): del self.__field_pictype 0919 0920 pictype=property(__getfield_pictype, __setfield_pictype, __delfield_pictype, "0= invalid, 4=builtin, 3=users") 0921 0922 def iscontainer(self): 0923 return True 0924 0925 def containerelements(self): 0926 yield ('path_prefix', self.__field_path_prefix, None) 0927 yield ('pathname', self.__field_pathname, None) 0928 yield ('path_name', self.__field_path_name, None) 0929 yield ('pictype', self.__field_pictype, "0= invalid, 4=builtin, 3=users") 0930 0931 0932 0933 0934 class WPictureIndexFile(BaseProtogenClass): 0935 __fields=['header', 'preloaded1', 'preloaded2', 'preloaded3', 'preloaded4', 'preloaded5', 'preloaded6', 'preloaded7', 'preloaded8', 'items'] 0936 0937 def __init__(self, *args, **kwargs): 0938 dict={} 0939 # What was supplied to this function 0940 dict.update(kwargs) 0941 # Parent constructor 0942 super(WPictureIndexFile,self).__init__(**dict) 0943 if self.__class__ is WPictureIndexFile: 0944 self._update(args,dict) 0945 0946 0947 def getfields(self): 0948 return self.__fields 0949 0950 0951 def _update(self, args, kwargs): 0952 super(WPictureIndexFile,self)._update(args,kwargs) 0953 keys=kwargs.keys() 0954 for key in keys: 0955 if key in self.__fields: 0956 setattr(self, key, kwargs[key]) 0957 del kwargs[key] 0958 # Were any unrecognized kwargs passed in? 0959 if __debug__: 0960 self._complainaboutunusedargs(WPictureIndexFile,kwargs) 0961 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 0962 # Make all P fields that haven't already been constructed 0963 0964 0965 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 0966 'Writes this packet to the supplied buffer' 0967 self._bufferstartoffset=buf.getcurrentoffset() 0968 try: self.__field_header 0969 except: 0970 self.__field_header=WPictureIndexEntry(**{ 'pathname': '0|/ff/brew/mod/10888/Default Album|\x0A', 'path_prefix': '', 'pictype': PIC_TYPE_HEADER }) 0971 self.__field_header.writetobuffer(buf) 0972 try: self.__field_preloaded1 0973 except: 0974 self.__field_preloaded1=WPictureIndexEntry(**{ 'pathname': 'Preloaded1', 'path_prefix': '', 'pictype': PIC_TYPE_BUILTIN }) 0975 self.__field_preloaded1.writetobuffer(buf) 0976 try: self.__field_preloaded2 0977 except: 0978 self.__field_preloaded2=WPictureIndexEntry(**{ 'pathname': 'Preloaded2', 'path_prefix': '', 'pictype': PIC_TYPE_BUILTIN }) 0979 self.__field_preloaded2.writetobuffer(buf) 0980 try: self.__field_preloaded3 0981 except: 0982 self.__field_preloaded3=WPictureIndexEntry(**{ 'pathname': 'Preloaded3', 'path_prefix': '', 'pictype': PIC_TYPE_BUILTIN }) 0983 self.__field_preloaded3.writetobuffer(buf) 0984 try: self.__field_preloaded4 0985 except: 0986 self.__field_preloaded4=WPictureIndexEntry(**{ 'pathname': 'Preloaded4', 'path_prefix': '', 'pictype': PIC_TYPE_BUILTIN }) 0987 self.__field_preloaded4.writetobuffer(buf) 0988 try: self.__field_preloaded5 0989 except: 0990 self.__field_preloaded5=WPictureIndexEntry(**{ 'pathname': 'Preloaded5', 'path_prefix': '', 'pictype': PIC_TYPE_BUILTIN }) 0991 self.__field_preloaded5.writetobuffer(buf) 0992 try: self.__field_preloaded6 0993 except: 0994 self.__field_preloaded6=WPictureIndexEntry(**{ 'pathname': 'Preloaded6', 'path_prefix': '', 'pictype': PIC_TYPE_BUILTIN }) 0995 self.__field_preloaded6.writetobuffer(buf) 0996 try: self.__field_preloaded7 0997 except: 0998 self.__field_preloaded7=WPictureIndexEntry(**{ 'pathname': 'Preloaded7', 'path_prefix': '', 'pictype': PIC_TYPE_BUILTIN }) 0999 self.__field_preloaded7.writetobuffer(buf) 1000 try: self.__field_preloaded8 1001 except: 1002 self.__field_preloaded8=WPictureIndexEntry(**{ 'pathname': 'Preloaded8', 'path_prefix': '', 'pictype': PIC_TYPE_BUILTIN }) 1003 self.__field_preloaded8.writetobuffer(buf) 1004 try: self.__field_items 1005 except: 1006 self.__field_items=LIST(**{ 'elementclass': WPictureIndexEntry }) 1007 self.__field_items.writetobuffer(buf) 1008 self._bufferendoffset=buf.getcurrentoffset() 1009 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 1010 1011 1012 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 1013 'Reads this packet from the supplied buffer' 1014 self._bufferstartoffset=buf.getcurrentoffset() 1015 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 1016 self.__field_header=WPictureIndexEntry(**{ 'pathname': '0|/ff/brew/mod/10888/Default Album|\x0A', 'path_prefix': '', 'pictype': PIC_TYPE_HEADER }) 1017 self.__field_header.readfrombuffer(buf) 1018 self.__field_preloaded1=WPictureIndexEntry(**{ 'pathname': 'Preloaded1', 'path_prefix': '', 'pictype': PIC_TYPE_BUILTIN }) 1019 self.__field_preloaded1.readfrombuffer(buf) 1020 self.__field_preloaded2=WPictureIndexEntry(**{ 'pathname': 'Preloaded2', 'path_prefix': '', 'pictype': PIC_TYPE_BUILTIN }) 1021 self.__field_preloaded2.readfrombuffer(buf) 1022 self.__field_preloaded3=WPictureIndexEntry(**{ 'pathname': 'Preloaded3', 'path_prefix': '', 'pictype': PIC_TYPE_BUILTIN }) 1023 self.__field_preloaded3.readfrombuffer(buf) 1024 self.__field_preloaded4=WPictureIndexEntry(**{ 'pathname': 'Preloaded4', 'path_prefix': '', 'pictype': PIC_TYPE_BUILTIN }) 1025 self.__field_preloaded4.readfrombuffer(buf) 1026 self.__field_preloaded5=WPictureIndexEntry(**{ 'pathname': 'Preloaded5', 'path_prefix': '', 'pictype': PIC_TYPE_BUILTIN }) 1027 self.__field_preloaded5.readfrombuffer(buf) 1028 self.__field_preloaded6=WPictureIndexEntry(**{ 'pathname': 'Preloaded6', 'path_prefix': '', 'pictype': PIC_TYPE_BUILTIN }) 1029 self.__field_preloaded6.readfrombuffer(buf) 1030 self.__field_preloaded7=WPictureIndexEntry(**{ 'pathname': 'Preloaded7', 'path_prefix': '', 'pictype': PIC_TYPE_BUILTIN }) 1031 self.__field_preloaded7.readfrombuffer(buf) 1032 self.__field_preloaded8=WPictureIndexEntry(**{ 'pathname': 'Preloaded8', 'path_prefix': '', 'pictype': PIC_TYPE_BUILTIN }) 1033 self.__field_preloaded8.readfrombuffer(buf) 1034 self.__field_items=LIST(**{ 'elementclass': WPictureIndexEntry }) 1035 self.__field_items.readfrombuffer(buf) 1036 self._bufferendoffset=buf.getcurrentoffset() 1037 1038 1039 def __getfield_header(self): 1040 try: self.__field_header 1041 except: 1042 self.__field_header=WPictureIndexEntry(**{ 'pathname': '0|/ff/brew/mod/10888/Default Album|\x0A', 'path_prefix': '', 'pictype': PIC_TYPE_HEADER }) 1043 return self.__field_header.getvalue() 1044 1045 def __setfield_header(self, value): 1046 if isinstance(value,WPictureIndexEntry): 1047 self.__field_header=value 1048 else: 1049 self.__field_header=WPictureIndexEntry(value,**{ 'pathname': '0|/ff/brew/mod/10888/Default Album|\x0A', 'path_prefix': '', 'pictype': PIC_TYPE_HEADER }) 1050 1051 def __delfield_header(self): del self.__field_header 1052 1053 header=property(__getfield_header, __setfield_header, __delfield_header, None) 1054 1055 def __getfield_preloaded1(self): 1056 try: self.__field_preloaded1 1057 except: 1058 self.__field_preloaded1=WPictureIndexEntry(**{ 'pathname': 'Preloaded1', 'path_prefix': '', 'pictype': PIC_TYPE_BUILTIN }) 1059 return self.__field_preloaded1.getvalue() 1060 1061 def __setfield_preloaded1(self, value): 1062 if isinstance(value,WPictureIndexEntry): 1063 self.__field_preloaded1=value 1064 else: 1065 self.__field_preloaded1=WPictureIndexEntry(value,**{ 'pathname': 'Preloaded1', 'path_prefix': '', 'pictype': PIC_TYPE_BUILTIN }) 1066 1067 def __delfield_preloaded1(self): del self.__field_preloaded1 1068 1069 preloaded1=property(__getfield_preloaded1, __setfield_preloaded1, __delfield_preloaded1, None) 1070 1071 def __getfield_preloaded2(self): 1072 try: self.__field_preloaded2 1073 except: 1074 self.__field_preloaded2=WPictureIndexEntry(**{ 'pathname': 'Preloaded2', 'path_prefix': '', 'pictype': PIC_TYPE_BUILTIN }) 1075 return self.__field_preloaded2.getvalue() 1076 1077 def __setfield_preloaded2(self, value): 1078 if isinstance(value,WPictureIndexEntry): 1079 self.__field_preloaded2=value 1080 else: 1081 self.__field_preloaded2=WPictureIndexEntry(value,**{ 'pathname': 'Preloaded2', 'path_prefix': '', 'pictype': PIC_TYPE_BUILTIN }) 1082 1083 def __delfield_preloaded2(self): del self.__field_preloaded2 1084 1085 preloaded2=property(__getfield_preloaded2, __setfield_preloaded2, __delfield_preloaded2, None) 1086 1087 def __getfield_preloaded3(self): 1088 try: self.__field_preloaded3 1089 except: 1090 self.__field_preloaded3=WPictureIndexEntry(**{ 'pathname': 'Preloaded3', 'path_prefix': '', 'pictype': PIC_TYPE_BUILTIN }) 1091 return self.__field_preloaded3.getvalue() 1092 1093 def __setfield_preloaded3(self, value): 1094 if isinstance(value,WPictureIndexEntry): 1095 self.__field_preloaded3=value 1096 else: 1097 self.__field_preloaded3=WPictureIndexEntry(value,**{ 'pathname': 'Preloaded3', 'path_prefix': '', 'pictype': PIC_TYPE_BUILTIN }) 1098 1099 def __delfield_preloaded3(self): del self.__field_preloaded3 1100 1101 preloaded3=property(__getfield_preloaded3, __setfield_preloaded3, __delfield_preloaded3, None) 1102 1103 def __getfield_preloaded4(self): 1104 try: self.__field_preloaded4 1105 except: 1106 self.__field_preloaded4=WPictureIndexEntry(**{ 'pathname': 'Preloaded4', 'path_prefix': '', 'pictype': PIC_TYPE_BUILTIN }) 1107 return self.__field_preloaded4.getvalue() 1108 1109 def __setfield_preloaded4(self, value): 1110 if isinstance(value,WPictureIndexEntry): 1111 self.__field_preloaded4=value 1112 else: 1113 self.__field_preloaded4=WPictureIndexEntry(value,**{ 'pathname': 'Preloaded4', 'path_prefix': '', 'pictype': PIC_TYPE_BUILTIN }) 1114 1115 def __delfield_preloaded4(self): del self.__field_preloaded4 1116 1117 preloaded4=property(__getfield_preloaded4, __setfield_preloaded4, __delfield_preloaded4, None) 1118 1119 def __getfield_preloaded5(self): 1120 try: self.__field_preloaded5 1121 except: 1122 self.__field_preloaded5=WPictureIndexEntry(**{ 'pathname': 'Preloaded5', 'path_prefix': '', 'pictype': PIC_TYPE_BUILTIN }) 1123 return self.__field_preloaded5.getvalue() 1124 1125 def __setfield_preloaded5(self, value): 1126 if isinstance(value,WPictureIndexEntry): 1127 self.__field_preloaded5=value 1128 else: 1129 self.__field_preloaded5=WPictureIndexEntry(value,**{ 'pathname': 'Preloaded5', 'path_prefix': '', 'pictype': PIC_TYPE_BUILTIN }) 1130 1131 def __delfield_preloaded5(self): del self.__field_preloaded5 1132 1133 preloaded5=property(__getfield_preloaded5, __setfield_preloaded5, __delfield_preloaded5, None) 1134 1135 def __getfield_preloaded6(self): 1136 try: self.__field_preloaded6 1137 except: 1138 self.__field_preloaded6=WPictureIndexEntry(**{ 'pathname': 'Preloaded6', 'path_prefix': '', 'pictype': PIC_TYPE_BUILTIN }) 1139 return self.__field_preloaded6.getvalue() 1140 1141 def __setfield_preloaded6(self, value): 1142 if isinstance(value,WPictureIndexEntry): 1143 self.__field_preloaded6=value 1144 else: 1145 self.__field_preloaded6=WPictureIndexEntry(value,**{ 'pathname': 'Preloaded6', 'path_prefix': '', 'pictype': PIC_TYPE_BUILTIN }) 1146 1147 def __delfield_preloaded6(self): del self.__field_preloaded6 1148 1149 preloaded6=property(__getfield_preloaded6, __setfield_preloaded6, __delfield_preloaded6, None) 1150 1151 def __getfield_preloaded7(self): 1152 try: self.__field_preloaded7 1153 except: 1154 self.__field_preloaded7=WPictureIndexEntry(**{ 'pathname': 'Preloaded7', 'path_prefix': '', 'pictype': PIC_TYPE_BUILTIN }) 1155 return self.__field_preloaded7.getvalue() 1156 1157 def __setfield_preloaded7(self, value): 1158 if isinstance(value,WPictureIndexEntry): 1159 self.__field_preloaded7=value 1160 else: 1161 self.__field_preloaded7=WPictureIndexEntry(value,**{ 'pathname': 'Preloaded7', 'path_prefix': '', 'pictype': PIC_TYPE_BUILTIN }) 1162 1163 def __delfield_preloaded7(self): del self.__field_preloaded7 1164 1165 preloaded7=property(__getfield_preloaded7, __setfield_preloaded7, __delfield_preloaded7, None) 1166 1167 def __getfield_preloaded8(self): 1168 try: self.__field_preloaded8 1169 except: 1170 self.__field_preloaded8=WPictureIndexEntry(**{ 'pathname': 'Preloaded8', 'path_prefix': '', 'pictype': PIC_TYPE_BUILTIN }) 1171 return self.__field_preloaded8.getvalue() 1172 1173 def __setfield_preloaded8(self, value): 1174 if isinstance(value,WPictureIndexEntry): 1175 self.__field_preloaded8=value 1176 else: 1177 self.__field_preloaded8=WPictureIndexEntry(value,**{ 'pathname': 'Preloaded8', 'path_prefix': '', 'pictype': PIC_TYPE_BUILTIN }) 1178 1179 def __delfield_preloaded8(self): del self.__field_preloaded8 1180 1181 preloaded8=property(__getfield_preloaded8, __setfield_preloaded8, __delfield_preloaded8, None) 1182 1183 def __getfield_items(self): 1184 try: self.__field_items 1185 except: 1186 self.__field_items=LIST(**{ 'elementclass': WPictureIndexEntry }) 1187 return self.__field_items.getvalue() 1188 1189 def __setfield_items(self, value): 1190 if isinstance(value,LIST): 1191 self.__field_items=value 1192 else: 1193 self.__field_items=LIST(value,**{ 'elementclass': WPictureIndexEntry }) 1194 1195 def __delfield_items(self): del self.__field_items 1196 1197 items=property(__getfield_items, __setfield_items, __delfield_items, None) 1198 1199 def iscontainer(self): 1200 return True 1201 1202 def containerelements(self): 1203 yield ('header', self.__field_header, None) 1204 yield ('preloaded1', self.__field_preloaded1, None) 1205 yield ('preloaded2', self.__field_preloaded2, None) 1206 yield ('preloaded3', self.__field_preloaded3, None) 1207 yield ('preloaded4', self.__field_preloaded4, None) 1208 yield ('preloaded5', self.__field_preloaded5, None) 1209 yield ('preloaded6', self.__field_preloaded6, None) 1210 yield ('preloaded7', self.__field_preloaded7, None) 1211 yield ('preloaded8', self.__field_preloaded8, None) 1212 yield ('items', self.__field_items, None) 1213 1214 1215 1216 1217 class RPictureIndexEntry(BaseProtogenClass): 1218 __fields=['pathname', 'pictype'] 1219 1220 def __init__(self, *args, **kwargs): 1221 dict={} 1222 # What was supplied to this function 1223 dict.update(kwargs) 1224 # Parent constructor 1225 super(RPictureIndexEntry,self).__init__(**dict) 1226 if self.__class__ is RPictureIndexEntry: 1227 self._update(args,dict) 1228 1229 1230 def getfields(self): 1231 return self.__fields 1232 1233 1234 def _update(self, args, kwargs): 1235 super(RPictureIndexEntry,self)._update(args,kwargs) 1236 keys=kwargs.keys() 1237 for key in keys: 1238 if key in self.__fields: 1239 setattr(self, key, kwargs[key]) 1240 del kwargs[key] 1241 # Were any unrecognized kwargs passed in? 1242 if __debug__: 1243 self._complainaboutunusedargs(RPictureIndexEntry,kwargs) 1244 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 1245 # Make all P fields that haven't already been constructed 1246 1247 1248 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 1249 'Writes this packet to the supplied buffer' 1250 self._bufferstartoffset=buf.getcurrentoffset() 1251 self.__field_pathname.writetobuffer(buf) 1252 self.__field_pictype.writetobuffer(buf) 1253 self._bufferendoffset=buf.getcurrentoffset() 1254 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 1255 1256 1257 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 1258 'Reads this packet from the supplied buffer' 1259 self._bufferstartoffset=buf.getcurrentoffset() 1260 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 1261 self.__field_pathname=STRING(**{'sizeinbytes': 258, 'terminator': 0, 'raiseonunterminatedread': False }) 1262 self.__field_pathname.readfrombuffer(buf) 1263 self.__field_pictype=UINT(**{'sizeinbytes': 2}) 1264 self.__field_pictype.readfrombuffer(buf) 1265 self._bufferendoffset=buf.getcurrentoffset() 1266 1267 1268 def __getfield_pathname(self): 1269 return self.__field_pathname.getvalue() 1270 1271 def __setfield_pathname(self, value): 1272 if isinstance(value,STRING): 1273 self.__field_pathname=value 1274 else: 1275 self.__field_pathname=STRING(value,**{'sizeinbytes': 258, 'terminator': 0, 'raiseonunterminatedread': False }) 1276 1277 def __delfield_pathname(self): del self.__field_pathname 1278 1279 pathname=property(__getfield_pathname, __setfield_pathname, __delfield_pathname, None) 1280 1281 def __getfield_pictype(self): 1282 return self.__field_pictype.getvalue() 1283 1284 def __setfield_pictype(self, value): 1285 if isinstance(value,UINT): 1286 self.__field_pictype=value 1287 else: 1288 self.__field_pictype=UINT(value,**{'sizeinbytes': 2}) 1289 1290 def __delfield_pictype(self): del self.__field_pictype 1291 1292 pictype=property(__getfield_pictype, __setfield_pictype, __delfield_pictype, "0= invalid, 4=builtin, 3=users") 1293 1294 def iscontainer(self): 1295 return True 1296 1297 def containerelements(self): 1298 yield ('pathname', self.__field_pathname, None) 1299 yield ('pictype', self.__field_pictype, "0= invalid, 4=builtin, 3=users") 1300 1301 1302 1303 1304 class RPictureIndexFile(BaseProtogenClass): 1305 __fields=['items'] 1306 1307 def __init__(self, *args, **kwargs): 1308 dict={} 1309 # What was supplied to this function 1310 dict.update(kwargs) 1311 # Parent constructor 1312 super(RPictureIndexFile,self).__init__(**dict) 1313 if self.__class__ is RPictureIndexFile: 1314 self._update(args,dict) 1315 1316 1317 def getfields(self): 1318 return self.__fields 1319 1320 1321 def _update(self, args, kwargs): 1322 super(RPictureIndexFile,self)._update(args,kwargs) 1323 keys=kwargs.keys() 1324 for key in keys: 1325 if key in self.__fields: 1326 setattr(self, key, kwargs[key]) 1327 del kwargs[key] 1328 # Were any unrecognized kwargs passed in? 1329 if __debug__: 1330 self._complainaboutunusedargs(RPictureIndexFile,kwargs) 1331 if len(args): 1332 dict2={ 'elementclass': RPictureIndexEntry } 1333 dict2.update(kwargs) 1334 kwargs=dict2 1335 self.__field_items=LIST(*args,**dict2) 1336 # Make all P fields that haven't already been constructed 1337 1338 1339 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 1340 'Writes this packet to the supplied buffer' 1341 self._bufferstartoffset=buf.getcurrentoffset() 1342 try: self.__field_items 1343 except: 1344 self.__field_items=LIST(**{ 'elementclass': RPictureIndexEntry }) 1345 self.__field_items.writetobuffer(buf) 1346 self._bufferendoffset=buf.getcurrentoffset() 1347 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 1348 1349 1350 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 1351 'Reads this packet from the supplied buffer' 1352 self._bufferstartoffset=buf.getcurrentoffset() 1353 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 1354 self.__field_items=LIST(**{ 'elementclass': RPictureIndexEntry }) 1355 self.__field_items.readfrombuffer(buf) 1356 self._bufferendoffset=buf.getcurrentoffset() 1357 1358 1359 def __getfield_items(self): 1360 try: self.__field_items 1361 except: 1362 self.__field_items=LIST(**{ 'elementclass': RPictureIndexEntry }) 1363 return self.__field_items.getvalue() 1364 1365 def __setfield_items(self, value): 1366 if isinstance(value,LIST): 1367 self.__field_items=value 1368 else: 1369 self.__field_items=LIST(value,**{ 'elementclass': RPictureIndexEntry }) 1370 1371 def __delfield_items(self): del self.__field_items 1372 1373 items=property(__getfield_items, __setfield_items, __delfield_items, None) 1374 1375 def iscontainer(self): 1376 return True 1377 1378 def containerelements(self): 1379 yield ('items', self.__field_items, None) 1380 1381 1382 1383 1384 class NumberEntry(BaseProtogenClass): 1385 __fields=['number', 'option', 'speeddial', 'ringtone'] 1386 1387 def __init__(self, *args, **kwargs): 1388 dict={} 1389 # What was supplied to this function 1390 dict.update(kwargs) 1391 # Parent constructor 1392 super(NumberEntry,self).__init__(**dict) 1393 if self.__class__ is NumberEntry: 1394 self._update(args,dict) 1395 1396 1397 def getfields(self): 1398 return self.__fields 1399 1400 1401 def _update(self, args, kwargs): 1402 super(NumberEntry,self)._update(args,kwargs) 1403 keys=kwargs.keys() 1404 for key in keys: 1405 if key in self.__fields: 1406 setattr(self, key, kwargs[key]) 1407 del kwargs[key] 1408 # Were any unrecognized kwargs passed in? 1409 if __debug__: 1410 self._complainaboutunusedargs(NumberEntry,kwargs) 1411 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 1412 # Make all P fields that haven't already been constructed 1413 1414 1415 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 1416 'Writes this packet to the supplied buffer' 1417 self._bufferstartoffset=buf.getcurrentoffset() 1418 self.__field_number.writetobuffer(buf) 1419 self.__field_option.writetobuffer(buf) 1420 if self.option & PB_FLG_SPEEDDIAL: 1421 self.__field_speeddial.writetobuffer(buf) 1422 if self.option & PB_FLG_RINGTONE: 1423 self.__field_ringtone.writetobuffer(buf) 1424 self._bufferendoffset=buf.getcurrentoffset() 1425 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 1426 1427 1428 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 1429 'Reads this packet from the supplied buffer' 1430 self._bufferstartoffset=buf.getcurrentoffset() 1431 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 1432 self.__field_number=STRING(**{ 'terminator': None, 'pascal': True }) 1433 self.__field_number.readfrombuffer(buf) 1434 self.__field_option=UINT(**{'sizeinbytes': 1}) 1435 self.__field_option.readfrombuffer(buf) 1436 if self.option & PB_FLG_SPEEDDIAL: 1437 self.__field_speeddial=UINT(**{'sizeinbytes': 2}) 1438 self.__field_speeddial.readfrombuffer(buf) 1439 if self.option & PB_FLG_RINGTONE: 1440 self.__field_ringtone=STRING(**{ 'terminator': None, 'pascal': True }) 1441 self.__field_ringtone.readfrombuffer(buf) 1442 self._bufferendoffset=buf.getcurrentoffset() 1443 1444 1445 def __getfield_number(self): 1446 return self.__field_number.getvalue() 1447 1448 def __setfield_number(self, value): 1449 if isinstance(value,STRING): 1450 self.__field_number=value 1451 else: 1452 self.__field_number=STRING(value,**{ 'terminator': None, 'pascal': True }) 1453 1454 def __delfield_number(self): del self.__field_number 1455 1456 number=property(__getfield_number, __setfield_number, __delfield_number, None) 1457 1458 def __getfield_option(self): 1459 return self.__field_option.getvalue() 1460 1461 def __setfield_option(self, value): 1462 if isinstance(value,UINT): 1463 self.__field_option=value 1464 else: 1465 self.__field_option=UINT(value,**{'sizeinbytes': 1}) 1466 1467 def __delfield_option(self): del self.__field_option 1468 1469 option=property(__getfield_option, __setfield_option, __delfield_option, None) 1470 1471 def __getfield_speeddial(self): 1472 return self.__field_speeddial.getvalue() 1473 1474 def __setfield_speeddial(self, value): 1475 if isinstance(value,UINT): 1476 self.__field_speeddial=value 1477 else: 1478 self.__field_speeddial=UINT(value,**{'sizeinbytes': 2}) 1479 1480 def __delfield_speeddial(self): del self.__field_speeddial 1481 1482 speeddial=property(__getfield_speeddial, __setfield_speeddial, __delfield_speeddial, None) 1483 1484 def __getfield_ringtone(self): 1485 return self.__field_ringtone.getvalue() 1486 1487 def __setfield_ringtone(self, value): 1488 if isinstance(value,STRING): 1489 self.__field_ringtone=value 1490 else: 1491 self.__field_ringtone=STRING(value,**{ 'terminator': None, 'pascal': True }) 1492 1493 def __delfield_ringtone(self): del self.__field_ringtone 1494 1495 ringtone=property(__getfield_ringtone, __setfield_ringtone, __delfield_ringtone, None) 1496 1497 def iscontainer(self): 1498 return True 1499 1500 def containerelements(self): 1501 yield ('number', self.__field_number, None) 1502 yield ('option', self.__field_option, None) 1503 if self.option & PB_FLG_SPEEDDIAL: 1504 yield ('speeddial', self.__field_speeddial, None) 1505 if self.option & PB_FLG_RINGTONE: 1506 yield ('ringtone', self.__field_ringtone, None) 1507 1508 1509 1510 1511 class PBEntry(BaseProtogenClass): 1512 __fields=['info', 'info2', 'name', 'email', 'email2', 'home', 'work', 'cell', 'fax', 'cell2', 'note', 'datetime', 'group', 'wallpaper', 'wallpaper_range'] 1513 1514 def __init__(self, *args, **kwargs): 1515 dict={} 1516 # What was supplied to this function 1517 dict.update(kwargs) 1518 # Parent constructor 1519 super(PBEntry,self).__init__(**dict) 1520 if self.__class__ is PBEntry: 1521 self._update(args,dict) 1522 1523 1524 def getfields(self): 1525 return self.__fields 1526 1527 1528 def _update(self, args, kwargs): 1529 super(PBEntry,self)._update(args,kwargs) 1530 keys=kwargs.keys() 1531 for key in keys: 1532 if key in self.__fields: 1533 setattr(self, key, kwargs[key]) 1534 del kwargs[key] 1535 # Were any unrecognized kwargs passed in? 1536 if __debug__: 1537 self._complainaboutunusedargs(PBEntry,kwargs) 1538 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 1539 # Make all P fields that haven't already been constructed 1540 1541 1542 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 1543 'Writes this packet to the supplied buffer' 1544 self._bufferstartoffset=buf.getcurrentoffset() 1545 self.__field_info.writetobuffer(buf) 1546 self.__field_info2.writetobuffer(buf) 1547 if self.info & PB_FLG_NAME: 1548 self.__field_name.writetobuffer(buf) 1549 if self.info & PB_FLG_EMAIL: 1550 self.__field_email.writetobuffer(buf) 1551 if self.info & PB_FLG_EMAIL2: 1552 self.__field_email2.writetobuffer(buf) 1553 if self.info & PB_FLG_HOME: 1554 self.__field_home.writetobuffer(buf) 1555 if self.info & PB_FLG_WORK: 1556 self.__field_work.writetobuffer(buf) 1557 if self.info & PB_FLG_CELL: 1558 self.__field_cell.writetobuffer(buf) 1559 if self.info & PB_FLG_FAX: 1560 self.__field_fax.writetobuffer(buf) 1561 if self.info & PB_FLG_CELL2: 1562 self.__field_cell2.writetobuffer(buf) 1563 if self.info & PB_FLG_NOTE: 1564 self.__field_note.writetobuffer(buf) 1565 if self.info & PB_FLG_DATE: 1566 self.__field_datetime.writetobuffer(buf) 1567 if self.info & PB_FLG_GROUP: 1568 self.__field_group.writetobuffer(buf) 1569 if self.info & PB_FLG_WP: 1570 self.__field_wallpaper.writetobuffer(buf) 1571 self.__field_wallpaper_range.writetobuffer(buf) 1572 self._bufferendoffset=buf.getcurrentoffset() 1573 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 1574 1575 1576 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 1577 'Reads this packet from the supplied buffer' 1578 self._bufferstartoffset=buf.getcurrentoffset() 1579 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 1580 self.__field_info=UINT(**{'sizeinbytes': 2}) 1581 self.__field_info.readfrombuffer(buf) 1582 self.__field_info2=UINT(**{'sizeinbytes': 2}) 1583 self.__field_info2.readfrombuffer(buf) 1584 if self.info & PB_FLG_NAME: 1585 self.__field_name=USTRING(**{ 'terminator': None, 'encoding': ENCODING, 'pascal': True }) 1586 self.__field_name.readfrombuffer(buf) 1587 if self.info & PB_FLG_EMAIL: 1588 self.__field_email=USTRING(**{ 'terminator': None, 'encoding': ENCODING, 'pascal': True }) 1589 self.__field_email.readfrombuffer(buf) 1590 if self.info & PB_FLG_EMAIL2: 1591 self.__field_email2=USTRING(**{ 'terminator': None, 'encoding': ENCODING, 'pascal': True }) 1592 self.__field_email2.readfrombuffer(buf) 1593 if self.info & PB_FLG_HOME: 1594 self.__field_home=NumberEntry() 1595 self.__field_home.readfrombuffer(buf) 1596 if self.info & PB_FLG_WORK: 1597 self.__field_work=NumberEntry() 1598 self.__field_work.readfrombuffer(buf) 1599 if self.info & PB_FLG_CELL: 1600 self.__field_cell=NumberEntry() 1601 self.__field_cell.readfrombuffer(buf) 1602 if self.info & PB_FLG_FAX: 1603 self.__field_fax=NumberEntry() 1604 self.__field_fax.readfrombuffer(buf) 1605 if self.info & PB_FLG_CELL2: 1606 self.__field_cell2=NumberEntry() 1607 self.__field_cell2.readfrombuffer(buf) 1608 if self.info & PB_FLG_NOTE: 1609 self.__field_note=STRING(**{ 'terminator': None, 'pascal': True }) 1610 self.__field_note.readfrombuffer(buf) 1611 if self.info & PB_FLG_DATE: 1612 self.__field_datetime=DateTime(**{'sizeinbytes': 4}) 1613 self.__field_datetime.readfrombuffer(buf) 1614 if self.info & PB_FLG_GROUP: 1615 self.__field_group=UINT(**{'sizeinbytes': 1}) 1616 self.__field_group.readfrombuffer(buf) 1617 if self.info & PB_FLG_WP: 1618 self.__field_wallpaper=STRING(**{ 'terminator': None, 'pascal': True }) 1619 self.__field_wallpaper.readfrombuffer(buf) 1620 self.__field_wallpaper_range=UINT(**{'sizeinbytes': 4}) 1621 self.__field_wallpaper_range.readfrombuffer(buf) 1622 self._bufferendoffset=buf.getcurrentoffset() 1623 1624 1625 def __getfield_info(self): 1626 return self.__field_info.getvalue() 1627 1628 def __setfield_info(self, value): 1629 if isinstance(value,UINT): 1630 self.__field_info=value 1631 else: 1632 self.__field_info=UINT(value,**{'sizeinbytes': 2}) 1633 1634 def __delfield_info(self): del self.__field_info 1635 1636 info=property(__getfield_info, __setfield_info, __delfield_info, None) 1637 1638 def __getfield_info2(self): 1639 return self.__field_info2.getvalue() 1640 1641 def __setfield_info2(self, value): 1642 if isinstance(value,UINT): 1643 self.__field_info2=value 1644 else: 1645 self.__field_info2=UINT(value,**{'sizeinbytes': 2}) 1646 1647 def __delfield_info2(self): del self.__field_info2 1648 1649 info2=property(__getfield_info2, __setfield_info2, __delfield_info2, None) 1650 1651 def __getfield_name(self): 1652 return self.__field_name.getvalue() 1653 1654 def __setfield_name(self, value): 1655 if isinstance(value,USTRING): 1656 self.__field_name=value 1657 else: 1658 self.__field_name=USTRING(value,**{ 'terminator': None, 'encoding': ENCODING, 'pascal': True }) 1659 1660 def __delfield_name(self): del self.__field_name 1661 1662 name=property(__getfield_name, __setfield_name, __delfield_name, None) 1663 1664 def __getfield_email(self): 1665 return self.__field_email.getvalue() 1666 1667 def __setfield_email(self, value): 1668 if isinstance(value,USTRING): 1669 self.__field_email=value 1670 else: 1671 self.__field_email=USTRING(value,**{ 'terminator': None, 'encoding': ENCODING, 'pascal': True }) 1672 1673 def __delfield_email(self): del self.__field_email 1674 1675 email=property(__getfield_email, __setfield_email, __delfield_email, None) 1676 1677 def __getfield_email2(self): 1678 return self.__field_email2.getvalue() 1679 1680 def __setfield_email2(self, value): 1681 if isinstance(value,USTRING): 1682 self.__field_email2=value 1683 else: 1684 self.__field_email2=USTRING(value,**{ 'terminator': None, 'encoding': ENCODING, 'pascal': True }) 1685 1686 def __delfield_email2(self): del self.__field_email2 1687 1688 email2=property(__getfield_email2, __setfield_email2, __delfield_email2, None) 1689 1690 def __getfield_home(self): 1691 return self.__field_home.getvalue() 1692 1693 def __setfield_home(self, value): 1694 if isinstance(value,NumberEntry): 1695 self.__field_home=value 1696 else: 1697 self.__field_home=NumberEntry(value,) 1698 1699 def __delfield_home(self): del self.__field_home 1700 1701 home=property(__getfield_home, __setfield_home, __delfield_home, None) 1702 1703 def __getfield_work(self): 1704 return self.__field_work.getvalue() 1705 1706 def __setfield_work(self, value): 1707 if isinstance(value,NumberEntry): 1708 self.__field_work=value 1709 else: 1710 self.__field_work=NumberEntry(value,) 1711 1712 def __delfield_work(self): del self.__field_work 1713 1714 work=property(__getfield_work, __setfield_work, __delfield_work, None) 1715 1716 def __getfield_cell(self): 1717 return self.__field_cell.getvalue() 1718 1719 def __setfield_cell(self, value): 1720 if isinstance(value,NumberEntry): 1721 self.__field_cell=value 1722 else: 1723 self.__field_cell=NumberEntry(value,) 1724 1725 def __delfield_cell(self): del self.__field_cell 1726 1727 cell=property(__getfield_cell, __setfield_cell, __delfield_cell, None) 1728 1729 def __getfield_fax(self): 1730 return self.__field_fax.getvalue() 1731 1732 def __setfield_fax(self, value): 1733 if isinstance(value,NumberEntry): 1734 self.__field_fax=value 1735 else: 1736 self.__field_fax=NumberEntry(value,) 1737 1738 def __delfield_fax(self): del self.__field_fax 1739 1740 fax=property(__getfield_fax, __setfield_fax, __delfield_fax, None) 1741 1742 def __getfield_cell2(self): 1743 return self.__field_cell2.getvalue() 1744 1745 def __setfield_cell2(self, value): 1746 if isinstance(value,NumberEntry): 1747 self.__field_cell2=value 1748 else: 1749 self.__field_cell2=NumberEntry(value,) 1750 1751 def __delfield_cell2(self): del self.__field_cell2 1752 1753 cell2=property(__getfield_cell2, __setfield_cell2, __delfield_cell2, None) 1754 1755 def __getfield_note(self): 1756 return self.__field_note.getvalue() 1757 1758 def __setfield_note(self, value): 1759 if isinstance(value,STRING): 1760 self.__field_note=value 1761 else: 1762 self.__field_note=STRING(value,**{ 'terminator': None, 'pascal': True }) 1763 1764 def __delfield_note(self): del self.__field_note 1765 1766 note=property(__getfield_note, __setfield_note, __delfield_note, None) 1767 1768 def __getfield_datetime(self): 1769 return self.__field_datetime.getvalue() 1770 1771 def __setfield_datetime(self, value): 1772 if isinstance(value,DateTime): 1773 self.__field_datetime=value 1774 else: 1775 self.__field_datetime=DateTime(value,**{'sizeinbytes': 4}) 1776 1777 def __delfield_datetime(self): del self.__field_datetime 1778 1779 datetime=property(__getfield_datetime, __setfield_datetime, __delfield_datetime, None) 1780 1781 def __getfield_group(self): 1782 return self.__field_group.getvalue() 1783 1784 def __setfield_group(self, value): 1785 if isinstance(value,UINT): 1786 self.__field_group=value 1787 else: 1788 self.__field_group=UINT(value,**{'sizeinbytes': 1}) 1789 1790 def __delfield_group(self): del self.__field_group 1791 1792 group=property(__getfield_group, __setfield_group, __delfield_group, None) 1793 1794 def __getfield_wallpaper(self): 1795 return self.__field_wallpaper.getvalue() 1796 1797 def __setfield_wallpaper(self, value): 1798 if isinstance(value,STRING): 1799 self.__field_wallpaper=value 1800 else: 1801 self.__field_wallpaper=STRING(value,**{ 'terminator': None, 'pascal': True }) 1802 1803 def __delfield_wallpaper(self): del self.__field_wallpaper 1804 1805 wallpaper=property(__getfield_wallpaper, __setfield_wallpaper, __delfield_wallpaper, None) 1806 1807 def __getfield_wallpaper_range(self): 1808 return self.__field_wallpaper_range.getvalue() 1809 1810 def __setfield_wallpaper_range(self, value): 1811 if isinstance(value,UINT): 1812 self.__field_wallpaper_range=value 1813 else: 1814 self.__field_wallpaper_range=UINT(value,**{'sizeinbytes': 4}) 1815 1816 def __delfield_wallpaper_range(self): del self.__field_wallpaper_range 1817 1818 wallpaper_range=property(__getfield_wallpaper_range, __setfield_wallpaper_range, __delfield_wallpaper_range, None) 1819 1820 def iscontainer(self): 1821 return True 1822 1823 def containerelements(self): 1824 yield ('info', self.__field_info, None) 1825 yield ('info2', self.__field_info2, None) 1826 if self.info & PB_FLG_NAME: 1827 yield ('name', self.__field_name, None) 1828 if self.info & PB_FLG_EMAIL: 1829 yield ('email', self.__field_email, None) 1830 if self.info & PB_FLG_EMAIL2: 1831 yield ('email2', self.__field_email2, None) 1832 if self.info & PB_FLG_HOME: 1833 yield ('home', self.__field_home, None) 1834 if self.info & PB_FLG_WORK: 1835 yield ('work', self.__field_work, None) 1836 if self.info & PB_FLG_CELL: 1837 yield ('cell', self.__field_cell, None) 1838 if self.info & PB_FLG_FAX: 1839 yield ('fax', self.__field_fax, None) 1840 if self.info & PB_FLG_CELL2: 1841 yield ('cell2', self.__field_cell2, None) 1842 if self.info & PB_FLG_NOTE: 1843 yield ('note', self.__field_note, None) 1844 if self.info & PB_FLG_DATE: 1845 yield ('datetime', self.__field_datetime, None) 1846 if self.info & PB_FLG_GROUP: 1847 yield ('group', self.__field_group, None) 1848 if self.info & PB_FLG_WP: 1849 yield ('wallpaper', self.__field_wallpaper, None) 1850 yield ('wallpaper_range', self.__field_wallpaper_range, None) 1851 1852 1853 1854 1855 class LenEntry(BaseProtogenClass): 1856 __fields=['itemlen'] 1857 1858 def __init__(self, *args, **kwargs): 1859 dict={} 1860 # What was supplied to this function 1861 dict.update(kwargs) 1862 # Parent constructor 1863 super(LenEntry,self).__init__(**dict) 1864 if self.__class__ is LenEntry: 1865 self._update(args,dict) 1866 1867 1868 def getfields(self): 1869 return self.__fields 1870 1871 1872 def _update(self, args, kwargs): 1873 super(LenEntry,self)._update(args,kwargs) 1874 keys=kwargs.keys() 1875 for key in keys: 1876 if key in self.__fields: 1877 setattr(self, key, kwargs[key]) 1878 del kwargs[key] 1879 # Were any unrecognized kwargs passed in? 1880 if __debug__: 1881 self._complainaboutunusedargs(LenEntry,kwargs) 1882 if len(args): 1883 dict2={'sizeinbytes': 2, 'default': 0 } 1884 dict2.update(kwargs) 1885 kwargs=dict2 1886 self.__field_itemlen=UINT(*args,**dict2) 1887 # Make all P fields that haven't already been constructed 1888 1889 1890 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 1891 'Writes this packet to the supplied buffer' 1892 self._bufferstartoffset=buf.getcurrentoffset() 1893 try: self.__field_itemlen 1894 except: 1895 self.__field_itemlen=UINT(**{'sizeinbytes': 2, 'default': 0 }) 1896 self.__field_itemlen.writetobuffer(buf) 1897 self._bufferendoffset=buf.getcurrentoffset() 1898 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 1899 1900 1901 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 1902 'Reads this packet from the supplied buffer' 1903 self._bufferstartoffset=buf.getcurrentoffset() 1904 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 1905 self.__field_itemlen=UINT(**{'sizeinbytes': 2, 'default': 0 }) 1906 self.__field_itemlen.readfrombuffer(buf) 1907 self._bufferendoffset=buf.getcurrentoffset() 1908 1909 1910 def __getfield_itemlen(self): 1911 try: self.__field_itemlen 1912 except: 1913 self.__field_itemlen=UINT(**{'sizeinbytes': 2, 'default': 0 }) 1914 return self.__field_itemlen.getvalue() 1915 1916 def __setfield_itemlen(self, value): 1917 if isinstance(value,UINT): 1918 self.__field_itemlen=value 1919 else: 1920 self.__field_itemlen=UINT(value,**{'sizeinbytes': 2, 'default': 0 }) 1921 1922 def __delfield_itemlen(self): del self.__field_itemlen 1923 1924 itemlen=property(__getfield_itemlen, __setfield_itemlen, __delfield_itemlen, None) 1925 1926 def iscontainer(self): 1927 return True 1928 1929 def containerelements(self): 1930 yield ('itemlen', self.__field_itemlen, None) 1931 1932 1933 1934 1935 class PBFile(BaseProtogenClass): 1936 __fields=['lens', 'items'] 1937 1938 def __init__(self, *args, **kwargs): 1939 dict={} 1940 # What was supplied to this function 1941 dict.update(kwargs) 1942 # Parent constructor 1943 super(PBFile,self).__init__(**dict) 1944 if self.__class__ is PBFile: 1945 self._update(args,dict) 1946 1947 1948 def getfields(self): 1949 return self.__fields 1950 1951 1952 def _update(self, args, kwargs): 1953 super(PBFile,self)._update(args,kwargs) 1954 keys=kwargs.keys() 1955 for key in keys: 1956 if key in self.__fields: 1957 setattr(self, key, kwargs[key]) 1958 del kwargs[key] 1959 # Were any unrecognized kwargs passed in? 1960 if __debug__: 1961 self._complainaboutunusedargs(PBFile,kwargs) 1962 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 1963 # Make all P fields that haven't already been constructed 1964 1965 1966 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 1967 'Writes this packet to the supplied buffer' 1968 self._bufferstartoffset=buf.getcurrentoffset() 1969 try: self.__field_lens 1970 except: 1971 self.__field_lens=LIST(**{ 'elementclass': LenEntry, 'length': 8, 'createdefault': True }) 1972 self.__field_lens.writetobuffer(buf) 1973 try: self.__field_items 1974 except: 1975 self.__field_items=LIST(**{ 'elementclass': PBEntry }) 1976 self.__field_items.writetobuffer(buf) 1977 self._bufferendoffset=buf.getcurrentoffset() 1978 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 1979 1980 1981 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 1982 'Reads this packet from the supplied buffer' 1983 self._bufferstartoffset=buf.getcurrentoffset() 1984 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 1985 self.__field_lens=LIST(**{ 'elementclass': LenEntry, 'length': 8, 'createdefault': True }) 1986 self.__field_lens.readfrombuffer(buf) 1987 self.__field_items=LIST(**{ 'elementclass': PBEntry }) 1988 self.__field_items.readfrombuffer(buf) 1989 self._bufferendoffset=buf.getcurrentoffset() 1990 1991 1992 def __getfield_lens(self): 1993 try: self.__field_lens 1994 except: 1995 self.__field_lens=LIST(**{ 'elementclass': LenEntry, 'length': 8, 'createdefault': True }) 1996 return self.__field_lens.getvalue() 1997 1998 def __setfield_lens(self, value): 1999 if isinstance(value,LIST): 2000 self.__field_lens=value 2001 else: 2002 self.__field_lens=LIST(value,**{ 'elementclass': LenEntry, 'length': 8, 'createdefault': True }) 2003 2004 def __delfield_lens(self): del self.__field_lens 2005 2006 lens=property(__getfield_lens, __setfield_lens, __delfield_lens, None) 2007 2008 def __getfield_items(self): 2009 try: self.__field_items 2010 except: 2011 self.__field_items=LIST(**{ 'elementclass': PBEntry }) 2012 return self.__field_items.getvalue() 2013 2014 def __setfield_items(self, value): 2015 if isinstance(value,LIST): 2016 self.__field_items=value 2017 else: 2018 self.__field_items=LIST(value,**{ 'elementclass': PBEntry }) 2019 2020 def __delfield_items(self): del self.__field_items 2021 2022 items=property(__getfield_items, __setfield_items, __delfield_items, None) 2023 2024 def iscontainer(self): 2025 return True 2026 2027 def containerelements(self): 2028 yield ('lens', self.__field_lens, None) 2029 yield ('items', self.__field_items, None) 2030 2031 2032 2033 2034 class PBFileHeader(BaseProtogenClass): 2035 __fields=['lens'] 2036 2037 def __init__(self, *args, **kwargs): 2038 dict={} 2039 # What was supplied to this function 2040 dict.update(kwargs) 2041 # Parent constructor 2042 super(PBFileHeader,self).__init__(**dict) 2043 if self.__class__ is PBFileHeader: 2044 self._update(args,dict) 2045 2046 2047 def getfields(self): 2048 return self.__fields 2049 2050 2051 def _update(self, args, kwargs): 2052 super(PBFileHeader,self)._update(args,kwargs) 2053 keys=kwargs.keys() 2054 for key in keys: 2055 if key in self.__fields: 2056 setattr(self, key, kwargs[key]) 2057 del kwargs[key] 2058 # Were any unrecognized kwargs passed in? 2059 if __debug__: 2060 self._complainaboutunusedargs(PBFileHeader,kwargs) 2061 if len(args): 2062 dict2={ 'elementclass': LenEntry, 'length': 8, 'createdefault': True } 2063 dict2.update(kwargs) 2064 kwargs=dict2 2065 self.__field_lens=LIST(*args,**dict2) 2066 # Make all P fields that haven't already been constructed 2067 2068 2069 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 2070 'Writes this packet to the supplied buffer' 2071 self._bufferstartoffset=buf.getcurrentoffset() 2072 try: self.__field_lens 2073 except: 2074 self.__field_lens=LIST(**{ 'elementclass': LenEntry, 'length': 8, 'createdefault': True }) 2075 self.__field_lens.writetobuffer(buf) 2076 self._bufferendoffset=buf.getcurrentoffset() 2077 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 2078 2079 2080 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 2081 'Reads this packet from the supplied buffer' 2082 self._bufferstartoffset=buf.getcurrentoffset() 2083 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 2084 self.__field_lens=LIST(**{ 'elementclass': LenEntry, 'length': 8, 'createdefault': True }) 2085 self.__field_lens.readfrombuffer(buf) 2086 self._bufferendoffset=buf.getcurrentoffset() 2087 2088 2089 def __getfield_lens(self): 2090 try: self.__field_lens 2091 except: 2092 self.__field_lens=LIST(**{ 'elementclass': LenEntry, 'length': 8, 'createdefault': True }) 2093 return self.__field_lens.getvalue() 2094 2095 def __setfield_lens(self, value): 2096 if isinstance(value,LIST): 2097 self.__field_lens=value 2098 else: 2099 self.__field_lens=LIST(value,**{ 'elementclass': LenEntry, 'length': 8, 'createdefault': True }) 2100 2101 def __delfield_lens(self): del self.__field_lens 2102 2103 lens=property(__getfield_lens, __setfield_lens, __delfield_lens, None) 2104 2105 def iscontainer(self): 2106 return True 2107 2108 def containerelements(self): 2109 yield ('lens', self.__field_lens, None) 2110 2111 2112 2113 2114 class ss_number_entry(BaseProtogenClass): 2115 __fields=['number', 'speeddial', 'primary', 'zero', 'ringtone'] 2116 2117 def __init__(self, *args, **kwargs): 2118 dict={} 2119 # What was supplied to this function 2120 dict.update(kwargs) 2121 # Parent constructor 2122 super(ss_number_entry,self).__init__(**dict) 2123 if self.__class__ is ss_number_entry: 2124 self._update(args,dict) 2125 2126 2127 def getfields(self): 2128 return self.__fields 2129 2130 2131 def _update(self, args, kwargs): 2132 super(ss_number_entry,self)._update(args,kwargs) 2133 keys=kwargs.keys() 2134 for key in keys: 2135 if key in self.__fields: 2136 setattr(self, key, kwargs[key]) 2137 del kwargs[key] 2138 # Were any unrecognized kwargs passed in? 2139 if __debug__: 2140 self._complainaboutunusedargs(ss_number_entry,kwargs) 2141 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 2142 # Make all P fields that haven't already been constructed 2143 2144 2145 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 2146 'Writes this packet to the supplied buffer' 2147 self._bufferstartoffset=buf.getcurrentoffset() 2148 try: self.__field_number 2149 except: 2150 self.__field_number=STRING(**{ 'terminator': 0, 'default': '', 'maxsizeinbytes': PB_MAX_NUMBER_LEN, 'raiseontruncate': False }) 2151 self.__field_number.writetobuffer(buf) 2152 try: self.__field_speeddial 2153 except: 2154 self.__field_speeddial=UINT(**{'sizeinbytes': 2, 'default': 0 }) 2155 self.__field_speeddial.writetobuffer(buf) 2156 try: self.__field_primary 2157 except: 2158 self.__field_primary=UINT(**{'sizeinbytes': 1, 'default': 0 }) 2159 self.__field_primary.writetobuffer(buf) 2160 try: self.__field_zero 2161 except: 2162 self.__field_zero=STRING(**{'sizeinbytes': 8, 'pad': 0, 'default': '' }) 2163 self.__field_zero.writetobuffer(buf) 2164 try: self.__field_ringtone 2165 except: 2166 self.__field_ringtone=STRING(**{ 'terminator': 0, 'default': '' }) 2167 self.__field_ringtone.writetobuffer(buf) 2168 self._bufferendoffset=buf.getcurrentoffset() 2169 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 2170 2171 2172 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 2173 'Reads this packet from the supplied buffer' 2174 self._bufferstartoffset=buf.getcurrentoffset() 2175 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 2176 self.__field_number=STRING(**{ 'terminator': 0, 'default': '', 'maxsizeinbytes': PB_MAX_NUMBER_LEN, 'raiseontruncate': False }) 2177 self.__field_number.readfrombuffer(buf) 2178 self.__field_speeddial=UINT(**{'sizeinbytes': 2, 'default': 0 }) 2179 self.__field_speeddial.readfrombuffer(buf) 2180 self.__field_primary=UINT(**{'sizeinbytes': 1, 'default': 0 }) 2181 self.__field_primary.readfrombuffer(buf) 2182 self.__field_zero=STRING(**{'sizeinbytes': 8, 'pad': 0, 'default': '' }) 2183 self.__field_zero.readfrombuffer(buf) 2184 self.__field_ringtone=STRING(**{ 'terminator': 0, 'default': '' }) 2185 self.__field_ringtone.readfrombuffer(buf) 2186 self._bufferendoffset=buf.getcurrentoffset() 2187 2188 2189 def __getfield_number(self): 2190 try: self.__field_number 2191 except: 2192 self.__field_number=STRING(**{ 'terminator': 0, 'default': '', 'maxsizeinbytes': PB_MAX_NUMBER_LEN, 'raiseontruncate': False }) 2193 return self.__field_number.getvalue() 2194 2195 def __setfield_number(self, value): 2196 if isinstance(value,STRING): 2197 self.__field_number=value 2198 else: 2199 self.__field_number=STRING(value,**{ 'terminator': 0, 'default': '', 'maxsizeinbytes': PB_MAX_NUMBER_LEN, 'raiseontruncate': False }) 2200 2201 def __delfield_number(self): del self.__field_number 2202 2203 number=property(__getfield_number, __setfield_number, __delfield_number, None) 2204 2205 def __getfield_speeddial(self): 2206 try: self.__field_speeddial 2207 except: 2208 self.__field_speeddial=UINT(**{'sizeinbytes': 2, 'default': 0 }) 2209 return self.__field_speeddial.getvalue() 2210 2211 def __setfield_speeddial(self, value): 2212 if isinstance(value,UINT): 2213 self.__field_speeddial=value 2214 else: 2215 self.__field_speeddial=UINT(value,**{'sizeinbytes': 2, 'default': 0 }) 2216 2217 def __delfield_speeddial(self): del self.__field_speeddial 2218 2219 speeddial=property(__getfield_speeddial, __setfield_speeddial, __delfield_speeddial, None) 2220 2221 def __getfield_primary(self): 2222 try: self.__field_primary 2223 except: 2224 self.__field_primary=UINT(**{'sizeinbytes': 1, 'default': 0 }) 2225 return self.__field_primary.getvalue() 2226 2227 def __setfield_primary(self, value): 2228 if isinstance(value,UINT): 2229 self.__field_primary=value 2230 else: 2231 self.__field_primary=UINT(value,**{'sizeinbytes': 1, 'default': 0 }) 2232 2233 def __delfield_primary(self): del self.__field_primary 2234 2235 primary=property(__getfield_primary, __setfield_primary, __delfield_primary, None) 2236 2237 def __getfield_zero(self): 2238 try: self.__field_zero 2239 except: 2240 self.__field_zero=STRING(**{'sizeinbytes': 8, 'pad': 0, 'default': '' }) 2241 return self.__field_zero.getvalue() 2242 2243 def __setfield_zero(self, value): 2244 if isinstance(value,STRING): 2245 self.__field_zero=value 2246 else: 2247 self.__field_zero=STRING(value,**{'sizeinbytes': 8, 'pad': 0, 'default': '' }) 2248 2249 def __delfield_zero(self): del self.__field_zero 2250 2251 zero=property(__getfield_zero, __setfield_zero, __delfield_zero, None) 2252 2253 def __getfield_ringtone(self): 2254 try: self.__field_ringtone 2255 except: 2256 self.__field_ringtone=STRING(**{ 'terminator': 0, 'default': '' }) 2257 return self.__field_ringtone.getvalue() 2258 2259 def __setfield_ringtone(self, value): 2260 if isinstance(value,STRING): 2261 self.__field_ringtone=value 2262 else: 2263 self.__field_ringtone=STRING(value,**{ 'terminator': 0, 'default': '' }) 2264 2265 def __delfield_ringtone(self): del self.__field_ringtone 2266 2267 ringtone=property(__getfield_ringtone, __setfield_ringtone, __delfield_ringtone, None) 2268 2269 def iscontainer(self): 2270 return True 2271 2272 def containerelements(self): 2273 yield ('number', self.__field_number, None) 2274 yield ('speeddial', self.__field_speeddial, None) 2275 yield ('primary', self.__field_primary, None) 2276 yield ('zero', self.__field_zero, None) 2277 yield ('ringtone', self.__field_ringtone, None) 2278 2279 2280 2281 2282 class ss_pb_entry(BaseProtogenClass): 2283 __fields=['name', 'email', 'email2', 'zero1', 'note', 'zero5', 'wallpaper', 'wallpaper_range', 'zero2', 'home', 'work', 'cell', 'dummy', 'fax', 'cell2', 'zero3', 'group', 'zero4'] 2284 2285 def __init__(self, *args, **kwargs): 2286 dict={} 2287 # What was supplied to this function 2288 dict.update(kwargs) 2289 # Parent constructor 2290 super(ss_pb_entry,self).__init__(**dict) 2291 if self.__class__ is ss_pb_entry: 2292 self._update(args,dict) 2293 2294 2295 def getfields(self): 2296 return self.__fields 2297 2298 2299 def _update(self, args, kwargs): 2300 super(ss_pb_entry,self)._update(args,kwargs) 2301 keys=kwargs.keys() 2302 for key in keys: 2303 if key in self.__fields: 2304 setattr(self, key, kwargs[key]) 2305 del kwargs[key] 2306 # Were any unrecognized kwargs passed in? 2307 if __debug__: 2308 self._complainaboutunusedargs(ss_pb_entry,kwargs) 2309 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 2310 # Make all P fields that haven't already been constructed 2311 2312 2313 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 2314 'Writes this packet to the supplied buffer' 2315 self._bufferstartoffset=buf.getcurrentoffset() 2316 self.__field_name.writetobuffer(buf) 2317 try: self.__field_email 2318 except: 2319 self.__field_email=USTRING(**{ 'terminator': 0, 'encoding': ENCODING, 'default': '', 'maxsizeinbytes': PB_MAX_EMAIL_LEN, 'raiseontruncate': False }) 2320 self.__field_email.writetobuffer(buf) 2321 try: self.__field_email2 2322 except: 2323 self.__field_email2=USTRING(**{ 'terminator': 0, 'encoding': ENCODING, 'default': '', 'maxsizeinbytes': PB_MAX_EMAIL_LEN, 'raiseontruncate': False }) 2324 self.__field_email2.writetobuffer(buf) 2325 try: self.__field_zero1 2326 except: 2327 self.__field_zero1=UINT(**{'sizeinbytes': 2, 'default': 0 }) 2328 self.__field_zero1.writetobuffer(buf) 2329 try: self.__field_note 2330 except: 2331 self.__field_note=USTRING(**{ 'terminator': 0, 'encoding': ENCODING, 'maxsizeinbytes': PB_MAX_NOTE_LEN, 'raiseontruncate': False, 'default': '' }) 2332 self.__field_note.writetobuffer(buf) 2333 try: self.__field_zero5 2334 except: 2335 self.__field_zero5=UINT(**{'sizeinbytes': 1, 'default': 0 }) 2336 self.__field_zero5.writetobuffer(buf) 2337 try: self.__field_wallpaper 2338 except: 2339 self.__field_wallpaper=STRING(**{ 'terminator': 0, 'default': '' }) 2340 self.__field_wallpaper.writetobuffer(buf) 2341 try: self.__field_wallpaper_range 2342 except: 2343 self.__field_wallpaper_range=UINT(**{'sizeinbytes': 4, 'default': 0 }) 2344 self.__field_wallpaper_range.writetobuffer(buf) 2345 try: self.__field_zero2 2346 except: 2347 self.__field_zero2=UINT(**{'sizeinbytes': 1, 'default': 0 }) 2348 self.__field_zero2.writetobuffer(buf) 2349 try: self.__field_home 2350 except: 2351 self.__field_home=ss_number_entry() 2352 self.__field_home.writetobuffer(buf) 2353 try: self.__field_work 2354 except: 2355 self.__field_work=ss_number_entry() 2356 self.__field_work.writetobuffer(buf) 2357 try: self.__field_cell 2358 except: 2359 self.__field_cell=ss_number_entry() 2360 self.__field_cell.writetobuffer(buf) 2361 try: self.__field_dummy 2362 except: 2363 self.__field_dummy=ss_number_entry() 2364 self.__field_dummy.writetobuffer(buf) 2365 try: self.__field_fax 2366 except: 2367 self.__field_fax=ss_number_entry() 2368 self.__field_fax.writetobuffer(buf) 2369 try: self.__field_cell2 2370 except: 2371 self.__field_cell2=ss_number_entry() 2372 self.__field_cell2.writetobuffer(buf) 2373 try: self.__field_zero3 2374 except: 2375 self.__field_zero3=UINT(**{'sizeinbytes': 4, 'default': 0 }) 2376 self.__field_zero3.writetobuffer(buf) 2377 try: self.__field_group 2378 except: 2379 self.__field_group=UINT(**{'sizeinbytes': 1, 'default': 0 }) 2380 self.__field_group.writetobuffer(buf) 2381 try: self.__field_zero4 2382 except: 2383 self.__field_zero4=UINT(**{'sizeinbytes': 2, 'default': 0 }) 2384 self.__field_zero4.writetobuffer(buf) 2385 self._bufferendoffset=buf.getcurrentoffset() 2386 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 2387 2388 2389 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 2390 'Reads this packet from the supplied buffer' 2391 self._bufferstartoffset=buf.getcurrentoffset() 2392 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 2393 self.__field_name=USTRING(**{ 'terminator': 0, 'maxsizeinbytes': PB_MAX_NAME_LEN, 'encoding': ENCODING, 'raiseontruncate': False }) 2394 self.__field_name.readfrombuffer(buf) 2395 self.__field_email=USTRING(**{ 'terminator': 0, 'encoding': ENCODING, 'default': '', 'maxsizeinbytes': PB_MAX_EMAIL_LEN, 'raiseontruncate': False }) 2396 self.__field_email.readfrombuffer(buf) 2397 self.__field_email2=USTRING(**{ 'terminator': 0, 'encoding': ENCODING, 'default': '', 'maxsizeinbytes': PB_MAX_EMAIL_LEN, 'raiseontruncate': False }) 2398 self.__field_email2.readfrombuffer(buf) 2399 self.__field_zero1=UINT(**{'sizeinbytes': 2, 'default': 0 }) 2400 self.__field_zero1.readfrombuffer(buf) 2401 self.__field_note=USTRING(**{ 'terminator': 0, 'encoding': ENCODING, 'maxsizeinbytes': PB_MAX_NOTE_LEN, 'raiseontruncate': False, 'default': '' }) 2402 self.__field_note.readfrombuffer(buf) 2403 self.__field_zero5=UINT(**{'sizeinbytes': 1, 'default': 0 }) 2404 self.__field_zero5.readfrombuffer(buf) 2405 self.__field_wallpaper=STRING(**{ 'terminator': 0, 'default': '' }) 2406 self.__field_wallpaper.readfrombuffer(buf) 2407 self.__field_wallpaper_range=UINT(**{'sizeinbytes': 4, 'default': 0 }) 2408 self.__field_wallpaper_range.readfrombuffer(buf) 2409 self.__field_zero2=UINT(**{'sizeinbytes': 1, 'default': 0 }) 2410 self.__field_zero2.readfrombuffer(buf) 2411 self.__field_home=ss_number_entry() 2412 self.__field_home.readfrombuffer(buf) 2413 self.__field_work=ss_number_entry() 2414 self.__field_work.readfrombuffer(buf) 2415 self.__field_cell=ss_number_entry() 2416 self.__field_cell.readfrombuffer(buf) 2417 self.__field_dummy=ss_number_entry() 2418 self.__field_dummy.readfrombuffer(buf) 2419 self.__field_fax=ss_number_entry() 2420 self.__field_fax.readfrombuffer(buf) 2421 self.__field_cell2=ss_number_entry() 2422 self.__field_cell2.readfrombuffer(buf) 2423 self.__field_zero3=UINT(**{'sizeinbytes': 4, 'default': 0 }) 2424 self.__field_zero3.readfrombuffer(buf) 2425 self.__field_group=UINT(**{'sizeinbytes': 1, 'default': 0 }) 2426 self.__field_group.readfrombuffer(buf) 2427 self.__field_zero4=UINT(**{'sizeinbytes': 2, 'default': 0 }) 2428 self.__field_zero4.readfrombuffer(buf) 2429 self._bufferendoffset=buf.getcurrentoffset() 2430 2431 2432 def __getfield_name(self): 2433 return self.__field_name.getvalue() 2434 2435 def __setfield_name(self, value): 2436 if isinstance(value,USTRING): 2437 self.__field_name=value 2438 else: 2439 self.__field_name=USTRING(value,**{ 'terminator': 0, 'maxsizeinbytes': PB_MAX_NAME_LEN, 'encoding': ENCODING, 'raiseontruncate': False }) 2440 2441 def __delfield_name(self): del self.__field_name 2442 2443 name=property(__getfield_name, __setfield_name, __delfield_name, None) 2444 2445 def __getfield_email(self): 2446 try: self.__field_email 2447 except: 2448 self.__field_email=USTRING(**{ 'terminator': 0, 'encoding': ENCODING, 'default': '', 'maxsizeinbytes': PB_MAX_EMAIL_LEN, 'raiseontruncate': False }) 2449 return self.__field_email.getvalue() 2450 2451 def __setfield_email(self, value): 2452 if isinstance(value,USTRING): 2453 self.__field_email=value 2454 else: 2455 self.__field_email=USTRING(value,**{ 'terminator': 0, 'encoding': ENCODING, 'default': '', 'maxsizeinbytes': PB_MAX_EMAIL_LEN, 'raiseontruncate': False }) 2456 2457 def __delfield_email(self): del self.__field_email 2458 2459 email=property(__getfield_email, __setfield_email, __delfield_email, None) 2460 2461 def __getfield_email2(self): 2462 try: self.__field_email2 2463 except: 2464 self.__field_email2=USTRING(**{ 'terminator': 0, 'encoding': ENCODING, 'default': '', 'maxsizeinbytes': PB_MAX_EMAIL_LEN, 'raiseontruncate': False }) 2465 return self.__field_email2.getvalue() 2466 2467 def __setfield_email2(self, value): 2468 if isinstance(value,USTRING): 2469 self.__field_email2=value 2470 else: 2471 self.__field_email2=USTRING(value,**{ 'terminator': 0, 'encoding': ENCODING, 'default': '', 'maxsizeinbytes': PB_MAX_EMAIL_LEN, 'raiseontruncate': False }) 2472 2473 def __delfield_email2(self): del self.__field_email2 2474 2475 email2=property(__getfield_email2, __setfield_email2, __delfield_email2, None) 2476 2477 def __getfield_zero1(self): 2478 try: self.__field_zero1 2479 except: 2480 self.__field_zero1=UINT(**{'sizeinbytes': 2, 'default': 0 }) 2481 return self.__field_zero1.getvalue() 2482 2483 def __setfield_zero1(self, value): 2484 if isinstance(value,UINT): 2485 self.__field_zero1=value 2486 else: 2487 self.__field_zero1=UINT(value,**{'sizeinbytes': 2, 'default': 0 }) 2488 2489 def __delfield_zero1(self): del self.__field_zero1 2490 2491 zero1=property(__getfield_zero1, __setfield_zero1, __delfield_zero1, None) 2492 2493 def __getfield_note(self): 2494 try: self.__field_note 2495 except: 2496 self.__field_note=USTRING(**{ 'terminator': 0, 'encoding': ENCODING, 'maxsizeinbytes': PB_MAX_NOTE_LEN, 'raiseontruncate': False, 'default': '' }) 2497 return self.__field_note.getvalue() 2498 2499 def __setfield_note(self, value): 2500 if isinstance(value,USTRING): 2501 self.__field_note=value 2502 else: 2503 self.__field_note=USTRING(value,**{ 'terminator': 0, 'encoding': ENCODING, 'maxsizeinbytes': PB_MAX_NOTE_LEN, 'raiseontruncate': False, 'default': '' }) 2504 2505 def __delfield_note(self): del self.__field_note 2506 2507 note=property(__getfield_note, __setfield_note, __delfield_note, None) 2508 2509 def __getfield_zero5(self): 2510 try: self.__field_zero5 2511 except: 2512 self.__field_zero5=UINT(**{'sizeinbytes': 1, 'default': 0 }) 2513 return self.__field_zero5.getvalue() 2514 2515 def __setfield_zero5(self, value): 2516 if isinstance(value,UINT): 2517 self.__field_zero5=value 2518 else: 2519 self.__field_zero5=UINT(value,**{'sizeinbytes': 1, 'default': 0 }) 2520 2521 def __delfield_zero5(self): del self.__field_zero5 2522 2523 zero5=property(__getfield_zero5, __setfield_zero5, __delfield_zero5, None) 2524 2525 def __getfield_wallpaper(self): 2526 try: self.__field_wallpaper 2527 except: 2528 self.__field_wallpaper=STRING(**{ 'terminator': 0, 'default': '' }) 2529 return self.__field_wallpaper.getvalue() 2530 2531 def __setfield_wallpaper(self, value): 2532 if isinstance(value,STRING): 2533 self.__field_wallpaper=value 2534 else: 2535 self.__field_wallpaper=STRING(value,**{ 'terminator': 0, 'default': '' }) 2536 2537 def __delfield_wallpaper(self): del self.__field_wallpaper 2538 2539 wallpaper=property(__getfield_wallpaper, __setfield_wallpaper, __delfield_wallpaper, None) 2540 2541 def __getfield_wallpaper_range(self): 2542 try: self.__field_wallpaper_range 2543 except: 2544 self.__field_wallpaper_range=UINT(**{'sizeinbytes': 4, 'default': 0 }) 2545 return self.__field_wallpaper_range.getvalue() 2546 2547 def __setfield_wallpaper_range(self, value): 2548 if isinstance(value,UINT): 2549 self.__field_wallpaper_range=value 2550 else: 2551 self.__field_wallpaper_range=UINT(value,**{'sizeinbytes': 4, 'default': 0 }) 2552 2553 def __delfield_wallpaper_range(self): del self.__field_wallpaper_range 2554 2555 wallpaper_range=property(__getfield_wallpaper_range, __setfield_wallpaper_range, __delfield_wallpaper_range, None) 2556 2557 def __getfield_zero2(self): 2558 try: self.__field_zero2 2559 except: 2560 self.__field_zero2=UINT(**{'sizeinbytes': 1, 'default': 0 }) 2561 return self.__field_zero2.getvalue() 2562 2563 def __setfield_zero2(self, value): 2564 if isinstance(value,UINT): 2565 self.__field_zero2=value 2566 else: 2567 self.__field_zero2=UINT(value,**{'sizeinbytes': 1, 'default': 0 }) 2568 2569 def __delfield_zero2(self): del self.__field_zero2 2570 2571 zero2=property(__getfield_zero2, __setfield_zero2, __delfield_zero2, None) 2572 2573 def __getfield_home(self): 2574 try: self.__field_home 2575 except: 2576 self.__field_home=ss_number_entry() 2577 return self.__field_home.getvalue() 2578 2579 def __setfield_home(self, value): 2580 if isinstance(value,ss_number_entry): 2581 self.__field_home=value 2582 else: 2583 self.__field_home=ss_number_entry(value,) 2584 2585 def __delfield_home(self): del self.__field_home 2586 2587 home=property(__getfield_home, __setfield_home, __delfield_home, None) 2588 2589 def __getfield_work(self): 2590 try: self.__field_work 2591 except: 2592 self.__field_work=ss_number_entry() 2593 return self.__field_work.getvalue() 2594 2595 def __setfield_work(self, value): 2596 if isinstance(value,ss_number_entry): 2597 self.__field_work=value 2598 else: 2599 self.__field_work=ss_number_entry(value,) 2600 2601 def __delfield_work(self): del self.__field_work 2602 2603 work=property(__getfield_work, __setfield_work, __delfield_work, None) 2604 2605 def __getfield_cell(self): 2606 try: self.__field_cell 2607 except: 2608 self.__field_cell=ss_number_entry() 2609 return self.__field_cell.getvalue() 2610 2611 def __setfield_cell(self, value): 2612 if isinstance(value,ss_number_entry): 2613 self.__field_cell=value 2614 else: 2615 self.__field_cell=ss_number_entry(value,) 2616 2617 def __delfield_cell(self): del self.__field_cell 2618 2619 cell=property(__getfield_cell, __setfield_cell, __delfield_cell, None) 2620 2621 def __getfield_dummy(self): 2622 try: self.__field_dummy 2623 except: 2624 self.__field_dummy=ss_number_entry() 2625 return self.__field_dummy.getvalue() 2626 2627 def __setfield_dummy(self, value): 2628 if isinstance(value,ss_number_entry): 2629 self.__field_dummy=value 2630 else: 2631 self.__field_dummy=ss_number_entry(value,) 2632 2633 def __delfield_dummy(self): del self.__field_dummy 2634 2635 dummy=property(__getfield_dummy, __setfield_dummy, __delfield_dummy, None) 2636 2637 def __getfield_fax(self): 2638 try: self.__field_fax 2639 except: 2640 self.__field_fax=ss_number_entry() 2641 return self.__field_fax.getvalue() 2642 2643 def __setfield_fax(self, value): 2644 if isinstance(value,ss_number_entry): 2645 self.__field_fax=value 2646 else: 2647 self.__field_fax=ss_number_entry(value,) 2648 2649 def __delfield_fax(self): del self.__field_fax 2650 2651 fax=property(__getfield_fax, __setfield_fax, __delfield_fax, None) 2652 2653 def __getfield_cell2(self): 2654 try: self.__field_cell2 2655 except: 2656 self.__field_cell2=ss_number_entry() 2657 return self.__field_cell2.getvalue() 2658 2659 def __setfield_cell2(self, value): 2660 if isinstance(value,ss_number_entry): 2661 self.__field_cell2=value 2662 else: 2663 self.__field_cell2=ss_number_entry(value,) 2664 2665 def __delfield_cell2(self): del self.__field_cell2 2666 2667 cell2=property(__getfield_cell2, __setfield_cell2, __delfield_cell2, None) 2668 2669 def __getfield_zero3(self): 2670 try: self.__field_zero3 2671 except: 2672 self.__field_zero3=UINT(**{'sizeinbytes': 4, 'default': 0 }) 2673 return self.__field_zero3.getvalue() 2674 2675 def __setfield_zero3(self, value): 2676 if isinstance(value,UINT): 2677 self.__field_zero3=value 2678 else: 2679 self.__field_zero3=UINT(value,**{'sizeinbytes': 4, 'default': 0 }) 2680 2681 def __delfield_zero3(self): del self.__field_zero3 2682 2683 zero3=property(__getfield_zero3, __setfield_zero3, __delfield_zero3, None) 2684 2685 def __getfield_group(self): 2686 try: self.__field_group 2687 except: 2688 self.__field_group=UINT(**{'sizeinbytes': 1, 'default': 0 }) 2689 return self.__field_group.getvalue() 2690 2691 def __setfield_group(self, value): 2692 if isinstance(value,UINT): 2693 self.__field_group=value 2694 else: 2695 self.__field_group=UINT(value,**{'sizeinbytes': 1, 'default': 0 }) 2696 2697 def __delfield_group(self): del self.__field_group 2698 2699 group=property(__getfield_group, __setfield_group, __delfield_group, None) 2700 2701 def __getfield_zero4(self): 2702 try: self.__field_zero4 2703 except: 2704 self.__field_zero4=UINT(**{'sizeinbytes': 2, 'default': 0 }) 2705 return self.__field_zero4.getvalue() 2706 2707 def __setfield_zero4(self, value): 2708 if isinstance(value,UINT): 2709 self.__field_zero4=value 2710 else: 2711 self.__field_zero4=UINT(value,**{'sizeinbytes': 2, 'default': 0 }) 2712 2713 def __delfield_zero4(self): del self.__field_zero4 2714 2715 zero4=property(__getfield_zero4, __setfield_zero4, __delfield_zero4, None) 2716 2717 def iscontainer(self): 2718 return True 2719 2720 def containerelements(self): 2721 yield ('name', self.__field_name, None) 2722 yield ('email', self.__field_email, None) 2723 yield ('email2', self.__field_email2, None) 2724 yield ('zero1', self.__field_zero1, None) 2725 yield ('note', self.__field_note, None) 2726 yield ('zero5', self.__field_zero5, None) 2727 yield ('wallpaper', self.__field_wallpaper, None) 2728 yield ('wallpaper_range', self.__field_wallpaper_range, None) 2729 yield ('zero2', self.__field_zero2, None) 2730 yield ('home', self.__field_home, None) 2731 yield ('work', self.__field_work, None) 2732 yield ('cell', self.__field_cell, None) 2733 yield ('dummy', self.__field_dummy, None) 2734 yield ('fax', self.__field_fax, None) 2735 yield ('cell2', self.__field_cell2, None) 2736 yield ('zero3', self.__field_zero3, None) 2737 yield ('group', self.__field_group, None) 2738 yield ('zero4', self.__field_zero4, None) 2739 2740 2741 2742 2743 class ss_pb_write_req(BaseProtogenClass): 2744 __fields=['hdr', 'zero', 'entry'] 2745 2746 def __init__(self, *args, **kwargs): 2747 dict={} 2748 # What was supplied to this function 2749 dict.update(kwargs) 2750 # Parent constructor 2751 super(ss_pb_write_req,self).__init__(**dict) 2752 if self.__class__ is ss_pb_write_req: 2753 self._update(args,dict) 2754 2755 2756 def getfields(self): 2757 return self.__fields 2758 2759 2760 def _update(self, args, kwargs): 2761 super(ss_pb_write_req,self)._update(args,kwargs) 2762 keys=kwargs.keys() 2763 for key in keys: 2764 if key in self.__fields: 2765 setattr(self, key, kwargs[key]) 2766 del kwargs[key] 2767 # Were any unrecognized kwargs passed in? 2768 if __debug__: 2769 self._complainaboutunusedargs(ss_pb_write_req,kwargs) 2770 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 2771 # Make all P fields that haven't already been constructed 2772 2773 2774 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 2775 'Writes this packet to the supplied buffer' 2776 self._bufferstartoffset=buf.getcurrentoffset() 2777 try: self.__field_hdr 2778 except: 2779 self.__field_hdr=ss_cmd_hdr(**{ 'command': SS_CMD_PB_WRITE }) 2780 self.__field_hdr.writetobuffer(buf) 2781 try: self.__field_zero 2782 except: 2783 self.__field_zero=UINT(**{'sizeinbytes': 1, 'default': 0 }) 2784 self.__field_zero.writetobuffer(buf) 2785 self.__field_entry.writetobuffer(buf) 2786 self._bufferendoffset=buf.getcurrentoffset() 2787 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 2788 2789 2790 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 2791 'Reads this packet from the supplied buffer' 2792 self._bufferstartoffset=buf.getcurrentoffset() 2793 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 2794 self.__field_hdr=ss_cmd_hdr(**{ 'command': SS_CMD_PB_WRITE }) 2795 self.__field_hdr.readfrombuffer(buf) 2796 self.__field_zero=UINT(**{'sizeinbytes': 1, 'default': 0 }) 2797 self.__field_zero.readfrombuffer(buf) 2798 self.__field_entry=ss_pb_entry() 2799 self.__field_entry.readfrombuffer(buf) 2800 self._bufferendoffset=buf.getcurrentoffset() 2801 2802 2803 def __getfield_hdr(self): 2804 try: self.__field_hdr 2805 except: 2806 self.__field_hdr=ss_cmd_hdr(**{ 'command': SS_CMD_PB_WRITE }) 2807 return self.__field_hdr.getvalue() 2808 2809 def __setfield_hdr(self, value): 2810 if isinstance(value,ss_cmd_hdr): 2811 self.__field_hdr=value 2812 else: 2813 self.__field_hdr=ss_cmd_hdr(value,**{ 'command': SS_CMD_PB_WRITE }) 2814 2815 def __delfield_hdr(self): del self.__field_hdr 2816 2817 hdr=property(__getfield_hdr, __setfield_hdr, __delfield_hdr, None) 2818 2819 def __getfield_zero(self): 2820 try: self.__field_zero 2821 except: 2822 self.__field_zero=UINT(**{'sizeinbytes': 1, 'default': 0 }) 2823 return self.__field_zero.getvalue() 2824 2825 def __setfield_zero(self, value): 2826 if isinstance(value,UINT): 2827 self.__field_zero=value 2828 else: 2829 self.__field_zero=UINT(value,**{'sizeinbytes': 1, 'default': 0 }) 2830 2831 def __delfield_zero(self): del self.__field_zero 2832 2833 zero=property(__getfield_zero, __setfield_zero, __delfield_zero, None) 2834 2835 def __getfield_entry(self): 2836 return self.__field_entry.getvalue() 2837 2838 def __setfield_entry(self, value): 2839 if isinstance(value,ss_pb_entry): 2840 self.__field_entry=value 2841 else: 2842 self.__field_entry=ss_pb_entry(value,) 2843 2844 def __delfield_entry(self): del self.__field_entry 2845 2846 entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None) 2847 2848 def iscontainer(self): 2849 return True 2850 2851 def containerelements(self): 2852 yield ('hdr', self.__field_hdr, None) 2853 yield ('zero', self.__field_zero, None) 2854 yield ('entry', self.__field_entry, None) 2855 2856 2857 2858 2859 class ss_pb_write_resp(BaseProtogenClass): 2860 __fields=['hdr', 'zero', 'index'] 2861 2862 def __init__(self, *args, **kwargs): 2863 dict={} 2864 # What was supplied to this function 2865 dict.update(kwargs) 2866 # Parent constructor 2867 super(ss_pb_write_resp,self).__init__(**dict) 2868 if self.__class__ is ss_pb_write_resp: 2869 self._update(args,dict) 2870 2871 2872 def getfields(self): 2873 return self.__fields 2874 2875 2876 def _update(self, args, kwargs): 2877 super(ss_pb_write_resp,self)._update(args,kwargs) 2878 keys=kwargs.keys() 2879 for key in keys: 2880 if key in self.__fields: 2881 setattr(self, key, kwargs[key]) 2882 del kwargs[key] 2883 # Were any unrecognized kwargs passed in? 2884 if __debug__: 2885 self._complainaboutunusedargs(ss_pb_write_resp,kwargs) 2886 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 2887 # Make all P fields that haven't already been constructed 2888 2889 2890 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 2891 'Writes this packet to the supplied buffer' 2892 self._bufferstartoffset=buf.getcurrentoffset() 2893 self.__field_hdr.writetobuffer(buf) 2894 self.__field_zero.writetobuffer(buf) 2895 self.__field_index.writetobuffer(buf) 2896 self._bufferendoffset=buf.getcurrentoffset() 2897 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 2898 2899 2900 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 2901 'Reads this packet from the supplied buffer' 2902 self._bufferstartoffset=buf.getcurrentoffset() 2903 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 2904 self.__field_hdr=ss_cmd_hdr() 2905 self.__field_hdr.readfrombuffer(buf) 2906 self.__field_zero=UINT(**{'sizeinbytes': 1}) 2907 self.__field_zero.readfrombuffer(buf) 2908 self.__field_index=UINT(**{'sizeinbytes': 2}) 2909 self.__field_index.readfrombuffer(buf) 2910 self._bufferendoffset=buf.getcurrentoffset() 2911 2912 2913 def __getfield_hdr(self): 2914 return self.__field_hdr.getvalue() 2915 2916 def __setfield_hdr(self, value): 2917 if isinstance(value,ss_cmd_hdr): 2918 self.__field_hdr=value 2919 else: 2920 self.__field_hdr=ss_cmd_hdr(value,) 2921 2922 def __delfield_hdr(self): del self.__field_hdr 2923 2924 hdr=property(__getfield_hdr, __setfield_hdr, __delfield_hdr, None) 2925 2926 def __getfield_zero(self): 2927 return self.__field_zero.getvalue() 2928 2929 def __setfield_zero(self, value): 2930 if isinstance(value,UINT): 2931 self.__field_zero=value 2932 else: 2933 self.__field_zero=UINT(value,**{'sizeinbytes': 1}) 2934 2935 def __delfield_zero(self): del self.__field_zero 2936 2937 zero=property(__getfield_zero, __setfield_zero, __delfield_zero, None) 2938 2939 def __getfield_index(self): 2940 return self.__field_index.getvalue() 2941 2942 def __setfield_index(self, value): 2943 if isinstance(value,UINT): 2944 self.__field_index=value 2945 else: 2946 self.__field_index=UINT(value,**{'sizeinbytes': 2}) 2947 2948 def __delfield_index(self): del self.__field_index 2949 2950 index=property(__getfield_index, __setfield_index, __delfield_index, None) 2951 2952 def iscontainer(self): 2953 return True 2954 2955 def containerelements(self): 2956 yield ('hdr', self.__field_hdr, None) 2957 yield ('zero', self.__field_zero, None) 2958 yield ('index', self.__field_index, None) 2959 2960 2961 2962 2963 class pBOOL(BaseProtogenClass): 2964 __fields=['value'] 2965 2966 def __init__(self, *args, **kwargs): 2967 dict={} 2968 # What was supplied to this function 2969 dict.update(kwargs) 2970 # Parent constructor 2971 super(pBOOL,self).__init__(**dict) 2972 if self.__class__ is pBOOL: 2973 self._update(args,dict) 2974 2975 2976 def getfields(self): 2977 return self.__fields 2978 2979 2980 def _update(self, args, kwargs): 2981 super(pBOOL,self)._update(args,kwargs) 2982 keys=kwargs.keys() 2983 for key in keys: 2984 if key in self.__fields: 2985 setattr(self, key, kwargs[key]) 2986 del kwargs[key] 2987 # Were any unrecognized kwargs passed in? 2988 if __debug__: 2989 self._complainaboutunusedargs(pBOOL,kwargs) 2990 if len(args): 2991 dict2={'sizeinbytes': 'P'} 2992 dict2.update(kwargs) 2993 kwargs=dict2 2994 self.__field_value=BOOL(*args,**dict2) 2995 # Make all P fields that haven't already been constructed 2996 try: self.__field_value 2997 except: 2998 self.__field_value=BOOL() 2999 3000 3001 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 3002 'Writes this packet to the supplied buffer' 3003 self._bufferstartoffset=buf.getcurrentoffset() 3004 self._bufferendoffset=buf.getcurrentoffset() 3005 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 3006 3007 3008 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 3009 'Reads this packet from the supplied buffer' 3010 self._bufferstartoffset=buf.getcurrentoffset() 3011 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 3012 self._bufferendoffset=buf.getcurrentoffset() 3013 3014 3015 def __getfield_value(self): 3016 return self.__field_value.getvalue() 3017 3018 def __setfield_value(self, value): 3019 if isinstance(value,BOOL): 3020 self.__field_value=value 3021 else: 3022 self.__field_value=BOOL(value,) 3023 3024 def __delfield_value(self): del self.__field_value 3025 3026 value=property(__getfield_value, __setfield_value, __delfield_value, None) 3027 3028 def iscontainer(self): 3029 return True 3030 3031 def containerelements(self): 3032 yield ('value', self.__field_value, None) 3033 3034 3035 3036 3037 class sms_header(BaseProtogenClass): 3038 __fields=['index', 'msg_len', 'callback_len', 'bitmap1', 'bitmap2', 'dunno1', 'body_len', 'file_type', 'msg_type', 'enhance_delivery', 'is_txt_msg', 'in_msg', 'sent_msg', 'draft_msg', 'body'] 3039 3040 def __init__(self, *args, **kwargs): 3041 dict={} 3042 # What was supplied to this function 3043 dict.update(kwargs) 3044 # Parent constructor 3045 super(sms_header,self).__init__(**dict) 3046 if self.__class__ is sms_header: 3047 self._update(args,dict) 3048 3049 3050 def getfields(self): 3051 return self.__fields 3052 3053 3054 def _update(self, args, kwargs): 3055 super(sms_header,self)._update(args,kwargs) 3056 keys=kwargs.keys() 3057 for key in keys: 3058 if key in self.__fields: 3059 setattr(self, key, kwargs[key]) 3060 del kwargs[key] 3061 # Were any unrecognized kwargs passed in? 3062 if __debug__: 3063 self._complainaboutunusedargs(sms_header,kwargs) 3064 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 3065 # Make all P fields that haven't already been constructed 3066 3067 3068 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 3069 'Writes this packet to the supplied buffer' 3070 self._bufferstartoffset=buf.getcurrentoffset() 3071 self.__field_index.writetobuffer(buf) 3072 self.__field_msg_len.writetobuffer(buf) 3073 self.__field_callback_len.writetobuffer(buf) 3074 self.__field_bitmap1.writetobuffer(buf) 3075 self.__field_bitmap2.writetobuffer(buf) 3076 self.__field_dunno1.writetobuffer(buf) 3077 self.__field_body_len.writetobuffer(buf) 3078 self.__field_file_type.writetobuffer(buf) 3079 self.__field_msg_type.writetobuffer(buf) 3080 self.__field_enhance_delivery.writetobuffer(buf) 3081 self.__field_is_txt_msg.writetobuffer(buf) 3082 self.__field_in_msg.writetobuffer(buf) 3083 self.__field_sent_msg.writetobuffer(buf) 3084 self.__field_draft_msg.writetobuffer(buf) 3085 if self.is_txt_msg.value: 3086 self.__field_body.writetobuffer(buf) 3087 self._bufferendoffset=buf.getcurrentoffset() 3088 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 3089 3090 3091 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 3092 'Reads this packet from the supplied buffer' 3093 self._bufferstartoffset=buf.getcurrentoffset() 3094 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 3095 self.__field_index=UINT(**{'sizeinbytes': 2}) 3096 self.__field_index.readfrombuffer(buf) 3097 self.__field_msg_len=UINT(**{'sizeinbytes': 1}) 3098 self.__field_msg_len.readfrombuffer(buf) 3099 self.__field_callback_len=UINT(**{'sizeinbytes': 1}) 3100 self.__field_callback_len.readfrombuffer(buf) 3101 self.__field_bitmap1=UINT(**{'sizeinbytes': 1}) 3102 self.__field_bitmap1.readfrombuffer(buf) 3103 self.__field_bitmap2=UINT(**{'sizeinbytes': 1}) 3104 self.__field_bitmap2.readfrombuffer(buf) 3105 self.__field_dunno1=UNKNOWN(**{'sizeinbytes': 6}) 3106 self.__field_dunno1.readfrombuffer(buf) 3107 self.__field_body_len=UINT(**{'sizeinbytes': 2}) 3108 self.__field_body_len.readfrombuffer(buf) 3109 self.__field_file_type=UINT(**{'sizeinbytes': 2}) 3110 self.__field_file_type.readfrombuffer(buf) 3111 self.__field_msg_type=UINT(**{'sizeinbytes': 1}) 3112 self.__field_msg_type.readfrombuffer(buf) 3113 self.__field_enhance_delivery=UINT(**{'sizeinbytes': 1}) 3114 self.__field_enhance_delivery.readfrombuffer(buf) 3115 self.__field_is_txt_msg=pBOOL(**{ 'value': self.file_type==SMS_TXT_TYPE and self.msg_type in SMS_VALID_TYPE }) 3116 self.__field_is_txt_msg.readfrombuffer(buf) 3117 self.__field_in_msg=pBOOL(**{ 'value': self.msg_type==SMS_TYPE_IN }) 3118 self.__field_in_msg.readfrombuffer(buf) 3119 self.__field_sent_msg=pBOOL(**{ 'value': self.msg_type==SMS_TYPE_SENT }) 3120 self.__field_sent_msg.readfrombuffer(buf) 3121 self.__field_draft_msg=pBOOL(**{ 'value': self.msg_type==SMS_TYPE_DRAFT }) 3122 self.__field_draft_msg.readfrombuffer(buf) 3123 if self.is_txt_msg.value: 3124 self.__field_body=sms_body(**{ 'msg_len': self.msg_len, 'has_callback': self.bitmap2 & SMS_FLG2_CALLBACK, 'has_priority': self.bitmap2 & SMS_FLG2_PRIORITY, 'has_1byte': self.bitmap2 & SMS_FLG2_SOMETHING, 'has_1byte2': self.bitmap2 & SMS_FLG2_MSG, 'has_40bytes': self.bitmap1 & SMS_FLG1_HAS40 }) 3125 self.__field_body.readfrombuffer(buf) 3126 self._bufferendoffset=buf.getcurrentoffset() 3127 3128 3129 def __getfield_index(self): 3130 return self.__field_index.getvalue() 3131 3132 def __setfield_index(self, value): 3133 if isinstance(value,UINT): 3134 self.__field_index=value 3135 else: 3136 self.__field_index=UINT(value,**{'sizeinbytes': 2}) 3137 3138 def __delfield_index(self): del self.__field_index 3139 3140 index=property(__getfield_index, __setfield_index, __delfield_index, None) 3141 3142 def __getfield_msg_len(self): 3143 return self.__field_msg_len.getvalue() 3144 3145 def __setfield_msg_len(self, value): 3146 if isinstance(value,UINT): 3147 self.__field_msg_len=value 3148 else: 3149 self.__field_msg_len=UINT(value,**{'sizeinbytes': 1}) 3150 3151 def __delfield_msg_len(self): del self.__field_msg_len 3152 3153 msg_len=property(__getfield_msg_len, __setfield_msg_len, __delfield_msg_len, None) 3154 3155 def __getfield_callback_len(self): 3156 return self.__field_callback_len.getvalue() 3157 3158 def __setfield_callback_len(self, value): 3159 if isinstance(value,UINT): 3160 self.__field_callback_len=value 3161 else: 3162 self.__field_callback_len=UINT(value,**{'sizeinbytes': 1}) 3163 3164 def __delfield_callback_len(self): del self.__field_callback_len 3165 3166 callback_len=property(__getfield_callback_len, __setfield_callback_len, __delfield_callback_len, None) 3167 3168 def __getfield_bitmap1(self): 3169 return self.__field_bitmap1.getvalue() 3170 3171 def __setfield_bitmap1(self, value): 3172 if isinstance(value,UINT): 3173 self.__field_bitmap1=value 3174 else: 3175 self.__field_bitmap1=UINT(value,**{'sizeinbytes': 1}) 3176 3177 def __delfield_bitmap1(self): del self.__field_bitmap1 3178 3179 bitmap1=property(__getfield_bitmap1, __setfield_bitmap1, __delfield_bitmap1, None) 3180 3181 def __getfield_bitmap2(self): 3182 return self.__field_bitmap2.getvalue() 3183 3184 def __setfield_bitmap2(self, value): 3185 if isinstance(value,UINT): 3186 self.__field_bitmap2=value 3187 else: 3188 self.__field_bitmap2=UINT(value,**{'sizeinbytes': 1}) 3189 3190 def __delfield_bitmap2(self): del self.__field_bitmap2 3191 3192 bitmap2=property(__getfield_bitmap2, __setfield_bitmap2, __delfield_bitmap2, None) 3193 3194 def __getfield_dunno1(self): 3195 return self.__field_dunno1.getvalue() 3196 3197 def __setfield_dunno1(self, value): 3198 if isinstance(value,UNKNOWN): 3199 self.__field_dunno1=value 3200 else: 3201 self.__field_dunno1=UNKNOWN(value,**{'sizeinbytes': 6}) 3202 3203 def __delfield_dunno1(self): del self.__field_dunno1 3204 3205 dunno1=property(__getfield_dunno1, __setfield_dunno1, __delfield_dunno1, None) 3206 3207 def __getfield_body_len(self): 3208 return self.__field_body_len.getvalue() 3209 3210 def __setfield_body_len(self, value): 3211 if isinstance(value,UINT): 3212 self.__field_body_len=value 3213 else: 3214 self.__field_body_len=UINT(value,**{'sizeinbytes': 2}) 3215 3216 def __delfield_body_len(self): del self.__field_body_len 3217 3218 body_len=property(__getfield_body_len, __setfield_body_len, __delfield_body_len, None) 3219 3220 def __getfield_file_type(self): 3221 return self.__field_file_type.getvalue() 3222 3223 def __setfield_file_type(self, value): 3224 if isinstance(value,UINT): 3225 self.__field_file_type=value 3226 else: 3227 self.__field_file_type=UINT(value,**{'sizeinbytes': 2}) 3228 3229 def __delfield_file_type(self): del self.__field_file_type 3230 3231 file_type=property(__getfield_file_type, __setfield_file_type, __delfield_file_type, None) 3232 3233 def __getfield_msg_type(self): 3234 return self.__field_msg_type.getvalue() 3235 3236 def __setfield_msg_type(self, value): 3237 if isinstance(value,UINT): 3238 self.__field_msg_type=value 3239 else: 3240 self.__field_msg_type=UINT(value,**{'sizeinbytes': 1}) 3241 3242 def __delfield_msg_type(self): del self.__field_msg_type 3243 3244 msg_type=property(__getfield_msg_type, __setfield_msg_type, __delfield_msg_type, None) 3245 3246 def __getfield_enhance_delivery(self): 3247 return self.__field_enhance_delivery.getvalue() 3248 3249 def __setfield_enhance_delivery(self, value): 3250 if isinstance(value,UINT): 3251 self.__field_enhance_delivery=value 3252 else: 3253 self.__field_enhance_delivery=UINT(value,**{'sizeinbytes': 1}) 3254 3255 def __delfield_enhance_delivery(self): del self.__field_enhance_delivery 3256 3257 enhance_delivery=property(__getfield_enhance_delivery, __setfield_enhance_delivery, __delfield_enhance_delivery, None) 3258 3259 def __getfield_is_txt_msg(self): 3260 return self.__field_is_txt_msg.getvalue() 3261 3262 def __setfield_is_txt_msg(self, value): 3263 if isinstance(value,pBOOL): 3264 self.__field_is_txt_msg=value 3265 else: 3266 self.__field_is_txt_msg=pBOOL(value,**{ 'value': self.file_type==SMS_TXT_TYPE and self.msg_type in SMS_VALID_TYPE }) 3267 3268 def __delfield_is_txt_msg(self): del self.__field_is_txt_msg 3269 3270 is_txt_msg=property(__getfield_is_txt_msg, __setfield_is_txt_msg, __delfield_is_txt_msg, None) 3271 3272 def __getfield_in_msg(self): 3273 return self.__field_in_msg.getvalue() 3274 3275 def __setfield_in_msg(self, value): 3276 if isinstance(value,pBOOL): 3277 self.__field_in_msg=value 3278 else: 3279 self.__field_in_msg=pBOOL(value,**{ 'value': self.msg_type==SMS_TYPE_IN }) 3280 3281 def __delfield_in_msg(self): del self.__field_in_msg 3282 3283 in_msg=property(__getfield_in_msg, __setfield_in_msg, __delfield_in_msg, None) 3284 3285 def __getfield_sent_msg(self): 3286 return self.__field_sent_msg.getvalue() 3287 3288 def __setfield_sent_msg(self, value): 3289 if isinstance(value,pBOOL): 3290 self.__field_sent_msg=value 3291 else: 3292 self.__field_sent_msg=pBOOL(value,**{ 'value': self.msg_type==SMS_TYPE_SENT }) 3293 3294 def __delfield_sent_msg(self): del self.__field_sent_msg 3295 3296 sent_msg=property(__getfield_sent_msg, __setfield_sent_msg, __delfield_sent_msg, None) 3297 3298 def __getfield_draft_msg(self): 3299 return self.__field_draft_msg.getvalue() 3300 3301 def __setfield_draft_msg(self, value): 3302 if isinstance(value,pBOOL): 3303 self.__field_draft_msg=value 3304 else: 3305 self.__field_draft_msg=pBOOL(value,**{ 'value': self.msg_type==SMS_TYPE_DRAFT }) 3306 3307 def __delfield_draft_msg(self): del self.__field_draft_msg 3308 3309 draft_msg=property(__getfield_draft_msg, __setfield_draft_msg, __delfield_draft_msg, None) 3310 3311 def __getfield_body(self): 3312 return self.__field_body.getvalue() 3313 3314 def __setfield_body(self, value): 3315 if isinstance(value,sms_body): 3316 self.__field_body=value 3317 else: 3318 self.__field_body=sms_body(value,**{ 'msg_len': self.msg_len, 'has_callback': self.bitmap2 & SMS_FLG2_CALLBACK, 'has_priority': self.bitmap2 & SMS_FLG2_PRIORITY, 'has_1byte': self.bitmap2 & SMS_FLG2_SOMETHING, 'has_1byte2': self.bitmap2 & SMS_FLG2_MSG, 'has_40bytes': self.bitmap1 & SMS_FLG1_HAS40 }) 3319 3320 def __delfield_body(self): del self.__field_body 3321 3322 body=property(__getfield_body, __setfield_body, __delfield_body, None) 3323 3324 def iscontainer(self): 3325 return True 3326 3327 def containerelements(self): 3328 yield ('index', self.__field_index, None) 3329 yield ('msg_len', self.__field_msg_len, None) 3330 yield ('callback_len', self.__field_callback_len, None) 3331 yield ('bitmap1', self.__field_bitmap1, None) 3332 yield ('bitmap2', self.__field_bitmap2, None) 3333 yield ('dunno1', self.__field_dunno1, None) 3334 yield ('body_len', self.__field_body_len, None) 3335 yield ('file_type', self.__field_file_type, None) 3336 yield ('msg_type', self.__field_msg_type, None) 3337 yield ('enhance_delivery', self.__field_enhance_delivery, None) 3338 yield ('is_txt_msg', self.__field_is_txt_msg, None) 3339 yield ('in_msg', self.__field_in_msg, None) 3340 yield ('sent_msg', self.__field_sent_msg, None) 3341 yield ('draft_msg', self.__field_draft_msg, None) 3342 if self.is_txt_msg.value: 3343 yield ('body', self.__field_body, None) 3344 3345 3346 3347 3348 class sms_msg_stat_list(BaseProtogenClass): 3349 __fields=['status'] 3350 3351 def __init__(self, *args, **kwargs): 3352 dict={} 3353 # What was supplied to this function 3354 dict.update(kwargs) 3355 # Parent constructor 3356 super(sms_msg_stat_list,self).__init__(**dict) 3357 if self.__class__ is sms_msg_stat_list: 3358 self._update(args,dict) 3359 3360 3361 def getfields(self): 3362 return self.__fields 3363 3364 3365 def _update(self, args, kwargs): 3366 super(sms_msg_stat_list,self)._update(args,kwargs) 3367 keys=kwargs.keys() 3368 for key in keys: 3369 if key in self.__fields: 3370 setattr(self, key, kwargs[key]) 3371 del kwargs[key] 3372 # Were any unrecognized kwargs passed in? 3373 if __debug__: 3374 self._complainaboutunusedargs(sms_msg_stat_list,kwargs) 3375 if len(args): 3376 dict2={'sizeinbytes': 1} 3377 dict2.update(kwargs) 3378 kwargs=dict2 3379 self.__field_status=UINT(*args,**dict2) 3380 # Make all P fields that haven't already been constructed 3381 3382 3383 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 3384 'Writes this packet to the supplied buffer' 3385 self._bufferstartoffset=buf.getcurrentoffset() 3386 self.__field_status.writetobuffer(buf) 3387 self._bufferendoffset=buf.getcurrentoffset() 3388 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 3389 3390 3391 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 3392 'Reads this packet from the supplied buffer' 3393 self._bufferstartoffset=buf.getcurrentoffset() 3394 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 3395 self.__field_status=UINT(**{'sizeinbytes': 1}) 3396 self.__field_status.readfrombuffer(buf) 3397 self._bufferendoffset=buf.getcurrentoffset() 3398 3399 3400 def __getfield_status(self): 3401 return self.__field_status.getvalue() 3402 3403 def __setfield_status(self, value): 3404 if isinstance(value,UINT): 3405 self.__field_status=value 3406 else: 3407 self.__field_status=UINT(value,**{'sizeinbytes': 1}) 3408 3409 def __delfield_status(self): del self.__field_status 3410 3411 status=property(__getfield_status, __setfield_status, __delfield_status, None) 3412 3413 def iscontainer(self): 3414 return True 3415 3416 def containerelements(self): 3417 yield ('status', self.__field_status, None) 3418 3419 3420 3421 3422 class sms_datetime_list(BaseProtogenClass): 3423 __fields=['datetime', 'dunno'] 3424 3425 def __init__(self, *args, **kwargs): 3426 dict={} 3427 # What was supplied to this function 3428 dict.update(kwargs) 3429 # Parent constructor 3430 super(sms_datetime_list,self).__init__(**dict) 3431 if self.__class__ is sms_datetime_list: 3432 self._update(args,dict) 3433 3434 3435 def getfields(self): 3436 return self.__fields 3437 3438 3439 def _update(self, args, kwargs): 3440 super(sms_datetime_list,self)._update(args,kwargs) 3441 keys=kwargs.keys() 3442 for key in keys: 3443 if key in self.__fields: 3444 setattr(self, key, kwargs[key]) 3445 del kwargs[key] 3446 # Were any unrecognized kwargs passed in? 3447 if __debug__: 3448 self._complainaboutunusedargs(sms_datetime_list,kwargs) 3449 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 3450 # Make all P fields that haven't already been constructed 3451 3452 3453 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 3454 'Writes this packet to the supplied buffer' 3455 self._bufferstartoffset=buf.getcurrentoffset() 3456 self.__field_datetime.writetobuffer(buf) 3457 self.__field_dunno.writetobuffer(buf) 3458 self._bufferendoffset=buf.getcurrentoffset() 3459 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 3460 3461 3462 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 3463 'Reads this packet from the supplied buffer' 3464 self._bufferstartoffset=buf.getcurrentoffset() 3465 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 3466 self.__field_datetime=DateTime1(**{'sizeinbytes': 4}) 3467 self.__field_datetime.readfrombuffer(buf) 3468 self.__field_dunno=UNKNOWN(**{'sizeinbytes': 4}) 3469 self.__field_dunno.readfrombuffer(buf) 3470 self._bufferendoffset=buf.getcurrentoffset() 3471 3472 3473 def __getfield_datetime(self): 3474 return self.__field_datetime.getvalue() 3475 3476 def __setfield_datetime(self, value): 3477 if isinstance(value,DateTime1): 3478 self.__field_datetime=value 3479 else: 3480 self.__field_datetime=DateTime1(value,**{'sizeinbytes': 4}) 3481 3482 def __delfield_datetime(self): del self.__field_datetime 3483 3484 datetime=property(__getfield_datetime, __setfield_datetime, __delfield_datetime, None) 3485 3486 def __getfield_dunno(self): 3487 return self.__field_dunno.getvalue() 3488 3489 def __setfield_dunno(self, value): 3490 if isinstance(value,UNKNOWN): 3491 self.__field_dunno=value 3492 else: 3493 self.__field_dunno=UNKNOWN(value,**{'sizeinbytes': 4}) 3494 3495 def __delfield_dunno(self): del self.__field_dunno 3496 3497 dunno=property(__getfield_dunno, __setfield_dunno, __delfield_dunno, None) 3498 3499 def iscontainer(self): 3500 return True 3501 3502 def containerelements(self): 3503 yield ('datetime', self.__field_datetime, None) 3504 yield ('dunno', self.__field_dunno, None) 3505 3506 3507 3508 3509 class sms_delivered_datetime(BaseProtogenClass): 3510 __fields=['datetime', 'dunno'] 3511 3512 def __init__(self, *args, **kwargs): 3513 dict={} 3514 # What was supplied to this function 3515 dict.update(kwargs) 3516 # Parent constructor 3517 super(sms_delivered_datetime,self).__init__(**dict) 3518 if self.__class__ is sms_delivered_datetime: 3519 self._update(args,dict) 3520 3521 3522 def getfields(self): 3523 return self.__fields 3524 3525 3526 def _update(self, args, kwargs): 3527 super(sms_delivered_datetime,self)._update(args,kwargs) 3528 keys=kwargs.keys() 3529 for key in keys: 3530 if key in self.__fields: 3531 setattr(self, key, kwargs[key]) 3532 del kwargs[key] 3533 # Were any unrecognized kwargs passed in? 3534 if __debug__: 3535 self._complainaboutunusedargs(sms_delivered_datetime,kwargs) 3536 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 3537 # Make all P fields that haven't already been constructed 3538 3539 3540 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 3541 'Writes this packet to the supplied buffer' 3542 self._bufferstartoffset=buf.getcurrentoffset() 3543 self.__field_datetime.writetobuffer(buf) 3544 self.__field_dunno.writetobuffer(buf) 3545 self._bufferendoffset=buf.getcurrentoffset() 3546 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 3547 3548 3549 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 3550 'Reads this packet from the supplied buffer' 3551 self._bufferstartoffset=buf.getcurrentoffset() 3552 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 3553 self.__field_datetime=LIST(**{ 'elementclass': sms_datetime_list, 'length': 10 }) 3554 self.__field_datetime.readfrombuffer(buf) 3555 self.__field_dunno=UNKNOWN(**{'sizeinbytes': 20}) 3556 self.__field_dunno.readfrombuffer(buf) 3557 self._bufferendoffset=buf.getcurrentoffset() 3558 3559 3560 def __getfield_datetime(self): 3561 return self.__field_datetime.getvalue() 3562 3563 def __setfield_datetime(self, value): 3564 if isinstance(value,LIST): 3565 self.__field_datetime=value 3566 else: 3567 self.__field_datetime=LIST(value,**{ 'elementclass': sms_datetime_list, 'length': 10 }) 3568 3569 def __delfield_datetime(self): del self.__field_datetime 3570 3571 datetime=property(__getfield_datetime, __setfield_datetime, __delfield_datetime, None) 3572 3573 def __getfield_dunno(self): 3574 return self.__field_dunno.getvalue() 3575 3576 def __setfield_dunno(self, value): 3577 if isinstance(value,UNKNOWN): 3578 self.__field_dunno=value 3579 else: 3580 self.__field_dunno=UNKNOWN(value,**{'sizeinbytes': 20}) 3581 3582 def __delfield_dunno(self): del self.__field_dunno 3583 3584 dunno=property(__getfield_dunno, __setfield_dunno, __delfield_dunno, None) 3585 3586 def iscontainer(self): 3587 return True 3588 3589 def containerelements(self): 3590 yield ('datetime', self.__field_datetime, None) 3591 yield ('dunno', self.__field_dunno, None) 3592 3593 3594 3595 3596 class sms_body(BaseProtogenClass): 3597 __fields=['msg_len', 'has_callback', 'has_priority', 'has_1byte', 'has_1byte2', 'has_40bytes', 'dunno1', 'msg', 'dunno2', 'callback_len', 'callback', 'priority', 'dunno3', 'dunno4', 'datetime', 'dunno5', 'addr_len0', 'addr_len1', 'addr_len2', 'addr_len3', 'addr_len4', 'addr_len5', 'addr_len6', 'addr_len7', 'addr_len8', 'addr_len9', 'addr0', 'addr1', 'addr2', 'addr3', 'addr4', 'addr5', 'addr6', 'addr7', 'addr8', 'addr9', 'dunno6', 'dunno7', 'dunno8', 'dunno9', 'msg_stat'] 3598 3599 def __init__(self, *args, **kwargs): 3600 dict={} 3601 # What was supplied to this function 3602 dict.update(kwargs) 3603 # Parent constructor 3604 super(sms_body,self).__init__(**dict) 3605 if self.__class__ is sms_body: 3606 self._update(args,dict) 3607 3608 3609 def getfields(self): 3610 return self.__fields 3611 3612 3613 def _update(self, args, kwargs): 3614 super(sms_body,self)._update(args,kwargs) 3615 keys=kwargs.keys() 3616 for key in keys: 3617 if key in self.__fields: 3618 setattr(self, key, kwargs[key]) 3619 del kwargs[key] 3620 # Were any unrecognized kwargs passed in? 3621 if __debug__: 3622 self._complainaboutunusedargs(sms_body,kwargs) 3623 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 3624 # Make all P fields that haven't already been constructed 3625 try: self.__field_msg_len 3626 except: 3627 self.__field_msg_len=UINT() 3628 try: self.__field_has_callback 3629 except: 3630 self.__field_has_callback=BOOL(**{ 'default': True }) 3631 try: self.__field_has_priority 3632 except: 3633 self.__field_has_priority=BOOL(**{ 'default': False }) 3634 try: self.__field_has_1byte 3635 except: 3636 self.__field_has_1byte=BOOL(**{ 'default': False }) 3637 try: self.__field_has_1byte2 3638 except: 3639 self.__field_has_1byte2=BOOL(**{ 'default': True }) 3640 try: self.__field_has_40bytes 3641 except: 3642 self.__field_has_40bytes=BOOL(**{ 'default': False }) 3643 3644 3645 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 3646 'Writes this packet to the supplied buffer' 3647 self._bufferstartoffset=buf.getcurrentoffset() 3648 self.__field_dunno1.writetobuffer(buf) 3649 self.__field_msg.writetobuffer(buf) 3650 if self.has_callback: 3651 self.__field_dunno2.writetobuffer(buf) 3652 self.__field_callback_len.writetobuffer(buf) 3653 self.__field_callback.writetobuffer(buf) 3654 if self.has_priority: 3655 self.__field_priority.writetobuffer(buf) 3656 if self.has_1byte: 3657 self.__field_dunno3.writetobuffer(buf) 3658 self.__field_dunno4.writetobuffer(buf) 3659 self.__field_datetime.writetobuffer(buf) 3660 self.__field_dunno5.writetobuffer(buf) 3661 self.__field_addr_len0.writetobuffer(buf) 3662 self.__field_addr_len1.writetobuffer(buf) 3663 self.__field_addr_len2.writetobuffer(buf) 3664 self.__field_addr_len3.writetobuffer(buf) 3665 self.__field_addr_len4.writetobuffer(buf) 3666 self.__field_addr_len5.writetobuffer(buf) 3667 self.__field_addr_len6.writetobuffer(buf) 3668 self.__field_addr_len7.writetobuffer(buf) 3669 self.__field_addr_len8.writetobuffer(buf) 3670 self.__field_addr_len9.writetobuffer(buf) 3671 if self.addr_len0: 3672 self.__field_addr0.writetobuffer(buf) 3673 if self.addr_len1: 3674 self.__field_addr1.writetobuffer(buf) 3675 if self.addr_len2: 3676 self.__field_addr2.writetobuffer(buf) 3677 if self.addr_len3: 3678 self.__field_addr3.writetobuffer(buf) 3679 if self.addr_len4: 3680 self.__field_addr4.writetobuffer(buf) 3681 if self.addr_len5: 3682 self.__field_addr5.writetobuffer(buf) 3683 if self.addr_len6: 3684 self.__field_addr6.writetobuffer(buf) 3685 if self.addr_len7: 3686 self.__field_addr7.writetobuffer(buf) 3687 if self.addr_len8: 3688 self.__field_addr8.writetobuffer(buf) 3689 if self.addr_len9: 3690 self.__field_addr9.writetobuffer(buf) 3691 if not self.has_1byte and self.has_1byte2: 3692 self.__field_dunno6.writetobuffer(buf) 3693 if self.has_1byte2: 3694 self.__field_dunno7.writetobuffer(buf) 3695 self.__field_dunno8.writetobuffer(buf) 3696 if self.has_40bytes: 3697 self.__field_dunno9.writetobuffer(buf) 3698 self.__field_msg_stat.writetobuffer(buf) 3699 self._bufferendoffset=buf.getcurrentoffset() 3700 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 3701 3702 3703 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 3704 'Reads this packet from the supplied buffer' 3705 self._bufferstartoffset=buf.getcurrentoffset() 3706 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 3707 self.__field_dunno1=UNKNOWN(**{'sizeinbytes': 53}) 3708 self.__field_dunno1.readfrombuffer(buf) 3709 self.__field_msg=USTRING(**{ 'sizeinbytes': self.msg_len, 'encoding': ENCODING, 'terminator': None }) 3710 self.__field_msg.readfrombuffer(buf) 3711 if self.has_callback: 3712 self.__field_dunno2=UNKNOWN(**{'sizeinbytes': 3}) 3713 self.__field_dunno2.readfrombuffer(buf) 3714 self.__field_callback_len=UINT(**{'sizeinbytes': 1}) 3715 self.__field_callback_len.readfrombuffer(buf) 3716 self.__field_callback=STRING(**{ 'sizeinbytes': self.callback_len, 'terminator': None }) 3717 self.__field_callback.readfrombuffer(buf) 3718 if self.has_priority: 3719 self.__field_priority=UINT(**{'sizeinbytes': 1}) 3720 self.__field_priority.readfrombuffer(buf) 3721 if self.has_1byte: 3722 self.__field_dunno3=UNKNOWN(**{'sizeinbytes': 1}) 3723 self.__field_dunno3.readfrombuffer(buf) 3724 self.__field_dunno4=UNKNOWN(**{'sizeinbytes': 40}) 3725 self.__field_dunno4.readfrombuffer(buf) 3726 self.__field_datetime=DateTime1(**{'sizeinbytes': 4}) 3727 self.__field_datetime.readfrombuffer(buf) 3728 self.__field_dunno5=UNKNOWN(**{'sizeinbytes': 17}) 3729 self.__field_dunno5.readfrombuffer(buf) 3730 self.__field_addr_len0=UINT(**{'sizeinbytes': 1}) 3731 self.__field_addr_len0.readfrombuffer(buf) 3732 self.__field_addr_len1=UINT(**{'sizeinbytes': 1}) 3733 self.__field_addr_len1.readfrombuffer(buf) 3734 self.__field_addr_len2=UINT(**{'sizeinbytes': 1}) 3735 self.__field_addr_len2.readfrombuffer(buf) 3736 self.__field_addr_len3=UINT(**{'sizeinbytes': 1}) 3737 self.__field_addr_len3.readfrombuffer(buf) 3738 self.__field_addr_len4=UINT(**{'sizeinbytes': 1}) 3739 self.__field_addr_len4.readfrombuffer(buf) 3740 self.__field_addr_len5=UINT(**{'sizeinbytes': 1}) 3741 self.__field_addr_len5.readfrombuffer(buf) 3742 self.__field_addr_len6=UINT(**{'sizeinbytes': 1}) 3743 self.__field_addr_len6.readfrombuffer(buf) 3744 self.__field_addr_len7=UINT(**{'sizeinbytes': 1}) 3745 self.__field_addr_len7.readfrombuffer(buf) 3746 self.__field_addr_len8=UINT(**{'sizeinbytes': 1}) 3747 self.__field_addr_len8.readfrombuffer(buf) 3748 self.__field_addr_len9=UINT(**{'sizeinbytes': 1}) 3749 self.__field_addr_len9.readfrombuffer(buf) 3750 if self.addr_len0: 3751 self.__field_addr0=STRING(**{ 'sizeinbytes': self.addr_len0, 'terminator': None }) 3752 self.__field_addr0.readfrombuffer(buf) 3753 if self.addr_len1: 3754 self.__field_addr1=STRING(**{ 'sizeinbytes': self.addr_len1, 'terminator': None }) 3755 self.__field_addr1.readfrombuffer(buf) 3756 if self.addr_len2: 3757 self.__field_addr2=STRING(**{ 'sizeinbytes': self.addr_len2, 'terminator': None }) 3758 self.__field_addr2.readfrombuffer(buf) 3759 if self.addr_len3: 3760 self.__field_addr3=STRING(**{ 'sizeinbytes': self.addr_len3, 'terminator': None }) 3761 self.__field_addr3.readfrombuffer(buf) 3762 if self.addr_len4: 3763 self.__field_addr4=STRING(**{ 'sizeinbytes': self.addr_len4, 'terminator': None }) 3764 self.__field_addr4.readfrombuffer(buf) 3765 if self.addr_len5: 3766 self.__field_addr5=STRING(**{ 'sizeinbytes': self.addr_len5, 'terminator': None }) 3767 self.__field_addr5.readfrombuffer(buf) 3768 if self.addr_len6: 3769 self.__field_addr6=STRING(**{ 'sizeinbytes': self.addr_len6, 'terminator': None }) 3770 self.__field_addr6.readfrombuffer(buf) 3771 if self.addr_len7: 3772 self.__field_addr7=STRING(**{ 'sizeinbytes': self.addr_len7, 'terminator': None }) 3773 self.__field_addr7.readfrombuffer(buf) 3774 if self.addr_len8: 3775 self.__field_addr8=STRING(**{ 'sizeinbytes': self.addr_len8, 'terminator': None }) 3776 self.__field_addr8.readfrombuffer(buf) 3777 if self.addr_len9: 3778 self.__field_addr9=STRING(**{ 'sizeinbytes': self.addr_len9, 'terminator': None }) 3779 self.__field_addr9.readfrombuffer(buf) 3780 if not self.has_1byte and self.has_1byte2: 3781 self.__field_dunno6=UNKNOWN(**{'sizeinbytes': 1}) 3782 self.__field_dunno6.readfrombuffer(buf) 3783 if self.has_1byte2: 3784 self.__field_dunno7=UNKNOWN(**{'sizeinbytes': 1}) 3785 self.__field_dunno7.readfrombuffer(buf) 3786 self.__field_dunno8=UNKNOWN(**{'sizeinbytes': 81}) 3787 self.__field_dunno8.readfrombuffer(buf) 3788 if self.has_40bytes: 3789 self.__field_dunno9=UNKNOWN(**{'sizeinbytes': 40}) 3790 self.__field_dunno9.readfrombuffer(buf) 3791 self.__field_msg_stat=LIST(**{ 'elementclass': sms_msg_stat_list, 'length': 10 }) 3792 self.__field_msg_stat.readfrombuffer(buf) 3793 self._bufferendoffset=buf.getcurrentoffset() 3794 3795 3796 def __getfield_msg_len(self): 3797 return self.__field_msg_len.getvalue() 3798 3799 def __setfield_msg_len(self, value): 3800 if isinstance(value,UINT): 3801 self.__field_msg_len=value 3802 else: 3803 self.__field_msg_len=UINT(value,) 3804 3805 def __delfield_msg_len(self): del self.__field_msg_len 3806 3807 msg_len=property(__getfield_msg_len, __setfield_msg_len, __delfield_msg_len, None) 3808 3809 def __getfield_has_callback(self): 3810 try: self.__field_has_callback 3811 except: 3812 self.__field_has_callback=BOOL(**{ 'default': True }) 3813 return self.__field_has_callback.getvalue() 3814 3815 def __setfield_has_callback(self, value): 3816 if isinstance(value,BOOL): 3817 self.__field_has_callback=value 3818 else: 3819 self.__field_has_callback=BOOL(value,**{ 'default': True }) 3820 3821 def __delfield_has_callback(self): del self.__field_has_callback 3822 3823 has_callback=property(__getfield_has_callback, __setfield_has_callback, __delfield_has_callback, None) 3824 3825 def __getfield_has_priority(self): 3826 try: self.__field_has_priority 3827 except: 3828 self.__field_has_priority=BOOL(**{ 'default': False }) 3829 return self.__field_has_priority.getvalue() 3830 3831 def __setfield_has_priority(self, value): 3832 if isinstance(value,BOOL): 3833 self.__field_has_priority=value 3834 else: 3835 self.__field_has_priority=BOOL(value,**{ 'default': False }) 3836 3837 def __delfield_has_priority(self): del self.__field_has_priority 3838 3839 has_priority=property(__getfield_has_priority, __setfield_has_priority, __delfield_has_priority, None) 3840 3841 def __getfield_has_1byte(self): 3842 try: self.__field_has_1byte 3843 except: 3844 self.__field_has_1byte=BOOL(**{ 'default': False }) 3845 return self.__field_has_1byte.getvalue() 3846 3847 def __setfield_has_1byte(self, value): 3848 if isinstance(value,BOOL): 3849 self.__field_has_1byte=value 3850 else: 3851 self.__field_has_1byte=BOOL(value,**{ 'default': False }) 3852 3853 def __delfield_has_1byte(self): del self.__field_has_1byte 3854 3855 has_1byte=property(__getfield_has_1byte, __setfield_has_1byte, __delfield_has_1byte, None) 3856 3857 def __getfield_has_1byte2(self): 3858 try: self.__field_has_1byte2 3859 except: 3860 self.__field_has_1byte2=BOOL(**{ 'default': True }) 3861 return self.__field_has_1byte2.getvalue() 3862 3863 def __setfield_has_1byte2(self, value): 3864 if isinstance(value,BOOL): 3865 self.__field_has_1byte2=value 3866 else: 3867 self.__field_has_1byte2=BOOL(value,**{ 'default': True }) 3868 3869 def __delfield_has_1byte2(self): del self.__field_has_1byte2 3870 3871 has_1byte2=property(__getfield_has_1byte2, __setfield_has_1byte2, __delfield_has_1byte2, None) 3872 3873 def __getfield_has_40bytes(self): 3874 try: self.__field_has_40bytes 3875 except: 3876 self.__field_has_40bytes=BOOL(**{ 'default': False }) 3877 return self.__field_has_40bytes.getvalue() 3878 3879 def __setfield_has_40bytes(self, value): 3880 if isinstance(value,BOOL): 3881 self.__field_has_40bytes=value 3882 else: 3883 self.__field_has_40bytes=BOOL(value,**{ 'default': False }) 3884 3885 def __delfield_has_40bytes(self): del self.__field_has_40bytes 3886 3887 has_40bytes=property(__getfield_has_40bytes, __setfield_has_40bytes, __delfield_has_40bytes, None) 3888 3889 def __getfield_dunno1(self): 3890 return self.__field_dunno1.getvalue() 3891 3892 def __setfield_dunno1(self, value): 3893 if isinstance(value,UNKNOWN): 3894 self.__field_dunno1=value 3895 else: 3896 self.__field_dunno1=UNKNOWN(value,**{'sizeinbytes': 53}) 3897 3898 def __delfield_dunno1(self): del self.__field_dunno1 3899 3900 dunno1=property(__getfield_dunno1, __setfield_dunno1, __delfield_dunno1, None) 3901 3902 def __getfield_msg(self): 3903 return self.__field_msg.getvalue() 3904 3905 def __setfield_msg(self, value): 3906 if isinstance(value,USTRING): 3907 self.__field_msg=value 3908 else: 3909 self.__field_msg=USTRING(value,**{ 'sizeinbytes': self.msg_len, 'encoding': ENCODING, 'terminator': None }) 3910 3911 def __delfield_msg(self): del self.__field_msg 3912 3913 msg=property(__getfield_msg, __setfield_msg, __delfield_msg, None) 3914 3915 def __getfield_dunno2(self): 3916 return self.__field_dunno2.getvalue() 3917 3918 def __setfield_dunno2(self, value): 3919 if isinstance(value,UNKNOWN): 3920 self.__field_dunno2=value 3921 else: 3922 self.__field_dunno2=UNKNOWN(value,**{'sizeinbytes': 3}) 3923 3924 def __delfield_dunno2(self): del self.__field_dunno2 3925 3926 dunno2=property(__getfield_dunno2, __setfield_dunno2, __delfield_dunno2, None) 3927 3928 def __getfield_callback_len(self): 3929 return self.__field_callback_len.getvalue() 3930 3931 def __setfield_callback_len(self, value): 3932 if isinstance(value,UINT): 3933 self.__field_callback_len=value 3934 else: 3935 self.__field_callback_len=UINT(value,**{'sizeinbytes': 1}) 3936 3937 def __delfield_callback_len(self): del self.__field_callback_len 3938 3939 callback_len=property(__getfield_callback_len, __setfield_callback_len, __delfield_callback_len, None) 3940 3941 def __getfield_callback(self): 3942 return self.__field_callback.getvalue() 3943 3944 def __setfield_callback(self, value): 3945 if isinstance(value,STRING): 3946 self.__field_callback=value 3947 else: 3948 self.__field_callback=STRING(value,**{ 'sizeinbytes': self.callback_len, 'terminator': None }) 3949 3950 def __delfield_callback(self): del self.__field_callback 3951 3952 callback=property(__getfield_callback, __setfield_callback, __delfield_callback, None) 3953 3954 def __getfield_priority(self): 3955 return self.__field_priority.getvalue() 3956 3957 def __setfield_priority(self, value): 3958 if isinstance(value,UINT): 3959 self.__field_priority=value 3960 else: 3961 self.__field_priority=UINT(value,**{'sizeinbytes': 1}) 3962 3963 def __delfield_priority(self): del self.__field_priority 3964 3965 priority=property(__getfield_priority, __setfield_priority, __delfield_priority, None) 3966 3967 def __getfield_dunno3(self): 3968 return self.__field_dunno3.getvalue() 3969 3970 def __setfield_dunno3(self, value): 3971 if isinstance(value,UNKNOWN): 3972 self.__field_dunno3=value 3973 else: 3974 self.__field_dunno3=UNKNOWN(value,**{'sizeinbytes': 1}) 3975 3976 def __delfield_dunno3(self): del self.__field_dunno3 3977 3978 dunno3=property(__getfield_dunno3, __setfield_dunno3, __delfield_dunno3, None) 3979 3980 def __getfield_dunno4(self): 3981 return self.__field_dunno4.getvalue() 3982 3983 def __setfield_dunno4(self, value): 3984 if isinstance(value,UNKNOWN): 3985 self.__field_dunno4=value 3986 else: 3987 self.__field_dunno4=UNKNOWN(value,**{'sizeinbytes': 40}) 3988 3989 def __delfield_dunno4(self): del self.__field_dunno4 3990 3991 dunno4=property(__getfield_dunno4, __setfield_dunno4, __delfield_dunno4, None) 3992 3993 def __getfield_datetime(self): 3994 return self.__field_datetime.getvalue() 3995 3996 def __setfield_datetime(self, value): 3997 if isinstance(value,DateTime1): 3998 self.__field_datetime=value 3999 else: 4000 self.__field_datetime=DateTime1(value,**{'sizeinbytes': 4}) 4001 4002 def __delfield_datetime(self): del self.__field_datetime 4003 4004 datetime=property(__getfield_datetime, __setfield_datetime, __delfield_datetime, None) 4005 4006 def __getfield_dunno5(self): 4007 return self.__field_dunno5.getvalue() 4008 4009 def __setfield_dunno5(self, value): 4010 if isinstance(value,UNKNOWN): 4011 self.__field_dunno5=value 4012 else: 4013 self.__field_dunno5=UNKNOWN(value,**{'sizeinbytes': 17}) 4014 4015 def __delfield_dunno5(self): del self.__field_dunno5 4016 4017 dunno5=property(__getfield_dunno5, __setfield_dunno5, __delfield_dunno5, None) 4018 4019 def __getfield_addr_len0(self): 4020 return self.__field_addr_len0.getvalue() 4021 4022 def __setfield_addr_len0(self, value): 4023 if isinstance(value,UINT): 4024 self.__field_addr_len0=value 4025 else: 4026 self.__field_addr_len0=UINT(value,**{'sizeinbytes': 1}) 4027 4028 def __delfield_addr_len0(self): del self.__field_addr_len0 4029 4030 addr_len0=property(__getfield_addr_len0, __setfield_addr_len0, __delfield_addr_len0, None) 4031 4032 def __getfield_addr_len1(self): 4033 return self.__field_addr_len1.getvalue() 4034 4035 def __setfield_addr_len1(self, value): 4036 if isinstance(value,UINT): 4037 self.__field_addr_len1=value 4038 else: 4039 self.__field_addr_len1=UINT(value,**{'sizeinbytes': 1}) 4040 4041 def __delfield_addr_len1(self): del self.__field_addr_len1 4042 4043 addr_len1=property(__getfield_addr_len1, __setfield_addr_len1, __delfield_addr_len1, None) 4044 4045 def __getfield_addr_len2(self): 4046 return self.__field_addr_len2.getvalue() 4047 4048 def __setfield_addr_len2(self, value): 4049 if isinstance(value,UINT): 4050 self.__field_addr_len2=value 4051 else: 4052 self.__field_addr_len2=UINT(value,**{'sizeinbytes': 1}) 4053 4054 def __delfield_addr_len2(self): del self.__field_addr_len2 4055 4056 addr_len2=property(__getfield_addr_len2, __setfield_addr_len2, __delfield_addr_len2, None) 4057 4058 def __getfield_addr_len3(self): 4059 return self.__field_addr_len3.getvalue() 4060 4061 def __setfield_addr_len3(self, value): 4062 if isinstance(value,UINT): 4063 self.__field_addr_len3=value 4064 else: 4065 self.__field_addr_len3=UINT(value,**{'sizeinbytes': 1}) 4066 4067 def __delfield_addr_len3(self): del self.__field_addr_len3 4068 4069 addr_len3=property(__getfield_addr_len3, __setfield_addr_len3, __delfield_addr_len3, None) 4070 4071 def __getfield_addr_len4(self): 4072 return self.__field_addr_len4.getvalue() 4073 4074 def __setfield_addr_len4(self, value): 4075 if isinstance(value,UINT): 4076 self.__field_addr_len4=value 4077 else: 4078 self.__field_addr_len4=UINT(value,**{'sizeinbytes': 1}) 4079 4080 def __delfield_addr_len4(self): del self.__field_addr_len4 4081 4082 addr_len4=property(__getfield_addr_len4, __setfield_addr_len4, __delfield_addr_len4, None) 4083 4084 def __getfield_addr_len5(self): 4085 return self.__field_addr_len5.getvalue() 4086 4087 def __setfield_addr_len5(self, value): 4088 if isinstance(value,UINT): 4089 self.__field_addr_len5=value 4090 else: 4091 self.__field_addr_len5=UINT(value,**{'sizeinbytes': 1}) 4092 4093 def __delfield_addr_len5(self): del self.__field_addr_len5 4094 4095 addr_len5=property(__getfield_addr_len5, __setfield_addr_len5, __delfield_addr_len5, None) 4096 4097 def __getfield_addr_len6(self): 4098 return self.__field_addr_len6.getvalue() 4099 4100 def __setfield_addr_len6(self, value): 4101 if isinstance(value,UINT): 4102 self.__field_addr_len6=value 4103 else: 4104 self.__field_addr_len6=UINT(value,**{'sizeinbytes': 1}) 4105 4106 def __delfield_addr_len6(self): del self.__field_addr_len6 4107 4108 addr_len6=property(__getfield_addr_len6, __setfield_addr_len6, __delfield_addr_len6, None) 4109 4110 def __getfield_addr_len7(self): 4111 return self.__field_addr_len7.getvalue() 4112 4113 def __setfield_addr_len7(self, value): 4114 if isinstance(value,UINT): 4115 self.__field_addr_len7=value 4116 else: 4117 self.__field_addr_len7=UINT(value,**{'sizeinbytes': 1}) 4118 4119 def __delfield_addr_len7(self): del self.__field_addr_len7 4120 4121 addr_len7=property(__getfield_addr_len7, __setfield_addr_len7, __delfield_addr_len7, None) 4122 4123 def __getfield_addr_len8(self): 4124 return self.__field_addr_len8.getvalue() 4125 4126 def __setfield_addr_len8(self, value): 4127 if isinstance(value,UINT): 4128 self.__field_addr_len8=value 4129 else: 4130 self.__field_addr_len8=UINT(value,**{'sizeinbytes': 1}) 4131 4132 def __delfield_addr_len8(self): del self.__field_addr_len8 4133 4134 addr_len8=property(__getfield_addr_len8, __setfield_addr_len8, __delfield_addr_len8, None) 4135 4136 def __getfield_addr_len9(self): 4137 return self.__field_addr_len9.getvalue() 4138 4139 def __setfield_addr_len9(self, value): 4140 if isinstance(value,UINT): 4141 self.__field_addr_len9=value 4142 else: 4143 self.__field_addr_len9=UINT(value,**{'sizeinbytes': 1}) 4144 4145 def __delfield_addr_len9(self): del self.__field_addr_len9 4146 4147 addr_len9=property(__getfield_addr_len9, __setfield_addr_len9, __delfield_addr_len9, None) 4148 4149 def __getfield_addr0(self): 4150 return self.__field_addr0.getvalue() 4151 4152 def __setfield_addr0(self, value): 4153 if isinstance(value,STRING): 4154 self.__field_addr0=value 4155 else: 4156 self.__field_addr0=STRING(value,**{ 'sizeinbytes': self.addr_len0, 'terminator': None }) 4157 4158 def __delfield_addr0(self): del self.__field_addr0 4159 4160 addr0=property(__getfield_addr0, __setfield_addr0, __delfield_addr0, None) 4161 4162 def __getfield_addr1(self): 4163 return self.__field_addr1.getvalue() 4164 4165 def __setfield_addr1(self, value): 4166 if isinstance(value,STRING): 4167 self.__field_addr1=value 4168 else: 4169 self.__field_addr1=STRING(value,**{ 'sizeinbytes': self.addr_len1, 'terminator': None }) 4170 4171 def __delfield_addr1(self): del self.__field_addr1 4172 4173 addr1=property(__getfield_addr1, __setfield_addr1, __delfield_addr1, None) 4174 4175 def __getfield_addr2(self): 4176 return self.__field_addr2.getvalue() 4177 4178 def __setfield_addr2(self, value): 4179 if isinstance(value,STRING): 4180 self.__field_addr2=value 4181 else: 4182 self.__field_addr2=STRING(value,**{ 'sizeinbytes': self.addr_len2, 'terminator': None }) 4183 4184 def __delfield_addr2(self): del self.__field_addr2 4185 4186 addr2=property(__getfield_addr2, __setfield_addr2, __delfield_addr2, None) 4187 4188 def __getfield_addr3(self): 4189 return self.__field_addr3.getvalue() 4190 4191 def __setfield_addr3(self, value): 4192 if isinstance(value,STRING): 4193 self.__field_addr3=value 4194 else: 4195 self.__field_addr3=STRING(value,**{ 'sizeinbytes': self.addr_len3, 'terminator': None }) 4196 4197 def __delfield_addr3(self): del self.__field_addr3 4198 4199 addr3=property(__getfield_addr3, __setfield_addr3, __delfield_addr3, None) 4200 4201 def __getfield_addr4(self): 4202 return self.__field_addr4.getvalue() 4203 4204 def __setfield_addr4(self, value): 4205 if isinstance(value,STRING): 4206 self.__field_addr4=value 4207 else: 4208 self.__field_addr4=STRING(value,**{ 'sizeinbytes': self.addr_len4, 'terminator': None }) 4209 4210 def __delfield_addr4(self): del self.__field_addr4 4211 4212 addr4=property(__getfield_addr4, __setfield_addr4, __delfield_addr4, None) 4213 4214 def __getfield_addr5(self): 4215 return self.__field_addr5.getvalue() 4216 4217 def __setfield_addr5(self, value): 4218 if isinstance(value,STRING): 4219 self.__field_addr5=value 4220 else: 4221 self.__field_addr5=STRING(value,**{ 'sizeinbytes': self.addr_len5, 'terminator': None }) 4222 4223 def __delfield_addr5(self): del self.__field_addr5 4224 4225 addr5=property(__getfield_addr5, __setfield_addr5, __delfield_addr5, None) 4226 4227 def __getfield_addr6(self): 4228 return self.__field_addr6.getvalue() 4229 4230 def __setfield_addr6(self, value): 4231 if isinstance(value,STRING): 4232 self.__field_addr6=value 4233 else: 4234 self.__field_addr6=STRING(value,**{ 'sizeinbytes': self.addr_len6, 'terminator': None }) 4235 4236 def __delfield_addr6(self): del self.__field_addr6 4237 4238 addr6=property(__getfield_addr6, __setfield_addr6, __delfield_addr6, None) 4239 4240 def __getfield_addr7(self): 4241 return self.__field_addr7.getvalue() 4242 4243 def __setfield_addr7(self, value): 4244 if isinstance(value,STRING): 4245 self.__field_addr7=value 4246 else: 4247 self.__field_addr7=STRING(value,**{ 'sizeinbytes': self.addr_len7, 'terminator': None }) 4248 4249 def __delfield_addr7(self): del self.__field_addr7 4250 4251 addr7=property(__getfield_addr7, __setfield_addr7, __delfield_addr7, None) 4252 4253 def __getfield_addr8(self): 4254 return self.__field_addr8.getvalue() 4255 4256 def __setfield_addr8(self, value): 4257 if isinstance(value,STRING): 4258 self.__field_addr8=value 4259 else: 4260 self.__field_addr8=STRING(value,**{ 'sizeinbytes': self.addr_len8, 'terminator': None }) 4261 4262 def __delfield_addr8(self): del self.__field_addr8 4263 4264 addr8=property(__getfield_addr8, __setfield_addr8, __delfield_addr8, None) 4265 4266 def __getfield_addr9(self): 4267 return self.__field_addr9.getvalue() 4268 4269 def __setfield_addr9(self, value): 4270 if isinstance(value,STRING): 4271 self.__field_addr9=value 4272 else: 4273 self.__field_addr9=STRING(value,**{ 'sizeinbytes': self.addr_len9, 'terminator': None }) 4274 4275 def __delfield_addr9(self): del self.__field_addr9 4276 4277 addr9=property(__getfield_addr9, __setfield_addr9, __delfield_addr9, None) 4278 4279 def __getfield_dunno6(self): 4280 return self.__field_dunno6.getvalue() 4281 4282 def __setfield_dunno6(self, value): 4283 if isinstance(value,UNKNOWN): 4284 self.__field_dunno6=value 4285 else: 4286 self.__field_dunno6=UNKNOWN(value,**{'sizeinbytes': 1}) 4287 4288 def __delfield_dunno6(self): del self.__field_dunno6 4289 4290 dunno6=property(__getfield_dunno6, __setfield_dunno6, __delfield_dunno6, None) 4291 4292 def __getfield_dunno7(self): 4293 return self.__field_dunno7.getvalue() 4294 4295 def __setfield_dunno7(self, value): 4296 if isinstance(value,UNKNOWN): 4297 self.__field_dunno7=value 4298 else: 4299 self.__field_dunno7=UNKNOWN(value,**{'sizeinbytes': 1}) 4300 4301 def __delfield_dunno7(self): del self.__field_dunno7 4302 4303 dunno7=property(__getfield_dunno7, __setfield_dunno7, __delfield_dunno7, None) 4304 4305 def __getfield_dunno8(self): 4306 return self.__field_dunno8.getvalue() 4307 4308 def __setfield_dunno8(self, value): 4309 if isinstance(value,UNKNOWN): 4310 self.__field_dunno8=value 4311 else: 4312 self.__field_dunno8=UNKNOWN(value,**{'sizeinbytes': 81}) 4313 4314 def __delfield_dunno8(self): del self.__field_dunno8 4315 4316 dunno8=property(__getfield_dunno8, __setfield_dunno8, __delfield_dunno8, None) 4317 4318 def __getfield_dunno9(self): 4319 return self.__field_dunno9.getvalue() 4320 4321 def __setfield_dunno9(self, value): 4322 if isinstance(value,UNKNOWN): 4323 self.__field_dunno9=value 4324 else: 4325 self.__field_dunno9=UNKNOWN(value,**{'sizeinbytes': 40}) 4326 4327 def __delfield_dunno9(self): del self.__field_dunno9 4328 4329 dunno9=property(__getfield_dunno9, __setfield_dunno9, __delfield_dunno9, None) 4330 4331 def __getfield_msg_stat(self): 4332 return self.__field_msg_stat.getvalue() 4333 4334 def __setfield_msg_stat(self, value): 4335 if isinstance(value,LIST): 4336 self.__field_msg_stat=value 4337 else: 4338 self.__field_msg_stat=LIST(value,**{ 'elementclass': sms_msg_stat_list, 'length': 10 }) 4339 4340 def __delfield_msg_stat(self): del self.__field_msg_stat 4341 4342 msg_stat=property(__getfield_msg_stat, __setfield_msg_stat, __delfield_msg_stat, None) 4343 4344 def iscontainer(self): 4345 return True 4346 4347 def containerelements(self): 4348 yield ('msg_len', self.__field_msg_len, None) 4349 yield ('has_callback', self.__field_has_callback, None) 4350 yield ('has_priority', self.__field_has_priority, None) 4351 yield ('has_1byte', self.__field_has_1byte, None) 4352 yield ('has_1byte2', self.__field_has_1byte2, None) 4353 yield ('has_40bytes', self.__field_has_40bytes, None) 4354 yield ('dunno1', self.__field_dunno1, None) 4355 yield ('msg', self.__field_msg, None) 4356 if self.has_callback: 4357 yield ('dunno2', self.__field_dunno2, None) 4358 yield ('callback_len', self.__field_callback_len, None) 4359 yield ('callback', self.__field_callback, None) 4360 if self.has_priority: 4361 yield ('priority', self.__field_priority, None) 4362 if self.has_1byte: 4363 yield ('dunno3', self.__field_dunno3, None) 4364 yield ('dunno4', self.__field_dunno4, None) 4365 yield ('datetime', self.__field_datetime, None) 4366 yield ('dunno5', self.__field_dunno5, None) 4367 yield ('addr_len0', self.__field_addr_len0, None) 4368 yield ('addr_len1', self.__field_addr_len1, None) 4369 yield ('addr_len2', self.__field_addr_len2, None) 4370 yield ('addr_len3', self.__field_addr_len3, None) 4371 yield ('addr_len4', self.__field_addr_len4, None) 4372 yield ('addr_len5', self.__field_addr_len5, None) 4373 yield ('addr_len6', self.__field_addr_len6, None) 4374 yield ('addr_len7', self.__field_addr_len7, None) 4375 yield ('addr_len8', self.__field_addr_len8, None) 4376 yield ('addr_len9', self.__field_addr_len9, None) 4377 if self.addr_len0: 4378 yield ('addr0', self.__field_addr0, None) 4379 if self.addr_len1: 4380 yield ('addr1', self.__field_addr1, None) 4381 if self.addr_len2: 4382 yield ('addr2', self.__field_addr2, None) 4383 if self.addr_len3: 4384 yield ('addr3', self.__field_addr3, None) 4385 if self.addr_len4: 4386 yield ('addr4', self.__field_addr4, None) 4387 if self.addr_len5: 4388 yield ('addr5', self.__field_addr5, None) 4389 if self.addr_len6: 4390 yield ('addr6', self.__field_addr6, None) 4391 if self.addr_len7: 4392 yield ('addr7', self.__field_addr7, None) 4393 if self.addr_len8: 4394 yield ('addr8', self.__field_addr8, None) 4395 if self.addr_len9: 4396 yield ('addr9', self.__field_addr9, None) 4397 if not self.has_1byte and self.has_1byte2: 4398 yield ('dunno6', self.__field_dunno6, None) 4399 if self.has_1byte2: 4400 yield ('dunno7', self.__field_dunno7, None) 4401 yield ('dunno8', self.__field_dunno8, None) 4402 if self.has_40bytes: 4403 yield ('dunno9', self.__field_dunno9, None) 4404 yield ('msg_stat', self.__field_msg_stat, None) 4405 4406 4407 4408 4409 class cl_list(BaseProtogenClass): 4410 __fields=['index'] 4411 4412 def __init__(self, *args, **kwargs): 4413 dict={} 4414 # What was supplied to this function 4415 dict.update(kwargs) 4416 # Parent constructor 4417 super(cl_list,self).__init__(**dict) 4418 if self.__class__ is cl_list: 4419 self._update(args,dict) 4420 4421 4422 def getfields(self): 4423 return self.__fields 4424 4425 4426 def _update(self, args, kwargs): 4427 super(cl_list,self)._update(args,kwargs) 4428 keys=kwargs.keys() 4429 for key in keys: 4430 if key in self.__fields: 4431 setattr(self, key, kwargs[key]) 4432 del kwargs[key] 4433 # Were any unrecognized kwargs passed in? 4434 if __debug__: 4435 self._complainaboutunusedargs(cl_list,kwargs) 4436 if len(args): 4437 dict2={'sizeinbytes': 2} 4438 dict2.update(kwargs) 4439 kwargs=dict2 4440 self.__field_index=UINT(*args,**dict2) 4441 # Make all P fields that haven't already been constructed 4442 4443 4444 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 4445 'Writes this packet to the supplied buffer' 4446 self._bufferstartoffset=buf.getcurrentoffset() 4447 self.__field_index.writetobuffer(buf) 4448 self._bufferendoffset=buf.getcurrentoffset() 4449 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 4450 4451 4452 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 4453 'Reads this packet from the supplied buffer' 4454 self._bufferstartoffset=buf.getcurrentoffset() 4455 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 4456 self.__field_index=UINT(**{'sizeinbytes': 2}) 4457 self.__field_index.readfrombuffer(buf) 4458 self._bufferendoffset=buf.getcurrentoffset() 4459 4460 4461 def __getfield_index(self): 4462 return self.__field_index.getvalue() 4463 4464 def __setfield_index(self, value): 4465 if isinstance(value,UINT): 4466 self.__field_index=value 4467 else: 4468 self.__field_index=UINT(value,**{'sizeinbytes': 2}) 4469 4470 def __delfield_index(self): del self.__field_index 4471 4472 index=property(__getfield_index, __setfield_index, __delfield_index, None) 4473 4474 def iscontainer(self): 4475 return True 4476 4477 def containerelements(self): 4478 yield ('index', self.__field_index, None) 4479 4480 4481 4482 4483 class cl_index_file(BaseProtogenClass): 4484 __fields=['incoming', 'outgoing', 'missed', 'dunno1', 'incoming_count', 'outgoing_count', 'missed_count'] 4485 4486 def __init__(self, *args, **kwargs): 4487 dict={} 4488 # What was supplied to this function 4489 dict.update(kwargs) 4490 # Parent constructor 4491 super(cl_index_file,self).__init__(**dict) 4492 if self.__class__ is cl_index_file: 4493 self._update(args,dict) 4494 4495 4496 def getfields(self): 4497 return self.__fields 4498 4499 4500 def _update(self, args, kwargs): 4501 super(cl_index_file,self)._update(args,kwargs) 4502 keys=kwargs.keys() 4503 for key in keys: 4504 if key in self.__fields: 4505 setattr(self, key, kwargs[key]) 4506 del kwargs[key] 4507 # Were any unrecognized kwargs passed in? 4508 if __debug__: 4509 self._complainaboutunusedargs(cl_index_file,kwargs) 4510 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 4511 # Make all P fields that haven't already been constructed 4512 4513 4514 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 4515 'Writes this packet to the supplied buffer' 4516 self._bufferstartoffset=buf.getcurrentoffset() 4517 self.__field_incoming.writetobuffer(buf) 4518 self.__field_outgoing.writetobuffer(buf) 4519 self.__field_missed.writetobuffer(buf) 4520 self.__field_dunno1.writetobuffer(buf) 4521 self.__field_incoming_count.writetobuffer(buf) 4522 self.__field_outgoing_count.writetobuffer(buf) 4523 self.__field_missed_count.writetobuffer(buf) 4524 self._bufferendoffset=buf.getcurrentoffset() 4525 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 4526 4527 4528 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 4529 'Reads this packet from the supplied buffer' 4530 self._bufferstartoffset=buf.getcurrentoffset() 4531 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 4532 self.__field_incoming=LIST(**{ 'length': CL_MAX_ENTRIES, 'elementclass': cl_list }) 4533 self.__field_incoming.readfrombuffer(buf) 4534 self.__field_outgoing=LIST(**{ 'length': CL_MAX_ENTRIES, 'elementclass': cl_list }) 4535 self.__field_outgoing.readfrombuffer(buf) 4536 self.__field_missed=LIST(**{ 'length': CL_MAX_ENTRIES, 'elementclass': cl_list }) 4537 self.__field_missed.readfrombuffer(buf) 4538 self.__field_dunno1=UNKNOWN(**{'sizeinbytes': 992}) 4539 self.__field_dunno1.readfrombuffer(buf) 4540 self.__field_incoming_count=UINT(**{'sizeinbytes': 4}) 4541 self.__field_incoming_count.readfrombuffer(buf) 4542 self.__field_outgoing_count=UINT(**{'sizeinbytes': 4}) 4543 self.__field_outgoing_count.readfrombuffer(buf) 4544 self.__field_missed_count=UINT(**{'sizeinbytes': 4}) 4545 self.__field_missed_count.readfrombuffer(buf) 4546 self._bufferendoffset=buf.getcurrentoffset() 4547 4548 4549 def __getfield_incoming(self): 4550 return self.__field_incoming.getvalue() 4551 4552 def __setfield_incoming(self, value): 4553 if isinstance(value,LIST): 4554 self.__field_incoming=value 4555 else: 4556 self.__field_incoming=LIST(value,**{ 'length': CL_MAX_ENTRIES, 'elementclass': cl_list }) 4557 4558 def __delfield_incoming(self): del self.__field_incoming 4559 4560 incoming=property(__getfield_incoming, __setfield_incoming, __delfield_incoming, None) 4561 4562 def __getfield_outgoing(self): 4563 return self.__field_outgoing.getvalue() 4564 4565 def __setfield_outgoing(self, value): 4566 if isinstance(value,LIST): 4567 self.__field_outgoing=value 4568 else: 4569 self.__field_outgoing=LIST(value,**{ 'length': CL_MAX_ENTRIES, 'elementclass': cl_list }) 4570 4571 def __delfield_outgoing(self): del self.__field_outgoing 4572 4573 outgoing=property(__getfield_outgoing, __setfield_outgoing, __delfield_outgoing, None) 4574 4575 def __getfield_missed(self): 4576 return self.__field_missed.getvalue() 4577 4578 def __setfield_missed(self, value): 4579 if isinstance(value,LIST): 4580 self.__field_missed=value 4581 else: 4582 self.__field_missed=LIST(value,**{ 'length': CL_MAX_ENTRIES, 'elementclass': cl_list }) 4583 4584 def __delfield_missed(self): del self.__field_missed 4585 4586 missed=property(__getfield_missed, __setfield_missed, __delfield_missed, None) 4587 4588 def __getfield_dunno1(self): 4589 return self.__field_dunno1.getvalue() 4590 4591 def __setfield_dunno1(self, value): 4592 if isinstance(value,UNKNOWN): 4593 self.__field_dunno1=value 4594 else: 4595 self.__field_dunno1=UNKNOWN(value,**{'sizeinbytes': 992}) 4596 4597 def __delfield_dunno1(self): del self.__field_dunno1 4598 4599 dunno1=property(__getfield_dunno1, __setfield_dunno1, __delfield_dunno1, None) 4600 4601 def __getfield_incoming_count(self): 4602 return self.__field_incoming_count.getvalue() 4603 4604 def __setfield_incoming_count(self, value): 4605 if isinstance(value,UINT): 4606 self.__field_incoming_count=value 4607 else: 4608 self.__field_incoming_count=UINT(value,**{'sizeinbytes': 4}) 4609 4610 def __delfield_incoming_count(self): del self.__field_incoming_count 4611 4612 incoming_count=property(__getfield_incoming_count, __setfield_incoming_count, __delfield_incoming_count, None) 4613 4614 def __getfield_outgoing_count(self): 4615 return self.__field_outgoing_count.getvalue() 4616 4617 def __setfield_outgoing_count(self, value): 4618 if isinstance(value,UINT): 4619 self.__field_outgoing_count=value 4620 else: 4621 self.__field_outgoing_count=UINT(value,**{'sizeinbytes': 4}) 4622 4623 def __delfield_outgoing_count(self): del self.__field_outgoing_count 4624 4625 outgoing_count=property(__getfield_outgoing_count, __setfield_outgoing_count, __delfield_outgoing_count, None) 4626 4627 def __getfield_missed_count(self): 4628 return self.__field_missed_count.getvalue() 4629 4630 def __setfield_missed_count(self, value): 4631 if isinstance(value,UINT): 4632 self.__field_missed_count=value 4633 else: 4634 self.__field_missed_count=UINT(value,**{'sizeinbytes': 4}) 4635 4636 def __delfield_missed_count(self): del self.__field_missed_count 4637 4638 missed_count=property(__getfield_missed_count, __setfield_missed_count, __delfield_missed_count, None) 4639 4640 def iscontainer(self): 4641 return True 4642 4643 def containerelements(self): 4644 yield ('incoming', self.__field_incoming, None) 4645 yield ('outgoing', self.__field_outgoing, None) 4646 yield ('missed', self.__field_missed, None) 4647 yield ('dunno1', self.__field_dunno1, None) 4648 yield ('incoming_count', self.__field_incoming_count, None) 4649 yield ('outgoing_count', self.__field_outgoing_count, None) 4650 yield ('missed_count', self.__field_missed_count, None) 4651 4652 4653 4654 4655 class cl_file(BaseProtogenClass): 4656 __fields=['cl_type', 'number', 'datetime', 'dunno1', 'duration'] 4657 4658 def __init__(self, *args, **kwargs): 4659 dict={} 4660 # What was supplied to this function 4661 dict.update(kwargs) 4662 # Parent constructor 4663 super(cl_file,self).__init__(**dict) 4664 if self.__class__ is cl_file: 4665 self._update(args,dict) 4666 4667 4668 def getfields(self): 4669 return self.__fields 4670 4671 4672 def _update(self, args, kwargs): 4673 super(cl_file,self)._update(args,kwargs) 4674 keys=kwargs.keys() 4675 for key in keys: 4676 if key in self.__fields: 4677 setattr(self, key, kwargs[key]) 4678 del kwargs[key] 4679 # Were any unrecognized kwargs passed in? 4680 if __debug__: 4681 self._complainaboutunusedargs(cl_file,kwargs) 4682 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 4683 # Make all P fields that haven't already been constructed 4684 4685 4686 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 4687 'Writes this packet to the supplied buffer' 4688 self._bufferstartoffset=buf.getcurrentoffset() 4689 self.__field_cl_type.writetobuffer(buf) 4690 self.__field_number.writetobuffer(buf) 4691 self.__field_datetime.writetobuffer(buf) 4692 self.__field_dunno1.writetobuffer(buf) 4693 self.__field_duration.writetobuffer(buf) 4694 self._bufferendoffset=buf.getcurrentoffset() 4695 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 4696 4697 4698 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 4699 'Reads this packet from the supplied buffer' 4700 self._bufferstartoffset=buf.getcurrentoffset() 4701 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 4702 self.__field_cl_type=UINT(**{'sizeinbytes': 1}) 4703 self.__field_cl_type.readfrombuffer(buf) 4704 self.__field_number=STRING(**{'sizeinbytes': 51, 'terminator': 0 }) 4705 self.__field_number.readfrombuffer(buf) 4706 self.__field_datetime=DateTime1(**{'sizeinbytes': 4}) 4707 self.__field_datetime.readfrombuffer(buf) 4708 self.__field_dunno1=UNKNOWN(**{'sizeinbytes': 4}) 4709 self.__field_dunno1.readfrombuffer(buf) 4710 self.__field_duration=UINT(**{'sizeinbytes': 4}) 4711 self.__field_duration.readfrombuffer(buf) 4712 self._bufferendoffset=buf.getcurrentoffset() 4713 4714 4715 def __getfield_cl_type(self): 4716 return self.__field_cl_type.getvalue() 4717 4718 def __setfield_cl_type(self, value): 4719 if isinstance(value,UINT): 4720 self.__field_cl_type=value 4721 else: 4722 self.__field_cl_type=UINT(value,**{'sizeinbytes': 1}) 4723 4724 def __delfield_cl_type(self): del self.__field_cl_type 4725 4726 cl_type=property(__getfield_cl_type, __setfield_cl_type, __delfield_cl_type, None) 4727 4728 def __getfield_number(self): 4729 return self.__field_number.getvalue() 4730 4731 def __setfield_number(self, value): 4732 if isinstance(value,STRING): 4733 self.__field_number=value 4734 else: 4735 self.__field_number=STRING(value,**{'sizeinbytes': 51, 'terminator': 0 }) 4736 4737 def __delfield_number(self): del self.__field_number 4738 4739 number=property(__getfield_number, __setfield_number, __delfield_number, None) 4740 4741 def __getfield_datetime(self): 4742 return self.__field_datetime.getvalue() 4743 4744 def __setfield_datetime(self, value): 4745 if isinstance(value,DateTime1): 4746 self.__field_datetime=value 4747 else: 4748 self.__field_datetime=DateTime1(value,**{'sizeinbytes': 4}) 4749 4750 def __delfield_datetime(self): del self.__field_datetime 4751 4752 datetime=property(__getfield_datetime, __setfield_datetime, __delfield_datetime, None) 4753 4754 def __getfield_dunno1(self): 4755 return self.__field_dunno1.getvalue() 4756 4757 def __setfield_dunno1(self, value): 4758 if isinstance(value,UNKNOWN): 4759 self.__field_dunno1=value 4760 else: 4761 self.__field_dunno1=UNKNOWN(value,**{'sizeinbytes': 4}) 4762 4763 def __delfield_dunno1(self): del self.__field_dunno1 4764 4765 dunno1=property(__getfield_dunno1, __setfield_dunno1, __delfield_dunno1, None) 4766 4767 def __getfield_duration(self): 4768 return self.__field_duration.getvalue() 4769 4770 def __setfield_duration(self, value): 4771 if isinstance(value,UINT): 4772 self.__field_duration=value 4773 else: 4774 self.__field_duration=UINT(value,**{'sizeinbytes': 4}) 4775 4776 def __delfield_duration(self): del self.__field_duration 4777 4778 duration=property(__getfield_duration, __setfield_duration, __delfield_duration, None) 4779 4780 def iscontainer(self): 4781 return True 4782 4783 def containerelements(self): 4784 yield ('cl_type', self.__field_cl_type, None) 4785 yield ('number', self.__field_number, None) 4786 yield ('datetime', self.__field_datetime, None) 4787 yield ('dunno1', self.__field_dunno1, None) 4788 yield ('duration', self.__field_duration, None) 4789 4790 def _valid(self): 4791 global CL_VALID_TYPE 4792 return bool(self.cl_type in CL_VALID_TYPE and self.number) 4793 valid=property(fget=_valid) 4794 4795 4796 4797 4798
Generated by PyXR 0.9.4