Source Code for Module phones.p_lgvx8100

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