Source Code for Module phones.p_lgvx5200

   1  # THIS FILE IS AUTOMATICALLY GENERATED.  EDIT THE SOURCE FILE NOT THIS ONE 
   2   
   3  """Various descriptions of data specific to LG VX5200""" 
   4   
   5  from common import PhoneBookBusyException 
   6   
   7  from prototypes import * 
   8   
   9  # Make all lg stuff available in this module as well 
  10  from p_lg import * 
  11   
  12  # we are the same as lgvx8100 except as noted 
  13  # below 
  14  from p_lgvx8100 import * 
  15   
  16  # We use LSB for all integer like fields 
  17  UINT=UINTlsb 
  18  BOOL=BOOLlsb 
  19   
  20  BREW_FILE_SYSTEM=0 
  21   
  22  PHONE_ENCODING='iso8859_1' 
  23   
  24  # need to call stat to get the file time/data 
  25  broken_filelist_date=True 
  26 -class indexentry(BaseProtogenClass): 
  27      __fields=['index', 'type', 'filename', 'icon', 'date', 'dunno'] 
  28   
  29 -    def __init__(self, *args, **kwargs): 
  30          dict={} 
  31          # What was supplied to this function 
  32          dict.update(kwargs) 
  33          # Parent constructor 
  34          super(indexentry,self).__init__(**dict) 
  35          if self.__class__ is indexentry: 
  36              self._update(args,dict) 
  37   
  38   
  39 -    def getfields(self): 
  40          return self.__fields 
  41   
  42   
  43 -    def _update(self, args, kwargs): 
  44          super(indexentry,self)._update(args,kwargs) 
  45          keys=kwargs.keys() 
  46          for key in keys: 
  47              if key in self.__fields: 
  48                  setattr(self, key, kwargs[key]) 
  49                  del kwargs[key] 
  50          # Were any unrecognized kwargs passed in? 
  51          if __debug__: 
  52              self._complainaboutunusedargs(indexentry,kwargs) 
  53          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
  54          # Make all P fields that haven't already been constructed 
  55   
  56   
  57 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
  58          'Writes this packet to the supplied buffer' 
  59          self._bufferstartoffset=buf.getcurrentoffset() 
  60          self.__field_index.writetobuffer(buf) 
  61          self.__field_type.writetobuffer(buf) 
  62          self.__field_filename.writetobuffer(buf) 
  63          try: self.__field_icon 
  64          except: 
  65              self.__field_icon=UINT(**{'sizeinbytes': 4, 'default':0}) 
  66          self.__field_icon.writetobuffer(buf) 
  67          try: self.__field_date 
  68          except: 
  69              self.__field_date=UINT(**{'sizeinbytes': 4, 'default': 0}) 
  70          self.__field_date.writetobuffer(buf) 
  71          self.__field_dunno.writetobuffer(buf) 
  72          self._bufferendoffset=buf.getcurrentoffset() 
  73          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
  74   
  75   
  76 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
  77          'Reads this packet from the supplied buffer' 
  78          self._bufferstartoffset=buf.getcurrentoffset() 
  79          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
  80          self.__field_index=UINT(**{'sizeinbytes': 2}) 
  81          self.__field_index.readfrombuffer(buf) 
  82          self.__field_type=UINT(**{'sizeinbytes': 2}) 
  83          self.__field_type.readfrombuffer(buf) 
  84          self.__field_filename=USTRING(**{'sizeinbytes': 60, 'raiseonunterminatedread': False, 'raiseontruncate': False }) 
  85          self.__field_filename.readfrombuffer(buf) 
  86          self.__field_icon=UINT(**{'sizeinbytes': 4, 'default':0}) 
  87          self.__field_icon.readfrombuffer(buf) 
  88          self.__field_date=UINT(**{'sizeinbytes': 4, 'default': 0}) 
  89          self.__field_date.readfrombuffer(buf) 
  90          self.__field_dunno=UINT(**{'sizeinbytes': 4}) 
  91          self.__field_dunno.readfrombuffer(buf) 
  92          self._bufferendoffset=buf.getcurrentoffset() 
  93   
  94   
  95 -    def __getfield_index(self): 
  96          return self.__field_index.getvalue() 
  97   
  98 -    def __setfield_index(self, value): 
  99          if isinstance(value,UINT): 
 100              self.__field_index=value 
 101          else: 
 102              self.__field_index=UINT(value,**{'sizeinbytes': 2}) 
 103   
 104 -    def __delfield_index(self): del self.__field_index 
 105   
 106      index=property(__getfield_index, __setfield_index, __delfield_index, None) 
 107   
 108 -    def __getfield_type(self): 
 109          return self.__field_type.getvalue() 
 110   
 111 -    def __setfield_type(self, value): 
 112          if isinstance(value,UINT): 
 113              self.__field_type=value 
 114          else: 
 115              self.__field_type=UINT(value,**{'sizeinbytes': 2}) 
 116   
 117 -    def __delfield_type(self): del self.__field_type 
 118   
 119      type=property(__getfield_type, __setfield_type, __delfield_type, None) 
 120   
 121 -    def __getfield_filename(self): 
 122          return self.__field_filename.getvalue() 
 123   
 124 -    def __setfield_filename(self, value): 
 125          if isinstance(value,USTRING): 
 126              self.__field_filename=value 
 127          else: 
 128              self.__field_filename=USTRING(value,**{'sizeinbytes': 60, 'raiseonunterminatedread': False, 'raiseontruncate': False }) 
 129   
 130 -    def __delfield_filename(self): del self.__field_filename 
 131   
 132      filename=property(__getfield_filename, __setfield_filename, __delfield_filename, "includes full pathname") 
 133   
 134 -    def __getfield_icon(self): 
 135          try: self.__field_icon 
 136          except: 
 137              self.__field_icon=UINT(**{'sizeinbytes': 4, 'default':0}) 
 138          return self.__field_icon.getvalue() 
 139   
 140 -    def __setfield_icon(self, value): 
 141          if isinstance(value,UINT): 
 142              self.__field_icon=value 
 143          else: 
 144              self.__field_icon=UINT(value,**{'sizeinbytes': 4, 'default':0}) 
 145   
 146 -    def __delfield_icon(self): del self.__field_icon 
 147   
 148      icon=property(__getfield_icon, __setfield_icon, __delfield_icon, None) 
 149   
 150 -    def __getfield_date(self): 
 151          try: self.__field_date 
 152          except: 
 153              self.__field_date=UINT(**{'sizeinbytes': 4, 'default': 0}) 
 154          return self.__field_date.getvalue() 
 155   
 156 -    def __setfield_date(self, value): 
 157          if isinstance(value,UINT): 
 158              self.__field_date=value 
 159          else: 
 160              self.__field_date=UINT(value,**{'sizeinbytes': 4, 'default': 0}) 
 161   
 162 -    def __delfield_date(self): del self.__field_date 
 163   
 164      date=property(__getfield_date, __setfield_date, __delfield_date, "i think this is bitfield of the date") 
 165   
 166 -    def __getfield_dunno(self): 
 167          return self.__field_dunno.getvalue() 
 168   
 169 -    def __setfield_dunno(self, value): 
 170          if isinstance(value,UINT): 
 171              self.__field_dunno=value 
 172          else: 
 173              self.__field_dunno=UINT(value,**{'sizeinbytes': 4}) 
 174   
 175 -    def __delfield_dunno(self): del self.__field_dunno 
 176   
 177      dunno=property(__getfield_dunno, __setfield_dunno, __delfield_dunno, None) 
 178   
 179 -    def iscontainer(self): 
 180          return True 
 181   
 182 -    def containerelements(self): 
 183          yield ('index', self.__field_index, None) 
 184          yield ('type', self.__field_type, None) 
 185          yield ('filename', self.__field_filename, "includes full pathname") 
 186          yield ('icon', self.__field_icon, None) 
 187          yield ('date', self.__field_date, "i think this is bitfield of the date") 
 188          yield ('dunno', self.__field_dunno, None) 
 189   
 190   
 191   
 192   
 193 -class indexfile(BaseProtogenClass): 
 194      "Used for tracking wallpaper and ringtones" 
 195      __fields=['items'] 
 196   
 197 -    def __init__(self, *args, **kwargs): 
 198          dict={} 
 199          # What was supplied to this function 
 200          dict.update(kwargs) 
 201          # Parent constructor 
 202          super(indexfile,self).__init__(**dict) 
 203          if self.__class__ is indexfile: 
 204              self._update(args,dict) 
 205   
 206   
 207 -    def getfields(self): 
 208          return self.__fields 
 209   
 210   
 211 -    def _update(self, args, kwargs): 
 212          super(indexfile,self)._update(args,kwargs) 
 213          keys=kwargs.keys() 
 214          for key in keys: 
 215              if key in self.__fields: 
 216                  setattr(self, key, kwargs[key]) 
 217                  del kwargs[key] 
 218          # Were any unrecognized kwargs passed in? 
 219          if __debug__: 
 220              self._complainaboutunusedargs(indexfile,kwargs) 
 221          if len(args): 
 222              dict2={'elementclass': indexentry, 'createdefault': True} 
 223              dict2.update(kwargs) 
 224              kwargs=dict2 
 225              self.__field_items=LIST(*args,**dict2) 
 226          # Make all P fields that haven't already been constructed 
 227   
 228   
 229 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
 230          'Writes this packet to the supplied buffer' 
 231          self._bufferstartoffset=buf.getcurrentoffset() 
 232          try: self.__field_items 
 233          except: 
 234              self.__field_items=LIST(**{'elementclass': indexentry, 'createdefault': True}) 
 235          self.__field_items.writetobuffer(buf) 
 236          self._bufferendoffset=buf.getcurrentoffset() 
 237          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
 238   
 239   
 240 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
 241          'Reads this packet from the supplied buffer' 
 242          self._bufferstartoffset=buf.getcurrentoffset() 
 243          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
 244          self.__field_items=LIST(**{'elementclass': indexentry, 'createdefault': True}) 
 245          self.__field_items.readfrombuffer(buf) 
 246          self._bufferendoffset=buf.getcurrentoffset() 
 247   
 248   
 249 -    def __getfield_items(self): 
 250          try: self.__field_items 
 251          except: 
 252              self.__field_items=LIST(**{'elementclass': indexentry, 'createdefault': True}) 
 253          return self.__field_items.getvalue() 
 254   
 255 -    def __setfield_items(self, value): 
 256          if isinstance(value,LIST): 
 257              self.__field_items=value 
 258          else: 
 259              self.__field_items=LIST(value,**{'elementclass': indexentry, 'createdefault': True}) 
 260   
 261 -    def __delfield_items(self): del self.__field_items 
 262   
 263      items=property(__getfield_items, __setfield_items, __delfield_items, None) 
 264   
 265 -    def iscontainer(self): 
 266          return True 
 267   
 268 -    def containerelements(self): 
 269          yield ('items', self.__field_items, None) 
 270   
 271   
 272   
 273   
 274 -class msg_record(BaseProtogenClass): 
 275      __fields=['unknown1', 'binary', 'unknown3', 'unknown4', 'unknown6', 'length', 'msg'] 
 276   
 277 -    def __init__(self, *args, **kwargs): 
 278          dict={} 
 279          # What was supplied to this function 
 280          dict.update(kwargs) 
 281          # Parent constructor 
 282          super(msg_record,self).__init__(**dict) 
 283          if self.__class__ is msg_record: 
 284              self._update(args,dict) 
 285   
 286   
 287 -    def getfields(self): 
 288          return self.__fields 
 289   
 290   
 291 -    def _update(self, args, kwargs): 
 292          super(msg_record,self)._update(args,kwargs) 
 293          keys=kwargs.keys() 
 294          for key in keys: 
 295              if key in self.__fields: 
 296                  setattr(self, key, kwargs[key]) 
 297                  del kwargs[key] 
 298          # Were any unrecognized kwargs passed in? 
 299          if __debug__: 
 300              self._complainaboutunusedargs(msg_record,kwargs) 
 301          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
 302          # Make all P fields that haven't already been constructed 
 303   
 304   
 305 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
 306          'Writes this packet to the supplied buffer' 
 307          self._bufferstartoffset=buf.getcurrentoffset() 
 308          self.__field_unknown1.writetobuffer(buf) 
 309          self.__field_binary.writetobuffer(buf) 
 310          self.__field_unknown3.writetobuffer(buf) 
 311          self.__field_unknown4.writetobuffer(buf) 
 312          self.__field_unknown6.writetobuffer(buf) 
 313          self.__field_length.writetobuffer(buf) 
 314          try: self.__field_msg 
 315          except: 
 316              self.__field_msg=LIST(**{'elementclass': _gen_p_lgvx5200_89, 'length': 219}) 
 317          self.__field_msg.writetobuffer(buf) 
 318          self._bufferendoffset=buf.getcurrentoffset() 
 319          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
 320   
 321   
 322 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
 323          'Reads this packet from the supplied buffer' 
 324          self._bufferstartoffset=buf.getcurrentoffset() 
 325          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
 326          self.__field_unknown1=UINT(**{'sizeinbytes': 1}) 
 327          self.__field_unknown1.readfrombuffer(buf) 
 328          self.__field_binary=UINT(**{'sizeinbytes': 1}) 
 329          self.__field_binary.readfrombuffer(buf) 
 330          self.__field_unknown3=UINT(**{'sizeinbytes': 1}) 
 331          self.__field_unknown3.readfrombuffer(buf) 
 332          self.__field_unknown4=UINT(**{'sizeinbytes': 1}) 
 333          self.__field_unknown4.readfrombuffer(buf) 
 334          self.__field_unknown6=UINT(**{'sizeinbytes': 1}) 
 335          self.__field_unknown6.readfrombuffer(buf) 
 336          self.__field_length=UINT(**{'sizeinbytes': 1}) 
 337          self.__field_length.readfrombuffer(buf) 
 338          self.__field_msg=LIST(**{'elementclass': _gen_p_lgvx5200_89, 'length': 219}) 
 339          self.__field_msg.readfrombuffer(buf) 
 340          self._bufferendoffset=buf.getcurrentoffset() 
 341   
 342   
 343 -    def __getfield_unknown1(self): 
 344          return self.__field_unknown1.getvalue() 
 345   
 346 -    def __setfield_unknown1(self, value): 
 347          if isinstance(value,UINT): 
 348              self.__field_unknown1=value 
 349          else: 
 350              self.__field_unknown1=UINT(value,**{'sizeinbytes': 1}) 
 351   
 352 -    def __delfield_unknown1(self): del self.__field_unknown1 
 353   
 354      unknown1=property(__getfield_unknown1, __setfield_unknown1, __delfield_unknown1, None) 
 355   
 356 -    def __getfield_binary(self): 
 357          return self.__field_binary.getvalue() 
 358   
 359 -    def __setfield_binary(self, value): 
 360          if isinstance(value,UINT): 
 361              self.__field_binary=value 
 362          else: 
 363              self.__field_binary=UINT(value,**{'sizeinbytes': 1}) 
 364   
 365 -    def __delfield_binary(self): del self.__field_binary 
 366   
 367      binary=property(__getfield_binary, __setfield_binary, __delfield_binary, None) 
 368   
 369 -    def __getfield_unknown3(self): 
 370          return self.__field_unknown3.getvalue() 
 371   
 372 -    def __setfield_unknown3(self, value): 
 373          if isinstance(value,UINT): 
 374              self.__field_unknown3=value 
 375          else: 
 376              self.__field_unknown3=UINT(value,**{'sizeinbytes': 1}) 
 377   
 378 -    def __delfield_unknown3(self): del self.__field_unknown3 
 379   
 380      unknown3=property(__getfield_unknown3, __setfield_unknown3, __delfield_unknown3, None) 
 381   
 382 -    def __getfield_unknown4(self): 
 383          return self.__field_unknown4.getvalue() 
 384   
 385 -    def __setfield_unknown4(self, value): 
 386          if isinstance(value,UINT): 
 387              self.__field_unknown4=value 
 388          else: 
 389              self.__field_unknown4=UINT(value,**{'sizeinbytes': 1}) 
 390   
 391 -    def __delfield_unknown4(self): del self.__field_unknown4 
 392   
 393      unknown4=property(__getfield_unknown4, __setfield_unknown4, __delfield_unknown4, None) 
 394   
 395 -    def __getfield_unknown6(self): 
 396          return self.__field_unknown6.getvalue() 
 397   
 398 -    def __setfield_unknown6(self, value): 
 399          if isinstance(value,UINT): 
 400              self.__field_unknown6=value 
 401          else: 
 402              self.__field_unknown6=UINT(value,**{'sizeinbytes': 1}) 
 403   
 404 -    def __delfield_unknown6(self): del self.__field_unknown6 
 405   
 406      unknown6=property(__getfield_unknown6, __setfield_unknown6, __delfield_unknown6, None) 
 407   
 408 -    def __getfield_length(self): 
 409          return self.__field_length.getvalue() 
 410   
 411 -    def __setfield_length(self, value): 
 412          if isinstance(value,UINT): 
 413              self.__field_length=value 
 414          else: 
 415              self.__field_length=UINT(value,**{'sizeinbytes': 1}) 
 416   
 417 -    def __delfield_length(self): del self.__field_length 
 418   
 419      length=property(__getfield_length, __setfield_length, __delfield_length, None) 
 420   
 421 -    def __getfield_msg(self): 
 422          try: self.__field_msg 
 423          except: 
 424              self.__field_msg=LIST(**{'elementclass': _gen_p_lgvx5200_89, 'length': 219}) 
 425          return self.__field_msg.getvalue() 
 426   
 427 -    def __setfield_msg(self, value): 
 428          if isinstance(value,LIST): 
 429              self.__field_msg=value 
 430          else: 
 431              self.__field_msg=LIST(value,**{'elementclass': _gen_p_lgvx5200_89, 'length': 219}) 
 432   
 433 -    def __delfield_msg(self): del self.__field_msg 
 434   
 435      msg=property(__getfield_msg, __setfield_msg, __delfield_msg, None) 
 436   
 437 -    def iscontainer(self): 
 438          return True 
 439   
 440 -    def containerelements(self): 
 441          yield ('unknown1', self.__field_unknown1, None) 
 442          yield ('binary', self.__field_binary, None) 
 443          yield ('unknown3', self.__field_unknown3, None) 
 444          yield ('unknown4', self.__field_unknown4, None) 
 445          yield ('unknown6', self.__field_unknown6, None) 
 446          yield ('length', self.__field_length, None) 
 447          yield ('msg', self.__field_msg, None) 
 448   
 449   
 450   
 451   
 452 -class _gen_p_lgvx5200_89(BaseProtogenClass): 
 453      'Anonymous inner class' 
 454      __fields=['byte'] 
 455   
 456 -    def __init__(self, *args, **kwargs): 
 457          dict={} 
 458          # What was supplied to this function 
 459          dict.update(kwargs) 
 460          # Parent constructor 
 461          super(_gen_p_lgvx5200_89,self).__init__(**dict) 
 462          if self.__class__ is _gen_p_lgvx5200_89: 
 463              self._update(args,dict) 
 464   
 465   
 466 -    def getfields(self): 
 467          return self.__fields 
 468   
 469   
 470 -    def _update(self, args, kwargs): 
 471          super(_gen_p_lgvx5200_89,self)._update(args,kwargs) 
 472          keys=kwargs.keys() 
 473          for key in keys: 
 474              if key in self.__fields: 
 475                  setattr(self, key, kwargs[key]) 
 476                  del kwargs[key] 
 477          # Were any unrecognized kwargs passed in? 
 478          if __debug__: 
 479              self._complainaboutunusedargs(_gen_p_lgvx5200_89,kwargs) 
 480          if len(args): 
 481              dict2={'sizeinbytes': 1} 
 482              dict2.update(kwargs) 
 483              kwargs=dict2 
 484              self.__field_byte=UINT(*args,**dict2) 
 485          # Make all P fields that haven't already been constructed 
 486   
 487   
 488 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
 489          'Writes this packet to the supplied buffer' 
 490          self._bufferstartoffset=buf.getcurrentoffset() 
 491          self.__field_byte.writetobuffer(buf) 
 492          self._bufferendoffset=buf.getcurrentoffset() 
 493          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
 494   
 495   
 496 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
 497          'Reads this packet from the supplied buffer' 
 498          self._bufferstartoffset=buf.getcurrentoffset() 
 499          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
 500          self.__field_byte=UINT(**{'sizeinbytes': 1}) 
 501          self.__field_byte.readfrombuffer(buf) 
 502          self._bufferendoffset=buf.getcurrentoffset() 
 503   
 504   
 505 -    def __getfield_byte(self): 
 506          return self.__field_byte.getvalue() 
 507   
 508 -    def __setfield_byte(self, value): 
 509          if isinstance(value,UINT): 
 510              self.__field_byte=value 
 511          else: 
 512              self.__field_byte=UINT(value,**{'sizeinbytes': 1}) 
 513   
 514 -    def __delfield_byte(self): del self.__field_byte 
 515   
 516      byte=property(__getfield_byte, __setfield_byte, __delfield_byte, "individual byte of message") 
 517   
 518 -    def iscontainer(self): 
 519          return True 
 520   
 521 -    def containerelements(self): 
 522          yield ('byte', self.__field_byte, "individual byte of message") 
 523   
 524   
 525   
 526   
 527 -class recipient_record(BaseProtogenClass): 
 528      __fields=['unknown1', 'number', 'status', 'timesent', 'timereceived', 'unknown2', 'unknown3'] 
 529   
 530 -    def __init__(self, *args, **kwargs): 
 531          dict={} 
 532          # What was supplied to this function 
 533          dict.update(kwargs) 
 534          # Parent constructor 
 535          super(recipient_record,self).__init__(**dict) 
 536          if self.__class__ is recipient_record: 
 537              self._update(args,dict) 
 538   
 539   
 540 -    def getfields(self): 
 541          return self.__fields 
 542   
 543   
 544 -    def _update(self, args, kwargs): 
 545          super(recipient_record,self)._update(args,kwargs) 
 546          keys=kwargs.keys() 
 547          for key in keys: 
 548              if key in self.__fields: 
 549                  setattr(self, key, kwargs[key]) 
 550                  del kwargs[key] 
 551          # Were any unrecognized kwargs passed in? 
 552          if __debug__: 
 553              self._complainaboutunusedargs(recipient_record,kwargs) 
 554          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
 555          # Make all P fields that haven't already been constructed 
 556   
 557   
 558 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
 559          'Writes this packet to the supplied buffer' 
 560          self._bufferstartoffset=buf.getcurrentoffset() 
 561          self.__field_unknown1.writetobuffer(buf) 
 562          self.__field_number.writetobuffer(buf) 
 563          self.__field_status.writetobuffer(buf) 
 564          self.__field_timesent.writetobuffer(buf) 
 565          self.__field_timereceived.writetobuffer(buf) 
 566          self.__field_unknown2.writetobuffer(buf) 
 567          self.__field_unknown3.writetobuffer(buf) 
 568          self._bufferendoffset=buf.getcurrentoffset() 
 569          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
 570   
 571   
 572 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
 573          'Reads this packet from the supplied buffer' 
 574          self._bufferstartoffset=buf.getcurrentoffset() 
 575          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
 576          self.__field_unknown1=DATA(**{'sizeinbytes': 33}) 
 577          self.__field_unknown1.readfrombuffer(buf) 
 578          self.__field_number=USTRING(**{'sizeinbytes': 49}) 
 579          self.__field_number.readfrombuffer(buf) 
 580          self.__field_status=UINT(**{'sizeinbytes': 1}) 
 581          self.__field_status.readfrombuffer(buf) 
 582          self.__field_timesent=LGCALDATE(**{'sizeinbytes': 4}) 
 583          self.__field_timesent.readfrombuffer(buf) 
 584          self.__field_timereceived=LGCALDATE(**{'sizeinbytes': 4}) 
 585          self.__field_timereceived.readfrombuffer(buf) 
 586          self.__field_unknown2=UINT(**{'sizeinbytes': 1}) 
 587          self.__field_unknown2.readfrombuffer(buf) 
 588          self.__field_unknown3=DATA(**{'sizeinbytes': 40}) 
 589          self.__field_unknown3.readfrombuffer(buf) 
 590          self._bufferendoffset=buf.getcurrentoffset() 
 591   
 592   
 593 -    def __getfield_unknown1(self): 
 594          return self.__field_unknown1.getvalue() 
 595   
 596 -    def __setfield_unknown1(self, value): 
 597          if isinstance(value,DATA): 
 598              self.__field_unknown1=value 
 599          else: 
 600              self.__field_unknown1=DATA(value,**{'sizeinbytes': 33}) 
 601   
 602 -    def __delfield_unknown1(self): del self.__field_unknown1 
 603   
 604      unknown1=property(__getfield_unknown1, __setfield_unknown1, __delfield_unknown1, None) 
 605   
 606 -    def __getfield_number(self): 
 607          return self.__field_number.getvalue() 
 608   
 609 -    def __setfield_number(self, value): 
 610          if isinstance(value,USTRING): 
 611              self.__field_number=value 
 612          else: 
 613              self.__field_number=USTRING(value,**{'sizeinbytes': 49}) 
 614   
 615 -    def __delfield_number(self): del self.__field_number 
 616   
 617      number=property(__getfield_number, __setfield_number, __delfield_number, None) 
 618   
 619 -    def __getfield_status(self): 
 620          return self.__field_status.getvalue() 
 621   
 622 -    def __setfield_status(self, value): 
 623          if isinstance(value,UINT): 
 624              self.__field_status=value 
 625          else: 
 626              self.__field_status=UINT(value,**{'sizeinbytes': 1}) 
 627   
 628 -    def __delfield_status(self): del self.__field_status 
 629   
 630      status=property(__getfield_status, __setfield_status, __delfield_status, None) 
 631   
 632 -    def __getfield_timesent(self): 
 633          return self.__field_timesent.getvalue() 
 634   
 635 -    def __setfield_timesent(self, value): 
 636          if isinstance(value,LGCALDATE): 
 637              self.__field_timesent=value 
 638          else: 
 639              self.__field_timesent=LGCALDATE(value,**{'sizeinbytes': 4}) 
 640   
 641 -    def __delfield_timesent(self): del self.__field_timesent 
 642   
 643      timesent=property(__getfield_timesent, __setfield_timesent, __delfield_timesent, None) 
 644   
 645 -    def __getfield_timereceived(self): 
 646          return self.__field_timereceived.getvalue() 
 647   
 648 -    def __setfield_timereceived(self, value): 
 649          if isinstance(value,LGCALDATE): 
 650              self.__field_timereceived=value 
 651          else: 
 652              self.__field_timereceived=LGCALDATE(value,**{'sizeinbytes': 4}) 
 653   
 654 -    def __delfield_timereceived(self): del self.__field_timereceived 
 655   
 656      timereceived=property(__getfield_timereceived, __setfield_timereceived, __delfield_timereceived, None) 
 657   
 658 -    def __getfield_unknown2(self): 
 659          return self.__field_unknown2.getvalue() 
 660   
 661 -    def __setfield_unknown2(self, value): 
 662          if isinstance(value,UINT): 
 663              self.__field_unknown2=value 
 664          else: 
 665              self.__field_unknown2=UINT(value,**{'sizeinbytes': 1}) 
 666   
 667 -    def __delfield_unknown2(self): del self.__field_unknown2 
 668   
 669      unknown2=property(__getfield_unknown2, __setfield_unknown2, __delfield_unknown2, None) 
 670   
 671 -    def __getfield_unknown3(self): 
 672          return self.__field_unknown3.getvalue() 
 673   
 674 -    def __setfield_unknown3(self, value): 
 675          if isinstance(value,DATA): 
 676              self.__field_unknown3=value 
 677          else: 
 678              self.__field_unknown3=DATA(value,**{'sizeinbytes': 40}) 
 679   
 680 -    def __delfield_unknown3(self): del self.__field_unknown3 
 681   
 682      unknown3=property(__getfield_unknown3, __setfield_unknown3, __delfield_unknown3, None) 
 683   
 684 -    def iscontainer(self): 
 685          return True 
 686   
 687 -    def containerelements(self): 
 688          yield ('unknown1', self.__field_unknown1, None) 
 689          yield ('number', self.__field_number, None) 
 690          yield ('status', self.__field_status, None) 
 691          yield ('timesent', self.__field_timesent, None) 
 692          yield ('timereceived', self.__field_timereceived, None) 
 693          yield ('unknown2', self.__field_unknown2, None) 
 694          yield ('unknown3', self.__field_unknown3, None) 
 695   
 696   
 697   
 698   
 699 -class sms_saved(BaseProtogenClass): 
 700      __fields=['outboxmsg', 'GPStime', 'outbox', 'inbox'] 
 701   
 702 -    def __init__(self, *args, **kwargs): 
 703          dict={} 
 704          # What was supplied to this function 
 705          dict.update(kwargs) 
 706          # Parent constructor 
 707          super(sms_saved,self).__init__(**dict) 
 708          if self.__class__ is sms_saved: 
 709              self._update(args,dict) 
 710   
 711   
 712 -    def getfields(self): 
 713          return self.__fields 
 714   
 715   
 716 -    def _update(self, args, kwargs): 
 717          super(sms_saved,self)._update(args,kwargs) 
 718          keys=kwargs.keys() 
 719          for key in keys: 
 720              if key in self.__fields: 
 721                  setattr(self, key, kwargs[key]) 
 722                  del kwargs[key] 
 723          # Were any unrecognized kwargs passed in? 
 724          if __debug__: 
 725              self._complainaboutunusedargs(sms_saved,kwargs) 
 726          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
 727          # Make all P fields that haven't already been constructed 
 728   
 729   
 730 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
 731          'Writes this packet to the supplied buffer' 
 732          self._bufferstartoffset=buf.getcurrentoffset() 
 733          self.__field_outboxmsg.writetobuffer(buf) 
 734          self.__field_GPStime.writetobuffer(buf) 
 735          if self.outboxmsg: 
 736              self.__field_outbox.writetobuffer(buf) 
 737          if not self.outboxmsg: 
 738              self.__field_inbox.writetobuffer(buf) 
 739          self._bufferendoffset=buf.getcurrentoffset() 
 740          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
 741   
 742   
 743 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
 744          'Reads this packet from the supplied buffer' 
 745          self._bufferstartoffset=buf.getcurrentoffset() 
 746          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
 747          self.__field_outboxmsg=UINT(**{'sizeinbytes': 4}) 
 748          self.__field_outboxmsg.readfrombuffer(buf) 
 749          self.__field_GPStime=GPSDATE(**{'sizeinbytes': 4}) 
 750          self.__field_GPStime.readfrombuffer(buf) 
 751          if self.outboxmsg: 
 752              self.__field_outbox=sms_out() 
 753              self.__field_outbox.readfrombuffer(buf) 
 754          if not self.outboxmsg: 
 755              self.__field_inbox=sms_in() 
 756              self.__field_inbox.readfrombuffer(buf) 
 757          self._bufferendoffset=buf.getcurrentoffset() 
 758   
 759   
 760 -    def __getfield_outboxmsg(self): 
 761          return self.__field_outboxmsg.getvalue() 
 762   
 763 -    def __setfield_outboxmsg(self, value): 
 764          if isinstance(value,UINT): 
 765              self.__field_outboxmsg=value 
 766          else: 
 767              self.__field_outboxmsg=UINT(value,**{'sizeinbytes': 4}) 
 768   
 769 -    def __delfield_outboxmsg(self): del self.__field_outboxmsg 
 770   
 771      outboxmsg=property(__getfield_outboxmsg, __setfield_outboxmsg, __delfield_outboxmsg, None) 
 772   
 773 -    def __getfield_GPStime(self): 
 774          return self.__field_GPStime.getvalue() 
 775   
 776 -    def __setfield_GPStime(self, value): 
 777          if isinstance(value,GPSDATE): 
 778              self.__field_GPStime=value 
 779          else: 
 780              self.__field_GPStime=GPSDATE(value,**{'sizeinbytes': 4}) 
 781   
 782 -    def __delfield_GPStime(self): del self.__field_GPStime 
 783   
 784      GPStime=property(__getfield_GPStime, __setfield_GPStime, __delfield_GPStime, None) 
 785   
 786 -    def __getfield_outbox(self): 
 787          return self.__field_outbox.getvalue() 
 788   
 789 -    def __setfield_outbox(self, value): 
 790          if isinstance(value,sms_out): 
 791              self.__field_outbox=value 
 792          else: 
 793              self.__field_outbox=sms_out(value,) 
 794   
 795 -    def __delfield_outbox(self): del self.__field_outbox 
 796   
 797      outbox=property(__getfield_outbox, __setfield_outbox, __delfield_outbox, None) 
 798   
 799 -    def __getfield_inbox(self): 
 800          return self.__field_inbox.getvalue() 
 801   
 802 -    def __setfield_inbox(self, value): 
 803          if isinstance(value,sms_in): 
 804              self.__field_inbox=value 
 805          else: 
 806              self.__field_inbox=sms_in(value,) 
 807   
 808 -    def __delfield_inbox(self): del self.__field_inbox 
 809   
 810      inbox=property(__getfield_inbox, __setfield_inbox, __delfield_inbox, None) 
 811   
 812 -    def iscontainer(self): 
 813          return True 
 814   
 815 -    def containerelements(self): 
 816          yield ('outboxmsg', self.__field_outboxmsg, None) 
 817          yield ('GPStime', self.__field_GPStime, None) 
 818          if self.outboxmsg: 
 819              yield ('outbox', self.__field_outbox, None) 
 820          if not self.outboxmsg: 
 821              yield ('inbox', self.__field_inbox, None) 
 822   
 823   
 824   
 825   
 826 -class sms_out(BaseProtogenClass): 
 827      __fields=['index', 'unknown1', 'locked', 'timesent', 'unknown2', 'GPStime', 'subject', 'unknown4', 'num_msg_elements', 'messages', 'unknown1', 'priority', 'unknown5', 'callback', 'recipients', 'pad'] 
 828   
 829 -    def __init__(self, *args, **kwargs): 
 830          dict={} 
 831          # What was supplied to this function 
 832          dict.update(kwargs) 
 833          # Parent constructor 
 834          super(sms_out,self).__init__(**dict) 
 835          if self.__class__ is sms_out: 
 836              self._update(args,dict) 
 837   
 838   
 839 -    def getfields(self): 
 840          return self.__fields 
 841   
 842   
 843 -    def _update(self, args, kwargs): 
 844          super(sms_out,self)._update(args,kwargs) 
 845          keys=kwargs.keys() 
 846          for key in keys: 
 847              if key in self.__fields: 
 848                  setattr(self, key, kwargs[key]) 
 849                  del kwargs[key] 
 850          # Were any unrecognized kwargs passed in? 
 851          if __debug__: 
 852              self._complainaboutunusedargs(sms_out,kwargs) 
 853          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
 854          # Make all P fields that haven't already been constructed 
 855   
 856   
 857 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
 858          'Writes this packet to the supplied buffer' 
 859          self._bufferstartoffset=buf.getcurrentoffset() 
 860          self.__field_index.writetobuffer(buf) 
 861          self.__field_unknown1.writetobuffer(buf) 
 862          self.__field_locked.writetobuffer(buf) 
 863          self.__field_timesent.writetobuffer(buf) 
 864          self.__field_unknown2.writetobuffer(buf) 
 865          self.__field_GPStime.writetobuffer(buf) 
 866          self.__field_subject.writetobuffer(buf) 
 867          self.__field_unknown4.writetobuffer(buf) 
 868          self.__field_num_msg_elements.writetobuffer(buf) 
 869          try: self.__field_messages 
 870          except: 
 871              self.__field_messages=LIST(**{'elementclass': msg_record, 'length': 7}) 
 872          self.__field_messages.writetobuffer(buf) 
 873          self.__field_unknown1.writetobuffer(buf) 
 874          self.__field_priority.writetobuffer(buf) 
 875          self.__field_unknown5.writetobuffer(buf) 
 876          self.__field_callback.writetobuffer(buf) 
 877          try: self.__field_recipients 
 878          except: 
 879              self.__field_recipients=LIST(**{'elementclass': recipient_record,'length': 9}) 
 880          self.__field_recipients.writetobuffer(buf) 
 881          self.__field_pad.writetobuffer(buf) 
 882          self._bufferendoffset=buf.getcurrentoffset() 
 883          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
 884   
 885   
 886 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
 887          'Reads this packet from the supplied buffer' 
 888          self._bufferstartoffset=buf.getcurrentoffset() 
 889          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
 890          self.__field_index=UINT(**{'sizeinbytes': 4}) 
 891          self.__field_index.readfrombuffer(buf) 
 892          self.__field_unknown1=UINT(**{'sizeinbytes': 1}) 
 893          self.__field_unknown1.readfrombuffer(buf) 
 894          self.__field_locked=UINT(**{'sizeinbytes': 1}) 
 895          self.__field_locked.readfrombuffer(buf) 
 896          self.__field_timesent=LGCALDATE(**{'sizeinbytes': 4}) 
 897          self.__field_timesent.readfrombuffer(buf) 
 898          self.__field_unknown2=UINT(**{'sizeinbytes': 2}) 
 899          self.__field_unknown2.readfrombuffer(buf) 
 900          self.__field_GPStime=GPSDATE(**{'sizeinbytes': 4}) 
 901          self.__field_GPStime.readfrombuffer(buf) 
 902          self.__field_subject=USTRING(**{'sizeinbytes': 21, 'encoding': PHONE_ENCODING}) 
 903          self.__field_subject.readfrombuffer(buf) 
 904          self.__field_unknown4=UNKNOWN(**{'sizeinbytes': 1}) 
 905          self.__field_unknown4.readfrombuffer(buf) 
 906          self.__field_num_msg_elements=UINT(**{'sizeinbytes': 1}) 
 907          self.__field_num_msg_elements.readfrombuffer(buf) 
 908          self.__field_messages=LIST(**{'elementclass': msg_record, 'length': 7}) 
 909          self.__field_messages.readfrombuffer(buf) 
 910          self.__field_unknown1=UNKNOWN(**{'sizeinbytes': 15}) 
 911          self.__field_unknown1.readfrombuffer(buf) 
 912          self.__field_priority=UINT(**{'sizeinbytes': 1}) 
 913          self.__field_priority.readfrombuffer(buf) 
 914          self.__field_unknown5=UNKNOWN(**{'sizeinbytes': 1}) 
 915          self.__field_unknown5.readfrombuffer(buf) 
 916          self.__field_callback=USTRING(**{'sizeinbytes': 35}) 
 917          self.__field_callback.readfrombuffer(buf) 
 918          self.__field_recipients=LIST(**{'elementclass': recipient_record,'length': 9}) 
 919          self.__field_recipients.readfrombuffer(buf) 
 920          self.__field_pad=UNKNOWN() 
 921          self.__field_pad.readfrombuffer(buf) 
 922          self._bufferendoffset=buf.getcurrentoffset() 
 923   
 924   
 925 -    def __getfield_index(self): 
 926          return self.__field_index.getvalue() 
 927   
 928 -    def __setfield_index(self, value): 
 929          if isinstance(value,UINT): 
 930              self.__field_index=value 
 931          else: 
 932              self.__field_index=UINT(value,**{'sizeinbytes': 4}) 
 933   
 934 -    def __delfield_index(self): del self.__field_index 
 935   
 936      index=property(__getfield_index, __setfield_index, __delfield_index, None) 
 937   
 938 -    def __getfield_unknown1(self): 
 939          return self.__field_unknown1.getvalue() 
 940   
 941 -    def __setfield_unknown1(self, value): 
 942          if isinstance(value,UINT): 
 943              self.__field_unknown1=value 
 944          else: 
 945              self.__field_unknown1=UINT(value,**{'sizeinbytes': 1}) 
 946   
 947 -    def __delfield_unknown1(self): del self.__field_unknown1 
 948   
 949      unknown1=property(__getfield_unknown1, __setfield_unknown1, __delfield_unknown1, None) 
 950   
 951 -    def __getfield_locked(self): 
 952          return self.__field_locked.getvalue() 
 953   
 954 -    def __setfield_locked(self, value): 
 955          if isinstance(value,UINT): 
 956              self.__field_locked=value 
 957          else: 
 958              self.__field_locked=UINT(value,**{'sizeinbytes': 1}) 
 959   
 960 -    def __delfield_locked(self): del self.__field_locked 
 961   
 962      locked=property(__getfield_locked, __setfield_locked, __delfield_locked, None) 
 963   
 964 -    def __getfield_timesent(self): 
 965          return self.__field_timesent.getvalue() 
 966   
 967 -    def __setfield_timesent(self, value): 
 968          if isinstance(value,LGCALDATE): 
 969              self.__field_timesent=value 
 970          else: 
 971              self.__field_timesent=LGCALDATE(value,**{'sizeinbytes': 4}) 
 972   
 973 -    def __delfield_timesent(self): del self.__field_timesent 
 974   
 975      timesent=property(__getfield_timesent, __setfield_timesent, __delfield_timesent, None) 
 976   
 977 -    def __getfield_unknown2(self): 
 978          return self.__field_unknown2.getvalue() 
 979   
 980 -    def __setfield_unknown2(self, value): 
 981          if isinstance(value,UINT): 
 982              self.__field_unknown2=value 
 983          else: 
 984              self.__field_unknown2=UINT(value,**{'sizeinbytes': 2}) 
 985   
 986 -    def __delfield_unknown2(self): del self.__field_unknown2 
 987   
 988      unknown2=property(__getfield_unknown2, __setfield_unknown2, __delfield_unknown2, None) 
 989   
 990 -    def __getfield_GPStime(self): 
 991          return self.__field_GPStime.getvalue() 
 992   
 993 -    def __setfield_GPStime(self, value): 
 994          if isinstance(value,GPSDATE): 
 995              self.__field_GPStime=value 
 996          else: 
 997              self.__field_GPStime=GPSDATE(value,**{'sizeinbytes': 4}) 
 998   
 999 -    def __delfield_GPStime(self): del self.__field_GPStime 
