Source Code for Module phones.p_lgvx8800

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