Source Code for Module phones.p_lgvx8300

   1  # THIS FILE IS AUTOMATICALLY GENERATED.  EDIT THE SOURCE FILE NOT THIS ONE 
   2   
   3  """Various descriptions of data specific to LG VX8300""" 
   4   
   5  from common import PhoneBookBusyException 
   6   
   7  from prototypes import * 
   8   
   9  # Make all lg stuff available in this module as well 
  10  from p_lg import * 
  11   
  12  # we are the same as lgvx8100 except as noted 
  13  # below 
  14  from p_lgvx8100 import * 
  15   
  16  # We use LSB for all integer like fields 
  17  UINT=UINTlsb 
  18  BOOL=BOOLlsb 
  19   
  20  BREW_FILE_SYSTEM=0 
  21   
  22  PHONE_ENCODING='iso-8859-1' 
  23   
  24  NUMSPEEDDIALS=100 
  25  FIRSTSPEEDDIAL=2 
  26  LASTSPEEDDIAL=99 
  27  NUMPHONEBOOKENTRIES=500 
  28  MAXCALENDARDESCRIPTION=32 
  29  CALENDAR_HAS_SEPARATE_END_TIME_AND_DATE=1 
  30   
  31  NUMEMAILS=2 
  32  NUMPHONENUMBERS=5 
  33   
  34  # need to call stat to get the file time/data 
  35  broken_filelist_date=True 
  36 -class indexentry(BaseProtogenClass): 
  37      __fields=['filename', 'size', 'date', 'type'] 
  38   
  39 -    def __init__(self, *args, **kwargs): 
  40          dict={} 
  41          # What was supplied to this function 
  42          dict.update(kwargs) 
  43          # Parent constructor 
  44          super(indexentry,self).__init__(**dict) 
  45          if self.__class__ is indexentry: 
  46              self._update(args,dict) 
  47   
  48   
  49 -    def getfields(self): 
  50          return self.__fields 
  51   
  52   
  53 -    def _update(self, args, kwargs): 
  54          super(indexentry,self)._update(args,kwargs) 
  55          keys=kwargs.keys() 
  56          for key in keys: 
  57              if key in self.__fields: 
  58                  setattr(self, key, kwargs[key]) 
  59                  del kwargs[key] 
  60          # Were any unrecognized kwargs passed in? 
  61          if __debug__: 
  62              self._complainaboutunusedargs(indexentry,kwargs) 
  63          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
  64          # Make all P fields that haven't already been constructed 
  65   
  66   
  67 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
  68          'Writes this packet to the supplied buffer' 
  69          self._bufferstartoffset=buf.getcurrentoffset() 
  70          self.__field_filename.writetobuffer(buf) 
  71          self.__field_size.writetobuffer(buf) 
  72          try: self.__field_date 
  73          except: 
  74              self.__field_date=UINT(**{'sizeinbytes': 4, 'default': 0}) 
  75          self.__field_date.writetobuffer(buf) 
  76          self.__field_type.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_filename=USTRING(**{'sizeinbytes': 256, 'encoding': PHONE_ENCODING,                 'raiseonunterminatedread': False,                 'raiseontruncate': False }) 
  86          self.__field_filename.readfrombuffer(buf) 
  87          self.__field_size=UINT(**{'sizeinbytes': 4}) 
  88          self.__field_size.readfrombuffer(buf) 
  89          self.__field_date=UINT(**{'sizeinbytes': 4, 'default': 0}) 
  90          self.__field_date.readfrombuffer(buf) 
  91          self.__field_type=UINT(**{'sizeinbytes': 4}) 
  92          self.__field_type.readfrombuffer(buf) 
  93          self._bufferendoffset=buf.getcurrentoffset() 
  94   
  95   
  96 -    def __getfield_filename(self): 
  97          return self.__field_filename.getvalue() 
  98   
  99 -    def __setfield_filename(self, value): 
 100          if isinstance(value,USTRING): 
 101              self.__field_filename=value 
 102          else: 
 103              self.__field_filename=USTRING(value,**{'sizeinbytes': 256, 'encoding': PHONE_ENCODING,                 'raiseonunterminatedread': False,                 'raiseontruncate': False }) 
 104   
 105 -    def __delfield_filename(self): del self.__field_filename 
 106   
 107      filename=property(__getfield_filename, __setfield_filename, __delfield_filename, "full pathname") 
 108   
 109 -    def __getfield_size(self): 
 110          return self.__field_size.getvalue() 
 111   
 112 -    def __setfield_size(self, value): 
 113          if isinstance(value,UINT): 
 114              self.__field_size=value 
 115          else: 
 116              self.__field_size=UINT(value,**{'sizeinbytes': 4}) 
 117   
 118 -    def __delfield_size(self): del self.__field_size 
 119   
 120      size=property(__getfield_size, __setfield_size, __delfield_size, None) 
 121   
 122 -    def __getfield_date(self): 
 123          try: self.__field_date 
 124          except: 
 125              self.__field_date=UINT(**{'sizeinbytes': 4, 'default': 0}) 
 126          return self.__field_date.getvalue() 
 127   
 128 -    def __setfield_date(self, value): 
 129          if isinstance(value,UINT): 
 130              self.__field_date=value 
 131          else: 
 132              self.__field_date=UINT(value,**{'sizeinbytes': 4, 'default': 0}) 
 133   
 134 -    def __delfield_date(self): del self.__field_date 
 135   
 136      date=property(__getfield_date, __setfield_date, __delfield_date, None) 
 137   
 138 -    def __getfield_type(self): 
 139          return self.__field_type.getvalue() 
 140   
 141 -    def __setfield_type(self, value): 
 142          if isinstance(value,UINT): 
 143              self.__field_type=value 
 144          else: 
 145              self.__field_type=UINT(value,**{'sizeinbytes': 4}) 
 146   
 147 -    def __delfield_type(self): del self.__field_type 
 148   
 149      type=property(__getfield_type, __setfield_type, __delfield_type, None) 
 150   
 151 -    def iscontainer(self): 
 152          return True 
 153   
 154 -    def containerelements(self): 
 155          yield ('filename', self.__field_filename, "full pathname") 
 156          yield ('size', self.__field_size, None) 
 157          yield ('date', self.__field_date, None) 
 158          yield ('type', self.__field_type, None) 
 159   
 160   
 161   
 162   
 163 -class indexfile(BaseProtogenClass): 
 164      "Used for tracking wallpaper and ringtones" 
 165      __fields=['items'] 
 166   
 167 -    def __init__(self, *args, **kwargs): 
 168          dict={} 
 169          # What was supplied to this function 
 170          dict.update(kwargs) 
 171          # Parent constructor 
 172          super(indexfile,self).__init__(**dict) 
 173          if self.__class__ is indexfile: 
 174              self._update(args,dict) 
 175   
 176   
 177 -    def getfields(self): 
 178          return self.__fields 
 179   
 180   
 181 -    def _update(self, args, kwargs): 
 182          super(indexfile,self)._update(args,kwargs) 
 183          keys=kwargs.keys() 
 184          for key in keys: 
 185              if key in self.__fields: 
 186                  setattr(self, key, kwargs[key]) 
 187                  del kwargs[key] 
 188          # Were any unrecognized kwargs passed in? 
 189          if __debug__: 
 190              self._complainaboutunusedargs(indexfile,kwargs) 
 191          if len(args): 
 192              dict2={'elementclass': indexentry, 'createdefault': True} 
 193              dict2.update(kwargs) 
 194              kwargs=dict2 
 195              self.__field_items=LIST(*args,**dict2) 
 196          # Make all P fields that haven't already been constructed 
 197   
 198   
 199 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
 200          'Writes this packet to the supplied buffer' 
 201          self._bufferstartoffset=buf.getcurrentoffset() 
 202          try: self.__field_items 
 203          except: 
 204              self.__field_items=LIST(**{'elementclass': indexentry, 'createdefault': True}) 
 205          self.__field_items.writetobuffer(buf) 
 206          self._bufferendoffset=buf.getcurrentoffset() 
 207          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
 208   
 209   
 210 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
 211          'Reads this packet from the supplied buffer' 
 212          self._bufferstartoffset=buf.getcurrentoffset() 
 213          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
 214          self.__field_items=LIST(**{'elementclass': indexentry, 'createdefault': True}) 
 215          self.__field_items.readfrombuffer(buf) 
 216          self._bufferendoffset=buf.getcurrentoffset() 
 217   
 218   
 219 -    def __getfield_items(self): 
 220          try: self.__field_items 
 221          except: 
 222              self.__field_items=LIST(**{'elementclass': indexentry, 'createdefault': True}) 
 223          return self.__field_items.getvalue() 
 224   
 225 -    def __setfield_items(self, value): 
 226          if isinstance(value,LIST): 
 227              self.__field_items=value 
 228          else: 
 229              self.__field_items=LIST(value,**{'elementclass': indexentry, 'createdefault': True}) 
 230   
 231 -    def __delfield_items(self): del self.__field_items 
 232   
 233      items=property(__getfield_items, __setfield_items, __delfield_items, None) 
 234   
 235 -    def iscontainer(self): 
 236          return True 
 237   
 238 -    def containerelements(self): 
 239          yield ('items', self.__field_items, None) 
 240   
 241   
 242   
 243   
 244 -class pbentry(BaseProtogenClass): 
 245      __fields=['serial1', 'entrysize', 'serial2', 'entrynumber', 'name', 'group', 'emails', 'ringtone', 'msgringtone', 'wallpaper', 'numbertypes', 'numbers', 'unknown'] 
 246   
 247 -    def __init__(self, *args, **kwargs): 
 248          dict={} 
 249          # What was supplied to this function 
 250          dict.update(kwargs) 
 251          # Parent constructor 
 252          super(pbentry,self).__init__(**dict) 
 253          if self.__class__ is pbentry: 
 254              self._update(args,dict) 
 255   
 256   
 257 -    def getfields(self): 
 258          return self.__fields 
 259   
 260   
 261 -    def _update(self, args, kwargs): 
 262          super(pbentry,self)._update(args,kwargs) 
 263          keys=kwargs.keys() 
 264          for key in keys: 
 265              if key in self.__fields: 
 266                  setattr(self, key, kwargs[key]) 
 267                  del kwargs[key] 
 268          # Were any unrecognized kwargs passed in? 
 269          if __debug__: 
 270              self._complainaboutunusedargs(pbentry,kwargs) 
 271          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
 272          # Make all P fields that haven't already been constructed 
 273   
 274   
 275 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
 276          'Writes this packet to the supplied buffer' 
 277          self._bufferstartoffset=buf.getcurrentoffset() 
 278          self.__field_serial1.writetobuffer(buf) 
 279          try: self.__field_entrysize 
 280          except: 
 281              self.__field_entrysize=UINT(**{'sizeinbytes': 2, 'constant': 0x181, 'constantexception': PhoneBookBusyException}) 
 282          self.__field_entrysize.writetobuffer(buf) 
 283          self.__field_serial2.writetobuffer(buf) 
 284          self.__field_entrynumber.writetobuffer(buf) 
 285          self.__field_name.writetobuffer(buf) 
 286          self.__field_group.writetobuffer(buf) 
 287          try: self.__field_emails 
 288          except: 
 289              self.__field_emails=LIST(**{'elementclass': _gen_p_lgvx8300_73, 'length': NUMEMAILS}) 
 290          self.__field_emails.writetobuffer(buf) 
 291          try: self.__field_ringtone 
 292          except: 
 293              self.__field_ringtone=UINT(**{'sizeinbytes': 2, 'default': 0xFFFF}) 
 294          self.__field_ringtone.writetobuffer(buf) 
 295          try: self.__field_msgringtone 
 296          except: 
 297              self.__field_msgringtone=UINT(**{'sizeinbytes': 2, 'default': 0xFFFF}) 
 298          self.__field_msgringtone.writetobuffer(buf) 
 299          try: self.__field_wallpaper 
 300          except: 
 301              self.__field_wallpaper=UINT(**{'sizeinbytes': 2, 'default': 0}) 
 302          self.__field_wallpaper.writetobuffer(buf) 
 303          try: self.__field_numbertypes 
 304          except: 
 305              self.__field_numbertypes=LIST(**{'elementclass': _gen_p_lgvx8300_78, 'length': NUMPHONENUMBERS}) 
 306          self.__field_numbertypes.writetobuffer(buf) 
 307          try: self.__field_numbers 
 308          except: 
 309              self.__field_numbers=LIST(**{'elementclass': _gen_p_lgvx8300_80, 'length': NUMPHONENUMBERS}) 
 310          self.__field_numbers.writetobuffer(buf) 
 311          try: self.__field_unknown 
 312          except: 
 313              self.__field_unknown=UNKNOWN() 
 314          self.__field_unknown.writetobuffer(buf) 
 315          self._bufferendoffset=buf.getcurrentoffset() 
 316          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
 317   
 318   
 319 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
 320          'Reads this packet from the supplied buffer' 
 321          self._bufferstartoffset=buf.getcurrentoffset() 
 322          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
 323          self.__field_serial1=UINT(**{'sizeinbytes': 4}) 
 324          self.__field_serial1.readfrombuffer(buf) 
 325          self.__field_entrysize=UINT(**{'sizeinbytes': 2, 'constant': 0x181, 'constantexception': PhoneBookBusyException}) 
 326          self.__field_entrysize.readfrombuffer(buf) 
 327          self.__field_serial2=UINT(**{'sizeinbytes': 4}) 
 328          self.__field_serial2.readfrombuffer(buf) 
 329          self.__field_entrynumber=UINT(**{'sizeinbytes': 2}) 
 330          self.__field_entrynumber.readfrombuffer(buf) 
 331          self.__field_name=USTRING(**{'sizeinbytes': 23, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False}) 
 332          self.__field_name.readfrombuffer(buf) 
 333          self.__field_group=UINT(**{'sizeinbytes': 2}) 
 334          self.__field_group.readfrombuffer(buf) 
 335          self.__field_emails=LIST(**{'elementclass': _gen_p_lgvx8300_73, 'length': NUMEMAILS}) 
 336          self.__field_emails.readfrombuffer(buf) 
 337          self.__field_ringtone=UINT(**{'sizeinbytes': 2, 'default': 0xFFFF}) 
 338          self.__field_ringtone.readfrombuffer(buf) 
 339          self.__field_msgringtone=UINT(**{'sizeinbytes': 2, 'default': 0xFFFF}) 
 340          self.__field_msgringtone.readfrombuffer(buf) 
 341          self.__field_wallpaper=UINT(**{'sizeinbytes': 2, 'default': 0}) 
 342          self.__field_wallpaper.readfrombuffer(buf) 
 343          self.__field_numbertypes=LIST(**{'elementclass': _gen_p_lgvx8300_78, 'length': NUMPHONENUMBERS}) 
 344          self.__field_numbertypes.readfrombuffer(buf) 
 345          self.__field_numbers=LIST(**{'elementclass': _gen_p_lgvx8300_80, 'length': NUMPHONENUMBERS}) 
 346          self.__field_numbers.readfrombuffer(buf) 
 347          self.__field_unknown=UNKNOWN() 
 348          self.__field_unknown.readfrombuffer(buf) 
 349          self._bufferendoffset=buf.getcurrentoffset() 
 350   
 351   
 352 -    def __getfield_serial1(self): 
 353          return self.__field_serial1.getvalue() 
 354   
 355 -    def __setfield_serial1(self, value): 
 356          if isinstance(value,UINT): 
 357              self.__field_serial1=value 
 358          else: 
 359              self.__field_serial1=UINT(value,**{'sizeinbytes': 4}) 
 360   
 361 -    def __delfield_serial1(self): del self.__field_serial1 
 362   
 363      serial1=property(__getfield_serial1, __setfield_serial1, __delfield_serial1, None) 
 364   
 365 -    def __getfield_entrysize(self): 
 366          try: self.__field_entrysize 
 367          except: 
 368              self.__field_entrysize=UINT(**{'sizeinbytes': 2, 'constant': 0x181, 'constantexception': PhoneBookBusyException}) 
 369          return self.__field_entrysize.getvalue() 
 370   
 371 -    def __setfield_entrysize(self, value): 
 372          if isinstance(value,UINT): 
 373              self.__field_entrysize=value 
 374          else: 
 375              self.__field_entrysize=UINT(value,**{'sizeinbytes': 2, 'constant': 0x181, 'constantexception': PhoneBookBusyException}) 
 376   
 377 -    def __delfield_entrysize(self): del self.__field_entrysize 
 378   
 379      entrysize=property(__getfield_entrysize, __setfield_entrysize, __delfield_entrysize, None) 
 380   
 381 -    def __getfield_serial2(self): 
 382          return self.__field_serial2.getvalue() 
 383   
 384 -    def __setfield_serial2(self, value): 
 385          if isinstance(value,UINT): 
 386              self.__field_serial2=value 
 387          else: 
 388              self.__field_serial2=UINT(value,**{'sizeinbytes': 4}) 
 389   
 390 -    def __delfield_serial2(self): del self.__field_serial2 
 391   
 392      serial2=property(__getfield_serial2, __setfield_serial2, __delfield_serial2, None) 
 393   
 394 -    def __getfield_entrynumber(self): 
 395          return self.__field_entrynumber.getvalue() 
 396   
 397 -    def __setfield_entrynumber(self, value): 
 398          if isinstance(value,UINT): 
 399              self.__field_entrynumber=value 
 400          else: 
 401              self.__field_entrynumber=UINT(value,**{'sizeinbytes': 2}) 
 402   
 403 -    def __delfield_entrynumber(self): del self.__field_entrynumber 
 404   
 405      entrynumber=property(__getfield_entrynumber, __setfield_entrynumber, __delfield_entrynumber, None) 
 406   
 407 -    def __getfield_name(self): 
 408          return self.__field_name.getvalue() 
 409   
 410 -    def __setfield_name(self, value): 
 411          if isinstance(value,USTRING): 
 412              self.__field_name=value 
 413          else: 
 414              self.__field_name=USTRING(value,**{'sizeinbytes': 23, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False}) 
 415   
 416 -    def __delfield_name(self): del self.__field_name 
 417   
 418      name=property(__getfield_name, __setfield_name, __delfield_name, None) 
 419   
 420 -    def __getfield_group(self): 
 421          return self.__field_group.getvalue() 
 422   
 423 -    def __setfield_group(self, value): 
 424          if isinstance(value,UINT): 
 425              self.__field_group=value 
 426          else: 
 427              self.__field_group=UINT(value,**{'sizeinbytes': 2}) 
 428   
 429 -    def __delfield_group(self): del self.__field_group 
 430   
 431      group=property(__getfield_group, __setfield_group, __delfield_group, None) 
 432   
 433 -    def __getfield_emails(self): 
 434          try: self.__field_emails 
 435          except: 
 436              self.__field_emails=LIST(**{'elementclass': _gen_p_lgvx8300_73, 'length': NUMEMAILS}) 
 437          return self.__field_emails.getvalue() 
 438   
 439 -    def __setfield_emails(self, value): 
 440          if isinstance(value,LIST): 
 441              self.__field_emails=value 
 442          else: 
 443              self.__field_emails=LIST(value,**{'elementclass': _gen_p_lgvx8300_73, 'length': NUMEMAILS}) 
 444   
 445 -    def __delfield_emails(self): del self.__field_emails 
 446   
 447      emails=property(__getfield_emails, __setfield_emails, __delfield_emails, None) 
 448   
 449 -    def __getfield_ringtone(self): 
 450          try: self.__field_ringtone 
 451          except: 
 452              self.__field_ringtone=UINT(**{'sizeinbytes': 2, 'default': 0xFFFF}) 
 453          return self.__field_ringtone.getvalue() 
 454   
 455 -    def __setfield_ringtone(self, value): 
 456          if isinstance(value,UINT): 
 457              self.__field_ringtone=value 
 458          else: 
 459              self.__field_ringtone=UINT(value,**{'sizeinbytes': 2, 'default': 0xFFFF}) 
 460   
 461 -    def __delfield_ringtone(self): del self.__field_ringtone 
 462   
 463      ringtone=property(__getfield_ringtone, __setfield_ringtone, __delfield_ringtone, "ringtone index for a call") 
 464   
 465 -    def __getfield_msgringtone(self): 
 466          try: self.__field_msgringtone 
 467          except: 
 468              self.__field_msgringtone=UINT(**{'sizeinbytes': 2, 'default': 0xFFFF}) 
 469          return self.__field_msgringtone.getvalue() 
 470   
 471 -    def __setfield_msgringtone(self, value): 
 472          if isinstance(value,UINT): 
 473              self.__field_msgringtone=value 
 474          else: 
 475              self.__field_msgringtone=UINT(value,**{'sizeinbytes': 2, 'default': 0xFFFF}) 
 476   
 477 -    def __delfield_msgringtone(self): del self.__field_msgringtone 
 478   
 479      msgringtone=property(__getfield_msgringtone, __setfield_msgringtone, __delfield_msgringtone, "ringtone index for a text message") 
 480   
 481 -    def __getfield_wallpaper(self): 
 482          try: self.__field_wallpaper 
 483          except: 
 484              self.__field_wallpaper=UINT(**{'sizeinbytes': 2, 'default': 0}) 
 485          return self.__field_wallpaper.getvalue() 
 486   
 487 -    def __setfield_wallpaper(self, value): 
 488          if isinstance(value,UINT): 
 489              self.__field_wallpaper=value 
 490          else: 
 491              self.__field_wallpaper=UINT(value,**{'sizeinbytes': 2, 'default': 0}) 
 492   
 493 -    def __delfield_wallpaper(self): del self.__field_wallpaper 
 494   
 495      wallpaper=property(__getfield_wallpaper, __setfield_wallpaper, __delfield_wallpaper, None) 
 496   
 497 -    def __getfield_numbertypes(self): 
 498          try: self.__field_numbertypes 
 499          except: 
 500              self.__field_numbertypes=LIST(**{'elementclass': _gen_p_lgvx8300_78, 'length': NUMPHONENUMBERS}) 
 501          return self.__field_numbertypes.getvalue() 
 502   
 503 -    def __setfield_numbertypes(self, value): 
 504          if isinstance(value,LIST): 
 505              self.__field_numbertypes=value 
 506          else: 
 507              self.__field_numbertypes=LIST(value,**{'elementclass': _gen_p_lgvx8300_78, 'length': NUMPHONENUMBERS}) 
 508   
 509 -    def __delfield_numbertypes(self): del self.__field_numbertypes 
 510   
 511      numbertypes=property(__getfield_numbertypes, __setfield_numbertypes, __delfield_numbertypes, None) 
 512   
 513 -    def __getfield_numbers(self): 
 514          try: self.__field_numbers 
 515          except: 
 516              self.__field_numbers=LIST(**{'elementclass': _gen_p_lgvx8300_80, 'length': NUMPHONENUMBERS}) 
 517          return self.__field_numbers.getvalue() 
 518   
 519 -    def __setfield_numbers(self, value): 
 520          if isinstance(value,LIST): 
 521              self.__field_numbers=value 
 522          else: 
 523              self.__field_numbers=LIST(value,**{'elementclass': _gen_p_lgvx8300_80, 'length': NUMPHONENUMBERS}) 
 524   
 525 -    def __delfield_numbers(self): del self.__field_numbers 
 526   
 527      numbers=property(__getfield_numbers, __setfield_numbers, __delfield_numbers, None) 
 528   
 529 -    def __getfield_unknown(self): 
 530          try: self.__field_unknown 
 531          except: 
 532              self.__field_unknown=UNKNOWN() 
 533          return self.__field_unknown.getvalue() 
 534   
 535 -    def __setfield_unknown(self, value): 
 536          if isinstance(value,UNKNOWN): 
 537              self.__field_unknown=value 
 538          else: 
 539              self.__field_unknown=UNKNOWN(value,) 
 540   
 541 -    def __delfield_unknown(self): del self.__field_unknown 
 542   
 543      unknown=property(__getfield_unknown, __setfield_unknown, __delfield_unknown, None) 
 544   
 545 -    def iscontainer(self): 
 546          return True 
 547   
 548 -    def containerelements(self): 
 549          yield ('serial1', self.__field_serial1, None) 
 550          yield ('entrysize', self.__field_entrysize, None) 
 551          yield ('serial2', self.__field_serial2, None) 
 552          yield ('entrynumber', self.__field_entrynumber, None) 
 553          yield ('name', self.__field_name, None) 
 554          yield ('group', self.__field_group, None) 
 555          yield ('emails', self.__field_emails, None) 
 556          yield ('ringtone', self.__field_ringtone, "ringtone index for a call") 
 557          yield ('msgringtone', self.__field_msgringtone, "ringtone index for a text message") 
 558          yield ('wallpaper', self.__field_wallpaper, None) 
 559          yield ('numbertypes', self.__field_numbertypes, None) 
 560          yield ('numbers', self.__field_numbers, None) 
 561          yield ('unknown', self.__field_unknown, None) 
 562   
 563   
 564   
 565   
 566 -class _gen_p_lgvx8300_73(BaseProtogenClass): 
 567      'Anonymous inner class' 
 568      __fields=['email'] 
 569   
 570 -    def __init__(self, *args, **kwargs): 
 571          dict={} 
 572          # What was supplied to this function 
 573          dict.update(kwargs) 
 574          # Parent constructor 
 575          super(_gen_p_lgvx8300_73,self).__init__(**dict) 
 576          if self.__class__ is _gen_p_lgvx8300_73: 
 577              self._update(args,dict) 
 578   
 579   
 580 -    def getfields(self): 
 581          return self.__fields 
 582   
 583   
 584 -    def _update(self, args, kwargs): 
 585          super(_gen_p_lgvx8300_73,self)._update(args,kwargs) 
 586          keys=kwargs.keys() 
 587          for key in keys: 
 588              if key in self.__fields: 
 589                  setattr(self, key, kwargs[key]) 
 590                  del kwargs[key] 
 591          # Were any unrecognized kwargs passed in? 
 592          if __debug__: 
 593              self._complainaboutunusedargs(_gen_p_lgvx8300_73,kwargs) 
 594          if len(args): 
 595              dict2={'sizeinbytes': 49, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False} 
 596              dict2.update(kwargs) 
 597              kwargs=dict2 
 598              self.__field_email=USTRING(*args,**dict2) 
 599          # Make all P fields that haven't already been constructed 
 600   
 601   
 602 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
 603          'Writes this packet to the supplied buffer' 
 604          self._bufferstartoffset=buf.getcurrentoffset() 
 605          self.__field_email.writetobuffer(buf) 
 606          self._bufferendoffset=buf.getcurrentoffset() 
 607          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
 608   
 609   
 610 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
 611          'Reads this packet from the supplied buffer' 
 612          self._bufferstartoffset=buf.getcurrentoffset() 
 613          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
 614          self.__field_email=USTRING(**{'sizeinbytes': 49, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False}) 
 615          self.__field_email.readfrombuffer(buf) 
 616          self._bufferendoffset=buf.getcurrentoffset() 
 617   
 618   
 619 -    def __getfield_email(self): 
 620          return self.__field_email.getvalue() 
 621   
 622 -    def __setfield_email(self, value): 
 623          if isinstance(value,USTRING): 
 624              self.__field_email=value 
 625          else: 
 626              self.__field_email=USTRING(value,**{'sizeinbytes': 49, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False}) 
 627   
 628 -    def __delfield_email(self): del self.__field_email 
 629   
 630      email=property(__getfield_email, __setfield_email, __delfield_email, None) 
 631   
 632 -    def iscontainer(self): 
 633          return True 
 634   
 635 -    def containerelements(self): 
 636          yield ('email', self.__field_email, None) 
 637   
 638   
 639   
 640   
 641 -class _gen_p_lgvx8300_78(BaseProtogenClass): 
 642      'Anonymous inner class' 
 643      __fields=['numbertype'] 
 644   
 645 -    def __init__(self, *args, **kwargs): 
 646          dict={} 
 647          # What was supplied to this function 
 648          dict.update(kwargs) 
 649          # Parent constructor 
 650          super(_gen_p_lgvx8300_78,self).__init__(**dict) 
 651          if self.__class__ is _gen_p_lgvx8300_78: 
 652              self._update(args,dict) 
 653   
 654   
 655 -    def getfields(self): 
 656          return self.__fields 
 657   
 658   
 659 -    def _update(self, args, kwargs): 
 660          super(_gen_p_lgvx8300_78,self)._update(args,kwargs) 
 661          keys=kwargs.keys() 
 662          for key in keys: 
 663              if key in self.__fields: 
 664                  setattr(self, key, kwargs[key]) 
 665                  del kwargs[key] 
 666          # Were any unrecognized kwargs passed in? 
 667          if __debug__: 
 668              self._complainaboutunusedargs(_gen_p_lgvx8300_78,kwargs) 
 669          if len(args): 
 670              dict2={'sizeinbytes': 1} 
 671              dict2.update(kwargs) 
 672              kwargs=dict2 
 673              self.__field_numbertype=UINT(*args,**dict2) 
 674          # Make all P fields that haven't already been constructed 
 675   
 676   
 677 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
 678          'Writes this packet to the supplied buffer' 
 679          self._bufferstartoffset=buf.getcurrentoffset() 
 680          self.__field_numbertype.writetobuffer(buf) 
 681          self._bufferendoffset=buf.getcurrentoffset() 
 682          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
 683   
 684   
 685 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
 686          'Reads this packet from the supplied buffer' 
 687          self._bufferstartoffset=buf.getcurrentoffset() 
 688          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
 689          self.__field_numbertype=UINT(**{'sizeinbytes': 1}) 
 690          self.__field_numbertype.readfrombuffer(buf) 
 691          self._bufferendoffset=buf.getcurrentoffset() 
 692   
 693   
 694 -    def __getfield_numbertype(self): 
 695          return self.__field_numbertype.getvalue() 
 696   
 697 -    def __setfield_numbertype(self, value): 
 698          if isinstance(value,UINT): 
 699              self.__field_numbertype=value 
 700          else: 
 701              self.__field_numbertype=UINT(value,**{'sizeinbytes': 1}) 
 702   
 703 -    def __delfield_numbertype(self): del self.__field_numbertype 
 704   
 705      numbertype=property(__getfield_numbertype, __setfield_numbertype, __delfield_numbertype, None) 
 706   
 707 -    def iscontainer(self): 
 708          return True 
 709   
 710 -    def containerelements(self): 
 711          yield ('numbertype', self.__field_numbertype, None) 
 712   
 713   
 714   
 715   
 716 -class _gen_p_lgvx8300_80(BaseProtogenClass): 
 717      'Anonymous inner class' 
 718      __fields=['number'] 
 719   
 720 -    def __init__(self, *args, **kwargs): 
 721          dict={} 
 722          # What was supplied to this function 
 723          dict.update(kwargs) 
 724          # Parent constructor 
 725          super(_gen_p_lgvx8300_80,self).__init__(**dict) 
 726          if self.__class__ is _gen_p_lgvx8300_80: 
 727              self._update(args,dict) 
 728   
 729   
 730 -    def getfields(self): 
 731          return self.__fields 
 732   
 733   
 734 -    def _update(self, args, kwargs): 
 735          super(_gen_p_lgvx8300_80,self)._update(args,kwargs) 
 736          keys=kwargs.keys() 
 737          for key in keys: 
 738              if key in self.__fields: 
 739                  setattr(self, key, kwargs[key]) 
 740                  del kwargs[key] 
 741          # Were any unrecognized kwargs passed in? 
 742          if __debug__: 
 743              self._complainaboutunusedargs(_gen_p_lgvx8300_80,kwargs) 
 744          if len(args): 
 745              dict2={'sizeinbytes': 49, 'raiseonunterminatedread': False} 
 746              dict2.update(kwargs) 
 747              kwargs=dict2 
 748              self.__field_number=USTRING(*args,**dict2) 
 749          # Make all P fields that haven't already been constructed 
 750   
 751   
 752 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
 753          'Writes this packet to the supplied buffer' 
 754          self._bufferstartoffset=buf.getcurrentoffset() 
 755          self.__field_number.writetobuffer(buf) 
 756          self._bufferendoffset=buf.getcurrentoffset() 
 757          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
 758   
 759   
 760 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
 761          'Reads this packet from the supplied buffer' 
 762          self._bufferstartoffset=buf.getcurrentoffset() 
 763          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
 764          self.__field_number=USTRING(**{'sizeinbytes': 49, 'raiseonunterminatedread': False}) 
 765          self.__field_number.readfrombuffer(buf) 
 766          self._bufferendoffset=buf.getcurrentoffset() 
 767   
 768   
 769 -    def __getfield_number(self): 
 770          return self.__field_number.getvalue() 
 771   
 772 -    def __setfield_number(self, value): 
 773          if isinstance(value,USTRING): 
 774              self.__field_number=value 
 775          else: 
 776              self.__field_number=USTRING(value,**{'sizeinbytes': 49, 'raiseonunterminatedread': False}) 
 777   
 778 -    def __delfield_number(self): del self.__field_number 
 779   
 780      number=property(__getfield_number, __setfield_number, __delfield_number, None) 
 781   
 782 -    def iscontainer(self): 
 783          return True 
 784   
 785 -    def containerelements(self): 
 786          yield ('number', self.__field_number, None) 
 787   
 788   
 789   
 790   
 791 -class pbreadentryresponse(BaseProtogenClass): 
 792      "Results of reading one entry" 
 793      __fields=['header', 'entry'] 
 794   
 795 -    def __init__(self, *args, **kwargs): 
 796          dict={} 
 797          # What was supplied to this function 
 798          dict.update(kwargs) 
 799          # Parent constructor 
 800          super(pbreadentryresponse,self).__init__(**dict) 
 801          if self.__class__ is pbreadentryresponse: 
 802              self._update(args,dict) 
 803   
 804   
 805 -    def getfields(self): 
 806          return self.__fields 
 807   
 808   
 809 -    def _update(self, args, kwargs): 
 810          super(pbreadentryresponse,self)._update(args,kwargs) 
 811          keys=kwargs.keys() 
 812          for key in keys: 
 813              if key in self.__fields: 
 814                  setattr(self, key, kwargs[key]) 
 815                  del kwargs[key] 
 816          # Were any unrecognized kwargs passed in? 
 817          if __debug__: 
 818              self._complainaboutunusedargs(pbreadentryresponse,kwargs) 
 819          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
 820          # Make all P fields that haven't already been constructed 
 821   
 822   
 823 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
 824          'Writes this packet to the supplied buffer' 
 825          self._bufferstartoffset=buf.getcurrentoffset() 
 826          self.__field_header.writetobuffer(buf) 
 827          self.__field_entry.writetobuffer(buf) 
 828          self._bufferendoffset=buf.getcurrentoffset() 
 829          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
 830   
 831   
 832 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
 833          'Reads this packet from the supplied buffer' 
 834          self._bufferstartoffset=buf.getcurrentoffset() 
 835          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
 836          self.__field_header=pbheader() 
 837          self.__field_header.readfrombuffer(buf) 
 838          self.__field_entry=pbentry() 
 839          self.__field_entry.readfrombuffer(buf) 
 840          self._bufferendoffset=buf.getcurrentoffset() 
 841   
 842   
 843 -    def __getfield_header(self): 
 844          return self.__field_header.getvalue() 
 845   
 846 -    def __setfield_header(self, value): 
 847          if isinstance(value,pbheader): 
 848              self.__field_header=value 
 849          else: 
 850              self.__field_header=pbheader(value,) 
 851   
 852 -    def __delfield_header(self): del self.__field_header 
 853   
 854      header=property(__getfield_header, __setfield_header, __delfield_header, None) 
 855   
 856 -    def __getfield_entry(self): 
 857          return self.__field_entry.getvalue() 
 858   
 859 -    def __setfield_entry(self, value): 
 860          if isinstance(value,pbentry): 
 861              self.__field_entry=value 
 862          else: 
 863              self.__field_entry=pbentry(value,) 
 864   
 865 -    def __delfield_entry(self): del self.__field_entry 
 866   
 867      entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None) 
 868   
 869 -    def iscontainer(self): 
 870          return True 
 871   
 872 -    def containerelements(self): 
 873          yield ('header', self.__field_header, None) 
 874          yield ('entry', self.__field_entry, None) 
 875   
 876   
 877   
 878   
 879 -class pbupdateentryrequest(BaseProtogenClass): 
 880      __fields=['header', 'entry'] 
 881   
 882 -    def __init__(self, *args, **kwargs): 
 883          dict={} 
 884          # What was supplied to this function 
 885          dict.update(kwargs) 
 886          # Parent constructor 
 887          super(pbupdateentryrequest,self).__init__(**dict) 
 888          if self.__class__ is pbupdateentryrequest: 
 889              self._update(args,dict) 
 890   
 891   
 892 -    def getfields(self): 
 893          return self.__fields 
 894   
 895   
 896 -    def _update(self, args, kwargs): 
 897          super(pbupdateentryrequest,self)._update(args,kwargs) 
 898          keys=kwargs.keys() 
 899          for key in keys: 
 900              if key in self.__fields: 
 901                  setattr(self, key, kwargs[key]) 
 902                  del kwargs[key] 
 903          # Were any unrecognized kwargs passed in? 
 904          if __debug__: 
 905              self._complainaboutunusedargs(pbupdateentryrequest,kwargs) 
 906          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
 907          # Make all P fields that haven't already been constructed 
 908   
 909   
 910 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
 911          'Writes this packet to the supplied buffer' 
 912          self._bufferstartoffset=buf.getcurrentoffset() 
 913          try: self.__field_header 
 914          except: 
 915              self.__field_header=pbheader(**{'command': 0x04, 'flag': 0x01}) 
 916          self.__field_header.writetobuffer(buf) 
 917          self.__field_entry.writetobuffer(buf) 
 918          self._bufferendoffset=buf.getcurrentoffset() 
 919          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
 920   
 921   
 922 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
 923          'Reads this packet from the supplied buffer' 
 924          self._bufferstartoffset=buf.getcurrentoffset() 
 925          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
 926          self.__field_header=pbheader(**{'command': 0x04, 'flag': 0x01}) 
 927          self.__field_header.readfrombuffer(buf) 
 928          self.__field_entry=pbentry() 
 929          self.__field_entry.readfrombuffer(buf) 
 930          self._bufferendoffset=buf.getcurrentoffset() 
 931   
 932   
 933 -    def __getfield_header(self): 
 934          try: self.__field_header 
 935          except: 
 936              self.__field_header=pbheader(**{'command': 0x04, 'flag': 0x01}) 
 937          return self.__field_header.getvalue() 
 938   
 939 -    def __setfield_header(self, value): 
 940          if isinstance(value,pbheader): 
 941              self.__field_header=value 
 942          else: 
 943              self.__field_header=pbheader(value,**{'command': 0x04, 'flag': 0x01}) 
 944   
 945 -    def __delfield_header(self): del self.__field_header 
 946   
 947      header=property(__getfield_header, __setfield_header, __delfield_header, None) 
 948   
 949 -    def __getfield_entry(self): 
 950          return self.__field_entry.getvalue() 
 951   
 952 -    def __setfield_entry(self, value): 
 953          if isinstance(value,pbentry): 
 954              self.__field_entry=value 
 955          else: 
 956              self.__field_entry=pbentry(value,) 
 957   
 958 -    def __delfield_entry(self): del self.__field_entry 
 959   
 960      entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None) 
 961   
 962 -    def iscontainer(self): 
 963          return True 
 964   
 965 -    def containerelements(self): 
 966          yield ('header', self.__field_header, None) 
 967          yield ('entry', self.__field_entry, None) 
 968   
 969   
 970   
 971   
 972 -class pbappendentryrequest(BaseProtogenClass): 
 973      __fields=['header', 'entry'] 
 974   
 975 -    def __init__(self, *args, **kwargs): 
 976          dict={} 
 977          # What was supplied to this function 
 978          dict.update(kwargs) 
 979          # Parent constructor 
 980          super(pbappendentryrequest,self).__init__(**dict) 
 981          if self.__class__ is pbappendentryrequest: 
 982              self._update(args,dict) 
 983   
 984   
 985 -    def getfields(self): 
 986          return self.__fields 
 987   
 988   
 989 -    def _update(self, args, kwargs): 
 990          super(pbappendentryrequest,self)._update(args,kwargs) 
 991          keys=kwargs.keys() 
 992          for key in keys: 
 993              if key in self.__fields: 
 994                  setattr(self, key, kwargs[key]) 
 995                  del kwargs[key] 
 996          # Were any unrecognized kwargs passed in? 
 997          if __debug__: 
 998              self._complainaboutunusedargs(pbappendentryrequest,kwargs) 
 999          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
