PyXR

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



0001 # THIS FILE IS AUTOMATICALLY GENERATED.  EDIT THE SOURCE FILE NOT THIS ONE
0002 
0003 """Various descriptions of data specific to LG TM520"""
0004 
0005 from prototypes import *
0006 
0007 # Make all lg stuff available in this module as well
0008 from p_lg import *
0009 
0010 # We use LSB for all integer like fields
0011 UINT=UINTlsb
0012 BOOL=BOOLlsb
0013 
0014 class pbreadentryresponse(BaseProtogenClass):
0015     "Results of reading one entry"
0016     __fields=['header', 'entry']
0017 
0018     def __init__(self, *args, **kwargs):
0019         dict={}
0020         # What was supplied to this function
0021         dict.update(kwargs)
0022         # Parent constructor
0023         super(pbreadentryresponse,self).__init__(**dict)
0024         if self.__class__ is pbreadentryresponse:
0025             self._update(args,dict)
0026 
0027 
0028     def getfields(self):
0029         return self.__fields
0030 
0031 
0032     def _update(self, args, kwargs):
0033         super(pbreadentryresponse,self)._update(args,kwargs)
0034         keys=kwargs.keys()
0035         for key in keys:
0036             if key in self.__fields:
0037                 setattr(self, key, kwargs[key])
0038                 del kwargs[key]
0039         # Were any unrecognized kwargs passed in?
0040         if __debug__:
0041             self._complainaboutunusedargs(pbreadentryresponse,kwargs)
0042         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0043         # Make all P fields that haven't already been constructed
0044 
0045 
0046     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0047         'Writes this packet to the supplied buffer'
0048         self._bufferstartoffset=buf.getcurrentoffset()
0049         self.__field_header.writetobuffer(buf)
0050         self.__field_entry.writetobuffer(buf)
0051         self._bufferendoffset=buf.getcurrentoffset()
0052         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0053 
0054 
0055     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0056         'Reads this packet from the supplied buffer'
0057         self._bufferstartoffset=buf.getcurrentoffset()
0058         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0059         self.__field_header=pbheader()
0060         self.__field_header.readfrombuffer(buf)
0061         self.__field_entry=pbentry()
0062         self.__field_entry.readfrombuffer(buf)
0063         self._bufferendoffset=buf.getcurrentoffset()
0064 
0065 
0066     def __getfield_header(self):
0067         return self.__field_header.getvalue()
0068 
0069     def __setfield_header(self, value):
0070         if isinstance(value,pbheader):
0071             self.__field_header=value
0072         else:
0073             self.__field_header=pbheader(value,)
0074 
0075     def __delfield_header(self): del self.__field_header
0076 
0077     header=property(__getfield_header, __setfield_header, __delfield_header, None)
0078 
0079     def __getfield_entry(self):
0080         return self.__field_entry.getvalue()
0081 
0082     def __setfield_entry(self, value):
0083         if isinstance(value,pbentry):
0084             self.__field_entry=value
0085         else:
0086             self.__field_entry=pbentry(value,)
0087 
0088     def __delfield_entry(self): del self.__field_entry
0089 
0090     entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None)
0091 
0092     def iscontainer(self):
0093         return True
0094 
0095     def containerelements(self):
0096         yield ('header', self.__field_header, None)
0097         yield ('entry', self.__field_entry, None)
0098 
0099 
0100 
0101 
0102 class pbupdateentryrequest(BaseProtogenClass):
0103     __fields=['header', 'entry']
0104 
0105     def __init__(self, *args, **kwargs):
0106         dict={}
0107         # What was supplied to this function
0108         dict.update(kwargs)
0109         # Parent constructor
0110         super(pbupdateentryrequest,self).__init__(**dict)
0111         if self.__class__ is pbupdateentryrequest:
0112             self._update(args,dict)
0113 
0114 
0115     def getfields(self):
0116         return self.__fields
0117 
0118 
0119     def _update(self, args, kwargs):
0120         super(pbupdateentryrequest,self)._update(args,kwargs)
0121         keys=kwargs.keys()
0122         for key in keys:
0123             if key in self.__fields:
0124                 setattr(self, key, kwargs[key])
0125                 del kwargs[key]
0126         # Were any unrecognized kwargs passed in?
0127         if __debug__:
0128             self._complainaboutunusedargs(pbupdateentryrequest,kwargs)
0129         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0130         # Make all P fields that haven't already been constructed
0131 
0132 
0133     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0134         'Writes this packet to the supplied buffer'
0135         self._bufferstartoffset=buf.getcurrentoffset()
0136         try: self.__field_header
0137         except:
0138             self.__field_header=pbheader(**{'command': 0x04, 'flag': 0x01})
0139         self.__field_header.writetobuffer(buf)
0140         self.__field_entry.writetobuffer(buf)
0141         self._bufferendoffset=buf.getcurrentoffset()
0142         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0143 
0144 
0145     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0146         'Reads this packet from the supplied buffer'
0147         self._bufferstartoffset=buf.getcurrentoffset()
0148         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0149         self.__field_header=pbheader(**{'command': 0x04, 'flag': 0x01})
0150         self.__field_header.readfrombuffer(buf)
0151         self.__field_entry=pbentry()
0152         self.__field_entry.readfrombuffer(buf)
0153         self._bufferendoffset=buf.getcurrentoffset()
0154 
0155 
0156     def __getfield_header(self):
0157         try: self.__field_header
0158         except:
0159             self.__field_header=pbheader(**{'command': 0x04, 'flag': 0x01})
0160         return self.__field_header.getvalue()
0161 
0162     def __setfield_header(self, value):
0163         if isinstance(value,pbheader):
0164             self.__field_header=value
0165         else:
0166             self.__field_header=pbheader(value,**{'command': 0x04, 'flag': 0x01})
0167 
0168     def __delfield_header(self): del self.__field_header
0169 
0170     header=property(__getfield_header, __setfield_header, __delfield_header, None)
0171 
0172     def __getfield_entry(self):
0173         return self.__field_entry.getvalue()
0174 
0175     def __setfield_entry(self, value):
0176         if isinstance(value,pbentry):
0177             self.__field_entry=value
0178         else:
0179             self.__field_entry=pbentry(value,)
0180 
0181     def __delfield_entry(self): del self.__field_entry
0182 
0183     entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None)
0184 
0185     def iscontainer(self):
0186         return True
0187 
0188     def containerelements(self):
0189         yield ('header', self.__field_header, None)
0190         yield ('entry', self.__field_entry, None)
0191 
0192 
0193 
0194 
0195 class pbappendentryrequest(BaseProtogenClass):
0196     __fields=['header', 'entry']
0197 
0198     def __init__(self, *args, **kwargs):
0199         dict={}
0200         # What was supplied to this function
0201         dict.update(kwargs)
0202         # Parent constructor
0203         super(pbappendentryrequest,self).__init__(**dict)
0204         if self.__class__ is pbappendentryrequest:
0205             self._update(args,dict)
0206 
0207 
0208     def getfields(self):
0209         return self.__fields
0210 
0211 
0212     def _update(self, args, kwargs):
0213         super(pbappendentryrequest,self)._update(args,kwargs)
0214         keys=kwargs.keys()
0215         for key in keys:
0216             if key in self.__fields:
0217                 setattr(self, key, kwargs[key])
0218                 del kwargs[key]
0219         # Were any unrecognized kwargs passed in?
0220         if __debug__:
0221             self._complainaboutunusedargs(pbappendentryrequest,kwargs)
0222         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0223         # Make all P fields that haven't already been constructed
0224 
0225 
0226     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0227         'Writes this packet to the supplied buffer'
0228         self._bufferstartoffset=buf.getcurrentoffset()
0229         try: self.__field_header
0230         except:
0231             self.__field_header=pbheader(**{'command': 0x03, 'flag': 0x01})
0232         self.__field_header.writetobuffer(buf)
0233         self.__field_entry.writetobuffer(buf)
0234         self._bufferendoffset=buf.getcurrentoffset()
0235         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0236 
0237 
0238     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0239         'Reads this packet from the supplied buffer'
0240         self._bufferstartoffset=buf.getcurrentoffset()
0241         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0242         self.__field_header=pbheader(**{'command': 0x03, 'flag': 0x01})
0243         self.__field_header.readfrombuffer(buf)
0244         self.__field_entry=pbentry()
0245         self.__field_entry.readfrombuffer(buf)
0246         self._bufferendoffset=buf.getcurrentoffset()
0247 
0248 
0249     def __getfield_header(self):
0250         try: self.__field_header
0251         except:
0252             self.__field_header=pbheader(**{'command': 0x03, 'flag': 0x01})
0253         return self.__field_header.getvalue()
0254 
0255     def __setfield_header(self, value):
0256         if isinstance(value,pbheader):
0257             self.__field_header=value
0258         else:
0259             self.__field_header=pbheader(value,**{'command': 0x03, 'flag': 0x01})
0260 
0261     def __delfield_header(self): del self.__field_header
0262 
0263     header=property(__getfield_header, __setfield_header, __delfield_header, None)
0264 
0265     def __getfield_entry(self):
0266         return self.__field_entry.getvalue()
0267 
0268     def __setfield_entry(self, value):
0269         if isinstance(value,pbentry):
0270             self.__field_entry=value
0271         else:
0272             self.__field_entry=pbentry(value,)
0273 
0274     def __delfield_entry(self): del self.__field_entry
0275 
0276     entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None)
0277 
0278     def iscontainer(self):
0279         return True
0280 
0281     def containerelements(self):
0282         yield ('header', self.__field_header, None)
0283         yield ('entry', self.__field_entry, None)
0284 
0285 
0286 
0287 
0288 class numentry(BaseProtogenClass):
0289     __fields=['number', 'chksum']
0290 
0291     def __init__(self, *args, **kwargs):
0292         dict={}
0293         # What was supplied to this function
0294         dict.update(kwargs)
0295         # Parent constructor
0296         super(numentry,self).__init__(**dict)
0297         if self.__class__ is numentry:
0298             self._update(args,dict)
0299 
0300 
0301     def getfields(self):
0302         return self.__fields
0303 
0304 
0305     def _update(self, args, kwargs):
0306         super(numentry,self)._update(args,kwargs)
0307         keys=kwargs.keys()
0308         for key in keys:
0309             if key in self.__fields:
0310                 setattr(self, key, kwargs[key])
0311                 del kwargs[key]
0312         # Were any unrecognized kwargs passed in?
0313         if __debug__:
0314             self._complainaboutunusedargs(numentry,kwargs)
0315         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0316         # Make all P fields that haven't already been constructed
0317 
0318 
0319     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0320         'Writes this packet to the supplied buffer'
0321         self._bufferstartoffset=buf.getcurrentoffset()
0322         self.__field_number.writetobuffer(buf)
0323         self.__field_chksum.writetobuffer(buf)
0324         self._bufferendoffset=buf.getcurrentoffset()
0325         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0326 
0327 
0328     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0329         'Reads this packet from the supplied buffer'
0330         self._bufferstartoffset=buf.getcurrentoffset()
0331         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0332         self.__field_number=USTRING(**{'sizeinbytes': 33, 'raiseonunterminatedread': False})
0333         self.__field_number.readfrombuffer(buf)
0334         self.__field_chksum=UINT(**{'sizeinbytes': 1})
0335         self.__field_chksum.readfrombuffer(buf)
0336         self._bufferendoffset=buf.getcurrentoffset()
0337 
0338 
0339     def __getfield_number(self):
0340         return self.__field_number.getvalue()
0341 
0342     def __setfield_number(self, value):
0343         if isinstance(value,USTRING):
0344             self.__field_number=value
0345         else:
0346             self.__field_number=USTRING(value,**{'sizeinbytes': 33, 'raiseonunterminatedread': False})
0347 
0348     def __delfield_number(self): del self.__field_number
0349 
0350     number=property(__getfield_number, __setfield_number, __delfield_number, None)
0351 
0352     def __getfield_chksum(self):
0353         return self.__field_chksum.getvalue()
0354 
0355     def __setfield_chksum(self, value):
0356         if isinstance(value,UINT):
0357             self.__field_chksum=value
0358         else:
0359             self.__field_chksum=UINT(value,**{'sizeinbytes': 1})
0360 
0361     def __delfield_chksum(self): del self.__field_chksum
0362 
0363     chksum=property(__getfield_chksum, __setfield_chksum, __delfield_chksum, None)
0364 
0365     def iscontainer(self):
0366         return True
0367 
0368     def containerelements(self):
0369         yield ('number', self.__field_number, None)
0370         yield ('chksum', self.__field_chksum, None)
0371 
0372 
0373 
0374 
0375 class pbentry(BaseProtogenClass):
0376     "Results of reading one entry"
0377     __fields=['numberofemails', 'numberofphonenumbers', 'serial1', 'entrysize', 'serial2', 'entrynumber', 'name', 'secret', 'default', 'numbers', 'ringtone', 'voicetag', 'email']
0378 
0379     def __init__(self, *args, **kwargs):
0380         dict={}
0381         # What was supplied to this function
0382         dict.update(kwargs)
0383         # Parent constructor
0384         super(pbentry,self).__init__(**dict)
0385         if self.__class__ is pbentry:
0386             self._update(args,dict)
0387 
0388 
0389     def getfields(self):
0390         return self.__fields
0391 
0392 
0393     def _update(self, args, kwargs):
0394         super(pbentry,self)._update(args,kwargs)
0395         keys=kwargs.keys()
0396         for key in keys:
0397             if key in self.__fields:
0398                 setattr(self, key, kwargs[key])
0399                 del kwargs[key]
0400         # Were any unrecognized kwargs passed in?
0401         if __debug__:
0402             self._complainaboutunusedargs(pbentry,kwargs)
0403         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0404         # Make all P fields that haven't already been constructed
0405         try: self.__field_numberofemails
0406         except:
0407             self.__field_numberofemails=UINT(**{'constant': 1})
0408         try: self.__field_numberofphonenumbers
0409         except:
0410             self.__field_numberofphonenumbers=UINT(**{'constant': 5})
0411 
0412 
0413     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0414         'Writes this packet to the supplied buffer'
0415         self._bufferstartoffset=buf.getcurrentoffset()
0416         self.__field_serial1.writetobuffer(buf)
0417         try: self.__field_entrysize
0418         except:
0419             self.__field_entrysize=UINT(**{'sizeinbytes': 2, 'constant': 0xf5})
0420         self.__field_entrysize.writetobuffer(buf)
0421         self.__field_serial2.writetobuffer(buf)
0422         self.__field_entrynumber.writetobuffer(buf)
0423         self.__field_name.writetobuffer(buf)
0424         self.__field_secret.writetobuffer(buf)
0425         self.__field_default.writetobuffer(buf)
0426         try: self.__field_numbers
0427         except:
0428             self.__field_numbers=LIST(**{'length': self.numberofphonenumbers, 'elementclass': numentry, 'createdefault': True})
0429         self.__field_numbers.writetobuffer(buf)
0430         self.__field_ringtone.writetobuffer(buf)
0431         self.__field_voicetag.writetobuffer(buf)
0432         try: self.__field_email
0433         except:
0434             self.__field_email=USTRING(**{'sizeinbytes': 49, 'raiseonunterminatedread': False})
0435         self.__field_email.writetobuffer(buf)
0436         self._bufferendoffset=buf.getcurrentoffset()
0437         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0438 
0439 
0440     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0441         'Reads this packet from the supplied buffer'
0442         self._bufferstartoffset=buf.getcurrentoffset()
0443         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0444         self.__field_serial1=UINT(**{'sizeinbytes': 4})
0445         self.__field_serial1.readfrombuffer(buf)
0446         self.__field_entrysize=UINT(**{'sizeinbytes': 2, 'constant': 0xf5})
0447         self.__field_entrysize.readfrombuffer(buf)
0448         self.__field_serial2=UINT(**{'sizeinbytes': 4})
0449         self.__field_serial2.readfrombuffer(buf)
0450         self.__field_entrynumber=UINT(**{'sizeinbytes': 1})
0451         self.__field_entrynumber.readfrombuffer(buf)
0452         self.__field_name=USTRING(**{'sizeinbytes': 17, 'raiseonunterminatedread': False})
0453         self.__field_name.readfrombuffer(buf)
0454         self.__field_secret=BOOL(**{'sizeinbytes': 1})
0455         self.__field_secret.readfrombuffer(buf)
0456         self.__field_default=UINT(**{'sizeinbytes': 1})
0457         self.__field_default.readfrombuffer(buf)
0458         self.__field_numbers=LIST(**{'length': self.numberofphonenumbers, 'elementclass': numentry, 'createdefault': True})
0459         self.__field_numbers.readfrombuffer(buf)
0460         self.__field_ringtone=UINT(**{'sizeinbytes': 1})
0461         self.__field_ringtone.readfrombuffer(buf)
0462         self.__field_voicetag=BOOL(**{'sizeinbytes': 1})
0463         self.__field_voicetag.readfrombuffer(buf)
0464         self.__field_email=USTRING(**{'sizeinbytes': 49, 'raiseonunterminatedread': False})
0465         self.__field_email.readfrombuffer(buf)
0466         self._bufferendoffset=buf.getcurrentoffset()
0467 
0468 
0469     def __getfield_numberofemails(self):
0470         return self.__field_numberofemails.getvalue()
0471 
0472     def __setfield_numberofemails(self, value):
0473         if isinstance(value,UINT):
0474             self.__field_numberofemails=value
0475         else:
0476             self.__field_numberofemails=UINT(value,**{'constant': 1})
0477 
0478     def __delfield_numberofemails(self): del self.__field_numberofemails
0479 
0480     numberofemails=property(__getfield_numberofemails, __setfield_numberofemails, __delfield_numberofemails, None)
0481 
0482     def __getfield_numberofphonenumbers(self):
0483         return self.__field_numberofphonenumbers.getvalue()
0484 
0485     def __setfield_numberofphonenumbers(self, value):
0486         if isinstance(value,UINT):
0487             self.__field_numberofphonenumbers=value
0488         else:
0489             self.__field_numberofphonenumbers=UINT(value,**{'constant': 5})
0490 
0491     def __delfield_numberofphonenumbers(self): del self.__field_numberofphonenumbers
0492 
0493     numberofphonenumbers=property(__getfield_numberofphonenumbers, __setfield_numberofphonenumbers, __delfield_numberofphonenumbers, None)
0494 
0495     def __getfield_serial1(self):
0496         return self.__field_serial1.getvalue()
0497 
0498     def __setfield_serial1(self, value):
0499         if isinstance(value,UINT):
0500             self.__field_serial1=value
0501         else:
0502             self.__field_serial1=UINT(value,**{'sizeinbytes': 4})
0503 
0504     def __delfield_serial1(self): del self.__field_serial1
0505 
0506     serial1=property(__getfield_serial1, __setfield_serial1, __delfield_serial1, " == order created")
0507 
0508     def __getfield_entrysize(self):
0509         try: self.__field_entrysize
0510         except:
0511             self.__field_entrysize=UINT(**{'sizeinbytes': 2, 'constant': 0xf5})
0512         return self.__field_entrysize.getvalue()
0513 
0514     def __setfield_entrysize(self, value):
0515         if isinstance(value,UINT):
0516             self.__field_entrysize=value
0517         else:
0518             self.__field_entrysize=UINT(value,**{'sizeinbytes': 2, 'constant': 0xf5})
0519 
0520     def __delfield_entrysize(self): del self.__field_entrysize
0521 
0522     entrysize=property(__getfield_entrysize, __setfield_entrysize, __delfield_entrysize, None)
0523 
0524     def __getfield_serial2(self):
0525         return self.__field_serial2.getvalue()
0526 
0527     def __setfield_serial2(self, value):
0528         if isinstance(value,UINT):
0529             self.__field_serial2=value
0530         else:
0531             self.__field_serial2=UINT(value,**{'sizeinbytes': 4})
0532 
0533     def __delfield_serial2(self): del self.__field_serial2
0534 
0535     serial2=property(__getfield_serial2, __setfield_serial2, __delfield_serial2, "Same as serial1")
0536 
0537     def __getfield_entrynumber(self):
0538         return self.__field_entrynumber.getvalue()
0539 
0540     def __setfield_entrynumber(self, value):
0541         if isinstance(value,UINT):
0542             self.__field_entrynumber=value
0543         else:
0544             self.__field_entrynumber=UINT(value,**{'sizeinbytes': 1})
0545 
0546     def __delfield_entrynumber(self): del self.__field_entrynumber
0547 
0548     entrynumber=property(__getfield_entrynumber, __setfield_entrynumber, __delfield_entrynumber, None)
0549 
0550     def __getfield_name(self):
0551         return self.__field_name.getvalue()
0552 
0553     def __setfield_name(self, value):
0554         if isinstance(value,USTRING):
0555             self.__field_name=value
0556         else:
0557             self.__field_name=USTRING(value,**{'sizeinbytes': 17, 'raiseonunterminatedread': False})
0558 
0559     def __delfield_name(self): del self.__field_name
0560 
0561     name=property(__getfield_name, __setfield_name, __delfield_name, None)
0562 
0563     def __getfield_secret(self):
0564         return self.__field_secret.getvalue()
0565 
0566     def __setfield_secret(self, value):
0567         if isinstance(value,BOOL):
0568             self.__field_secret=value
0569         else:
0570             self.__field_secret=BOOL(value,**{'sizeinbytes': 1})
0571 
0572     def __delfield_secret(self): del self.__field_secret
0573 
0574     secret=property(__getfield_secret, __setfield_secret, __delfield_secret, None)
0575 
0576     def __getfield_default(self):
0577         return self.__field_default.getvalue()
0578 
0579     def __setfield_default(self, value):
0580         if isinstance(value,UINT):
0581             self.__field_default=value
0582         else:
0583             self.__field_default=UINT(value,**{'sizeinbytes': 1})
0584 
0585     def __delfield_default(self): del self.__field_default
0586 
0587     default=property(__getfield_default, __setfield_default, __delfield_default, "Default number")
0588 
0589     def __getfield_numbers(self):
0590         try: self.__field_numbers
0591         except:
0592             self.__field_numbers=LIST(**{'length': self.numberofphonenumbers, 'elementclass': numentry, 'createdefault': True})
0593         return self.__field_numbers.getvalue()
0594 
0595     def __setfield_numbers(self, value):
0596         if isinstance(value,LIST):
0597             self.__field_numbers=value
0598         else:
0599             self.__field_numbers=LIST(value,**{'length': self.numberofphonenumbers, 'elementclass': numentry, 'createdefault': True})
0600 
0601     def __delfield_numbers(self): del self.__field_numbers
0602 
0603     numbers=property(__getfield_numbers, __setfield_numbers, __delfield_numbers, None)
0604 
0605     def __getfield_ringtone(self):
0606         return self.__field_ringtone.getvalue()
0607 
0608     def __setfield_ringtone(self, value):
0609         if isinstance(value,UINT):
0610             self.__field_ringtone=value
0611         else:
0612             self.__field_ringtone=UINT(value,**{'sizeinbytes': 1})
0613 
0614     def __delfield_ringtone(self): del self.__field_ringtone
0615 
0616     ringtone=property(__getfield_ringtone, __setfield_ringtone, __delfield_ringtone, "ringtone index for a call, 0x17 for custom")
0617 
0618     def __getfield_voicetag(self):
0619         return self.__field_voicetag.getvalue()
0620 
0621     def __setfield_voicetag(self, value):
0622         if isinstance(value,BOOL):
0623             self.__field_voicetag=value
0624         else:
0625             self.__field_voicetag=BOOL(value,**{'sizeinbytes': 1})
0626 
0627     def __delfield_voicetag(self): del self.__field_voicetag
0628 
0629     voicetag=property(__getfield_voicetag, __setfield_voicetag, __delfield_voicetag, None)
0630 
0631     def __getfield_email(self):
0632         try: self.__field_email
0633         except:
0634             self.__field_email=USTRING(**{'sizeinbytes': 49, 'raiseonunterminatedread': False})
0635         return self.__field_email.getvalue()
0636 
0637     def __setfield_email(self, value):
0638         if isinstance(value,USTRING):
0639             self.__field_email=value
0640         else:
0641             self.__field_email=USTRING(value,**{'sizeinbytes': 49, 'raiseonunterminatedread': False})
0642 
0643     def __delfield_email(self): del self.__field_email
0644 
0645     email=property(__getfield_email, __setfield_email, __delfield_email, None)
0646 
0647     def iscontainer(self):
0648         return True
0649 
0650     def containerelements(self):
0651         yield ('numberofemails', self.__field_numberofemails, None)
0652         yield ('numberofphonenumbers', self.__field_numberofphonenumbers, None)
0653         yield ('serial1', self.__field_serial1, " == order created")
0654         yield ('entrysize', self.__field_entrysize, None)
0655         yield ('serial2', self.__field_serial2, "Same as serial1")
0656         yield ('entrynumber', self.__field_entrynumber, None)
0657         yield ('name', self.__field_name, None)
0658         yield ('secret', self.__field_secret, None)
0659         yield ('default', self.__field_default, "Default number")
0660         yield ('numbers', self.__field_numbers, None)
0661         yield ('ringtone', self.__field_ringtone, "ringtone index for a call, 0x17 for custom")
0662         yield ('voicetag', self.__field_voicetag, None)
0663         yield ('email', self.__field_email, None)
0664 
0665 
0666 
0667 
0668 class ringentry(BaseProtogenClass):
0669     __fields=['index', 'name']
0670 
0671     def __init__(self, *args, **kwargs):
0672         dict={}
0673         # What was supplied to this function
0674         dict.update(kwargs)
0675         # Parent constructor
0676         super(ringentry,self).__init__(**dict)
0677         if self.__class__ is ringentry:
0678             self._update(args,dict)
0679 
0680 
0681     def getfields(self):
0682         return self.__fields
0683 
0684 
0685     def _update(self, args, kwargs):
0686         super(ringentry,self)._update(args,kwargs)
0687         keys=kwargs.keys()
0688         for key in keys:
0689             if key in self.__fields:
0690                 setattr(self, key, kwargs[key])
0691                 del kwargs[key]
0692         # Were any unrecognized kwargs passed in?
0693         if __debug__:
0694             self._complainaboutunusedargs(ringentry,kwargs)
0695         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0696         # Make all P fields that haven't already been constructed
0697 
0698 
0699     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0700         'Writes this packet to the supplied buffer'
0701         self._bufferstartoffset=buf.getcurrentoffset()
0702         self.__field_index.writetobuffer(buf)
0703         self.__field_name.writetobuffer(buf)
0704         self._bufferendoffset=buf.getcurrentoffset()
0705         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0706 
0707 
0708     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0709         'Reads this packet from the supplied buffer'
0710         self._bufferstartoffset=buf.getcurrentoffset()
0711         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0712         self.__field_index=UINT(**{'sizeinbytes': 1})
0713         self.__field_index.readfrombuffer(buf)
0714         self.__field_name=USTRING(**{'sizeinbytes': 40, 'raiseonunterminatedread': False})
0715         self.__field_name.readfrombuffer(buf)
0716         self._bufferendoffset=buf.getcurrentoffset()
0717 
0718 
0719     def __getfield_index(self):
0720         return self.__field_index.getvalue()
0721 
0722     def __setfield_index(self, value):
0723         if isinstance(value,UINT):
0724             self.__field_index=value
0725         else:
0726             self.__field_index=UINT(value,**{'sizeinbytes': 1})
0727 
0728     def __delfield_index(self): del self.__field_index
0729 
0730     index=property(__getfield_index, __setfield_index, __delfield_index, "Phonebook entry number")
0731 
0732     def __getfield_name(self):
0733         return self.__field_name.getvalue()
0734 
0735     def __setfield_name(self, value):
0736         if isinstance(value,USTRING):
0737             self.__field_name=value
0738         else:
0739             self.__field_name=USTRING(value,**{'sizeinbytes': 40, 'raiseonunterminatedread': False})
0740 
0741     def __delfield_name(self): del self.__field_name
0742 
0743     name=property(__getfield_name, __setfield_name, __delfield_name, "Path of custom ringer, or default")
0744 
0745     def iscontainer(self):
0746         return True
0747 
0748     def containerelements(self):
0749         yield ('index', self.__field_index, "Phonebook entry number")
0750         yield ('name', self.__field_name, "Path of custom ringer, or default")
0751 
0752 
0753 
0754 
0755 class ringindex(BaseProtogenClass):
0756     __fields=['maxitems', 'items']
0757 
0758     def __init__(self, *args, **kwargs):
0759         dict={}
0760         # What was supplied to this function
0761         dict.update(kwargs)
0762         # Parent constructor
0763         super(ringindex,self).__init__(**dict)
0764         if self.__class__ is ringindex:
0765             self._update(args,dict)
0766 
0767 
0768     def getfields(self):
0769         return self.__fields
0770 
0771 
0772     def _update(self, args, kwargs):
0773         super(ringindex,self)._update(args,kwargs)
0774         keys=kwargs.keys()
0775         for key in keys:
0776             if key in self.__fields:
0777                 setattr(self, key, kwargs[key])
0778                 del kwargs[key]
0779         # Were any unrecognized kwargs passed in?
0780         if __debug__:
0781             self._complainaboutunusedargs(ringindex,kwargs)
0782         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0783         # Make all P fields that haven't already been constructed
0784         try: self.__field_maxitems
0785         except:
0786             self.__field_maxitems=UINT(**{'constant': 199})
0787 
0788 
0789     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0790         'Writes this packet to the supplied buffer'
0791         self._bufferstartoffset=buf.getcurrentoffset()
0792         try: self.__field_items
0793         except:
0794             self.__field_items=LIST(**{'length': self.maxitems, 'elementclass': ringentry, 'createdefault': True})
0795         self.__field_items.writetobuffer(buf)
0796         self._bufferendoffset=buf.getcurrentoffset()
0797         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0798 
0799 
0800     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0801         'Reads this packet from the supplied buffer'
0802         self._bufferstartoffset=buf.getcurrentoffset()
0803         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0804         self.__field_items=LIST(**{'length': self.maxitems, 'elementclass': ringentry, 'createdefault': True})
0805         self.__field_items.readfrombuffer(buf)
0806         self._bufferendoffset=buf.getcurrentoffset()
0807 
0808 
0809     def __getfield_maxitems(self):
0810         return self.__field_maxitems.getvalue()
0811 
0812     def __setfield_maxitems(self, value):
0813         if isinstance(value,UINT):
0814             self.__field_maxitems=value
0815         else:
0816             self.__field_maxitems=UINT(value,**{'constant': 199})
0817 
0818     def __delfield_maxitems(self): del self.__field_maxitems
0819 
0820     maxitems=property(__getfield_maxitems, __setfield_maxitems, __delfield_maxitems, None)
0821 
0822     def __getfield_items(self):
0823         try: self.__field_items
0824         except:
0825             self.__field_items=LIST(**{'length': self.maxitems, 'elementclass': ringentry, 'createdefault': True})
0826         return self.__field_items.getvalue()
0827 
0828     def __setfield_items(self, value):
0829         if isinstance(value,LIST):
0830             self.__field_items=value
0831         else:
0832             self.__field_items=LIST(value,**{'length': self.maxitems, 'elementclass': ringentry, 'createdefault': True})
0833 
0834     def __delfield_items(self): del self.__field_items
0835 
0836     items=property(__getfield_items, __setfield_items, __delfield_items, None)
0837 
0838     def iscontainer(self):
0839         return True
0840 
0841     def containerelements(self):
0842         yield ('maxitems', self.__field_maxitems, None)
0843         yield ('items', self.__field_items, None)
0844 
0845 
0846 
0847 
0848 class scheduleevent(BaseProtogenClass):
0849     __fields=['state', 'pos', 'alarm', 'date', 'repeat', 'description']
0850 
0851     def __init__(self, *args, **kwargs):
0852         dict={}
0853         # What was supplied to this function
0854         dict.update(kwargs)
0855         # Parent constructor
0856         super(scheduleevent,self).__init__(**dict)
0857         if self.__class__ is scheduleevent:
0858             self._update(args,dict)
0859 
0860 
0861     def getfields(self):
0862         return self.__fields
0863 
0864 
0865     def _update(self, args, kwargs):
0866         super(scheduleevent,self)._update(args,kwargs)
0867         keys=kwargs.keys()
0868         for key in keys:
0869             if key in self.__fields:
0870                 setattr(self, key, kwargs[key])
0871                 del kwargs[key]
0872         # Were any unrecognized kwargs passed in?
0873         if __debug__:
0874             self._complainaboutunusedargs(scheduleevent,kwargs)
0875         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0876         # Make all P fields that haven't already been constructed
0877 
0878 
0879     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0880         'Writes this packet to the supplied buffer'
0881         self._bufferstartoffset=buf.getcurrentoffset()
0882         self.__field_state.writetobuffer(buf)
0883         self.__field_pos.writetobuffer(buf)
0884         self.__field_alarm.writetobuffer(buf)
0885         self.__field_date.writetobuffer(buf)
0886         self.__field_repeat.writetobuffer(buf)
0887         self.__field_description.writetobuffer(buf)
0888         self._bufferendoffset=buf.getcurrentoffset()
0889         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0890 
0891 
0892     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0893         'Reads this packet from the supplied buffer'
0894         self._bufferstartoffset=buf.getcurrentoffset()
0895         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0896         self.__field_state=UINT(**{'sizeinbytes': 1})
0897         self.__field_state.readfrombuffer(buf)
0898         self.__field_pos=UINT(**{'sizeinbytes': 1})
0899         self.__field_pos.readfrombuffer(buf)
0900         self.__field_alarm=UINT(**{'sizeinbytes': 1})
0901         self.__field_alarm.readfrombuffer(buf)
0902         self.__field_date=UINT(**{'sizeinbytes': 4})
0903         self.__field_date.readfrombuffer(buf)
0904         self.__field_repeat=UINT(**{'sizeinbytes': 1})
0905         self.__field_repeat.readfrombuffer(buf)
0906         self.__field_description=USTRING(**{'sizeinbytes': 32, 'raiseonunterminatedread': False})
0907         self.__field_description.readfrombuffer(buf)
0908         self._bufferendoffset=buf.getcurrentoffset()
0909 
0910 
0911     def __getfield_state(self):
0912         return self.__field_state.getvalue()
0913 
0914     def __setfield_state(self, value):
0915         if isinstance(value,UINT):
0916             self.__field_state=value
0917         else:
0918             self.__field_state=UINT(value,**{'sizeinbytes': 1})
0919 
0920     def __delfield_state(self): del self.__field_state
0921 
0922     state=property(__getfield_state, __setfield_state, __delfield_state, "02 for an new entry, 01 for a modified entry, 00 for blank entry")
0923 
0924     def __getfield_pos(self):
0925         return self.__field_pos.getvalue()
0926 
0927     def __setfield_pos(self, value):
0928         if isinstance(value,UINT):
0929             self.__field_pos=value
0930         else:
0931             self.__field_pos=UINT(value,**{'sizeinbytes': 1})
0932 
0933     def __delfield_pos(self): del self.__field_pos
0934 
0935     pos=property(__getfield_pos, __setfield_pos, __delfield_pos, "position within file, used as an event id")
0936 
0937     def __getfield_alarm(self):
0938         return self.__field_alarm.getvalue()
0939 
0940     def __setfield_alarm(self, value):
0941         if isinstance(value,UINT):
0942             self.__field_alarm=value
0943         else:
0944             self.__field_alarm=UINT(value,**{'sizeinbytes': 1})
0945 
0946     def __delfield_alarm(self): del self.__field_alarm
0947 
0948     alarm=property(__getfield_alarm, __setfield_alarm, __delfield_alarm, "00 => created, 80 => modified/never been used, B0 => alarm")
0949 
0950     def __getfield_date(self):
0951         return self.__field_date.getvalue()
0952 
0953     def __setfield_date(self, value):
0954         if isinstance(value,UINT):
0955             self.__field_date=value
0956         else:
0957             self.__field_date=UINT(value,**{'sizeinbytes': 4})
0958 
0959     def __delfield_date(self): del self.__field_date
0960 
0961     date=property(__getfield_date, __setfield_date, __delfield_date, None)
0962 
0963     def __getfield_repeat(self):
0964         return self.__field_repeat.getvalue()
0965 
0966     def __setfield_repeat(self, value):
0967         if isinstance(value,UINT):
0968             self.__field_repeat=value
0969         else:
0970             self.__field_repeat=UINT(value,**{'sizeinbytes': 1})
0971 
0972     def __delfield_repeat(self): del self.__field_repeat
0973 
0974     repeat=property(__getfield_repeat, __setfield_repeat, __delfield_repeat, "01 => used, 02 => daily")
0975 
0976     def __getfield_description(self):
0977         return self.__field_description.getvalue()
0978 
0979     def __setfield_description(self, value):
0980         if isinstance(value,USTRING):
0981             self.__field_description=value
0982         else:
0983             self.__field_description=USTRING(value,**{'sizeinbytes': 32, 'raiseonunterminatedread': False})
0984 
0985     def __delfield_description(self): del self.__field_description
0986 
0987     description=property(__getfield_description, __setfield_description, __delfield_description, None)
0988 
0989     def iscontainer(self):
0990         return True
0991 
0992     def containerelements(self):
0993         yield ('state', self.__field_state, "02 for an new entry, 01 for a modified entry, 00 for blank entry")
0994         yield ('pos', self.__field_pos, "position within file, used as an event id")
0995         yield ('alarm', self.__field_alarm, "00 => created, 80 => modified/never been used, B0 => alarm")
0996         yield ('date', self.__field_date, None)
0997         yield ('repeat', self.__field_repeat, "01 => used, 02 => daily")
0998         yield ('description', self.__field_description, None)
0999 
1000 
1001 
1002 
1003 class schedulefile(BaseProtogenClass):
1004     __fields=['events']
1005 
1006     def __init__(self, *args, **kwargs):
1007         dict={}
1008         # What was supplied to this function
1009         dict.update(kwargs)
1010         # Parent constructor
1011         super(schedulefile,self).__init__(**dict)
1012         if self.__class__ is schedulefile:
1013             self._update(args,dict)
1014 
1015 
1016     def getfields(self):
1017         return self.__fields
1018 
1019 
1020     def _update(self, args, kwargs):
1021         super(schedulefile,self)._update(args,kwargs)
1022         keys=kwargs.keys()
1023         for key in keys:
1024             if key in self.__fields:
1025                 setattr(self, key, kwargs[key])
1026                 del kwargs[key]
1027         # Were any unrecognized kwargs passed in?
1028         if __debug__:
1029             self._complainaboutunusedargs(schedulefile,kwargs)
1030         if len(args):
1031             dict2={'length': 50, 'elementclass': scheduleevent}
1032             dict2.update(kwargs)
1033             kwargs=dict2
1034             self.__field_events=LIST(*args,**dict2)
1035         # Make all P fields that haven't already been constructed
1036 
1037 
1038     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1039         'Writes this packet to the supplied buffer'
1040         self._bufferstartoffset=buf.getcurrentoffset()
1041         try: self.__field_events
1042         except:
1043             self.__field_events=LIST(**{'length': 50, 'elementclass': scheduleevent})
1044         self.__field_events.writetobuffer(buf)
1045         self._bufferendoffset=buf.getcurrentoffset()
1046         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1047 
1048 
1049     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1050         'Reads this packet from the supplied buffer'
1051         self._bufferstartoffset=buf.getcurrentoffset()
1052         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1053         self.__field_events=LIST(**{'length': 50, 'elementclass': scheduleevent})
1054         self.__field_events.readfrombuffer(buf)
1055         self._bufferendoffset=buf.getcurrentoffset()
1056 
1057 
1058     def __getfield_events(self):
1059         try: self.__field_events
1060         except:
1061             self.__field_events=LIST(**{'length': 50, 'elementclass': scheduleevent})
1062         return self.__field_events.getvalue()
1063 
1064     def __setfield_events(self, value):
1065         if isinstance(value,LIST):
1066             self.__field_events=value
1067         else:
1068             self.__field_events=LIST(value,**{'length': 50, 'elementclass': scheduleevent})
1069 
1070     def __delfield_events(self): del self.__field_events
1071 
1072     events=property(__getfield_events, __setfield_events, __delfield_events, None)
1073 
1074     def iscontainer(self):
1075         return True
1076 
1077     def containerelements(self):
1078         yield ('events', self.__field_events, None)
1079 
1080 
1081 
1082 
1083 

Generated by PyXR 0.9.4