Source Code for Module phones.p_lgvx9900

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