1000          # Make all P fields that haven't already been constructed 
1001   
1002   
1003 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
1004          'Writes this packet to the supplied buffer' 
1005          self._bufferstartoffset=buf.getcurrentoffset() 
1006          try: self.__field_header 
1007          except: 
1008              self.__field_header=pbheader(**{'command': 0x03, 'flag': 0x01}) 
1009          self.__field_header.writetobuffer(buf) 
1010          self.__field_entry.writetobuffer(buf) 
1011          self._bufferendoffset=buf.getcurrentoffset() 
1012          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
1013   
1014   
1015 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
1016          'Reads this packet from the supplied buffer' 
1017          self._bufferstartoffset=buf.getcurrentoffset() 
1018          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
1019          self.__field_header=pbheader(**{'command': 0x03, 'flag': 0x01}) 
1020          self.__field_header.readfrombuffer(buf) 
1021          self.__field_entry=pbentry() 
1022          self.__field_entry.readfrombuffer(buf) 
1023          self._bufferendoffset=buf.getcurrentoffset() 
1024   
1025   
1026 -    def __getfield_header(self): 
1027          try: self.__field_header 
1028          except: 
1029              self.__field_header=pbheader(**{'command': 0x03, 'flag': 0x01}) 
1030          return self.__field_header.getvalue() 
1031   
1032 -    def __setfield_header(self, value): 
1033          if isinstance(value,pbheader): 
1034              self.__field_header=value 
1035          else: 
1036              self.__field_header=pbheader(value,**{'command': 0x03, 'flag': 0x01}) 
1037   
1038 -    def __delfield_header(self): del self.__field_header 
1039   
1040      header=property(__getfield_header, __setfield_header, __delfield_header, None) 
1041   
1042 -    def __getfield_entry(self): 
1043          return self.__field_entry.getvalue() 
1044   
1045 -    def __setfield_entry(self, value): 
1046          if isinstance(value,pbentry): 
1047              self.__field_entry=value 
1048          else: 
1049              self.__field_entry=pbentry(value,) 
1050   
1051 -    def __delfield_entry(self): del self.__field_entry 
1052   
1053      entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None) 
1054   
1055 -    def iscontainer(self): 
1056          return True 
1057   
1058 -    def containerelements(self): 
1059          yield ('header', self.__field_header, None) 
1060          yield ('entry', self.__field_entry, None) 
1061   
1062   
1063   
1064   
1065 -class scheduleexception(BaseProtogenClass): 
1066      __fields=['pos', 'day', 'month', 'year'] 
1067   
1068 -    def __init__(self, *args, **kwargs): 
1069          dict={} 
1070          # What was supplied to this function 
1071          dict.update(kwargs) 
1072          # Parent constructor 
1073          super(scheduleexception,self).__init__(**dict) 
1074          if self.__class__ is scheduleexception: 
1075              self._update(args,dict) 
1076   
1077   
1078 -    def getfields(self): 
1079          return self.__fields 
1080   
1081   
1082 -    def _update(self, args, kwargs): 
1083          super(scheduleexception,self)._update(args,kwargs) 
1084          keys=kwargs.keys() 
1085          for key in keys: 
1086              if key in self.__fields: 
1087                  setattr(self, key, kwargs[key]) 
1088                  del kwargs[key] 
1089          # Were any unrecognized kwargs passed in? 
1090          if __debug__: 
1091              self._complainaboutunusedargs(scheduleexception,kwargs) 
1092          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
1093          # Make all P fields that haven't already been constructed 
1094   
1095   
1096 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
1097          'Writes this packet to the supplied buffer' 
1098          self._bufferstartoffset=buf.getcurrentoffset() 
1099          self.__field_pos.writetobuffer(buf) 
1100          self.__field_day.writetobuffer(buf) 
1101          self.__field_month.writetobuffer(buf) 
1102          self.__field_year.writetobuffer(buf) 
1103          self._bufferendoffset=buf.getcurrentoffset() 
1104          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
1105   
1106   
1107 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
1108          'Reads this packet from the supplied buffer' 
1109          self._bufferstartoffset=buf.getcurrentoffset() 
1110          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
1111          self.__field_pos=UINT(**{'sizeinbytes': 4}) 
1112          self.__field_pos.readfrombuffer(buf) 
1113          self.__field_day=UINT(**{'sizeinbytes': 1}) 
1114          self.__field_day.readfrombuffer(buf) 
1115          self.__field_month=UINT(**{'sizeinbytes': 1}) 
1116          self.__field_month.readfrombuffer(buf) 
1117          self.__field_year=UINT(**{'sizeinbytes': 2}) 
1118          self.__field_year.readfrombuffer(buf) 
1119          self._bufferendoffset=buf.getcurrentoffset() 
1120   
1121   
1122 -    def __getfield_pos(self): 
1123          return self.__field_pos.getvalue() 
1124   
1125 -    def __setfield_pos(self, value): 
1126          if isinstance(value,UINT): 
1127              self.__field_pos=value 
1128          else: 
1129              self.__field_pos=UINT(value,**{'sizeinbytes': 4}) 
1130   
1131 -    def __delfield_pos(self): del self.__field_pos 
1132   
1133      pos=property(__getfield_pos, __setfield_pos, __delfield_pos, "Refers to event id (position in schedule file) that this suppresses") 
1134   
1135 -    def __getfield_day(self): 
1136          return self.__field_day.getvalue() 
1137   
1138 -    def __setfield_day(self, value): 
1139          if isinstance(value,UINT): 
1140              self.__field_day=value 
1141          else: 
1142              self.__field_day=UINT(value,**{'sizeinbytes': 1}) 
1143   
1144 -    def __delfield_day(self): del self.__field_day 
1145   
1146      day=property(__getfield_day, __setfield_day, __delfield_day, None) 
1147   
1148 -    def __getfield_month(self): 
1149          return self.__field_month.getvalue() 
1150   
1151 -    def __setfield_month(self, value): 
1152          if isinstance(value,UINT): 
1153              self.__field_month=value 
1154          else: 
1155              self.__field_month=UINT(value,**{'sizeinbytes': 1}) 
1156   
1157 -    def __delfield_month(self): del self.__field_month 
1158   
1159      month=property(__getfield_month, __setfield_month, __delfield_month, None) 
1160   
1161 -    def __getfield_year(self): 
1162          return self.__field_year.getvalue() 
1163   
1164 -    def __setfield_year(self, value): 
1165          if isinstance(value,UINT): 
1166              self.__field_year=value 
1167          else: 
1168              self.__field_year=UINT(value,**{'sizeinbytes': 2}) 
1169   
1170 -    def __delfield_year(self): del self.__field_year 
1171   
1172      year=property(__getfield_year, __setfield_year, __delfield_year, None) 
1173   
1174 -    def iscontainer(self): 
1175          return True 
1176   
1177 -    def containerelements(self): 
1178          yield ('pos', self.__field_pos, "Refers to event id (position in schedule file) that this suppresses") 
1179          yield ('day', self.__field_day, None) 
1180          yield ('month', self.__field_month, None) 
1181          yield ('year', self.__field_year, None) 
1182   
1183   
1184   
1185   
1186 -class scheduleexceptionfile(BaseProtogenClass): 
1187      __fields=['items'] 
1188   
1189 -    def __init__(self, *args, **kwargs): 
1190          dict={} 
1191          # What was supplied to this function 
1192          dict.update(kwargs) 
1193          # Parent constructor 
1194          super(scheduleexceptionfile,self).__init__(**dict) 
1195          if self.__class__ is scheduleexceptionfile: 
1196              self._update(args,dict) 
1197   
1198   
1199 -    def getfields(self): 
1200          return self.__fields 
1201   
1202   
1203 -    def _update(self, args, kwargs): 
1204          super(scheduleexceptionfile,self)._update(args,kwargs) 
1205          keys=kwargs.keys() 
1206          for key in keys: 
1207              if key in self.__fields: 
1208                  setattr(self, key, kwargs[key]) 
1209                  del kwargs[key] 
1210          # Were any unrecognized kwargs passed in? 
1211          if __debug__: 
1212              self._complainaboutunusedargs(scheduleexceptionfile,kwargs) 
1213          if len(args): 
1214              dict2={'elementclass': scheduleexception} 
1215              dict2.update(kwargs) 
1216              kwargs=dict2 
1217              self.__field_items=LIST(*args,**dict2) 
1218          # Make all P fields that haven't already been constructed 
1219   
1220   
1221 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
1222          'Writes this packet to the supplied buffer' 
1223          self._bufferstartoffset=buf.getcurrentoffset() 
1224          try: self.__field_items 
1225          except: 
1226              self.__field_items=LIST(**{'elementclass': scheduleexception}) 
1227          self.__field_items.writetobuffer(buf) 
1228          self._bufferendoffset=buf.getcurrentoffset() 
1229          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
1230   
1231   
1232 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
1233          'Reads this packet from the supplied buffer' 
1234          self._bufferstartoffset=buf.getcurrentoffset() 
1235          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
1236          self.__field_items=LIST(**{'elementclass': scheduleexception}) 
1237          self.__field_items.readfrombuffer(buf) 
1238          self._bufferendoffset=buf.getcurrentoffset() 
1239   
1240   
1241 -    def __getfield_items(self): 
1242          try: self.__field_items 
1243          except: 
1244              self.__field_items=LIST(**{'elementclass': scheduleexception}) 
1245          return self.__field_items.getvalue() 
1246   
1247 -    def __setfield_items(self, value): 
1248          if isinstance(value,LIST): 
1249              self.__field_items=value 
1250          else: 
1251              self.__field_items=LIST(value,**{'elementclass': scheduleexception}) 
1252   
1253 -    def __delfield_items(self): del self.__field_items 
1254   
1255      items=property(__getfield_items, __setfield_items, __delfield_items, None) 
1256   
1257 -    def iscontainer(self): 
1258          return True 
1259   
1260 -    def containerelements(self): 
1261          yield ('items', self.__field_items, None) 
1262   
1263   
1264   
1265   
1266 -class scheduleevent(BaseProtogenClass): 
1267      __fields=['pos', 'description', 'start', 'end_time', 'end_date', 'repeat', 'alarmindex_vibrate', 'ringtone', 'unknown1', 'alarmminutes', 'alarmhours', 'ringpath'] 
1268   
1269 -    def __init__(self, *args, **kwargs): 
1270          dict={} 
1271          # What was supplied to this function 
1272          dict.update(kwargs) 
1273          # Parent constructor 
1274          super(scheduleevent,self).__init__(**dict) 
1275          if self.__class__ is scheduleevent: 
1276              self._update(args,dict) 
1277   
1278   
1279 -    def getfields(self): 
1280          return self.__fields 
1281   
1282   
1283 -    def _update(self, args, kwargs): 
1284          super(scheduleevent,self)._update(args,kwargs) 
1285          keys=kwargs.keys() 
1286          for key in keys: 
1287              if key in self.__fields: 
1288                  setattr(self, key, kwargs[key]) 
1289                  del kwargs[key] 
1290          # Were any unrecognized kwargs passed in? 
1291          if __debug__: 
1292              self._complainaboutunusedargs(scheduleevent,kwargs) 
1293          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
1294          # Make all P fields that haven't already been constructed 
1295   
1296   
1297 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
1298          'Writes this packet to the supplied buffer' 
1299          self._bufferstartoffset=buf.getcurrentoffset() 
1300          self.__field_pos.writetobuffer(buf) 
1301          self.__field_description.writetobuffer(buf) 
1302          self.__field_start.writetobuffer(buf) 
1303          self.__field_end_time.writetobuffer(buf) 
1304          self.__field_end_date.writetobuffer(buf) 
1305          self.__field_repeat.writetobuffer(buf) 
1306          self.__field_alarmindex_vibrate.writetobuffer(buf) 
1307          self.__field_ringtone.writetobuffer(buf) 
1308          try: self.__field_unknown1 
1309          except: 
1310              self.__field_unknown1=UINT(**{'sizeinbytes': 1,  'default': 0 }) 
1311          self.__field_unknown1.writetobuffer(buf) 
1312          self.__field_alarmminutes.writetobuffer(buf) 
1313          self.__field_alarmhours.writetobuffer(buf) 
1314          try: self.__field_ringpath 
1315          except: 
1316              self.__field_ringpath=USTRING(**{'sizeinbytes': 256, 'encoding': PHONE_ENCODING,                 'raiseonunterminatedread': False,                 'raiseontruncate': False,                 'default': '' }) 
1317          self.__field_ringpath.writetobuffer(buf) 
1318          self._bufferendoffset=buf.getcurrentoffset() 
1319          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
1320   
1321   
1322 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
1323          'Reads this packet from the supplied buffer' 
1324          self._bufferstartoffset=buf.getcurrentoffset() 
1325          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
1326          self.__field_pos=UINT(**{'sizeinbytes': 4}) 
1327          self.__field_pos.readfrombuffer(buf) 
1328          self.__field_description=USTRING(**{'sizeinbytes': 33, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False, 'raiseontruncate': False }) 
1329          self.__field_description.readfrombuffer(buf) 
1330          self.__field_start=LGCALDATE(**{'sizeinbytes': 4}) 
1331          self.__field_start.readfrombuffer(buf) 
1332          self.__field_end_time=LGCALDATE(**{'sizeinbytes': 4}) 
1333          self.__field_end_time.readfrombuffer(buf) 
1334          self.__field_end_date=LGCALDATE(**{'sizeinbytes': 4}) 
1335          self.__field_end_date.readfrombuffer(buf) 
1336          self.__field_repeat=LGCALREPEAT(**{'sizeinbytes': 4}) 
1337          self.__field_repeat.readfrombuffer(buf) 
1338          self.__field_alarmindex_vibrate=UINT(**{'sizeinbytes': 1}) 
1339          self.__field_alarmindex_vibrate.readfrombuffer(buf) 
1340          self.__field_ringtone=UINT(**{'sizeinbytes': 1}) 
1341          self.__field_ringtone.readfrombuffer(buf) 
1342          self.__field_unknown1=UINT(**{'sizeinbytes': 1,  'default': 0 }) 
1343          self.__field_unknown1.readfrombuffer(buf) 
1344          self.__field_alarmminutes=UINT(**{'sizeinbytes': 1}) 
1345          self.__field_alarmminutes.readfrombuffer(buf) 
1346          self.__field_alarmhours=UINT(**{'sizeinbytes': 1}) 
1347          self.__field_alarmhours.readfrombuffer(buf) 
1348          self.__field_ringpath=USTRING(**{'sizeinbytes': 256, 'encoding': PHONE_ENCODING,                 'raiseonunterminatedread': False,                 'raiseontruncate': False,                 'default': '' }) 
1349          self.__field_ringpath.readfrombuffer(buf) 
1350          self._bufferendoffset=buf.getcurrentoffset() 
1351   
1352   
1353 -    def __getfield_pos(self): 
1354          return self.__field_pos.getvalue() 
1355   
1356 -    def __setfield_pos(self, value): 
1357          if isinstance(value,UINT): 
1358              self.__field_pos=value 
1359          else: 
1360              self.__field_pos=UINT(value,**{'sizeinbytes': 4}) 
1361   
1362 -    def __delfield_pos(self): del self.__field_pos 
1363   
1364      pos=property(__getfield_pos, __setfield_pos, __delfield_pos, "position within file, used as an event id") 
1365   
1366 -    def __getfield_description(self): 
1367          return self.__field_description.getvalue() 
1368   
1369 -    def __setfield_description(self, value): 
1370          if isinstance(value,USTRING): 
1371              self.__field_description=value 
1372          else: 
1373              self.__field_description=USTRING(value,**{'sizeinbytes': 33, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False, 'raiseontruncate': False }) 
1374   
1375 -    def __delfield_description(self): del self.__field_description 
1376   
1377      description=property(__getfield_description, __setfield_description, __delfield_description, None) 
1378   
1379 -    def __getfield_start(self): 
1380          return self.__field_start.getvalue() 
1381   
1382 -    def __setfield_start(self, value): 
1383          if isinstance(value,LGCALDATE): 
1384              self.__field_start=value 
1385          else: 
1386              self.__field_start=LGCALDATE(value,**{'sizeinbytes': 4}) 
1387   
1388 -    def __delfield_start(self): del self.__field_start 
1389   
1390      start=property(__getfield_start, __setfield_start, __delfield_start, None) 
1391   
1392 -    def __getfield_end_time(self): 
1393          return self.__field_end_time.getvalue() 
1394   
1395 -    def __setfield_end_time(self, value): 
1396          if isinstance(value,LGCALDATE): 
1397              self.__field_end_time=value 
1398          else: 
1399              self.__field_end_time=LGCALDATE(value,**{'sizeinbytes': 4}) 
1400   
1401 -    def __delfield_end_time(self): del self.__field_end_time 
1402   
1403      end_time=property(__getfield_end_time, __setfield_end_time, __delfield_end_time, None) 
1404   
1405 -    def __getfield_end_date(self): 
1406          return self.__field_end_date.getvalue() 
1407   
1408 -    def __setfield_end_date(self, value): 
1409          if isinstance(value,LGCALDATE): 
1410              self.__field_end_date=value 
1411          else: 
1412              self.__field_end_date=LGCALDATE(value,**{'sizeinbytes': 4}) 
1413   
1414 -    def __delfield_end_date(self): del self.__field_end_date 
1415   
1416      end_date=property(__getfield_end_date, __setfield_end_date, __delfield_end_date, None) 
1417   
1418 -    def __getfield_repeat(self): 
1419          return self.__field_repeat.getvalue() 
1420   
1421 -    def __setfield_repeat(self, value): 
1422          if isinstance(value,LGCALREPEAT): 
1423              self.__field_repeat=value 
1424          else: 
1425              self.__field_repeat=LGCALREPEAT(value,**{'sizeinbytes': 4}) 
1426   
1427 -    def __delfield_repeat(self): del self.__field_repeat 
1428   
1429      repeat=property(__getfield_repeat, __setfield_repeat, __delfield_repeat, None) 
1430   
1431 -    def __getfield_alarmindex_vibrate(self): 
1432          return self.__field_alarmindex_vibrate.getvalue() 
1433   
1434 -    def __setfield_alarmindex_vibrate(self, value): 
1435          if isinstance(value,UINT): 
1436              self.__field_alarmindex_vibrate=value 
1437          else: 
1438              self.__field_alarmindex_vibrate=UINT(value,**{'sizeinbytes': 1}) 
1439   
1440 -    def __delfield_alarmindex_vibrate(self): del self.__field_alarmindex_vibrate 
1441   
1442      alarmindex_vibrate=property(__getfield_alarmindex_vibrate, __setfield_alarmindex_vibrate, __delfield_alarmindex_vibrate, None) 
1443   
1444 -    def __getfield_ringtone(self): 
1445          return self.__field_ringtone.getvalue() 
1446   
1447 -    def __setfield_ringtone(self, value): 
1448          if isinstance(value,UINT): 
1449              self.__field_ringtone=value 
1450          else: 
1451              self.__field_ringtone=UINT(value,**{'sizeinbytes': 1}) 
1452   
1453 -    def __delfield_ringtone(self): del self.__field_ringtone 
1454   
1455      ringtone=property(__getfield_ringtone, __setfield_ringtone, __delfield_ringtone, None) 
1456   
1457 -    def __getfield_unknown1(self): 
1458          try: self.__field_unknown1 
1459          except: 
1460              self.__field_unknown1=UINT(**{'sizeinbytes': 1,  'default': 0 }) 
1461          return self.__field_unknown1.getvalue() 
1462   
1463 -    def __setfield_unknown1(self, value): 
1464          if isinstance(value,UINT): 
1465              self.__field_unknown1=value 
1466          else: 
1467              self.__field_unknown1=UINT(value,**{'sizeinbytes': 1,  'default': 0 }) 
1468   
1469 -    def __delfield_unknown1(self): del self.__field_unknown1 
1470   
1471      unknown1=property(__getfield_unknown1, __setfield_unknown1, __delfield_unknown1, None) 
1472   
1473 -    def __getfield_alarmminutes(self): 
1474          return self.__field_alarmminutes.getvalue() 
1475   
1476 -    def __setfield_alarmminutes(self, value): 
1477          if isinstance(value,UINT): 
1478              self.__field_alarmminutes=value 
1479          else: 
1480              self.__field_alarmminutes=UINT(value,**{'sizeinbytes': 1}) 
1481   
1482 -    def __delfield_alarmminutes(self): del self.__field_alarmminutes 
1483   
1484      alarmminutes=property(__getfield_alarmminutes, __setfield_alarmminutes, __delfield_alarmminutes, "a value of 0xFF indicates not set") 
1485   
1486 -    def __getfield_alarmhours(self): 
1487          return self.__field_alarmhours.getvalue() 
1488   
1489 -    def __setfield_alarmhours(self, value): 
1490          if isinstance(value,UINT): 
1491              self.__field_alarmhours=value 
1492          else: 
1493              self.__field_alarmhours=UINT(value,**{'sizeinbytes': 1}) 
1494   
1495 -    def __delfield_alarmhours(self): del self.__field_alarmhours 
1496   
1497      alarmhours=property(__getfield_alarmhours, __setfield_alarmhours, __delfield_alarmhours, "a value of 0xFF indicates not set") 
1498   
1499 -    def __getfield_ringpath(self): 
1500          try: self.__field_ringpath 
1501          except: 
1502              self.__field_ringpath=USTRING(**{'sizeinbytes': 256, 'encoding': PHONE_ENCODING,                 'raiseonunterminatedread': False,                 'raiseontruncate': False,                 'default': '' }) 
1503          return self.__field_ringpath.getvalue() 
1504   
1505 -    def __setfield_ringpath(self, value): 
1506          if isinstance(value,USTRING): 
1507              self.__field_ringpath=value 
1508          else: 
1509              self.__field_ringpath=USTRING(value,**{'sizeinbytes': 256, 'encoding': PHONE_ENCODING,                 'raiseonunterminatedread': False,                 'raiseontruncate': False,                 'default': '' }) 
1510   
1511 -    def __delfield_ringpath(self): del self.__field_ringpath 
1512   
1513      ringpath=property(__getfield_ringpath, __setfield_ringpath, __delfield_ringpath, None) 
1514   
1515 -    def iscontainer(self): 
1516          return True 
1517   
1518 -    def containerelements(self): 
1519          yield ('pos', self.__field_pos, "position within file, used as an event id") 
1520          yield ('description', self.__field_description, None) 
1521          yield ('start', self.__field_start, None) 
1522          yield ('end_time', self.__field_end_time, None) 
1523          yield ('end_date', self.__field_end_date, None) 
1524          yield ('repeat', self.__field_repeat, None) 
1525          yield ('alarmindex_vibrate', self.__field_alarmindex_vibrate, None) 
1526          yield ('ringtone', self.__field_ringtone, None) 
1527          yield ('unknown1', self.__field_unknown1, None) 
1528          yield ('alarmminutes', self.__field_alarmminutes, "a value of 0xFF indicates not set") 
1529          yield ('alarmhours', self.__field_alarmhours, "a value of 0xFF indicates not set") 
1530          yield ('ringpath', self.__field_ringpath, None) 
1531   
1532   
1533   
1534   
1535 -class schedulefile(BaseProtogenClass): 
1536      __fields=['numactiveitems', 'events'] 
1537   
1538 -    def __init__(self, *args, **kwargs): 
1539          dict={} 
1540          # What was supplied to this function 
1541          dict.update(kwargs) 
1542          # Parent constructor 
1543          super(schedulefile,self).__init__(**dict) 
1544          if self.__class__ is schedulefile: 
1545              self._update(args,dict) 
1546   
1547   
1548 -    def getfields(self): 
1549          return self.__fields 
1550   
1551   
1552 -    def _update(self, args, kwargs): 
1553          super(schedulefile,self)._update(args,kwargs) 
1554          keys=kwargs.keys() 
1555          for key in keys: 
1556              if key in self.__fields: 
1557                  setattr(self, key, kwargs[key]) 
1558                  del kwargs[key] 
1559          # Were any unrecognized kwargs passed in? 
1560          if __debug__: 
1561              self._complainaboutunusedargs(schedulefile,kwargs) 
1562          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
1563          # Make all P fields that haven't already been constructed 
1564   
1565   
1566 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
1567          'Writes this packet to the supplied buffer' 
1568          self._bufferstartoffset=buf.getcurrentoffset() 
1569          self.__field_numactiveitems.writetobuffer(buf) 
1570          try: self.__field_events 
1571          except: 
1572              self.__field_events=LIST(**{'elementclass': scheduleevent}) 
1573          self.__field_events.writetobuffer(buf) 
1574          self._bufferendoffset=buf.getcurrentoffset() 
1575          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
1576   
1577   
1578 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
1579          'Reads this packet from the supplied buffer' 
1580          self._bufferstartoffset=buf.getcurrentoffset() 
1581          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
1582          self.__field_numactiveitems=UINT(**{'sizeinbytes': 2}) 
1583          self.__field_numactiveitems.readfrombuffer(buf) 
1584          self.__field_events=LIST(**{'elementclass': scheduleevent}) 
1585          self.__field_events.readfrombuffer(buf) 
1586          self._bufferendoffset=buf.getcurrentoffset() 
1587   
1588   
1589 -    def __getfield_numactiveitems(self): 
1590          return self.__field_numactiveitems.getvalue() 
1591   
1592 -    def __setfield_numactiveitems(self, value): 
1593          if isinstance(value,UINT): 
1594              self.__field_numactiveitems=value 
1595          else: 
1596              self.__field_numactiveitems=UINT(value,**{'sizeinbytes': 2}) 
1597   
1598 -    def __delfield_numactiveitems(self): del self.__field_numactiveitems 
1599   
1600      numactiveitems=property(__getfield_numactiveitems, __setfield_numactiveitems, __delfield_numactiveitems, None) 
1601   
1602 -    def __getfield_events(self): 
1603          try: self.__field_events 
1604          except: 
1605              self.__field_events=LIST(**{'elementclass': scheduleevent}) 
1606          return self.__field_events.getvalue() 
1607   
1608 -    def __setfield_events(self, value): 
1609          if isinstance(value,LIST): 
1610              self.__field_events=value 
1611          else: 
1612              self.__field_events=LIST(value,**{'elementclass': scheduleevent}) 
1613   
1614 -    def __delfield_events(self): del self.__field_events 
1615   
1616      events=property(__getfield_events, __setfield_events, __delfield_events, None) 
1617   
1618 -    def iscontainer(self): 
1619          return True 
1620   
1621 -    def containerelements(self): 
1622          yield ('numactiveitems', self.__field_numactiveitems, None) 
1623          yield ('events', self.__field_events, None) 
1624   
1625   
1626   
1627   
1628 -class call(BaseProtogenClass): 
1629      __fields=['GPStime', 'unknown2', 'duration', 'number', 'name', 'numberlength', 'pbnumbertype', 'unknown2', 'pbentrynum'] 
1630   
1631 -    def __init__(self, *args, **kwargs): 
1632          dict={} 
1633          # What was supplied to this function 
1634          dict.update(kwargs) 
1635          # Parent constructor 
1636          super(call,self).__init__(**dict) 
1637          if self.__class__ is call: 
1638              self._update(args,dict) 
1639   
1640   
1641 -    def getfields(self): 
1642          return self.__fields 
1643   
1644   
1645 -    def _update(self, args, kwargs): 
1646          super(call,self)._update(args,kwargs) 
1647          keys=kwargs.keys() 
1648          for key in keys: 
1649              if key in self.__fields: 
1650                  setattr(self, key, kwargs[key]) 
1651                  del kwargs[key] 
1652          # Were any unrecognized kwargs passed in? 
1653          if __debug__: 
1654              self._complainaboutunusedargs(call,kwargs) 
1655          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
1656          # Make all P fields that haven't already been constructed 
1657   
1658   
1659 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
1660          'Writes this packet to the supplied buffer' 
1661          self._bufferstartoffset=buf.getcurrentoffset() 
1662          self.__field_GPStime.writetobuffer(buf) 
1663          self.__field_unknown2.writetobuffer(buf) 
1664          self.__field_duration.writetobuffer(buf) 
1665          self.__field_number.writetobuffer(buf) 
1666          self.__field_name.writetobuffer(buf) 
1667          self.__field_numberlength.writetobuffer(buf) 
1668          self.__field_pbnumbertype.writetobuffer(buf) 
1669          self.__field_unknown2.writetobuffer(buf) 
1670          self.__field_pbentrynum.writetobuffer(buf) 
1671          self._bufferendoffset=buf.getcurrentoffset() 
1672          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
1673   
1674   
1675 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
1676          'Reads this packet from the supplied buffer' 
1677          self._bufferstartoffset=buf.getcurrentoffset() 
1678          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
1679          self.__field_GPStime=GPSDATE(**{'sizeinbytes': 4}) 
1680          self.__field_GPStime.readfrombuffer(buf) 
1681          self.__field_unknown2=UINT(**{'sizeinbytes': 4}) 
1682          self.__field_unknown2.readfrombuffer(buf) 
1683          self.__field_duration=UINT(**{'sizeinbytes': 4}) 
1684          self.__field_duration.readfrombuffer(buf) 
1685          self.__field_number=USTRING(**{'sizeinbytes': 49, 'raiseonunterminatedread': False}) 
1686          self.__field_number.readfrombuffer(buf) 
1687          self.__field_name=USTRING(**{'sizeinbytes': 36, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False}) 
1688          self.__field_name.readfrombuffer(buf) 
1689          self.__field_numberlength=UINT(**{'sizeinbytes': 1}) 
1690          self.__field_numberlength.readfrombuffer(buf) 
1691          self.__field_pbnumbertype=UINT(**{'sizeinbytes': 1}) 
1692          self.__field_pbnumbertype.readfrombuffer(buf) 
1693          self.__field_unknown2=UINT(**{'sizeinbytes': 5}) 
1694          self.__field_unknown2.readfrombuffer(buf) 
1695          self.__field_pbentrynum=UINT(**{'sizeinbytes': 2}) 
1696          self.__field_pbentrynum.readfrombuffer(buf) 
1697          self._bufferendoffset=buf.getcurrentoffset() 
1698   
1699   
1700 -    def __getfield_GPStime(self): 
1701          return self.__field_GPStime.getvalue() 
1702   
1703 -    def __setfield_GPStime(self, value): 
1704          if isinstance(value,GPSDATE): 
1705              self.__field_GPStime=value 
1706          else: 
1707              self.__field_GPStime=GPSDATE(value,**{'sizeinbytes': 4}) 
1708   
1709 -    def __delfield_GPStime(self): del self.__field_GPStime 
1710   
1711      GPStime=property(__getfield_GPStime, __setfield_GPStime, __delfield_GPStime, None) 
1712   
1713 -    def __getfield_unknown2(self): 
1714          return self.__field_unknown2.getvalue() 
1715   
1716 -    def __setfield_unknown2(self, value): 
1717          if isinstance(value,UINT): 
1718              self.__field_unknown2=value 
1719          else: 
1720              self.__field_unknown2=UINT(value,**{'sizeinbytes': 4}) 
1721   
1722 -    def __delfield_unknown2(self): del self.__field_unknown2 
1723   
1724      unknown2=property(__getfield_unknown2, __setfield_unknown2, __delfield_unknown2, None) 
1725   
1726 -    def __getfield_duration(self): 
1727          return self.__field_duration.getvalue() 
1728   
1729 -    def __setfield_duration(self, value): 
1730          if isinstance(value,UINT): 
1731              self.__field_duration=value 
1732          else: 
1733              self.__field_duration=UINT(value,**{'sizeinbytes': 4}) 
1734   
1735 -    def __delfield_duration(self): del self.__field_duration 
1736   
1737      duration=property(__getfield_duration, __setfield_duration, __delfield_duration, None) 
1738   
1739 -    def __getfield_number(self): 
1740          return self.__field_number.getvalue() 
1741   
1742 -    def __setfield_number(self, value): 
1743          if isinstance(value,USTRING): 
1744              self.__field_number=value 
1745          else: 
1746              self.__field_number=USTRING(value,**{'sizeinbytes': 49, 'raiseonunterminatedread': False}) 
1747   
1748 -    def __delfield_number(self): del self.__field_number 
1749   
1750      number=property(__getfield_number, __setfield_number, __delfield_number, None) 
1751   
1752 -    def __getfield_name(self): 
1753          return self.__field_name.getvalue() 
1754   
1755 -    def __setfield_name(self, value): 
1756          if isinstance(value,USTRING): 
1757              self.__field_name=value 
1758          else: 
1759              self.__field_name=USTRING(value,**{'sizeinbytes': 36, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False}) 
1760   
1761 -    def __delfield_name(self): del self.__field_name 
1762   
1763      name=property(__getfield_name, __setfield_name, __delfield_name, None) 
1764   
1765 -    def __getfield_numberlength(self): 
1766          return self.__field_numberlength.getvalue() 
1767   
1768 -    def __setfield_numberlength(self, value): 
1769          if isinstance(value,UINT): 
1770              self.__field_numberlength=value 
1771          else: 
1772              self.__field_numberlength=UINT(value,**{'sizeinbytes': 1}) 
1773   
1774 -    def __delfield_numberlength(self): del self.__field_numberlength 
1775   
1776      numberlength=property(__getfield_numberlength, __setfield_numberlength, __delfield_numberlength, None) 
1777   
1778 -    def __getfield_pbnumbertype(self): 
1779          return self.__field_pbnumbertype.getvalue() 
1780   
1781 -    def __setfield_pbnumbertype(self, value): 
1782          if isinstance(value,UINT): 
1783              self.__field_pbnumbertype=value 
1784          else: 
1785              self.__field_pbnumbertype=UINT(value,**{'sizeinbytes': 1}) 
1786   
1787 -    def __delfield_pbnumbertype(self): del self.__field_pbnumbertype 
1788   
1789      pbnumbertype=property(__getfield_pbnumbertype, __setfield_pbnumbertype, __delfield_pbnumbertype, None) 
1790   
1791 -    def __getfield_unknown2(self): 
1792          return self.__field_unknown2.getvalue() 
1793   
1794 -    def __setfield_unknown2(self, value): 
1795          if isinstance(value,UINT): 
1796              self.__field_unknown2=value 
1797          else: 
1798              self.__field_unknown2=UINT(value,**{'sizeinbytes': 5}) 
1799   
1800 -    def __delfield_unknown2(self): del self.__field_unknown2 
1801   
1802      unknown2=property(__getfield_unknown2, __setfield_unknown2, __delfield_unknown2, None) 
1803   
1804 -    def __getfield_pbentrynum(self): 
1805          return self.__field_pbentrynum.getvalue() 
1806   
1807 -    def __setfield_pbentrynum(self, value): 
1808          if isinstance(value,UINT): 
1809              self.__field_pbentrynum=value 
1810          else: 
1811              self.__field_pbentrynum=UINT(value,**{'sizeinbytes': 2}) 
1812   
1813 -    def __delfield_pbentrynum(self): del self.__field_pbentrynum 
1814   
1815      pbentrynum=property(__getfield_pbentrynum, __setfield_pbentrynum, __delfield_pbentrynum, None) 
1816   
1817 -    def iscontainer(self): 
1818          return True 
1819   
1820 -    def containerelements(self): 
1821          yield ('GPStime', self.__field_GPStime, None) 
1822          yield ('unknown2', self.__field_unknown2, None) 
1823          yield ('duration', self.__field_duration, None) 
1824          yield ('number', self.__field_number, None) 
1825          yield ('name', self.__field_name, None) 
1826          yield ('numberlength', self.__field_numberlength, None) 
1827          yield ('pbnumbertype', self.__field_pbnumbertype, None) 
1828          yield ('unknown2', self.__field_unknown2, None) 
1829          yield ('pbentrynum', self.__field_pbentrynum, None) 
1830   
1831   
1832   
1833   
1834 -class callhistory(BaseProtogenClass): 
1835      __fields=['numcalls', 'unknown1', 'calls'] 
1836   
1837 -    def __init__(self, *args, **kwargs): 
1838          dict={} 
1839          # What was supplied to this function 
1840          dict.update(kwargs) 
1841          # Parent constructor 
1842          super(callhistory,self).__init__(**dict) 
1843          if self.__class__ is callhistory: 
1844              self._update(args,dict) 
1845   
1846   
1847 -    def getfields(self): 
1848          return self.__fields 
1849   
1850   
1851 -    def _update(self, args, kwargs): 
1852          super(callhistory,self)._update(args,kwargs) 
1853          keys=kwargs.keys() 
1854          for key in keys: 
1855              if key in self.__fields: 
1856                  setattr(self, key, kwargs[key]) 
1857                  del kwargs[key] 
1858          # Were any unrecognized kwargs passed in? 
1859          if __debug__: 
1860              self._complainaboutunusedargs(callhistory,kwargs) 
1861          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
1862          # Make all P fields that haven't already been constructed 
1863   
1864   
1865 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
1866          'Writes this packet to the supplied buffer' 
1867          self._bufferstartoffset=buf.getcurrentoffset() 
1868          self.__field_numcalls.writetobuffer(buf) 
1869          self.__field_unknown1.writetobuffer(buf) 
1870          try: self.__field_calls 
1871          except: 
1872              self.__field_calls=LIST(**{'elementclass': call}) 
1873          self.__field_calls.writetobuffer(buf) 
1874          self._bufferendoffset=buf.getcurrentoffset() 
1875          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
1876   
1877   
1878 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
1879          'Reads this packet from the supplied buffer' 
1880          self._bufferstartoffset=buf.getcurrentoffset() 
1881          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
1882          self.__field_numcalls=UINT(**{'sizeinbytes': 4}) 
1883          self.__field_numcalls.readfrombuffer(buf) 
1884          self.__field_unknown1=UINT(**{'sizeinbytes': 1}) 
1885          self.__field_unknown1.readfrombuffer(buf) 
1886          self.__field_calls=LIST(**{'elementclass': call}) 
1887          self.__field_calls.readfrombuffer(buf) 
1888          self._bufferendoffset=buf.getcurrentoffset() 
1889   
1890   
1891 -    def __getfield_numcalls(self): 
1892          return self.__field_numcalls.getvalue() 
1893   
1894 -    def __setfield_numcalls(self, value): 
1895          if isinstance(value,UINT): 
1896              self.__field_numcalls=value 
1897          else: 
1898              self.__field_numcalls=UINT(value,**{'sizeinbytes': 4}) 
1899   
1900 -    def __delfield_numcalls(self): del self.__field_numcalls 
1901   
1902      numcalls=property(__getfield_numcalls, __setfield_numcalls, __delfield_numcalls, None) 
1903   
1904 -    def __getfield_unknown1(self): 
1905          return self.__field_unknown1.getvalue() 
1906   
1907 -    def __setfield_unknown1(self, value): 
1908          if isinstance(value,UINT): 
1909              self.__field_unknown1=value 
1910          else: 
1911              self.__field_unknown1=UINT(value,**{'sizeinbytes': 1}) 
1912   
1913 -    def __delfield_unknown1(self): del self.__field_unknown1 
1914   
1915      unknown1=property(__getfield_unknown1, __setfield_unknown1, __delfield_unknown1, None) 
1916   
1917 -    def __getfield_calls(self): 
1918          try: self.__field_calls 
1919          except: 
1920              self.__field_calls=LIST(**{'elementclass': call}) 
1921          return self.__field_calls.getvalue() 
1922   
1923 -    def __setfield_calls(self, value): 
1924          if isinstance(value,LIST): 
1925              self.__field_calls=value 
1926          else: 
1927              self.__field_calls=LIST(value,**{'elementclass': call}) 
1928   
1929 -    def __delfield_calls(self): del self.__field_calls 
1930   
1931      calls=property(__getfield_calls, __setfield_calls, __delfield_calls, None) 
1932   
1933 -    def iscontainer(self): 
1934          return True 
1935   
1936 -    def containerelements(self): 
1937          yield ('numcalls', self.__field_numcalls, None) 
1938          yield ('unknown1', self.__field_unknown1, None) 
1939          yield ('calls', self.__field_calls, None) 
1940   
1941   
1942   
1943   
1944 -class msg_record(BaseProtogenClass): 
1945      __fields=['unknown1', 'binary', 'unknown3', 'unknown4', 'unknown6', 'length', 'msg'] 
1946   
1947 -    def __init__(self, *args, **kwargs): 
1948          dict={} 
1949          # What was supplied to this function 
1950          dict.update(kwargs) 
1951          # Parent constructor 
1952          super(msg_record,self).__init__(**dict) 
1953          if self.__class__ is msg_record: 
1954              self._update(args,dict) 
1955   
1956   
1957 -    def getfields(self): 
1958          return self.__fields 
1959   
1960   
1961 -    def _update(self, args, kwargs): 
1962          super(msg_record,self)._update(args,kwargs) 
1963          keys=kwargs.keys() 
1964          for key in keys: 
1965              if key in self.__fields: 
1966                  setattr(self, key, kwargs[key]) 
1967                  del kwargs[key] 
1968          # Were any unrecognized kwargs passed in? 
1969          if __debug__: 
1970              self._complainaboutunusedargs(msg_record,kwargs) 
1971          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
1972          # Make all P fields that haven't already been constructed 
1973   
1974   
1975 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
1976          'Writes this packet to the supplied buffer' 
1977          self._bufferstartoffset=buf.getcurrentoffset() 
1978          self.__field_unknown1.writetobuffer(buf) 
1979          self.__field_binary.writetobuffer(buf) 
1980          self.__field_unknown3.writetobuffer(buf) 
1981          self.__field_unknown4.writetobuffer(buf) 
1982          self.__field_unknown6.writetobuffer(buf) 
1983          self.__field_length.writetobuffer(buf) 
1984          try: self.__field_msg 
1985          except: 
1986              self.__field_msg=LIST(**{'elementclass': _gen_p_lgvx8300_202, 'length': 219}) 
1987          self.__field_msg.writetobuffer(buf) 
1988          self._bufferendoffset=buf.getcurrentoffset() 
1989          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
1990   
1991   
1992 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
1993          'Reads this packet from the supplied buffer' 
1994          self._bufferstartoffset=buf.getcurrentoffset() 
1995          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
1996          self.__field_unknown1=UINT(**{'sizeinbytes': 1}) 
1997          self.__field_unknown1.readfrombuffer(buf) 
1998          self.__field_binary=UINT(**{'sizeinbytes': 1}) 
1999          self.__field_binary.readfrombuffer(buf) 
2000          self.__field_unknown3=UINT(**{'sizeinbytes': 1}) 
2001          self.__field_unknown3.readfrombuffer(buf) 
2002          self.__field_unknown4=UINT(**{'sizeinbytes': 1}) 
2003          self.__field_unknown4.readfrombuffer(buf) 
2004          self.__field_unknown6=UINT(**{'sizeinbytes': 1}) 
2005          self.__field_unknown6.readfrombuffer(buf) 
2006          self.__field_length=UINT(**{'sizeinbytes': 1}) 
2007          self.__field_length.readfrombuffer(buf) 
2008          self.__field_msg=LIST(**{'elementclass': _gen_p_lgvx8300_202, 'length': 219}) 
2009          self.__field_msg.readfrombuffer(buf) 
2010          self._bufferendoffset=buf.getcurrentoffset() 
2011   
2012   
2013 -    def __getfield_unknown1(self): 
2014          return self.__field_unknown1.getvalue() 
2015   
2016 -    def __setfield_unknown1(self, value): 
2017          if isinstance(value,UINT): 
2018              self.__field_unknown1=value 
2019          else: 
2020              self.__field_unknown1=UINT(value,**{'sizeinbytes': 1}) 
2021   
2022 -    def __delfield_unknown1(self): del self.__field_unknown1 
2023   
2024      unknown1=property(__getfield_unknown1, __setfield_unknown1, __delfield_unknown1, None) 
2025   
2026 -    def __getfield_binary(self): 
2027          return self.__field_binary.getvalue() 
2028   
2029 -    def __setfield_binary(self, value): 
2030          if isinstance(value,UINT): 
2031              self.__field_binary=value 
2032          else: 
2033              self.__field_binary=UINT(value,**{'sizeinbytes': 1}) 
2034   
2035 -    def __delfield_binary(self): del self.__field_binary 
2036   
2037      binary=property(__getfield_binary, __setfield_binary, __delfield_binary, None) 
2038   
2039 -    def __getfield_unknown3(self): 
2040          return self.__field_unknown3.getvalue() 
2041   
2042 -    def __setfield_unknown3(self, value): 
2043          if isinstance(value,UINT): 
2044              self.__field_unknown3=value 
2045          else: 
2046              self.__field_unknown3=UINT(value,**{'sizeinbytes': 1}) 
2047   
2048 -    def __delfield_unknown3(self): del self.__field_unknown3 
2049   
2050      unknown3=property(__getfield_unknown3, __setfield_unknown3, __delfield_unknown3, None) 
2051   
2052 -    def __getfield_unknown4(self): 
2053          return self.__field_unknown4.getvalue() 
2054   
2055 -    def __setfield_unknown4(self, value): 
2056          if isinstance(value,UINT): 
2057              self.__field_unknown4=value 
2058          else: 
2059              self.__field_unknown4=UINT(value,**{'sizeinbytes': 1}) 
2060   
2061 -    def __delfield_unknown4(self): del self.__field_unknown4 
2062   
2063      unknown4=property(__getfield_unknown4, __setfield_unknown4, __delfield_unknown4, None) 
2064   
2065 -    def __getfield_unknown6(self): 
2066          return self.__field_unknown6.getvalue() 
2067   
2068 -    def __setfield_unknown6(self, value): 
2069          if isinstance(value,UINT): 
2070              self.__field_unknown6=value 
2071          else: 
2072              self.__field_unknown6=UINT(value,**{'sizeinbytes': 1}) 
2073   
2074 -    def __delfield_unknown6(self): del self.__field_unknown6 
2075   
2076      unknown6=property(__getfield_unknown6, __setfield_unknown6, __delfield_unknown6, None) 
2077   
2078 -    def __getfield_length(self): 
2079          return self.__field_length.getvalue() 
2080   
2081 -    def __setfield_length(self, value): 
2082          if isinstance(value,UINT): 
2083              self.__field_length=value 
2084          else: 
2085              self.__field_length=UINT(value,**{'sizeinbytes': 1}) 
2086   
2087 -    def __delfield_length(self): del self.__field_length 
2088   
2089      length=property(__getfield_length, __setfield_length, __delfield_length, None) 
2090   
2091 -    def __getfield_msg(self): 
2092          try: self.__field_msg 
2093          except: 
2094              self.__field_msg=LIST(**{'elementclass': _gen_p_lgvx8300_202, 'length': 219}) 
2095          return self.__field_msg.getvalue() 
2096   
2097 -    def __setfield_msg(self, value): 
2098          if isinstance(value,LIST): 
2099              self.__field_msg=value 
2100          else: 
2101              self.__field_msg=LIST(value,**{'elementclass': _gen_p_lgvx8300_202, 'length': 219}) 
2102   
2103 -    def __delfield_msg(self): del self.__field_msg 
2104   
2105      msg=property(__getfield_msg, __setfield_msg, __delfield_msg, None) 
2106   
2107 -    def iscontainer(self): 
2108          return True 
2109   
2110 -    def containerelements(self): 
2111          yield ('unknown1', self.__field_unknown1, None) 
2112          yield ('binary', self.__field_binary, None) 
2113          yield ('unknown3', self.__field_unknown3, None) 
2114          yield ('unknown4', self.__field_unknown4, None) 
2115          yield ('unknown6', self.__field_unknown6, None) 
2116          yield ('length', self.__field_length, None) 
2117          yield ('msg', self.__field_msg, None) 
2118   
2119   
2120   
2121   
2122 -class _gen_p_lgvx8300_202(BaseProtogenClass): 
2123      'Anonymous inner class' 
2124      __fields=['byte'] 
2125   
2126 -    def __init__(self, *args, **kwargs): 
2127          dict={} 
2128          # What was supplied to this function 
2129          dict.update(kwargs) 
2130          # Parent constructor 
2131          super(_gen_p_lgvx8300_202,self).__init__(**dict) 
2132          if self.__class__ is _gen_p_lgvx8300_202: 
2133              self._update(args,dict) 
2134   
2135   
2136 -    def getfields(self): 
2137          return self.__fields 
2138   
2139   
2140 -    def _update(self, args, kwargs): 
2141          super(_gen_p_lgvx8300_202,self)._update(args,kwargs) 
2142          keys=kwargs.keys() 
2143          for key in keys: 
2144              if key in self.__fields: 
2145                  setattr(self, key, kwargs[key]) 
2146                  del kwargs[key] 
2147          # Were any unrecognized kwargs passed in? 
2148          if __debug__: 
2149              self._complainaboutunusedargs(_gen_p_lgvx8300_202,kwargs) 
2150          if len(args): 
2151              dict2={'sizeinbytes': 1} 
2152              dict2.update(kwargs) 
2153              kwargs=dict2 
2154              self.__field_byte=UINT(*args,**dict2) 
2155          # Make all P fields that haven't already been constructed 
2156   
2157   
2158 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
2159          'Writes this packet to the supplied buffer' 
2160          self._bufferstartoffset=buf.getcurrentoffset() 
2161          self.__field_byte.writetobuffer(buf) 
2162          self._bufferendoffset=buf.getcurrentoffset() 
2163          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
2164   
2165   
2166 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
2167          'Reads this packet from the supplied buffer' 
2168          self._bufferstartoffset=buf.getcurrentoffset() 
2169          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
2170          self.__field_byte=UINT(**{'sizeinbytes': 1}) 
2171          self.__field_byte.readfrombuffer(buf) 
2172          self._bufferendoffset=buf.getcurrentoffset() 
2173   
2174   
2175 -    def __getfield_byte(self): 
2176          return self.__field_byte.getvalue() 
2177   
2178 -    def __setfield_byte(self, value): 
2179          if isinstance(value,UINT): 
2180              self.__field_byte=value 
2181          else: 
2182              self.__field_byte=UINT(value,**{'sizeinbytes': 1}) 
2183   
2184 -    def __delfield_byte(self): del self.__field_byte 
2185   
2186      byte=property(__getfield_byte, __setfield_byte, __delfield_byte, "individual byte of message") 
2187   
2188 -    def iscontainer(self): 
2189          return True 
2190   
2191 -    def containerelements(self): 
2192          yield ('byte', self.__field_byte, "individual byte of message") 
2193   
2194   
2195   
2196   
2197 -class recipient_record(BaseProtogenClass): 
2198      __fields=['unknown1', 'number', 'status', 'timesent', 'timereceived', 'unknown2', 'unknown3'] 
2199   
2200 -    def __init__(self, *args, **kwargs): 
2201          dict={} 
2202          # What was supplied to this function 
2203          dict.update(kwargs) 
2204          # Parent constructor 
2205          super(recipient_record,self).__init__(**dict) 
2206          if self.__class__ is recipient_record: 
2207              self._update(args,dict) 
2208   
2209   
2210 -    def getfields(self): 
2211          return self.__fields 
2212   
2213   
2214 -    def _update(self, args, kwargs): 
2215          super(recipient_record,self)._update(args,kwargs) 
2216          keys=kwargs.keys() 
2217          for key in keys: 
2218              if key in self.__fields: 
2219                  setattr(self, key, kwargs[key]) 
2220                  del kwargs[key] 
2221          # Were any unrecognized kwargs passed in? 
2222          if __debug__: 
2223              self._complainaboutunusedargs(recipient_record,kwargs) 
2224          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
2225          # Make all P fields that haven't already been constructed 
2226   
2227   
2228 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
2229          'Writes this packet to the supplied buffer' 
2230          self._bufferstartoffset=buf.getcurrentoffset() 
2231          self.__field_unknown1.writetobuffer(buf) 
2232          self.__field_number.writetobuffer(buf) 
2233          self.__field_status.writetobuffer(buf) 
2234          self.__field_timesent.writetobuffer(buf) 
2235          self.__field_timereceived.writetobuffer(buf) 
2236          self.__field_unknown2.writetobuffer(buf) 
2237          self.__field_unknown3.writetobuffer(buf) 
2238          self._bufferendoffset=buf.getcurrentoffset() 
2239          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
2240   
2241   
2242 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
2243          'Reads this packet from the supplied buffer' 
2244          self._bufferstartoffset=buf.getcurrentoffset() 
2245          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
2246          self.__field_unknown1=DATA(**{'sizeinbytes': 34}) 
2247          self.__field_unknown1.readfrombuffer(buf) 
2248          self.__field_number=USTRING(**{'sizeinbytes': 49}) 
2249          self.__field_number.readfrombuffer(buf) 
2250          self.__field_status=UINT(**{'sizeinbytes': 1}) 
2251          self.__field_status.readfrombuffer(buf) 
2252          self.__field_timesent=LGCALDATE(**{'sizeinbytes': 4}) 
2253          self.__field_timesent.readfrombuffer(buf) 
2254          self.__field_timereceived=LGCALDATE(**{'sizeinbytes': 4}) 
2255          self.__field_timereceived.readfrombuffer(buf) 
2256          self.__field_unknown2=UINT(**{'sizeinbytes': 1}) 
2257          self.__field_unknown2.readfrombuffer(buf) 
2258          self.__field_unknown3=DATA(**{'sizeinbytes': 53}) 
2259          self.__field_unknown3.readfrombuffer(buf) 
2260          self._bufferendoffset=buf.getcurrentoffset() 
2261   
2262   
2263 -    def __getfield_unknown1(self): 
2264          return self.__field_unknown1.getvalue() 
2265   
2266 -    def __setfield_unknown1(self, value): 
2267          if isinstance(value,DATA): 
2268              self.__field_unknown1=value 
2269          else: 
2270              self.__field_unknown1=DATA(value,**{'sizeinbytes': 34}) 
2271   
2272 -    def __delfield_unknown1(self): del self.__field_unknown1 
2273   
2274      unknown1=property(__getfield_unknown1, __setfield_unknown1, __delfield_unknown1, None) 
2275   
2276 -    def __getfield_number(self): 
2277          return self.__field_number.getvalue() 
2278   
2279 -    def __setfield_number(self, value): 
2280          if isinstance(value,USTRING): 
2281              self.__field_number=value 
2282          else: 
2283              self.__field_number=USTRING(value,**{'sizeinbytes': 49}) 
2284   
2285 -    def __delfield_number(self): del self.__field_number 
2286   
2287      number=property(__getfield_number, __setfield_number, __delfield_number, None) 
2288   
2289 -    def __getfield_status(self): 
2290          return self.__field_status.getvalue() 
2291   
2292 -    def __setfield_status(self, value): 
2293          if isinstance(value,UINT): 
2294              self.__field_status=value 
2295          else: 
2296              self.__field_status=UINT(value,**{'sizeinbytes': 1}) 
2297   
2298 -    def __delfield_status(self): del self.__field_status 
2299   
2300      status=property(__getfield_status, __setfield_status, __delfield_status, None) 
2301   
2302 -    def __getfield_timesent(self): 
2303          return self.__field_timesent.getvalue() 
2304   
2305 -    def __setfield_timesent(self, value): 
2306          if isinstance(value,LGCALDATE): 
2307              self.__field_timesent=value 
2308          else: 
2309              self.__field_timesent=LGCALDATE(value,**{'sizeinbytes': 4}) 
2310   
2311 -    def __delfield_timesent(self): del self.__field_timesent 
2312   
2313      timesent=property(__getfield_timesent, __setfield_timesent, __delfield_timesent, None) 
2314   
2315 -    def __getfield_timereceived(self): 
2316          return self.__field_timereceived.getvalue() 
2317   
2318 -    def __setfield_timereceived(self, value): 
2319          if isinstance(value,LGCALDATE): 
2320              self.__field_timereceived=value 
2321          else: 
2322              self.__field_timereceived=LGCALDATE(value,**{'sizeinbytes': 4}) 
2323   
2324 -    def __delfield_timereceived(self): del self.__field_timereceived 
2325   
2326      timereceived=property(__getfield_timereceived, __setfield_timereceived, __delfield_timereceived, None) 
2327   
2328 -    def __getfield_unknown2(self): 
2329          return self.__field_unknown2.getvalue() 
2330   
2331 -    def __setfield_unknown2(self, value): 
2332          if isinstance(value,UINT): 
2333              self.__field_unknown2=value 
2334          else: 
2335              self.__field_unknown2=UINT(value,**{'sizeinbytes': 1}) 
2336   
2337 -    def __delfield_unknown2(self): del self.__field_unknown2 
2338   
2339      unknown2=property(__getfield_unknown2, __setfield_unknown2, __delfield_unknown2, None) 
2340   
2341 -    def __getfield_unknown3(self): 
2342          return self.__field_unknown3.getvalue() 
2343   
2344 -    def __setfield_unknown3(self, value): 
2345          if isinstance(value,DATA): 
2346              self.__field_unknown3=value 
2347          else: 
2348              self.__field_unknown3=DATA(value,**{'sizeinbytes': 53}) 
2349   
2350 -    def __delfield_unknown3(self): del self.__field_unknown3 
2351   
2352      unknown3=property(__getfield_unknown3, __setfield_unknown3, __delfield_unknown3, None) 
2353   
2354 -    def iscontainer(self): 
2355          return True 
2356   
2357 -    def containerelements(self): 
2358          yield ('unknown1', self.__field_unknown1, None) 
2359          yield ('number', self.__field_number, None) 
2360          yield ('status', self.__field_status, None) 
2361          yield ('timesent', self.__field_timesent, None) 
2362          yield ('timereceived', self.__field_timereceived, None) 
2363          yield ('unknown2', self.__field_unknown2, None) 
2364          yield ('unknown3', self.__field_unknown3, None) 
2365   
2366   
2367   
2368   
2369 -class sms_saved(BaseProtogenClass): 
2370      __fields=['outboxmsg', 'GPStime', 'outbox', 'inbox'] 
2371   
2372 -    def __init__(self, *args, **kwargs): 
2373          dict={} 
2374          # What was supplied to this function 
2375          dict.update(kwargs) 
2376          # Parent constructor 
2377          super(sms_saved,self).__init__(**dict) 
2378          if self.__class__ is sms_saved: 
2379              self._update(args,dict) 
2380   
2381   
2382 -    def getfields(self): 
2383          return self.__fields 
2384   
2385   
2386 -    def _update(self, args, kwargs): 
2387          super(sms_saved,self)._update(args,kwargs) 
2388          keys=kwargs.keys() 
2389          for key in keys: 
2390              if key in self.__fields: 
2391                  setattr(self, key, kwargs[key]) 
2392                  del kwargs[key] 
2393          # Were any unrecognized kwargs passed in? 
2394          if __debug__: 
2395              self._complainaboutunusedargs(sms_saved,kwargs) 
2396          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
2397          # Make all P fields that haven't already been constructed 
2398   
2399   
2400 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
2401          'Writes this packet to the supplied buffer' 
2402          self._bufferstartoffset=buf.getcurrentoffset() 
2403          self.__field_outboxmsg.writetobuffer(buf) 
2404          self.__field_GPStime.writetobuffer(buf) 
2405          if self.outboxmsg: 
2406              self.__field_outbox.writetobuffer(buf) 
2407          if not self.outboxmsg: 
2408              self.__field_inbox.writetobuffer(buf) 
2409          self._bufferendoffset=buf.getcurrentoffset() 
2410          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
2411   
2412   
2413 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
2414          'Reads this packet from the supplied buffer' 
2415          self._bufferstartoffset=buf.getcurrentoffset() 
2416          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
2417          self.__field_outboxmsg=UINT(**{'sizeinbytes': 4}) 
2418          self.__field_outboxmsg.readfrombuffer(buf) 
2419          self.__field_GPStime=GPSDATE(**{'sizeinbytes': 4}) 
2420          self.__field_GPStime.readfrombuffer(buf) 
2421          if self.outboxmsg: 
2422              self.__field_outbox=sms_out() 
2423              self.__field_outbox.readfrombuffer(buf) 
2424          if not self.outboxmsg: 
2425              self.__field_inbox=sms_in() 
2426              self.__field_inbox.readfrombuffer(buf) 
2427          self._bufferendoffset=buf.getcurrentoffset() 
2428   
2429   
2430 -    def __getfield_outboxmsg(self): 
2431          return self.__field_outboxmsg.getvalue() 
2432   
2433 -    def __setfield_outboxmsg(self, value): 
2434          if isinstance(value,UINT): 
2435              self.__field_outboxmsg=value 
2436          else: 
2437              self.__field_outboxmsg=UINT(value,**{'sizeinbytes': 4}) 
2438   
2439 -    def __delfield_outboxmsg(self): del self.__field_outboxmsg 
2440   
2441      outboxmsg=property(__getfield_outboxmsg, __setfield_outboxmsg, __delfield_outboxmsg, None) 
2442   
2443 -    def __getfield_GPStime(self): 
2444          return self.__field_GPStime.getvalue() 
2445   
2446 -    def __setfield_GPStime(self, value): 
2447          if isinstance(value,GPSDATE): 
2448              self.__field_GPStime=value 
2449          else: 
2450              self.__field_GPStime=GPSDATE(value,**{'sizeinbytes': 4}) 
2451   
2452 -    def __delfield_GPStime(self): del self.__field_GPStime 
2453   
2454      GPStime=property(__getfield_GPStime, __setfield_GPStime, __delfield_GPStime, None) 
2455   
2456 -    def __getfield_outbox(self): 
2457          return self.__field_outbox.getvalue() 
2458   
2459 -    def __setfield_outbox(self, value): 
2460          if isinstance(value,sms_out): 
2461              self.__field_outbox=value 
2462          else: 
2463              self.__field_outbox=sms_out(value,) 
2464   
2465 -    def __delfield_outbox(self): del self.__field_outbox 
2466   
2467      outbox=property(__getfield_outbox, __setfield_outbox, __delfield_outbox, None) 
2468   
2469 -    def __getfield_inbox(self): 
2470          return self.__field_inbox.getvalue() 
2471   
2472 -    def __setfield_inbox(self, value): 
2473          if isinstance(value,sms_in): 
2474              self.__field_inbox=value 
2475          else: 
2476              self.__field_inbox=sms_in(value,) 
2477   
2478 -    def __delfield_inbox(self): del self.__field_inbox 
2479   
2480      inbox=property(__getfield_inbox, __setfield_inbox, __delfield_inbox, None) 
2481   
2482 -    def iscontainer(self): 
2483          return True 
2484   
2485 -    def containerelements(self): 
2486          yield ('outboxmsg', self.__field_outboxmsg, None) 
2487          yield ('GPStime', self.__field_GPStime, None) 
2488          if self.outboxmsg: 
2489              yield ('outbox', self.__field_outbox, None) 
2490          if not self.outboxmsg: 
2491              yield ('inbox', self.__field_inbox, None) 
2492   
2493   
2494   
2495   
2496 -class sms_out(BaseProtogenClass): 
2497      __fields=['index', 'unknown1', 'locked', 'timesent', 'unknown2', 'GPStime', 'subject', 'num_msg_elements', 'messages', 'unknown1', 'priority', 'unknown5', 'callback', 'recipients', 'pad'] 
2498   
2499 -    def __init__(self, *args, **kwargs): 
2500          dict={} 
2501          # What was supplied to this function 
2502          dict.update(kwargs) 
2503          # Parent constructor 
2504          super(sms_out,self).__init__(**dict) 
2505          if self.__class__ is sms_out: 
2506              self._update(args,dict) 
2507   
2508   
2509 -    def getfields(self): 
2510          return self.__fields 
2511   
2512   
2513 -    def _update(self, args, kwargs): 
2514          super(sms_out,self)._update(args,kwargs) 
2515          keys=kwargs.keys() 
2516          for key in keys: 
2517              if key in self.__fields: 
2518                  setattr(self, key, kwargs[key]) 
2519                  del kwargs[key] 
2520          # Were any unrecognized kwargs passed in? 
2521          if __debug__: 
2522              self._complainaboutunusedargs(sms_out,kwargs) 
2523          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
2524          # Make all P fields that haven't already been constructed 
2525   
2526   
2527 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
2528          'Writes this packet to the supplied buffer' 
2529          self._bufferstartoffset=buf.getcurrentoffset() 
2530          self.__field_index.writetobuffer(buf) 
2531          self.__field_unknown1.writetobuffer(buf) 
2532          self.__field_locked.writetobuffer(buf) 
2533          self.__field_timesent.writetobuffer(buf) 
2534          self.__field_unknown2.writetobuffer(buf) 
2535          self.__field_GPStime.writetobuffer(buf) 
2536          self.__field_subject.writetobuffer(buf) 
2537          self.__field_num_msg_elements.writetobuffer(buf) 
2538          try: self.__field_messages 
2539          except: 
2540              self.__field_messages=LIST(**{'elementclass': msg_record, 'length': 7}) 
2541          self.__field_messages.writetobuffer(buf) 
2542          self.__field_unknown1.writetobuffer(buf) 
2543          self.__field_priority.writetobuffer(buf) 
2544          self.__field_unknown5.writetobuffer(buf) 
2545          self.__field_callback.writetobuffer(buf) 
2546          try: self.__field_recipients 
2547          except: 
2548              self.__field_recipients=LIST(**{'elementclass': recipient_record,'length': 9}) 
2549          self.__field_recipients.writetobuffer(buf) 
2550          self.__field_pad.writetobuffer(buf) 
2551          self._bufferendoffset=buf.getcurrentoffset() 
2552          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
2553   
2554   
2555 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
2556          'Reads this packet from the supplied buffer' 
2557          self._bufferstartoffset=buf.getcurrentoffset() 
2558          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
2559          self.__field_index=UINT(**{'sizeinbytes': 4}) 
2560          self.__field_index.readfrombuffer(buf) 
2561          self.__field_unknown1=UINT(**{'sizeinbytes': 1}) 
2562          self.__field_unknown1.readfrombuffer(buf) 
2563          self.__field_locked=UINT(**{'sizeinbytes': 1}) 
2564          self.__field_locked.readfrombuffer(buf) 
2565          self.__field_timesent=LGCALDATE(**{'sizeinbytes': 4}) 
2566          self.__field_timesent.readfrombuffer(buf) 
2567          self.__field_unknown2=UINT(**{'sizeinbytes': 2}) 
2568          self.__field_unknown2.readfrombuffer(buf) 
2569          self.__field_GPStime=GPSDATE(**{'sizeinbytes': 4}) 
2570          self.__field_GPStime.readfrombuffer(buf) 
2571          self.__field_subject=USTRING(**{'sizeinbytes': 24, 'encoding': PHONE_ENCODING}) 
2572          self.__field_subject.readfrombuffer(buf) 
2573          self.__field_num_msg_elements=UINT(**{'sizeinbytes': 1}) 
2574          self.__field_num_msg_elements.readfrombuffer(buf) 
2575          self.__field_messages=LIST(**{'elementclass': msg_record, 'length': 7}) 
2576          self.__field_messages.readfrombuffer(buf) 
2577          self.__field_unknown1=UNKNOWN(**{'sizeinbytes': 15}) 
2578          self.__field_unknown1.readfrombuffer(buf) 
2579          self.__field_priority=UINT(**{'sizeinbytes': 1}) 
2580          self.__field_priority.readfrombuffer(buf) 
2581          self.__field_unknown5=UNKNOWN(**{'sizeinbytes': 1}) 
2582          self.__field_unknown5.readfrombuffer(buf) 
2583          self.__field_callback=USTRING(**{'sizeinbytes': 35}) 
2584          self.__field_callback.readfrombuffer(buf) 
2585          self.__field_recipients=LIST(**{'elementclass': recipient_record,'length': 9}) 
2586          self.__field_recipients.readfrombuffer(buf) 
2587          self.__field_pad=UNKNOWN() 
2588          self.__field_pad.readfrombuffer(buf) 
2589          self._bufferendoffset=buf.getcurrentoffset() 
2590   
2591   
2592 -    def __getfield_index(self): 
2593          return self.__field_index.getvalue() 
2594   
2595 -    def __setfield_index(self, value): 
2596          if isinstance(value,UINT): 
2597              self.__field_index=value 
2598          else: 
2599              self.__field_index=UINT(value,**{'sizeinbytes': 4}) 
2600   
2601 -    def __delfield_index(self): del self.__field_index 
2602   
2603      index=property(__getfield_index, __setfield_index, __delfield_index, None) 
2604   
2605 -    def __getfield_unknown1(self): 
2606          return self.__field_unknown1.getvalue() 
2607   
2608 -    def __setfield_unknown1(self, value): 
2609          if isinstance(value,UINT): 
2610              self.__field_unknown1=value 
2611          else: 
2612              self.__field_unknown1=UINT(value,**{'sizeinbytes': 1}) 
2613   
2614 -    def __delfield_unknown1(self): del self.__field_unknown1 
2615   
2616      unknown1=property(__getfield_unknown1, __setfield_unknown1, __delfield_unknown1, None) 
2617   
2618 -    def __getfield_locked(self): 
2619          return self.__field_locked.getvalue() 
2620   
2621 -    def __setfield_locked(self, value): 
2622          if isinstance(value,UINT): 
2623              self.__field_locked=value 
2624          else: 
2625              self.__field_locked=UINT(value,**{'sizeinbytes': 1}) 
2626   
2627 -    def __delfield_locked(self): del self.__field_locked 
2628   
2629      locked=property(__getfield_locked, __setfield_locked, __delfield_locked, None) 
2630   
2631 -    def __getfield_timesent(self): 
2632          return self.__field_timesent.getvalue() 
2633   
2634 -    def __setfield_timesent(self, value): 
2635          if isinstance(value,LGCALDATE): 
2636              self.__field_timesent=value 
2637          else: 
2638              self.__field_timesent=LGCALDATE(value,**{'sizeinbytes': 4}) 
2639   
2640 -    def __delfield_timesent(self): del self.__field_timesent 
2641   
2642      timesent=property(__getfield_timesent, __setfield_timesent, __delfield_timesent, None) 
2643   
2644 -    def __getfield_unknown2(self): 
2645          return self.__field_unknown2.getvalue() 
2646   
2647 -    def __setfield_unknown2(self, value): 
2648          if isinstance(value,UINT): 
2649              self.__field_unknown2=value 
2650          else: 
2651              self.__field_unknown2=UINT(value,**{'sizeinbytes': 2}) 
2652   
2653 -    def __delfield_unknown2(self): del self.__field_unknown2 
2654   
2655      unknown2=property(__getfield_unknown2, __setfield_unknown2, __delfield_unknown2, None) 
2656   
2657 -    def __getfield_GPStime(self): 
2658          return self.__field_GPStime.getvalue() 
2659   
2660 -    def __setfield_GPStime(self, value): 
2661          if isinstance(value,GPSDATE): 
2662              self.__field_GPStime=value 
2663          else: 
2664              self.__field_GPStime=GPSDATE(value,**{'sizeinbytes': 4}) 
2665   
2666 -    def __delfield_GPStime(self): del self.__field_GPStime 
2667   
2668      GPStime=property(__getfield_GPStime, __setfield_GPStime, __delfield_GPStime, None) 
2669   
2670 -    def __getfield_subject(self): 
2671          return self.__field_subject.getvalue() 
2672   
2673 -    def __setfield_subject(self, value): 
2674          if isinstance(value,USTRING): 
2675              self.__field_subject=value 
2676          else: 
2677              self.__field_subject=USTRING(value,**{'sizeinbytes': 24, 'encoding': PHONE_ENCODING}) 
2678   
2679 -    def __delfield_subject(self): del self.__field_subject 
2680   
2681      subject=property(__getfield_subject, __setfield_subject, __delfield_subject, None) 
2682   
2683 -    def __getfield_num_msg_elements(self): 
2684          return self.__field_num_msg_elements.getvalue() 
2685   
2686 -    def __setfield_num_msg_elements(self, value): 
2687          if isinstance(value,UINT): 
2688              self.__field_num_msg_elements=value 
2689          else: 
2690              self.__field_num_msg_elements=UINT(value,**{'sizeinbytes': 1}) 
2691   
2692 -    def __delfield_num_msg_elements(self): del self.__field_num_msg_elements 
2693   
2694      num_msg_elements=property(__getfield_num_msg_elements, __setfield_num_msg_elements, __delfield_num_msg_elements, None) 
2695   
2696 -    def __getfield_messages(self): 
2697          try: self.__field_messages 
2698          except: 
2699              self.__field_messages=LIST(**{'elementclass': msg_record, 'length': 7}) 
2700          return self.__field_messages.getvalue() 
2701   
2702 -    def __setfield_messages(self, value): 
2703          if isinstance(value,LIST): 
2704              self.__field_messages=value 
2705          else: 
2706              self.__field_messages=LIST(value,**{'elementclass': msg_record, 'length': 7}) 
2707   
2708 -    def __delfield_messages(self): del self.__field_messages 
2709   
2710      messages=property(__getfield_messages, __setfield_messages, __delfield_messages, None) 
2711   
2712 -    def __getfield_unknown1(self): 
2713          return self.__field_unknown1.getvalue() 
2714   
2715 -    def __setfield_unknown1(self, value): 
2716          if isinstance(value,UNKNOWN): 
2717              self.__field_unknown1=value 
2718          else: 
2719              self.__field_unknown1=UNKNOWN(value,**{'sizeinbytes': 15}) 
2720   
2721 -    def __delfield_unknown1(self): del self.__field_unknown1 
2722   
2723      unknown1=property(__getfield_unknown1, __setfield_unknown1, __delfield_unknown1, None) 
2724   
2725 -    def __getfield_priority(self): 
2726          return self.__field_priority.getvalue() 
2727   
2728 -    def __setfield_priority(self, value): 
2729          if isinstance(value,UINT): 
2730              self.__field_priority=value 
2731          else: 
2732              self.__field_priority=UINT(value,**{'sizeinbytes': 1}) 
2733   
2734 -    def __delfield_priority(self): del self.__field_priority 
2735   
2736      priority=property(__getfield_priority, __setfield_priority, __delfield_priority, None) 
2737   
2738 -    def __getfield_unknown5(self): 
2739          return self.__field_unknown5.getvalue() 
2740   
2741 -    def __setfield_unknown5(self, value): 
2742          if isinstance(value,UNKNOWN): 
2743              self.__field_unknown5=value 
2744          else: 
2745              self.__field_unknown5=UNKNOWN(value,**{'sizeinbytes': 1}) 
2746   
2747 -    def __delfield_unknown5(self): del self.__field_unknown5 
2748   
2749      unknown5=property(__getfield_unknown5, __setfield_unknown5, __delfield_unknown5, None) 
2750   
2751 -    def __getfield_callback(self): 
2752          return self.__field_callback.getvalue() 
2753   
2754 -    def __setfield_callback(self, value): 
2755          if isinstance(value,USTRING): 
2756              self.__field_callback=value 
2757          else: 
2758              self.__field_callback=USTRING(value,**{'sizeinbytes': 35}) 
2759   
2760 -    def __delfield_callback(self): del self.__field_callback 
2761   
2762      callback=property(__getfield_callback, __setfield_callback, __delfield_callback, None) 
2763   
2764 -    def __getfield_recipients(self): 
2765          try: self.__field_recipients 
2766          except: 
2767              self.__field_recipients=LIST(**{'elementclass': recipient_record,'length': 9}) 
2768          return self.__field_recipients.getvalue() 
2769   
2770 -    def __setfield_recipients(self, value): 
2771          if isinstance(value,LIST): 
2772              self.__field_recipients=value 
2773          else: 
2774              self.__field_recipients=LIST(value,**{'elementclass': recipient_record,'length': 9}) 
2775   
2776 -    def __delfield_recipients(self): del self.__field_recipients 
2777   
2778      recipients=property(__getfield_recipients, __setfield_recipients, __delfield_recipients, None) 
2779   
2780 -    def __getfield_pad(self): 
2781          return self.__field_pad.getvalue() 
2782   
2783 -    def __setfield_pad(self, value): 
2784          if isinstance(value,UNKNOWN): 
2785              self.__field_pad=value 
2786          else: 
2787              self.__field_pad=UNKNOWN(value,) 
2788   
2789 -    def __delfield_pad(self): del self.__field_pad 
2790   
2791      pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None) 
2792   
2793 -    def iscontainer(self): 
2794          return True 
2795   
2796 -    def containerelements(self): 
2797          yield ('index', self.__field_index, None) 
2798          yield ('unknown1', self.__field_unknown1, None) 
2799          yield ('locked', self.__field_locked, None) 
2800          yield ('timesent', self.__field_timesent, None) 
2801          yield ('unknown2', self.__field_unknown2, None) 
2802          yield ('GPStime', self.__field_GPStime, None) 
2803          yield ('subject', self.__field_subject, None) 
2804          yield ('num_msg_elements', self.__field_num_msg_elements, None) 
2805          yield ('messages', self.__field_messages, None) 
2806          yield ('unknown1', self.__field_unknown1, None) 
2807          yield ('priority', self.__field_priority, None) 
2808          yield ('unknown5', self.__field_unknown5, None) 
2809          yield ('callback', self.__field_callback, None) 
2810          yield ('recipients', self.__field_recipients, None) 
2811          yield ('pad', self.__field_pad, None) 
2812   
2813   
2814   
2815   
2816 -class SMSINBOXMSGFRAGMENT(BaseProtogenClass): 
2817      __fields=['msg'] 
2818   
2819 -    def __init__(self, *args, **kwargs): 
2820          dict={} 
2821          # What was supplied to this function 
2822          dict.update(kwargs) 
2823          # Parent constructor 
2824          super(SMSINBOXMSGFRAGMENT,self).__init__(**dict) 
2825          if self.__class__ is SMSINBOXMSGFRAGMENT: 
2826              self._update(args,dict) 
2827   
2828   
2829 -    def getfields(self): 
2830          return self.__fields 
2831   
2832   
2833 -    def _update(self, args, kwargs): 
2834          super(SMSINBOXMSGFRAGMENT,self)._update(args,kwargs) 
2835          keys=kwargs.keys() 
2836          for key in keys: 
2837              if key in self.__fields: 
2838                  setattr(self, key, kwargs[key]) 
2839                  del kwargs[key] 
2840          # Were any unrecognized kwargs passed in? 
2841          if __debug__: 
2842              self._complainaboutunusedargs(SMSINBOXMSGFRAGMENT,kwargs) 
2843          if len(args): 
2844              dict2={'elementclass': _gen_p_lgvx8300_240, 'length': 181} 
2845              dict2.update(kwargs) 
2846              kwargs=dict2 
2847              self.__field_msg=LIST(*args,**dict2) 
2848          # Make all P fields that haven't already been constructed 
2849   
2850   
2851 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
2852          'Writes this packet to the supplied buffer' 
2853          self._bufferstartoffset=buf.getcurrentoffset() 
2854          try: self.__field_msg 
2855          except: 
2856              self.__field_msg=LIST(**{'elementclass': _gen_p_lgvx8300_240, 'length': 181}) 
2857          self.__field_msg.writetobuffer(buf) 
2858          self._bufferendoffset=buf.getcurrentoffset() 
2859          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
2860   
2861   
2862 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
2863          'Reads this packet from the supplied buffer' 
2864          self._bufferstartoffset=buf.getcurrentoffset() 
2865          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
2866          self.__field_msg=LIST(**{'elementclass': _gen_p_lgvx8300_240, 'length': 181}) 
2867          self.__field_msg.readfrombuffer(buf) 
2868          self._bufferendoffset=buf.getcurrentoffset() 
2869   
2870   
2871 -    def __getfield_msg(self): 
2872          try: self.__field_msg 
2873          except: 
2874              self.__field_msg=LIST(**{'elementclass': _gen_p_lgvx8300_240, 'length': 181}) 
2875          return self.__field_msg.getvalue() 
2876   
2877 -    def __setfield_msg(self, value): 
2878          if isinstance(value,LIST): 
2879              self.__field_msg=value 
2880          else: 
2881              self.__field_msg=LIST(value,**{'elementclass': _gen_p_lgvx8300_240, 'length': 181}) 
2882   
2883 -    def __delfield_msg(self): del self.__field_msg 
2884   
2885      msg=property(__getfield_msg, __setfield_msg, __delfield_msg, None) 
2886   
2887 -    def iscontainer(self): 
2888          return True 
2889   
2890 -    def containerelements(self): 
2891          yield ('msg', self.__field_msg, None) 
2892   
2893   
2894   
2895   
2896 -class _gen_p_lgvx8300_240(BaseProtogenClass): 
2897      'Anonymous inner class' 
2898      __fields=['byte'] 
2899   
2900 -    def __init__(self, *args, **kwargs): 
2901          dict={} 
2902          # What was supplied to this function 
2903          dict.update(kwargs) 
2904          # Parent constructor 
2905          super(_gen_p_lgvx8300_240,self).__init__(**dict) 
2906          if self.__class__ is _gen_p_lgvx8300_240: 
2907              self._update(args,dict) 
2908   
2909   
2910 -    def getfields(self): 
2911          return self.__fields 
2912   
2913   
2914 -    def _update(self, args, kwargs): 
2915          super(_gen_p_lgvx8300_240,self)._update(args,kwargs) 
2916          keys=kwargs.keys() 
2917          for key in keys: 
2918              if key in self.__fields: 
2919                  setattr(self, key, kwargs[key]) 
2920                  del kwargs[key] 
2921          # Were any unrecognized kwargs passed in? 
2922          if __debug__: 
2923              self._complainaboutunusedargs(_gen_p_lgvx8300_240,kwargs) 
2924          if len(args): 
2925              dict2={'sizeinbytes': 1} 
2926              dict2.update(kwargs) 
2927              kwargs=dict2 
2928              self.__field_byte=UINT(*args,**dict2) 
2929          # Make all P fields that haven't already been constructed 
2930   
2931   
2932 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
2933          'Writes this packet to the supplied buffer' 
2934          self._bufferstartoffset=buf.getcurrentoffset() 
2935          self.__field_byte.writetobuffer(buf) 
2936          self._bufferendoffset=buf.getcurrentoffset() 
2937          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
2938   
2939   
2940 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
2941          'Reads this packet from the supplied buffer' 
2942          self._bufferstartoffset=buf.getcurrentoffset() 
2943          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
2944          self.__field_byte=UINT(**{'sizeinbytes': 1}) 
2945          self.__field_byte.readfrombuffer(buf) 
2946          self._bufferendoffset=buf.getcurrentoffset() 
2947   
2948   
2949 -    def __getfield_byte(self): 
2950          return self.__field_byte.getvalue() 
2951   
2952 -    def __setfield_byte(self, value): 
2953          if isinstance(value,UINT): 
2954              self.__field_byte=value 
2955          else: 
2956              self.__field_byte=UINT(value,**{'sizeinbytes': 1}) 
2957   
2958 -    def __delfield_byte(self): del self.__field_byte 
2959   
2960      byte=property(__getfield_byte, __setfield_byte, __delfield_byte, "individual byte of message") 
2961   
2962 -    def iscontainer(self): 
2963          return True 
2964   
2965 -    def containerelements(self): 
2966          yield ('byte', self.__field_byte, "individual byte of message") 
2967   
2968   
2969   
2970   
2971 -class sms_in(BaseProtogenClass): 
2972      __fields=['unknown1', 'lg_time', 'unknown2', 'GPStime', 'timesent', 'callback_length', 'callback', 'sender_length', 'sender', 'unknown3', 'unknown4', 'read', 'locked', 'priority', 'subject', 'bin_header1', 'bin_header2', 'unknown7', 'multipartID', 'bin_header3', 'unknown8', 'num_msg_elements', 'msglengths', 'unknown9', 'msgs', 'unknown10'] 
2973   
2974 -    def __init__(self, *args, **kwargs): 
2975          dict={} 
2976          # What was supplied to this function 
2977          dict.update(kwargs) 
2978          # Parent constructor 
2979          super(sms_in,self).__init__(**dict) 
2980          if self.__class__ is sms_in: 
2981              self._update(args,dict) 
2982   
2983   
2984 -    def getfields(self): 
2985          return self.__fields 
2986   
2987   
2988 -    def _update(self, args, kwargs): 
2989          super(sms_in,self)._update(args,kwargs) 
2990          keys=kwargs.keys() 
2991          for key in keys: 
2992              if key in self.__fields: 
2993                  setattr(self, key, kwargs[key]) 
2994                  del kwargs[key] 
2995          # Were any unrecognized kwargs passed in? 
2996          if __debug__: 
2997              self._complainaboutunusedargs(sms_in,kwargs) 
2998          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
2999          # Make all P fields that haven't already been constructed 
3000   
3001   
3002 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
3003          'Writes this packet to the supplied buffer' 
3004          self._bufferstartoffset=buf.getcurrentoffset() 
3005          self.__field_unknown1.writetobuffer(buf) 
3006          self.__field_lg_time.writetobuffer(buf) 
3007          self.__field_unknown2.writetobuffer(buf) 
3008          self.__field_GPStime.writetobuffer(buf) 
3009          self.__field_timesent.writetobuffer(buf) 
3010          self.__field_callback_length.writetobuffer(buf) 
3011          self.__field_callback.writetobuffer(buf) 
3012          self.__field_sender_length.writetobuffer(buf) 
3013          try: self.__field_sender 
3014          except: 
3015              self.__field_sender=LIST(**{'elementclass': _gen_p_lgvx8300_252, 'length': 38}) 
3016          self.__field_sender.writetobuffer(buf) 
3017          self.__field_unknown3.writetobuffer(buf) 
3018          self.__field_unknown4.writetobuffer(buf) 
3019          self.__field_read.writetobuffer(buf) 
3020          self.__field_locked.writetobuffer(buf) 
3021          self.__field_priority.writetobuffer(buf) 
3022          self.__field_subject.writetobuffer(buf) 
3023          self.__field_bin_header1.writetobuffer(buf) 
3024          self.__field_bin_header2.writetobuffer(buf) 
3025          self.__field_unknown7.writetobuffer(buf) 
3026          self.__field_multipartID.writetobuffer(buf) 
3027          self.__field_bin_header3.writetobuffer(buf) 
3028          self.__field_unknown8.writetobuffer(buf) 
3029          self.__field_num_msg_elements.writetobuffer(buf) 
3030          try: self.__field_msglengths 
3031          except: 
3032              self.__field_msglengths=LIST(**{'elementclass': _gen_p_lgvx8300_267, 'length': 10}) 
3033          self.__field_msglengths.writetobuffer(buf) 
3034          self.__field_unknown9.writetobuffer(buf) 
3035          try: self.__field_msgs 
3036          except: 
3037              self.__field_msgs=LIST(**{'length': 10, 'elementclass': SMSINBOXMSGFRAGMENT}) 
3038          self.__field_msgs.writetobuffer(buf) 
3039          self.__field_unknown10.writetobuffer(buf) 
3040          self._bufferendoffset=buf.getcurrentoffset() 
3041          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
3042   
3043   
3044 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
3045          'Reads this packet from the supplied buffer' 
3046          self._bufferstartoffset=buf.getcurrentoffset() 
3047          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
3048          self.__field_unknown1=UNKNOWN(**{'sizeinbytes': 7}) 
3049          self.__field_unknown1.readfrombuffer(buf) 
3050          self.__field_lg_time=LGCALDATE(**{'sizeinbytes': 4}) 
3051          self.__field_lg_time.readfrombuffer(buf) 
3052          self.__field_unknown2=UINT(**{'sizeinbytes': 1}) 
3053          self.__field_unknown2.readfrombuffer(buf) 
3054          self.__field_GPStime=GPSDATE(**{'sizeinbytes': 4}) 
3055          self.__field_GPStime.readfrombuffer(buf) 
3056          self.__field_timesent=SMSDATE(**{'sizeinbytes': 6}) 
3057          self.__field_timesent.readfrombuffer(buf) 
3058          self.__field_callback_length=UINT(**{'sizeinbytes': 1}) 
3059          self.__field_callback_length.readfrombuffer(buf) 
3060          self.__field_callback=USTRING(**{'sizeinbytes': 39}) 
3061          self.__field_callback.readfrombuffer(buf) 
3062          self.__field_sender_length=UINT(**{'sizeinbytes': 1}) 
3063          self.__field_sender_length.readfrombuffer(buf) 
3064          self.__field_sender=LIST(**{'elementclass': _gen_p_lgvx8300_252, 'length': 38}) 
3065          self.__field_sender.readfrombuffer(buf) 
3066          self.__field_unknown3=DATA(**{'sizeinbytes': 12}) 
3067          self.__field_unknown3.readfrombuffer(buf) 
3068          self.__field_unknown4=UNKNOWN(**{'sizeinbytes': 6}) 
3069          self.__field_unknown4.readfrombuffer(buf) 
3070          self.__field_read=UINT(**{'sizeinbytes': 1}) 
3071          self.__field_read.readfrombuffer(buf) 
3072          self.__field_locked=UINT(**{'sizeinbytes': 1}) 
3073          self.__field_locked.readfrombuffer(buf) 
3074          self.__field_priority=UINT(**{'sizeinbytes': 1}) 
3075          self.__field_priority.readfrombuffer(buf) 
3076          self.__field_subject=USTRING(**{'sizeinbytes': 24, 'encoding': PHONE_ENCODING}) 
3077          self.__field_subject.readfrombuffer(buf) 
3078          self.__field_bin_header1=UINT(**{'sizeinbytes': 1}) 
3079          self.__field_bin_header1.readfrombuffer(buf) 
3080          self.__field_bin_header2=UINT(**{'sizeinbytes': 1}) 
3081          self.__field_bin_header2.readfrombuffer(buf) 
3082          self.__field_unknown7=UINT(**{'sizeinbytes': 1}) 
3083          self.__field_unknown7.readfrombuffer(buf) 
3084          self.__field_multipartID=UINT(**{'sizeinbytes': 2}) 
3085          self.__field_multipartID.readfrombuffer(buf) 
3086          self.__field_bin_header3=UINT(**{'sizeinbytes': 1}) 
3087          self.__field_bin_header3.readfrombuffer(buf) 
3088          self.__field_unknown8=UINT(**{'sizeinbytes': 5}) 
3089          self.__field_unknown8.readfrombuffer(buf) 
3090          self.__field_num_msg_elements=UINT(**{'sizeinbytes': 1}) 
3091          self.__field_num_msg_elements.readfrombuffer(buf) 
3092          self.__field_msglengths=LIST(**{'elementclass': _gen_p_lgvx8300_267, 'length': 10}) 
3093          self.__field_msglengths.readfrombuffer(buf) 
3094          self.__field_unknown9=UNKNOWN(**{'sizeinbytes': 10}) 
3095          self.__field_unknown9.readfrombuffer(buf) 
3096          self.__field_msgs=LIST(**{'length': 10, 'elementclass': SMSINBOXMSGFRAGMENT}) 
3097          self.__field_msgs.readfrombuffer(buf) 
3098          self.__field_unknown10=UNKNOWN() 
3099          self.__field_unknown10.readfrombuffer(buf) 
3100          self._bufferendoffset=buf.getcurrentoffset() 
3101   
3102   
3103 -    def __getfield_unknown1(self): 
3104          return self.__field_unknown1.getvalue() 
3105   
3106 -    def __setfield_unknown1(self, value): 
3107          if isinstance(value,UNKNOWN): 
3108              self.__field_unknown1=value 
3109          else: 
3110              self.__field_unknown1=UNKNOWN(value,**{'sizeinbytes': 7}) 
3111   
3112 -    def __delfield_unknown1(self): del self.__field_unknown1 
3113   
3114      unknown1=property(__getfield_unknown1, __setfield_unknown1, __delfield_unknown1, None) 
3115   
3116 -    def __getfield_lg_time(self): 
3117          return self.__field_lg_time.getvalue() 
3118   
3119 -    def __setfield_lg_time(self, value): 
3120          if isinstance(value,LGCALDATE): 
3121              self.__field_lg_time=value 
3122          else: 
3123              self.__field_lg_time=LGCALDATE(value,**{'sizeinbytes': 4}) 
3124   
3125 -    def __delfield_lg_time(self): del self.__field_lg_time 
3126   
3127      lg_time=property(__getfield_lg_time, __setfield_lg_time, __delfield_lg_time, None) 
3128   
3129 -    def __getfield_unknown2(self): 
3130          return self.__field_unknown2.getvalue() 
3131   
3132 -    def __setfield_unknown2(self, value): 
3133          if isinstance(value,UINT): 
3134              self.__field_unknown2=value 
3135          else: 
3136              self.__field_unknown2=UINT(value,**{'sizeinbytes': 1}) 
3137   
3138 -    def __delfield_unknown2(self): del self.__field_unknown2 
3139   
3140      unknown2=property(__getfield_unknown2, __setfield_unknown2, __delfield_unknown2, None) 
3141   
3142 -    def __getfield_GPStime(self): 
3143          return self.__field_GPStime.getvalue() 
3144   
3145 -    def __setfield_GPStime(self, value): 
3146          if isinstance(value,GPSDATE): 
3147              self.__field_GPStime=value 
3148          else: 
3149              self.__field_GPStime=GPSDATE(value,**{'sizeinbytes': 4}) 
3150   
3151 -    def __delfield_GPStime(self): del self.__field_GPStime 
3152   
3153      GPStime=property(__getfield_GPStime, __setfield_GPStime, __delfield_GPStime, None) 
3154   
3155 -    def __getfield_timesent(self): 
3156          return self.__field_timesent.getvalue() 
3157   
3158 -    def __setfield_timesent(self, value): 
3159          if isinstance(value,SMSDATE): 
3160              self.__field_timesent=value 
3161          else: 
3162              self.__field_timesent=SMSDATE(value,**{'sizeinbytes': 6}) 
3163   
3164 -    def __delfield_timesent(self): del self.__field_timesent 
3165   
3166      timesent=property(__getfield_timesent, __setfield_timesent, __delfield_timesent, None) 
3167   
3168 -    def __getfield_callback_length(self): 
3169          return self.__field_callback_length.getvalue() 
3170   
3171 -    def __setfield_callback_length(self, value): 
3172          if isinstance(value,UINT): 
3173              self.__field_callback_length=value 
3174          else: 
3175              self.__field_callback_length=UINT(value,**{'sizeinbytes': 1}) 
3176   
3177 -    def __delfield_callback_length(self): del self.__field_callback_length 
3178   
3179      callback_length=property(__getfield_callback_length, __setfield_callback_length, __delfield_callback_length, None) 
3180   
3181 -    def __getfield_callback(self): 
3182          return self.__field_callback.getvalue() 
3183   
3184 -    def __setfield_callback(self, value): 
3185          if isinstance(value,USTRING): 
3186              self.__field_callback=value 
3187          else: 
3188              self.__field_callback=USTRING(value,**{'sizeinbytes': 39}) 
3189   
3190 -    def __delfield_callback(self): del self.__field_callback 
3191   
3192      callback=property(__getfield_callback, __setfield_callback, __delfield_callback, None) 
3193   
3194 -    def __getfield_sender_length(self): 
3195          return self.__field_sender_length.getvalue() 
3196   
3197 -    def __setfield_sender_length(self, value): 
3198          if isinstance(value,UINT): 
3199              self.__field_sender_length=value 
3200          else: 
3201              self.__field_sender_length=UINT(value,**{'sizeinbytes': 1}) 
3202   
3203 -    def __delfield_sender_length(self): del self.__field_sender_length 
3204   
3205      sender_length=property(__getfield_sender_length, __setfield_sender_length, __delfield_sender_length, None) 
3206   
3207 -    def __getfield_sender(self): 
3208          try: self.__field_sender 
3209          except: 
3210              self.__field_sender=LIST(**{'elementclass': _gen_p_lgvx8300_252, 'length': 38}) 
3211          return self.__field_sender.getvalue() 
3212   
3213 -    def __setfield_sender(self, value): 
3214          if isinstance(value,LIST): 
3215              self.__field_sender=value 
3216          else: 
3217              self.__field_sender=LIST(value,**{'elementclass': _gen_p_lgvx8300_252, 'length': 38}) 
3218   
3219 -    def __delfield_sender(self): del self.__field_sender 
3220   
3221      sender=property(__getfield_sender, __setfield_sender, __delfield_sender, None) 
3222   
3223 -    def __getfield_unknown3(self): 
3224          return self.__field_unknown3.getvalue() 
3225   
3226 -    def __setfield_unknown3(self, value): 
3227          if isinstance(value,DATA): 
3228              self.__field_unknown3=value 
3229          else: 
3230              self.__field_unknown3=DATA(value,**{'sizeinbytes': 12}) 
3231   
3232 -    def __delfield_unknown3(self): del self.__field_unknown3 
3233   
3234      unknown3=property(__getfield_unknown3, __setfield_unknown3, __delfield_unknown3, None) 
3235   
3236 -    def __getfield_unknown4(self): 
3237          return self.__field_unknown4.getvalue() 
3238   
3239 -    def __setfield_unknown4(self, value): 
3240          if isinstance(value,UNKNOWN): 
3241              self.__field_unknown4=value 
3242          else: 
3243              self.__field_unknown4=UNKNOWN(value,**{'sizeinbytes': 6}) 
3244   
3245 -    def __delfield_unknown4(self): del self.__field_unknown4 
3246   
3247      unknown4=property(__getfield_unknown4, __setfield_unknown4, __delfield_unknown4, None) 
3248   
3249 -    def __getfield_read(self): 
3250          return self.__field_read.getvalue() 
3251   
3252 -    def __setfield_read(self, value): 
3253          if isinstance(value,UINT): 
3254              self.__field_read=value 
3255          else: 
3256              self.__field_read=UINT(value,**{'sizeinbytes': 1}) 
3257   
3258 -    def __delfield_read(self): del self.__field_read 
3259   
3260      read=property(__getfield_read, __setfield_read, __delfield_read, None) 
3261   
3262 -    def __getfield_locked(self): 
3263          return self.__field_locked.getvalue() 
3264   
3265 -    def __setfield_locked(self, value): 
3266          if isinstance(value,UINT): 
3267              self.__field_locked=value 
3268          else: 
3269              self.__field_locked=UINT(value,**{'sizeinbytes': 1}) 
3270   
3271 -    def __delfield_locked(self): del self.__field_locked 
3272   
3273      locked=property(__getfield_locked, __setfield_locked, __delfield_locked, None) 
3274   
3275 -    def __getfield_priority(self): 
3276          return self.__field_priority.getvalue() 
3277   
3278 -    def __setfield_priority(self, value): 
3279          if isinstance(value,UINT): 
3280              self.__field_priority=value 
3281          else: 
3282              self.__field_priority=UINT(value,**{'sizeinbytes': 1}) 
3283   
3284 -    def __delfield_priority(self): del self.__field_priority 
3285   
3286      priority=property(__getfield_priority, __setfield_priority, __delfield_priority, None) 
3287   
3288 -    def __getfield_subject(self): 
3289          return self.__field_subject.getvalue() 
3290   
3291 -    def __setfield_subject(self, value): 
3292          if isinstance(value,USTRING): 
3293              self.__field_subject=value 
3294          else: 
3295              self.__field_subject=USTRING(value,**{'sizeinbytes': 24, 'encoding': PHONE_ENCODING}) 
3296   
3297 -    def __delfield_subject(self): del self.__field_subject 
3298   
3299      subject=property(__getfield_subject, __setfield_subject, __delfield_subject, None) 
3300   
3301 -    def __getfield_bin_header1(self): 
3302          return self.__field_bin_header1.getvalue() 
3303   
3304 -    def __setfield_bin_header1(self, value): 
3305          if isinstance(value,UINT): 
3306              self.__field_bin_header1=value 
3307          else: 
3308              self.__field_bin_header1=UINT(value,**{'sizeinbytes': 1}) 
3309   
3310 -    def __delfield_bin_header1(self): del self.__field_bin_header1 
3311   
3312      bin_header1=property(__getfield_bin_header1, __setfield_bin_header1, __delfield_bin_header1, None) 
3313   
3314 -    def __getfield_bin_header2(self): 
3315          return self.__field_bin_header2.getvalue() 
3316   
3317 -    def __setfield_bin_header2(self, value): 
3318          if isinstance(value,UINT): 
3319              self.__field_bin_header2=value 
3320          else: 
3321              self.__field_bin_header2=UINT(value,**{'sizeinbytes': 1}) 
3322   
3323 -    def __delfield_bin_header2(self): del self.__field_bin_header2 
3324   
3325      bin_header2=property(__getfield_bin_header2, __setfield_bin_header2, __delfield_bin_header2, None) 
3326   
3327 -    def __getfield_unknown7(self): 
3328          return self.__field_unknown7.getvalue() 
3329   
3330 -    def __setfield_unknown7(self, value): 
3331          if isinstance(value,UINT): 
3332              self.__field_unknown7=value 
3333          else: 
3334              self.__field_unknown7=UINT(value,**{'sizeinbytes': 1}) 
3335   
3336 -    def __delfield_unknown7(self): del self.__field_unknown7 
3337   
3338      unknown7=property(__getfield_unknown7, __setfield_unknown7, __delfield_unknown7, None) 
3339   
3340 -    def __getfield_multipartID(self): 
3341          return self.__field_multipartID.getvalue() 
3342   
3343 -    def __setfield_multipartID(self, value): 
3344          if isinstance(value,UINT): 
3345              self.__field_multipartID=value 
3346          else: 
3347              self.__field_multipartID=UINT(value,**{'sizeinbytes': 2}) 
3348   
3349 -    def __delfield_multipartID(self): del self.__field_multipartID 
3350   
3351      multipartID=property(__getfield_multipartID, __setfield_multipartID, __delfield_multipartID, None) 
3352   
3353 -    def __getfield_bin_header3(self): 
3354          return self.__field_bin_header3.getvalue() 
3355   
3356 -    def __setfield_bin_header3(self, value): 
3357          if isinstance(value,UINT): 
3358              self.__field_bin_header3=value 
3359          else: 
3360              self.__field_bin_header3=UINT(value,**{'sizeinbytes': 1}) 
3361   
3362 -    def __delfield_bin_header3(self): del self.__field_bin_header3 
3363   
3364      bin_header3=property(__getfield_bin_header3, __setfield_bin_header3, __delfield_bin_header3, None) 
3365   
3366 -    def __getfield_unknown8(self): 
3367          return self.__field_unknown8.getvalue() 
3368   
3369 -    def __setfield_unknown8(self, value): 
3370          if isinstance(value,UINT): 
3371              self.__field_unknown8=value 
3372          else: 
3373              self.__field_unknown8=UINT(value,**{'sizeinbytes': 5}) 
3374   
3375 -    def __delfield_unknown8(self): del self.__field_unknown8 
3376   
3377      unknown8=property(__getfield_unknown8, __setfield_unknown8, __delfield_unknown8, None) 
3378   
3379 -    def __getfield_num_msg_elements(self): 
3380          return self.__field_num_msg_elements.getvalue() 
3381   
3382 -    def __setfield_num_msg_elements(self, value): 
3383          if isinstance(value,UINT): 
3384              self.__field_num_msg_elements=value 
3385          else: 
3386              self.__field_num_msg_elements=UINT(value,**{'sizeinbytes': 1}) 
3387   
3388 -    def __delfield_num_msg_elements(self): del self.__field_num_msg_elements 
3389   
3390      num_msg_elements=property(__getfield_num_msg_elements, __setfield_num_msg_elements, __delfield_num_msg_elements, None) 
3391   
3392 -    def __getfield_msglengths(self): 
3393          try: self.__field_msglengths 
3394          except: 
3395              self.__field_msglengths=LIST(**{'elementclass': _gen_p_lgvx8300_267, 'length': 10}) 
3396          return self.__field_msglengths.getvalue() 
3397   
3398 -    def __setfield_msglengths(self, value): 
3399          if isinstance(value,LIST): 
3400              self.__field_msglengths=value 
3401          else: 
3402              self.__field_msglengths=LIST(value,**{'elementclass': _gen_p_lgvx8300_267, 'length': 10}) 
3403   
3404 -    def __delfield_msglengths(self): del self.__field_msglengths 
3405   
3406      msglengths=property(__getfield_msglengths, __setfield_msglengths, __delfield_msglengths, None) 
3407   
3408 -    def __getfield_unknown9(self): 
3409          return self.__field_unknown9.getvalue() 
3410   
3411 -    def __setfield_unknown9(self, value): 
3412          if isinstance(value,UNKNOWN): 
3413              self.__field_unknown9=value 
3414          else: 
3415              self.__field_unknown9=UNKNOWN(value,**{'sizeinbytes': 10}) 
3416   
3417 -    def __delfield_unknown9(self): del self.__field_unknown9 
3418   
3419      unknown9=property(__getfield_unknown9, __setfield_unknown9, __delfield_unknown9, None) 
3420   
3421 -    def __getfield_msgs(self): 
3422          try: self.__field_msgs 
3423          except: 
3424              self.__field_msgs=LIST(**{'length': 10, 'elementclass': SMSINBOXMSGFRAGMENT}) 
3425          return self.__field_msgs.getvalue() 
3426   
3427 -    def __setfield_msgs(self, value): 
3428          if isinstance(value,LIST): 
3429              self.__field_msgs=value 
3430          else: 
3431              self.__field_msgs=LIST(value,**{'length': 10, 'elementclass': SMSINBOXMSGFRAGMENT}) 
3432   
3433 -    def __delfield_msgs(self): del self.__field_msgs 
3434   
3435      msgs=property(__getfield_msgs, __setfield_msgs, __delfield_msgs, None) 
3436   
3437 -    def __getfield_unknown10(self): 
3438          return self.__field_unknown10.getvalue() 
3439   
3440 -    def __setfield_unknown10(self, value): 
3441          if isinstance(value,UNKNOWN): 
3442              self.__field_unknown10=value 
3443          else: 
3444              self.__field_unknown10=UNKNOWN(value,) 
3445   
3446 -    def __delfield_unknown10(self): del self.__field_unknown10 
3447   
3448      unknown10=property(__getfield_unknown10, __setfield_unknown10, __delfield_unknown10, None) 
3449   
3450 -    def iscontainer(self): 
3451          return True 
3452   
3453 -    def containerelements(self): 
3454          yield ('unknown1', self.__field_unknown1, None) 
3455          yield ('lg_time', self.__field_lg_time, None) 
3456          yield ('unknown2', self.__field_unknown2, None) 
3457          yield ('GPStime', self.__field_GPStime, None) 
3458          yield ('timesent', self.__field_timesent, None) 
3459          yield ('callback_length', self.__field_callback_length, None) 
3460          yield ('callback', self.__field_callback, None) 
3461          yield ('sender_length', self.__field_sender_length, None) 
3462          yield ('sender', self.__field_sender, None) 
3463          yield ('unknown3', self.__field_unknown3, None) 
3464          yield ('unknown4', self.__field_unknown4, None) 
3465          yield ('read', self.__field_read, None) 
3466          yield ('locked', self.__field_locked, None) 
3467          yield ('priority', self.__field_priority, None) 
3468          yield ('subject', self.__field_subject, None) 
3469          yield ('bin_header1', self.__field_bin_header1, None) 
3470          yield ('bin_header2', self.__field_bin_header2, None) 
3471          yield ('unknown7', self.__field_unknown7, None) 
3472          yield ('multipartID', self.__field_multipartID, None) 
3473          yield ('bin_header3', self.__field_bin_header3, None) 
3474          yield ('unknown8', self.__field_unknown8, None) 
3475          yield ('num_msg_elements', self.__field_num_msg_elements, None) 
3476          yield ('msglengths', self.__field_msglengths, None) 
3477          yield ('unknown9', self.__field_unknown9, None) 
3478          yield ('msgs', self.__field_msgs, None) 
3479          yield ('unknown10', self.__field_unknown10, None) 
3480   
3481   
3482   
3483   
3484 -class _gen_p_lgvx8300_252(BaseProtogenClass): 
3485      'Anonymous inner class' 
3486      __fields=['byte'] 
3487   
3488 -    def __init__(self, *args, **kwargs): 
3489          dict={} 
3490          # What was supplied to this function 
3491          dict.update(kwargs) 
3492          # Parent constructor 
3493          super(_gen_p_lgvx8300_252,self).__init__(**dict) 
3494          if self.__class__ is _gen_p_lgvx8300_252: 
3495              self._update(args,dict) 
3496   
3497   
3498 -    def getfields(self): 
3499          return self.__fields 
3500   
3501   
3502 -    def _update(self, args, kwargs): 
3503          super(_gen_p_lgvx8300_252,self)._update(args,kwargs) 
3504          keys=kwargs.keys() 
3505          for key in keys: 
3506              if key in self.__fields: 
3507                  setattr(self, key, kwargs[key]) 
3508                  del kwargs[key] 
3509          # Were any unrecognized kwargs passed in? 
3510          if __debug__: 
3511              self._complainaboutunusedargs(_gen_p_lgvx8300_252,kwargs) 
3512          if len(args): 
3513              dict2={'sizeinbytes': 1} 
3514              dict2.update(kwargs) 
3515              kwargs=dict2 
3516              self.__field_byte=UINT(*args,**dict2) 
3517          # Make all P fields that haven't already been constructed 
3518   
3519   
3520 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
3521          'Writes this packet to the supplied buffer' 
3522          self._bufferstartoffset=buf.getcurrentoffset() 
3523          self.__field_byte.writetobuffer(buf) 
3524          self._bufferendoffset=buf.getcurrentoffset() 
3525          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
3526   
3527   
3528 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
3529          'Reads this packet from the supplied buffer' 
3530          self._bufferstartoffset=buf.getcurrentoffset() 
3531          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
3532          self.__field_byte=UINT(**{'sizeinbytes': 1}) 
3533          self.__field_byte.readfrombuffer(buf) 
3534          self._bufferendoffset=buf.getcurrentoffset() 
3535   
3536   
3537 -    def __getfield_byte(self): 
3538          return self.__field_byte.getvalue() 
3539   
3540 -    def __setfield_byte(self, value): 
3541          if isinstance(value,UINT): 
3542              self.__field_byte=value 
3543          else: 
3544              self.__field_byte=UINT(value,**{'sizeinbytes': 1}) 
3545   
3546 -    def __delfield_byte(self): del self.__field_byte 
3547   
3548      byte=property(__getfield_byte, __setfield_byte, __delfield_byte, "individual byte of senders phone number") 
3549   
3550 -    def iscontainer(self): 
3551          return True 
3552   
3553 -    def containerelements(self): 
3554          yield ('byte', self.__field_byte, "individual byte of senders phone number") 
3555   
3556   
3557   
3558   
3559 -class _gen_p_lgvx8300_267(BaseProtogenClass): 
3560      'Anonymous inner class' 
3561      __fields=['msglength'] 
3562   
3563 -    def __init__(self, *args, **kwargs): 
3564          dict={} 
3565          # What was supplied to this function 
3566          dict.update(kwargs) 
3567          # Parent constructor 
3568          super(_gen_p_lgvx8300_267,self).__init__(**dict) 
3569          if self.__class__ is _gen_p_lgvx8300_267: 
3570              self._update(args,dict) 
3571   
3572   
3573 -    def getfields(self): 
3574          return self.__fields 
3575   
3576   
3577 -    def _update(self, args, kwargs): 
3578          super(_gen_p_lgvx8300_267,self)._update(args,kwargs) 
3579          keys=kwargs.keys() 
3580          for key in keys: 
3581              if key in self.__fields: 
3582                  setattr(self, key, kwargs[key]) 
3583                  del kwargs[key] 
3584          # Were any unrecognized kwargs passed in? 
3585          if __debug__: 
3586              self._complainaboutunusedargs(_gen_p_lgvx8300_267,kwargs) 
3587          if len(args): 
3588              dict2={'sizeinbytes': 1} 
3589              dict2.update(kwargs) 
3590              kwargs=dict2 
3591              self.__field_msglength=UINT(*args,**dict2) 
3592          # Make all P fields that haven't already been constructed 
3593   
3594   
3595 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
3596          'Writes this packet to the supplied buffer' 
3597          self._bufferstartoffset=buf.getcurrentoffset() 
3598          self.__field_msglength.writetobuffer(buf) 
3599          self._bufferendoffset=buf.getcurrentoffset() 
3600          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
3601   
3602   
3603 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
3604          'Reads this packet from the supplied buffer' 
3605          self._bufferstartoffset=buf.getcurrentoffset() 
3606          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
3607          self.__field_msglength=UINT(**{'sizeinbytes': 1}) 
3608          self.__field_msglength.readfrombuffer(buf) 
3609          self._bufferendoffset=buf.getcurrentoffset() 
3610   
3611   
3612 -    def __getfield_msglength(self): 
3613          return self.__field_msglength.getvalue() 
3614   
3615 -    def __setfield_msglength(self, value): 
3616          if isinstance(value,UINT): 
3617              self.__field_msglength=value 
3618          else: 
3619              self.__field_msglength=UINT(value,**{'sizeinbytes': 1}) 
3620   
3621 -    def __delfield_msglength(self): del self.__field_msglength 
3622   
3623      msglength=property(__getfield_msglength, __setfield_msglength, __delfield_msglength, "lengths of individual messages in septets") 
3624   
3625 -    def iscontainer(self): 
3626          return True 
3627   
3628 -    def containerelements(self): 
3629          yield ('msglength', self.__field_msglength, "lengths of individual messages in septets") 
3630   
3631   
3632   
3633   
3634 -class sms_quick_text(BaseProtogenClass): 
3635      __fields=['msgs'] 
3636   
3637 -    def __init__(self, *args, **kwargs): 
3638          dict={} 
3639          # What was supplied to this function 
3640          dict.update(kwargs) 
3641          # Parent constructor 
3642          super(sms_quick_text,self).__init__(**dict) 
3643          if self.__class__ is sms_quick_text: 
3644              self._update(args,dict) 
3645   
3646   
3647 -    def getfields(self): 
3648          return self.__fields 
3649   
3650   
3651 -    def _update(self, args, kwargs): 
3652          super(sms_quick_text,self)._update(args,kwargs) 
3653          keys=kwargs.keys() 
3654          for key in keys: 
3655              if key in self.__fields: 
3656                  setattr(self, key, kwargs[key]) 
3657                  del kwargs[key] 
3658          # Were any unrecognized kwargs passed in? 
3659          if __debug__: 
3660              self._complainaboutunusedargs(sms_quick_text,kwargs) 
3661          if len(args): 
3662              dict2={'elementclass': _gen_p_lgvx8300_280,  'length': SMS_CANNED_MAX_ITEMS, 'createdefault': True} 
3663              dict2.update(kwargs) 
3664              kwargs=dict2 
3665              self.__field_msgs=LIST(*args,**dict2) 
3666          # Make all P fields that haven't already been constructed 
3667   
3668   
3669 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
3670          'Writes this packet to the supplied buffer' 
3671          self._bufferstartoffset=buf.getcurrentoffset() 
3672          try: self.__field_msgs 
3673          except: 
3674              self.__field_msgs=LIST(**{'elementclass': _gen_p_lgvx8300_280,  'length': SMS_CANNED_MAX_ITEMS, 'createdefault': True}) 
3675          self.__field_msgs.writetobuffer(buf) 
3676          self._bufferendoffset=buf.getcurrentoffset() 
3677          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
3678   
3679   
3680 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
3681          'Reads this packet from the supplied buffer' 
3682          self._bufferstartoffset=buf.getcurrentoffset() 
3683          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
3684          self.__field_msgs=LIST(**{'elementclass': _gen_p_lgvx8300_280,  'length': SMS_CANNED_MAX_ITEMS, 'createdefault': True}) 
3685          self.__field_msgs.readfrombuffer(buf) 
3686          self._bufferendoffset=buf.getcurrentoffset() 
3687   
3688   
3689 -    def __getfield_msgs(self): 
3690          try: self.__field_msgs 
3691          except: 
3692              self.__field_msgs=LIST(**{'elementclass': _gen_p_lgvx8300_280,  'length': SMS_CANNED_MAX_ITEMS, 'createdefault': True}) 
3693          return self.__field_msgs.getvalue() 
3694   
3695 -    def __setfield_msgs(self, value): 
3696          if isinstance(value,LIST): 
3697              self.__field_msgs=value 
3698          else: 
3699              self.__field_msgs=LIST(value,**{'elementclass': _gen_p_lgvx8300_280,  'length': SMS_CANNED_MAX_ITEMS, 'createdefault': True}) 
3700   
3701 -    def __delfield_msgs(self): del self.__field_msgs 
3702   
3703      msgs=property(__getfield_msgs, __setfield_msgs, __delfield_msgs, None) 
3704   
3705 -    def iscontainer(self): 
3706          return True 
3707   
3708 -    def containerelements(self): 
3709          yield ('msgs', self.__field_msgs, None) 
3710   
3711   
3712   
3713   
3714 -class _gen_p_lgvx8300_280(BaseProtogenClass): 
3715      'Anonymous inner class' 
3716      __fields=['msg'] 
3717   
3718 -    def __init__(self, *args, **kwargs): 
3719          dict={} 
3720          # What was supplied to this function 
3721          dict.update(kwargs) 
3722          # Parent constructor 
3723          super(_gen_p_lgvx8300_280,self).__init__(**dict) 
3724          if self.__class__ is _gen_p_lgvx8300_280: 
3725              self._update(args,dict) 
3726   
3727   
3728 -    def getfields(self): 
3729          return self.__fields 
3730   
3731   
3732 -    def _update(self, args, kwargs): 
3733          super(_gen_p_lgvx8300_280,self)._update(args,kwargs) 
3734          keys=kwargs.keys() 
3735          for key in keys: 
3736              if key in self.__fields: 
3737                  setattr(self, key, kwargs[key]) 
3738                  del kwargs[key] 
3739          # Were any unrecognized kwargs passed in? 
3740          if __debug__: 
3741              self._complainaboutunusedargs(_gen_p_lgvx8300_280,kwargs) 
3742          if len(args): 
3743              dict2={'sizeinbytes': 101, 'encoding': PHONE_ENCODING, 'default': ""} 
3744              dict2.update(kwargs) 
3745              kwargs=dict2 
3746              self.__field_msg=USTRING(*args,**dict2) 
3747          # Make all P fields that haven't already been constructed 
3748   
3749   
3750 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
3751          'Writes this packet to the supplied buffer' 
3752          self._bufferstartoffset=buf.getcurrentoffset() 
3753          try: self.__field_msg 
3754          except: 
3755              self.__field_msg=USTRING(**{'sizeinbytes': 101, 'encoding': PHONE_ENCODING, 'default': ""}) 
3756          self.__field_msg.writetobuffer(buf) 
3757          self._bufferendoffset=buf.getcurrentoffset() 
3758          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
3759   
3760   
3761 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
3762          'Reads this packet from the supplied buffer' 
3763          self._bufferstartoffset=buf.getcurrentoffset() 
3764          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
3765          self.__field_msg=USTRING(**{'sizeinbytes': 101, 'encoding': PHONE_ENCODING, 'default': ""}) 
3766          self.__field_msg.readfrombuffer(buf) 
3767          self._bufferendoffset=buf.getcurrentoffset() 
3768   
3769   
3770 -    def __getfield_msg(self): 
3771          try: self.__field_msg 
3772          except: 
3773              self.__field_msg=USTRING(**{'sizeinbytes': 101, 'encoding': PHONE_ENCODING, 'default': ""}) 
3774          return self.__field_msg.getvalue() 
3775   
3776 -    def __setfield_msg(self, value): 
3777          if isinstance(value,USTRING): 
3778              self.__field_msg=value 
3779          else: 
3780              self.__field_msg=USTRING(value,**{'sizeinbytes': 101, 'encoding': PHONE_ENCODING, 'default': ""}) 
3781   
3782 -    def __delfield_msg(self): del self.__field_msg 
3783   
3784      msg=property(__getfield_msg, __setfield_msg, __delfield_msg, None) 
3785   
3786 -    def iscontainer(self): 
3787          return True 
3788   
3789 -    def containerelements(self): 
3790          yield ('msg', self.__field_msg, None) 
3791   
3792   
3793   
3794   
3795 -class textmemo(BaseProtogenClass): 
3796      __fields=['text', 'dunno', 'memotime'] 
3797   
3798 -    def __init__(self, *args, **kwargs): 
3799          dict={} 
3800          # What was supplied to this function 
3801          dict.update(kwargs) 
3802          # Parent constructor 
3803          super(textmemo,self).__init__(**dict) 
3804          if self.__class__ is textmemo: 
3805              self._update(args,dict) 
3806   
3807   
3808 -    def getfields(self): 
3809          return self.__fields 
3810   
3811   
3812 -    def _update(self, args, kwargs): 
3813          super(textmemo,self)._update(args,kwargs) 
3814          keys=kwargs.keys() 
3815          for key in keys: 
3816              if key in self.__fields: 
3817                  setattr(self, key, kwargs[key]) 
3818                  del kwargs[key] 
3819          # Were any unrecognized kwargs passed in? 
3820          if __debug__: 
3821              self._complainaboutunusedargs(textmemo,kwargs) 
3822          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
3823          # Make all P fields that haven't already been constructed 
3824   
3825   
3826 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
3827          'Writes this packet to the supplied buffer' 
3828          self._bufferstartoffset=buf.getcurrentoffset() 
3829          self.__field_text.writetobuffer(buf) 
3830          try: self.__field_dunno 
3831          except: 
3832              self.__field_dunno=UINT(**{'sizeinbytes': 4, 'default' : 0x1000000}) 
3833          self.__field_dunno.writetobuffer(buf) 
3834          self.__field_memotime.writetobuffer(buf) 
3835          self._bufferendoffset=buf.getcurrentoffset() 
3836          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
3837   
3838   
3839 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
3840          'Reads this packet from the supplied buffer' 
3841          self._bufferstartoffset=buf.getcurrentoffset() 
3842          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
3843          self.__field_text=USTRING(**{'sizeinbytes': 152, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False, 'raiseontruncate': False }) 
3844          self.__field_text.readfrombuffer(buf) 
3845          self.__field_dunno=UINT(**{'sizeinbytes': 4, 'default' : 0x1000000}) 
3846          self.__field_dunno.readfrombuffer(buf) 
3847          self.__field_memotime=LGCALDATE(**{'sizeinbytes': 4}) 
3848          self.__field_memotime.readfrombuffer(buf) 
3849          self._bufferendoffset=buf.getcurrentoffset() 
3850   
3851   
3852 -    def __getfield_text(self): 
3853          return self.__field_text.getvalue() 
3854   
3855 -    def __setfield_text(self, value): 
3856          if isinstance(value,USTRING): 
3857              self.__field_text=value 
3858          else: 
3859              self.__field_text=USTRING(value,**{'sizeinbytes': 152, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False, 'raiseontruncate': False }) 
3860   
3861 -    def __delfield_text(self): del self.__field_text 
3862   
3863      text=property(__getfield_text, __setfield_text, __delfield_text, None) 
3864   
3865 -    def __getfield_dunno(self): 
3866          try: self.__field_dunno 
3867          except: 
3868              self.__field_dunno=UINT(**{'sizeinbytes': 4, 'default' : 0x1000000}) 
3869          return self.__field_dunno.getvalue() 
3870   
3871 -    def __setfield_dunno(self, value): 
3872          if isinstance(value,UINT): 
3873              self.__field_dunno=value 
3874          else: 
3875              self.__field_dunno=UINT(value,**{'sizeinbytes': 4, 'default' : 0x1000000}) 
3876   
3877 -    def __delfield_dunno(self): del self.__field_dunno 
3878   
3879      dunno=property(__getfield_dunno, __setfield_dunno, __delfield_dunno, None) 
3880   
3881 -    def __getfield_memotime(self): 
3882          return self.__field_memotime.getvalue() 
3883   
3884 -    def __setfield_memotime(self, value): 
3885          if isinstance(value,LGCALDATE): 
3886              self.__field_memotime=value 
3887          else: 
3888              self.__field_memotime=LGCALDATE(value,**{'sizeinbytes': 4}) 
3889   
3890 -    def __delfield_memotime(self): del self.__field_memotime 
3891   
3892      memotime=property(__getfield_memotime, __setfield_memotime, __delfield_memotime, None) 
3893   
3894 -    def iscontainer(self): 
3895          return True 
3896   
3897 -    def containerelements(self): 
3898          yield ('text', self.__field_text, None) 
3899          yield ('dunno', self.__field_dunno, None) 
3900          yield ('memotime', self.__field_memotime, None) 
3901   
3902   
3903   
3904   
3905 -class textmemofile(BaseProtogenClass): 
3906      __fields=['itemcount', 'items'] 
3907   
3908 -    def __init__(self, *args, **kwargs): 
3909          dict={} 
3910          # What was supplied to this function 
3911          dict.update(kwargs) 
3912          # Parent constructor 
3913          super(textmemofile,self).__init__(**dict) 
3914          if self.__class__ is textmemofile: 
3915              self._update(args,dict) 
3916   
3917   
3918 -    def getfields(self): 
3919          return self.__fields 
3920   
3921   
3922 -    def _update(self, args, kwargs): 
3923          super(textmemofile,self)._update(args,kwargs) 
3924          keys=kwargs.keys() 
3925          for key in keys: 
3926              if key in self.__fields: 
3927                  setattr(self, key, kwargs[key]) 
3928                  del kwargs[key] 
3929          # Were any unrecognized kwargs passed in? 
3930          if __debug__: 
3931              self._complainaboutunusedargs(textmemofile,kwargs) 
3932          if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 
3933          # Make all P fields that haven't already been constructed 
3934   
3935   
3936 -    def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 
3937          'Writes this packet to the supplied buffer' 
3938          self._bufferstartoffset=buf.getcurrentoffset() 
3939          self.__field_itemcount.writetobuffer(buf) 
3940          try: self.__field_items 
3941          except: 
3942              self.__field_items=LIST(**{ 'elementclass': textmemo }) 
3943          self.__field_items.writetobuffer(buf) 
3944          self._bufferendoffset=buf.getcurrentoffset() 
3945          if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 
3946   
3947   
3948 -    def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 
3949          'Reads this packet from the supplied buffer' 
3950          self._bufferstartoffset=buf.getcurrentoffset() 
3951          if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 
3952          self.__field_itemcount=UINT(**{'sizeinbytes': 4}) 
3953          self.__field_itemcount.readfrombuffer(buf) 
3954          self.__field_items=LIST(**{ 'elementclass': textmemo }) 
3955          self.__field_items.readfrombuffer(buf) 
3956          self._bufferendoffset=buf.getcurrentoffset() 
3957   
3958   
3959 -    def __getfield_itemcount(self): 
3960          return self.__field_itemcount.getvalue() 
3961   
3962 -    def __setfield_itemcount(self, value): 
3963          if isinstance(value,UINT): 
3964              self.__field_itemcount=value 
3965          else: 
3966              self.__field_itemcount=UINT(value,**{'sizeinbytes': 4}) 
3967   
3968 -    def __delfield_itemcount(self): del self.__field_itemcount 
3969   
3970      itemcount=property(__getfield_itemcount, __setfield_itemcount, __delfield_itemcount, None) 
3971   
3972 -    def __getfield_items(self): 
3973          try: self.__field_items 
3974          except: 
3975              self.__field_items=LIST(**{ 'elementclass': textmemo }) 
3976          return self.__field_items.getvalue() 
3977   
3978 -    def __setfield_items(self, value): 
3979          if isinstance(value,LIST): 
3980              self.__field_items=value 
3981          else: 
3982              self.__field_items=LIST(value,**{ 'elementclass': textmemo }) 
3983   
3984 -    def __delfield_items(self): del self.__field_items 
3985   
3986      items=property(__getfield_items, __setfield_items, __delfield_items, None) 
3987   
3988 -    def iscontainer(self): 
3989          return True 
3990   
3991 -    def containerelements(self): 
3992          yield ('itemcount', self.__field_itemcount, None) 
3993          yield ('items', self.__field_items, None) 
3994