1000   
1001      GPStime=property(__getfield_GPStime, __setfield_GPStime, __delfield_GPStime, None) 
1002   
1003 -    def __getfield_subject(self): 
1004          return self.__field_subject.getvalue() 
1005   
1006 -    def __setfield_subject(self, value): 
1007          if isinstance(value,USTRING): 
1008              self.__field_subject=value 
1009          else: 
1010              self.__field_subject=USTRING(value,**{'sizeinbytes': 21, 'encoding': PHONE_ENCODING}) 
1011   
1012 -    def __delfield_subject(self): del self.__field_subject 
1013   
1014      subject=property(__getfield_subject, __setfield_subject, __delfield_subject, None) 
1015   
1016 -    def __getfield_unknown4(self): 
1017          return self.__field_unknown4.getvalue() 
1018   
1019 -    def __setfield_unknown4(self, value): 
1020          if isinstance(value,UNKNOWN): 
1021              self.__field_unknown4=value 
1022          else: 
1023              self.__field_unknown4=UNKNOWN(value,**{'sizeinbytes': 1}) 
1024   
1025 -    def __delfield_unknown4(self): del self.__field_unknown4 
1026   
1027      unknown4=property(__getfield_unknown4, __setfield_unknown4, __delfield_unknown4, None) 
1028   
1029 -    def __getfield_num_msg_elements(self): 
1030          return self.__field_num_msg_elements.getvalue() 
1031   
1032 -    def __setfield_num_msg_elements(self, value): 
1033          if isinstance(value,UINT): 
1034              self.__field_num_msg_elements=value 
1035          else: 
1036              self.__field_num_msg_elements=UINT(value,**{'sizeinbytes': 1}) 
1037   
1038 -    def __delfield_num_msg_elements(self): del self.__field_num_msg_elements 
1039   
1040      num_msg_elements=property(__getfield_num_msg_elements, __setfield_num_msg_elements, __delfield_num_msg_elements, None) 
1041   
1042 -    def __getfield_messages(self): 
1043          try: self.__field_messages 
1044          except: 
1045              self.__field_messages=LIST(**{'elementclass': msg_record, 'length': 7}) 
1046          return self.__field_messages.getvalue() 
1047   
1048 -    def __setfield_messages(self, value): 
1049          if isinstance(value,LIST): 
1050              self.__field_messages=value 
1051          else: 
1052              self.__field_messages=LIST(value,**{'elementclass': msg_record, 'length': 7}) 
1053   
1054 -    def __delfield_messages(self): del self.__field_messages 
1055   
1056      messages=property(__getfield_messages, __setfield_messages, __delfield_messages, None) 
1057   
1058 -    def __getfield_unknown1(self): 
1059          return self.__field_unknown1.getvalue() 
1060   
1061 -    def __setfield_unknown1(self, value): 
1062          if isinstance(value,UNKNOWN): 
1063              self.__field_unknown1=value 
1064          else: 
1065              self.__field_unknown1=UNKNOWN(value,**{'sizeinbytes': 15}) 
1066   
1067 -    def __delfield_unknown1(self): del self.__field_unknown1 
1068   
1069      unknown1=property(__getfield_unknown1, __setfield_unknown1, __delfield_unknown1, None) 
1070   
1071 -    def __getfield_priority(self): 
1072          return self.__field_priority.getvalue() 
1073   
1074 -    def __setfield_priority(self, value): 
1075          if isinstance(value,UINT): 
1076              self.__field_priority=value 
1077          else: 
1078              self.__field_priority=UINT(value,**{'sizeinbytes': 1}) 
1079   
1080 -    def __delfield_priority(self): del self.__field_priority 
1081   
1082      priority=property(__getfield_priority, __setfield_priority, __delfield_priority, None) 
1083   
1084 -    def __getfield_unknown5(self): 
1085          return self.__field_unknown5.getvalue() 
1086   
1087 -    def __setfield_unknown5(self, value): 
1088          if isinstance(value,UNKNOWN): 
1089              self.__field_unknown5=value 
1090          else: 
1091              self.__field_unknown5=UNKNOWN(value,**{'sizeinbytes': 1}) 
1092   
1093 -    def __delfield_unknown5(self): del self.__field_unknown5 
1094   
1095      unknown5=property(__getfield_unknown5, __setfield_unknown5, __delfield_unknown5, None) 
1096   
1097 -    def __getfield_callback(self): 
1098          return self.__field_callback.getvalue() 
1099   
1100 -    def __setfield_callback(self, value): 
1101          if isinstance(value,USTRING): 
1102              self.__field_callback=value 
1103          else: 
1104              self.__field_callback=USTRING(value,**{'sizeinbytes': 35}) 
1105   
1106 -    def __delfield_callback(self): del self.__field_callback 
1107   
1108      callback=property(__getfield_callback, __setfield_callback, __delfield_callback, None) 
1109   
1110 -    def __getfield_recipients(self): 
1111          try: self.__field_recipients 
1112          except: 
1113              self.__field_recipients=LIST(**{'elementclass': recipient_record,'length': 9}) 
1114          return self.__field_recipients.getvalue() 
1115   
1116 -    def __setfield_recipients(self, value): 
1117          if isinstance(value,LIST): 
1118              self.__field_recipients=value 
1119          else: 
1120              self.__field_recipients=LIST(value,**{'elementclass': recipient_record,'length': 9}) 
1121   
1122 -    def __delfield_recipients(self): del self.__field_recipients 
1123   
1124      recipients=property(__getfield_recipients, __setfield_recipients, __delfield_recipients, None) 
1125   
1126 -    def __getfield_pad(self): 
1127          return self.__field_pad.getvalue() 
1128   
1129 -    def __setfield_pad(self, value): 
1130          if isinstance(value,UNKNOWN): 
1131              self.__field_pad=value 
1132          else: 
1133              self.__field_pad=UNKNOWN(value,) 
1134   
1135 -    def __delfield_pad(self): del self.__field_pad 
1136   
1137      pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None) 
1138   
1139 -    def iscontainer(self): 
1140          return True 
1141   
1142 -    def containerelements(self): 
1143          yield ('index', self.__field_index, None) 
1144          yield ('unknown1', self.__field_unknown1, None) 
1145          yield ('locked', self.__field_locked, None) 
1146          yield ('timesent', self.__field_timesent, None) 
1147          yield ('unknown2', self.__field_unknown2, None) 
1148          yield ('GPStime', self.__field_GPStime, None) 
1149          yield ('subject', self.__field_subject, None) 
1150          yield ('unknown4', self.__field_unknown4, None) 
1151          yield ('num_msg_elements', self.__field_num_msg_elements, None) 
1152          yield ('messages', self.__field_messages, None) 
1153          yield ('unknown1', self.__field_unknown1, None) 
1154          yield ('priority', self.__field_priority, None) 
1155          yield ('unknown5', self.__field_unknown5, None) 
1156          yield ('callback', self.__field_callback, None) 
1157          yield ('recipients', self.__field_recipients, None) 
1158          yield ('pad', self.__field_pad, None) 
1159   
1160   
1161   
1162   
1163 -class SMSINBOXMSGFRAGMENT(BaseProtogenClass): 
1164      __fields=['msg'] 
1165   
1166 -    def __init__(self, *args, **kwargs): 
1167          dict={} 
1168          # What was supplied to this function 
1169          dict.update(kwargs) 
1170          # Parent constructor 
1171          super(SMSINBOXMSGFRAGMENT,self).__init__(**dict) 
1172          if self.__class__ is SMSINBOXMSGFRAGMENT: 
1173              self._update(args,dict) 
1174   
1175   
1176 -    def getfields(self): 
1177          return self.__fields 
1178   
1179   
1180 -    def _update(self, args, kwargs): 
1181          super(SMSINBOXMSGFRAGMENT,self)._update(args,kwargs) 
1182          keys=kwargs.keys() 
1183          for key in keys: 
1184              if key in self.__fields: 
1185                  setattr(self, key, kwargs[key]) 
1186                  del kwargs[key] 
1187          # Were any unrecognized kwargs passed in? 
1188          if __debug__: 
1189              self._complainaboutunusedargs(SMSINBOXMSGFRAGMENT,kwargs) 
1190          if len(args): 
1191              dict2={'elementclass': _gen_p_lgvx5200_128, 'length': 181} 
1192              dict2.update(kwargs) 
1193              kwargs=dict2 
1194              self.__field_msg=LIST(*args,**dict2) 
1195          # Make all P fields that haven't already been constructed 
1196   
1197   
1198 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
1199          'Writes this packet to the supplied buffer' 
1200          self._bufferstartoffset=buf.getcurrentoffset() 
1201          try: self.__field_msg 
1202          except: 
1203              self.__field_msg=LIST(**{'elementclass': _gen_p_lgvx5200_128, 'length': 181}) 
1204          self.__field_msg.writetobuffer(buf) 
1205          self._bufferendoffset=buf.getcurrentoffset() 
1206          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
1207   
1208   
1209 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
1210          'Reads this packet from the supplied buffer' 
1211          self._bufferstartoffset=buf.getcurrentoffset() 
1212          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
1213          self.__field_msg=LIST(**{'elementclass': _gen_p_lgvx5200_128, 'length': 181}) 
1214          self.__field_msg.readfrombuffer(buf) 
1215          self._bufferendoffset=buf.getcurrentoffset() 
1216   
1217   
1218 -    def __getfield_msg(self): 
1219          try: self.__field_msg 
1220          except: 
1221              self.__field_msg=LIST(**{'elementclass': _gen_p_lgvx5200_128, 'length': 181}) 
1222          return self.__field_msg.getvalue() 
1223   
1224 -    def __setfield_msg(self, value): 
1225          if isinstance(value,LIST): 
1226              self.__field_msg=value 
1227          else: 
1228              self.__field_msg=LIST(value,**{'elementclass': _gen_p_lgvx5200_128, 'length': 181}) 
1229   
1230 -    def __delfield_msg(self): del self.__field_msg 
1231   
1232      msg=property(__getfield_msg, __setfield_msg, __delfield_msg, None) 
1233   
1234 -    def iscontainer(self): 
1235          return True 
1236   
1237 -    def containerelements(self): 
1238          yield ('msg', self.__field_msg, None) 
1239   
1240   
1241   
1242   
1243 -class _gen_p_lgvx5200_128(BaseProtogenClass): 
1244      'Anonymous inner class' 
1245      __fields=['byte'] 
1246   
1247 -    def __init__(self, *args, **kwargs): 
1248          dict={} 
1249          # What was supplied to this function 
1250          dict.update(kwargs) 
1251          # Parent constructor 
1252          super(_gen_p_lgvx5200_128,self).__init__(**dict) 
1253          if self.__class__ is _gen_p_lgvx5200_128: 
1254              self._update(args,dict) 
1255   
1256   
1257 -    def getfields(self): 
1258          return self.__fields 
1259   
1260   
1261 -    def _update(self, args, kwargs): 
1262          super(_gen_p_lgvx5200_128,self)._update(args,kwargs) 
1263          keys=kwargs.keys() 
1264          for key in keys: 
1265              if key in self.__fields: 
1266                  setattr(self, key, kwargs[key]) 
1267                  del kwargs[key] 
1268          # Were any unrecognized kwargs passed in? 
1269          if __debug__: 
1270              self._complainaboutunusedargs(_gen_p_lgvx5200_128,kwargs) 
1271          if len(args): 
1272              dict2={'sizeinbytes': 1} 
1273              dict2.update(kwargs) 
1274              kwargs=dict2 
1275              self.__field_byte=UINT(*args,**dict2) 
1276          # Make all P fields that haven't already been constructed 
1277   
1278   
1279 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
1280          'Writes this packet to the supplied buffer' 
1281          self._bufferstartoffset=buf.getcurrentoffset() 
1282          self.__field_byte.writetobuffer(buf) 
1283          self._bufferendoffset=buf.getcurrentoffset() 
1284          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
1285   
1286   
1287 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
1288          'Reads this packet from the supplied buffer' 
1289          self._bufferstartoffset=buf.getcurrentoffset() 
1290          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
1291          self.__field_byte=UINT(**{'sizeinbytes': 1}) 
1292          self.__field_byte.readfrombuffer(buf) 
1293          self._bufferendoffset=buf.getcurrentoffset() 
1294   
1295   
1296 -    def __getfield_byte(self): 
1297          return self.__field_byte.getvalue() 
1298   
1299 -    def __setfield_byte(self, value): 
1300          if isinstance(value,UINT): 
1301              self.__field_byte=value 
1302          else: 
1303              self.__field_byte=UINT(value,**{'sizeinbytes': 1}) 
1304   
1305 -    def __delfield_byte(self): del self.__field_byte 
1306   
1307      byte=property(__getfield_byte, __setfield_byte, __delfield_byte, "individual byte of message") 
1308   
1309 -    def iscontainer(self): 
1310          return True 
1311   
1312 -    def containerelements(self): 
1313          yield ('byte', self.__field_byte, "individual byte of message") 
1314   
1315   
1316   
1317   
1318 -class sms_in(BaseProtogenClass): 
1319      __fields=['unknown1', 'timesent', 'unknown2', 'callback_length', 'callback', 'sender_length', 'sender', 'unknown3', 'lg_time', 'unknown4', 'GPStime', 'unknown5', 'read', 'locked', 'unknown6', 'priority', 'subject', 'bin_header1', 'bin_header2', 'unknown7', 'multipartID', 'bin_header3', 'num_msg_elements', 'msglengths', 'unknown8', 'msgs', 'unknown9'] 
1320   
1321 -    def __init__(self, *args, **kwargs): 
1322          dict={} 
1323          # What was supplied to this function 
1324          dict.update(kwargs) 
1325          # Parent constructor 
1326          super(sms_in,self).__init__(**dict) 
1327          if self.__class__ is sms_in: 
1328              self._update(args,dict) 
1329   
1330   
1331 -    def getfields(self): 
1332          return self.__fields 
1333   
1334   
1335 -    def _update(self, args, kwargs): 
1336          super(sms_in,self)._update(args,kwargs) 
1337          keys=kwargs.keys() 
1338          for key in keys: 
1339              if key in self.__fields: 
1340                  setattr(self, key, kwargs[key]) 
1341                  del kwargs[key] 
1342          # Were any unrecognized kwargs passed in? 
1343          if __debug__: 
1344              self._complainaboutunusedargs(sms_in,kwargs) 
1345          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
1346          # Make all P fields that haven't already been constructed 
1347   
1348   
1349 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
1350          'Writes this packet to the supplied buffer' 
1351          self._bufferstartoffset=buf.getcurrentoffset() 
1352          self.__field_unknown1.writetobuffer(buf) 
1353          self.__field_timesent.writetobuffer(buf) 
1354          self.__field_unknown2.writetobuffer(buf) 
1355          self.__field_callback_length.writetobuffer(buf) 
1356          self.__field_callback.writetobuffer(buf) 
1357          self.__field_sender_length.writetobuffer(buf) 
1358          try: self.__field_sender 
1359          except: 
1360              self.__field_sender=LIST(**{'elementclass': _gen_p_lgvx5200_138, 'length': 38}) 
1361          self.__field_sender.writetobuffer(buf) 
1362          self.__field_unknown3.writetobuffer(buf) 
1363          self.__field_lg_time.writetobuffer(buf) 
1364          self.__field_unknown4.writetobuffer(buf) 
1365          self.__field_GPStime.writetobuffer(buf) 
1366          self.__field_unknown5.writetobuffer(buf) 
1367          self.__field_read.writetobuffer(buf) 
1368          self.__field_locked.writetobuffer(buf) 
1369          self.__field_unknown6.writetobuffer(buf) 
1370          self.__field_priority.writetobuffer(buf) 
1371          self.__field_subject.writetobuffer(buf) 
1372          self.__field_bin_header1.writetobuffer(buf) 
1373          self.__field_bin_header2.writetobuffer(buf) 
1374          self.__field_unknown7.writetobuffer(buf) 
1375          self.__field_multipartID.writetobuffer(buf) 
1376          self.__field_bin_header3.writetobuffer(buf) 
1377          self.__field_num_msg_elements.writetobuffer(buf) 
1378          try: self.__field_msglengths 
1379          except: 
1380              self.__field_msglengths=LIST(**{'elementclass': _gen_p_lgvx5200_156, 'length': 10}) 
1381          self.__field_msglengths.writetobuffer(buf) 
1382          self.__field_unknown8.writetobuffer(buf) 
1383          try: self.__field_msgs 
1384          except: 
1385              self.__field_msgs=LIST(**{'length': 10, 'elementclass': SMSINBOXMSGFRAGMENT}) 
1386          self.__field_msgs.writetobuffer(buf) 
1387          self.__field_unknown9.writetobuffer(buf) 
1388          self._bufferendoffset=buf.getcurrentoffset() 
1389          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
1390   
1391   
1392 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
1393          'Reads this packet from the supplied buffer' 
1394          self._bufferstartoffset=buf.getcurrentoffset() 
1395          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
1396          self.__field_unknown1=UNKNOWN(**{'sizeinbytes': 10}) 
1397          self.__field_unknown1.readfrombuffer(buf) 
1398          self.__field_timesent=SMSDATE(**{'sizeinbytes': 6}) 
1399          self.__field_timesent.readfrombuffer(buf) 
1400          self.__field_unknown2=UINT(**{'sizeinbytes': 3}) 
1401          self.__field_unknown2.readfrombuffer(buf) 
1402          self.__field_callback_length=UINT(**{'sizeinbytes': 1}) 
1403          self.__field_callback_length.readfrombuffer(buf) 
1404          self.__field_callback=USTRING(**{'sizeinbytes': 38}) 
1405          self.__field_callback.readfrombuffer(buf) 
1406          self.__field_sender_length=UINT(**{'sizeinbytes': 1}) 
1407          self.__field_sender_length.readfrombuffer(buf) 
1408          self.__field_sender=LIST(**{'elementclass': _gen_p_lgvx5200_138, 'length': 38}) 
1409          self.__field_sender.readfrombuffer(buf) 
1410          self.__field_unknown3=DATA(**{'sizeinbytes': 12}) 
1411          self.__field_unknown3.readfrombuffer(buf) 
1412          self.__field_lg_time=LGCALDATE(**{'sizeinbytes': 4}) 
1413          self.__field_lg_time.readfrombuffer(buf) 
1414          self.__field_unknown4=UNKNOWN(**{'sizeinbytes': 3}) 
1415          self.__field_unknown4.readfrombuffer(buf) 
1416          self.__field_GPStime=GPSDATE(**{'sizeinbytes': 4}) 
1417          self.__field_GPStime.readfrombuffer(buf) 
1418          self.__field_unknown5=UINT(**{'sizeinbytes': 4}) 
1419          self.__field_unknown5.readfrombuffer(buf) 
1420          self.__field_read=UINT(**{'sizeinbytes': 1}) 
1421          self.__field_read.readfrombuffer(buf) 
1422          self.__field_locked=UINT(**{'sizeinbytes': 1}) 
1423          self.__field_locked.readfrombuffer(buf) 
1424          self.__field_unknown6=UINT(**{'sizeinbytes': 8}) 
1425          self.__field_unknown6.readfrombuffer(buf) 
1426          self.__field_priority=UINT(**{'sizeinbytes': 1}) 
1427          self.__field_priority.readfrombuffer(buf) 
1428          self.__field_subject=USTRING(**{'sizeinbytes': 21, 'encoding': PHONE_ENCODING}) 
1429          self.__field_subject.readfrombuffer(buf) 
1430          self.__field_bin_header1=UINT(**{'sizeinbytes': 1}) 
1431          self.__field_bin_header1.readfrombuffer(buf) 
1432          self.__field_bin_header2=UINT(**{'sizeinbytes': 1}) 
1433          self.__field_bin_header2.readfrombuffer(buf) 
1434          self.__field_unknown7=UINT(**{'sizeinbytes': 4}) 
1435          self.__field_unknown7.readfrombuffer(buf) 
1436          self.__field_multipartID=UINT(**{'sizeinbytes': 2}) 
1437          self.__field_multipartID.readfrombuffer(buf) 
1438          self.__field_bin_header3=UINT(**{'sizeinbytes': 1}) 
1439          self.__field_bin_header3.readfrombuffer(buf) 
1440          self.__field_num_msg_elements=UINT(**{'sizeinbytes': 1}) 
1441          self.__field_num_msg_elements.readfrombuffer(buf) 
1442          self.__field_msglengths=LIST(**{'elementclass': _gen_p_lgvx5200_156, 'length': 10}) 
1443          self.__field_msglengths.readfrombuffer(buf) 
1444          self.__field_unknown8=UNKNOWN(**{'sizeinbytes': 10}) 
1445          self.__field_unknown8.readfrombuffer(buf) 
1446          self.__field_msgs=LIST(**{'length': 10, 'elementclass': SMSINBOXMSGFRAGMENT}) 
1447          self.__field_msgs.readfrombuffer(buf) 
1448          self.__field_unknown9=UNKNOWN() 
1449          self.__field_unknown9.readfrombuffer(buf) 
1450          self._bufferendoffset=buf.getcurrentoffset() 
1451   
1452   
1453 -    def __getfield_unknown1(self): 
1454          return self.__field_unknown1.getvalue() 
1455   
1456 -    def __setfield_unknown1(self, value): 
1457          if isinstance(value,UNKNOWN): 
1458              self.__field_unknown1=value 
1459          else: 
1460              self.__field_unknown1=UNKNOWN(value,**{'sizeinbytes': 10}) 
1461   
1462 -    def __delfield_unknown1(self): del self.__field_unknown1 
1463   
1464      unknown1=property(__getfield_unknown1, __setfield_unknown1, __delfield_unknown1, None) 
1465   
1466 -    def __getfield_timesent(self): 
1467          return self.__field_timesent.getvalue() 
1468   
1469 -    def __setfield_timesent(self, value): 
1470          if isinstance(value,SMSDATE): 
1471              self.__field_timesent=value 
1472          else: 
1473              self.__field_timesent=SMSDATE(value,**{'sizeinbytes': 6}) 
1474   
1475 -    def __delfield_timesent(self): del self.__field_timesent 
1476   
1477      timesent=property(__getfield_timesent, __setfield_timesent, __delfield_timesent, None) 
1478   
1479 -    def __getfield_unknown2(self): 
1480          return self.__field_unknown2.getvalue() 
1481   
1482 -    def __setfield_unknown2(self, value): 
1483          if isinstance(value,UINT): 
1484              self.__field_unknown2=value 
1485          else: 
1486              self.__field_unknown2=UINT(value,**{'sizeinbytes': 3}) 
1487   
1488 -    def __delfield_unknown2(self): del self.__field_unknown2 
1489   
1490      unknown2=property(__getfield_unknown2, __setfield_unknown2, __delfield_unknown2, None) 
1491   
1492 -    def __getfield_callback_length(self): 
1493          return self.__field_callback_length.getvalue() 
1494   
1495 -    def __setfield_callback_length(self, value): 
1496          if isinstance(value,UINT): 
1497              self.__field_callback_length=value 
1498          else: 
1499              self.__field_callback_length=UINT(value,**{'sizeinbytes': 1}) 
1500   
1501 -    def __delfield_callback_length(self): del self.__field_callback_length 
1502   
1503      callback_length=property(__getfield_callback_length, __setfield_callback_length, __delfield_callback_length, None) 
1504   
1505 -    def __getfield_callback(self): 
1506          return self.__field_callback.getvalue() 
1507   
1508 -    def __setfield_callback(self, value): 
1509          if isinstance(value,USTRING): 
1510              self.__field_callback=value 
1511          else: 
1512              self.__field_callback=USTRING(value,**{'sizeinbytes': 38}) 
1513   
1514 -    def __delfield_callback(self): del self.__field_callback 
1515   
1516      callback=property(__getfield_callback, __setfield_callback, __delfield_callback, None) 
1517   
1518 -    def __getfield_sender_length(self): 
1519          return self.__field_sender_length.getvalue() 
1520   
1521 -    def __setfield_sender_length(self, value): 
1522          if isinstance(value,UINT): 
1523              self.__field_sender_length=value 
1524          else: 
1525              self.__field_sender_length=UINT(value,**{'sizeinbytes': 1}) 
1526   
1527 -    def __delfield_sender_length(self): del self.__field_sender_length 
1528   
1529      sender_length=property(__getfield_sender_length, __setfield_sender_length, __delfield_sender_length, None) 
1530   
1531 -    def __getfield_sender(self): 
1532          try: self.__field_sender 
1533          except: 
1534              self.__field_sender=LIST(**{'elementclass': _gen_p_lgvx5200_138, 'length': 38}) 
1535          return self.__field_sender.getvalue() 
1536   
1537 -    def __setfield_sender(self, value): 
1538          if isinstance(value,LIST): 
1539              self.__field_sender=value 
1540          else: 
1541              self.__field_sender=LIST(value,**{'elementclass': _gen_p_lgvx5200_138, 'length': 38}) 
1542   
1543 -    def __delfield_sender(self): del self.__field_sender 
1544   
1545      sender=property(__getfield_sender, __setfield_sender, __delfield_sender, None) 
1546   
1547 -    def __getfield_unknown3(self): 
1548          return self.__field_unknown3.getvalue() 
1549   
1550 -    def __setfield_unknown3(self, value): 
1551          if isinstance(value,DATA): 
1552              self.__field_unknown3=value 
1553          else: 
1554              self.__field_unknown3=DATA(value,**{'sizeinbytes': 12}) 
1555   
1556 -    def __delfield_unknown3(self): del self.__field_unknown3 
1557   
1558      unknown3=property(__getfield_unknown3, __setfield_unknown3, __delfield_unknown3, None) 
1559   
1560 -    def __getfield_lg_time(self): 
1561          return self.__field_lg_time.getvalue() 
1562   
1563 -    def __setfield_lg_time(self, value): 
1564          if isinstance(value,LGCALDATE): 
1565              self.__field_lg_time=value 
1566          else: 
1567              self.__field_lg_time=LGCALDATE(value,**{'sizeinbytes': 4}) 
1568   
1569 -    def __delfield_lg_time(self): del self.__field_lg_time 
1570   
1571      lg_time=property(__getfield_lg_time, __setfield_lg_time, __delfield_lg_time, None) 
1572   
1573 -    def __getfield_unknown4(self): 
1574          return self.__field_unknown4.getvalue() 
1575   
1576 -    def __setfield_unknown4(self, value): 
1577          if isinstance(value,UNKNOWN): 
1578              self.__field_unknown4=value 
1579          else: 
1580              self.__field_unknown4=UNKNOWN(value,**{'sizeinbytes': 3}) 
1581   
1582 -    def __delfield_unknown4(self): del self.__field_unknown4 
1583   
1584      unknown4=property(__getfield_unknown4, __setfield_unknown4, __delfield_unknown4, None) 
1585   
1586 -    def __getfield_GPStime(self): 
1587          return self.__field_GPStime.getvalue() 
1588   
1589 -    def __setfield_GPStime(self, value): 
1590          if isinstance(value,GPSDATE): 
1591              self.__field_GPStime=value 
1592          else: 
1593              self.__field_GPStime=GPSDATE(value,**{'sizeinbytes': 4}) 
1594   
1595 -    def __delfield_GPStime(self): del self.__field_GPStime 
1596   
1597      GPStime=property(__getfield_GPStime, __setfield_GPStime, __delfield_GPStime, None) 
1598   
1599 -    def __getfield_unknown5(self): 
1600          return self.__field_unknown5.getvalue() 
1601   
1602 -    def __setfield_unknown5(self, value): 
1603          if isinstance(value,UINT): 
1604              self.__field_unknown5=value 
1605          else: 
1606              self.__field_unknown5=UINT(value,**{'sizeinbytes': 4}) 
1607   
1608 -    def __delfield_unknown5(self): del self.__field_unknown5 
1609   
1610      unknown5=property(__getfield_unknown5, __setfield_unknown5, __delfield_unknown5, None) 
1611   
1612 -    def __getfield_read(self): 
1613          return self.__field_read.getvalue() 
1614   
1615 -    def __setfield_read(self, value): 
1616          if isinstance(value,UINT): 
1617              self.__field_read=value 
1618          else: 
1619              self.__field_read=UINT(value,**{'sizeinbytes': 1}) 
1620   
1621 -    def __delfield_read(self): del self.__field_read 
1622   
1623      read=property(__getfield_read, __setfield_read, __delfield_read, None) 
1624   
1625 -    def __getfield_locked(self): 
1626          return self.__field_locked.getvalue() 
1627   
1628 -    def __setfield_locked(self, value): 
1629          if isinstance(value,UINT): 
1630              self.__field_locked=value 
1631          else: 
1632              self.__field_locked=UINT(value,**{'sizeinbytes': 1}) 
1633   
1634 -    def __delfield_locked(self): del self.__field_locked 
1635   
1636      locked=property(__getfield_locked, __setfield_locked, __delfield_locked, None) 
1637   
1638 -    def __getfield_unknown6(self): 
1639          return self.__field_unknown6.getvalue() 
1640   
1641 -    def __setfield_unknown6(self, value): 
1642          if isinstance(value,UINT): 
1643              self.__field_unknown6=value 
1644          else: 
1645              self.__field_unknown6=UINT(value,**{'sizeinbytes': 8}) 
1646   
1647 -    def __delfield_unknown6(self): del self.__field_unknown6 
1648   
1649      unknown6=property(__getfield_unknown6, __setfield_unknown6, __delfield_unknown6, None) 
1650   
1651 -    def __getfield_priority(self): 
1652          return self.__field_priority.getvalue() 
1653   
1654 -    def __setfield_priority(self, value): 
1655          if isinstance(value,UINT): 
1656              self.__field_priority=value 
1657          else: 
1658              self.__field_priority=UINT(value,**{'sizeinbytes': 1}) 
1659   
1660 -    def __delfield_priority(self): del self.__field_priority 
1661   
1662      priority=property(__getfield_priority, __setfield_priority, __delfield_priority, None) 
1663   
1664 -    def __getfield_subject(self): 
1665          return self.__field_subject.getvalue() 
1666   
1667 -    def __setfield_subject(self, value): 
1668          if isinstance(value,USTRING): 
1669              self.__field_subject=value 
1670          else: 
1671              self.__field_subject=USTRING(value,**{'sizeinbytes': 21, 'encoding': PHONE_ENCODING}) 
1672   
1673 -    def __delfield_subject(self): del self.__field_subject 
1674   
1675      subject=property(__getfield_subject, __setfield_subject, __delfield_subject, None) 
1676   
1677 -    def __getfield_bin_header1(self): 
1678          return self.__field_bin_header1.getvalue() 
1679   
1680 -    def __setfield_bin_header1(self, value): 
1681          if isinstance(value,UINT): 
1682              self.__field_bin_header1=value 
1683          else: 
1684              self.__field_bin_header1=UINT(value,**{'sizeinbytes': 1}) 
1685   
1686 -    def __delfield_bin_header1(self): del self.__field_bin_header1 
1687   
1688      bin_header1=property(__getfield_bin_header1, __setfield_bin_header1, __delfield_bin_header1, None) 
1689   
1690 -    def __getfield_bin_header2(self): 
1691          return self.__field_bin_header2.getvalue() 
1692   
1693 -    def __setfield_bin_header2(self, value): 
1694          if isinstance(value,UINT): 
1695              self.__field_bin_header2=value 
1696          else: 
1697              self.__field_bin_header2=UINT(value,**{'sizeinbytes': 1}) 
1698   
1699 -    def __delfield_bin_header2(self): del self.__field_bin_header2 
1700   
1701      bin_header2=property(__getfield_bin_header2, __setfield_bin_header2, __delfield_bin_header2, None) 
1702   
1703 -    def __getfield_unknown7(self): 
1704          return self.__field_unknown7.getvalue() 
1705   
1706 -    def __setfield_unknown7(self, value): 
1707          if isinstance(value,UINT): 
1708              self.__field_unknown7=value 
1709          else: 
1710              self.__field_unknown7=UINT(value,**{'sizeinbytes': 4}) 
1711   
1712 -    def __delfield_unknown7(self): del self.__field_unknown7 
1713   
1714      unknown7=property(__getfield_unknown7, __setfield_unknown7, __delfield_unknown7, None) 
1715   
1716 -    def __getfield_multipartID(self): 
1717          return self.__field_multipartID.getvalue() 
1718   
1719 -    def __setfield_multipartID(self, value): 
1720          if isinstance(value,UINT): 
1721              self.__field_multipartID=value 
1722          else: 
1723              self.__field_multipartID=UINT(value,**{'sizeinbytes': 2}) 
1724   
1725 -    def __delfield_multipartID(self): del self.__field_multipartID 
1726   
1727      multipartID=property(__getfield_multipartID, __setfield_multipartID, __delfield_multipartID, None) 
1728   
1729 -    def __getfield_bin_header3(self): 
1730          return self.__field_bin_header3.getvalue() 
1731   
1732 -    def __setfield_bin_header3(self, value): 
1733          if isinstance(value,UINT): 
1734              self.__field_bin_header3=value 
1735          else: 
1736              self.__field_bin_header3=UINT(value,**{'sizeinbytes': 1}) 
1737   
1738 -    def __delfield_bin_header3(self): del self.__field_bin_header3 
1739   
1740      bin_header3=property(__getfield_bin_header3, __setfield_bin_header3, __delfield_bin_header3, None) 
1741   
1742 -    def __getfield_num_msg_elements(self): 
1743          return self.__field_num_msg_elements.getvalue() 
1744   
1745 -    def __setfield_num_msg_elements(self, value): 
1746          if isinstance(value,UINT): 
1747              self.__field_num_msg_elements=value 
1748          else: 
1749              self.__field_num_msg_elements=UINT(value,**{'sizeinbytes': 1}) 
1750   
1751 -    def __delfield_num_msg_elements(self): del self.__field_num_msg_elements 
1752   
1753      num_msg_elements=property(__getfield_num_msg_elements, __setfield_num_msg_elements, __delfield_num_msg_elements, None) 
1754   
1755 -    def __getfield_msglengths(self): 
1756          try: self.__field_msglengths 
1757          except: 
1758              self.__field_msglengths=LIST(**{'elementclass': _gen_p_lgvx5200_156, 'length': 10}) 
1759          return self.__field_msglengths.getvalue() 
1760   
1761 -    def __setfield_msglengths(self, value): 
1762          if isinstance(value,LIST): 
1763              self.__field_msglengths=value 
1764          else: 
1765              self.__field_msglengths=LIST(value,**{'elementclass': _gen_p_lgvx5200_156, 'length': 10}) 
1766   
1767 -    def __delfield_msglengths(self): del self.__field_msglengths 
1768   
1769      msglengths=property(__getfield_msglengths, __setfield_msglengths, __delfield_msglengths, None) 
1770   
1771 -    def __getfield_unknown8(self): 
1772          return self.__field_unknown8.getvalue() 
1773   
1774 -    def __setfield_unknown8(self, value): 
1775          if isinstance(value,UNKNOWN): 
1776              self.__field_unknown8=value 
1777          else: 
1778              self.__field_unknown8=UNKNOWN(value,**{'sizeinbytes': 10}) 
1779   
1780 -    def __delfield_unknown8(self): del self.__field_unknown8 
1781   
1782      unknown8=property(__getfield_unknown8, __setfield_unknown8, __delfield_unknown8, None) 
1783   
1784 -    def __getfield_msgs(self): 
1785          try: self.__field_msgs 
1786          except: 
1787              self.__field_msgs=LIST(**{'length': 10, 'elementclass': SMSINBOXMSGFRAGMENT}) 
1788          return self.__field_msgs.getvalue() 
1789   
1790 -    def __setfield_msgs(self, value): 
1791          if isinstance(value,LIST): 
1792              self.__field_msgs=value 
1793          else: 
1794              self.__field_msgs=LIST(value,**{'length': 10, 'elementclass': SMSINBOXMSGFRAGMENT}) 
1795   
1796 -    def __delfield_msgs(self): del self.__field_msgs 
1797   
1798      msgs=property(__getfield_msgs, __setfield_msgs, __delfield_msgs, None) 
1799   
1800 -    def __getfield_unknown9(self): 
1801          return self.__field_unknown9.getvalue() 
1802   
1803 -    def __setfield_unknown9(self, value): 
1804          if isinstance(value,UNKNOWN): 
1805              self.__field_unknown9=value 
1806          else: 
1807              self.__field_unknown9=UNKNOWN(value,) 
1808   
1809 -    def __delfield_unknown9(self): del self.__field_unknown9 
1810   
1811      unknown9=property(__getfield_unknown9, __setfield_unknown9, __delfield_unknown9, None) 
1812   
1813 -    def iscontainer(self): 
1814          return True 
1815   
1816 -    def containerelements(self): 
1817          yield ('unknown1', self.__field_unknown1, None) 
1818          yield ('timesent', self.__field_timesent, None) 
1819          yield ('unknown2', self.__field_unknown2, None) 
1820          yield ('callback_length', self.__field_callback_length, None) 
1821          yield ('callback', self.__field_callback, None) 
1822          yield ('sender_length', self.__field_sender_length, None) 
1823          yield ('sender', self.__field_sender, None) 
1824          yield ('unknown3', self.__field_unknown3, None) 
1825          yield ('lg_time', self.__field_lg_time, None) 
1826          yield ('unknown4', self.__field_unknown4, None) 
1827          yield ('GPStime', self.__field_GPStime, None) 
1828          yield ('unknown5', self.__field_unknown5, None) 
1829          yield ('read', self.__field_read, None) 
1830          yield ('locked', self.__field_locked, None) 
1831          yield ('unknown6', self.__field_unknown6, None) 
1832          yield ('priority', self.__field_priority, None) 
1833          yield ('subject', self.__field_subject, None) 
1834          yield ('bin_header1', self.__field_bin_header1, None) 
1835          yield ('bin_header2', self.__field_bin_header2, None) 
1836          yield ('unknown7', self.__field_unknown7, None) 
1837          yield ('multipartID', self.__field_multipartID, None) 
1838          yield ('bin_header3', self.__field_bin_header3, None) 
1839          yield ('num_msg_elements', self.__field_num_msg_elements, None) 
1840          yield ('msglengths', self.__field_msglengths, None) 
1841          yield ('unknown8', self.__field_unknown8, None) 
1842          yield ('msgs', self.__field_msgs, None) 
1843          yield ('unknown9', self.__field_unknown9, None) 
1844   
1845   
1846   
1847   
1848 -class _gen_p_lgvx5200_138(BaseProtogenClass): 
1849      'Anonymous inner class' 
1850      __fields=['byte'] 
1851   
1852 -    def __init__(self, *args, **kwargs): 
1853          dict={} 
1854          # What was supplied to this function 
1855          dict.update(kwargs) 
1856          # Parent constructor 
1857          super(_gen_p_lgvx5200_138,self).__init__(**dict) 
1858          if self.__class__ is _gen_p_lgvx5200_138: 
1859              self._update(args,dict) 
1860   
1861   
1862 -    def getfields(self): 
1863          return self.__fields 
1864   
1865   
1866 -    def _update(self, args, kwargs): 
1867          super(_gen_p_lgvx5200_138,self)._update(args,kwargs) 
1868          keys=kwargs.keys() 
1869          for key in keys: 
1870              if key in self.__fields: 
1871                  setattr(self, key, kwargs[key]) 
1872                  del kwargs[key] 
1873          # Were any unrecognized kwargs passed in? 
1874          if __debug__: 
1875              self._complainaboutunusedargs(_gen_p_lgvx5200_138,kwargs) 
1876          if len(args): 
1877              dict2={'sizeinbytes': 1} 
1878              dict2.update(kwargs) 
1879              kwargs=dict2 
1880              self.__field_byte=UINT(*args,**dict2) 
1881          # Make all P fields that haven't already been constructed 
1882   
1883   
1884 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
1885          'Writes this packet to the supplied buffer' 
1886          self._bufferstartoffset=buf.getcurrentoffset() 
1887          self.__field_byte.writetobuffer(buf) 
1888          self._bufferendoffset=buf.getcurrentoffset() 
1889          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
1890   
1891   
1892 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
1893          'Reads this packet from the supplied buffer' 
1894          self._bufferstartoffset=buf.getcurrentoffset() 
1895          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
1896          self.__field_byte=UINT(**{'sizeinbytes': 1}) 
1897          self.__field_byte.readfrombuffer(buf) 
1898          self._bufferendoffset=buf.getcurrentoffset() 
1899   
1900   
1901 -    def __getfield_byte(self): 
1902          return self.__field_byte.getvalue() 
1903   
1904 -    def __setfield_byte(self, value): 
1905          if isinstance(value,UINT): 
1906              self.__field_byte=value 
1907          else: 
1908              self.__field_byte=UINT(value,**{'sizeinbytes': 1}) 
1909   
1910 -    def __delfield_byte(self): del self.__field_byte 
1911   
1912      byte=property(__getfield_byte, __setfield_byte, __delfield_byte, "individual byte of senders phone number") 
1913   
1914 -    def iscontainer(self): 
1915          return True 
1916   
1917 -    def containerelements(self): 
1918          yield ('byte', self.__field_byte, "individual byte of senders phone number") 
1919   
1920   
1921   
1922   
1923 -class _gen_p_lgvx5200_156(BaseProtogenClass): 
1924      'Anonymous inner class' 
1925      __fields=['msglength'] 
1926   
1927 -    def __init__(self, *args, **kwargs): 
1928          dict={} 
1929          # What was supplied to this function 
1930          dict.update(kwargs) 
1931          # Parent constructor 
1932          super(_gen_p_lgvx5200_156,self).__init__(**dict) 
1933          if self.__class__ is _gen_p_lgvx5200_156: 
1934              self._update(args,dict) 
1935   
1936   
1937 -    def getfields(self): 
1938          return self.__fields 
1939   
1940   
1941 -    def _update(self, args, kwargs): 
1942          super(_gen_p_lgvx5200_156,self)._update(args,kwargs) 
1943          keys=kwargs.keys() 
1944          for key in keys: 
1945              if key in self.__fields: 
1946                  setattr(self, key, kwargs[key]) 
1947                  del kwargs[key] 
1948          # Were any unrecognized kwargs passed in? 
1949          if __debug__: 
1950              self._complainaboutunusedargs(_gen_p_lgvx5200_156,kwargs) 
1951          if len(args): 
1952              dict2={'sizeinbytes': 1} 
1953              dict2.update(kwargs) 
1954              kwargs=dict2 
1955              self.__field_msglength=UINT(*args,**dict2) 
1956          # Make all P fields that haven't already been constructed 
1957   
1958   
1959 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
1960          'Writes this packet to the supplied buffer' 
1961          self._bufferstartoffset=buf.getcurrentoffset() 
1962          self.__field_msglength.writetobuffer(buf) 
1963          self._bufferendoffset=buf.getcurrentoffset() 
1964          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
1965   
1966   
1967 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
1968          'Reads this packet from the supplied buffer' 
1969          self._bufferstartoffset=buf.getcurrentoffset() 
1970          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
1971          self.__field_msglength=UINT(**{'sizeinbytes': 1}) 
1972          self.__field_msglength.readfrombuffer(buf) 
1973          self._bufferendoffset=buf.getcurrentoffset() 
1974   
1975   
1976 -    def __getfield_msglength(self): 
1977          return self.__field_msglength.getvalue() 
1978   
1979 -    def __setfield_msglength(self, value): 
1980          if isinstance(value,UINT): 
1981              self.__field_msglength=value 
1982          else: 
1983              self.__field_msglength=UINT(value,**{'sizeinbytes': 1}) 
1984   
1985 -    def __delfield_msglength(self): del self.__field_msglength 
1986   
1987      msglength=property(__getfield_msglength, __setfield_msglength, __delfield_msglength, "lengths of individual messages in septets") 
1988   
1989 -    def iscontainer(self): 
1990          return True 
1991   
1992 -    def containerelements(self): 
1993          yield ('msglength', self.__field_msglength, "lengths of individual messages in septets") 
1994   
1995   
1996   
1997   
1998 -class sms_quick_text(BaseProtogenClass): 
1999      __fields=['msgs'] 
2000   
2001 -    def __init__(self, *args, **kwargs): 
2002          dict={} 
2003          # What was supplied to this function 
2004          dict.update(kwargs) 
2005          # Parent constructor 
2006          super(sms_quick_text,self).__init__(**dict) 
2007          if self.__class__ is sms_quick_text: 
2008              self._update(args,dict) 
2009   
2010   
2011 -    def getfields(self): 
2012          return self.__fields 
2013   
2014   
2015 -    def _update(self, args, kwargs): 
2016          super(sms_quick_text,self)._update(args,kwargs) 
2017          keys=kwargs.keys() 
2018          for key in keys: 
2019              if key in self.__fields: 
2020                  setattr(self, key, kwargs[key]) 
2021                  del kwargs[key] 
2022          # Were any unrecognized kwargs passed in? 
2023          if __debug__: 
2024              self._complainaboutunusedargs(sms_quick_text,kwargs) 
2025          if len(args): 
2026              dict2={'elementclass': _gen_p_lgvx5200_169,  'length': SMS_CANNED_MAX_ITEMS, 'createdefault': True} 
2027              dict2.update(kwargs) 
2028              kwargs=dict2 
2029              self.__field_msgs=LIST(*args,**dict2) 
2030          # Make all P fields that haven't already been constructed 
2031   
2032   
2033 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
2034          'Writes this packet to the supplied buffer' 
2035          self._bufferstartoffset=buf.getcurrentoffset() 
2036          try: self.__field_msgs 
2037          except: 
2038              self.__field_msgs=LIST(**{'elementclass': _gen_p_lgvx5200_169,  'length': SMS_CANNED_MAX_ITEMS, 'createdefault': True}) 
2039          self.__field_msgs.writetobuffer(buf) 
2040          self._bufferendoffset=buf.getcurrentoffset() 
2041          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
2042   
2043   
2044 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
2045          'Reads this packet from the supplied buffer' 
2046          self._bufferstartoffset=buf.getcurrentoffset() 
2047          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
2048          self.__field_msgs=LIST(**{'elementclass': _gen_p_lgvx5200_169,  'length': SMS_CANNED_MAX_ITEMS, 'createdefault': True}) 
2049          self.__field_msgs.readfrombuffer(buf) 
2050          self._bufferendoffset=buf.getcurrentoffset() 
2051   
2052   
2053 -    def __getfield_msgs(self): 
2054          try: self.__field_msgs 
2055          except: 
2056              self.__field_msgs=LIST(**{'elementclass': _gen_p_lgvx5200_169,  'length': SMS_CANNED_MAX_ITEMS, 'createdefault': True}) 
2057          return self.__field_msgs.getvalue() 
2058   
2059 -    def __setfield_msgs(self, value): 
2060          if isinstance(value,LIST): 
2061              self.__field_msgs=value 
2062          else: 
2063              self.__field_msgs=LIST(value,**{'elementclass': _gen_p_lgvx5200_169,  'length': SMS_CANNED_MAX_ITEMS, 'createdefault': True}) 
2064   
2065 -    def __delfield_msgs(self): del self.__field_msgs 
2066   
2067      msgs=property(__getfield_msgs, __setfield_msgs, __delfield_msgs, None) 
2068   
2069 -    def iscontainer(self): 
2070          return True 
2071   
2072 -    def containerelements(self): 
2073          yield ('msgs', self.__field_msgs, None) 
2074   
2075   
2076   
2077   
2078 -class _gen_p_lgvx5200_169(BaseProtogenClass): 
2079      'Anonymous inner class' 
2080      __fields=['msg'] 
2081   
2082 -    def __init__(self, *args, **kwargs): 
2083          dict={} 
2084          # What was supplied to this function 
2085          dict.update(kwargs) 
2086          # Parent constructor 
2087          super(_gen_p_lgvx5200_169,self).__init__(**dict) 
2088          if self.__class__ is _gen_p_lgvx5200_169: 
2089              self._update(args,dict) 
2090   
2091   
2092 -    def getfields(self): 
2093          return self.__fields 
2094   
2095   
2096 -    def _update(self, args, kwargs): 
2097          super(_gen_p_lgvx5200_169,self)._update(args,kwargs) 
2098          keys=kwargs.keys() 
2099          for key in keys: 
2100              if key in self.__fields: 
2101                  setattr(self, key, kwargs[key]) 
2102                  del kwargs[key] 
2103          # Were any unrecognized kwargs passed in? 
2104          if __debug__: 
2105              self._complainaboutunusedargs(_gen_p_lgvx5200_169,kwargs) 
2106          if len(args): 
2107              dict2={'sizeinbytes': 101, 'encoding': PHONE_ENCODING, 'default': ""} 
2108              dict2.update(kwargs) 
2109              kwargs=dict2 
2110              self.__field_msg=USTRING(*args,**dict2) 
2111          # Make all P fields that haven't already been constructed 
2112   
2113   
2114 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
2115          'Writes this packet to the supplied buffer' 
2116          self._bufferstartoffset=buf.getcurrentoffset() 
2117          try: self.__field_msg 
2118          except: 
2119              self.__field_msg=USTRING(**{'sizeinbytes': 101, 'encoding': PHONE_ENCODING, 'default': ""}) 
2120          self.__field_msg.writetobuffer(buf) 
2121          self._bufferendoffset=buf.getcurrentoffset() 
2122          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
2123   
2124   
2125 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
2126          'Reads this packet from the supplied buffer' 
2127          self._bufferstartoffset=buf.getcurrentoffset() 
2128          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
2129          self.__field_msg=USTRING(**{'sizeinbytes': 101, 'encoding': PHONE_ENCODING, 'default': ""}) 
2130          self.__field_msg.readfrombuffer(buf) 
2131          self._bufferendoffset=buf.getcurrentoffset() 
2132   
2133   
2134 -    def __getfield_msg(self): 
2135          try: self.__field_msg 
2136          except: 
2137              self.__field_msg=USTRING(**{'sizeinbytes': 101, 'encoding': PHONE_ENCODING, 'default': ""}) 
2138          return self.__field_msg.getvalue() 
2139   
2140 -    def __setfield_msg(self, value): 
2141          if isinstance(value,USTRING): 
2142              self.__field_msg=value 
2143          else: 
2144              self.__field_msg=USTRING(value,**{'sizeinbytes': 101, 'encoding': PHONE_ENCODING, 'default': ""}) 
2145   
2146 -    def __delfield_msg(self): del self.__field_msg 
2147   
2148      msg=property(__getfield_msg, __setfield_msg, __delfield_msg, None) 
2149   
2150 -    def iscontainer(self): 
2151          return True 
2152   
2153 -    def containerelements(self): 
2154          yield ('msg', self.__field_msg, None) 
2155   
2156   
2157   
2158   
2159 -class textmemo(BaseProtogenClass): 
2160      __fields=['dunno', 'GPStime', 'memotime', 'text'] 
2161   
2162 -    def __init__(self, *args, **kwargs): 
2163          dict={} 
2164          # What was supplied to this function 
2165          dict.update(kwargs) 
2166          # Parent constructor 
2167          super(textmemo,self).__init__(**dict) 
2168          if self.__class__ is textmemo: 
2169              self._update(args,dict) 
2170   
2171   
2172 -    def getfields(self): 
2173          return self.__fields 
2174   
2175   
2176 -    def _update(self, args, kwargs): 
2177          super(textmemo,self)._update(args,kwargs) 
2178          keys=kwargs.keys() 
2179          for key in keys: 
2180              if key in self.__fields: 
2181                  setattr(self, key, kwargs[key]) 
2182                  del kwargs[key] 
2183          # Were any unrecognized kwargs passed in? 
2184          if __debug__: 
2185              self._complainaboutunusedargs(textmemo,kwargs) 
2186          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
2187          # Make all P fields that haven't already been constructed 
2188   
2189   
2190 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
2191          'Writes this packet to the supplied buffer' 
2192          self._bufferstartoffset=buf.getcurrentoffset() 
2193          try: self.__field_dunno 
2194          except: 
2195              self.__field_dunno=UINT(**{'sizeinbytes': 4,  'constant':1 }) 
2196          self.__field_dunno.writetobuffer(buf) 
2197          self.__field_GPStime.writetobuffer(buf) 
2198          self.__field_memotime.writetobuffer(buf) 
2199          self.__field_text.writetobuffer(buf) 
2200          self._bufferendoffset=buf.getcurrentoffset() 
2201          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
2202   
2203   
2204 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
2205          'Reads this packet from the supplied buffer' 
2206          self._bufferstartoffset=buf.getcurrentoffset() 
2207          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
2208          self.__field_dunno=UINT(**{'sizeinbytes': 4,  'constant':1 }) 
2209          self.__field_dunno.readfrombuffer(buf) 
2210          self.__field_GPStime=GPSDATE(**{'sizeinbytes': 4}) 
2211          self.__field_GPStime.readfrombuffer(buf) 
2212          self.__field_memotime=LGCALDATE(**{'sizeinbytes': 4}) 
2213          self.__field_memotime.readfrombuffer(buf) 
2214          self.__field_text=USTRING(**{'sizeinbytes': 152, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False, 'raiseontruncate': False }) 
2215          self.__field_text.readfrombuffer(buf) 
2216          self._bufferendoffset=buf.getcurrentoffset() 
2217   
2218   
2219 -    def __getfield_dunno(self): 
2220          try: self.__field_dunno 
2221          except: 
2222              self.__field_dunno=UINT(**{'sizeinbytes': 4,  'constant':1 }) 
2223          return self.__field_dunno.getvalue() 
2224   
2225 -    def __setfield_dunno(self, value): 
2226          if isinstance(value,UINT): 
2227              self.__field_dunno=value 
2228          else: 
2229              self.__field_dunno=UINT(value,**{'sizeinbytes': 4,  'constant':1 }) 
2230   
2231 -    def __delfield_dunno(self): del self.__field_dunno 
2232   
2233      dunno=property(__getfield_dunno, __setfield_dunno, __delfield_dunno, None) 
2234   
2235 -    def __getfield_GPStime(self): 
2236          return self.__field_GPStime.getvalue() 
2237   
2238 -    def __setfield_GPStime(self, value): 
2239          if isinstance(value,GPSDATE): 
2240              self.__field_GPStime=value 
2241          else: 
2242              self.__field_GPStime=GPSDATE(value,**{'sizeinbytes': 4}) 
2243   
2244 -    def __delfield_GPStime(self): del self.__field_GPStime 
2245   
2246      GPStime=property(__getfield_GPStime, __setfield_GPStime, __delfield_GPStime, None) 
2247   
2248 -    def __getfield_memotime(self): 
2249          return self.__field_memotime.getvalue() 
2250   
2251 -    def __setfield_memotime(self, value): 
2252          if isinstance(value,LGCALDATE): 
2253              self.__field_memotime=value 
2254          else: 
2255              self.__field_memotime=LGCALDATE(value,**{'sizeinbytes': 4}) 
2256   
2257 -    def __delfield_memotime(self): del self.__field_memotime 
2258   
2259      memotime=property(__getfield_memotime, __setfield_memotime, __delfield_memotime, None) 
2260   
2261 -    def __getfield_text(self): 
2262          return self.__field_text.getvalue() 
2263   
2264 -    def __setfield_text(self, value): 
2265          if isinstance(value,USTRING): 
2266              self.__field_text=value 
2267          else: 
2268              self.__field_text=USTRING(value,**{'sizeinbytes': 152, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False, 'raiseontruncate': False }) 
2269   
2270 -    def __delfield_text(self): del self.__field_text 
2271   
2272      text=property(__getfield_text, __setfield_text, __delfield_text, None) 
2273   
2274 -    def iscontainer(self): 
2275          return True 
2276   
2277 -    def containerelements(self): 
2278          yield ('dunno', self.__field_dunno, None) 
2279          yield ('GPStime', self.__field_GPStime, None) 
2280          yield ('memotime', self.__field_memotime, None) 
2281          yield ('text', self.__field_text, None) 
2282   
2283   
2284   
2285   
2286 -class textmemofile(BaseProtogenClass): 
2287      __fields=['itemcount', 'items'] 
2288   
2289 -    def __init__(self, *args, **kwargs): 
2290          dict={} 
2291          # What was supplied to this function 
2292          dict.update(kwargs) 
2293          # Parent constructor 
2294          super(textmemofile,self).__init__(**dict) 
2295          if self.__class__ is textmemofile: 
2296              self._update(args,dict) 
2297   
2298   
2299 -    def getfields(self): 
2300          return self.__fields 
2301   
2302   
2303 -    def _update(self, args, kwargs): 
2304          super(textmemofile,self)._update(args,kwargs) 
2305          keys=kwargs.keys() 
2306          for key in keys: 
2307              if key in self.__fields: 
2308                  setattr(self, key, kwargs[key]) 
2309                  del kwargs[key] 
2310          # Were any unrecognized kwargs passed in? 
2311          if __debug__: 
2312              self._complainaboutunusedargs(textmemofile,kwargs) 
2313          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
2314          # Make all P fields that haven't already been constructed 
2315   
2316   
2317 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
2318          'Writes this packet to the supplied buffer' 
2319          self._bufferstartoffset=buf.getcurrentoffset() 
2320          self.__field_itemcount.writetobuffer(buf) 
2321          try: self.__field_items 
2322          except: 
2323              self.__field_items=LIST(**{ 'elementclass': textmemo }) 
2324          self.__field_items.writetobuffer(buf) 
2325          self._bufferendoffset=buf.getcurrentoffset() 
2326          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
2327   
2328   
2329 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
2330          'Reads this packet from the supplied buffer' 
2331          self._bufferstartoffset=buf.getcurrentoffset() 
2332          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
2333          self.__field_itemcount=UINT(**{'sizeinbytes': 4}) 
2334          self.__field_itemcount.readfrombuffer(buf) 
2335          self.__field_items=LIST(**{ 'elementclass': textmemo }) 
2336          self.__field_items.readfrombuffer(buf) 
2337          self._bufferendoffset=buf.getcurrentoffset() 
2338   
2339   
2340 -    def __getfield_itemcount(self): 
2341          return self.__field_itemcount.getvalue() 
2342   
2343 -    def __setfield_itemcount(self, value): 
2344          if isinstance(value,UINT): 
2345              self.__field_itemcount=value 
2346          else: 
2347              self.__field_itemcount=UINT(value,**{'sizeinbytes': 4}) 
2348   
2349 -    def __delfield_itemcount(self): del self.__field_itemcount 
2350   
2351      itemcount=property(__getfield_itemcount, __setfield_itemcount, __delfield_itemcount, None) 
2352   
2353 -    def __getfield_items(self): 
2354          try: self.__field_items 
2355          except: 
2356              self.__field_items=LIST(**{ 'elementclass': textmemo }) 
2357          return self.__field_items.getvalue() 
2358   
2359 -    def __setfield_items(self, value): 
2360          if isinstance(value,LIST): 
2361              self.__field_items=value 
2362          else: 
2363              self.__field_items=LIST(value,**{ 'elementclass': textmemo }) 
2364   
2365 -    def __delfield_items(self): del self.__field_items 
2366   
2367      items=property(__getfield_items, __setfield_items, __delfield_items, None) 
2368   
2369 -    def iscontainer(self): 
2370          return True 
2371   
2372 -    def containerelements(self): 
2373          yield ('itemcount', self.__field_itemcount, None) 
2374          yield ('items', self.__field_items, None) 
2375