PyXR

c:\projects\bitpim\src \ phones \ p_lgvi5225.py



0001 # THIS FILE IS AUTOMATICALLY GENERATED.  EDIT THE SOURCE FILE NOT THIS ONE
0002 
0003 """Various descriptions of data specific to LG VI5225"""
0004 
0005 from prototypes import *
0006 from prototypeslg import *
0007 
0008 # Make all lg stuff available in this module as well
0009 from p_lg import *
0010 
0011 # we are the same as lgvx4400 except as noted
0012 # below
0013 from p_lgvx4400 import *
0014 
0015 # We use LSB for all integer like fields
0016 UINT=UINTlsb
0017 BOOL=BOOLlsb
0018 
0019 NUMSPEEDDIALS=100
0020 FIRSTSPEEDDIAL=2
0021 LASTSPEEDDIAL=99
0022 NUMPHONEBOOKENTRIES=500
0023 MAXCALENDARDESCRIPTION=38
0024 
0025 NUMEMAILS=1
0026 NUMPHONENUMBERS=5
0027 MEMOLENGTH=48
0028 
0029 pb_file_name='pim/pbentry.dat'
0030 
0031 # Calendar parameters
0032 NUMCALENDARENTRIES=300
0033 CAL_REP_NONE=0x10
0034 CAL_REP_DAILY=0x11
0035 CAL_REP_MONFRI=0x12
0036 CAL_REP_WEEKLY=0x13
0037 CAL_REP_MONTHLY=0x14
0038 CAL_REP_YEARLY=0x15
0039 CAL_DOW_SUN=0x0800
0040 CAL_DOW_MON=0x0400
0041 CAL_DOW_TUE=0x0200
0042 CAL_DOW_WED=0x0100
0043 CAL_DOW_THU=0x0080
0044 CAL_DOW_FRI=0x0040
0045 CAL_DOW_SAT=0x0020
0046 CAL_DOW_EXCEPTIONS=0x0010
0047 CAL_REMINDER_NONE=0
0048 CAL_REMINDER_ONTIME=1
0049 CAL_REMINDER_5MIN=2
0050 CAL_REMINDER_10MIN=3
0051 CAL_REMINDER_1HOUR=4
0052 CAL_REMINDER_1DAY=5
0053 CAL_REMINDER_2DAYS=6
0054 CAL_REPEAT_DATE=(2100, 12, 31)
0055 
0056 cal_dir='sch'
0057 cal_data_file_name='sch/schedule.dat'
0058 cal_exception_file_name='sch/schexception.dat'
0059 cal_has_voice_id=False
0060 
0061 class ffpacket(BaseProtogenClass):
0062     __fields=['header', 'command', 'dunno1', 'dunno2', 'pad', 'dunno3', 'dunno4']
0063 
0064     def __init__(self, *args, **kwargs):
0065         dict={}
0066         # What was supplied to this function
0067         dict.update(kwargs)
0068         # Parent constructor
0069         super(ffpacket,self).__init__(**dict)
0070         if self.__class__ is ffpacket:
0071             self._update(args,dict)
0072 
0073 
0074     def getfields(self):
0075         return self.__fields
0076 
0077 
0078     def _update(self, args, kwargs):
0079         super(ffpacket,self)._update(args,kwargs)
0080         keys=kwargs.keys()
0081         for key in keys:
0082             if key in self.__fields:
0083                 setattr(self, key, kwargs[key])
0084                 del kwargs[key]
0085         # Were any unrecognized kwargs passed in?
0086         if __debug__:
0087             self._complainaboutunusedargs(ffpacket,kwargs)
0088         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0089         # Make all P fields that haven't already been constructed
0090 
0091 
0092     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0093         'Writes this packet to the supplied buffer'
0094         self._bufferstartoffset=buf.getcurrentoffset()
0095         try: self.__field_header
0096         except:
0097             self.__field_header=UINT(**{'sizeinbytes': 1, 'constant': 0xff})
0098         self.__field_header.writetobuffer(buf)
0099         self.__field_command.writetobuffer(buf)
0100         self.__field_dunno1.writetobuffer(buf)
0101         self.__field_dunno2.writetobuffer(buf)
0102         self.__field_pad.writetobuffer(buf)
0103         self.__field_dunno3.writetobuffer(buf)
0104         self.__field_dunno4.writetobuffer(buf)
0105         self._bufferendoffset=buf.getcurrentoffset()
0106         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0107 
0108 
0109     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0110         'Reads this packet from the supplied buffer'
0111         self._bufferstartoffset=buf.getcurrentoffset()
0112         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0113         self.__field_header=UINT(**{'sizeinbytes': 1, 'constant': 0xff})
0114         self.__field_header.readfrombuffer(buf)
0115         self.__field_command=UINT(**{'sizeinbytes': 1})
0116         self.__field_command.readfrombuffer(buf)
0117         self.__field_dunno1=UINT(**{'sizeinbytes': 1})
0118         self.__field_dunno1.readfrombuffer(buf)
0119         self.__field_dunno2=UINT(**{'sizeinbytes': 1})
0120         self.__field_dunno2.readfrombuffer(buf)
0121         self.__field_pad=UKNOWN(**{'sizeinbytes': 4})
0122         self.__field_pad.readfrombuffer(buf)
0123         self.__field_dunno3=UINT(**{'sizeinbytes': 1})
0124         self.__field_dunno3.readfrombuffer(buf)
0125         self.__field_dunno4=UINT(**{'sizeinbytes': 1})
0126         self.__field_dunno4.readfrombuffer(buf)
0127         self._bufferendoffset=buf.getcurrentoffset()
0128 
0129 
0130     def __getfield_header(self):
0131         try: self.__field_header
0132         except:
0133             self.__field_header=UINT(**{'sizeinbytes': 1, 'constant': 0xff})
0134         return self.__field_header.getvalue()
0135 
0136     def __setfield_header(self, value):
0137         if isinstance(value,UINT):
0138             self.__field_header=value
0139         else:
0140             self.__field_header=UINT(value,**{'sizeinbytes': 1, 'constant': 0xff})
0141 
0142     def __delfield_header(self): del self.__field_header
0143 
0144     header=property(__getfield_header, __setfield_header, __delfield_header, None)
0145 
0146     def __getfield_command(self):
0147         return self.__field_command.getvalue()
0148 
0149     def __setfield_command(self, value):
0150         if isinstance(value,UINT):
0151             self.__field_command=value
0152         else:
0153             self.__field_command=UINT(value,**{'sizeinbytes': 1})
0154 
0155     def __delfield_command(self): del self.__field_command
0156 
0157     command=property(__getfield_command, __setfield_command, __delfield_command, None)
0158 
0159     def __getfield_dunno1(self):
0160         return self.__field_dunno1.getvalue()
0161 
0162     def __setfield_dunno1(self, value):
0163         if isinstance(value,UINT):
0164             self.__field_dunno1=value
0165         else:
0166             self.__field_dunno1=UINT(value,**{'sizeinbytes': 1})
0167 
0168     def __delfield_dunno1(self): del self.__field_dunno1
0169 
0170     dunno1=property(__getfield_dunno1, __setfield_dunno1, __delfield_dunno1, None)
0171 
0172     def __getfield_dunno2(self):
0173         return self.__field_dunno2.getvalue()
0174 
0175     def __setfield_dunno2(self, value):
0176         if isinstance(value,UINT):
0177             self.__field_dunno2=value
0178         else:
0179             self.__field_dunno2=UINT(value,**{'sizeinbytes': 1})
0180 
0181     def __delfield_dunno2(self): del self.__field_dunno2
0182 
0183     dunno2=property(__getfield_dunno2, __setfield_dunno2, __delfield_dunno2, None)
0184 
0185     def __getfield_pad(self):
0186         return self.__field_pad.getvalue()
0187 
0188     def __setfield_pad(self, value):
0189         if isinstance(value,UKNOWN):
0190             self.__field_pad=value
0191         else:
0192             self.__field_pad=UKNOWN(value,**{'sizeinbytes': 4})
0193 
0194     def __delfield_pad(self): del self.__field_pad
0195 
0196     pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None)
0197 
0198     def __getfield_dunno3(self):
0199         return self.__field_dunno3.getvalue()
0200 
0201     def __setfield_dunno3(self, value):
0202         if isinstance(value,UINT):
0203             self.__field_dunno3=value
0204         else:
0205             self.__field_dunno3=UINT(value,**{'sizeinbytes': 1})
0206 
0207     def __delfield_dunno3(self): del self.__field_dunno3
0208 
0209     dunno3=property(__getfield_dunno3, __setfield_dunno3, __delfield_dunno3, None)
0210 
0211     def __getfield_dunno4(self):
0212         return self.__field_dunno4.getvalue()
0213 
0214     def __setfield_dunno4(self, value):
0215         if isinstance(value,UINT):
0216             self.__field_dunno4=value
0217         else:
0218             self.__field_dunno4=UINT(value,**{'sizeinbytes': 1})
0219 
0220     def __delfield_dunno4(self): del self.__field_dunno4
0221 
0222     dunno4=property(__getfield_dunno4, __setfield_dunno4, __delfield_dunno4, None)
0223 
0224     def iscontainer(self):
0225         return True
0226 
0227     def containerelements(self):
0228         yield ('header', self.__field_header, None)
0229         yield ('command', self.__field_command, None)
0230         yield ('dunno1', self.__field_dunno1, None)
0231         yield ('dunno2', self.__field_dunno2, None)
0232         yield ('pad', self.__field_pad, None)
0233         yield ('dunno3', self.__field_dunno3, None)
0234         yield ('dunno4', self.__field_dunno4, None)
0235 
0236 
0237 
0238 
0239 class speeddial(BaseProtogenClass):
0240     __fields=['entry', 'number']
0241 
0242     def __init__(self, *args, **kwargs):
0243         dict={}
0244         # What was supplied to this function
0245         dict.update(kwargs)
0246         # Parent constructor
0247         super(speeddial,self).__init__(**dict)
0248         if self.__class__ is speeddial:
0249             self._update(args,dict)
0250 
0251 
0252     def getfields(self):
0253         return self.__fields
0254 
0255 
0256     def _update(self, args, kwargs):
0257         super(speeddial,self)._update(args,kwargs)
0258         keys=kwargs.keys()
0259         for key in keys:
0260             if key in self.__fields:
0261                 setattr(self, key, kwargs[key])
0262                 del kwargs[key]
0263         # Were any unrecognized kwargs passed in?
0264         if __debug__:
0265             self._complainaboutunusedargs(speeddial,kwargs)
0266         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0267         # Make all P fields that haven't already been constructed
0268 
0269 
0270     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0271         'Writes this packet to the supplied buffer'
0272         self._bufferstartoffset=buf.getcurrentoffset()
0273         try: self.__field_entry
0274         except:
0275             self.__field_entry=UINT(**{'sizeinbytes': 1, 'default': 0xff})
0276         self.__field_entry.writetobuffer(buf)
0277         try: self.__field_number
0278         except:
0279             self.__field_number=UINT(**{'sizeinbytes': 1, 'default': 0xff})
0280         self.__field_number.writetobuffer(buf)
0281         self._bufferendoffset=buf.getcurrentoffset()
0282         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0283 
0284 
0285     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0286         'Reads this packet from the supplied buffer'
0287         self._bufferstartoffset=buf.getcurrentoffset()
0288         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0289         self.__field_entry=UINT(**{'sizeinbytes': 1, 'default': 0xff})
0290         self.__field_entry.readfrombuffer(buf)
0291         self.__field_number=UINT(**{'sizeinbytes': 1, 'default': 0xff})
0292         self.__field_number.readfrombuffer(buf)
0293         self._bufferendoffset=buf.getcurrentoffset()
0294 
0295 
0296     def __getfield_entry(self):
0297         try: self.__field_entry
0298         except:
0299             self.__field_entry=UINT(**{'sizeinbytes': 1, 'default': 0xff})
0300         return self.__field_entry.getvalue()
0301 
0302     def __setfield_entry(self, value):
0303         if isinstance(value,UINT):
0304             self.__field_entry=value
0305         else:
0306             self.__field_entry=UINT(value,**{'sizeinbytes': 1, 'default': 0xff})
0307 
0308     def __delfield_entry(self): del self.__field_entry
0309 
0310     entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None)
0311 
0312     def __getfield_number(self):
0313         try: self.__field_number
0314         except:
0315             self.__field_number=UINT(**{'sizeinbytes': 1, 'default': 0xff})
0316         return self.__field_number.getvalue()
0317 
0318     def __setfield_number(self, value):
0319         if isinstance(value,UINT):
0320             self.__field_number=value
0321         else:
0322             self.__field_number=UINT(value,**{'sizeinbytes': 1, 'default': 0xff})
0323 
0324     def __delfield_number(self): del self.__field_number
0325 
0326     number=property(__getfield_number, __setfield_number, __delfield_number, None)
0327 
0328     def iscontainer(self):
0329         return True
0330 
0331     def containerelements(self):
0332         yield ('entry', self.__field_entry, None)
0333         yield ('number', self.__field_number, None)
0334 
0335 
0336 
0337 
0338 class speeddials(BaseProtogenClass):
0339     __fields=['speeddials']
0340 
0341     def __init__(self, *args, **kwargs):
0342         dict={}
0343         # What was supplied to this function
0344         dict.update(kwargs)
0345         # Parent constructor
0346         super(speeddials,self).__init__(**dict)
0347         if self.__class__ is speeddials:
0348             self._update(args,dict)
0349 
0350 
0351     def getfields(self):
0352         return self.__fields
0353 
0354 
0355     def _update(self, args, kwargs):
0356         super(speeddials,self)._update(args,kwargs)
0357         keys=kwargs.keys()
0358         for key in keys:
0359             if key in self.__fields:
0360                 setattr(self, key, kwargs[key])
0361                 del kwargs[key]
0362         # Were any unrecognized kwargs passed in?
0363         if __debug__:
0364             self._complainaboutunusedargs(speeddials,kwargs)
0365         if len(args):
0366             dict2={'length': NUMSPEEDDIALS, 'elementclass': speeddial}
0367             dict2.update(kwargs)
0368             kwargs=dict2
0369             self.__field_speeddials=LIST(*args,**dict2)
0370         # Make all P fields that haven't already been constructed
0371 
0372 
0373     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0374         'Writes this packet to the supplied buffer'
0375         self._bufferstartoffset=buf.getcurrentoffset()
0376         try: self.__field_speeddials
0377         except:
0378             self.__field_speeddials=LIST(**{'length': NUMSPEEDDIALS, 'elementclass': speeddial})
0379         self.__field_speeddials.writetobuffer(buf)
0380         self._bufferendoffset=buf.getcurrentoffset()
0381         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0382 
0383 
0384     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0385         'Reads this packet from the supplied buffer'
0386         self._bufferstartoffset=buf.getcurrentoffset()
0387         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0388         self.__field_speeddials=LIST(**{'length': NUMSPEEDDIALS, 'elementclass': speeddial})
0389         self.__field_speeddials.readfrombuffer(buf)
0390         self._bufferendoffset=buf.getcurrentoffset()
0391 
0392 
0393     def __getfield_speeddials(self):
0394         try: self.__field_speeddials
0395         except:
0396             self.__field_speeddials=LIST(**{'length': NUMSPEEDDIALS, 'elementclass': speeddial})
0397         return self.__field_speeddials.getvalue()
0398 
0399     def __setfield_speeddials(self, value):
0400         if isinstance(value,LIST):
0401             self.__field_speeddials=value
0402         else:
0403             self.__field_speeddials=LIST(value,**{'length': NUMSPEEDDIALS, 'elementclass': speeddial})
0404 
0405     def __delfield_speeddials(self): del self.__field_speeddials
0406 
0407     speeddials=property(__getfield_speeddials, __setfield_speeddials, __delfield_speeddials, None)
0408 
0409     def iscontainer(self):
0410         return True
0411 
0412     def containerelements(self):
0413         yield ('speeddials', self.__field_speeddials, None)
0414 
0415 
0416 
0417 
0418 class pbreadentryresponse(BaseProtogenClass):
0419     "Results of reading one entry"
0420     __fields=['header', 'entry']
0421 
0422     def __init__(self, *args, **kwargs):
0423         dict={}
0424         # What was supplied to this function
0425         dict.update(kwargs)
0426         # Parent constructor
0427         super(pbreadentryresponse,self).__init__(**dict)
0428         if self.__class__ is pbreadentryresponse:
0429             self._update(args,dict)
0430 
0431 
0432     def getfields(self):
0433         return self.__fields
0434 
0435 
0436     def _update(self, args, kwargs):
0437         super(pbreadentryresponse,self)._update(args,kwargs)
0438         keys=kwargs.keys()
0439         for key in keys:
0440             if key in self.__fields:
0441                 setattr(self, key, kwargs[key])
0442                 del kwargs[key]
0443         # Were any unrecognized kwargs passed in?
0444         if __debug__:
0445             self._complainaboutunusedargs(pbreadentryresponse,kwargs)
0446         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0447         # Make all P fields that haven't already been constructed
0448 
0449 
0450     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0451         'Writes this packet to the supplied buffer'
0452         self._bufferstartoffset=buf.getcurrentoffset()
0453         self.__field_header.writetobuffer(buf)
0454         self.__field_entry.writetobuffer(buf)
0455         self._bufferendoffset=buf.getcurrentoffset()
0456         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0457 
0458 
0459     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0460         'Reads this packet from the supplied buffer'
0461         self._bufferstartoffset=buf.getcurrentoffset()
0462         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0463         self.__field_header=pbheader()
0464         self.__field_header.readfrombuffer(buf)
0465         self.__field_entry=pbentry()
0466         self.__field_entry.readfrombuffer(buf)
0467         self._bufferendoffset=buf.getcurrentoffset()
0468 
0469 
0470     def __getfield_header(self):
0471         return self.__field_header.getvalue()
0472 
0473     def __setfield_header(self, value):
0474         if isinstance(value,pbheader):
0475             self.__field_header=value
0476         else:
0477             self.__field_header=pbheader(value,)
0478 
0479     def __delfield_header(self): del self.__field_header
0480 
0481     header=property(__getfield_header, __setfield_header, __delfield_header, None)
0482 
0483     def __getfield_entry(self):
0484         return self.__field_entry.getvalue()
0485 
0486     def __setfield_entry(self, value):
0487         if isinstance(value,pbentry):
0488             self.__field_entry=value
0489         else:
0490             self.__field_entry=pbentry(value,)
0491 
0492     def __delfield_entry(self): del self.__field_entry
0493 
0494     entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None)
0495 
0496     def iscontainer(self):
0497         return True
0498 
0499     def containerelements(self):
0500         yield ('header', self.__field_header, None)
0501         yield ('entry', self.__field_entry, None)
0502 
0503 
0504 
0505 
0506 class pbupdateentryrequest(BaseProtogenClass):
0507     __fields=['header', 'entry']
0508 
0509     def __init__(self, *args, **kwargs):
0510         dict={}
0511         # What was supplied to this function
0512         dict.update(kwargs)
0513         # Parent constructor
0514         super(pbupdateentryrequest,self).__init__(**dict)
0515         if self.__class__ is pbupdateentryrequest:
0516             self._update(args,dict)
0517 
0518 
0519     def getfields(self):
0520         return self.__fields
0521 
0522 
0523     def _update(self, args, kwargs):
0524         super(pbupdateentryrequest,self)._update(args,kwargs)
0525         keys=kwargs.keys()
0526         for key in keys:
0527             if key in self.__fields:
0528                 setattr(self, key, kwargs[key])
0529                 del kwargs[key]
0530         # Were any unrecognized kwargs passed in?
0531         if __debug__:
0532             self._complainaboutunusedargs(pbupdateentryrequest,kwargs)
0533         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0534         # Make all P fields that haven't already been constructed
0535 
0536 
0537     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0538         'Writes this packet to the supplied buffer'
0539         self._bufferstartoffset=buf.getcurrentoffset()
0540         try: self.__field_header
0541         except:
0542             self.__field_header=pbheader(**{'command': 0x04, 'flag': 0x01})
0543         self.__field_header.writetobuffer(buf)
0544         self.__field_entry.writetobuffer(buf)
0545         self._bufferendoffset=buf.getcurrentoffset()
0546         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0547 
0548 
0549     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0550         'Reads this packet from the supplied buffer'
0551         self._bufferstartoffset=buf.getcurrentoffset()
0552         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0553         self.__field_header=pbheader(**{'command': 0x04, 'flag': 0x01})
0554         self.__field_header.readfrombuffer(buf)
0555         self.__field_entry=pbentry()
0556         self.__field_entry.readfrombuffer(buf)
0557         self._bufferendoffset=buf.getcurrentoffset()
0558 
0559 
0560     def __getfield_header(self):
0561         try: self.__field_header
0562         except:
0563             self.__field_header=pbheader(**{'command': 0x04, 'flag': 0x01})
0564         return self.__field_header.getvalue()
0565 
0566     def __setfield_header(self, value):
0567         if isinstance(value,pbheader):
0568             self.__field_header=value
0569         else:
0570             self.__field_header=pbheader(value,**{'command': 0x04, 'flag': 0x01})
0571 
0572     def __delfield_header(self): del self.__field_header
0573 
0574     header=property(__getfield_header, __setfield_header, __delfield_header, None)
0575 
0576     def __getfield_entry(self):
0577         return self.__field_entry.getvalue()
0578 
0579     def __setfield_entry(self, value):
0580         if isinstance(value,pbentry):
0581             self.__field_entry=value
0582         else:
0583             self.__field_entry=pbentry(value,)
0584 
0585     def __delfield_entry(self): del self.__field_entry
0586 
0587     entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None)
0588 
0589     def iscontainer(self):
0590         return True
0591 
0592     def containerelements(self):
0593         yield ('header', self.__field_header, None)
0594         yield ('entry', self.__field_entry, None)
0595 
0596 
0597 
0598 
0599 class pbappendentryrequest(BaseProtogenClass):
0600     __fields=['header', 'entry']
0601 
0602     def __init__(self, *args, **kwargs):
0603         dict={}
0604         # What was supplied to this function
0605         dict.update(kwargs)
0606         # Parent constructor
0607         super(pbappendentryrequest,self).__init__(**dict)
0608         if self.__class__ is pbappendentryrequest:
0609             self._update(args,dict)
0610 
0611 
0612     def getfields(self):
0613         return self.__fields
0614 
0615 
0616     def _update(self, args, kwargs):
0617         super(pbappendentryrequest,self)._update(args,kwargs)
0618         keys=kwargs.keys()
0619         for key in keys:
0620             if key in self.__fields:
0621                 setattr(self, key, kwargs[key])
0622                 del kwargs[key]
0623         # Were any unrecognized kwargs passed in?
0624         if __debug__:
0625             self._complainaboutunusedargs(pbappendentryrequest,kwargs)
0626         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0627         # Make all P fields that haven't already been constructed
0628 
0629 
0630     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0631         'Writes this packet to the supplied buffer'
0632         self._bufferstartoffset=buf.getcurrentoffset()
0633         try: self.__field_header
0634         except:
0635             self.__field_header=pbheader(**{'command': 0x03, 'flag': 0x01})
0636         self.__field_header.writetobuffer(buf)
0637         self.__field_entry.writetobuffer(buf)
0638         self._bufferendoffset=buf.getcurrentoffset()
0639         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0640 
0641 
0642     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0643         'Reads this packet from the supplied buffer'
0644         self._bufferstartoffset=buf.getcurrentoffset()
0645         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0646         self.__field_header=pbheader(**{'command': 0x03, 'flag': 0x01})
0647         self.__field_header.readfrombuffer(buf)
0648         self.__field_entry=pbentry()
0649         self.__field_entry.readfrombuffer(buf)
0650         self._bufferendoffset=buf.getcurrentoffset()
0651 
0652 
0653     def __getfield_header(self):
0654         try: self.__field_header
0655         except:
0656             self.__field_header=pbheader(**{'command': 0x03, 'flag': 0x01})
0657         return self.__field_header.getvalue()
0658 
0659     def __setfield_header(self, value):
0660         if isinstance(value,pbheader):
0661             self.__field_header=value
0662         else:
0663             self.__field_header=pbheader(value,**{'command': 0x03, 'flag': 0x01})
0664 
0665     def __delfield_header(self): del self.__field_header
0666 
0667     header=property(__getfield_header, __setfield_header, __delfield_header, None)
0668 
0669     def __getfield_entry(self):
0670         return self.__field_entry.getvalue()
0671 
0672     def __setfield_entry(self, value):
0673         if isinstance(value,pbentry):
0674             self.__field_entry=value
0675         else:
0676             self.__field_entry=pbentry(value,)
0677 
0678     def __delfield_entry(self): del self.__field_entry
0679 
0680     entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None)
0681 
0682     def iscontainer(self):
0683         return True
0684 
0685     def containerelements(self):
0686         yield ('header', self.__field_header, None)
0687         yield ('entry', self.__field_entry, None)
0688 
0689 
0690 
0691 
0692 class pbentry(BaseProtogenClass):
0693     __fields=['wallpaper', 'serial1', 'entrysize', 'serial2', 'entrynumber', 'name', 'group', 'emails', 'url', 'ringtone', 'secret', 'memo', 'dunno1', 'dunno2', 'numbertypes', 'numbers']
0694 
0695     def __init__(self, *args, **kwargs):
0696         dict={}
0697         # What was supplied to this function
0698         dict.update(kwargs)
0699         # Parent constructor
0700         super(pbentry,self).__init__(**dict)
0701         if self.__class__ is pbentry:
0702             self._update(args,dict)
0703 
0704 
0705     def getfields(self):
0706         return self.__fields
0707 
0708 
0709     def _update(self, args, kwargs):
0710         super(pbentry,self)._update(args,kwargs)
0711         keys=kwargs.keys()
0712         for key in keys:
0713             if key in self.__fields:
0714                 setattr(self, key, kwargs[key])
0715                 del kwargs[key]
0716         # Were any unrecognized kwargs passed in?
0717         if __debug__:
0718             self._complainaboutunusedargs(pbentry,kwargs)
0719         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0720         # Make all P fields that haven't already been constructed
0721         try: self.__field_wallpaper
0722         except:
0723             self.__field_wallpaper=UINT(**{'constant': NOWALLPAPER})
0724 
0725 
0726     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0727         'Writes this packet to the supplied buffer'
0728         self._bufferstartoffset=buf.getcurrentoffset()
0729         self.__field_serial1.writetobuffer(buf)
0730         try: self.__field_entrysize
0731         except:
0732             self.__field_entrysize=UINT(**{'sizeinbytes': 2, 'constant': 0x01E0})
0733         self.__field_entrysize.writetobuffer(buf)
0734         self.__field_serial2.writetobuffer(buf)
0735         self.__field_entrynumber.writetobuffer(buf)
0736         self.__field_name.writetobuffer(buf)
0737         self.__field_group.writetobuffer(buf)
0738         try: self.__field_emails
0739         except:
0740             self.__field_emails=LIST(**{'elementclass': _gen_p_lgvi5225_116, 'length': NUMEMAILS})
0741         self.__field_emails.writetobuffer(buf)
0742         self.__field_url.writetobuffer(buf)
0743         self.__field_ringtone.writetobuffer(buf)
0744         self.__field_secret.writetobuffer(buf)
0745         self.__field_memo.writetobuffer(buf)
0746         try: self.__field_dunno1
0747         except:
0748             self.__field_dunno1=UINT(**{'sizeinbytes': 1, 'default': 0})
0749         self.__field_dunno1.writetobuffer(buf)
0750         try: self.__field_dunno2
0751         except:
0752             self.__field_dunno2=UINT(**{'sizeinbytes': 2, 'default': 0})
0753         self.__field_dunno2.writetobuffer(buf)
0754         try: self.__field_numbertypes
0755         except:
0756             self.__field_numbertypes=LIST(**{'elementclass': _gen_p_lgvi5225_124, 'length': NUMPHONENUMBERS})
0757         self.__field_numbertypes.writetobuffer(buf)
0758         try: self.__field_numbers
0759         except:
0760             self.__field_numbers=LIST(**{'elementclass': _gen_p_lgvi5225_126, 'length': NUMPHONENUMBERS})
0761         self.__field_numbers.writetobuffer(buf)
0762         self._bufferendoffset=buf.getcurrentoffset()
0763         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0764 
0765 
0766     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0767         'Reads this packet from the supplied buffer'
0768         self._bufferstartoffset=buf.getcurrentoffset()
0769         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0770         self.__field_serial1=UINT(**{'sizeinbytes': 4})
0771         self.__field_serial1.readfrombuffer(buf)
0772         self.__field_entrysize=UINT(**{'sizeinbytes': 2, 'constant': 0x01E0})
0773         self.__field_entrysize.readfrombuffer(buf)
0774         self.__field_serial2=UINT(**{'sizeinbytes': 4})
0775         self.__field_serial2.readfrombuffer(buf)
0776         self.__field_entrynumber=UINT(**{'sizeinbytes': 2})
0777         self.__field_entrynumber.readfrombuffer(buf)
0778         self.__field_name=USTRING(**{'sizeinbytes': 23, 'raiseonunterminatedread': False})
0779         self.__field_name.readfrombuffer(buf)
0780         self.__field_group=UINT(**{'sizeinbytes': 2})
0781         self.__field_group.readfrombuffer(buf)
0782         self.__field_emails=LIST(**{'elementclass': _gen_p_lgvi5225_116, 'length': NUMEMAILS})
0783         self.__field_emails.readfrombuffer(buf)
0784         self.__field_url=USTRING(**{'sizeinbytes': 73, 'raiseonunterminatedread': False})
0785         self.__field_url.readfrombuffer(buf)
0786         self.__field_ringtone=UINT(**{'sizeinbytes': 1})
0787         self.__field_ringtone.readfrombuffer(buf)
0788         self.__field_secret=UINT(**{'sizeinbytes': 1})
0789         self.__field_secret.readfrombuffer(buf)
0790         self.__field_memo=USTRING(**{'raiseonunterminatedread': False, 'sizeinbytes': MEMOLENGTH})
0791         self.__field_memo.readfrombuffer(buf)
0792         self.__field_dunno1=UINT(**{'sizeinbytes': 1, 'default': 0})
0793         self.__field_dunno1.readfrombuffer(buf)
0794         self.__field_dunno2=UINT(**{'sizeinbytes': 2, 'default': 0})
0795         self.__field_dunno2.readfrombuffer(buf)
0796         self.__field_numbertypes=LIST(**{'elementclass': _gen_p_lgvi5225_124, 'length': NUMPHONENUMBERS})
0797         self.__field_numbertypes.readfrombuffer(buf)
0798         self.__field_numbers=LIST(**{'elementclass': _gen_p_lgvi5225_126, 'length': NUMPHONENUMBERS})
0799         self.__field_numbers.readfrombuffer(buf)
0800         self._bufferendoffset=buf.getcurrentoffset()
0801 
0802 
0803     def __getfield_wallpaper(self):
0804         return self.__field_wallpaper.getvalue()
0805 
0806     def __setfield_wallpaper(self, value):
0807         if isinstance(value,UINT):
0808             self.__field_wallpaper=value
0809         else:
0810             self.__field_wallpaper=UINT(value,**{'constant': NOWALLPAPER})
0811 
0812     def __delfield_wallpaper(self): del self.__field_wallpaper
0813 
0814     wallpaper=property(__getfield_wallpaper, __setfield_wallpaper, __delfield_wallpaper, None)
0815 
0816     def __getfield_serial1(self):
0817         return self.__field_serial1.getvalue()
0818 
0819     def __setfield_serial1(self, value):
0820         if isinstance(value,UINT):
0821             self.__field_serial1=value
0822         else:
0823             self.__field_serial1=UINT(value,**{'sizeinbytes': 4})
0824 
0825     def __delfield_serial1(self): del self.__field_serial1
0826 
0827     serial1=property(__getfield_serial1, __setfield_serial1, __delfield_serial1, None)
0828 
0829     def __getfield_entrysize(self):
0830         try: self.__field_entrysize
0831         except:
0832             self.__field_entrysize=UINT(**{'sizeinbytes': 2, 'constant': 0x01E0})
0833         return self.__field_entrysize.getvalue()
0834 
0835     def __setfield_entrysize(self, value):
0836         if isinstance(value,UINT):
0837             self.__field_entrysize=value
0838         else:
0839             self.__field_entrysize=UINT(value,**{'sizeinbytes': 2, 'constant': 0x01E0})
0840 
0841     def __delfield_entrysize(self): del self.__field_entrysize
0842 
0843     entrysize=property(__getfield_entrysize, __setfield_entrysize, __delfield_entrysize, None)
0844 
0845     def __getfield_serial2(self):
0846         return self.__field_serial2.getvalue()
0847 
0848     def __setfield_serial2(self, value):
0849         if isinstance(value,UINT):
0850             self.__field_serial2=value
0851         else:
0852             self.__field_serial2=UINT(value,**{'sizeinbytes': 4})
0853 
0854     def __delfield_serial2(self): del self.__field_serial2
0855 
0856     serial2=property(__getfield_serial2, __setfield_serial2, __delfield_serial2, None)
0857 
0858     def __getfield_entrynumber(self):
0859         return self.__field_entrynumber.getvalue()
0860 
0861     def __setfield_entrynumber(self, value):
0862         if isinstance(value,UINT):
0863             self.__field_entrynumber=value
0864         else:
0865             self.__field_entrynumber=UINT(value,**{'sizeinbytes': 2})
0866 
0867     def __delfield_entrynumber(self): del self.__field_entrynumber
0868 
0869     entrynumber=property(__getfield_entrynumber, __setfield_entrynumber, __delfield_entrynumber, None)
0870 
0871     def __getfield_name(self):
0872         return self.__field_name.getvalue()
0873 
0874     def __setfield_name(self, value):
0875         if isinstance(value,USTRING):
0876             self.__field_name=value
0877         else:
0878             self.__field_name=USTRING(value,**{'sizeinbytes': 23, 'raiseonunterminatedread': False})
0879 
0880     def __delfield_name(self): del self.__field_name
0881 
0882     name=property(__getfield_name, __setfield_name, __delfield_name, None)
0883 
0884     def __getfield_group(self):
0885         return self.__field_group.getvalue()
0886 
0887     def __setfield_group(self, value):
0888         if isinstance(value,UINT):
0889             self.__field_group=value
0890         else:
0891             self.__field_group=UINT(value,**{'sizeinbytes': 2})
0892 
0893     def __delfield_group(self): del self.__field_group
0894 
0895     group=property(__getfield_group, __setfield_group, __delfield_group, None)
0896 
0897     def __getfield_emails(self):
0898         try: self.__field_emails
0899         except:
0900             self.__field_emails=LIST(**{'elementclass': _gen_p_lgvi5225_116, 'length': NUMEMAILS})
0901         return self.__field_emails.getvalue()
0902 
0903     def __setfield_emails(self, value):
0904         if isinstance(value,LIST):
0905             self.__field_emails=value
0906         else:
0907             self.__field_emails=LIST(value,**{'elementclass': _gen_p_lgvi5225_116, 'length': NUMEMAILS})
0908 
0909     def __delfield_emails(self): del self.__field_emails
0910 
0911     emails=property(__getfield_emails, __setfield_emails, __delfield_emails, None)
0912 
0913     def __getfield_url(self):
0914         return self.__field_url.getvalue()
0915 
0916     def __setfield_url(self, value):
0917         if isinstance(value,USTRING):
0918             self.__field_url=value
0919         else:
0920             self.__field_url=USTRING(value,**{'sizeinbytes': 73, 'raiseonunterminatedread': False})
0921 
0922     def __delfield_url(self): del self.__field_url
0923 
0924     url=property(__getfield_url, __setfield_url, __delfield_url, None)
0925 
0926     def __getfield_ringtone(self):
0927         return self.__field_ringtone.getvalue()
0928 
0929     def __setfield_ringtone(self, value):
0930         if isinstance(value,UINT):
0931             self.__field_ringtone=value
0932         else:
0933             self.__field_ringtone=UINT(value,**{'sizeinbytes': 1})
0934 
0935     def __delfield_ringtone(self): del self.__field_ringtone
0936 
0937     ringtone=property(__getfield_ringtone, __setfield_ringtone, __delfield_ringtone, "ringtone index for a call")
0938 
0939     def __getfield_secret(self):
0940         return self.__field_secret.getvalue()
0941 
0942     def __setfield_secret(self, value):
0943         if isinstance(value,UINT):
0944             self.__field_secret=value
0945         else:
0946             self.__field_secret=UINT(value,**{'sizeinbytes': 1})
0947 
0948     def __delfield_secret(self): del self.__field_secret
0949 
0950     secret=property(__getfield_secret, __setfield_secret, __delfield_secret, None)
0951 
0952     def __getfield_memo(self):
0953         return self.__field_memo.getvalue()
0954 
0955     def __setfield_memo(self, value):
0956         if isinstance(value,USTRING):
0957             self.__field_memo=value
0958         else:
0959             self.__field_memo=USTRING(value,**{'raiseonunterminatedread': False, 'sizeinbytes': MEMOLENGTH})
0960 
0961     def __delfield_memo(self): del self.__field_memo
0962 
0963     memo=property(__getfield_memo, __setfield_memo, __delfield_memo, None)
0964 
0965     def __getfield_dunno1(self):
0966         try: self.__field_dunno1
0967         except:
0968             self.__field_dunno1=UINT(**{'sizeinbytes': 1, 'default': 0})
0969         return self.__field_dunno1.getvalue()
0970 
0971     def __setfield_dunno1(self, value):
0972         if isinstance(value,UINT):
0973             self.__field_dunno1=value
0974         else:
0975             self.__field_dunno1=UINT(value,**{'sizeinbytes': 1, 'default': 0})
0976 
0977     def __delfield_dunno1(self): del self.__field_dunno1
0978 
0979     dunno1=property(__getfield_dunno1, __setfield_dunno1, __delfield_dunno1, None)
0980 
0981     def __getfield_dunno2(self):
0982         try: self.__field_dunno2
0983         except:
0984             self.__field_dunno2=UINT(**{'sizeinbytes': 2, 'default': 0})
0985         return self.__field_dunno2.getvalue()
0986 
0987     def __setfield_dunno2(self, value):
0988         if isinstance(value,UINT):
0989             self.__field_dunno2=value
0990         else:
0991             self.__field_dunno2=UINT(value,**{'sizeinbytes': 2, 'default': 0})
0992 
0993     def __delfield_dunno2(self): del self.__field_dunno2
0994 
0995     dunno2=property(__getfield_dunno2, __setfield_dunno2, __delfield_dunno2, None)
0996 
0997     def __getfield_numbertypes(self):
0998         try: self.__field_numbertypes
0999         except:
1000             self.__field_numbertypes=LIST(**{'elementclass': _gen_p_lgvi5225_124, 'length': NUMPHONENUMBERS})
1001         return self.__field_numbertypes.getvalue()
1002 
1003     def __setfield_numbertypes(self, value):
1004         if isinstance(value,LIST):
1005             self.__field_numbertypes=value
1006         else:
1007             self.__field_numbertypes=LIST(value,**{'elementclass': _gen_p_lgvi5225_124, 'length': NUMPHONENUMBERS})
1008 
1009     def __delfield_numbertypes(self): del self.__field_numbertypes
1010 
1011     numbertypes=property(__getfield_numbertypes, __setfield_numbertypes, __delfield_numbertypes, None)
1012 
1013     def __getfield_numbers(self):
1014         try: self.__field_numbers
1015         except:
1016             self.__field_numbers=LIST(**{'elementclass': _gen_p_lgvi5225_126, 'length': NUMPHONENUMBERS})
1017         return self.__field_numbers.getvalue()
1018 
1019     def __setfield_numbers(self, value):
1020         if isinstance(value,LIST):
1021             self.__field_numbers=value
1022         else:
1023             self.__field_numbers=LIST(value,**{'elementclass': _gen_p_lgvi5225_126, 'length': NUMPHONENUMBERS})
1024 
1025     def __delfield_numbers(self): del self.__field_numbers
1026 
1027     numbers=property(__getfield_numbers, __setfield_numbers, __delfield_numbers, None)
1028 
1029     def iscontainer(self):
1030         return True
1031 
1032     def containerelements(self):
1033         yield ('wallpaper', self.__field_wallpaper, None)
1034         yield ('serial1', self.__field_serial1, None)
1035         yield ('entrysize', self.__field_entrysize, None)
1036         yield ('serial2', self.__field_serial2, None)
1037         yield ('entrynumber', self.__field_entrynumber, None)
1038         yield ('name', self.__field_name, None)
1039         yield ('group', self.__field_group, None)
1040         yield ('emails', self.__field_emails, None)
1041         yield ('url', self.__field_url, None)
1042         yield ('ringtone', self.__field_ringtone, "ringtone index for a call")
1043         yield ('secret', self.__field_secret, None)
1044         yield ('memo', self.__field_memo, None)
1045         yield ('dunno1', self.__field_dunno1, None)
1046         yield ('dunno2', self.__field_dunno2, None)
1047         yield ('numbertypes', self.__field_numbertypes, None)
1048         yield ('numbers', self.__field_numbers, None)
1049 
1050 
1051 
1052 
1053 class _gen_p_lgvi5225_116(BaseProtogenClass):
1054     'Anonymous inner class'
1055     __fields=['email']
1056 
1057     def __init__(self, *args, **kwargs):
1058         dict={}
1059         # What was supplied to this function
1060         dict.update(kwargs)
1061         # Parent constructor
1062         super(_gen_p_lgvi5225_116,self).__init__(**dict)
1063         if self.__class__ is _gen_p_lgvi5225_116:
1064             self._update(args,dict)
1065 
1066 
1067     def getfields(self):
1068         return self.__fields
1069 
1070 
1071     def _update(self, args, kwargs):
1072         super(_gen_p_lgvi5225_116,self)._update(args,kwargs)
1073         keys=kwargs.keys()
1074         for key in keys:
1075             if key in self.__fields:
1076                 setattr(self, key, kwargs[key])
1077                 del kwargs[key]
1078         # Were any unrecognized kwargs passed in?
1079         if __debug__:
1080             self._complainaboutunusedargs(_gen_p_lgvi5225_116,kwargs)
1081         if len(args):
1082             dict2={'sizeinbytes': 73, 'raiseonunterminatedread': False}
1083             dict2.update(kwargs)
1084             kwargs=dict2
1085             self.__field_email=USTRING(*args,**dict2)
1086         # Make all P fields that haven't already been constructed
1087 
1088 
1089     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1090         'Writes this packet to the supplied buffer'
1091         self._bufferstartoffset=buf.getcurrentoffset()
1092         self.__field_email.writetobuffer(buf)
1093         self._bufferendoffset=buf.getcurrentoffset()
1094         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1095 
1096 
1097     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1098         'Reads this packet from the supplied buffer'
1099         self._bufferstartoffset=buf.getcurrentoffset()
1100         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1101         self.__field_email=USTRING(**{'sizeinbytes': 73, 'raiseonunterminatedread': False})
1102         self.__field_email.readfrombuffer(buf)
1103         self._bufferendoffset=buf.getcurrentoffset()
1104 
1105 
1106     def __getfield_email(self):
1107         return self.__field_email.getvalue()
1108 
1109     def __setfield_email(self, value):
1110         if isinstance(value,USTRING):
1111             self.__field_email=value
1112         else:
1113             self.__field_email=USTRING(value,**{'sizeinbytes': 73, 'raiseonunterminatedread': False})
1114 
1115     def __delfield_email(self): del self.__field_email
1116 
1117     email=property(__getfield_email, __setfield_email, __delfield_email, None)
1118 
1119     def iscontainer(self):
1120         return True
1121 
1122     def containerelements(self):
1123         yield ('email', self.__field_email, None)
1124 
1125 
1126 
1127 
1128 class _gen_p_lgvi5225_124(BaseProtogenClass):
1129     'Anonymous inner class'
1130     __fields=['numbertype']
1131 
1132     def __init__(self, *args, **kwargs):
1133         dict={}
1134         # What was supplied to this function
1135         dict.update(kwargs)
1136         # Parent constructor
1137         super(_gen_p_lgvi5225_124,self).__init__(**dict)
1138         if self.__class__ is _gen_p_lgvi5225_124:
1139             self._update(args,dict)
1140 
1141 
1142     def getfields(self):
1143         return self.__fields
1144 
1145 
1146     def _update(self, args, kwargs):
1147         super(_gen_p_lgvi5225_124,self)._update(args,kwargs)
1148         keys=kwargs.keys()
1149         for key in keys:
1150             if key in self.__fields:
1151                 setattr(self, key, kwargs[key])
1152                 del kwargs[key]
1153         # Were any unrecognized kwargs passed in?
1154         if __debug__:
1155             self._complainaboutunusedargs(_gen_p_lgvi5225_124,kwargs)
1156         if len(args):
1157             dict2={'sizeinbytes': 1}
1158             dict2.update(kwargs)
1159             kwargs=dict2
1160             self.__field_numbertype=UINT(*args,**dict2)
1161         # Make all P fields that haven't already been constructed
1162 
1163 
1164     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1165         'Writes this packet to the supplied buffer'
1166         self._bufferstartoffset=buf.getcurrentoffset()
1167         self.__field_numbertype.writetobuffer(buf)
1168         self._bufferendoffset=buf.getcurrentoffset()
1169         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1170 
1171 
1172     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1173         'Reads this packet from the supplied buffer'
1174         self._bufferstartoffset=buf.getcurrentoffset()
1175         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1176         self.__field_numbertype=UINT(**{'sizeinbytes': 1})
1177         self.__field_numbertype.readfrombuffer(buf)
1178         self._bufferendoffset=buf.getcurrentoffset()
1179 
1180 
1181     def __getfield_numbertype(self):
1182         return self.__field_numbertype.getvalue()
1183 
1184     def __setfield_numbertype(self, value):
1185         if isinstance(value,UINT):
1186             self.__field_numbertype=value
1187         else:
1188             self.__field_numbertype=UINT(value,**{'sizeinbytes': 1})
1189 
1190     def __delfield_numbertype(self): del self.__field_numbertype
1191 
1192     numbertype=property(__getfield_numbertype, __setfield_numbertype, __delfield_numbertype, None)
1193 
1194     def iscontainer(self):
1195         return True
1196 
1197     def containerelements(self):
1198         yield ('numbertype', self.__field_numbertype, None)
1199 
1200 
1201 
1202 
1203 class _gen_p_lgvi5225_126(BaseProtogenClass):
1204     'Anonymous inner class'
1205     __fields=['number']
1206 
1207     def __init__(self, *args, **kwargs):
1208         dict={}
1209         # What was supplied to this function
1210         dict.update(kwargs)
1211         # Parent constructor
1212         super(_gen_p_lgvi5225_126,self).__init__(**dict)
1213         if self.__class__ is _gen_p_lgvi5225_126:
1214             self._update(args,dict)
1215 
1216 
1217     def getfields(self):
1218         return self.__fields
1219 
1220 
1221     def _update(self, args, kwargs):
1222         super(_gen_p_lgvi5225_126,self)._update(args,kwargs)
1223         keys=kwargs.keys()
1224         for key in keys:
1225             if key in self.__fields:
1226                 setattr(self, key, kwargs[key])
1227                 del kwargs[key]
1228         # Were any unrecognized kwargs passed in?
1229         if __debug__:
1230             self._complainaboutunusedargs(_gen_p_lgvi5225_126,kwargs)
1231         if len(args):
1232             dict2={'sizeinbytes': 49, 'raiseonunterminatedread': False}
1233             dict2.update(kwargs)
1234             kwargs=dict2
1235             self.__field_number=USTRING(*args,**dict2)
1236         # Make all P fields that haven't already been constructed
1237 
1238 
1239     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1240         'Writes this packet to the supplied buffer'
1241         self._bufferstartoffset=buf.getcurrentoffset()
1242         self.__field_number.writetobuffer(buf)
1243         self._bufferendoffset=buf.getcurrentoffset()
1244         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1245 
1246 
1247     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1248         'Reads this packet from the supplied buffer'
1249         self._bufferstartoffset=buf.getcurrentoffset()
1250         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1251         self.__field_number=USTRING(**{'sizeinbytes': 49, 'raiseonunterminatedread': False})
1252         self.__field_number.readfrombuffer(buf)
1253         self._bufferendoffset=buf.getcurrentoffset()
1254 
1255 
1256     def __getfield_number(self):
1257         return self.__field_number.getvalue()
1258 
1259     def __setfield_number(self, value):
1260         if isinstance(value,USTRING):
1261             self.__field_number=value
1262         else:
1263             self.__field_number=USTRING(value,**{'sizeinbytes': 49, 'raiseonunterminatedread': False})
1264 
1265     def __delfield_number(self): del self.__field_number
1266 
1267     number=property(__getfield_number, __setfield_number, __delfield_number, None)
1268 
1269     def iscontainer(self):
1270         return True
1271 
1272     def containerelements(self):
1273         yield ('number', self.__field_number, None)
1274 
1275 
1276 
1277 
1278 

Generated by PyXR 0.9.4