PyXR

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

0001 # THIS FILE IS AUTOMATICALLY GENERATED.  EDIT THE SOURCE FILE NOT THIS ONE
0002 
0003 """Various descriptions of data specific to Sanyo phones"""
0004 
0005 from prototypes import *
0006 from prototypeslg import *
0007 
0008 # We use LSB for all integer like fields
0009 
0010 UINT=UINTlsb
0011 BOOL=BOOLlsb
0012 _NUMPBSLOTS=300
0013 _NUMSPEEDDIALS=8
0014 _NUMLONGNUMBERS=5
0015 _LONGPHONENUMBERLEN=30
0016 _NUMEVENTSLOTS=100
0017 _NUMCALLALARMSLOTS=15
0018 NUMCALLHISTORY=20
0019 NUMPHONENUMBERS=7
0020 NUMMESSAGESLOTS=128
0021 NUMTODOSLOTS=20
0022 HASRINGPICBUF=1
0023 FIRSTSPEEDDIAL=2
0024 LASTSPEEDDIAL=9
0025 
0026 OUTGOING=0
0027 INCOMING=1
0028 MISSED=2
0029 
0030 class sanyoerror(BaseProtogenClass):
0031     __fields=['errorcode', 'unknown']
0032 
0033     def __init__(self, *args, **kwargs):
0034         dict={}
0035         # What was supplied to this function
0036         dict.update(kwargs)
0037         # Parent constructor
0038         super(sanyoerror,self).__init__(**dict)
0039         if self.__class__ is sanyoerror:
0040             self._update(args,dict)
0041 
0042 
0043     def getfields(self):
0044         return self.__fields
0045 
0046 
0047     def _update(self, args, kwargs):
0048         super(sanyoerror,self)._update(args,kwargs)
0049         keys=kwargs.keys()
0050         for key in keys:
0051             if key in self.__fields:
0052                 setattr(self, key, kwargs[key])
0053                 del kwargs[key]
0054         # Were any unrecognized kwargs passed in?
0055         if __debug__:
0056             self._complainaboutunusedargs(sanyoerror,kwargs)
0057         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0058         # Make all P fields that haven't already been constructed
0059 
0060 
0061     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0062         'Writes this packet to the supplied buffer'
0063         self._bufferstartoffset=buf.getcurrentoffset()
0064         self.__field_errorcode.writetobuffer(buf)
0065         self.__field_unknown.writetobuffer(buf)
0066         self._bufferendoffset=buf.getcurrentoffset()
0067         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0068 
0069 
0070     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0071         'Reads this packet from the supplied buffer'
0072         self._bufferstartoffset=buf.getcurrentoffset()
0073         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0074         self.__field_errorcode=UINT(**{'sizeinbytes': 1})
0075         self.__field_errorcode.readfrombuffer(buf)
0076         self.__field_unknown=UNKNOWN()
0077         self.__field_unknown.readfrombuffer(buf)
0078         self._bufferendoffset=buf.getcurrentoffset()
0079 
0080 
0081     def __getfield_errorcode(self):
0082         return self.__field_errorcode.getvalue()
0083 
0084     def __setfield_errorcode(self, value):
0085         if isinstance(value,UINT):
0086             self.__field_errorcode=value
0087         else:
0088             self.__field_errorcode=UINT(value,**{'sizeinbytes': 1})
0089 
0090     def __delfield_errorcode(self): del self.__field_errorcode
0091 
0092     errorcode=property(__getfield_errorcode, __setfield_errorcode, __delfield_errorcode, None)
0093 
0094     def __getfield_unknown(self):
0095         return self.__field_unknown.getvalue()
0096 
0097     def __setfield_unknown(self, value):
0098         if isinstance(value,UNKNOWN):
0099             self.__field_unknown=value
0100         else:
0101             self.__field_unknown=UNKNOWN(value,)
0102 
0103     def __delfield_unknown(self): del self.__field_unknown
0104 
0105     unknown=property(__getfield_unknown, __setfield_unknown, __delfield_unknown, None)
0106 
0107     def iscontainer(self):
0108         return True
0109 
0110     def containerelements(self):
0111         yield ('errorcode', self.__field_errorcode, None)
0112         yield ('unknown', self.__field_unknown, None)
0113 
0114 
0115 
0116 
0117 class firmwarerequest(BaseProtogenClass):
0118     __fields=['command']
0119 
0120     def __init__(self, *args, **kwargs):
0121         dict={}
0122         # What was supplied to this function
0123         dict.update(kwargs)
0124         # Parent constructor
0125         super(firmwarerequest,self).__init__(**dict)
0126         if self.__class__ is firmwarerequest:
0127             self._update(args,dict)
0128 
0129 
0130     def getfields(self):
0131         return self.__fields
0132 
0133 
0134     def _update(self, args, kwargs):
0135         super(firmwarerequest,self)._update(args,kwargs)
0136         keys=kwargs.keys()
0137         for key in keys:
0138             if key in self.__fields:
0139                 setattr(self, key, kwargs[key])
0140                 del kwargs[key]
0141         # Were any unrecognized kwargs passed in?
0142         if __debug__:
0143             self._complainaboutunusedargs(firmwarerequest,kwargs)
0144         if len(args):
0145             dict2={'sizeinbytes': 1, 'constant': 0x00}
0146             dict2.update(kwargs)
0147             kwargs=dict2
0148             self.__field_command=UINT(*args,**dict2)
0149         # Make all P fields that haven't already been constructed
0150 
0151 
0152     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0153         'Writes this packet to the supplied buffer'
0154         self._bufferstartoffset=buf.getcurrentoffset()
0155         try: self.__field_command
0156         except:
0157             self.__field_command=UINT(**{'sizeinbytes': 1, 'constant': 0x00})
0158         self.__field_command.writetobuffer(buf)
0159         self._bufferendoffset=buf.getcurrentoffset()
0160         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0161 
0162 
0163     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0164         'Reads this packet from the supplied buffer'
0165         self._bufferstartoffset=buf.getcurrentoffset()
0166         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0167         self.__field_command=UINT(**{'sizeinbytes': 1, 'constant': 0x00})
0168         self.__field_command.readfrombuffer(buf)
0169         self._bufferendoffset=buf.getcurrentoffset()
0170 
0171 
0172     def __getfield_command(self):
0173         try: self.__field_command
0174         except:
0175             self.__field_command=UINT(**{'sizeinbytes': 1, 'constant': 0x00})
0176         return self.__field_command.getvalue()
0177 
0178     def __setfield_command(self, value):
0179         if isinstance(value,UINT):
0180             self.__field_command=value
0181         else:
0182             self.__field_command=UINT(value,**{'sizeinbytes': 1, 'constant': 0x00})
0183 
0184     def __delfield_command(self): del self.__field_command
0185 
0186     command=property(__getfield_command, __setfield_command, __delfield_command, None)
0187 
0188     def iscontainer(self):
0189         return True
0190 
0191     def containerelements(self):
0192         yield ('command', self.__field_command, None)
0193 
0194 
0195 
0196 
0197 class firmwareresponse(BaseProtogenClass):
0198     __fields=['command', 'unknown']
0199 
0200     def __init__(self, *args, **kwargs):
0201         dict={}
0202         # What was supplied to this function
0203         dict.update(kwargs)
0204         # Parent constructor
0205         super(firmwareresponse,self).__init__(**dict)
0206         if self.__class__ is firmwareresponse:
0207             self._update(args,dict)
0208 
0209 
0210     def getfields(self):
0211         return self.__fields
0212 
0213 
0214     def _update(self, args, kwargs):
0215         super(firmwareresponse,self)._update(args,kwargs)
0216         keys=kwargs.keys()
0217         for key in keys:
0218             if key in self.__fields:
0219                 setattr(self, key, kwargs[key])
0220                 del kwargs[key]
0221         # Were any unrecognized kwargs passed in?
0222         if __debug__:
0223             self._complainaboutunusedargs(firmwareresponse,kwargs)
0224         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0225         # Make all P fields that haven't already been constructed
0226 
0227 
0228     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0229         'Writes this packet to the supplied buffer'
0230         self._bufferstartoffset=buf.getcurrentoffset()
0231         self.__field_command.writetobuffer(buf)
0232         self.__field_unknown.writetobuffer(buf)
0233         self._bufferendoffset=buf.getcurrentoffset()
0234         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0235 
0236 
0237     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0238         'Reads this packet from the supplied buffer'
0239         self._bufferstartoffset=buf.getcurrentoffset()
0240         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0241         self.__field_command=UINT(**{'sizeinbytes': 1})
0242         self.__field_command.readfrombuffer(buf)
0243         self.__field_unknown=UNKNOWN()
0244         self.__field_unknown.readfrombuffer(buf)
0245         self._bufferendoffset=buf.getcurrentoffset()
0246 
0247 
0248     def __getfield_command(self):
0249         return self.__field_command.getvalue()
0250 
0251     def __setfield_command(self, value):
0252         if isinstance(value,UINT):
0253             self.__field_command=value
0254         else:
0255             self.__field_command=UINT(value,**{'sizeinbytes': 1})
0256 
0257     def __delfield_command(self): del self.__field_command
0258 
0259     command=property(__getfield_command, __setfield_command, __delfield_command, None)
0260 
0261     def __getfield_unknown(self):
0262         return self.__field_unknown.getvalue()
0263 
0264     def __setfield_unknown(self, value):
0265         if isinstance(value,UNKNOWN):
0266             self.__field_unknown=value
0267         else:
0268             self.__field_unknown=UNKNOWN(value,)
0269 
0270     def __delfield_unknown(self): del self.__field_unknown
0271 
0272     unknown=property(__getfield_unknown, __setfield_unknown, __delfield_unknown, None)
0273 
0274     def iscontainer(self):
0275         return True
0276 
0277     def containerelements(self):
0278         yield ('command', self.__field_command, None)
0279         yield ('unknown', self.__field_unknown, None)
0280 
0281 
0282 
0283 
0284 class beginendupdaterequest(BaseProtogenClass):
0285     __fields=['command', 'beginend']
0286 
0287     def __init__(self, *args, **kwargs):
0288         dict={}
0289         # What was supplied to this function
0290         dict.update(kwargs)
0291         # Parent constructor
0292         super(beginendupdaterequest,self).__init__(**dict)
0293         if self.__class__ is beginendupdaterequest:
0294             self._update(args,dict)
0295 
0296 
0297     def getfields(self):
0298         return self.__fields
0299 
0300 
0301     def _update(self, args, kwargs):
0302         super(beginendupdaterequest,self)._update(args,kwargs)
0303         keys=kwargs.keys()
0304         for key in keys:
0305             if key in self.__fields:
0306                 setattr(self, key, kwargs[key])
0307                 del kwargs[key]
0308         # Were any unrecognized kwargs passed in?
0309         if __debug__:
0310             self._complainaboutunusedargs(beginendupdaterequest,kwargs)
0311         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0312         # Make all P fields that haven't already been constructed
0313 
0314 
0315     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0316         'Writes this packet to the supplied buffer'
0317         self._bufferstartoffset=buf.getcurrentoffset()
0318         try: self.__field_command
0319         except:
0320             self.__field_command=UINT(**{'sizeinbytes': 1, 'constant': 0x29})
0321         self.__field_command.writetobuffer(buf)
0322         self.__field_beginend.writetobuffer(buf)
0323         self._bufferendoffset=buf.getcurrentoffset()
0324         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0325 
0326 
0327     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0328         'Reads this packet from the supplied buffer'
0329         self._bufferstartoffset=buf.getcurrentoffset()
0330         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0331         self.__field_command=UINT(**{'sizeinbytes': 1, 'constant': 0x29})
0332         self.__field_command.readfrombuffer(buf)
0333         self.__field_beginend=UINT(**{'sizeinbytes': 2})
0334         self.__field_beginend.readfrombuffer(buf)
0335         self._bufferendoffset=buf.getcurrentoffset()
0336 
0337 
0338     def __getfield_command(self):
0339         try: self.__field_command
0340         except:
0341             self.__field_command=UINT(**{'sizeinbytes': 1, 'constant': 0x29})
0342         return self.__field_command.getvalue()
0343 
0344     def __setfield_command(self, value):
0345         if isinstance(value,UINT):
0346             self.__field_command=value
0347         else:
0348             self.__field_command=UINT(value,**{'sizeinbytes': 1, 'constant': 0x29})
0349 
0350     def __delfield_command(self): del self.__field_command
0351 
0352     command=property(__getfield_command, __setfield_command, __delfield_command, None)
0353 
0354     def __getfield_beginend(self):
0355         return self.__field_beginend.getvalue()
0356 
0357     def __setfield_beginend(self, value):
0358         if isinstance(value,UINT):
0359             self.__field_beginend=value
0360         else:
0361             self.__field_beginend=UINT(value,**{'sizeinbytes': 2})
0362 
0363     def __delfield_beginend(self): del self.__field_beginend
0364 
0365     beginend=property(__getfield_beginend, __setfield_beginend, __delfield_beginend, None)
0366 
0367     def iscontainer(self):
0368         return True
0369 
0370     def containerelements(self):
0371         yield ('command', self.__field_command, None)
0372         yield ('beginend', self.__field_beginend, None)
0373 
0374 
0375 
0376 
0377 class beginendupdateresponse(BaseProtogenClass):
0378     __fields=['command', 'beginend']
0379 
0380     def __init__(self, *args, **kwargs):
0381         dict={}
0382         # What was supplied to this function
0383         dict.update(kwargs)
0384         # Parent constructor
0385         super(beginendupdateresponse,self).__init__(**dict)
0386         if self.__class__ is beginendupdateresponse:
0387             self._update(args,dict)
0388 
0389 
0390     def getfields(self):
0391         return self.__fields
0392 
0393 
0394     def _update(self, args, kwargs):
0395         super(beginendupdateresponse,self)._update(args,kwargs)
0396         keys=kwargs.keys()
0397         for key in keys:
0398             if key in self.__fields:
0399                 setattr(self, key, kwargs[key])
0400                 del kwargs[key]
0401         # Were any unrecognized kwargs passed in?
0402         if __debug__:
0403             self._complainaboutunusedargs(beginendupdateresponse,kwargs)
0404         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0405         # Make all P fields that haven't already been constructed
0406 
0407 
0408     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0409         'Writes this packet to the supplied buffer'
0410         self._bufferstartoffset=buf.getcurrentoffset()
0411         self.__field_command.writetobuffer(buf)
0412         self.__field_beginend.writetobuffer(buf)
0413         self._bufferendoffset=buf.getcurrentoffset()
0414         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0415 
0416 
0417     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0418         'Reads this packet from the supplied buffer'
0419         self._bufferstartoffset=buf.getcurrentoffset()
0420         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0421         self.__field_command=UINT(**{'sizeinbytes': 1})
0422         self.__field_command.readfrombuffer(buf)
0423         self.__field_beginend=UINT(**{'sizeinbytes': 2})
0424         self.__field_beginend.readfrombuffer(buf)
0425         self._bufferendoffset=buf.getcurrentoffset()
0426 
0427 
0428     def __getfield_command(self):
0429         return self.__field_command.getvalue()
0430 
0431     def __setfield_command(self, value):
0432         if isinstance(value,UINT):
0433             self.__field_command=value
0434         else:
0435             self.__field_command=UINT(value,**{'sizeinbytes': 1})
0436 
0437     def __delfield_command(self): del self.__field_command
0438 
0439     command=property(__getfield_command, __setfield_command, __delfield_command, None)
0440 
0441     def __getfield_beginend(self):
0442         return self.__field_beginend.getvalue()
0443 
0444     def __setfield_beginend(self, value):
0445         if isinstance(value,UINT):
0446             self.__field_beginend=value
0447         else:
0448             self.__field_beginend=UINT(value,**{'sizeinbytes': 2})
0449 
0450     def __delfield_beginend(self): del self.__field_beginend
0451 
0452     beginend=property(__getfield_beginend, __setfield_beginend, __delfield_beginend, None)
0453 
0454     def iscontainer(self):
0455         return True
0456 
0457     def containerelements(self):
0458         yield ('command', self.__field_command, None)
0459         yield ('beginend', self.__field_beginend, None)
0460 
0461 
0462 
0463 
0464 class statusrequest(BaseProtogenClass):
0465     __fields=['command']
0466 
0467     def __init__(self, *args, **kwargs):
0468         dict={}
0469         # What was supplied to this function
0470         dict.update(kwargs)
0471         # Parent constructor
0472         super(statusrequest,self).__init__(**dict)
0473         if self.__class__ is statusrequest:
0474             self._update(args,dict)
0475 
0476 
0477     def getfields(self):
0478         return self.__fields
0479 
0480 
0481     def _update(self, args, kwargs):
0482         super(statusrequest,self)._update(args,kwargs)
0483         keys=kwargs.keys()
0484         for key in keys:
0485             if key in self.__fields:
0486                 setattr(self, key, kwargs[key])
0487                 del kwargs[key]
0488         # Were any unrecognized kwargs passed in?
0489         if __debug__:
0490             self._complainaboutunusedargs(statusrequest,kwargs)
0491         if len(args):
0492             dict2={'sizeinbytes': 1, 'constant': 0x0c}
0493             dict2.update(kwargs)
0494             kwargs=dict2
0495             self.__field_command=UINT(*args,**dict2)
0496         # Make all P fields that haven't already been constructed
0497 
0498 
0499     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0500         'Writes this packet to the supplied buffer'
0501         self._bufferstartoffset=buf.getcurrentoffset()
0502         try: self.__field_command
0503         except:
0504             self.__field_command=UINT(**{'sizeinbytes': 1, 'constant': 0x0c})
0505         self.__field_command.writetobuffer(buf)
0506         self._bufferendoffset=buf.getcurrentoffset()
0507         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0508 
0509 
0510     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0511         'Reads this packet from the supplied buffer'
0512         self._bufferstartoffset=buf.getcurrentoffset()
0513         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0514         self.__field_command=UINT(**{'sizeinbytes': 1, 'constant': 0x0c})
0515         self.__field_command.readfrombuffer(buf)
0516         self._bufferendoffset=buf.getcurrentoffset()
0517 
0518 
0519     def __getfield_command(self):
0520         try: self.__field_command
0521         except:
0522             self.__field_command=UINT(**{'sizeinbytes': 1, 'constant': 0x0c})
0523         return self.__field_command.getvalue()
0524 
0525     def __setfield_command(self, value):
0526         if isinstance(value,UINT):
0527             self.__field_command=value
0528         else:
0529             self.__field_command=UINT(value,**{'sizeinbytes': 1, 'constant': 0x0c})
0530 
0531     def __delfield_command(self): del self.__field_command
0532 
0533     command=property(__getfield_command, __setfield_command, __delfield_command, None)
0534 
0535     def iscontainer(self):
0536         return True
0537 
0538     def containerelements(self):
0539         yield ('command', self.__field_command, None)
0540 
0541 
0542 
0543 
0544 class statusresponse(BaseProtogenClass):
0545     __fields=['readyvalue', 'command', 'dunno1', 'esn', 'flag0', 'dunno2', 'ready', 'dunno3', 'flag2', 'dunno4', 'flag3', 'unknown']
0546 
0547     def __init__(self, *args, **kwargs):
0548         dict={}
0549         # What was supplied to this function
0550         dict.update(kwargs)
0551         # Parent constructor
0552         super(statusresponse,self).__init__(**dict)
0553         if self.__class__ is statusresponse:
0554             self._update(args,dict)
0555 
0556 
0557     def getfields(self):
0558         return self.__fields
0559 
0560 
0561     def _update(self, args, kwargs):
0562         super(statusresponse,self)._update(args,kwargs)
0563         keys=kwargs.keys()
0564         for key in keys:
0565             if key in self.__fields:
0566                 setattr(self, key, kwargs[key])
0567                 del kwargs[key]
0568         # Were any unrecognized kwargs passed in?
0569         if __debug__:
0570             self._complainaboutunusedargs(statusresponse,kwargs)
0571         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0572         # Make all P fields that haven't already been constructed
0573         try: self.__field_readyvalue
0574         except:
0575             self.__field_readyvalue=UINT(**{'constant': 0x0})
0576 
0577 
0578     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0579         'Writes this packet to the supplied buffer'
0580         self._bufferstartoffset=buf.getcurrentoffset()
0581         self.__field_command.writetobuffer(buf)
0582         self.__field_dunno1.writetobuffer(buf)
0583         self.__field_esn.writetobuffer(buf)
0584         self.__field_flag0.writetobuffer(buf)
0585         self.__field_dunno2.writetobuffer(buf)
0586         self.__field_ready.writetobuffer(buf)
0587         self.__field_dunno3.writetobuffer(buf)
0588         self.__field_flag2.writetobuffer(buf)
0589         self.__field_dunno4.writetobuffer(buf)
0590         self.__field_flag3.writetobuffer(buf)
0591         self.__field_unknown.writetobuffer(buf)
0592         self._bufferendoffset=buf.getcurrentoffset()
0593         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0594 
0595 
0596     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0597         'Reads this packet from the supplied buffer'
0598         self._bufferstartoffset=buf.getcurrentoffset()
0599         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0600         self.__field_command=UINT(**{'sizeinbytes': 1})
0601         self.__field_command.readfrombuffer(buf)
0602         self.__field_dunno1=UNKNOWN(**{'sizeinbytes': 3})
0603         self.__field_dunno1.readfrombuffer(buf)
0604         self.__field_esn=UINT(**{'sizeinbytes': 4})
0605         self.__field_esn.readfrombuffer(buf)
0606         self.__field_flag0=UINT(**{'sizeinbytes': 1})
0607         self.__field_flag0.readfrombuffer(buf)
0608         self.__field_dunno2=UNKNOWN(**{'sizeinbytes': 14})
0609         self.__field_dunno2.readfrombuffer(buf)
0610         self.__field_ready=UINT(**{'sizeinbytes': 1})
0611         self.__field_ready.readfrombuffer(buf)
0612         self.__field_dunno3=UINT(**{'sizeinbytes': 1})
0613         self.__field_dunno3.readfrombuffer(buf)
0614         self.__field_flag2=UINT(**{'sizeinbytes': 1})
0615         self.__field_flag2.readfrombuffer(buf)
0616         self.__field_dunno4=UNKNOWN(**{'sizeinbytes': 6})
0617         self.__field_dunno4.readfrombuffer(buf)
0618         self.__field_flag3=UINT(**{'sizeinbytes': 1})
0619         self.__field_flag3.readfrombuffer(buf)
0620         self.__field_unknown=UNKNOWN()
0621         self.__field_unknown.readfrombuffer(buf)
0622         self._bufferendoffset=buf.getcurrentoffset()
0623 
0624 
0625     def __getfield_readyvalue(self):
0626         return self.__field_readyvalue.getvalue()
0627 
0628     def __setfield_readyvalue(self, value):
0629         if isinstance(value,UINT):
0630             self.__field_readyvalue=value
0631         else:
0632             self.__field_readyvalue=UINT(value,**{'constant': 0x0})
0633 
0634     def __delfield_readyvalue(self): del self.__field_readyvalue
0635 
0636     readyvalue=property(__getfield_readyvalue, __setfield_readyvalue, __delfield_readyvalue, None)
0637 
0638     def __getfield_command(self):
0639         return self.__field_command.getvalue()
0640 
0641     def __setfield_command(self, value):
0642         if isinstance(value,UINT):
0643             self.__field_command=value
0644         else:
0645             self.__field_command=UINT(value,**{'sizeinbytes': 1})
0646 
0647     def __delfield_command(self): del self.__field_command
0648 
0649     command=property(__getfield_command, __setfield_command, __delfield_command, None)
0650 
0651     def __getfield_dunno1(self):
0652         return self.__field_dunno1.getvalue()
0653 
0654     def __setfield_dunno1(self, value):
0655         if isinstance(value,UNKNOWN):
0656             self.__field_dunno1=value
0657         else:
0658             self.__field_dunno1=UNKNOWN(value,**{'sizeinbytes': 3})
0659 
0660     def __delfield_dunno1(self): del self.__field_dunno1
0661 
0662     dunno1=property(__getfield_dunno1, __setfield_dunno1, __delfield_dunno1, None)
0663 
0664     def __getfield_esn(self):
0665         return self.__field_esn.getvalue()
0666 
0667     def __setfield_esn(self, value):
0668         if isinstance(value,UINT):
0669             self.__field_esn=value
0670         else:
0671             self.__field_esn=UINT(value,**{'sizeinbytes': 4})
0672 
0673     def __delfield_esn(self): del self.__field_esn
0674 
0675     esn=property(__getfield_esn, __setfield_esn, __delfield_esn, None)
0676 
0677     def __getfield_flag0(self):
0678         return self.__field_flag0.getvalue()
0679 
0680     def __setfield_flag0(self, value):
0681         if isinstance(value,UINT):
0682             self.__field_flag0=value
0683         else:
0684             self.__field_flag0=UINT(value,**{'sizeinbytes': 1})
0685 
0686     def __delfield_flag0(self): del self.__field_flag0
0687 
0688     flag0=property(__getfield_flag0, __setfield_flag0, __delfield_flag0, None)
0689 
0690     def __getfield_dunno2(self):
0691         return self.__field_dunno2.getvalue()
0692 
0693     def __setfield_dunno2(self, value):
0694         if isinstance(value,UNKNOWN):
0695             self.__field_dunno2=value
0696         else:
0697             self.__field_dunno2=UNKNOWN(value,**{'sizeinbytes': 14})
0698 
0699     def __delfield_dunno2(self): del self.__field_dunno2
0700 
0701     dunno2=property(__getfield_dunno2, __setfield_dunno2, __delfield_dunno2, None)
0702 
0703     def __getfield_ready(self):
0704         return self.__field_ready.getvalue()
0705 
0706     def __setfield_ready(self, value):
0707         if isinstance(value,UINT):
0708             self.__field_ready=value
0709         else:
0710             self.__field_ready=UINT(value,**{'sizeinbytes': 1})
0711 
0712     def __delfield_ready(self): del self.__field_ready
0713 
0714     ready=property(__getfield_ready, __setfield_ready, __delfield_ready, None)
0715 
0716     def __getfield_dunno3(self):
0717         return self.__field_dunno3.getvalue()
0718 
0719     def __setfield_dunno3(self, value):
0720         if isinstance(value,UINT):
0721             self.__field_dunno3=value
0722         else:
0723             self.__field_dunno3=UINT(value,**{'sizeinbytes': 1})
0724 
0725     def __delfield_dunno3(self): del self.__field_dunno3
0726 
0727     dunno3=property(__getfield_dunno3, __setfield_dunno3, __delfield_dunno3, None)
0728 
0729     def __getfield_flag2(self):
0730         return self.__field_flag2.getvalue()
0731 
0732     def __setfield_flag2(self, value):
0733         if isinstance(value,UINT):
0734             self.__field_flag2=value
0735         else:
0736             self.__field_flag2=UINT(value,**{'sizeinbytes': 1})
0737 
0738     def __delfield_flag2(self): del self.__field_flag2
0739 
0740     flag2=property(__getfield_flag2, __setfield_flag2, __delfield_flag2, None)
0741 
0742     def __getfield_dunno4(self):
0743         return self.__field_dunno4.getvalue()
0744 
0745     def __setfield_dunno4(self, value):
0746         if isinstance(value,UNKNOWN):
0747             self.__field_dunno4=value
0748         else:
0749             self.__field_dunno4=UNKNOWN(value,**{'sizeinbytes': 6})
0750 
0751     def __delfield_dunno4(self): del self.__field_dunno4
0752 
0753     dunno4=property(__getfield_dunno4, __setfield_dunno4, __delfield_dunno4, None)
0754 
0755     def __getfield_flag3(self):
0756         return self.__field_flag3.getvalue()
0757 
0758     def __setfield_flag3(self, value):
0759         if isinstance(value,UINT):
0760             self.__field_flag3=value
0761         else:
0762             self.__field_flag3=UINT(value,**{'sizeinbytes': 1})
0763 
0764     def __delfield_flag3(self): del self.__field_flag3
0765 
0766     flag3=property(__getfield_flag3, __setfield_flag3, __delfield_flag3, None)
0767 
0768     def __getfield_unknown(self):
0769         return self.__field_unknown.getvalue()
0770 
0771     def __setfield_unknown(self, value):
0772         if isinstance(value,UNKNOWN):
0773             self.__field_unknown=value
0774         else:
0775             self.__field_unknown=UNKNOWN(value,)
0776 
0777     def __delfield_unknown(self): del self.__field_unknown
0778 
0779     unknown=property(__getfield_unknown, __setfield_unknown, __delfield_unknown, None)
0780 
0781     def iscontainer(self):
0782         return True
0783 
0784     def containerelements(self):
0785         yield ('readyvalue', self.__field_readyvalue, None)
0786         yield ('command', self.__field_command, None)
0787         yield ('dunno1', self.__field_dunno1, None)
0788         yield ('esn', self.__field_esn, None)
0789         yield ('flag0', self.__field_flag0, None)
0790         yield ('dunno2', self.__field_dunno2, None)
0791         yield ('ready', self.__field_ready, None)
0792         yield ('dunno3', self.__field_dunno3, None)
0793         yield ('flag2', self.__field_flag2, None)
0794         yield ('dunno4', self.__field_dunno4, None)
0795         yield ('flag3', self.__field_flag3, None)
0796         yield ('unknown', self.__field_unknown, None)
0797 
0798 
0799 
0800 
0801 class lockcoderequest(BaseProtogenClass):
0802     __fields=['command1', 'command2', 'pad']
0803 
0804     def __init__(self, *args, **kwargs):
0805         dict={}
0806         # What was supplied to this function
0807         dict.update(kwargs)
0808         # Parent constructor
0809         super(lockcoderequest,self).__init__(**dict)
0810         if self.__class__ is lockcoderequest:
0811             self._update(args,dict)
0812 
0813 
0814     def getfields(self):
0815         return self.__fields
0816 
0817 
0818     def _update(self, args, kwargs):
0819         super(lockcoderequest,self)._update(args,kwargs)
0820         keys=kwargs.keys()
0821         for key in keys:
0822             if key in self.__fields:
0823                 setattr(self, key, kwargs[key])
0824                 del kwargs[key]
0825         # Were any unrecognized kwargs passed in?
0826         if __debug__:
0827             self._complainaboutunusedargs(lockcoderequest,kwargs)
0828         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0829         # Make all P fields that haven't already been constructed
0830 
0831 
0832     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0833         'Writes this packet to the supplied buffer'
0834         self._bufferstartoffset=buf.getcurrentoffset()
0835         try: self.__field_command1
0836         except:
0837             self.__field_command1=UINT(**{'sizeinbytes': 1, 'constant': 0x26})
0838         self.__field_command1.writetobuffer(buf)
0839         try: self.__field_command2
0840         except:
0841             self.__field_command2=UINT(**{'sizeinbytes': 2, 'constant': 0x52})
0842         self.__field_command2.writetobuffer(buf)
0843         try: self.__field_pad
0844         except:
0845             self.__field_pad=UNKNOWN(**{'sizeinbytes': 130})
0846         self.__field_pad.writetobuffer(buf)
0847         self._bufferendoffset=buf.getcurrentoffset()
0848         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0849 
0850 
0851     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0852         'Reads this packet from the supplied buffer'
0853         self._bufferstartoffset=buf.getcurrentoffset()
0854         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0855         self.__field_command1=UINT(**{'sizeinbytes': 1, 'constant': 0x26})
0856         self.__field_command1.readfrombuffer(buf)
0857         self.__field_command2=UINT(**{'sizeinbytes': 2, 'constant': 0x52})
0858         self.__field_command2.readfrombuffer(buf)
0859         self.__field_pad=UNKNOWN(**{'sizeinbytes': 130})
0860         self.__field_pad.readfrombuffer(buf)
0861         self._bufferendoffset=buf.getcurrentoffset()
0862 
0863 
0864     def __getfield_command1(self):
0865         try: self.__field_command1
0866         except:
0867             self.__field_command1=UINT(**{'sizeinbytes': 1, 'constant': 0x26})
0868         return self.__field_command1.getvalue()
0869 
0870     def __setfield_command1(self, value):
0871         if isinstance(value,UINT):
0872             self.__field_command1=value
0873         else:
0874             self.__field_command1=UINT(value,**{'sizeinbytes': 1, 'constant': 0x26})
0875 
0876     def __delfield_command1(self): del self.__field_command1
0877 
0878     command1=property(__getfield_command1, __setfield_command1, __delfield_command1, None)
0879 
0880     def __getfield_command2(self):
0881         try: self.__field_command2
0882         except:
0883             self.__field_command2=UINT(**{'sizeinbytes': 2, 'constant': 0x52})
0884         return self.__field_command2.getvalue()
0885 
0886     def __setfield_command2(self, value):
0887         if isinstance(value,UINT):
0888             self.__field_command2=value
0889         else:
0890             self.__field_command2=UINT(value,**{'sizeinbytes': 2, 'constant': 0x52})
0891 
0892     def __delfield_command2(self): del self.__field_command2
0893 
0894     command2=property(__getfield_command2, __setfield_command2, __delfield_command2, None)
0895 
0896     def __getfield_pad(self):
0897         try: self.__field_pad
0898         except:
0899             self.__field_pad=UNKNOWN(**{'sizeinbytes': 130})
0900         return self.__field_pad.getvalue()
0901 
0902     def __setfield_pad(self, value):
0903         if isinstance(value,UNKNOWN):
0904             self.__field_pad=value
0905         else:
0906             self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 130})
0907 
0908     def __delfield_pad(self): del self.__field_pad
0909 
0910     pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None)
0911 
0912     def iscontainer(self):
0913         return True
0914 
0915     def containerelements(self):
0916         yield ('command1', self.__field_command1, None)
0917         yield ('command2', self.__field_command2, None)
0918         yield ('pad', self.__field_pad, None)
0919 
0920 
0921 
0922 
0923 class lockcoderesponse(BaseProtogenClass):
0924     __fields=['command1', 'command2', 'lockcode', 'pad']
0925 
0926     def __init__(self, *args, **kwargs):
0927         dict={}
0928         # What was supplied to this function
0929         dict.update(kwargs)
0930         # Parent constructor
0931         super(lockcoderesponse,self).__init__(**dict)
0932         if self.__class__ is lockcoderesponse:
0933             self._update(args,dict)
0934 
0935 
0936     def getfields(self):
0937         return self.__fields
0938 
0939 
0940     def _update(self, args, kwargs):
0941         super(lockcoderesponse,self)._update(args,kwargs)
0942         keys=kwargs.keys()
0943         for key in keys:
0944             if key in self.__fields:
0945                 setattr(self, key, kwargs[key])
0946                 del kwargs[key]
0947         # Were any unrecognized kwargs passed in?
0948         if __debug__:
0949             self._complainaboutunusedargs(lockcoderesponse,kwargs)
0950         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0951         # Make all P fields that haven't already been constructed
0952 
0953 
0954     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0955         'Writes this packet to the supplied buffer'
0956         self._bufferstartoffset=buf.getcurrentoffset()
0957         try: self.__field_command1
0958         except:
0959             self.__field_command1=UINT(**{'sizeinbytes': 1, 'constant': 0x26})
0960         self.__field_command1.writetobuffer(buf)
0961         try: self.__field_command2
0962         except:
0963             self.__field_command2=UINT(**{'sizeinbytes': 2, 'constant': 0x52})
0964         self.__field_command2.writetobuffer(buf)
0965         self.__field_lockcode.writetobuffer(buf)
0966         self.__field_pad.writetobuffer(buf)
0967         self._bufferendoffset=buf.getcurrentoffset()
0968         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0969 
0970 
0971     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0972         'Reads this packet from the supplied buffer'
0973         self._bufferstartoffset=buf.getcurrentoffset()
0974         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0975         self.__field_command1=UINT(**{'sizeinbytes': 1, 'constant': 0x26})
0976         self.__field_command1.readfrombuffer(buf)
0977         self.__field_command2=UINT(**{'sizeinbytes': 2, 'constant': 0x52})
0978         self.__field_command2.readfrombuffer(buf)
0979         self.__field_lockcode=USTRING(**{'sizeinbytes': 4, 'raiseonunterminatedread': False})
0980         self.__field_lockcode.readfrombuffer(buf)
0981         self.__field_pad=UNKNOWN()
0982         self.__field_pad.readfrombuffer(buf)
0983         self._bufferendoffset=buf.getcurrentoffset()
0984 
0985 
0986     def __getfield_command1(self):
0987         try: self.__field_command1
0988         except:
0989             self.__field_command1=UINT(**{'sizeinbytes': 1, 'constant': 0x26})
0990         return self.__field_command1.getvalue()
0991 
0992     def __setfield_command1(self, value):
0993         if isinstance(value,UINT):
0994             self.__field_command1=value
0995         else:
0996             self.__field_command1=UINT(value,**{'sizeinbytes': 1, 'constant': 0x26})
0997 
0998     def __delfield_command1(self): del self.__field_command1
0999 
1000     command1=property(__getfield_command1, __setfield_command1, __delfield_command1, None)
1001 
1002     def __getfield_command2(self):
1003         try: self.__field_command2
1004         except:
1005             self.__field_command2=UINT(**{'sizeinbytes': 2, 'constant': 0x52})
1006         return self.__field_command2.getvalue()
1007 
1008     def __setfield_command2(self, value):
1009         if isinstance(value,UINT):
1010             self.__field_command2=value
1011         else:
1012             self.__field_command2=UINT(value,**{'sizeinbytes': 2, 'constant': 0x52})
1013 
1014     def __delfield_command2(self): del self.__field_command2
1015 
1016     command2=property(__getfield_command2, __setfield_command2, __delfield_command2, None)
1017 
1018     def __getfield_lockcode(self):
1019         return self.__field_lockcode.getvalue()
1020 
1021     def __setfield_lockcode(self, value):
1022         if isinstance(value,USTRING):
1023             self.__field_lockcode=value
1024         else:
1025             self.__field_lockcode=USTRING(value,**{'sizeinbytes': 4, 'raiseonunterminatedread': False})
1026 
1027     def __delfield_lockcode(self): del self.__field_lockcode
1028 
1029     lockcode=property(__getfield_lockcode, __setfield_lockcode, __delfield_lockcode, None)
1030 
1031     def __getfield_pad(self):
1032         return self.__field_pad.getvalue()
1033 
1034     def __setfield_pad(self, value):
1035         if isinstance(value,UNKNOWN):
1036             self.__field_pad=value
1037         else:
1038             self.__field_pad=UNKNOWN(value,)
1039 
1040     def __delfield_pad(self): del self.__field_pad
1041 
1042     pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None)
1043 
1044     def iscontainer(self):
1045         return True
1046 
1047     def containerelements(self):
1048         yield ('command1', self.__field_command1, None)
1049         yield ('command2', self.__field_command2, None)
1050         yield ('lockcode', self.__field_lockcode, None)
1051         yield ('pad', self.__field_pad, None)
1052 
1053 
1054 
1055 
1056 class sanyofirmwarerequest(BaseProtogenClass):
1057     __fields=['command']
1058 
1059     def __init__(self, *args, **kwargs):
1060         dict={}
1061         # What was supplied to this function
1062         dict.update(kwargs)
1063         # Parent constructor
1064         super(sanyofirmwarerequest,self).__init__(**dict)
1065         if self.__class__ is sanyofirmwarerequest:
1066             self._update(args,dict)
1067 
1068 
1069     def getfields(self):
1070         return self.__fields
1071 
1072 
1073     def _update(self, args, kwargs):
1074         super(sanyofirmwarerequest,self)._update(args,kwargs)
1075         keys=kwargs.keys()
1076         for key in keys:
1077             if key in self.__fields:
1078                 setattr(self, key, kwargs[key])
1079                 del kwargs[key]
1080         # Were any unrecognized kwargs passed in?
1081         if __debug__:
1082             self._complainaboutunusedargs(sanyofirmwarerequest,kwargs)
1083         if len(args):
1084             dict2={'sizeinbytes': 1, 'constant': 0x00}
1085             dict2.update(kwargs)
1086             kwargs=dict2
1087             self.__field_command=UINT(*args,**dict2)
1088         # Make all P fields that haven't already been constructed
1089 
1090 
1091     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1092         'Writes this packet to the supplied buffer'
1093         self._bufferstartoffset=buf.getcurrentoffset()
1094         try: self.__field_command
1095         except:
1096             self.__field_command=UINT(**{'sizeinbytes': 1, 'constant': 0x00})
1097         self.__field_command.writetobuffer(buf)
1098         self._bufferendoffset=buf.getcurrentoffset()
1099         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1100 
1101 
1102     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1103         'Reads this packet from the supplied buffer'
1104         self._bufferstartoffset=buf.getcurrentoffset()
1105         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1106         self.__field_command=UINT(**{'sizeinbytes': 1, 'constant': 0x00})
1107         self.__field_command.readfrombuffer(buf)
1108         self._bufferendoffset=buf.getcurrentoffset()
1109 
1110 
1111     def __getfield_command(self):
1112         try: self.__field_command
1113         except:
1114             self.__field_command=UINT(**{'sizeinbytes': 1, 'constant': 0x00})
1115         return self.__field_command.getvalue()
1116 
1117     def __setfield_command(self, value):
1118         if isinstance(value,UINT):
1119             self.__field_command=value
1120         else:
1121             self.__field_command=UINT(value,**{'sizeinbytes': 1, 'constant': 0x00})
1122 
1123     def __delfield_command(self): del self.__field_command
1124 
1125     command=property(__getfield_command, __setfield_command, __delfield_command, None)
1126 
1127     def iscontainer(self):
1128         return True
1129 
1130     def containerelements(self):
1131         yield ('command', self.__field_command, None)
1132 
1133 
1134 
1135 
1136 class sanyofirmwareresponse(BaseProtogenClass):
1137     __fields=['command', 'date1', 'time1', 'date2', 'time2', 'string1', 'dunno1', 'date3', 'dunno2', 'time3', 'dunno3', 'firmware', 'pad', 'phonemodel', 'prl']
1138 
1139     def __init__(self, *args, **kwargs):
1140         dict={}
1141         # What was supplied to this function
1142         dict.update(kwargs)
1143         # Parent constructor
1144         super(sanyofirmwareresponse,self).__init__(**dict)
1145         if self.__class__ is sanyofirmwareresponse:
1146             self._update(args,dict)
1147 
1148 
1149     def getfields(self):
1150         return self.__fields
1151 
1152 
1153     def _update(self, args, kwargs):
1154         super(sanyofirmwareresponse,self)._update(args,kwargs)
1155         keys=kwargs.keys()
1156         for key in keys:
1157             if key in self.__fields:
1158                 setattr(self, key, kwargs[key])
1159                 del kwargs[key]
1160         # Were any unrecognized kwargs passed in?
1161         if __debug__:
1162             self._complainaboutunusedargs(sanyofirmwareresponse,kwargs)
1163         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
1164         # Make all P fields that haven't already been constructed
1165 
1166 
1167     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1168         'Writes this packet to the supplied buffer'
1169         self._bufferstartoffset=buf.getcurrentoffset()
1170         self.__field_command.writetobuffer(buf)
1171         self.__field_date1.writetobuffer(buf)
1172         self.__field_time1.writetobuffer(buf)
1173         self.__field_date2.writetobuffer(buf)
1174         self.__field_time2.writetobuffer(buf)
1175         self.__field_string1.writetobuffer(buf)
1176         self.__field_dunno1.writetobuffer(buf)
1177         self.__field_date3.writetobuffer(buf)
1178         self.__field_dunno2.writetobuffer(buf)
1179         self.__field_time3.writetobuffer(buf)
1180         self.__field_dunno3.writetobuffer(buf)
1181         self.__field_firmware.writetobuffer(buf)
1182         self.__field_pad.writetobuffer(buf)
1183         self.__field_phonemodel.writetobuffer(buf)
1184         self.__field_prl.writetobuffer(buf)
1185         self._bufferendoffset=buf.getcurrentoffset()
1186         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1187 
1188 
1189     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1190         'Reads this packet from the supplied buffer'
1191         self._bufferstartoffset=buf.getcurrentoffset()
1192         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1193         self.__field_command=UINT(**{'sizeinbytes': 1})
1194         self.__field_command.readfrombuffer(buf)
1195         self.__field_date1=USTRING(**{'sizeinbytes': 11, 'terminator': None})
1196         self.__field_date1.readfrombuffer(buf)
1197         self.__field_time1=USTRING(**{'sizeinbytes': 8, 'terminator': None})
1198         self.__field_time1.readfrombuffer(buf)
1199         self.__field_date2=USTRING(**{'sizeinbytes': 11, 'terminator': None})
1200         self.__field_date2.readfrombuffer(buf)
1201         self.__field_time2=USTRING(**{'sizeinbytes': 8, 'terminator': None})
1202         self.__field_time2.readfrombuffer(buf)
1203         self.__field_string1=USTRING(**{'sizeinbytes': 8, 'terminator': None})
1204         self.__field_string1.readfrombuffer(buf)
1205         self.__field_dunno1=UNKNOWN(**{'sizeinbytes': 1})
1206         self.__field_dunno1.readfrombuffer(buf)
1207         self.__field_date3=USTRING(**{'sizeinbytes': 11, 'terminator': None})
1208         self.__field_date3.readfrombuffer(buf)
1209         self.__field_dunno2=UNKNOWN(**{'sizeinbytes': 1})
1210         self.__field_dunno2.readfrombuffer(buf)
1211         self.__field_time3=USTRING(**{'sizeinbytes': 8, 'terminator': None})
1212         self.__field_time3.readfrombuffer(buf)
1213         self.__field_dunno3=UNKNOWN(**{'sizeinbytes': 11})
1214         self.__field_dunno3.readfrombuffer(buf)
1215         self.__field_firmware=USTRING(**{'sizeinbytes': 10, 'terminator': None})
1216         self.__field_firmware.readfrombuffer(buf)
1217         self.__field_pad=UNKNOWN(**{'sizeinbytes': 7})
1218         self.__field_pad.readfrombuffer(buf)
1219         self.__field_phonemodel=USTRING(**{'sizeinbytes': 16, 'terminator': None})
1220         self.__field_phonemodel.readfrombuffer(buf)
1221         self.__field_prl=USTRING(**{'sizeinbytes': 5, 'terminator': None})
1222         self.__field_prl.readfrombuffer(buf)
1223         self._bufferendoffset=buf.getcurrentoffset()
1224 
1225 
1226     def __getfield_command(self):
1227         return self.__field_command.getvalue()
1228 
1229     def __setfield_command(self, value):
1230         if isinstance(value,UINT):
1231             self.__field_command=value
1232         else:
1233             self.__field_command=UINT(value,**{'sizeinbytes': 1})
1234 
1235     def __delfield_command(self): del self.__field_command
1236 
1237     command=property(__getfield_command, __setfield_command, __delfield_command, None)
1238 
1239     def __getfield_date1(self):
1240         return self.__field_date1.getvalue()
1241 
1242     def __setfield_date1(self, value):
1243         if isinstance(value,USTRING):
1244             self.__field_date1=value
1245         else:
1246             self.__field_date1=USTRING(value,**{'sizeinbytes': 11, 'terminator': None})
1247 
1248     def __delfield_date1(self): del self.__field_date1
1249 
1250     date1=property(__getfield_date1, __setfield_date1, __delfield_date1, None)
1251 
1252     def __getfield_time1(self):
1253         return self.__field_time1.getvalue()
1254 
1255     def __setfield_time1(self, value):
1256         if isinstance(value,USTRING):
1257             self.__field_time1=value
1258         else:
1259             self.__field_time1=USTRING(value,**{'sizeinbytes': 8, 'terminator': None})
1260 
1261     def __delfield_time1(self): del self.__field_time1
1262 
1263     time1=property(__getfield_time1, __setfield_time1, __delfield_time1, None)
1264 
1265     def __getfield_date2(self):
1266         return self.__field_date2.getvalue()
1267 
1268     def __setfield_date2(self, value):
1269         if isinstance(value,USTRING):
1270             self.__field_date2=value
1271         else:
1272             self.__field_date2=USTRING(value,**{'sizeinbytes': 11, 'terminator': None})
1273 
1274     def __delfield_date2(self): del self.__field_date2
1275 
1276     date2=property(__getfield_date2, __setfield_date2, __delfield_date2, None)
1277 
1278     def __getfield_time2(self):
1279         return self.__field_time2.getvalue()
1280 
1281     def __setfield_time2(self, value):
1282         if isinstance(value,USTRING):
1283             self.__field_time2=value
1284         else:
1285             self.__field_time2=USTRING(value,**{'sizeinbytes': 8, 'terminator': None})
1286 
1287     def __delfield_time2(self): del self.__field_time2
1288 
1289     time2=property(__getfield_time2, __setfield_time2, __delfield_time2, None)
1290 
1291     def __getfield_string1(self):
1292         return self.__field_string1.getvalue()
1293 
1294     def __setfield_string1(self, value):
1295         if isinstance(value,USTRING):
1296             self.__field_string1=value
1297         else:
1298             self.__field_string1=USTRING(value,**{'sizeinbytes': 8, 'terminator': None})
1299 
1300     def __delfield_string1(self): del self.__field_string1
1301 
1302     string1=property(__getfield_string1, __setfield_string1, __delfield_string1, None)
1303 
1304     def __getfield_dunno1(self):
1305         return self.__field_dunno1.getvalue()
1306 
1307     def __setfield_dunno1(self, value):
1308         if isinstance(value,UNKNOWN):
1309             self.__field_dunno1=value
1310         else:
1311             self.__field_dunno1=UNKNOWN(value,**{'sizeinbytes': 1})
1312 
1313     def __delfield_dunno1(self): del self.__field_dunno1
1314 
1315     dunno1=property(__getfield_dunno1, __setfield_dunno1, __delfield_dunno1, None)
1316 
1317     def __getfield_date3(self):
1318         return self.__field_date3.getvalue()
1319 
1320     def __setfield_date3(self, value):
1321         if isinstance(value,USTRING):
1322             self.__field_date3=value
1323         else:
1324             self.__field_date3=USTRING(value,**{'sizeinbytes': 11, 'terminator': None})
1325 
1326     def __delfield_date3(self): del self.__field_date3
1327 
1328     date3=property(__getfield_date3, __setfield_date3, __delfield_date3, None)
1329 
1330     def __getfield_dunno2(self):
1331         return self.__field_dunno2.getvalue()
1332 
1333     def __setfield_dunno2(self, value):
1334         if isinstance(value,UNKNOWN):
1335             self.__field_dunno2=value
1336         else:
1337             self.__field_dunno2=UNKNOWN(value,**{'sizeinbytes': 1})
1338 
1339     def __delfield_dunno2(self): del self.__field_dunno2
1340 
1341     dunno2=property(__getfield_dunno2, __setfield_dunno2, __delfield_dunno2, None)
1342 
1343     def __getfield_time3(self):
1344         return self.__field_time3.getvalue()
1345 
1346     def __setfield_time3(self, value):
1347         if isinstance(value,USTRING):
1348             self.__field_time3=value
1349         else:
1350             self.__field_time3=USTRING(value,**{'sizeinbytes': 8, 'terminator': None})
1351 
1352     def __delfield_time3(self): del self.__field_time3
1353 
1354     time3=property(__getfield_time3, __setfield_time3, __delfield_time3, None)
1355 
1356     def __getfield_dunno3(self):
1357         return self.__field_dunno3.getvalue()
1358 
1359     def __setfield_dunno3(self, value):
1360         if isinstance(value,UNKNOWN):
1361             self.__field_dunno3=value
1362         else:
1363             self.__field_dunno3=UNKNOWN(value,**{'sizeinbytes': 11})
1364 
1365     def __delfield_dunno3(self): del self.__field_dunno3
1366 
1367     dunno3=property(__getfield_dunno3, __setfield_dunno3, __delfield_dunno3, None)
1368 
1369     def __getfield_firmware(self):
1370         return self.__field_firmware.getvalue()
1371 
1372     def __setfield_firmware(self, value):
1373         if isinstance(value,USTRING):
1374             self.__field_firmware=value
1375         else:
1376             self.__field_firmware=USTRING(value,**{'sizeinbytes': 10, 'terminator': None})
1377 
1378     def __delfield_firmware(self): del self.__field_firmware
1379 
1380     firmware=property(__getfield_firmware, __setfield_firmware, __delfield_firmware, None)
1381 
1382     def __getfield_pad(self):
1383         return self.__field_pad.getvalue()
1384 
1385     def __setfield_pad(self, value):
1386         if isinstance(value,UNKNOWN):
1387             self.__field_pad=value
1388         else:
1389             self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 7})
1390 
1391     def __delfield_pad(self): del self.__field_pad
1392 
1393     pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None)
1394 
1395     def __getfield_phonemodel(self):
1396         return self.__field_phonemodel.getvalue()
1397 
1398     def __setfield_phonemodel(self, value):
1399         if isinstance(value,USTRING):
1400             self.__field_phonemodel=value
1401         else:
1402             self.__field_phonemodel=USTRING(value,**{'sizeinbytes': 16, 'terminator': None})
1403 
1404     def __delfield_phonemodel(self): del self.__field_phonemodel
1405 
1406     phonemodel=property(__getfield_phonemodel, __setfield_phonemodel, __delfield_phonemodel, None)
1407 
1408     def __getfield_prl(self):
1409         return self.__field_prl.getvalue()
1410 
1411     def __setfield_prl(self, value):
1412         if isinstance(value,USTRING):
1413             self.__field_prl=value
1414         else:
1415             self.__field_prl=USTRING(value,**{'sizeinbytes': 5, 'terminator': None})
1416 
1417     def __delfield_prl(self): del self.__field_prl
1418 
1419     prl=property(__getfield_prl, __setfield_prl, __delfield_prl, None)
1420 
1421     def iscontainer(self):
1422         return True
1423 
1424     def containerelements(self):
1425         yield ('command', self.__field_command, None)
1426         yield ('date1', self.__field_date1, None)
1427         yield ('time1', self.__field_time1, None)
1428         yield ('date2', self.__field_date2, None)
1429         yield ('time2', self.__field_time2, None)
1430         yield ('string1', self.__field_string1, None)
1431         yield ('dunno1', self.__field_dunno1, None)
1432         yield ('date3', self.__field_date3, None)
1433         yield ('dunno2', self.__field_dunno2, None)
1434         yield ('time3', self.__field_time3, None)
1435         yield ('dunno3', self.__field_dunno3, None)
1436         yield ('firmware', self.__field_firmware, None)
1437         yield ('pad', self.__field_pad, None)
1438         yield ('phonemodel', self.__field_phonemodel, None)
1439         yield ('prl', self.__field_prl, None)
1440 
1441 
1442 
1443 
1444 class reconditionedrequest(BaseProtogenClass):
1445     __fields=['command1', 'command2', 'pad']
1446 
1447     def __init__(self, *args, **kwargs):
1448         dict={}
1449         # What was supplied to this function
1450         dict.update(kwargs)
1451         # Parent constructor
1452         super(reconditionedrequest,self).__init__(**dict)
1453         if self.__class__ is reconditionedrequest:
1454             self._update(args,dict)
1455 
1456 
1457     def getfields(self):
1458         return self.__fields
1459 
1460 
1461     def _update(self, args, kwargs):
1462         super(reconditionedrequest,self)._update(args,kwargs)
1463         keys=kwargs.keys()
1464         for key in keys:
1465             if key in self.__fields:
1466                 setattr(self, key, kwargs[key])
1467                 del kwargs[key]
1468         # Were any unrecognized kwargs passed in?
1469         if __debug__:
1470             self._complainaboutunusedargs(reconditionedrequest,kwargs)
1471         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
1472         # Make all P fields that haven't already been constructed
1473 
1474 
1475     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1476         'Writes this packet to the supplied buffer'
1477         self._bufferstartoffset=buf.getcurrentoffset()
1478         try: self.__field_command1
1479         except:
1480             self.__field_command1=UINT(**{'sizeinbytes': 1, 'constant': 0x26})
1481         self.__field_command1.writetobuffer(buf)
1482         try: self.__field_command2
1483         except:
1484             self.__field_command2=UINT(**{'sizeinbytes': 2, 'constant': 0x0c1b})
1485         self.__field_command2.writetobuffer(buf)
1486         try: self.__field_pad
1487         except:
1488             self.__field_pad=UNKNOWN(**{'sizeinbytes': 130})
1489         self.__field_pad.writetobuffer(buf)
1490         self._bufferendoffset=buf.getcurrentoffset()
1491         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1492 
1493 
1494     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1495         'Reads this packet from the supplied buffer'
1496         self._bufferstartoffset=buf.getcurrentoffset()
1497         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1498         self.__field_command1=UINT(**{'sizeinbytes': 1, 'constant': 0x26})
1499         self.__field_command1.readfrombuffer(buf)
1500         self.__field_command2=UINT(**{'sizeinbytes': 2, 'constant': 0x0c1b})
1501         self.__field_command2.readfrombuffer(buf)
1502         self.__field_pad=UNKNOWN(**{'sizeinbytes': 130})
1503         self.__field_pad.readfrombuffer(buf)
1504         self._bufferendoffset=buf.getcurrentoffset()
1505 
1506 
1507     def __getfield_command1(self):
1508         try: self.__field_command1
1509         except:
1510             self.__field_command1=UINT(**{'sizeinbytes': 1, 'constant': 0x26})
1511         return self.__field_command1.getvalue()
1512 
1513     def __setfield_command1(self, value):
1514         if isinstance(value,UINT):
1515             self.__field_command1=value
1516         else:
1517             self.__field_command1=UINT(value,**{'sizeinbytes': 1, 'constant': 0x26})
1518 
1519     def __delfield_command1(self): del self.__field_command1
1520 
1521     command1=property(__getfield_command1, __setfield_command1, __delfield_command1, None)
1522 
1523     def __getfield_command2(self):
1524         try: self.__field_command2
1525         except:
1526             self.__field_command2=UINT(**{'sizeinbytes': 2, 'constant': 0x0c1b})
1527         return self.__field_command2.getvalue()
1528 
1529     def __setfield_command2(self, value):
1530         if isinstance(value,UINT):
1531             self.__field_command2=value
1532         else:
1533             self.__field_command2=UINT(value,**{'sizeinbytes': 2, 'constant': 0x0c1b})
1534 
1535     def __delfield_command2(self): del self.__field_command2
1536 
1537     command2=property(__getfield_command2, __setfield_command2, __delfield_command2, None)
1538 
1539     def __getfield_pad(self):
1540         try: self.__field_pad
1541         except:
1542             self.__field_pad=UNKNOWN(**{'sizeinbytes': 130})
1543         return self.__field_pad.getvalue()
1544 
1545     def __setfield_pad(self, value):
1546         if isinstance(value,UNKNOWN):
1547             self.__field_pad=value
1548         else:
1549             self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 130})
1550 
1551     def __delfield_pad(self): del self.__field_pad
1552 
1553     pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None)
1554 
1555     def iscontainer(self):
1556         return True
1557 
1558     def containerelements(self):
1559         yield ('command1', self.__field_command1, None)
1560         yield ('command2', self.__field_command2, None)
1561         yield ('pad', self.__field_pad, None)
1562 
1563 
1564 
1565 
1566 class reconditionedresponse(BaseProtogenClass):
1567     __fields=['command1', 'command2', 'reconditioned', 'pad']
1568 
1569     def __init__(self, *args, **kwargs):
1570         dict={}
1571         # What was supplied to this function
1572         dict.update(kwargs)
1573         # Parent constructor
1574         super(reconditionedresponse,self).__init__(**dict)
1575         if self.__class__ is reconditionedresponse:
1576             self._update(args,dict)
1577 
1578 
1579     def getfields(self):
1580         return self.__fields
1581 
1582 
1583     def _update(self, args, kwargs):
1584         super(reconditionedresponse,self)._update(args,kwargs)
1585         keys=kwargs.keys()
1586         for key in keys:
1587             if key in self.__fields:
1588                 setattr(self, key, kwargs[key])
1589                 del kwargs[key]
1590         # Were any unrecognized kwargs passed in?
1591         if __debug__:
1592             self._complainaboutunusedargs(reconditionedresponse,kwargs)
1593         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
1594         # Make all P fields that haven't already been constructed
1595 
1596 
1597     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1598         'Writes this packet to the supplied buffer'
1599         self._bufferstartoffset=buf.getcurrentoffset()
1600         self.__field_command1.writetobuffer(buf)
1601         self.__field_command2.writetobuffer(buf)
1602         self.__field_reconditioned.writetobuffer(buf)
1603         self.__field_pad.writetobuffer(buf)
1604         self._bufferendoffset=buf.getcurrentoffset()
1605         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1606 
1607 
1608     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1609         'Reads this packet from the supplied buffer'
1610         self._bufferstartoffset=buf.getcurrentoffset()
1611         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1612         self.__field_command1=UINT(**{'sizeinbytes': 1, 'constant': 0x26})
1613         self.__field_command1.readfrombuffer(buf)
1614         self.__field_command2=UINT(**{'sizeinbytes': 2, 'constant': 0x0c1b})
1615         self.__field_command2.readfrombuffer(buf)
1616         self.__field_reconditioned=UINT(**{'sizeinbytes': 1})
1617         self.__field_reconditioned.readfrombuffer(buf)
1618         self.__field_pad=UNKNOWN()
1619         self.__field_pad.readfrombuffer(buf)
1620         self._bufferendoffset=buf.getcurrentoffset()
1621 
1622 
1623     def __getfield_command1(self):
1624         return self.__field_command1.getvalue()
1625 
1626     def __setfield_command1(self, value):
1627         if isinstance(value,UINT):
1628             self.__field_command1=value
1629         else:
1630             self.__field_command1=UINT(value,**{'sizeinbytes': 1, 'constant': 0x26})
1631 
1632     def __delfield_command1(self): del self.__field_command1
1633 
1634     command1=property(__getfield_command1, __setfield_command1, __delfield_command1, None)
1635 
1636     def __getfield_command2(self):
1637         return self.__field_command2.getvalue()
1638 
1639     def __setfield_command2(self, value):
1640         if isinstance(value,UINT):
1641             self.__field_command2=value
1642         else:
1643             self.__field_command2=UINT(value,**{'sizeinbytes': 2, 'constant': 0x0c1b})
1644 
1645     def __delfield_command2(self): del self.__field_command2
1646 
1647     command2=property(__getfield_command2, __setfield_command2, __delfield_command2, None)
1648 
1649     def __getfield_reconditioned(self):
1650         return self.__field_reconditioned.getvalue()
1651 
1652     def __setfield_reconditioned(self, value):
1653         if isinstance(value,UINT):
1654             self.__field_reconditioned=value
1655         else:
1656             self.__field_reconditioned=UINT(value,**{'sizeinbytes': 1})
1657 
1658     def __delfield_reconditioned(self): del self.__field_reconditioned
1659 
1660     reconditioned=property(__getfield_reconditioned, __setfield_reconditioned, __delfield_reconditioned, None)
1661 
1662     def __getfield_pad(self):
1663         return self.__field_pad.getvalue()
1664 
1665     def __setfield_pad(self, value):
1666         if isinstance(value,UNKNOWN):
1667             self.__field_pad=value
1668         else:
1669             self.__field_pad=UNKNOWN(value,)
1670 
1671     def __delfield_pad(self): del self.__field_pad
1672 
1673     pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None)
1674 
1675     def iscontainer(self):
1676         return True
1677 
1678     def containerelements(self):
1679         yield ('command1', self.__field_command1, None)
1680         yield ('command2', self.__field_command2, None)
1681         yield ('reconditioned', self.__field_reconditioned, None)
1682         yield ('pad', self.__field_pad, None)
1683 
1684 
1685 
1686 
1687 class phonenumberrequest(BaseProtogenClass):
1688     __fields=['command1', 'command2', 'zero', 'pad']
1689 
1690     def __init__(self, *args, **kwargs):
1691         dict={}
1692         # What was supplied to this function
1693         dict.update(kwargs)
1694         # Parent constructor
1695         super(phonenumberrequest,self).__init__(**dict)
1696         if self.__class__ is phonenumberrequest:
1697             self._update(args,dict)
1698 
1699 
1700     def getfields(self):
1701         return self.__fields
1702 
1703 
1704     def _update(self, args, kwargs):
1705         super(phonenumberrequest,self)._update(args,kwargs)
1706         keys=kwargs.keys()
1707         for key in keys:
1708             if key in self.__fields:
1709                 setattr(self, key, kwargs[key])
1710                 del kwargs[key]
1711         # Were any unrecognized kwargs passed in?
1712         if __debug__:
1713             self._complainaboutunusedargs(phonenumberrequest,kwargs)
1714         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
1715         # Make all P fields that haven't already been constructed
1716 
1717 
1718     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1719         'Writes this packet to the supplied buffer'
1720         self._bufferstartoffset=buf.getcurrentoffset()
1721         try: self.__field_command1
1722         except:
1723             self.__field_command1=UINT(**{'sizeinbytes': 1, 'constant': 0x26})
1724         self.__field_command1.writetobuffer(buf)
1725         try: self.__field_command2
1726         except:
1727             self.__field_command2=UINT(**{'sizeinbytes': 1, 'constant': 0xb2})
1728         self.__field_command2.writetobuffer(buf)
1729         try: self.__field_zero
1730         except:
1731             self.__field_zero=UINT(**{'sizeinbytes': 1, 'constant': 0})
1732         self.__field_zero.writetobuffer(buf)
1733         try: self.__field_pad
1734         except:
1735             self.__field_pad=UNKNOWN(**{'sizeinbytes': 130})
1736         self.__field_pad.writetobuffer(buf)
1737         self._bufferendoffset=buf.getcurrentoffset()
1738         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1739 
1740 
1741     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1742         'Reads this packet from the supplied buffer'
1743         self._bufferstartoffset=buf.getcurrentoffset()
1744         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1745         self.__field_command1=UINT(**{'sizeinbytes': 1, 'constant': 0x26})
1746         self.__field_command1.readfrombuffer(buf)
1747         self.__field_command2=UINT(**{'sizeinbytes': 1, 'constant': 0xb2})
1748         self.__field_command2.readfrombuffer(buf)
1749         self.__field_zero=UINT(**{'sizeinbytes': 1, 'constant': 0})
1750         self.__field_zero.readfrombuffer(buf)
1751         self.__field_pad=UNKNOWN(**{'sizeinbytes': 130})
1752         self.__field_pad.readfrombuffer(buf)
1753         self._bufferendoffset=buf.getcurrentoffset()
1754 
1755 
1756     def __getfield_command1(self):
1757         try: self.__field_command1
1758         except:
1759             self.__field_command1=UINT(**{'sizeinbytes': 1, 'constant': 0x26})
1760         return self.__field_command1.getvalue()
1761 
1762     def __setfield_command1(self, value):
1763         if isinstance(value,UINT):
1764             self.__field_command1=value
1765         else:
1766             self.__field_command1=UINT(value,**{'sizeinbytes': 1, 'constant': 0x26})
1767 
1768     def __delfield_command1(self): del self.__field_command1
1769 
1770     command1=property(__getfield_command1, __setfield_command1, __delfield_command1, None)
1771 
1772     def __getfield_command2(self):
1773         try: self.__field_command2
1774         except:
1775             self.__field_command2=UINT(**{'sizeinbytes': 1, 'constant': 0xb2})
1776         return self.__field_command2.getvalue()
1777 
1778     def __setfield_command2(self, value):
1779         if isinstance(value,UINT):
1780             self.__field_command2=value
1781         else:
1782             self.__field_command2=UINT(value,**{'sizeinbytes': 1, 'constant': 0xb2})
1783 
1784     def __delfield_command2(self): del self.__field_command2
1785 
1786     command2=property(__getfield_command2, __setfield_command2, __delfield_command2, None)
1787 
1788     def __getfield_zero(self):
1789         try: self.__field_zero
1790         except:
1791             self.__field_zero=UINT(**{'sizeinbytes': 1, 'constant': 0})
1792         return self.__field_zero.getvalue()
1793 
1794     def __setfield_zero(self, value):
1795         if isinstance(value,UINT):
1796             self.__field_zero=value
1797         else:
1798             self.__field_zero=UINT(value,**{'sizeinbytes': 1, 'constant': 0})
1799 
1800     def __delfield_zero(self): del self.__field_zero
1801 
1802     zero=property(__getfield_zero, __setfield_zero, __delfield_zero, None)
1803 
1804     def __getfield_pad(self):
1805         try: self.__field_pad
1806         except:
1807             self.__field_pad=UNKNOWN(**{'sizeinbytes': 130})
1808         return self.__field_pad.getvalue()
1809 
1810     def __setfield_pad(self, value):
1811         if isinstance(value,UNKNOWN):
1812             self.__field_pad=value
1813         else:
1814             self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 130})
1815 
1816     def __delfield_pad(self): del self.__field_pad
1817 
1818     pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None)
1819 
1820     def iscontainer(self):
1821         return True
1822 
1823     def containerelements(self):
1824         yield ('command1', self.__field_command1, None)
1825         yield ('command2', self.__field_command2, None)
1826         yield ('zero', self.__field_zero, None)
1827         yield ('pad', self.__field_pad, None)
1828 
1829 
1830 
1831 
1832 class phonenumberresponse(BaseProtogenClass):
1833     __fields=['command1', 'command2', 'pad1', 'myphonenumber', 'pad2']
1834 
1835     def __init__(self, *args, **kwargs):
1836         dict={}
1837         # What was supplied to this function
1838         dict.update(kwargs)
1839         # Parent constructor
1840         super(phonenumberresponse,self).__init__(**dict)
1841         if self.__class__ is phonenumberresponse:
1842             self._update(args,dict)
1843 
1844 
1845     def getfields(self):
1846         return self.__fields
1847 
1848 
1849     def _update(self, args, kwargs):
1850         super(phonenumberresponse,self)._update(args,kwargs)
1851         keys=kwargs.keys()
1852         for key in keys:
1853             if key in self.__fields:
1854                 setattr(self, key, kwargs[key])
1855                 del kwargs[key]
1856         # Were any unrecognized kwargs passed in?
1857         if __debug__:
1858             self._complainaboutunusedargs(phonenumberresponse,kwargs)
1859         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
1860         # Make all P fields that haven't already been constructed
1861 
1862 
1863     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1864         'Writes this packet to the supplied buffer'
1865         self._bufferstartoffset=buf.getcurrentoffset()
1866         self.__field_command1.writetobuffer(buf)
1867         self.__field_command2.writetobuffer(buf)
1868         self.__field_pad1.writetobuffer(buf)
1869         self.__field_myphonenumber.writetobuffer(buf)
1870         self.__field_pad2.writetobuffer(buf)
1871         self._bufferendoffset=buf.getcurrentoffset()
1872         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1873 
1874 
1875     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1876         'Reads this packet from the supplied buffer'
1877         self._bufferstartoffset=buf.getcurrentoffset()
1878         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1879         self.__field_command1=UINT(**{'sizeinbytes': 1, 'constant': 0x26})
1880         self.__field_command1.readfrombuffer(buf)
1881         self.__field_command2=UINT(**{'sizeinbytes': 1, 'constant': 0xb2})
1882         self.__field_command2.readfrombuffer(buf)
1883         self.__field_pad1=UNKNOWN(**{'sizeinbytes': 2})
1884         self.__field_pad1.readfrombuffer(buf)
1885         self.__field_myphonenumber=USTRING(**{'sizeinbytes': 10, 'raiseonunterminatedread': False})
1886         self.__field_myphonenumber.readfrombuffer(buf)
1887         self.__field_pad2=UNKNOWN(**{'sizeinbytes': 119})
1888         self.__field_pad2.readfrombuffer(buf)
1889         self._bufferendoffset=buf.getcurrentoffset()
1890 
1891 
1892     def __getfield_command1(self):
1893         return self.__field_command1.getvalue()
1894 
1895     def __setfield_command1(self, value):
1896         if isinstance(value,UINT):
1897             self.__field_command1=value
1898         else:
1899             self.__field_command1=UINT(value,**{'sizeinbytes': 1, 'constant': 0x26})
1900 
1901     def __delfield_command1(self): del self.__field_command1
1902 
1903     command1=property(__getfield_command1, __setfield_command1, __delfield_command1, None)
1904 
1905     def __getfield_command2(self):
1906         return self.__field_command2.getvalue()
1907 
1908     def __setfield_command2(self, value):
1909         if isinstance(value,UINT):
1910             self.__field_command2=value
1911         else:
1912             self.__field_command2=UINT(value,**{'sizeinbytes': 1, 'constant': 0xb2})
1913 
1914     def __delfield_command2(self): del self.__field_command2
1915 
1916     command2=property(__getfield_command2, __setfield_command2, __delfield_command2, None)
1917 
1918     def __getfield_pad1(self):
1919         return self.__field_pad1.getvalue()
1920 
1921     def __setfield_pad1(self, value):
1922         if isinstance(value,UNKNOWN):
1923             self.__field_pad1=value
1924         else:
1925             self.__field_pad1=UNKNOWN(value,**{'sizeinbytes': 2})
1926 
1927     def __delfield_pad1(self): del self.__field_pad1
1928 
1929     pad1=property(__getfield_pad1, __setfield_pad1, __delfield_pad1, None)
1930 
1931     def __getfield_myphonenumber(self):
1932         return self.__field_myphonenumber.getvalue()
1933 
1934     def __setfield_myphonenumber(self, value):
1935         if isinstance(value,USTRING):
1936             self.__field_myphonenumber=value
1937         else:
1938             self.__field_myphonenumber=USTRING(value,**{'sizeinbytes': 10, 'raiseonunterminatedread': False})
1939 
1940     def __delfield_myphonenumber(self): del self.__field_myphonenumber
1941 
1942     myphonenumber=property(__getfield_myphonenumber, __setfield_myphonenumber, __delfield_myphonenumber, None)
1943 
1944     def __getfield_pad2(self):
1945         return self.__field_pad2.getvalue()
1946 
1947     def __setfield_pad2(self, value):
1948         if isinstance(value,UNKNOWN):
1949             self.__field_pad2=value
1950         else:
1951             self.__field_pad2=UNKNOWN(value,**{'sizeinbytes': 119})
1952 
1953     def __delfield_pad2(self): del self.__field_pad2
1954 
1955     pad2=property(__getfield_pad2, __setfield_pad2, __delfield_pad2, None)
1956 
1957     def iscontainer(self):
1958         return True
1959 
1960     def containerelements(self):
1961         yield ('command1', self.__field_command1, None)
1962         yield ('command2', self.__field_command2, None)
1963         yield ('pad1', self.__field_pad1, None)
1964         yield ('myphonenumber', self.__field_myphonenumber, None)
1965         yield ('pad2', self.__field_pad2, None)
1966 
1967 
1968 
1969 
1970 class sanyoheader(BaseProtogenClass):
1971     __fields=['readwrite', 'command', 'packettype']
1972 
1973     def __init__(self, *args, **kwargs):
1974         dict={}
1975         # User specified arguments in the packet description
1976         dict.update({'readwrite': 0x0d})
1977         # What was supplied to this function
1978         dict.update(kwargs)
1979         # Parent constructor
1980         super(sanyoheader,self).__init__(**dict)
1981         if self.__class__ is sanyoheader:
1982             self._update(args,dict)
1983 
1984 
1985     def getfields(self):
1986         return self.__fields
1987 
1988 
1989     def _update(self, args, kwargs):
1990         super(sanyoheader,self)._update(args,kwargs)
1991         keys=kwargs.keys()
1992         for key in keys:
1993             if key in self.__fields:
1994                 setattr(self, key, kwargs[key])
1995                 del kwargs[key]
1996         # Were any unrecognized kwargs passed in?
1997         if __debug__:
1998             self._complainaboutunusedargs(sanyoheader,kwargs)
1999         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
2000         # Make all P fields that haven't already been constructed
2001 
2002 
2003     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
2004         'Writes this packet to the supplied buffer'
2005         self._bufferstartoffset=buf.getcurrentoffset()
2006         self.__field_readwrite.writetobuffer(buf)
2007         self.__field_command.writetobuffer(buf)
2008         self.__field_packettype.writetobuffer(buf)
2009         self._bufferendoffset=buf.getcurrentoffset()
2010         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
2011 
2012 
2013     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
2014         'Reads this packet from the supplied buffer'
2015         self._bufferstartoffset=buf.getcurrentoffset()
2016         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
2017         self.__field_readwrite=UINT(**{'sizeinbytes': 1})
2018         self.__field_readwrite.readfrombuffer(buf)
2019         self.__field_command=UINT(**{'sizeinbytes': 1})
2020         self.__field_command.readfrombuffer(buf)
2021         self.__field_packettype=UINT(**{'sizeinbytes': 1})
2022         self.__field_packettype.readfrombuffer(buf)
2023         self._bufferendoffset=buf.getcurrentoffset()
2024 
2025 
2026     def __getfield_readwrite(self):
2027         return self.__field_readwrite.getvalue()
2028 
2029     def __setfield_readwrite(self, value):
2030         if isinstance(value,UINT):
2031             self.__field_readwrite=value
2032         else:
2033             self.__field_readwrite=UINT(value,**{'sizeinbytes': 1})
2034 
2035     def __delfield_readwrite(self): del self.__field_readwrite
2036 
2037     readwrite=property(__getfield_readwrite, __setfield_readwrite, __delfield_readwrite, None)
2038 
2039     def __getfield_command(self):
2040         return self.__field_command.getvalue()
2041 
2042     def __setfield_command(self, value):
2043         if isinstance(value,UINT):
2044             self.__field_command=value
2045         else:
2046             self.__field_command=UINT(value,**{'sizeinbytes': 1})
2047 
2048     def __delfield_command(self): del self.__field_command
2049 
2050     command=property(__getfield_command, __setfield_command, __delfield_command, None)
2051 
2052     def __getfield_packettype(self):
2053         return self.__field_packettype.getvalue()
2054 
2055     def __setfield_packettype(self, value):
2056         if isinstance(value,UINT):
2057             self.__field_packettype=value
2058         else:
2059             self.__field_packettype=UINT(value,**{'sizeinbytes': 1})
2060 
2061     def __delfield_packettype(self): del self.__field_packettype
2062 
2063     packettype=property(__getfield_packettype, __setfield_packettype, __delfield_packettype, None)
2064 
2065     def iscontainer(self):
2066         return True
2067 
2068     def containerelements(self):
2069         yield ('readwrite', self.__field_readwrite, None)
2070         yield ('command', self.__field_command, None)
2071         yield ('packettype', self.__field_packettype, None)
2072 
2073 
2074 
2075 
2076 class esnrequest(BaseProtogenClass):
2077     __fields=['command']
2078 
2079     def __init__(self, *args, **kwargs):
2080         dict={}
2081         # What was supplied to this function
2082         dict.update(kwargs)
2083         # Parent constructor
2084         super(esnrequest,self).__init__(**dict)
2085         if self.__class__ is esnrequest:
2086             self._update(args,dict)
2087 
2088 
2089     def getfields(self):
2090         return self.__fields
2091 
2092 
2093     def _update(self, args, kwargs):
2094         super(esnrequest,self)._update(args,kwargs)
2095         keys=kwargs.keys()
2096         for key in keys:
2097             if key in self.__fields:
2098                 setattr(self, key, kwargs[key])
2099                 del kwargs[key]
2100         # Were any unrecognized kwargs passed in?
2101         if __debug__:
2102             self._complainaboutunusedargs(esnrequest,kwargs)
2103         if len(args):
2104             dict2={'sizeinbytes': 1, 'constant': 0x01}
2105             dict2.update(kwargs)
2106             kwargs=dict2
2107             self.__field_command=UINT(*args,**dict2)
2108         # Make all P fields that haven't already been constructed
2109 
2110 
2111     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
2112         'Writes this packet to the supplied buffer'
2113         self._bufferstartoffset=buf.getcurrentoffset()
2114         try: self.__field_command
2115         except:
2116             self.__field_command=UINT(**{'sizeinbytes': 1, 'constant': 0x01})
2117         self.__field_command.writetobuffer(buf)
2118         self._bufferendoffset=buf.getcurrentoffset()
2119         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
2120 
2121 
2122     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
2123         'Reads this packet from the supplied buffer'
2124         self._bufferstartoffset=buf.getcurrentoffset()
2125         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
2126         self.__field_command=UINT(**{'sizeinbytes': 1, 'constant': 0x01})
2127         self.__field_command.readfrombuffer(buf)
2128         self._bufferendoffset=buf.getcurrentoffset()
2129 
2130 
2131     def __getfield_command(self):
2132         try: self.__field_command
2133         except:
2134             self.__field_command=UINT(**{'sizeinbytes': 1, 'constant': 0x01})
2135         return self.__field_command.getvalue()
2136 
2137     def __setfield_command(self, value):
2138         if isinstance(value,UINT):
2139             self.__field_command=value
2140         else:
2141             self.__field_command=UINT(value,**{'sizeinbytes': 1, 'constant': 0x01})
2142 
2143     def __delfield_command(self): del self.__field_command
2144 
2145     command=property(__getfield_command, __setfield_command, __delfield_command, None)
2146 
2147     def iscontainer(self):
2148         return True
2149 
2150     def containerelements(self):
2151         yield ('command', self.__field_command, None)
2152 
2153 
2154 
2155 
2156 class esnresponse(BaseProtogenClass):
2157     __fields=['command', 'esn']
2158 
2159     def __init__(self, *args, **kwargs):
2160         dict={}
2161         # What was supplied to this function
2162         dict.update(kwargs)
2163         # Parent constructor
2164         super(esnresponse,self).__init__(**dict)
2165         if self.__class__ is esnresponse:
2166             self._update(args,dict)
2167 
2168 
2169     def getfields(self):
2170         return self.__fields
2171 
2172 
2173     def _update(self, args, kwargs):
2174         super(esnresponse,self)._update(args,kwargs)
2175         keys=kwargs.keys()
2176         for key in keys:
2177             if key in self.__fields:
2178                 setattr(self, key, kwargs[key])
2179                 del kwargs[key]
2180         # Were any unrecognized kwargs passed in?
2181         if __debug__:
2182             self._complainaboutunusedargs(esnresponse,kwargs)
2183         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
2184         # Make all P fields that haven't already been constructed
2185 
2186 
2187     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
2188         'Writes this packet to the supplied buffer'
2189         self._bufferstartoffset=buf.getcurrentoffset()
2190         self.__field_command.writetobuffer(buf)
2191         self.__field_esn.writetobuffer(buf)
2192         self._bufferendoffset=buf.getcurrentoffset()
2193         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
2194 
2195 
2196     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
2197         'Reads this packet from the supplied buffer'
2198         self._bufferstartoffset=buf.getcurrentoffset()
2199         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
2200         self.__field_command=UINT(**{'sizeinbytes': 1, 'constant': 0x01})
2201         self.__field_command.readfrombuffer(buf)
2202         self.__field_esn=UINT(**{'sizeinbytes': 4})
2203         self.__field_esn.readfrombuffer(buf)
2204         self._bufferendoffset=buf.getcurrentoffset()
2205 
2206 
2207     def __getfield_command(self):
2208         return self.__field_command.getvalue()
2209 
2210     def __setfield_command(self, value):
2211         if isinstance(value,UINT):
2212             self.__field_command=value
2213         else:
2214             self.__field_command=UINT(value,**{'sizeinbytes': 1, 'constant': 0x01})
2215 
2216     def __delfield_command(self): del self.__field_command
2217 
2218     command=property(__getfield_command, __setfield_command, __delfield_command, None)
2219 
2220     def __getfield_esn(self):
2221         return self.__field_esn.getvalue()
2222 
2223     def __setfield_esn(self, value):
2224         if isinstance(value,UINT):
2225             self.__field_esn=value
2226         else:
2227             self.__field_esn=UINT(value,**{'sizeinbytes': 4})
2228 
2229     def __delfield_esn(self): del self.__field_esn
2230 
2231     esn=property(__getfield_esn, __setfield_esn, __delfield_esn, None)
2232 
2233     def iscontainer(self):
2234         return True
2235 
2236     def containerelements(self):
2237         yield ('command', self.__field_command, None)
2238         yield ('esn', self.__field_esn, None)
2239 
2240 
2241 
2242 
2243 class ownerinforequest(BaseProtogenClass):
2244     __fields=['header', 'pad']
2245 
2246     def __init__(self, *args, **kwargs):
2247         dict={}
2248         # What was supplied to this function
2249         dict.update(kwargs)
2250         # Parent constructor
2251         super(ownerinforequest,self).__init__(**dict)
2252         if self.__class__ is ownerinforequest:
2253             self._update(args,dict)
2254 
2255 
2256     def getfields(self):
2257         return self.__fields
2258 
2259 
2260     def _update(self, args, kwargs):
2261         super(ownerinforequest,self)._update(args,kwargs)
2262         keys=kwargs.keys()
2263         for key in keys:
2264             if key in self.__fields:
2265                 setattr(self, key, kwargs[key])
2266                 del kwargs[key]
2267         # Were any unrecognized kwargs passed in?
2268         if __debug__:
2269             self._complainaboutunusedargs(ownerinforequest,kwargs)
2270         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
2271         # Make all P fields that haven't already been constructed
2272 
2273 
2274     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
2275         'Writes this packet to the supplied buffer'
2276         self._bufferstartoffset=buf.getcurrentoffset()
2277         try: self.__field_header
2278         except:
2279             self.__field_header=sanyoheader(**{'packettype': 0x0c,                'command': 0x3b})
2280         self.__field_header.writetobuffer(buf)
2281         try: self.__field_pad
2282         except:
2283             self.__field_pad=UNKNOWN(**{'sizeinbytes': 502})
2284         self.__field_pad.writetobuffer(buf)
2285         self._bufferendoffset=buf.getcurrentoffset()
2286         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
2287 
2288 
2289     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
2290         'Reads this packet from the supplied buffer'
2291         self._bufferstartoffset=buf.getcurrentoffset()
2292         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
2293         self.__field_header=sanyoheader(**{'packettype': 0x0c,                'command': 0x3b})
2294         self.__field_header.readfrombuffer(buf)
2295         self.__field_pad=UNKNOWN(**{'sizeinbytes': 502})
2296         self.__field_pad.readfrombuffer(buf)
2297         self._bufferendoffset=buf.getcurrentoffset()
2298 
2299 
2300     def __getfield_header(self):
2301         try: self.__field_header
2302         except:
2303             self.__field_header=sanyoheader(**{'packettype': 0x0c,                'command': 0x3b})
2304         return self.__field_header.getvalue()
2305 
2306     def __setfield_header(self, value):
2307         if isinstance(value,sanyoheader):
2308             self.__field_header=value
2309         else:
2310             self.__field_header=sanyoheader(value,**{'packettype': 0x0c,                'command': 0x3b})
2311 
2312     def __delfield_header(self): del self.__field_header
2313 
2314     header=property(__getfield_header, __setfield_header, __delfield_header, None)
2315 
2316     def __getfield_pad(self):
2317         try: self.__field_pad
2318         except:
2319             self.__field_pad=UNKNOWN(**{'sizeinbytes': 502})
2320         return self.__field_pad.getvalue()
2321 
2322     def __setfield_pad(self, value):
2323         if isinstance(value,UNKNOWN):
2324             self.__field_pad=value
2325         else:
2326             self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 502})
2327 
2328     def __delfield_pad(self): del self.__field_pad
2329 
2330     pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None)
2331 
2332     def iscontainer(self):
2333         return True
2334 
2335     def containerelements(self):
2336         yield ('header', self.__field_header, None)
2337         yield ('pad', self.__field_pad, None)
2338 
2339 
2340 
2341 
2342 class ownerentry(BaseProtogenClass):
2343     __fields=['ownername', 'birthyear', 'birthmonth', 'birthday', 'bloodtype', 'address', 'pad', 'homeemail', 'workemail', 'homephone', 'workphone']
2344 
2345     def __init__(self, *args, **kwargs):
2346         dict={}
2347         # What was supplied to this function
2348         dict.update(kwargs)
2349         # Parent constructor
2350         super(ownerentry,self).__init__(**dict)
2351         if self.__class__ is ownerentry:
2352             self._update(args,dict)
2353 
2354 
2355     def getfields(self):
2356         return self.__fields
2357 
2358 
2359     def _update(self, args, kwargs):
2360         super(ownerentry,self)._update(args,kwargs)
2361         keys=kwargs.keys()
2362         for key in keys:
2363             if key in self.__fields:
2364                 setattr(self, key, kwargs[key])
2365                 del kwargs[key]
2366         # Were any unrecognized kwargs passed in?
2367         if __debug__:
2368             self._complainaboutunusedargs(ownerentry,kwargs)
2369         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
2370         # Make all P fields that haven't already been constructed
2371 
2372 
2373     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
2374         'Writes this packet to the supplied buffer'
2375         self._bufferstartoffset=buf.getcurrentoffset()
2376         self.__field_ownername.writetobuffer(buf)
2377         self.__field_birthyear.writetobuffer(buf)
2378         self.__field_birthmonth.writetobuffer(buf)
2379         self.__field_birthday.writetobuffer(buf)
2380         self.__field_bloodtype.writetobuffer(buf)
2381         self.__field_address.writetobuffer(buf)
2382         try: self.__field_pad
2383         except:
2384             self.__field_pad=UNKNOWN(**{'sizeinbytes': 14})
2385         self.__field_pad.writetobuffer(buf)
2386         self.__field_homeemail.writetobuffer(buf)
2387         self.__field_workemail.writetobuffer(buf)
2388         self.__field_homephone.writetobuffer(buf)
2389         self.__field_workphone.writetobuffer(buf)
2390         self._bufferendoffset=buf.getcurrentoffset()
2391         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
2392 
2393 
2394     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
2395         'Reads this packet from the supplied buffer'
2396         self._bufferstartoffset=buf.getcurrentoffset()
2397         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
2398         self.__field_ownername=USTRING(**{'sizeinbytes': 16, 'raiseonunterminatedread': False})
2399         self.__field_ownername.readfrombuffer(buf)
2400         self.__field_birthyear=UINT(**{'sizeinbytes': 2})
2401         self.__field_birthyear.readfrombuffer(buf)
2402         self.__field_birthmonth=UINT(**{'sizeinbytes': 1})
2403         self.__field_birthmonth.readfrombuffer(buf)
2404         self.__field_birthday=UINT(**{'sizeinbytes': 1})
2405         self.__field_birthday.readfrombuffer(buf)
2406         self.__field_bloodtype=UINT(**{'sizeinbytes': 1})
2407         self.__field_bloodtype.readfrombuffer(buf)
2408         self.__field_address=USTRING(**{'sizeinbytes': 96, 'raiseonunterminatedread': False})
2409         self.__field_address.readfrombuffer(buf)
2410         self.__field_pad=UNKNOWN(**{'sizeinbytes': 14})
2411         self.__field_pad.readfrombuffer(buf)
2412         self.__field_homeemail=USTRING(**{'sizeinbytes': 48, 'raiseonunterminatedread': False})
2413         self.__field_homeemail.readfrombuffer(buf)
2414         self.__field_workemail=USTRING(**{'sizeinbytes': 48, 'raiseonunterminatedread': False})
2415         self.__field_workemail.readfrombuffer(buf)
2416         self.__field_homephone=USTRING(**{'sizeinbytes': 48, 'raiseonunterminatedread': False})
2417         self.__field_homephone.readfrombuffer(buf)
2418         self.__field_workphone=USTRING(**{'sizeinbytes': 48, 'raiseonunterminatedread': False})
2419         self.__field_workphone.readfrombuffer(buf)
2420         self._bufferendoffset=buf.getcurrentoffset()
2421 
2422 
2423     def __getfield_ownername(self):
2424         return self.__field_ownername.getvalue()
2425 
2426     def __setfield_ownername(self, value):
2427         if isinstance(value,USTRING):
2428             self.__field_ownername=value
2429         else:
2430             self.__field_ownername=USTRING(value,**{'sizeinbytes': 16, 'raiseonunterminatedread': False})
2431 
2432     def __delfield_ownername(self): del self.__field_ownername
2433 
2434     ownername=property(__getfield_ownername, __setfield_ownername, __delfield_ownername, None)
2435 
2436     def __getfield_birthyear(self):
2437         return self.__field_birthyear.getvalue()
2438 
2439     def __setfield_birthyear(self, value):
2440         if isinstance(value,UINT):
2441             self.__field_birthyear=value
2442         else:
2443             self.__field_birthyear=UINT(value,**{'sizeinbytes': 2})
2444 
2445     def __delfield_birthyear(self): del self.__field_birthyear
2446 
2447     birthyear=property(__getfield_birthyear, __setfield_birthyear, __delfield_birthyear, None)
2448 
2449     def __getfield_birthmonth(self):
2450         return self.__field_birthmonth.getvalue()
2451 
2452     def __setfield_birthmonth(self, value):
2453         if isinstance(value,UINT):
2454             self.__field_birthmonth=value
2455         else:
2456             self.__field_birthmonth=UINT(value,**{'sizeinbytes': 1})
2457 
2458     def __delfield_birthmonth(self): del self.__field_birthmonth
2459 
2460     birthmonth=property(__getfield_birthmonth, __setfield_birthmonth, __delfield_birthmonth, None)
2461 
2462     def __getfield_birthday(self):
2463         return self.__field_birthday.getvalue()
2464 
2465     def __setfield_birthday(self, value):
2466         if isinstance(value,UINT):
2467             self.__field_birthday=value
2468         else:
2469             self.__field_birthday=UINT(value,**{'sizeinbytes': 1})
2470 
2471     def __delfield_birthday(self): del self.__field_birthday
2472 
2473     birthday=property(__getfield_birthday, __setfield_birthday, __delfield_birthday, None)
2474 
2475     def __getfield_bloodtype(self):
2476         return self.__field_bloodtype.getvalue()
2477 
2478     def __setfield_bloodtype(self, value):
2479         if isinstance(value,UINT):
2480             self.__field_bloodtype=value
2481         else:
2482             self.__field_bloodtype=UINT(value,**{'sizeinbytes': 1})
2483 
2484     def __delfield_bloodtype(self): del self.__field_bloodtype
2485 
2486     bloodtype=property(__getfield_bloodtype, __setfield_bloodtype, __delfield_bloodtype, "0: ?, 1: A, 2: B, 3: O, 4: AB")
2487 
2488     def __getfield_address(self):
2489         return self.__field_address.getvalue()
2490 
2491     def __setfield_address(self, value):
2492         if isinstance(value,USTRING):
2493             self.__field_address=value
2494         else:
2495             self.__field_address=USTRING(value,**{'sizeinbytes': 96, 'raiseonunterminatedread': False})
2496 
2497     def __delfield_address(self): del self.__field_address
2498 
2499     address=property(__getfield_address, __setfield_address, __delfield_address, None)
2500 
2501     def __getfield_pad(self):
2502         try: self.__field_pad
2503         except:
2504             self.__field_pad=UNKNOWN(**{'sizeinbytes': 14})
2505         return self.__field_pad.getvalue()
2506 
2507     def __setfield_pad(self, value):
2508         if isinstance(value,UNKNOWN):
2509             self.__field_pad=value
2510         else:
2511             self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 14})
2512 
2513     def __delfield_pad(self): del self.__field_pad
2514 
2515     pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None)
2516 
2517     def __getfield_homeemail(self):
2518         return self.__field_homeemail.getvalue()
2519 
2520     def __setfield_homeemail(self, value):
2521         if isinstance(value,USTRING):
2522             self.__field_homeemail=value
2523         else:
2524             self.__field_homeemail=USTRING(value,**{'sizeinbytes': 48, 'raiseonunterminatedread': False})
2525 
2526     def __delfield_homeemail(self): del self.__field_homeemail
2527 
2528     homeemail=property(__getfield_homeemail, __setfield_homeemail, __delfield_homeemail, None)
2529 
2530     def __getfield_workemail(self):
2531         return self.__field_workemail.getvalue()
2532 
2533     def __setfield_workemail(self, value):
2534         if isinstance(value,USTRING):
2535             self.__field_workemail=value
2536         else:
2537             self.__field_workemail=USTRING(value,**{'sizeinbytes': 48, 'raiseonunterminatedread': False})
2538 
2539     def __delfield_workemail(self): del self.__field_workemail
2540 
2541     workemail=property(__getfield_workemail, __setfield_workemail, __delfield_workemail, None)
2542 
2543     def __getfield_homephone(self):
2544         return self.__field_homephone.getvalue()
2545 
2546     def __setfield_homephone(self, value):
2547         if isinstance(value,USTRING):
2548             self.__field_homephone=value
2549         else:
2550             self.__field_homephone=USTRING(value,**{'sizeinbytes': 48, 'raiseonunterminatedread': False})
2551 
2552     def __delfield_homephone(self): del self.__field_homephone
2553 
2554     homephone=property(__getfield_homephone, __setfield_homephone, __delfield_homephone, None)
2555 
2556     def __getfield_workphone(self):
2557         return self.__field_workphone.getvalue()
2558 
2559     def __setfield_workphone(self, value):
2560         if isinstance(value,USTRING):
2561             self.__field_workphone=value
2562         else:
2563             self.__field_workphone=USTRING(value,**{'sizeinbytes': 48, 'raiseonunterminatedread': False})
2564 
2565     def __delfield_workphone(self): del self.__field_workphone
2566 
2567     workphone=property(__getfield_workphone, __setfield_workphone, __delfield_workphone, None)
2568 
2569     def iscontainer(self):
2570         return True
2571 
2572     def containerelements(self):
2573         yield ('ownername', self.__field_ownername, None)
2574         yield ('birthyear', self.__field_birthyear, None)
2575         yield ('birthmonth', self.__field_birthmonth, None)
2576         yield ('birthday', self.__field_birthday, None)
2577         yield ('bloodtype', self.__field_bloodtype, "0: ?, 1: A, 2: B, 3: O, 4: AB")
2578         yield ('address', self.__field_address, None)
2579         yield ('pad', self.__field_pad, None)
2580         yield ('homeemail', self.__field_homeemail, None)
2581         yield ('workemail', self.__field_workemail, None)
2582         yield ('homephone', self.__field_homephone, None)
2583         yield ('workphone', self.__field_workphone, None)
2584 
2585 
2586 
2587 
2588 class ownerinforesponse(BaseProtogenClass):
2589     __fields=['header', 'entry', 'pad']
2590 
2591     def __init__(self, *args, **kwargs):
2592         dict={}
2593         # What was supplied to this function
2594         dict.update(kwargs)
2595         # Parent constructor
2596         super(ownerinforesponse,self).__init__(**dict)
2597         if self.__class__ is ownerinforesponse:
2598             self._update(args,dict)
2599 
2600 
2601     def getfields(self):
2602         return self.__fields
2603 
2604 
2605     def _update(self, args, kwargs):
2606         super(ownerinforesponse,self)._update(args,kwargs)
2607         keys=kwargs.keys()
2608         for key in keys:
2609             if key in self.__fields:
2610                 setattr(self, key, kwargs[key])
2611                 del kwargs[key]
2612         # Were any unrecognized kwargs passed in?
2613         if __debug__:
2614             self._complainaboutunusedargs(ownerinforesponse,kwargs)
2615         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
2616         # Make all P fields that haven't already been constructed
2617 
2618 
2619     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
2620         'Writes this packet to the supplied buffer'
2621         self._bufferstartoffset=buf.getcurrentoffset()
2622         self.__field_header.writetobuffer(buf)
2623         self.__field_entry.writetobuffer(buf)
2624         self.__field_pad.writetobuffer(buf)
2625         self._bufferendoffset=buf.getcurrentoffset()
2626         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
2627 
2628 
2629     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
2630         'Reads this packet from the supplied buffer'
2631         self._bufferstartoffset=buf.getcurrentoffset()
2632         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
2633         self.__field_header=sanyoheader()
2634         self.__field_header.readfrombuffer(buf)
2635         self.__field_entry=ownerentry()
2636         self.__field_entry.readfrombuffer(buf)
2637         self.__field_pad=UNKNOWN(**{'sizeinbytes': 178})
2638         self.__field_pad.readfrombuffer(buf)
2639         self._bufferendoffset=buf.getcurrentoffset()
2640 
2641 
2642     def __getfield_header(self):
2643         return self.__field_header.getvalue()
2644 
2645     def __setfield_header(self, value):
2646         if isinstance(value,sanyoheader):
2647             self.__field_header=value
2648         else:
2649             self.__field_header=sanyoheader(value,)
2650 
2651     def __delfield_header(self): del self.__field_header
2652 
2653     header=property(__getfield_header, __setfield_header, __delfield_header, None)
2654 
2655     def __getfield_entry(self):
2656         return self.__field_entry.getvalue()
2657 
2658     def __setfield_entry(self, value):
2659         if isinstance(value,ownerentry):
2660             self.__field_entry=value
2661         else:
2662             self.__field_entry=ownerentry(value,)
2663 
2664     def __delfield_entry(self): del self.__field_entry
2665 
2666     entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None)
2667 
2668     def __getfield_pad(self):
2669         return self.__field_pad.getvalue()
2670 
2671     def __setfield_pad(self, value):
2672         if isinstance(value,UNKNOWN):
2673             self.__field_pad=value
2674         else:
2675             self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 178})
2676 
2677     def __delfield_pad(self): del self.__field_pad
2678 
2679     pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None)
2680 
2681     def iscontainer(self):
2682         return True
2683 
2684     def containerelements(self):
2685         yield ('header', self.__field_header, None)
2686         yield ('entry', self.__field_entry, None)
2687         yield ('pad', self.__field_pad, None)
2688 
2689 
2690 
2691 
2692 class eventrequest(BaseProtogenClass):
2693     __fields=['header', 'slot', 'pad']
2694 
2695     def __init__(self, *args, **kwargs):
2696         dict={}
2697         # What was supplied to this function
2698         dict.update(kwargs)
2699         # Parent constructor
2700         super(eventrequest,self).__init__(**dict)
2701         if self.__class__ is eventrequest:
2702             self._update(args,dict)
2703 
2704 
2705     def getfields(self):
2706         return self.__fields
2707 
2708 
2709     def _update(self, args, kwargs):
2710         super(eventrequest,self)._update(args,kwargs)
2711         keys=kwargs.keys()
2712         for key in keys:
2713             if key in self.__fields:
2714                 setattr(self, key, kwargs[key])
2715                 del kwargs[key]
2716         # Were any unrecognized kwargs passed in?
2717         if __debug__:
2718             self._complainaboutunusedargs(eventrequest,kwargs)
2719         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
2720         # Make all P fields that haven't already been constructed
2721 
2722 
2723     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
2724         'Writes this packet to the supplied buffer'
2725         self._bufferstartoffset=buf.getcurrentoffset()
2726         try: self.__field_header
2727         except:
2728             self.__field_header=sanyoheader(**{'packettype': 0x0c,                'command': 0x23})
2729         self.__field_header.writetobuffer(buf)
2730         self.__field_slot.writetobuffer(buf)
2731         try: self.__field_pad
2732         except:
2733             self.__field_pad=UNKNOWN(**{'sizeinbytes': 501})
2734         self.__field_pad.writetobuffer(buf)
2735         self._bufferendoffset=buf.getcurrentoffset()
2736         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
2737 
2738 
2739     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
2740         'Reads this packet from the supplied buffer'
2741         self._bufferstartoffset=buf.getcurrentoffset()
2742         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
2743         self.__field_header=sanyoheader(**{'packettype': 0x0c,                'command': 0x23})
2744         self.__field_header.readfrombuffer(buf)
2745         self.__field_slot=UINT(**{'sizeinbytes': 1})
2746         self.__field_slot.readfrombuffer(buf)
2747         self.__field_pad=UNKNOWN(**{'sizeinbytes': 501})
2748         self.__field_pad.readfrombuffer(buf)
2749         self._bufferendoffset=buf.getcurrentoffset()
2750 
2751 
2752     def __getfield_header(self):
2753         try: self.__field_header
2754         except:
2755             self.__field_header=sanyoheader(**{'packettype': 0x0c,                'command': 0x23})
2756         return self.__field_header.getvalue()
2757 
2758     def __setfield_header(self, value):
2759         if isinstance(value,sanyoheader):
2760             self.__field_header=value
2761         else:
2762             self.__field_header=sanyoheader(value,**{'packettype': 0x0c,                'command': 0x23})
2763 
2764     def __delfield_header(self): del self.__field_header
2765 
2766     header=property(__getfield_header, __setfield_header, __delfield_header, None)
2767 
2768     def __getfield_slot(self):
2769         return self.__field_slot.getvalue()
2770 
2771     def __setfield_slot(self, value):
2772         if isinstance(value,UINT):
2773             self.__field_slot=value
2774         else:
2775             self.__field_slot=UINT(value,**{'sizeinbytes': 1})
2776 
2777     def __delfield_slot(self): del self.__field_slot
2778 
2779     slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None)
2780 
2781     def __getfield_pad(self):
2782         try: self.__field_pad
2783         except:
2784             self.__field_pad=UNKNOWN(**{'sizeinbytes': 501})
2785         return self.__field_pad.getvalue()
2786 
2787     def __setfield_pad(self, value):
2788         if isinstance(value,UNKNOWN):
2789             self.__field_pad=value
2790         else:
2791             self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 501})
2792 
2793     def __delfield_pad(self): del self.__field_pad
2794 
2795     pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None)
2796 
2797     def iscontainer(self):
2798         return True
2799 
2800     def containerelements(self):
2801         yield ('header', self.__field_header, None)
2802         yield ('slot', self.__field_slot, None)
2803         yield ('pad', self.__field_pad, None)
2804 
2805 
2806 
2807 
2808 class evententry(BaseProtogenClass):
2809     __fields=['slot', 'flag', 'eventname', 'pad1', 'eventname_len', 'start', 'end', 'location', 'pad2', 'location_len', 'ringtone', 'alarmdiff', 'period', 'dom', 'alarm', 'serial']
2810 
2811     def __init__(self, *args, **kwargs):
2812         dict={}
2813         # What was supplied to this function
2814         dict.update(kwargs)
2815         # Parent constructor
2816         super(evententry,self).__init__(**dict)
2817         if self.__class__ is evententry:
2818             self._update(args,dict)
2819 
2820 
2821     def getfields(self):
2822         return self.__fields
2823 
2824 
2825     def _update(self, args, kwargs):
2826         super(evententry,self)._update(args,kwargs)
2827         keys=kwargs.keys()
2828         for key in keys:
2829             if key in self.__fields:
2830                 setattr(self, key, kwargs[key])
2831                 del kwargs[key]
2832         # Were any unrecognized kwargs passed in?
2833         if __debug__:
2834             self._complainaboutunusedargs(evententry,kwargs)
2835         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
2836         # Make all P fields that haven't already been constructed
2837 
2838 
2839     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
2840         'Writes this packet to the supplied buffer'
2841         self._bufferstartoffset=buf.getcurrentoffset()
2842         self.__field_slot.writetobuffer(buf)
2843         self.__field_flag.writetobuffer(buf)
2844         self.__field_eventname.writetobuffer(buf)
2845         try: self.__field_pad1
2846         except:
2847             self.__field_pad1=UNKNOWN(**{'sizeinbytes': 7})
2848         self.__field_pad1.writetobuffer(buf)
2849         self.__field_eventname_len.writetobuffer(buf)
2850         self.__field_start.writetobuffer(buf)
2851         self.__field_end.writetobuffer(buf)
2852         self.__field_location.writetobuffer(buf)
2853         try: self.__field_pad2
2854         except:
2855             self.__field_pad2=UNKNOWN(**{'sizeinbytes': 7})
2856         self.__field_pad2.writetobuffer(buf)
2857         self.__field_location_len.writetobuffer(buf)
2858         self.__field_ringtone.writetobuffer(buf)
2859         self.__field_alarmdiff.writetobuffer(buf)
2860         self.__field_period.writetobuffer(buf)
2861         self.__field_dom.writetobuffer(buf)
2862         self.__field_alarm.writetobuffer(buf)
2863         try: self.__field_serial
2864         except:
2865             self.__field_serial=UINT(**{'sizeinbytes': 1, 'default': 0})
2866         self.__field_serial.writetobuffer(buf)
2867         self._bufferendoffset=buf.getcurrentoffset()
2868         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
2869 
2870 
2871     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
2872         'Reads this packet from the supplied buffer'
2873         self._bufferstartoffset=buf.getcurrentoffset()
2874         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
2875         self.__field_slot=UINT(**{'sizeinbytes': 1})
2876         self.__field_slot.readfrombuffer(buf)
2877         self.__field_flag=UINT(**{'sizeinbytes': 1})
2878         self.__field_flag.readfrombuffer(buf)
2879         self.__field_eventname=USTRING(**{'sizeinbytes': 14, 'raiseonunterminatedread': False, 'raiseontruncate': False, 'terminator': None})
2880         self.__field_eventname.readfrombuffer(buf)
2881         self.__field_pad1=UNKNOWN(**{'sizeinbytes': 7})
2882         self.__field_pad1.readfrombuffer(buf)
2883         self.__field_eventname_len=UINT(**{'sizeinbytes': 1})
2884         self.__field_eventname_len.readfrombuffer(buf)
2885         self.__field_start=UINT(**{'sizeinbytes': 4})
2886         self.__field_start.readfrombuffer(buf)
2887         self.__field_end=UINT(**{'sizeinbytes': 4})
2888         self.__field_end.readfrombuffer(buf)
2889         self.__field_location=USTRING(**{'sizeinbytes': 14, 'raiseonunterminatedread': False, 'raiseontruncate': False, 'terminator': None})
2890         self.__field_location.readfrombuffer(buf)
2891         self.__field_pad2=UNKNOWN(**{'sizeinbytes': 7})
2892         self.__field_pad2.readfrombuffer(buf)
2893         self.__field_location_len=UINT(**{'sizeinbytes': 1})
2894         self.__field_location_len.readfrombuffer(buf)
2895         self.__field_ringtone=UINT(**{'sizeinbytes': 1})
2896         self.__field_ringtone.readfrombuffer(buf)
2897         self.__field_alarmdiff=UINT(**{'sizeinbytes': 4})
2898         self.__field_alarmdiff.readfrombuffer(buf)
2899         self.__field_period=UINT(**{'sizeinbytes': 1})
2900         self.__field_period.readfrombuffer(buf)
2901         self.__field_dom=UINT(**{'sizeinbytes': 1})
2902         self.__field_dom.readfrombuffer(buf)
2903         self.__field_alarm=UINT(**{'sizeinbytes': 4})
2904         self.__field_alarm.readfrombuffer(buf)
2905         self.__field_serial=UINT(**{'sizeinbytes': 1, 'default': 0})
2906         self.__field_serial.readfrombuffer(buf)
2907         self._bufferendoffset=buf.getcurrentoffset()
2908 
2909 
2910     def __getfield_slot(self):
2911         return self.__field_slot.getvalue()
2912 
2913     def __setfield_slot(self, value):
2914         if isinstance(value,UINT):
2915             self.__field_slot=value
2916         else:
2917             self.__field_slot=UINT(value,**{'sizeinbytes': 1})
2918 
2919     def __delfield_slot(self): del self.__field_slot
2920 
2921     slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None)
2922 
2923     def __getfield_flag(self):
2924         return self.__field_flag.getvalue()
2925 
2926     def __setfield_flag(self, value):
2927         if isinstance(value,UINT):
2928             self.__field_flag=value
2929         else:
2930             self.__field_flag=UINT(value,**{'sizeinbytes': 1})
2931 
2932     def __delfield_flag(self): del self.__field_flag
2933 
2934     flag=property(__getfield_flag, __setfield_flag, __delfield_flag, "0: Not used, 1: Scheduled, 2: Already Happened")
2935 
2936     def __getfield_eventname(self):
2937         return self.__field_eventname.getvalue()
2938 
2939     def __setfield_eventname(self, value):
2940         if isinstance(value,USTRING):
2941             self.__field_eventname=value
2942         else:
2943             self.__field_eventname=USTRING(value,**{'sizeinbytes': 14, 'raiseonunterminatedread': False, 'raiseontruncate': False, 'terminator': None})
2944 
2945     def __delfield_eventname(self): del self.__field_eventname
2946 
2947     eventname=property(__getfield_eventname, __setfield_eventname, __delfield_eventname, None)
2948 
2949     def __getfield_pad1(self):
2950         try: self.__field_pad1
2951         except:
2952             self.__field_pad1=UNKNOWN(**{'sizeinbytes': 7})
2953         return self.__field_pad1.getvalue()
2954 
2955     def __setfield_pad1(self, value):
2956         if isinstance(value,UNKNOWN):
2957             self.__field_pad1=value
2958         else:
2959             self.__field_pad1=UNKNOWN(value,**{'sizeinbytes': 7})
2960 
2961     def __delfield_pad1(self): del self.__field_pad1
2962 
2963     pad1=property(__getfield_pad1, __setfield_pad1, __delfield_pad1, None)
2964 
2965     def __getfield_eventname_len(self):
2966         return self.__field_eventname_len.getvalue()
2967 
2968     def __setfield_eventname_len(self, value):
2969         if isinstance(value,UINT):
2970             self.__field_eventname_len=value
2971         else:
2972             self.__field_eventname_len=UINT(value,**{'sizeinbytes': 1})
2973 
2974     def __delfield_eventname_len(self): del self.__field_eventname_len
2975 
2976     eventname_len=property(__getfield_eventname_len, __setfield_eventname_len, __delfield_eventname_len, None)
2977 
2978     def __getfield_start(self):
2979         return self.__field_start.getvalue()
2980 
2981     def __setfield_start(self, value):
2982         if isinstance(value,UINT):
2983             self.__field_start=value
2984         else:
2985             self.__field_start=UINT(value,**{'sizeinbytes': 4})
2986 
2987     def __delfield_start(self): del self.__field_start
2988 
2989     start=property(__getfield_start, __setfield_start, __delfield_start, "# seconds since Jan 1, 1980 approximately")
2990 
2991     def __getfield_end(self):
2992         return self.__field_end.getvalue()
2993 
2994     def __setfield_end(self, value):
2995         if isinstance(value,UINT):
2996             self.__field_end=value
2997         else:
2998             self.__field_end=UINT(value,**{'sizeinbytes': 4})
2999 
3000     def __delfield_end(self): del self.__field_end
3001 
3002     end=property(__getfield_end, __setfield_end, __delfield_end, None)
3003 
3004     def __getfield_location(self):
3005         return self.__field_location.getvalue()
3006 
3007     def __setfield_location(self, value):
3008         if isinstance(value,USTRING):
3009             self.__field_location=value
3010         else:
3011             self.__field_location=USTRING(value,**{'sizeinbytes': 14, 'raiseonunterminatedread': False, 'raiseontruncate': False, 'terminator': None})
3012 
3013     def __delfield_location(self): del self.__field_location
3014 
3015     location=property(__getfield_location, __setfield_location, __delfield_location, None)
3016 
3017     def __getfield_pad2(self):
3018         try: self.__field_pad2
3019         except:
3020             self.__field_pad2=UNKNOWN(**{'sizeinbytes': 7})
3021         return self.__field_pad2.getvalue()
3022 
3023     def __setfield_pad2(self, value):
3024         if isinstance(value,UNKNOWN):
3025             self.__field_pad2=value
3026         else:
3027             self.__field_pad2=UNKNOWN(value,**{'sizeinbytes': 7})
3028 
3029     def __delfield_pad2(self): del self.__field_pad2
3030 
3031     pad2=property(__getfield_pad2, __setfield_pad2, __delfield_pad2, None)
3032 
3033     def __getfield_location_len(self):
3034         return self.__field_location_len.getvalue()
3035 
3036     def __setfield_location_len(self, value):
3037         if isinstance(value,UINT):
3038             self.__field_location_len=value
3039         else:
3040             self.__field_location_len=UINT(value,**{'sizeinbytes': 1})
3041 
3042     def __delfield_location_len(self): del self.__field_location_len
3043 
3044     location_len=property(__getfield_location_len, __setfield_location_len, __delfield_location_len, None)
3045 
3046     def __getfield_ringtone(self):
3047         return self.__field_ringtone.getvalue()
3048 
3049     def __setfield_ringtone(self, value):
3050         if isinstance(value,UINT):
3051             self.__field_ringtone=value
3052         else:
3053             self.__field_ringtone=UINT(value,**{'sizeinbytes': 1})
3054 
3055     def __delfield_ringtone(self): del self.__field_ringtone
3056 
3057     ringtone=property(__getfield_ringtone, __setfield_ringtone, __delfield_ringtone, "0: Beep, 1: Voice, 2: Silent")
3058 
3059     def __getfield_alarmdiff(self):
3060         return self.__field_alarmdiff.getvalue()
3061 
3062     def __setfield_alarmdiff(self, value):
3063         if isinstance(value,UINT):
3064             self.__field_alarmdiff=value
3065         else:
3066             self.__field_alarmdiff=UINT(value,**{'sizeinbytes': 4})
3067 
3068     def __delfield_alarmdiff(self): del self.__field_alarmdiff
3069 
3070     alarmdiff=property(__getfield_alarmdiff, __setfield_alarmdiff, __delfield_alarmdiff, "Displayed alarm time")
3071 
3072     def __getfield_period(self):
3073         return self.__field_period.getvalue()
3074 
3075     def __setfield_period(self, value):
3076         if isinstance(value,UINT):
3077             self.__field_period=value
3078         else:
3079             self.__field_period=UINT(value,**{'sizeinbytes': 1})
3080 
3081     def __delfield_period(self): del self.__field_period
3082 
3083     period=property(__getfield_period, __setfield_period, __delfield_period, "No, Daily, Weekly, Monthly, Yearly")
3084 
3085     def __getfield_dom(self):
3086         return self.__field_dom.getvalue()
3087 
3088     def __setfield_dom(self, value):
3089         if isinstance(value,UINT):
3090             self.__field_dom=value
3091         else:
3092             self.__field_dom=UINT(value,**{'sizeinbytes': 1})
3093 
3094     def __delfield_dom(self): del self.__field_dom
3095 
3096     dom=property(__getfield_dom, __setfield_dom, __delfield_dom, "Day of month for the event")
3097 
3098     def __getfield_alarm(self):
3099         return self.__field_alarm.getvalue()
3100 
3101     def __setfield_alarm(self, value):
3102         if isinstance(value,UINT):
3103             self.__field_alarm=value
3104         else:
3105             self.__field_alarm=UINT(value,**{'sizeinbytes': 4})
3106 
3107     def __delfield_alarm(self): del self.__field_alarm
3108 
3109     alarm=property(__getfield_alarm, __setfield_alarm, __delfield_alarm, None)
3110 
3111     def __getfield_serial(self):
3112         try: self.__field_serial
3113         except:
3114             self.__field_serial=UINT(**{'sizeinbytes': 1, 'default': 0})
3115         return self.__field_serial.getvalue()
3116 
3117     def __setfield_serial(self, value):
3118         if isinstance(value,UINT):
3119             self.__field_serial=value
3120         else:
3121             self.__field_serial=UINT(value,**{'sizeinbytes': 1, 'default': 0})
3122 
3123     def __delfield_serial(self): del self.__field_serial
3124 
3125     serial=property(__getfield_serial, __setfield_serial, __delfield_serial, "Some kind of serial number")
3126 
3127     def iscontainer(self):
3128         return True
3129 
3130     def containerelements(self):
3131         yield ('slot', self.__field_slot, None)
3132         yield ('flag', self.__field_flag, "0: Not used, 1: Scheduled, 2: Already Happened")
3133         yield ('eventname', self.__field_eventname, None)
3134         yield ('pad1', self.__field_pad1, None)
3135         yield ('eventname_len', self.__field_eventname_len, None)
3136         yield ('start', self.__field_start, "# seconds since Jan 1, 1980 approximately")
3137         yield ('end', self.__field_end, None)
3138         yield ('location', self.__field_location, None)
3139         yield ('pad2', self.__field_pad2, None)
3140         yield ('location_len', self.__field_location_len, None)
3141         yield ('ringtone', self.__field_ringtone, "0: Beep, 1: Voice, 2: Silent")
3142         yield ('alarmdiff', self.__field_alarmdiff, "Displayed alarm time")
3143         yield ('period', self.__field_period, "No, Daily, Weekly, Monthly, Yearly")
3144         yield ('dom', self.__field_dom, "Day of month for the event")
3145         yield ('alarm', self.__field_alarm, None)
3146         yield ('serial', self.__field_serial, "Some kind of serial number")
3147 
3148 
3149 
3150 
3151 class eventresponse(BaseProtogenClass):
3152     __fields=['header', 'entry', 'pad']
3153 
3154     def __init__(self, *args, **kwargs):
3155         dict={}
3156         # What was supplied to this function
3157         dict.update(kwargs)
3158         # Parent constructor
3159         super(eventresponse,self).__init__(**dict)
3160         if self.__class__ is eventresponse:
3161             self._update(args,dict)
3162 
3163 
3164     def getfields(self):
3165         return self.__fields
3166 
3167 
3168     def _update(self, args, kwargs):
3169         super(eventresponse,self)._update(args,kwargs)
3170         keys=kwargs.keys()
3171         for key in keys:
3172             if key in self.__fields:
3173                 setattr(self, key, kwargs[key])
3174                 del kwargs[key]
3175         # Were any unrecognized kwargs passed in?
3176         if __debug__:
3177             self._complainaboutunusedargs(eventresponse,kwargs)
3178         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
3179         # Make all P fields that haven't already been constructed
3180 
3181 
3182     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
3183         'Writes this packet to the supplied buffer'
3184         self._bufferstartoffset=buf.getcurrentoffset()
3185         self.__field_header.writetobuffer(buf)
3186         self.__field_entry.writetobuffer(buf)
3187         self.__field_pad.writetobuffer(buf)
3188         self._bufferendoffset=buf.getcurrentoffset()
3189         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
3190 
3191 
3192     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
3193         'Reads this packet from the supplied buffer'
3194         self._bufferstartoffset=buf.getcurrentoffset()
3195         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
3196         self.__field_header=sanyoheader()
3197         self.__field_header.readfrombuffer(buf)
3198         self.__field_entry=evententry()
3199         self.__field_entry.readfrombuffer(buf)
3200         self.__field_pad=UNKNOWN(**{'sizeinbytes': 436})
3201         self.__field_pad.readfrombuffer(buf)
3202         self._bufferendoffset=buf.getcurrentoffset()
3203 
3204 
3205     def __getfield_header(self):
3206         return self.__field_header.getvalue()
3207 
3208     def __setfield_header(self, value):
3209         if isinstance(value,sanyoheader):
3210             self.__field_header=value
3211         else:
3212             self.__field_header=sanyoheader(value,)
3213 
3214     def __delfield_header(self): del self.__field_header
3215 
3216     header=property(__getfield_header, __setfield_header, __delfield_header, None)
3217 
3218     def __getfield_entry(self):
3219         return self.__field_entry.getvalue()
3220 
3221     def __setfield_entry(self, value):
3222         if isinstance(value,evententry):
3223             self.__field_entry=value
3224         else:
3225             self.__field_entry=evententry(value,)
3226 
3227     def __delfield_entry(self): del self.__field_entry
3228 
3229     entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None)
3230 
3231     def __getfield_pad(self):
3232         return self.__field_pad.getvalue()
3233 
3234     def __setfield_pad(self, value):
3235         if isinstance(value,UNKNOWN):
3236             self.__field_pad=value
3237         else:
3238             self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 436})
3239 
3240     def __delfield_pad(self): del self.__field_pad
3241 
3242     pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None)
3243 
3244     def iscontainer(self):
3245         return True
3246 
3247     def containerelements(self):
3248         yield ('header', self.__field_header, None)
3249         yield ('entry', self.__field_entry, None)
3250         yield ('pad', self.__field_pad, None)
3251 
3252 
3253 
3254 
3255 class eventupdaterequest(BaseProtogenClass):
3256     __fields=['header', 'entry', 'pad']
3257 
3258     def __init__(self, *args, **kwargs):
3259         dict={}
3260         # What was supplied to this function
3261         dict.update(kwargs)
3262         # Parent constructor
3263         super(eventupdaterequest,self).__init__(**dict)
3264         if self.__class__ is eventupdaterequest:
3265             self._update(args,dict)
3266 
3267 
3268     def getfields(self):
3269         return self.__fields
3270 
3271 
3272     def _update(self, args, kwargs):
3273         super(eventupdaterequest,self)._update(args,kwargs)
3274         keys=kwargs.keys()
3275         for key in keys:
3276             if key in self.__fields:
3277                 setattr(self, key, kwargs[key])
3278                 del kwargs[key]
3279         # Were any unrecognized kwargs passed in?
3280         if __debug__:
3281             self._complainaboutunusedargs(eventupdaterequest,kwargs)
3282         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
3283         # Make all P fields that haven't already been constructed
3284 
3285 
3286     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
3287         'Writes this packet to the supplied buffer'
3288         self._bufferstartoffset=buf.getcurrentoffset()
3289         try: self.__field_header
3290         except:
3291             self.__field_header=sanyoheader(**{'readwrite': 0x0e,                   'packettype': 0x0c, 'command':0x23})
3292         self.__field_header.writetobuffer(buf)
3293         self.__field_entry.writetobuffer(buf)
3294         try: self.__field_pad
3295         except:
3296             self.__field_pad=UNKNOWN(**{'sizeinbytes': 436})
3297         self.__field_pad.writetobuffer(buf)
3298         self._bufferendoffset=buf.getcurrentoffset()
3299         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
3300 
3301 
3302     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
3303         'Reads this packet from the supplied buffer'
3304         self._bufferstartoffset=buf.getcurrentoffset()
3305         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
3306         self.__field_header=sanyoheader(**{'readwrite': 0x0e,                   'packettype': 0x0c, 'command':0x23})
3307         self.__field_header.readfrombuffer(buf)
3308         self.__field_entry=evententry()
3309         self.__field_entry.readfrombuffer(buf)
3310         self.__field_pad=UNKNOWN(**{'sizeinbytes': 436})
3311         self.__field_pad.readfrombuffer(buf)
3312         self._bufferendoffset=buf.getcurrentoffset()
3313 
3314 
3315     def __getfield_header(self):
3316         try: self.__field_header
3317         except:
3318             self.__field_header=sanyoheader(**{'readwrite': 0x0e,                   'packettype': 0x0c, 'command':0x23})
3319         return self.__field_header.getvalue()
3320 
3321     def __setfield_header(self, value):
3322         if isinstance(value,sanyoheader):
3323             self.__field_header=value
3324         else:
3325             self.__field_header=sanyoheader(value,**{'readwrite': 0x0e,                   'packettype': 0x0c, 'command':0x23})
3326 
3327     def __delfield_header(self): del self.__field_header
3328 
3329     header=property(__getfield_header, __setfield_header, __delfield_header, None)
3330 
3331     def __getfield_entry(self):
3332         return self.__field_entry.getvalue()
3333 
3334     def __setfield_entry(self, value):
3335         if isinstance(value,evententry):
3336             self.__field_entry=value
3337         else:
3338             self.__field_entry=evententry(value,)
3339 
3340     def __delfield_entry(self): del self.__field_entry
3341 
3342     entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None)
3343 
3344     def __getfield_pad(self):
3345         try: self.__field_pad
3346         except:
3347             self.__field_pad=UNKNOWN(**{'sizeinbytes': 436})
3348         return self.__field_pad.getvalue()
3349 
3350     def __setfield_pad(self, value):
3351         if isinstance(value,UNKNOWN):
3352             self.__field_pad=value
3353         else:
3354             self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 436})
3355 
3356     def __delfield_pad(self): del self.__field_pad
3357 
3358     pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None)
3359 
3360     def iscontainer(self):
3361         return True
3362 
3363     def containerelements(self):
3364         yield ('header', self.__field_header, None)
3365         yield ('entry', self.__field_entry, None)
3366         yield ('pad', self.__field_pad, None)
3367 
3368 
3369 
3370 
3371 class callalarmrequest(BaseProtogenClass):
3372     __fields=['header', 'slot', 'pad']
3373 
3374     def __init__(self, *args, **kwargs):
3375         dict={}
3376         # What was supplied to this function
3377         dict.update(kwargs)
3378         # Parent constructor
3379         super(callalarmrequest,self).__init__(**dict)
3380         if self.__class__ is callalarmrequest:
3381             self._update(args,dict)
3382 
3383 
3384     def getfields(self):
3385         return self.__fields
3386 
3387 
3388     def _update(self, args, kwargs):
3389         super(callalarmrequest,self)._update(args,kwargs)
3390         keys=kwargs.keys()
3391         for key in keys:
3392             if key in self.__fields:
3393                 setattr(self, key, kwargs[key])
3394                 del kwargs[key]
3395         # Were any unrecognized kwargs passed in?
3396         if __debug__:
3397             self._complainaboutunusedargs(callalarmrequest,kwargs)
3398         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
3399         # Make all P fields that haven't already been constructed
3400 
3401 
3402     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
3403         'Writes this packet to the supplied buffer'
3404         self._bufferstartoffset=buf.getcurrentoffset()
3405         try: self.__field_header
3406         except:
3407             self.__field_header=sanyoheader(**{'packettype': 0x0c,                'command': 0x24})
3408         self.__field_header.writetobuffer(buf)
3409         self.__field_slot.writetobuffer(buf)
3410         try: self.__field_pad
3411         except:
3412             self.__field_pad=UNKNOWN(**{'sizeinbytes': 501})
3413         self.__field_pad.writetobuffer(buf)
3414         self._bufferendoffset=buf.getcurrentoffset()
3415         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
3416 
3417 
3418     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
3419         'Reads this packet from the supplied buffer'
3420         self._bufferstartoffset=buf.getcurrentoffset()
3421         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
3422         self.__field_header=sanyoheader(**{'packettype': 0x0c,                'command': 0x24})
3423         self.__field_header.readfrombuffer(buf)
3424         self.__field_slot=UINT(**{'sizeinbytes': 1})
3425         self.__field_slot.readfrombuffer(buf)
3426         self.__field_pad=UNKNOWN(**{'sizeinbytes': 501})
3427         self.__field_pad.readfrombuffer(buf)
3428         self._bufferendoffset=buf.getcurrentoffset()
3429 
3430 
3431     def __getfield_header(self):
3432         try: self.__field_header
3433         except:
3434             self.__field_header=sanyoheader(**{'packettype': 0x0c,                'command': 0x24})
3435         return self.__field_header.getvalue()
3436 
3437     def __setfield_header(self, value):
3438         if isinstance(value,sanyoheader):
3439             self.__field_header=value
3440         else:
3441             self.__field_header=sanyoheader(value,**{'packettype': 0x0c,                'command': 0x24})
3442 
3443     def __delfield_header(self): del self.__field_header
3444 
3445     header=property(__getfield_header, __setfield_header, __delfield_header, None)
3446 
3447     def __getfield_slot(self):
3448         return self.__field_slot.getvalue()
3449 
3450     def __setfield_slot(self, value):
3451         if isinstance(value,UINT):
3452             self.__field_slot=value
3453         else:
3454             self.__field_slot=UINT(value,**{'sizeinbytes': 1})
3455 
3456     def __delfield_slot(self): del self.__field_slot
3457 
3458     slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None)
3459 
3460     def __getfield_pad(self):
3461         try: self.__field_pad
3462         except:
3463             self.__field_pad=UNKNOWN(**{'sizeinbytes': 501})
3464         return self.__field_pad.getvalue()
3465 
3466     def __setfield_pad(self, value):
3467         if isinstance(value,UNKNOWN):
3468             self.__field_pad=value
3469         else:
3470             self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 501})
3471 
3472     def __delfield_pad(self): del self.__field_pad
3473 
3474     pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None)
3475 
3476     def iscontainer(self):
3477         return True
3478 
3479     def containerelements(self):
3480         yield ('header', self.__field_header, None)
3481         yield ('slot', self.__field_slot, None)
3482         yield ('pad', self.__field_pad, None)
3483 
3484 
3485 
3486 
3487 class callalarmentry(BaseProtogenClass):
3488     __fields=['ringtone', 'slot', 'flag', 'dunno1', 'phonenum', 'phonenum_len', 'date', 'period', 'dom', 'datedup', 'name', 'pad1', 'name_len', 'phonenumbertype', 'phonenumberslot', 'serial']
3489 
3490     def __init__(self, *args, **kwargs):
3491         dict={}
3492         # What was supplied to this function
3493         dict.update(kwargs)
3494         # Parent constructor
3495         super(callalarmentry,self).__init__(**dict)
3496         if self.__class__ is callalarmentry:
3497             self._update(args,dict)
3498 
3499 
3500     def getfields(self):
3501         return self.__fields
3502 
3503 
3504     def _update(self, args, kwargs):
3505         super(callalarmentry,self)._update(args,kwargs)
3506         keys=kwargs.keys()
3507         for key in keys:
3508             if key in self.__fields:
3509                 setattr(self, key, kwargs[key])
3510                 del kwargs[key]
3511         # Were any unrecognized kwargs passed in?
3512         if __debug__:
3513             self._complainaboutunusedargs(callalarmentry,kwargs)
3514         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
3515         # Make all P fields that haven't already been constructed
3516         try: self.__field_ringtone
3517         except:
3518             self.__field_ringtone=UINT(**{'constant': 0})
3519 
3520 
3521     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
3522         'Writes this packet to the supplied buffer'
3523         self._bufferstartoffset=buf.getcurrentoffset()
3524         self.__field_slot.writetobuffer(buf)
3525         self.__field_flag.writetobuffer(buf)
3526         try: self.__field_dunno1
3527         except:
3528             self.__field_dunno1=UINT(**{'sizeinbytes': 1, 'default': 0})
3529         self.__field_dunno1.writetobuffer(buf)
3530         self.__field_phonenum.writetobuffer(buf)
3531         self.__field_phonenum_len.writetobuffer(buf)
3532         self.__field_date.writetobuffer(buf)
3533         self.__field_period.writetobuffer(buf)
3534         self.__field_dom.writetobuffer(buf)
3535         self.__field_datedup.writetobuffer(buf)
3536         self.__field_name.writetobuffer(buf)
3537         try: self.__field_pad1
3538         except:
3539             self.__field_pad1=UNKNOWN(**{'sizeinbytes': 1})
3540         self.__field_pad1.writetobuffer(buf)
3541         self.__field_name_len.writetobuffer(buf)
3542         self.__field_phonenumbertype.writetobuffer(buf)
3543         self.__field_phonenumberslot.writetobuffer(buf)
3544         try: self.__field_serial
3545         except:
3546             self.__field_serial=UINT(**{'sizeinbytes': 1, 'default': 0})
3547         self.__field_serial.writetobuffer(buf)
3548         self._bufferendoffset=buf.getcurrentoffset()
3549         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
3550 
3551 
3552     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
3553         'Reads this packet from the supplied buffer'
3554         self._bufferstartoffset=buf.getcurrentoffset()
3555         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
3556         self.__field_slot=UINT(**{'sizeinbytes': 1})
3557         self.__field_slot.readfrombuffer(buf)
3558         self.__field_flag=UINT(**{'sizeinbytes': 1})
3559         self.__field_flag.readfrombuffer(buf)
3560         self.__field_dunno1=UINT(**{'sizeinbytes': 1, 'default': 0})
3561         self.__field_dunno1.readfrombuffer(buf)
3562         self.__field_phonenum=USTRING(**{'sizeinbytes': 49, 'raiseonunterminatedread': False})
3563         self.__field_phonenum.readfrombuffer(buf)
3564         self.__field_phonenum_len=UINT(**{'sizeinbytes': 1})
3565         self.__field_phonenum_len.readfrombuffer(buf)
3566         self.__field_date=UINT(**{'sizeinbytes': 4})
3567         self.__field_date.readfrombuffer(buf)
3568         self.__field_period=UINT(**{'sizeinbytes': 1})
3569         self.__field_period.readfrombuffer(buf)
3570         self.__field_dom=UINT(**{'sizeinbytes': 1})
3571         self.__field_dom.readfrombuffer(buf)
3572         self.__field_datedup=UINT(**{'sizeinbytes': 4})
3573         self.__field_datedup.readfrombuffer(buf)
3574         self.__field_name=USTRING(**{'sizeinbytes': 16, 'raiseonunterminatedread': False, 'raiseontruncate': False, 'terminator': None})
3575         self.__field_name.readfrombuffer(buf)
3576         self.__field_pad1=UNKNOWN(**{'sizeinbytes': 1})
3577         self.__field_pad1.readfrombuffer(buf)
3578         self.__field_name_len=UINT(**{'sizeinbytes': 1})
3579         self.__field_name_len.readfrombuffer(buf)
3580         self.__field_phonenumbertype=UINT(**{'sizeinbytes': 1})
3581         self.__field_phonenumbertype.readfrombuffer(buf)
3582         self.__field_phonenumberslot=UINT(**{'sizeinbytes': 2})
3583         self.__field_phonenumberslot.readfrombuffer(buf)
3584         self.__field_serial=UINT(**{'sizeinbytes': 1, 'default': 0})
3585         self.__field_serial.readfrombuffer(buf)
3586         self._bufferendoffset=buf.getcurrentoffset()
3587 
3588 
3589     def __getfield_ringtone(self):
3590         return self.__field_ringtone.getvalue()
3591 
3592     def __setfield_ringtone(self, value):
3593         if isinstance(value,UINT):
3594             self.__field_ringtone=value
3595         else:
3596             self.__field_ringtone=UINT(value,**{'constant': 0})
3597 
3598     def __delfield_ringtone(self): del self.__field_ringtone
3599 
3600     ringtone=property(__getfield_ringtone, __setfield_ringtone, __delfield_ringtone, None)
3601 
3602     def __getfield_slot(self):
3603         return self.__field_slot.getvalue()
3604 
3605     def __setfield_slot(self, value):
3606         if isinstance(value,UINT):
3607             self.__field_slot=value
3608         else:
3609             self.__field_slot=UINT(value,**{'sizeinbytes': 1})
3610 
3611     def __delfield_slot(self): del self.__field_slot
3612 
3613     slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None)
3614 
3615     def __getfield_flag(self):
3616         return self.__field_flag.getvalue()
3617 
3618     def __setfield_flag(self, value):
3619         if isinstance(value,UINT):
3620             self.__field_flag=value
3621         else:
3622             self.__field_flag=UINT(value,**{'sizeinbytes': 1})
3623 
3624     def __delfield_flag(self): del self.__field_flag
3625 
3626     flag=property(__getfield_flag, __setfield_flag, __delfield_flag, "0: Not used, 1: Scheduled, 2: Already Happened")
3627 
3628     def __getfield_dunno1(self):
3629         try: self.__field_dunno1
3630         except:
3631             self.__field_dunno1=UINT(**{'sizeinbytes': 1, 'default': 0})
3632         return self.__field_dunno1.getvalue()
3633 
3634     def __setfield_dunno1(self, value):
3635         if isinstance(value,UINT):
3636             self.__field_dunno1=value
3637         else:
3638             self.__field_dunno1=UINT(value,**{'sizeinbytes': 1, 'default': 0})
3639 
3640     def __delfield_dunno1(self): del self.__field_dunno1
3641 
3642     dunno1=property(__getfield_dunno1, __setfield_dunno1, __delfield_dunno1, "Related to Snooze?")
3643 
3644     def __getfield_phonenum(self):
3645         return self.__field_phonenum.getvalue()
3646 
3647     def __setfield_phonenum(self, value):
3648         if isinstance(value,USTRING):
3649             self.__field_phonenum=value
3650         else:
3651             self.__field_phonenum=USTRING(value,**{'sizeinbytes': 49, 'raiseonunterminatedread': False})
3652 
3653     def __delfield_phonenum(self): del self.__field_phonenum
3654 
3655     phonenum=property(__getfield_phonenum, __setfield_phonenum, __delfield_phonenum, None)
3656 
3657     def __getfield_phonenum_len(self):
3658         return self.__field_phonenum_len.getvalue()
3659 
3660     def __setfield_phonenum_len(self, value):
3661         if isinstance(value,UINT):
3662             self.__field_phonenum_len=value
3663         else:
3664             self.__field_phonenum_len=UINT(value,**{'sizeinbytes': 1})
3665 
3666     def __delfield_phonenum_len(self): del self.__field_phonenum_len
3667 
3668     phonenum_len=property(__getfield_phonenum_len, __setfield_phonenum_len, __delfield_phonenum_len, None)
3669 
3670     def __getfield_date(self):
3671         return self.__field_date.getvalue()
3672 
3673     def __setfield_date(self, value):
3674         if isinstance(value,UINT):
3675             self.__field_date=value
3676         else:
3677             self.__field_date=UINT(value,**{'sizeinbytes': 4})
3678 
3679     def __delfield_date(self): del self.__field_date
3680 
3681     date=property(__getfield_date, __setfield_date, __delfield_date, "# seconds since Jan 1, 1980 approximately")
3682 
3683     def __getfield_period(self):
3684         return self.__field_period.getvalue()
3685 
3686     def __setfield_period(self, value):
3687         if isinstance(value,UINT):
3688             self.__field_period=value
3689         else:
3690             self.__field_period=UINT(value,**{'sizeinbytes': 1})
3691 
3692     def __delfield_period(self): del self.__field_period
3693 
3694     period=property(__getfield_period, __setfield_period, __delfield_period, "No, Daily, Weekly, Monthly, Yearly")
3695 
3696     def __getfield_dom(self):
3697         return self.__field_dom.getvalue()
3698 
3699     def __setfield_dom(self, value):
3700         if isinstance(value,UINT):
3701             self.__field_dom=value
3702         else:
3703             self.__field_dom=UINT(value,**{'sizeinbytes': 1})
3704 
3705     def __delfield_dom(self): del self.__field_dom
3706 
3707     dom=property(__getfield_dom, __setfield_dom, __delfield_dom, "Day of month for the event")
3708 
3709     def __getfield_datedup(self):
3710         return self.__field_datedup.getvalue()
3711 
3712     def __setfield_datedup(self, value):
3713         if isinstance(value,UINT):
3714             self.__field_datedup=value
3715         else:
3716             self.__field_datedup=UINT(value,**{'sizeinbytes': 4})
3717 
3718     def __delfield_datedup(self): del self.__field_datedup
3719 
3720     datedup=property(__getfield_datedup, __setfield_datedup, __delfield_datedup, "Copy of the date.  Always the same???")
3721 
3722     def __getfield_name(self):
3723         return self.__field_name.getvalue()
3724 
3725     def __setfield_name(self, value):
3726         if isinstance(value,USTRING):
3727             self.__field_name=value
3728         else:
3729             self.__field_name=USTRING(value,**{'sizeinbytes': 16, 'raiseonunterminatedread': False, 'raiseontruncate': False, 'terminator': None})
3730 
3731     def __delfield_name(self): del self.__field_name
3732 
3733     name=property(__getfield_name, __setfield_name, __delfield_name, None)
3734 
3735     def __getfield_pad1(self):
3736         try: self.__field_pad1
3737         except:
3738             self.__field_pad1=UNKNOWN(**{'sizeinbytes': 1})
3739         return self.__field_pad1.getvalue()
3740 
3741     def __setfield_pad1(self, value):
3742         if isinstance(value,UNKNOWN):
3743             self.__field_pad1=value
3744         else:
3745             self.__field_pad1=UNKNOWN(value,**{'sizeinbytes': 1})
3746 
3747     def __delfield_pad1(self): del self.__field_pad1
3748 
3749     pad1=property(__getfield_pad1, __setfield_pad1, __delfield_pad1, None)
3750 
3751     def __getfield_name_len(self):
3752         return self.__field_name_len.getvalue()
3753 
3754     def __setfield_name_len(self, value):
3755         if isinstance(value,UINT):
3756             self.__field_name_len=value
3757         else:
3758             self.__field_name_len=UINT(value,**{'sizeinbytes': 1})
3759 
3760     def __delfield_name_len(self): del self.__field_name_len
3761 
3762     name_len=property(__getfield_name_len, __setfield_name_len, __delfield_name_len, None)
3763 
3764     def __getfield_phonenumbertype(self):
3765         return self.__field_phonenumbertype.getvalue()
3766 
3767     def __setfield_phonenumbertype(self, value):
3768         if isinstance(value,UINT):
3769             self.__field_phonenumbertype=value
3770         else:
3771             self.__field_phonenumbertype=UINT(value,**{'sizeinbytes': 1})
3772 
3773     def __delfield_phonenumbertype(self): del self.__field_phonenumbertype
3774 
3775     phonenumbertype=property(__getfield_phonenumbertype, __setfield_phonenumbertype, __delfield_phonenumbertype, "1: Home, 2: Work, ...")
3776 
3777     def __getfield_phonenumberslot(self):
3778         return self.__field_phonenumberslot.getvalue()
3779 
3780     def __setfield_phonenumberslot(self, value):
3781         if isinstance(value,UINT):
3782             self.__field_phonenumberslot=value
3783         else:
3784             self.__field_phonenumberslot=UINT(value,**{'sizeinbytes': 2})
3785 
3786     def __delfield_phonenumberslot(self): del self.__field_phonenumberslot
3787 
3788     phonenumberslot=property(__getfield_phonenumberslot, __setfield_phonenumberslot, __delfield_phonenumberslot, None)
3789 
3790     def __getfield_serial(self):
3791         try: self.__field_serial
3792         except:
3793             self.__field_serial=UINT(**{'sizeinbytes': 1, 'default': 0})
3794         return self.__field_serial.getvalue()
3795 
3796     def __setfield_serial(self, value):
3797         if isinstance(value,UINT):
3798             self.__field_serial=value
3799         else:
3800             self.__field_serial=UINT(value,**{'sizeinbytes': 1, 'default': 0})
3801 
3802     def __delfield_serial(self): del self.__field_serial
3803 
3804     serial=property(__getfield_serial, __setfield_serial, __delfield_serial, None)
3805 
3806     def iscontainer(self):
3807         return True
3808 
3809     def containerelements(self):
3810         yield ('ringtone', self.__field_ringtone, None)
3811         yield ('slot', self.__field_slot, None)
3812         yield ('flag', self.__field_flag, "0: Not used, 1: Scheduled, 2: Already Happened")
3813         yield ('dunno1', self.__field_dunno1, "Related to Snooze?")
3814         yield ('phonenum', self.__field_phonenum, None)
3815         yield ('phonenum_len', self.__field_phonenum_len, None)
3816         yield ('date', self.__field_date, "# seconds since Jan 1, 1980 approximately")
3817         yield ('period', self.__field_period, "No, Daily, Weekly, Monthly, Yearly")
3818         yield ('dom', self.__field_dom, "Day of month for the event")
3819         yield ('datedup', self.__field_datedup, "Copy of the date.  Always the same???")
3820         yield ('name', self.__field_name, None)
3821         yield ('pad1', self.__field_pad1, None)
3822         yield ('name_len', self.__field_name_len, None)
3823         yield ('phonenumbertype', self.__field_phonenumbertype, "1: Home, 2: Work, ...")
3824         yield ('phonenumberslot', self.__field_phonenumberslot, None)
3825         yield ('serial', self.__field_serial, None)
3826 
3827 
3828 
3829 
3830 class callalarmresponse(BaseProtogenClass):
3831     __fields=['header', 'entry', 'pad']
3832 
3833     def __init__(self, *args, **kwargs):
3834         dict={}
3835         # What was supplied to this function
3836         dict.update(kwargs)
3837         # Parent constructor
3838         super(callalarmresponse,self).__init__(**dict)
3839         if self.__class__ is callalarmresponse:
3840             self._update(args,dict)
3841 
3842 
3843     def getfields(self):
3844         return self.__fields
3845 
3846 
3847     def _update(self, args, kwargs):
3848         super(callalarmresponse,self)._update(args,kwargs)
3849         keys=kwargs.keys()
3850         for key in keys:
3851             if key in self.__fields:
3852                 setattr(self, key, kwargs[key])
3853                 del kwargs[key]
3854         # Were any unrecognized kwargs passed in?
3855         if __debug__:
3856             self._complainaboutunusedargs(callalarmresponse,kwargs)
3857         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
3858         # Make all P fields that haven't already been constructed
3859 
3860 
3861     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
3862         'Writes this packet to the supplied buffer'
3863         self._bufferstartoffset=buf.getcurrentoffset()
3864         self.__field_header.writetobuffer(buf)
3865         self.__field_entry.writetobuffer(buf)
3866         self.__field_pad.writetobuffer(buf)
3867         self._bufferendoffset=buf.getcurrentoffset()
3868         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
3869 
3870 
3871     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
3872         'Reads this packet from the supplied buffer'
3873         self._bufferstartoffset=buf.getcurrentoffset()
3874         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
3875         self.__field_header=sanyoheader()
3876         self.__field_header.readfrombuffer(buf)
3877         self.__field_entry=callalarmentry()
3878         self.__field_entry.readfrombuffer(buf)
3879         self.__field_pad=UNKNOWN(**{'sizeinbytes': 417})
3880         self.__field_pad.readfrombuffer(buf)
3881         self._bufferendoffset=buf.getcurrentoffset()
3882 
3883 
3884     def __getfield_header(self):
3885         return self.__field_header.getvalue()
3886 
3887     def __setfield_header(self, value):
3888         if isinstance(value,sanyoheader):
3889             self.__field_header=value
3890         else:
3891             self.__field_header=sanyoheader(value,)
3892 
3893     def __delfield_header(self): del self.__field_header
3894 
3895     header=property(__getfield_header, __setfield_header, __delfield_header, None)
3896 
3897     def __getfield_entry(self):
3898         return self.__field_entry.getvalue()
3899 
3900     def __setfield_entry(self, value):
3901         if isinstance(value,callalarmentry):
3902             self.__field_entry=value
3903         else:
3904             self.__field_entry=callalarmentry(value,)
3905 
3906     def __delfield_entry(self): del self.__field_entry
3907 
3908     entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None)
3909 
3910     def __getfield_pad(self):
3911         return self.__field_pad.getvalue()
3912 
3913     def __setfield_pad(self, value):
3914         if isinstance(value,UNKNOWN):
3915             self.__field_pad=value
3916         else:
3917             self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 417})
3918 
3919     def __delfield_pad(self): del self.__field_pad
3920 
3921     pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None)
3922 
3923     def iscontainer(self):
3924         return True
3925 
3926     def containerelements(self):
3927         yield ('header', self.__field_header, None)
3928         yield ('entry', self.__field_entry, None)
3929         yield ('pad', self.__field_pad, None)
3930 
3931 
3932 
3933 
3934 class callalarmupdaterequest(BaseProtogenClass):
3935     __fields=['header', 'entry', 'pad']
3936 
3937     def __init__(self, *args, **kwargs):
3938         dict={}
3939         # What was supplied to this function
3940         dict.update(kwargs)
3941         # Parent constructor
3942         super(callalarmupdaterequest,self).__init__(**dict)
3943         if self.__class__ is callalarmupdaterequest:
3944             self._update(args,dict)
3945 
3946 
3947     def getfields(self):
3948         return self.__fields
3949 
3950 
3951     def _update(self, args, kwargs):
3952         super(callalarmupdaterequest,self)._update(args,kwargs)
3953         keys=kwargs.keys()
3954         for key in keys:
3955             if key in self.__fields:
3956                 setattr(self, key, kwargs[key])
3957                 del kwargs[key]
3958         # Were any unrecognized kwargs passed in?
3959         if __debug__:
3960             self._complainaboutunusedargs(callalarmupdaterequest,kwargs)
3961         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
3962         # Make all P fields that haven't already been constructed
3963 
3964 
3965     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
3966         'Writes this packet to the supplied buffer'
3967         self._bufferstartoffset=buf.getcurrentoffset()
3968         try: self.__field_header
3969         except:
3970             self.__field_header=sanyoheader(**{'readwrite': 0x0e,                   'packettype': 0x0c, 'command':0x24})
3971         self.__field_header.writetobuffer(buf)
3972         self.__field_entry.writetobuffer(buf)
3973         try: self.__field_pad
3974         except:
3975             self.__field_pad=UNKNOWN(**{'sizeinbytes': 417})
3976         self.__field_pad.writetobuffer(buf)
3977         self._bufferendoffset=buf.getcurrentoffset()
3978         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
3979 
3980 
3981     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
3982         'Reads this packet from the supplied buffer'
3983         self._bufferstartoffset=buf.getcurrentoffset()
3984         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
3985         self.__field_header=sanyoheader(**{'readwrite': 0x0e,                   'packettype': 0x0c, 'command':0x24})
3986         self.__field_header.readfrombuffer(buf)
3987         self.__field_entry=callalarmentry()
3988         self.__field_entry.readfrombuffer(buf)
3989         self.__field_pad=UNKNOWN(**{'sizeinbytes': 417})
3990         self.__field_pad.readfrombuffer(buf)
3991         self._bufferendoffset=buf.getcurrentoffset()
3992 
3993 
3994     def __getfield_header(self):
3995         try: self.__field_header
3996         except:
3997             self.__field_header=sanyoheader(**{'readwrite': 0x0e,                   'packettype': 0x0c, 'command':0x24})
3998         return self.__field_header.getvalue()
3999 
4000     def __setfield_header(self, value):
4001         if isinstance(value,sanyoheader):
4002             self.__field_header=value
4003         else:
4004             self.__field_header=sanyoheader(value,**{'readwrite': 0x0e,                   'packettype': 0x0c, 'command':0x24})
4005 
4006     def __delfield_header(self): del self.__field_header
4007 
4008     header=property(__getfield_header, __setfield_header, __delfield_header, None)
4009 
4010     def __getfield_entry(self):
4011         return self.__field_entry.getvalue()
4012 
4013     def __setfield_entry(self, value):
4014         if isinstance(value,callalarmentry):
4015             self.__field_entry=value
4016         else:
4017             self.__field_entry=callalarmentry(value,)
4018 
4019     def __delfield_entry(self): del self.__field_entry
4020 
4021     entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None)
4022 
4023     def __getfield_pad(self):
4024         try: self.__field_pad
4025         except:
4026             self.__field_pad=UNKNOWN(**{'sizeinbytes': 417})
4027         return self.__field_pad.getvalue()
4028 
4029     def __setfield_pad(self, value):
4030         if isinstance(value,UNKNOWN):
4031             self.__field_pad=value
4032         else:
4033             self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 417})
4034 
4035     def __delfield_pad(self): del self.__field_pad
4036 
4037     pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None)
4038 
4039     def iscontainer(self):
4040         return True
4041 
4042     def containerelements(self):
4043         yield ('header', self.__field_header, None)
4044         yield ('entry', self.__field_entry, None)
4045         yield ('pad', self.__field_pad, None)
4046 
4047 
4048 
4049 
4050 class todorequest(BaseProtogenClass):
4051     __fields=['header', 'slot', 'pad']
4052 
4053     def __init__(self, *args, **kwargs):
4054         dict={}
4055         # What was supplied to this function
4056         dict.update(kwargs)
4057         # Parent constructor
4058         super(todorequest,self).__init__(**dict)
4059         if self.__class__ is todorequest:
4060             self._update(args,dict)
4061 
4062 
4063     def getfields(self):
4064         return self.__fields
4065 
4066 
4067     def _update(self, args, kwargs):
4068         super(todorequest,self)._update(args,kwargs)
4069         keys=kwargs.keys()
4070         for key in keys:
4071             if key in self.__fields:
4072                 setattr(self, key, kwargs[key])
4073                 del kwargs[key]
4074         # Were any unrecognized kwargs passed in?
4075         if __debug__:
4076             self._complainaboutunusedargs(todorequest,kwargs)
4077         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
4078         # Make all P fields that haven't already been constructed
4079 
4080 
4081     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
4082         'Writes this packet to the supplied buffer'
4083         self._bufferstartoffset=buf.getcurrentoffset()
4084         try: self.__field_header
4085         except:
4086             self.__field_header=sanyoheader(**{'packettype': 0x0c,                'command': 0x25})
4087         self.__field_header.writetobuffer(buf)
4088         self.__field_slot.writetobuffer(buf)
4089         try: self.__field_pad
4090         except:
4091             self.__field_pad=UNKNOWN(**{'sizeinbytes': 501})
4092         self.__field_pad.writetobuffer(buf)
4093         self._bufferendoffset=buf.getcurrentoffset()
4094         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
4095 
4096 
4097     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
4098         'Reads this packet from the supplied buffer'
4099         self._bufferstartoffset=buf.getcurrentoffset()
4100         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
4101         self.__field_header=sanyoheader(**{'packettype': 0x0c,                'command': 0x25})
4102         self.__field_header.readfrombuffer(buf)
4103         self.__field_slot=UINT(**{'sizeinbytes': 1})
4104         self.__field_slot.readfrombuffer(buf)
4105         self.__field_pad=UNKNOWN(**{'sizeinbytes': 501})
4106         self.__field_pad.readfrombuffer(buf)
4107         self._bufferendoffset=buf.getcurrentoffset()
4108 
4109 
4110     def __getfield_header(self):
4111         try: self.__field_header
4112         except:
4113             self.__field_header=sanyoheader(**{'packettype': 0x0c,                'command': 0x25})
4114         return self.__field_header.getvalue()
4115 
4116     def __setfield_header(self, value):
4117         if isinstance(value,sanyoheader):
4118             self.__field_header=value
4119         else:
4120             self.__field_header=sanyoheader(value,**{'packettype': 0x0c,                'command': 0x25})
4121 
4122     def __delfield_header(self): del self.__field_header
4123 
4124     header=property(__getfield_header, __setfield_header, __delfield_header, None)
4125 
4126     def __getfield_slot(self):
4127         return self.__field_slot.getvalue()
4128 
4129     def __setfield_slot(self, value):
4130         if isinstance(value,UINT):
4131             self.__field_slot=value
4132         else:
4133             self.__field_slot=UINT(value,**{'sizeinbytes': 1})
4134 
4135     def __delfield_slot(self): del self.__field_slot
4136 
4137     slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None)
4138 
4139     def __getfield_pad(self):
4140         try: self.__field_pad
4141         except:
4142             self.__field_pad=UNKNOWN(**{'sizeinbytes': 501})
4143         return self.__field_pad.getvalue()
4144 
4145     def __setfield_pad(self, value):
4146         if isinstance(value,UNKNOWN):
4147             self.__field_pad=value
4148         else:
4149             self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 501})
4150 
4151     def __delfield_pad(self): del self.__field_pad
4152 
4153     pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None)
4154 
4155     def iscontainer(self):
4156         return True
4157 
4158     def containerelements(self):
4159         yield ('header', self.__field_header, None)
4160         yield ('slot', self.__field_slot, None)
4161         yield ('pad', self.__field_pad, None)
4162 
4163 
4164 
4165 
4166 class todoentry(BaseProtogenClass):
4167     __fields=['slot', 'flag', 'todo', 'pad1', 'todo_len', 'priority', 'dunno', 'order']
4168 
4169     def __init__(self, *args, **kwargs):
4170         dict={}
4171         # What was supplied to this function
4172         dict.update(kwargs)
4173         # Parent constructor
4174         super(todoentry,self).__init__(**dict)
4175         if self.__class__ is todoentry:
4176             self._update(args,dict)
4177 
4178 
4179     def getfields(self):
4180         return self.__fields
4181 
4182 
4183     def _update(self, args, kwargs):
4184         super(todoentry,self)._update(args,kwargs)
4185         keys=kwargs.keys()
4186         for key in keys:
4187             if key in self.__fields:
4188                 setattr(self, key, kwargs[key])
4189                 del kwargs[key]
4190         # Were any unrecognized kwargs passed in?
4191         if __debug__:
4192             self._complainaboutunusedargs(todoentry,kwargs)
4193         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
4194         # Make all P fields that haven't already been constructed
4195 
4196 
4197     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
4198         'Writes this packet to the supplied buffer'
4199         self._bufferstartoffset=buf.getcurrentoffset()
4200         self.__field_slot.writetobuffer(buf)
4201         self.__field_flag.writetobuffer(buf)
4202         self.__field_todo.writetobuffer(buf)
4203         try: self.__field_pad1
4204         except:
4205             self.__field_pad1=UNKNOWN(**{'sizeinbytes': 7})
4206         self.__field_pad1.writetobuffer(buf)
4207         self.__field_todo_len.writetobuffer(buf)
4208         self.__field_priority.writetobuffer(buf)
4209         try: self.__field_dunno
4210         except:
4211             self.__field_dunno=UINT(**{'sizeinbytes': 1})
4212         self.__field_dunno.writetobuffer(buf)
4213         self.__field_order.writetobuffer(buf)
4214         self._bufferendoffset=buf.getcurrentoffset()
4215         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
4216 
4217 
4218     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
4219         'Reads this packet from the supplied buffer'
4220         self._bufferstartoffset=buf.getcurrentoffset()
4221         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
4222         self.__field_slot=UINT(**{'sizeinbytes': 1})
4223         self.__field_slot.readfrombuffer(buf)
4224         self.__field_flag=UINT(**{'sizeinbytes': 1})
4225         self.__field_flag.readfrombuffer(buf)
4226         self.__field_todo=USTRING(**{'sizeinbytes': 14, 'raiseonunterminatedread': False})
4227         self.__field_todo.readfrombuffer(buf)
4228         self.__field_pad1=UNKNOWN(**{'sizeinbytes': 7})
4229         self.__field_pad1.readfrombuffer(buf)
4230         self.__field_todo_len=UINT(**{'sizeinbytes': 1})
4231         self.__field_todo_len.readfrombuffer(buf)
4232         self.__field_priority=UINT(**{'sizeinbytes': 1})
4233         self.__field_priority.readfrombuffer(buf)
4234         self.__field_dunno=UINT(**{'sizeinbytes': 1})
4235         self.__field_dunno.readfrombuffer(buf)
4236         self.__field_order=UINT(**{'sizeinbytes': 1})
4237         self.__field_order.readfrombuffer(buf)
4238         self._bufferendoffset=buf.getcurrentoffset()
4239 
4240 
4241     def __getfield_slot(self):
4242         return self.__field_slot.getvalue()
4243 
4244     def __setfield_slot(self, value):
4245         if isinstance(value,UINT):
4246             self.__field_slot=value
4247         else:
4248             self.__field_slot=UINT(value,**{'sizeinbytes': 1})
4249 
4250     def __delfield_slot(self): del self.__field_slot
4251 
4252     slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None)
4253 
4254     def __getfield_flag(self):
4255         return self.__field_flag.getvalue()
4256 
4257     def __setfield_flag(self, value):
4258         if isinstance(value,UINT):
4259             self.__field_flag=value
4260         else:
4261             self.__field_flag=UINT(value,**{'sizeinbytes': 1})
4262 
4263     def __delfield_flag(self): del self.__field_flag
4264 
4265     flag=property(__getfield_flag, __setfield_flag, __delfield_flag, "0: Not used, 1: Used")
4266 
4267     def __getfield_todo(self):
4268         return self.__field_todo.getvalue()
4269 
4270     def __setfield_todo(self, value):
4271         if isinstance(value,USTRING):
4272             self.__field_todo=value
4273         else:
4274             self.__field_todo=USTRING(value,**{'sizeinbytes': 14, 'raiseonunterminatedread': False})
4275 
4276     def __delfield_todo(self): del self.__field_todo
4277 
4278     todo=property(__getfield_todo, __setfield_todo, __delfield_todo, None)
4279 
4280     def __getfield_pad1(self):
4281         try: self.__field_pad1
4282         except:
4283             self.__field_pad1=UNKNOWN(**{'sizeinbytes': 7})
4284         return self.__field_pad1.getvalue()
4285 
4286     def __setfield_pad1(self, value):
4287         if isinstance(value,UNKNOWN):
4288             self.__field_pad1=value
4289         else:
4290             self.__field_pad1=UNKNOWN(value,**{'sizeinbytes': 7})
4291 
4292     def __delfield_pad1(self): del self.__field_pad1
4293 
4294     pad1=property(__getfield_pad1, __setfield_pad1, __delfield_pad1, None)
4295 
4296     def __getfield_todo_len(self):
4297         return self.__field_todo_len.getvalue()
4298 
4299     def __setfield_todo_len(self, value):
4300         if isinstance(value,UINT):
4301             self.__field_todo_len=value
4302         else:
4303             self.__field_todo_len=UINT(value,**{'sizeinbytes': 1})
4304 
4305     def __delfield_todo_len(self): del self.__field_todo_len
4306 
4307     todo_len=property(__getfield_todo_len, __setfield_todo_len, __delfield_todo_len, None)
4308 
4309     def __getfield_priority(self):
4310         return self.__field_priority.getvalue()
4311 
4312     def __setfield_priority(self, value):
4313         if isinstance(value,UINT):
4314             self.__field_priority=value
4315         else:
4316             self.__field_priority=UINT(value,**{'sizeinbytes': 1})
4317 
4318     def __delfield_priority(self): del self.__field_priority
4319 
4320     priority=property(__getfield_priority, __setfield_priority, __delfield_priority, "0: Normal, 1: Urgent, 2: Done")
4321 
4322     def __getfield_dunno(self):
4323         try: self.__field_dunno
4324         except:
4325             self.__field_dunno=UINT(**{'sizeinbytes': 1})
4326         return self.__field_dunno.getvalue()
4327 
4328     def __setfield_dunno(self, value):
4329         if isinstance(value,UINT):
4330             self.__field_dunno=value
4331         else:
4332             self.__field_dunno=UINT(value,**{'sizeinbytes': 1})
4333 
4334     def __delfield_dunno(self): del self.__field_dunno
4335 
4336     dunno=property(__getfield_dunno, __setfield_dunno, __delfield_dunno, "Maybe always zero")
4337 
4338     def __getfield_order(self):
4339         return self.__field_order.getvalue()
4340 
4341     def __setfield_order(self, value):
4342         if isinstance(value,UINT):
4343             self.__field_order=value
4344         else:
4345             self.__field_order=UINT(value,**{'sizeinbytes': 1})
4346 
4347     def __delfield_order(self): del self.__field_order
4348 
4349     order=property(__getfield_order, __setfield_order, __delfield_order, "Gets sorted on screen in this order")
4350 
4351     def iscontainer(self):
4352         return True
4353 
4354     def containerelements(self):
4355         yield ('slot', self.__field_slot, None)
4356         yield ('flag', self.__field_flag, "0: Not used, 1: Used")
4357         yield ('todo', self.__field_todo, None)
4358         yield ('pad1', self.__field_pad1, None)
4359         yield ('todo_len', self.__field_todo_len, None)
4360         yield ('priority', self.__field_priority, "0: Normal, 1: Urgent, 2: Done")
4361         yield ('dunno', self.__field_dunno, "Maybe always zero")
4362         yield ('order', self.__field_order, "Gets sorted on screen in this order")
4363 
4364 
4365 
4366 
4367 class todoresponse(BaseProtogenClass):
4368     __fields=['header', 'entry', 'pad']
4369 
4370     def __init__(self, *args, **kwargs):
4371         dict={}
4372         # What was supplied to this function
4373         dict.update(kwargs)
4374         # Parent constructor
4375         super(todoresponse,self).__init__(**dict)
4376         if self.__class__ is todoresponse:
4377             self._update(args,dict)
4378 
4379 
4380     def getfields(self):
4381         return self.__fields
4382 
4383 
4384     def _update(self, args, kwargs):
4385         super(todoresponse,self)._update(args,kwargs)
4386         keys=kwargs.keys()
4387         for key in keys:
4388             if key in self.__fields:
4389                 setattr(self, key, kwargs[key])
4390                 del kwargs[key]
4391         # Were any unrecognized kwargs passed in?
4392         if __debug__:
4393             self._complainaboutunusedargs(todoresponse,kwargs)
4394         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
4395         # Make all P fields that haven't already been constructed
4396 
4397 
4398     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
4399         'Writes this packet to the supplied buffer'
4400         self._bufferstartoffset=buf.getcurrentoffset()
4401         self.__field_header.writetobuffer(buf)
4402         self.__field_entry.writetobuffer(buf)
4403         self.__field_pad.writetobuffer(buf)
4404         self._bufferendoffset=buf.getcurrentoffset()
4405         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
4406 
4407 
4408     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
4409         'Reads this packet from the supplied buffer'
4410         self._bufferstartoffset=buf.getcurrentoffset()
4411         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
4412         self.__field_header=sanyoheader()
4413         self.__field_header.readfrombuffer(buf)
4414         self.__field_entry=todoentry()
4415         self.__field_entry.readfrombuffer(buf)
4416         self.__field_pad=UNKNOWN(**{'sizeinbytes': 472})
4417         self.__field_pad.readfrombuffer(buf)
4418         self._bufferendoffset=buf.getcurrentoffset()
4419 
4420 
4421     def __getfield_header(self):
4422         return self.__field_header.getvalue()
4423 
4424     def __setfield_header(self, value):
4425         if isinstance(value,sanyoheader):
4426             self.__field_header=value
4427         else:
4428             self.__field_header=sanyoheader(value,)
4429 
4430     def __delfield_header(self): del self.__field_header
4431 
4432     header=property(__getfield_header, __setfield_header, __delfield_header, None)
4433 
4434     def __getfield_entry(self):
4435         return self.__field_entry.getvalue()
4436 
4437     def __setfield_entry(self, value):
4438         if isinstance(value,todoentry):
4439             self.__field_entry=value
4440         else:
4441             self.__field_entry=todoentry(value,)
4442 
4443     def __delfield_entry(self): del self.__field_entry
4444 
4445     entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None)
4446 
4447     def __getfield_pad(self):
4448         return self.__field_pad.getvalue()
4449 
4450     def __setfield_pad(self, value):
4451         if isinstance(value,UNKNOWN):
4452             self.__field_pad=value
4453         else:
4454             self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 472})
4455 
4456     def __delfield_pad(self): del self.__field_pad
4457 
4458     pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None)
4459 
4460     def iscontainer(self):
4461         return True
4462 
4463     def containerelements(self):
4464         yield ('header', self.__field_header, None)
4465         yield ('entry', self.__field_entry, None)
4466         yield ('pad', self.__field_pad, None)
4467 
4468 
4469 
4470 
4471 class holidaybitsrequest(BaseProtogenClass):
4472     __fields=['unknown']
4473 
4474     def __init__(self, *args, **kwargs):
4475         dict={}
4476         # What was supplied to this function
4477         dict.update(kwargs)
4478         # Parent constructor
4479         super(holidaybitsrequest,self).__init__(**dict)
4480         if self.__class__ is holidaybitsrequest:
4481             self._update(args,dict)
4482 
4483 
4484     def getfields(self):
4485         return self.__fields
4486 
4487 
4488     def _update(self, args, kwargs):
4489         super(holidaybitsrequest,self)._update(args,kwargs)
4490         keys=kwargs.keys()
4491         for key in keys:
4492             if key in self.__fields:
4493                 setattr(self, key, kwargs[key])
4494                 del kwargs[key]
4495         # Were any unrecognized kwargs passed in?
4496         if __debug__:
4497             self._complainaboutunusedargs(holidaybitsrequest,kwargs)
4498         if len(args):
4499             dict2={}
4500             dict2.update(kwargs)
4501             kwargs=dict2
4502             self.__field_unknown=UNKNOWN(*args,**dict2)
4503         # Make all P fields that haven't already been constructed
4504 
4505 
4506     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
4507         'Writes this packet to the supplied buffer'
4508         self._bufferstartoffset=buf.getcurrentoffset()
4509         self.__field_unknown.writetobuffer(buf)
4510         self._bufferendoffset=buf.getcurrentoffset()
4511         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
4512 
4513 
4514     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
4515         'Reads this packet from the supplied buffer'
4516         self._bufferstartoffset=buf.getcurrentoffset()
4517         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
4518         self.__field_unknown=UNKNOWN()
4519         self.__field_unknown.readfrombuffer(buf)
4520         self._bufferendoffset=buf.getcurrentoffset()
4521 
4522 
4523     def __getfield_unknown(self):
4524         return self.__field_unknown.getvalue()
4525 
4526     def __setfield_unknown(self, value):
4527         if isinstance(value,UNKNOWN):
4528             self.__field_unknown=value
4529         else:
4530             self.__field_unknown=UNKNOWN(value,)
4531 
4532     def __delfield_unknown(self): del self.__field_unknown
4533 
4534     unknown=property(__getfield_unknown, __setfield_unknown, __delfield_unknown, None)
4535 
4536     def iscontainer(self):
4537         return True
4538 
4539     def containerelements(self):
4540         yield ('unknown', self.__field_unknown, None)
4541 
4542 
4543 
4544 
4545 class holidaybitsresponse(BaseProtogenClass):
4546     __fields=['unknown']
4547 
4548     def __init__(self, *args, **kwargs):
4549         dict={}
4550         # What was supplied to this function
4551         dict.update(kwargs)
4552         # Parent constructor
4553         super(holidaybitsresponse,self).__init__(**dict)
4554         if self.__class__ is holidaybitsresponse:
4555             self._update(args,dict)
4556 
4557 
4558     def getfields(self):
4559         return self.__fields
4560 
4561 
4562     def _update(self, args, kwargs):
4563         super(holidaybitsresponse,self)._update(args,kwargs)
4564         keys=kwargs.keys()
4565         for key in keys:
4566             if key in self.__fields:
4567                 setattr(self, key, kwargs[key])
4568                 del kwargs[key]
4569         # Were any unrecognized kwargs passed in?
4570         if __debug__:
4571             self._complainaboutunusedargs(holidaybitsresponse,kwargs)
4572         if len(args):
4573             dict2={}
4574             dict2.update(kwargs)
4575             kwargs=dict2
4576             self.__field_unknown=UNKNOWN(*args,**dict2)
4577         # Make all P fields that haven't already been constructed
4578 
4579 
4580     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
4581         'Writes this packet to the supplied buffer'
4582         self._bufferstartoffset=buf.getcurrentoffset()
4583         self.__field_unknown.writetobuffer(buf)
4584         self._bufferendoffset=buf.getcurrentoffset()
4585         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
4586 
4587 
4588     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
4589         'Reads this packet from the supplied buffer'
4590         self._bufferstartoffset=buf.getcurrentoffset()
4591         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
4592         self.__field_unknown=UNKNOWN()
4593         self.__field_unknown.readfrombuffer(buf)
4594         self._bufferendoffset=buf.getcurrentoffset()
4595 
4596 
4597     def __getfield_unknown(self):
4598         return self.__field_unknown.getvalue()
4599 
4600     def __setfield_unknown(self, value):
4601         if isinstance(value,UNKNOWN):
4602             self.__field_unknown=value
4603         else:
4604             self.__field_unknown=UNKNOWN(value,)
4605 
4606     def __delfield_unknown(self): del self.__field_unknown
4607 
4608     unknown=property(__getfield_unknown, __setfield_unknown, __delfield_unknown, None)
4609 
4610     def iscontainer(self):
4611         return True
4612 
4613     def containerelements(self):
4614         yield ('unknown', self.__field_unknown, None)
4615 
4616 
4617 
4618 
4619 class weeklyholidaybitsrequest(BaseProtogenClass):
4620     __fields=['unknown']
4621 
4622     def __init__(self, *args, **kwargs):
4623         dict={}
4624         # What was supplied to this function
4625         dict.update(kwargs)
4626         # Parent constructor
4627         super(weeklyholidaybitsrequest,self).__init__(**dict)
4628         if self.__class__ is weeklyholidaybitsrequest:
4629             self._update(args,dict)
4630 
4631 
4632     def getfields(self):
4633         return self.__fields
4634 
4635 
4636     def _update(self, args, kwargs):
4637         super(weeklyholidaybitsrequest,self)._update(args,kwargs)
4638         keys=kwargs.keys()
4639         for key in keys:
4640             if key in self.__fields:
4641                 setattr(self, key, kwargs[key])
4642                 del kwargs[key]
4643         # Were any unrecognized kwargs passed in?
4644         if __debug__:
4645             self._complainaboutunusedargs(weeklyholidaybitsrequest,kwargs)
4646         if len(args):
4647             dict2={}
4648             dict2.update(kwargs)
4649             kwargs=dict2
4650             self.__field_unknown=UNKNOWN(*args,**dict2)
4651         # Make all P fields that haven't already been constructed
4652 
4653 
4654     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
4655         'Writes this packet to the supplied buffer'
4656         self._bufferstartoffset=buf.getcurrentoffset()
4657         self.__field_unknown.writetobuffer(buf)
4658         self._bufferendoffset=buf.getcurrentoffset()
4659         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
4660 
4661 
4662     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
4663         'Reads this packet from the supplied buffer'
4664         self._bufferstartoffset=buf.getcurrentoffset()
4665         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
4666         self.__field_unknown=UNKNOWN()
4667         self.__field_unknown.readfrombuffer(buf)
4668         self._bufferendoffset=buf.getcurrentoffset()
4669 
4670 
4671     def __getfield_unknown(self):
4672         return self.__field_unknown.getvalue()
4673 
4674     def __setfield_unknown(self, value):
4675         if isinstance(value,UNKNOWN):
4676             self.__field_unknown=value
4677         else:
4678             self.__field_unknown=UNKNOWN(value,)
4679 
4680     def __delfield_unknown(self): del self.__field_unknown
4681 
4682     unknown=property(__getfield_unknown, __setfield_unknown, __delfield_unknown, None)
4683 
4684     def iscontainer(self):
4685         return True
4686 
4687     def containerelements(self):
4688         yield ('unknown', self.__field_unknown, None)
4689 
4690 
4691 
4692 
4693 class weeklyholidaybitsresponse(BaseProtogenClass):
4694     __fields=['unknown']
4695 
4696     def __init__(self, *args, **kwargs):
4697         dict={}
4698         # What was supplied to this function
4699         dict.update(kwargs)
4700         # Parent constructor
4701         super(weeklyholidaybitsresponse,self).__init__(**dict)
4702         if self.__class__ is weeklyholidaybitsresponse:
4703             self._update(args,dict)
4704 
4705 
4706     def getfields(self):
4707         return self.__fields
4708 
4709 
4710     def _update(self, args, kwargs):
4711         super(weeklyholidaybitsresponse,self)._update(args,kwargs)
4712         keys=kwargs.keys()
4713         for key in keys:
4714             if key in self.__fields:
4715                 setattr(self, key, kwargs[key])
4716                 del kwargs[key]
4717         # Were any unrecognized kwargs passed in?
4718         if __debug__:
4719             self._complainaboutunusedargs(weeklyholidaybitsresponse,kwargs)
4720         if len(args):
4721             dict2={}
4722             dict2.update(kwargs)
4723             kwargs=dict2
4724             self.__field_unknown=UNKNOWN(*args,**dict2)
4725         # Make all P fields that haven't already been constructed
4726 
4727 
4728     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
4729         'Writes this packet to the supplied buffer'
4730         self._bufferstartoffset=buf.getcurrentoffset()
4731         self.__field_unknown.writetobuffer(buf)
4732         self._bufferendoffset=buf.getcurrentoffset()
4733         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
4734 
4735 
4736     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
4737         'Reads this packet from the supplied buffer'
4738         self._bufferstartoffset=buf.getcurrentoffset()
4739         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
4740         self.__field_unknown=UNKNOWN()
4741         self.__field_unknown.readfrombuffer(buf)
4742         self._bufferendoffset=buf.getcurrentoffset()
4743 
4744 
4745     def __getfield_unknown(self):
4746         return self.__field_unknown.getvalue()
4747 
4748     def __setfield_unknown(self, value):
4749         if isinstance(value,UNKNOWN):
4750             self.__field_unknown=value
4751         else:
4752             self.__field_unknown=UNKNOWN(value,)
4753 
4754     def __delfield_unknown(self): del self.__field_unknown
4755 
4756     unknown=property(__getfield_unknown, __setfield_unknown, __delfield_unknown, None)
4757 
4758     def iscontainer(self):
4759         return True
4760 
4761     def containerelements(self):
4762         yield ('unknown', self.__field_unknown, None)
4763 
4764 
4765 
4766 
4767 class foldernamerequest(BaseProtogenClass):
4768     __fields=['header', 'index', 'pad']
4769 
4770     def __init__(self, *args, **kwargs):
4771         dict={}
4772         # What was supplied to this function
4773         dict.update(kwargs)
4774         # Parent constructor
4775         super(foldernamerequest,self).__init__(**dict)
4776         if self.__class__ is foldernamerequest:
4777             self._update(args,dict)
4778 
4779 
4780     def getfields(self):
4781         return self.__fields
4782 
4783 
4784     def _update(self, args, kwargs):
4785         super(foldernamerequest,self)._update(args,kwargs)
4786         keys=kwargs.keys()
4787         for key in keys:
4788             if key in self.__fields:
4789                 setattr(self, key, kwargs[key])
4790                 del kwargs[key]
4791         # Were any unrecognized kwargs passed in?
4792         if __debug__:
4793             self._complainaboutunusedargs(foldernamerequest,kwargs)
4794         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
4795         # Make all P fields that haven't already been constructed
4796 
4797 
4798     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
4799         'Writes this packet to the supplied buffer'
4800         self._bufferstartoffset=buf.getcurrentoffset()
4801         try: self.__field_header
4802         except:
4803             self.__field_header=sanyoheader(**{'packettype': 0x0b,                   'command': 0xef})
4804         self.__field_header.writetobuffer(buf)
4805         self.__field_index.writetobuffer(buf)
4806         try: self.__field_pad
4807         except:
4808             self.__field_pad=UNKNOWN(**{'sizeinbytes': 501})
4809         self.__field_pad.writetobuffer(buf)
4810         self._bufferendoffset=buf.getcurrentoffset()
4811         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
4812 
4813 
4814     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
4815         'Reads this packet from the supplied buffer'
4816         self._bufferstartoffset=buf.getcurrentoffset()
4817         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
4818         self.__field_header=sanyoheader(**{'packettype': 0x0b,                   'command': 0xef})
4819         self.__field_header.readfrombuffer(buf)
4820         self.__field_index=UINT(**{'sizeinbytes': 1})
4821         self.__field_index.readfrombuffer(buf)
4822         self.__field_pad=UNKNOWN(**{'sizeinbytes': 501})
4823         self.__field_pad.readfrombuffer(buf)
4824         self._bufferendoffset=buf.getcurrentoffset()
4825 
4826 
4827     def __getfield_header(self):
4828         try: self.__field_header
4829         except:
4830             self.__field_header=sanyoheader(**{'packettype': 0x0b,                   'command': 0xef})
4831         return self.__field_header.getvalue()
4832 
4833     def __setfield_header(self, value):
4834         if isinstance(value,sanyoheader):
4835             self.__field_header=value
4836         else:
4837             self.__field_header=sanyoheader(value,**{'packettype': 0x0b,                   'command': 0xef})
4838 
4839     def __delfield_header(self): del self.__field_header
4840 
4841     header=property(__getfield_header, __setfield_header, __delfield_header, None)
4842 
4843     def __getfield_index(self):
4844         return self.__field_index.getvalue()
4845 
4846     def __setfield_index(self, value):
4847         if isinstance(value,UINT):
4848             self.__field_index=value
4849         else:
4850             self.__field_index=UINT(value,**{'sizeinbytes': 1})
4851 
4852     def __delfield_index(self): del self.__field_index
4853 
4854     index=property(__getfield_index, __setfield_index, __delfield_index, None)
4855 
4856     def __getfield_pad(self):
4857         try: self.__field_pad
4858         except:
4859             self.__field_pad=UNKNOWN(**{'sizeinbytes': 501})
4860         return self.__field_pad.getvalue()
4861 
4862     def __setfield_pad(self, value):
4863         if isinstance(value,UNKNOWN):
4864             self.__field_pad=value
4865         else:
4866             self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 501})
4867 
4868     def __delfield_pad(self): del self.__field_pad
4869 
4870     pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None)
4871 
4872     def iscontainer(self):
4873         return True
4874 
4875     def containerelements(self):
4876         yield ('header', self.__field_header, None)
4877         yield ('index', self.__field_index, None)
4878         yield ('pad', self.__field_pad, None)
4879 
4880 
4881 
4882 
4883 class foldernameentry(BaseProtogenClass):
4884     __fields=['index', 'flag', 'autofile', 'notify', 'icon', 'name', 'pad', 'keyword']
4885 
4886     def __init__(self, *args, **kwargs):
4887         dict={}
4888         # What was supplied to this function
4889         dict.update(kwargs)
4890         # Parent constructor
4891         super(foldernameentry,self).__init__(**dict)
4892         if self.__class__ is foldernameentry:
4893             self._update(args,dict)
4894 
4895 
4896     def getfields(self):
4897         return self.__fields
4898 
4899 
4900     def _update(self, args, kwargs):
4901         super(foldernameentry,self)._update(args,kwargs)
4902         keys=kwargs.keys()
4903         for key in keys:
4904             if key in self.__fields:
4905                 setattr(self, key, kwargs[key])
4906                 del kwargs[key]
4907         # Were any unrecognized kwargs passed in?
4908         if __debug__:
4909             self._complainaboutunusedargs(foldernameentry,kwargs)
4910         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
4911         # Make all P fields that haven't already been constructed
4912 
4913 
4914     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
4915         'Writes this packet to the supplied buffer'
4916         self._bufferstartoffset=buf.getcurrentoffset()
4917         self.__field_index.writetobuffer(buf)
4918         self.__field_flag.writetobuffer(buf)
4919         self.__field_autofile.writetobuffer(buf)
4920         self.__field_notify.writetobuffer(buf)
4921         self.__field_icon.writetobuffer(buf)
4922         self.__field_name.writetobuffer(buf)
4923         try: self.__field_pad
4924         except:
4925             self.__field_pad=UNKNOWN(**{'sizeinbytes': 3})
4926         self.__field_pad.writetobuffer(buf)
4927         self.__field_keyword.writetobuffer(buf)
4928         self._bufferendoffset=buf.getcurrentoffset()
4929         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
4930 
4931 
4932     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
4933         'Reads this packet from the supplied buffer'
4934         self._bufferstartoffset=buf.getcurrentoffset()
4935         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
4936         self.__field_index=UINT(**{'sizeinbytes': 1})
4937         self.__field_index.readfrombuffer(buf)
4938         self.__field_flag=UINT(**{'sizeinbytes': 1})
4939         self.__field_flag.readfrombuffer(buf)
4940         self.__field_autofile=UINT(**{'sizeinbytes': 1})
4941         self.__field_autofile.readfrombuffer(buf)
4942         self.__field_notify=UINT(**{'sizeinbytes': 1})
4943         self.__field_notify.readfrombuffer(buf)
4944         self.__field_icon=UINT(**{'sizeinbytes': 1})
4945         self.__field_icon.readfrombuffer(buf)
4946         self.__field_name=USTRING(**{'sizeinbytes': 13, 'raiseonunterminatedread': False})
4947         self.__field_name.readfrombuffer(buf)
4948         self.__field_pad=UNKNOWN(**{'sizeinbytes': 3})
4949         self.__field_pad.readfrombuffer(buf)
4950         self.__field_keyword=USTRING(**{'sizeinbytes': 14, 'raiseonunterminatedread': False})
4951         self.__field_keyword.readfrombuffer(buf)
4952         self._bufferendoffset=buf.getcurrentoffset()
4953 
4954 
4955     def __getfield_index(self):
4956         return self.__field_index.getvalue()
4957 
4958     def __setfield_index(self, value):
4959         if isinstance(value,UINT):
4960             self.__field_index=value
4961         else:
4962             self.__field_index=UINT(value,**{'sizeinbytes': 1})
4963 
4964     def __delfield_index(self): del self.__field_index
4965 
4966     index=property(__getfield_index, __setfield_index, __delfield_index, None)
4967 
4968     def __getfield_flag(self):
4969         return self.__field_flag.getvalue()
4970 
4971     def __setfield_flag(self, value):
4972         if isinstance(value,UINT):
4973             self.__field_flag=value
4974         else:
4975             self.__field_flag=UINT(value,**{'sizeinbytes': 1})
4976 
4977     def __delfield_flag(self): del self.__field_flag
4978 
4979     flag=property(__getfield_flag, __setfield_flag, __delfield_flag, "0 if empty, 1 in use")
4980 
4981     def __getfield_autofile(self):
4982         return self.__field_autofile.getvalue()
4983 
4984     def __setfield_autofile(self, value):
4985         if isinstance(value,UINT):
4986             self.__field_autofile=value
4987         else:
4988             self.__field_autofile=UINT(value,**{'sizeinbytes': 1})
4989 
4990     def __delfield_autofile(self): del self.__field_autofile
4991 
4992     autofile=property(__getfield_autofile, __setfield_autofile, __delfield_autofile, "If 1, autofile messages with keyword")
4993 
4994     def __getfield_notify(self):
4995         return self.__field_notify.getvalue()
4996 
4997     def __setfield_notify(self, value):
4998         if isinstance(value,UINT):
4999             self.__field_notify=value
5000         else:
5001             self.__field_notify=UINT(value,**{'sizeinbytes': 1})
5002 
5003     def __delfield_notify(self): del self.__field_notify
5004 
5005     notify=property(__getfield_notify, __setfield_notify, __delfield_notify, None)
5006 
5007     def __getfield_icon(self):
5008         return self.__field_icon.getvalue()
5009 
5010     def __setfield_icon(self, value):
5011         if isinstance(value,UINT):
5012             self.__field_icon=value
5013         else:
5014             self.__field_icon=UINT(value,**{'sizeinbytes': 1})
5015 
5016     def __delfield_icon(self): del self.__field_icon
5017 
5018     icon=property(__getfield_icon, __setfield_icon, __delfield_icon, None)
5019 
5020     def __getfield_name(self):
5021         return self.__field_name.getvalue()
5022 
5023     def __setfield_name(self, value):
5024         if isinstance(value,USTRING):
5025             self.__field_name=value
5026         else:
5027             self.__field_name=USTRING(value,**{'sizeinbytes': 13, 'raiseonunterminatedread': False})
5028 
5029     def __delfield_name(self): del self.__field_name
5030 
5031     name=property(__getfield_name, __setfield_name, __delfield_name, "Name of the folder")
5032 
5033     def __getfield_pad(self):
5034         try: self.__field_pad
5035         except:
5036             self.__field_pad=UNKNOWN(**{'sizeinbytes': 3})
5037         return self.__field_pad.getvalue()
5038 
5039     def __setfield_pad(self, value):
5040         if isinstance(value,UNKNOWN):
5041             self.__field_pad=value
5042         else:
5043             self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 3})
5044 
5045     def __delfield_pad(self): del self.__field_pad
5046 
5047     pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None)
5048 
5049     def __getfield_keyword(self):
5050         return self.__field_keyword.getvalue()
5051 
5052     def __setfield_keyword(self, value):
5053         if isinstance(value,USTRING):
5054             self.__field_keyword=value
5055         else:
5056             self.__field_keyword=USTRING(value,**{'sizeinbytes': 14, 'raiseonunterminatedread': False})
5057 
5058     def __delfield_keyword(self): del self.__field_keyword
5059 
5060     keyword=property(__getfield_keyword, __setfield_keyword, __delfield_keyword, None)
5061 
5062     def iscontainer(self):
5063         return True
5064 
5065     def containerelements(self):
5066         yield ('index', self.__field_index, None)
5067         yield ('flag', self.__field_flag, "0 if empty, 1 in use")
5068         yield ('autofile', self.__field_autofile, "If 1, autofile messages with keyword")
5069         yield ('notify', self.__field_notify, None)
5070         yield ('icon', self.__field_icon, None)
5071         yield ('name', self.__field_name, "Name of the folder")
5072         yield ('pad', self.__field_pad, None)
5073         yield ('keyword', self.__field_keyword, None)
5074 
5075 
5076 
5077 
5078 class foldernameresponse(BaseProtogenClass):
5079     __fields=['header', 'entry', 'pad']
5080 
5081     def __init__(self, *args, **kwargs):
5082         dict={}
5083         # What was supplied to this function
5084         dict.update(kwargs)
5085         # Parent constructor
5086         super(foldernameresponse,self).__init__(**dict)
5087         if self.__class__ is foldernameresponse:
5088             self._update(args,dict)
5089 
5090 
5091     def getfields(self):
5092         return self.__fields
5093 
5094 
5095     def _update(self, args, kwargs):
5096         super(foldernameresponse,self)._update(args,kwargs)
5097         keys=kwargs.keys()
5098         for key in keys:
5099             if key in self.__fields:
5100                 setattr(self, key, kwargs[key])
5101                 del kwargs[key]
5102         # Were any unrecognized kwargs passed in?
5103         if __debug__:
5104             self._complainaboutunusedargs(foldernameresponse,kwargs)
5105         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
5106         # Make all P fields that haven't already been constructed
5107 
5108 
5109     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
5110         'Writes this packet to the supplied buffer'
5111         self._bufferstartoffset=buf.getcurrentoffset()
5112         self.__field_header.writetobuffer(buf)
5113         self.__field_entry.writetobuffer(buf)
5114         self.__field_pad.writetobuffer(buf)
5115         self._bufferendoffset=buf.getcurrentoffset()
5116         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
5117 
5118 
5119     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
5120         'Reads this packet from the supplied buffer'
5121         self._bufferstartoffset=buf.getcurrentoffset()
5122         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
5123         self.__field_header=sanyoheader()
5124         self.__field_header.readfrombuffer(buf)
5125         self.__field_entry=foldernameentry()
5126         self.__field_entry.readfrombuffer(buf)
5127         self.__field_pad=UNKNOWN(**{'sizeinbytes': 467})
5128         self.__field_pad.readfrombuffer(buf)
5129         self._bufferendoffset=buf.getcurrentoffset()
5130 
5131 
5132     def __getfield_header(self):
5133         return self.__field_header.getvalue()
5134 
5135     def __setfield_header(self, value):
5136         if isinstance(value,sanyoheader):
5137             self.__field_header=value
5138         else:
5139             self.__field_header=sanyoheader(value,)
5140 
5141     def __delfield_header(self): del self.__field_header
5142 
5143     header=property(__getfield_header, __setfield_header, __delfield_header, None)
5144 
5145     def __getfield_entry(self):
5146         return self.__field_entry.getvalue()
5147 
5148     def __setfield_entry(self, value):
5149         if isinstance(value,foldernameentry):
5150             self.__field_entry=value
5151         else:
5152             self.__field_entry=foldernameentry(value,)
5153 
5154     def __delfield_entry(self): del self.__field_entry
5155 
5156     entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None)
5157 
5158     def __getfield_pad(self):
5159         return self.__field_pad.getvalue()
5160 
5161     def __setfield_pad(self, value):
5162         if isinstance(value,UNKNOWN):
5163             self.__field_pad=value
5164         else:
5165             self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 467})
5166 
5167     def __delfield_pad(self): del self.__field_pad
5168 
5169     pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None)
5170 
5171     def iscontainer(self):
5172         return True
5173 
5174     def containerelements(self):
5175         yield ('header', self.__field_header, None)
5176         yield ('entry', self.__field_entry, None)
5177         yield ('pad', self.__field_pad, None)
5178 
5179 
5180 
5181 
5182 class messagerequest(BaseProtogenClass):
5183     __fields=['header', 'slot', 'pad']
5184 
5185     def __init__(self, *args, **kwargs):
5186         dict={}
5187         # What was supplied to this function
5188         dict.update(kwargs)
5189         # Parent constructor
5190         super(messagerequest,self).__init__(**dict)
5191         if self.__class__ is messagerequest:
5192             self._update(args,dict)
5193 
5194 
5195     def getfields(self):
5196         return self.__fields
5197 
5198 
5199     def _update(self, args, kwargs):
5200         super(messagerequest,self)._update(args,kwargs)
5201         keys=kwargs.keys()
5202         for key in keys:
5203             if key in self.__fields:
5204                 setattr(self, key, kwargs[key])
5205                 del kwargs[key]
5206         # Were any unrecognized kwargs passed in?
5207         if __debug__:
5208             self._complainaboutunusedargs(messagerequest,kwargs)
5209         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
5210         # Make all P fields that haven't already been constructed
5211 
5212 
5213     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
5214         'Writes this packet to the supplied buffer'
5215         self._bufferstartoffset=buf.getcurrentoffset()
5216         try: self.__field_header
5217         except:
5218             self.__field_header=sanyoheader(**{'packettype': 0x0c,                   'command': 0xe1})
5219         self.__field_header.writetobuffer(buf)
5220         self.__field_slot.writetobuffer(buf)
5221         try: self.__field_pad
5222         except:
5223             self.__field_pad=UNKNOWN(**{'sizeinbytes': 501})
5224         self.__field_pad.writetobuffer(buf)
5225         self._bufferendoffset=buf.getcurrentoffset()
5226         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
5227 
5228 
5229     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
5230         'Reads this packet from the supplied buffer'
5231         self._bufferstartoffset=buf.getcurrentoffset()
5232         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
5233         self.__field_header=sanyoheader(**{'packettype': 0x0c,                   'command': 0xe1})
5234         self.__field_header.readfrombuffer(buf)
5235         self.__field_slot=UINT(**{'sizeinbytes': 1})
5236         self.__field_slot.readfrombuffer(buf)
5237         self.__field_pad=UNKNOWN(**{'sizeinbytes': 501})
5238         self.__field_pad.readfrombuffer(buf)
5239         self._bufferendoffset=buf.getcurrentoffset()
5240 
5241 
5242     def __getfield_header(self):
5243         try: self.__field_header
5244         except:
5245             self.__field_header=sanyoheader(**{'packettype': 0x0c,                   'command': 0xe1})
5246         return self.__field_header.getvalue()
5247 
5248     def __setfield_header(self, value):
5249         if isinstance(value,sanyoheader):
5250             self.__field_header=value
5251         else:
5252             self.__field_header=sanyoheader(value,**{'packettype': 0x0c,                   'command': 0xe1})
5253 
5254     def __delfield_header(self): del self.__field_header
5255 
5256     header=property(__getfield_header, __setfield_header, __delfield_header, None)
5257 
5258     def __getfield_slot(self):
5259         return self.__field_slot.getvalue()
5260 
5261     def __setfield_slot(self, value):
5262         if isinstance(value,UINT):
5263             self.__field_slot=value
5264         else:
5265             self.__field_slot=UINT(value,**{'sizeinbytes': 1})
5266 
5267     def __delfield_slot(self): del self.__field_slot
5268 
5269     slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None)
5270 
5271     def __getfield_pad(self):
5272         try: self.__field_pad
5273         except:
5274             self.__field_pad=UNKNOWN(**{'sizeinbytes': 501})
5275         return self.__field_pad.getvalue()
5276 
5277     def __setfield_pad(self, value):
5278         if isinstance(value,UNKNOWN):
5279             self.__field_pad=value
5280         else:
5281             self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 501})
5282 
5283     def __delfield_pad(self): del self.__field_pad
5284 
5285     pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None)
5286 
5287     def iscontainer(self):
5288         return True
5289 
5290     def containerelements(self):
5291         yield ('header', self.__field_header, None)
5292         yield ('slot', self.__field_slot, None)
5293         yield ('pad', self.__field_pad, None)
5294 
5295 
5296 
5297 
5298 class messageentry(BaseProtogenClass):
5299     __fields=['slot', 'messagetype', 'dunno1', 'dunno2', 'dunno3', 'dunno4', 'dunno5', 'dunno6', 'dunno7', 'dunno8', 'dunno9', 'dunno10', 'dunno11', 'message_len', 'message', 'pad1', 'year', 'month', 'day', 'hour', 'minute', 'second', 'phonenum_len', 'phonenum', 'dunno12', 'pad2', 'dunno13', 'folder']
5300 
5301     def __init__(self, *args, **kwargs):
5302         dict={}
5303         # What was supplied to this function
5304         dict.update(kwargs)
5305         # Parent constructor
5306         super(messageentry,self).__init__(**dict)
5307         if self.__class__ is messageentry:
5308             self._update(args,dict)
5309 
5310 
5311     def getfields(self):
5312         return self.__fields
5313 
5314 
5315     def _update(self, args, kwargs):
5316         super(messageentry,self)._update(args,kwargs)
5317         keys=kwargs.keys()
5318         for key in keys:
5319             if key in self.__fields:
5320                 setattr(self, key, kwargs[key])
5321                 del kwargs[key]
5322         # Were any unrecognized kwargs passed in?
5323         if __debug__:
5324             self._complainaboutunusedargs(messageentry,kwargs)
5325         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
5326         # Make all P fields that haven't already been constructed
5327 
5328 
5329     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
5330         'Writes this packet to the supplied buffer'
5331         self._bufferstartoffset=buf.getcurrentoffset()
5332         self.__field_slot.writetobuffer(buf)
5333         self.__field_messagetype.writetobuffer(buf)
5334         self.__field_dunno1.writetobuffer(buf)
5335         self.__field_dunno2.writetobuffer(buf)
5336         self.__field_dunno3.writetobuffer(buf)
5337         self.__field_dunno4.writetobuffer(buf)
5338         self.__field_dunno5.writetobuffer(buf)
5339         self.__field_dunno6.writetobuffer(buf)
5340         self.__field_dunno7.writetobuffer(buf)
5341         self.__field_dunno8.writetobuffer(buf)
5342         self.__field_dunno9.writetobuffer(buf)
5343         self.__field_dunno10.writetobuffer(buf)
5344         self.__field_dunno11.writetobuffer(buf)
5345         self.__field_message_len.writetobuffer(buf)
5346         self.__field_message.writetobuffer(buf)
5347         self.__field_pad1.writetobuffer(buf)
5348         self.__field_year.writetobuffer(buf)
5349         self.__field_month.writetobuffer(buf)
5350         self.__field_day.writetobuffer(buf)
5351         self.__field_hour.writetobuffer(buf)
5352         self.__field_minute.writetobuffer(buf)
5353         self.__field_second.writetobuffer(buf)
5354         self.__field_phonenum_len.writetobuffer(buf)
5355         self.__field_phonenum.writetobuffer(buf)
5356         self.__field_dunno12.writetobuffer(buf)
5357         self.__field_pad2.writetobuffer(buf)
5358         self.__field_dunno13.writetobuffer(buf)
5359         self.__field_folder.writetobuffer(buf)
5360         self._bufferendoffset=buf.getcurrentoffset()
5361         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
5362 
5363 
5364     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
5365         'Reads this packet from the supplied buffer'
5366         self._bufferstartoffset=buf.getcurrentoffset()
5367         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
5368         self.__field_slot=UINT(**{'sizeinbytes': 1})
5369         self.__field_slot.readfrombuffer(buf)
5370         self.__field_messagetype=UINT(**{'sizeinbytes': 1})
5371         self.__field_messagetype.readfrombuffer(buf)
5372         self.__field_dunno1=UINT(**{'sizeinbytes': 1})
5373         self.__field_dunno1.readfrombuffer(buf)
5374         self.__field_dunno2=UINT(**{'sizeinbytes': 1})
5375         self.__field_dunno2.readfrombuffer(buf)
5376         self.__field_dunno3=UINT(**{'sizeinbytes': 1})
5377         self.__field_dunno3.readfrombuffer(buf)
5378         self.__field_dunno4=UINT(**{'sizeinbytes': 1})
5379         self.__field_dunno4.readfrombuffer(buf)
5380         self.__field_dunno5=UINT(**{'sizeinbytes': 1})
5381         self.__field_dunno5.readfrombuffer(buf)
5382         self.__field_dunno6=UINT(**{'sizeinbytes': 1})
5383         self.__field_dunno6.readfrombuffer(buf)
5384         self.__field_dunno7=UINT(**{'sizeinbytes': 1})
5385         self.__field_dunno7.readfrombuffer(buf)
5386         self.__field_dunno8=UINT(**{'sizeinbytes': 1})
5387         self.__field_dunno8.readfrombuffer(buf)
5388         self.__field_dunno9=UINT(**{'sizeinbytes': 1})
5389         self.__field_dunno9.readfrombuffer(buf)
5390         self.__field_dunno10=UINT(**{'sizeinbytes': 1})
5391         self.__field_dunno10.readfrombuffer(buf)
5392         self.__field_dunno11=UINT(**{'sizeinbytes': 1})
5393         self.__field_dunno11.readfrombuffer(buf)
5394         self.__field_message_len=UINT(**{'sizeinbytes': 1})
5395         self.__field_message_len.readfrombuffer(buf)
5396         self.__field_message=USTRING(**{'sizeinbytes': 255})
5397         self.__field_message.readfrombuffer(buf)
5398         self.__field_pad1=UNKNOWN(**{'sizeinbytes': 1})
5399         self.__field_pad1.readfrombuffer(buf)
5400         self.__field_year=UINT(**{'sizeinbytes': 1})
5401         self.__field_year.readfrombuffer(buf)
5402         self.__field_month=UINT(**{'sizeinbytes': 1})
5403         self.__field_month.readfrombuffer(buf)
5404         self.__field_day=UINT(**{'sizeinbytes': 1})
5405         self.__field_day.readfrombuffer(buf)
5406         self.__field_hour=UINT(**{'sizeinbytes': 1})
5407         self.__field_hour.readfrombuffer(buf)
5408         self.__field_minute=UINT(**{'sizeinbytes': 1})
5409         self.__field_minute.readfrombuffer(buf)
5410         self.__field_second=UINT(**{'sizeinbytes': 1})
5411         self.__field_second.readfrombuffer(buf)
5412         self.__field_phonenum_len=UINT(**{'sizeinbytes': 1})
5413         self.__field_phonenum_len.readfrombuffer(buf)
5414         self.__field_phonenum=USTRING(**{'sizeinbytes': 33})
5415         self.__field_phonenum.readfrombuffer(buf)
5416         self.__field_dunno12=UINT(**{'sizeinbytes': 1})
5417         self.__field_dunno12.readfrombuffer(buf)
5418         self.__field_pad2=UNKNOWN(**{'sizeinbytes': 38})
5419         self.__field_pad2.readfrombuffer(buf)
5420         self.__field_dunno13=UINT(**{'sizeinbytes': 1})
5421         self.__field_dunno13.readfrombuffer(buf)
5422         self.__field_folder=UINT(**{'sizeinbytes': 1})
5423         self.__field_folder.readfrombuffer(buf)
5424         self._bufferendoffset=buf.getcurrentoffset()
5425 
5426 
5427     def __getfield_slot(self):
5428         return self.__field_slot.getvalue()
5429 
5430     def __setfield_slot(self, value):
5431         if isinstance(value,UINT):
5432             self.__field_slot=value
5433         else:
5434             self.__field_slot=UINT(value,**{'sizeinbytes': 1})
5435 
5436     def __delfield_slot(self): del self.__field_slot
5437 
5438     slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None)
5439 
5440     def __getfield_messagetype(self):
5441         return self.__field_messagetype.getvalue()
5442 
5443     def __setfield_messagetype(self, value):
5444         if isinstance(value,UINT):
5445             self.__field_messagetype=value
5446         else:
5447             self.__field_messagetype=UINT(value,**{'sizeinbytes': 1})
5448 
5449     def __delfield_messagetype(self): del self.__field_messagetype
5450 
5451     messagetype=property(__getfield_messagetype, __setfield_messagetype, __delfield_messagetype, None)
5452 
5453     def __getfield_dunno1(self):
5454         return self.__field_dunno1.getvalue()
5455 
5456     def __setfield_dunno1(self, value):
5457         if isinstance(value,UINT):
5458             self.__field_dunno1=value
5459         else:
5460             self.__field_dunno1=UINT(value,**{'sizeinbytes': 1})
5461 
5462     def __delfield_dunno1(self): del self.__field_dunno1
5463 
5464     dunno1=property(__getfield_dunno1, __setfield_dunno1, __delfield_dunno1, None)
5465 
5466     def __getfield_dunno2(self):
5467         return self.__field_dunno2.getvalue()
5468 
5469     def __setfield_dunno2(self, value):
5470         if isinstance(value,UINT):
5471             self.__field_dunno2=value
5472         else:
5473             self.__field_dunno2=UINT(value,**{'sizeinbytes': 1})
5474 
5475     def __delfield_dunno2(self): del self.__field_dunno2
5476 
5477     dunno2=property(__getfield_dunno2, __setfield_dunno2, __delfield_dunno2, None)
5478 
5479     def __getfield_dunno3(self):
5480         return self.__field_dunno3.getvalue()
5481 
5482     def __setfield_dunno3(self, value):
5483         if isinstance(value,UINT):
5484             self.__field_dunno3=value
5485         else:
5486             self.__field_dunno3=UINT(value,**{'sizeinbytes': 1})
5487 
5488     def __delfield_dunno3(self): del self.__field_dunno3
5489 
5490     dunno3=property(__getfield_dunno3, __setfield_dunno3, __delfield_dunno3, None)
5491 
5492     def __getfield_dunno4(self):
5493         return self.__field_dunno4.getvalue()
5494 
5495     def __setfield_dunno4(self, value):
5496         if isinstance(value,UINT):
5497             self.__field_dunno4=value
5498         else:
5499             self.__field_dunno4=UINT(value,**{'sizeinbytes': 1})
5500 
5501     def __delfield_dunno4(self): del self.__field_dunno4
5502 
5503     dunno4=property(__getfield_dunno4, __setfield_dunno4, __delfield_dunno4, None)
5504 
5505     def __getfield_dunno5(self):
5506         return self.__field_dunno5.getvalue()
5507 
5508     def __setfield_dunno5(self, value):
5509         if isinstance(value,UINT):
5510             self.__field_dunno5=value
5511         else:
5512             self.__field_dunno5=UINT(value,**{'sizeinbytes': 1})
5513 
5514     def __delfield_dunno5(self): del self.__field_dunno5
5515 
5516     dunno5=property(__getfield_dunno5, __setfield_dunno5, __delfield_dunno5, None)
5517 
5518     def __getfield_dunno6(self):
5519         return self.__field_dunno6.getvalue()
5520 
5521     def __setfield_dunno6(self, value):
5522         if isinstance(value,UINT):
5523             self.__field_dunno6=value
5524         else:
5525             self.__field_dunno6=UINT(value,**{'sizeinbytes': 1})
5526 
5527     def __delfield_dunno6(self): del self.__field_dunno6
5528 
5529     dunno6=property(__getfield_dunno6, __setfield_dunno6, __delfield_dunno6, None)
5530 
5531     def __getfield_dunno7(self):
5532         return self.__field_dunno7.getvalue()
5533 
5534     def __setfield_dunno7(self, value):
5535         if isinstance(value,UINT):
5536             self.__field_dunno7=value
5537         else:
5538             self.__field_dunno7=UINT(value,**{'sizeinbytes': 1})
5539 
5540     def __delfield_dunno7(self): del self.__field_dunno7
5541 
5542     dunno7=property(__getfield_dunno7, __setfield_dunno7, __delfield_dunno7, None)
5543 
5544     def __getfield_dunno8(self):
5545         return self.__field_dunno8.getvalue()
5546 
5547     def __setfield_dunno8(self, value):
5548         if isinstance(value,UINT):
5549             self.__field_dunno8=value
5550         else:
5551             self.__field_dunno8=UINT(value,**{'sizeinbytes': 1})
5552 
5553     def __delfield_dunno8(self): del self.__field_dunno8
5554 
5555     dunno8=property(__getfield_dunno8, __setfield_dunno8, __delfield_dunno8, None)
5556 
5557     def __getfield_dunno9(self):
5558         return self.__field_dunno9.getvalue()
5559 
5560     def __setfield_dunno9(self, value):
5561         if isinstance(value,UINT):
5562             self.__field_dunno9=value
5563         else:
5564             self.__field_dunno9=UINT(value,**{'sizeinbytes': 1})
5565 
5566     def __delfield_dunno9(self): del self.__field_dunno9
5567 
5568     dunno9=property(__getfield_dunno9, __setfield_dunno9, __delfield_dunno9, None)
5569 
5570     def __getfield_dunno10(self):
5571         return self.__field_dunno10.getvalue()
5572 
5573     def __setfield_dunno10(self, value):
5574         if isinstance(value,UINT):
5575             self.__field_dunno10=value
5576         else:
5577             self.__field_dunno10=UINT(value,**{'sizeinbytes': 1})
5578 
5579     def __delfield_dunno10(self): del self.__field_dunno10
5580 
5581     dunno10=property(__getfield_dunno10, __setfield_dunno10, __delfield_dunno10, None)
5582 
5583     def __getfield_dunno11(self):
5584         return self.__field_dunno11.getvalue()
5585 
5586     def __setfield_dunno11(self, value):
5587         if isinstance(value,UINT):
5588             self.__field_dunno11=value
5589         else:
5590             self.__field_dunno11=UINT(value,**{'sizeinbytes': 1})
5591 
5592     def __delfield_dunno11(self): del self.__field_dunno11
5593 
5594     dunno11=property(__getfield_dunno11, __setfield_dunno11, __delfield_dunno11, None)
5595 
5596     def __getfield_message_len(self):
5597         return self.__field_message_len.getvalue()
5598 
5599     def __setfield_message_len(self, value):
5600         if isinstance(value,UINT):
5601             self.__field_message_len=value
5602         else:
5603             self.__field_message_len=UINT(value,**{'sizeinbytes': 1})
5604 
5605     def __delfield_message_len(self): del self.__field_message_len
5606 
5607     message_len=property(__getfield_message_len, __setfield_message_len, __delfield_message_len, None)
5608 
5609     def __getfield_message(self):
5610         return self.__field_message.getvalue()
5611 
5612     def __setfield_message(self, value):
5613         if isinstance(value,USTRING):
5614             self.__field_message=value
5615         else:
5616             self.__field_message=USTRING(value,**{'sizeinbytes': 255})
5617 
5618     def __delfield_message(self): del self.__field_message
5619 
5620     message=property(__getfield_message, __setfield_message, __delfield_message, "Text of the notification")
5621 
5622     def __getfield_pad1(self):
5623         return self.__field_pad1.getvalue()
5624 
5625     def __setfield_pad1(self, value):
5626         if isinstance(value,UNKNOWN):
5627             self.__field_pad1=value
5628         else:
5629             self.__field_pad1=UNKNOWN(value,**{'sizeinbytes': 1})
5630 
5631     def __delfield_pad1(self): del self.__field_pad1
5632 
5633     pad1=property(__getfield_pad1, __setfield_pad1, __delfield_pad1, None)
5634 
5635     def __getfield_year(self):
5636         return self.__field_year.getvalue()
5637 
5638     def __setfield_year(self, value):
5639         if isinstance(value,UINT):
5640             self.__field_year=value
5641         else:
5642             self.__field_year=UINT(value,**{'sizeinbytes': 1})
5643 
5644     def __delfield_year(self): del self.__field_year
5645 
5646     year=property(__getfield_year, __setfield_year, __delfield_year, None)
5647 
5648     def __getfield_month(self):
5649         return self.__field_month.getvalue()
5650 
5651     def __setfield_month(self, value):
5652         if isinstance(value,UINT):
5653             self.__field_month=value
5654         else:
5655             self.__field_month=UINT(value,**{'sizeinbytes': 1})
5656 
5657     def __delfield_month(self): del self.__field_month
5658 
5659     month=property(__getfield_month, __setfield_month, __delfield_month, None)
5660 
5661     def __getfield_day(self):
5662         return self.__field_day.getvalue()
5663 
5664     def __setfield_day(self, value):
5665         if isinstance(value,UINT):
5666             self.__field_day=value
5667         else:
5668             self.__field_day=UINT(value,**{'sizeinbytes': 1})
5669 
5670     def __delfield_day(self): del self.__field_day
5671 
5672     day=property(__getfield_day, __setfield_day, __delfield_day, None)
5673 
5674     def __getfield_hour(self):
5675         return self.__field_hour.getvalue()
5676 
5677     def __setfield_hour(self, value):
5678         if isinstance(value,UINT):
5679             self.__field_hour=value
5680         else:
5681             self.__field_hour=UINT(value,**{'sizeinbytes': 1})
5682 
5683     def __delfield_hour(self): del self.__field_hour
5684 
5685     hour=property(__getfield_hour, __setfield_hour, __delfield_hour, None)
5686 
5687     def __getfield_minute(self):
5688         return self.__field_minute.getvalue()
5689 
5690     def __setfield_minute(self, value):
5691         if isinstance(value,UINT):
5692             self.__field_minute=value
5693         else:
5694             self.__field_minute=UINT(value,**{'sizeinbytes': 1})
5695 
5696     def __delfield_minute(self): del self.__field_minute
5697 
5698     minute=property(__getfield_minute, __setfield_minute, __delfield_minute, None)
5699 
5700     def __getfield_second(self):
5701         return self.__field_second.getvalue()
5702 
5703     def __setfield_second(self, value):
5704         if isinstance(value,UINT):
5705             self.__field_second=value
5706         else:
5707             self.__field_second=UINT(value,**{'sizeinbytes': 1})
5708 
5709     def __delfield_second(self): del self.__field_second
5710 
5711     second=property(__getfield_second, __setfield_second, __delfield_second, None)
5712 
5713     def __getfield_phonenum_len(self):
5714         return self.__field_phonenum_len.getvalue()
5715 
5716     def __setfield_phonenum_len(self, value):
5717         if isinstance(value,UINT):
5718             self.__field_phonenum_len=value
5719         else:
5720             self.__field_phonenum_len=UINT(value,**{'sizeinbytes': 1})
5721 
5722     def __delfield_phonenum_len(self): del self.__field_phonenum_len
5723 
5724     phonenum_len=property(__getfield_phonenum_len, __setfield_phonenum_len, __delfield_phonenum_len, None)
5725 
5726     def __getfield_phonenum(self):
5727         return self.__field_phonenum.getvalue()
5728 
5729     def __setfield_phonenum(self, value):
5730         if isinstance(value,USTRING):
5731             self.__field_phonenum=value
5732         else:
5733             self.__field_phonenum=USTRING(value,**{'sizeinbytes': 33})
5734 
5735     def __delfield_phonenum(self): del self.__field_phonenum
5736 
5737     phonenum=property(__getfield_phonenum, __setfield_phonenum, __delfield_phonenum, None)
5738 
5739     def __getfield_dunno12(self):
5740         return self.__field_dunno12.getvalue()
5741 
5742     def __setfield_dunno12(self, value):
5743         if isinstance(value,UINT):
5744             self.__field_dunno12=value
5745         else:
5746             self.__field_dunno12=UINT(value,**{'sizeinbytes': 1})
5747 
5748     def __delfield_dunno12(self): del self.__field_dunno12
5749 
5750     dunno12=property(__getfield_dunno12, __setfield_dunno12, __delfield_dunno12, None)
5751 
5752     def __getfield_pad2(self):
5753         return self.__field_pad2.getvalue()
5754 
5755     def __setfield_pad2(self, value):
5756         if isinstance(value,UNKNOWN):
5757             self.__field_pad2=value
5758         else:
5759             self.__field_pad2=UNKNOWN(value,**{'sizeinbytes': 38})
5760 
5761     def __delfield_pad2(self): del self.__field_pad2
5762 
5763     pad2=property(__getfield_pad2, __setfield_pad2, __delfield_pad2, None)
5764 
5765     def __getfield_dunno13(self):
5766         return self.__field_dunno13.getvalue()
5767 
5768     def __setfield_dunno13(self, value):
5769         if isinstance(value,UINT):
5770             self.__field_dunno13=value
5771         else:
5772             self.__field_dunno13=UINT(value,**{'sizeinbytes': 1})
5773 
5774     def __delfield_dunno13(self): del self.__field_dunno13
5775 
5776     dunno13=property(__getfield_dunno13, __setfield_dunno13, __delfield_dunno13, None)
5777 
5778     def __getfield_folder(self):
5779         return self.__field_folder.getvalue()
5780 
5781     def __setfield_folder(self, value):
5782         if isinstance(value,UINT):
5783             self.__field_folder=value
5784         else:
5785             self.__field_folder=UINT(value,**{'sizeinbytes': 1})
5786 
5787     def __delfield_folder(self): del self.__field_folder
5788 
5789     folder=property(__getfield_folder, __setfield_folder, __delfield_folder, None)
5790 
5791     def iscontainer(self):
5792         return True
5793 
5794     def containerelements(self):
5795         yield ('slot', self.__field_slot, None)
5796         yield ('messagetype', self.__field_messagetype, None)
5797         yield ('dunno1', self.__field_dunno1, None)
5798         yield ('dunno2', self.__field_dunno2, None)
5799         yield ('dunno3', self.__field_dunno3, None)
5800         yield ('dunno4', self.__field_dunno4, None)
5801         yield ('dunno5', self.__field_dunno5, None)
5802         yield ('dunno6', self.__field_dunno6, None)
5803         yield ('dunno7', self.__field_dunno7, None)
5804         yield ('dunno8', self.__field_dunno8, None)
5805         yield ('dunno9', self.__field_dunno9, None)
5806         yield ('dunno10', self.__field_dunno10, None)
5807         yield ('dunno11', self.__field_dunno11, None)
5808         yield ('message_len', self.__field_message_len, None)
5809         yield ('message', self.__field_message, "Text of the notification")
5810         yield ('pad1', self.__field_pad1, None)
5811         yield ('year', self.__field_year, None)
5812         yield ('month', self.__field_month, None)
5813         yield ('day', self.__field_day, None)
5814         yield ('hour', self.__field_hour, None)
5815         yield ('minute', self.__field_minute, None)
5816         yield ('second', self.__field_second, None)
5817         yield ('phonenum_len', self.__field_phonenum_len, None)
5818         yield ('phonenum', self.__field_phonenum, None)
5819         yield ('dunno12', self.__field_dunno12, None)
5820         yield ('pad2', self.__field_pad2, None)
5821         yield ('dunno13', self.__field_dunno13, None)
5822         yield ('folder', self.__field_folder, None)
5823 
5824 
5825 
5826 
5827 class messageresponse(BaseProtogenClass):
5828     __fields=['header', 'entry', 'pad']
5829 
5830     def __init__(self, *args, **kwargs):
5831         dict={}
5832         # What was supplied to this function
5833         dict.update(kwargs)
5834         # Parent constructor
5835         super(messageresponse,self).__init__(**dict)
5836         if self.__class__ is messageresponse:
5837             self._update(args,dict)
5838 
5839 
5840     def getfields(self):
5841         return self.__fields
5842 
5843 
5844     def _update(self, args, kwargs):
5845         super(messageresponse,self)._update(args,kwargs)
5846         keys=kwargs.keys()
5847         for key in keys:
5848             if key in self.__fields:
5849                 setattr(self, key, kwargs[key])
5850                 del kwargs[key]
5851         # Were any unrecognized kwargs passed in?
5852         if __debug__:
5853             self._complainaboutunusedargs(messageresponse,kwargs)
5854         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
5855         # Make all P fields that haven't already been constructed
5856 
5857 
5858     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
5859         'Writes this packet to the supplied buffer'
5860         self._bufferstartoffset=buf.getcurrentoffset()
5861         self.__field_header.writetobuffer(buf)
5862         self.__field_entry.writetobuffer(buf)
5863         self.__field_pad.writetobuffer(buf)
5864         self._bufferendoffset=buf.getcurrentoffset()
5865         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
5866 
5867 
5868     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
5869         'Reads this packet from the supplied buffer'
5870         self._bufferstartoffset=buf.getcurrentoffset()
5871         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
5872         self.__field_header=sanyoheader()
5873         self.__field_header.readfrombuffer(buf)
5874         self.__field_entry=messageentry()
5875         self.__field_entry.readfrombuffer(buf)
5876         self.__field_pad=UNKNOWN(**{'sizeinbytes': 151})
5877         self.__field_pad.readfrombuffer(buf)
5878         self._bufferendoffset=buf.getcurrentoffset()
5879 
5880 
5881     def __getfield_header(self):
5882         return self.__field_header.getvalue()
5883 
5884     def __setfield_header(self, value):
5885         if isinstance(value,sanyoheader):
5886             self.__field_header=value
5887         else:
5888             self.__field_header=sanyoheader(value,)
5889 
5890     def __delfield_header(self): del self.__field_header
5891 
5892     header=property(__getfield_header, __setfield_header, __delfield_header, None)
5893 
5894     def __getfield_entry(self):
5895         return self.__field_entry.getvalue()
5896 
5897     def __setfield_entry(self, value):
5898         if isinstance(value,messageentry):
5899             self.__field_entry=value
5900         else:
5901             self.__field_entry=messageentry(value,)
5902 
5903     def __delfield_entry(self): del self.__field_entry
5904 
5905     entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None)
5906 
5907     def __getfield_pad(self):
5908         return self.__field_pad.getvalue()
5909 
5910     def __setfield_pad(self, value):
5911         if isinstance(value,UNKNOWN):
5912             self.__field_pad=value
5913         else:
5914             self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 151})
5915 
5916     def __delfield_pad(self): del self.__field_pad
5917 
5918     pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None)
5919 
5920     def iscontainer(self):
5921         return True
5922 
5923     def containerelements(self):
5924         yield ('header', self.__field_header, None)
5925         yield ('entry', self.__field_entry, None)
5926         yield ('pad', self.__field_pad, None)
5927 
5928 
5929 
5930 
5931 class historyrequest(BaseProtogenClass):
5932     __fields=['type', 'header', 'header', 'header', 'slot', 'pad']
5933 
5934     def __init__(self, *args, **kwargs):
5935         dict={}
5936         # What was supplied to this function
5937         dict.update(kwargs)
5938         # Parent constructor
5939         super(historyrequest,self).__init__(**dict)
5940         if self.__class__ is historyrequest:
5941             self._update(args,dict)
5942 
5943 
5944     def getfields(self):
5945         return self.__fields
5946 
5947 
5948     def _update(self, args, kwargs):
5949         super(historyrequest,self)._update(args,kwargs)
5950         keys=kwargs.keys()
5951         for key in keys:
5952             if key in self.__fields:
5953                 setattr(self, key, kwargs[key])
5954                 del kwargs[key]
5955         # Were any unrecognized kwargs passed in?
5956         if __debug__:
5957             self._complainaboutunusedargs(historyrequest,kwargs)
5958         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
5959         # Make all P fields that haven't already been constructed
5960         try: self.__field_type
5961         except:
5962             self.__field_type=UINT()
5963 
5964 
5965     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
5966         'Writes this packet to the supplied buffer'
5967         self._bufferstartoffset=buf.getcurrentoffset()
5968         if self.type==OUTGOING:
5969             try: self.__field_header
5970             except:
5971                 self.__field_header=sanyoheader(**{'packettype': 0x0c, 'command': 0x3d})
5972             self.__field_header.writetobuffer(buf)
5973         if self.type==INCOMING:
5974             try: self.__field_header
5975             except:
5976                 self.__field_header=sanyoheader(**{'packettype': 0x0c, 'command': 0x3e})
5977             self.__field_header.writetobuffer(buf)
5978         if self.type==MISSED:
5979             try: self.__field_header
5980             except:
5981                 self.__field_header=sanyoheader(**{'packettype': 0x0c, 'command': 0x3f})
5982             self.__field_header.writetobuffer(buf)
5983         self.__field_slot.writetobuffer(buf)
5984         try: self.__field_pad
5985         except:
5986             self.__field_pad=UNKNOWN(**{'sizeinbytes': 501})
5987         self.__field_pad.writetobuffer(buf)
5988         self._bufferendoffset=buf.getcurrentoffset()
5989         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
5990 
5991 
5992     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
5993         'Reads this packet from the supplied buffer'
5994         self._bufferstartoffset=buf.getcurrentoffset()
5995         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
5996         if self.type==OUTGOING:
5997             self.__field_header=sanyoheader(**{'packettype': 0x0c, 'command': 0x3d})
5998             self.__field_header.readfrombuffer(buf)
5999         if self.type==INCOMING:
6000             self.__field_header=sanyoheader(**{'packettype': 0x0c, 'command': 0x3e})
6001             self.__field_header.readfrombuffer(buf)
6002         if self.type==MISSED:
6003             self.__field_header=sanyoheader(**{'packettype': 0x0c, 'command': 0x3f})
6004             self.__field_header.readfrombuffer(buf)
6005         self.__field_slot=UINT(**{'sizeinbytes': 1})
6006         self.__field_slot.readfrombuffer(buf)
6007         self.__field_pad=UNKNOWN(**{'sizeinbytes': 501})
6008         self.__field_pad.readfrombuffer(buf)
6009         self._bufferendoffset=buf.getcurrentoffset()
6010 
6011 
6012     def __getfield_type(self):
6013         return self.__field_type.getvalue()
6014 
6015     def __setfield_type(self, value):
6016         if isinstance(value,UINT):
6017             self.__field_type=value
6018         else:
6019             self.__field_type=UINT(value,)
6020 
6021     def __delfield_type(self): del self.__field_type
6022 
6023     type=property(__getfield_type, __setfield_type, __delfield_type, "0: Outgoing, 1: Incoming, 2: Missed")
6024 
6025     def __getfield_header(self):
6026         try: self.__field_header
6027         except:
6028             self.__field_header=sanyoheader(**{'packettype': 0x0c, 'command': 0x3d})
6029         return self.__field_header.getvalue()
6030 
6031     def __setfield_header(self, value):
6032         if isinstance(value,sanyoheader):
6033             self.__field_header=value
6034         else:
6035             self.__field_header=sanyoheader(value,**{'packettype': 0x0c, 'command': 0x3d})
6036 
6037     def __delfield_header(self): del self.__field_header
6038 
6039     header=property(__getfield_header, __setfield_header, __delfield_header, None)
6040 
6041     def __getfield_header(self):
6042         try: self.__field_header
6043         except:
6044             self.__field_header=sanyoheader(**{'packettype': 0x0c, 'command': 0x3e})
6045         return self.__field_header.getvalue()
6046 
6047     def __setfield_header(self, value):
6048         if isinstance(value,sanyoheader):
6049             self.__field_header=value
6050         else:
6051             self.__field_header=sanyoheader(value,**{'packettype': 0x0c, 'command': 0x3e})
6052 
6053     def __delfield_header(self): del self.__field_header
6054 
6055     header=property(__getfield_header, __setfield_header, __delfield_header, None)
6056 
6057     def __getfield_header(self):
6058         try: self.__field_header
6059         except:
6060             self.__field_header=sanyoheader(**{'packettype': 0x0c, 'command': 0x3f})
6061         return self.__field_header.getvalue()
6062 
6063     def __setfield_header(self, value):
6064         if isinstance(value,sanyoheader):
6065             self.__field_header=value
6066         else:
6067             self.__field_header=sanyoheader(value,**{'packettype': 0x0c, 'command': 0x3f})
6068 
6069     def __delfield_header(self): del self.__field_header
6070 
6071     header=property(__getfield_header, __setfield_header, __delfield_header, None)
6072 
6073     def __getfield_slot(self):
6074         return self.__field_slot.getvalue()
6075 
6076     def __setfield_slot(self, value):
6077         if isinstance(value,UINT):
6078             self.__field_slot=value
6079         else:
6080             self.__field_slot=UINT(value,**{'sizeinbytes': 1})
6081 
6082     def __delfield_slot(self): del self.__field_slot
6083 
6084     slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None)
6085 
6086     def __getfield_pad(self):
6087         try: self.__field_pad
6088         except:
6089             self.__field_pad=UNKNOWN(**{'sizeinbytes': 501})
6090         return self.__field_pad.getvalue()
6091 
6092     def __setfield_pad(self, value):
6093         if isinstance(value,UNKNOWN):
6094             self.__field_pad=value
6095         else:
6096             self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 501})
6097 
6098     def __delfield_pad(self): del self.__field_pad
6099 
6100     pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None)
6101 
6102     def iscontainer(self):
6103         return True
6104 
6105     def containerelements(self):
6106         yield ('type', self.__field_type, "0: Outgoing, 1: Incoming, 2: Missed")
6107         if self.type==OUTGOING:
6108             yield ('header', self.__field_header, None)
6109         if self.type==INCOMING:
6110             yield ('header', self.__field_header, None)
6111         if self.type==MISSED:
6112             yield ('header', self.__field_header, None)
6113         yield ('slot', self.__field_slot, None)
6114         yield ('pad', self.__field_pad, None)
6115 
6116 
6117 
6118 
6119 class historymiscrequest(BaseProtogenClass):
6120     __fields=['type', 'header', 'header', 'header', 'slot', 'pad']
6121 
6122     def __init__(self, *args, **kwargs):
6123         dict={}
6124         # What was supplied to this function
6125         dict.update(kwargs)
6126         # Parent constructor
6127         super(historymiscrequest,self).__init__(**dict)
6128         if self.__class__ is historymiscrequest:
6129             self._update(args,dict)
6130 
6131 
6132     def getfields(self):
6133         return self.__fields
6134 
6135 
6136     def _update(self, args, kwargs):
6137         super(historymiscrequest,self)._update(args,kwargs)
6138         keys=kwargs.keys()
6139         for key in keys:
6140             if key in self.__fields:
6141                 setattr(self, key, kwargs[key])
6142                 del kwargs[key]
6143         # Were any unrecognized kwargs passed in?
6144         if __debug__:
6145             self._complainaboutunusedargs(historymiscrequest,kwargs)
6146         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
6147         # Make all P fields that haven't already been constructed
6148         try: self.__field_type
6149         except:
6150             self.__field_type=UINT()
6151 
6152 
6153     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
6154         'Writes this packet to the supplied buffer'
6155         self._bufferstartoffset=buf.getcurrentoffset()
6156         if self.type==OUTGOING:
6157             try: self.__field_header
6158             except:
6159                 self.__field_header=sanyoheader(**{'packettype': 0x0c, 'command': 0x60})
6160             self.__field_header.writetobuffer(buf)
6161         if self.type==INCOMING:
6162             try: self.__field_header
6163             except:
6164                 self.__field_header=sanyoheader(**{'packettype': 0x0c, 'command': 0x61})
6165             self.__field_header.writetobuffer(buf)
6166         if self.type==MISSED:
6167             try: self.__field_header
6168             except:
6169                 self.__field_header=sanyoheader(**{'packettype': 0x0c, 'command': 0x62})
6170             self.__field_header.writetobuffer(buf)
6171         self.__field_slot.writetobuffer(buf)
6172         try: self.__field_pad
6173         except:
6174             self.__field_pad=UNKNOWN(**{'sizeinbytes': 501})
6175         self.__field_pad.writetobuffer(buf)
6176         self._bufferendoffset=buf.getcurrentoffset()
6177         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
6178 
6179 
6180     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
6181         'Reads this packet from the supplied buffer'
6182         self._bufferstartoffset=buf.getcurrentoffset()
6183         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
6184         if self.type==OUTGOING:
6185             self.__field_header=sanyoheader(**{'packettype': 0x0c, 'command': 0x60})
6186             self.__field_header.readfrombuffer(buf)
6187         if self.type==INCOMING:
6188             self.__field_header=sanyoheader(**{'packettype': 0x0c, 'command': 0x61})
6189             self.__field_header.readfrombuffer(buf)
6190         if self.type==MISSED:
6191             self.__field_header=sanyoheader(**{'packettype': 0x0c, 'command': 0x62})
6192             self.__field_header.readfrombuffer(buf)
6193         self.__field_slot=UINT(**{'sizeinbytes': 1})
6194         self.__field_slot.readfrombuffer(buf)
6195         self.__field_pad=UNKNOWN(**{'sizeinbytes': 501})
6196         self.__field_pad.readfrombuffer(buf)
6197         self._bufferendoffset=buf.getcurrentoffset()
6198 
6199 
6200     def __getfield_type(self):
6201         return self.__field_type.getvalue()
6202 
6203     def __setfield_type(self, value):
6204         if isinstance(value,UINT):
6205             self.__field_type=value
6206         else:
6207             self.__field_type=UINT(value,)
6208 
6209     def __delfield_type(self): del self.__field_type
6210 
6211     type=property(__getfield_type, __setfield_type, __delfield_type, "0: Outgoing, 1: Incoming, 2: Missed")
6212 
6213     def __getfield_header(self):
6214         try: self.__field_header
6215         except:
6216             self.__field_header=sanyoheader(**{'packettype': 0x0c, 'command': 0x60})
6217         return self.__field_header.getvalue()
6218 
6219     def __setfield_header(self, value):
6220         if isinstance(value,sanyoheader):
6221             self.__field_header=value
6222         else:
6223             self.__field_header=sanyoheader(value,**{'packettype': 0x0c, 'command': 0x60})
6224 
6225     def __delfield_header(self): del self.__field_header
6226 
6227     header=property(__getfield_header, __setfield_header, __delfield_header, None)
6228 
6229     def __getfield_header(self):
6230         try: self.__field_header
6231         except:
6232             self.__field_header=sanyoheader(**{'packettype': 0x0c, 'command': 0x61})
6233         return self.__field_header.getvalue()
6234 
6235     def __setfield_header(self, value):
6236         if isinstance(value,sanyoheader):
6237             self.__field_header=value
6238         else:
6239             self.__field_header=sanyoheader(value,**{'packettype': 0x0c, 'command': 0x61})
6240 
6241     def __delfield_header(self): del self.__field_header
6242 
6243     header=property(__getfield_header, __setfield_header, __delfield_header, None)
6244 
6245     def __getfield_header(self):
6246         try: self.__field_header
6247         except:
6248             self.__field_header=sanyoheader(**{'packettype': 0x0c, 'command': 0x62})
6249         return self.__field_header.getvalue()
6250 
6251     def __setfield_header(self, value):
6252         if isinstance(value,sanyoheader):
6253             self.__field_header=value
6254         else:
6255             self.__field_header=sanyoheader(value,**{'packettype': 0x0c, 'command': 0x62})
6256 
6257     def __delfield_header(self): del self.__field_header
6258 
6259     header=property(__getfield_header, __setfield_header, __delfield_header, None)
6260 
6261     def __getfield_slot(self):
6262         return self.__field_slot.getvalue()
6263 
6264     def __setfield_slot(self, value):
6265         if isinstance(value,UINT):
6266             self.__field_slot=value
6267         else:
6268             self.__field_slot=UINT(value,**{'sizeinbytes': 1})
6269 
6270     def __delfield_slot(self): del self.__field_slot
6271 
6272     slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None)
6273 
6274     def __getfield_pad(self):
6275         try: self.__field_pad
6276         except:
6277             self.__field_pad=UNKNOWN(**{'sizeinbytes': 501})
6278         return self.__field_pad.getvalue()
6279 
6280     def __setfield_pad(self, value):
6281         if isinstance(value,UNKNOWN):
6282             self.__field_pad=value
6283         else:
6284             self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 501})
6285 
6286     def __delfield_pad(self): del self.__field_pad
6287 
6288     pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None)
6289 
6290     def iscontainer(self):
6291         return True
6292 
6293     def containerelements(self):
6294         yield ('type', self.__field_type, "0: Outgoing, 1: Incoming, 2: Missed")
6295         if self.type==OUTGOING:
6296             yield ('header', self.__field_header, None)
6297         if self.type==INCOMING:
6298             yield ('header', self.__field_header, None)
6299         if self.type==MISSED:
6300             yield ('header', self.__field_header, None)
6301         yield ('slot', self.__field_slot, None)
6302         yield ('pad', self.__field_pad, None)
6303 
6304 
6305 
6306 
6307 class historyentry(BaseProtogenClass):
6308     __fields=['slot', 'dunno1', 'date', 'phonenumlen', 'phonenum', 'name', 'dunno2', 'dunno3']
6309 
6310     def __init__(self, *args, **kwargs):
6311         dict={}
6312         # What was supplied to this function
6313         dict.update(kwargs)
6314         # Parent constructor
6315         super(historyentry,self).__init__(**dict)
6316         if self.__class__ is historyentry:
6317             self._update(args,dict)
6318 
6319 
6320     def getfields(self):
6321         return self.__fields
6322 
6323 
6324     def _update(self, args, kwargs):
6325         super(historyentry,self)._update(args,kwargs)
6326         keys=kwargs.keys()
6327         for key in keys:
6328             if key in self.__fields:
6329                 setattr(self, key, kwargs[key])
6330                 del kwargs[key]
6331         # Were any unrecognized kwargs passed in?
6332         if __debug__:
6333             self._complainaboutunusedargs(historyentry,kwargs)
6334         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
6335         # Make all P fields that haven't already been constructed
6336 
6337 
6338     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
6339         'Writes this packet to the supplied buffer'
6340         self._bufferstartoffset=buf.getcurrentoffset()
6341         self.__field_slot.writetobuffer(buf)
6342         self.__field_dunno1.writetobuffer(buf)
6343         self.__field_date.writetobuffer(buf)
6344         self.__field_phonenumlen.writetobuffer(buf)
6345         self.__field_phonenum.writetobuffer(buf)
6346         self.__field_name.writetobuffer(buf)
6347         self.__field_dunno2.writetobuffer(buf)
6348         self.__field_dunno3.writetobuffer(buf)
6349         self._bufferendoffset=buf.getcurrentoffset()
6350         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
6351 
6352 
6353     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
6354         'Reads this packet from the supplied buffer'
6355         self._bufferstartoffset=buf.getcurrentoffset()
6356         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
6357         self.__field_slot=UINT(**{'sizeinbytes': 2})
6358         self.__field_slot.readfrombuffer(buf)
6359         self.__field_dunno1=UNKNOWN(**{'sizeinbytes': 1})
6360         self.__field_dunno1.readfrombuffer(buf)
6361         self.__field_date=GPSDATE(**{'sizeinbytes': 4})
6362         self.__field_date.readfrombuffer(buf)
6363         self.__field_phonenumlen=UINT(**{'sizeinbytes': 1})
6364         self.__field_phonenumlen.readfrombuffer(buf)
6365         self.__field_phonenum=USTRING(**{'sizeinbytes': 48, 'raiseonunterminatedread': False})
6366         self.__field_phonenum.readfrombuffer(buf)
6367         self.__field_name=USTRING(**{'sizeinbytes': 16, 'raiseonunterminatedread': False, 'raiseontruncate': False, 'terminator': None})
6368         self.__field_name.readfrombuffer(buf)
6369         self.__field_dunno2=UNKNOWN(**{'sizeinbytes': 1})
6370         self.__field_dunno2.readfrombuffer(buf)
6371         self.__field_dunno3=UNKNOWN(**{'sizeinbytes': 1})
6372         self.__field_dunno3.readfrombuffer(buf)
6373         self._bufferendoffset=buf.getcurrentoffset()
6374 
6375 
6376     def __getfield_slot(self):
6377         return self.__field_slot.getvalue()
6378 
6379     def __setfield_slot(self, value):
6380         if isinstance(value,UINT):
6381             self.__field_slot=value
6382         else:
6383             self.__field_slot=UINT(value,**{'sizeinbytes': 2})
6384 
6385     def __delfield_slot(self): del self.__field_slot
6386 
6387     slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None)
6388 
6389     def __getfield_dunno1(self):
6390         return self.__field_dunno1.getvalue()
6391 
6392     def __setfield_dunno1(self, value):
6393         if isinstance(value,UNKNOWN):
6394             self.__field_dunno1=value
6395         else:
6396             self.__field_dunno1=UNKNOWN(value,**{'sizeinbytes': 1})
6397 
6398     def __delfield_dunno1(self): del self.__field_dunno1
6399 
6400     dunno1=property(__getfield_dunno1, __setfield_dunno1, __delfield_dunno1, None)
6401 
6402     def __getfield_date(self):
6403         return self.__field_date.getvalue()
6404 
6405     def __setfield_date(self, value):
6406         if isinstance(value,GPSDATE):
6407             self.__field_date=value
6408         else:
6409             self.__field_date=GPSDATE(value,**{'sizeinbytes': 4})
6410 
6411     def __delfield_date(self): del self.__field_date
6412 
6413     date=property(__getfield_date, __setfield_date, __delfield_date, None)
6414 
6415     def __getfield_phonenumlen(self):
6416         return self.__field_phonenumlen.getvalue()
6417 
6418     def __setfield_phonenumlen(self, value):
6419         if isinstance(value,UINT):
6420             self.__field_phonenumlen=value
6421         else:
6422             self.__field_phonenumlen=UINT(value,**{'sizeinbytes': 1})
6423 
6424     def __delfield_phonenumlen(self): del self.__field_phonenumlen
6425 
6426     phonenumlen=property(__getfield_phonenumlen, __setfield_phonenumlen, __delfield_phonenumlen, None)
6427 
6428     def __getfield_phonenum(self):
6429         return self.__field_phonenum.getvalue()
6430 
6431     def __setfield_phonenum(self, value):
6432         if isinstance(value,USTRING):
6433             self.__field_phonenum=value
6434         else:
6435             self.__field_phonenum=USTRING(value,**{'sizeinbytes': 48, 'raiseonunterminatedread': False})
6436 
6437     def __delfield_phonenum(self): del self.__field_phonenum
6438 
6439     phonenum=property(__getfield_phonenum, __setfield_phonenum, __delfield_phonenum, None)
6440 
6441     def __getfield_name(self):
6442         return self.__field_name.getvalue()
6443 
6444     def __setfield_name(self, value):
6445         if isinstance(value,USTRING):
6446             self.__field_name=value
6447         else:
6448             self.__field_name=USTRING(value,**{'sizeinbytes': 16, 'raiseonunterminatedread': False, 'raiseontruncate': False, 'terminator': None})
6449 
6450     def __delfield_name(self): del self.__field_name
6451 
6452     name=property(__getfield_name, __setfield_name, __delfield_name, None)
6453 
6454     def __getfield_dunno2(self):
6455         return self.__field_dunno2.getvalue()
6456 
6457     def __setfield_dunno2(self, value):
6458         if isinstance(value,UNKNOWN):
6459             self.__field_dunno2=value
6460         else:
6461             self.__field_dunno2=UNKNOWN(value,**{'sizeinbytes': 1})
6462 
6463     def __delfield_dunno2(self): del self.__field_dunno2
6464 
6465     dunno2=property(__getfield_dunno2, __setfield_dunno2, __delfield_dunno2, None)
6466 
6467     def __getfield_dunno3(self):
6468         return self.__field_dunno3.getvalue()
6469 
6470     def __setfield_dunno3(self, value):
6471         if isinstance(value,UNKNOWN):
6472             self.__field_dunno3=value
6473         else:
6474             self.__field_dunno3=UNKNOWN(value,**{'sizeinbytes': 1})
6475 
6476     def __delfield_dunno3(self): del self.__field_dunno3
6477 
6478     dunno3=property(__getfield_dunno3, __setfield_dunno3, __delfield_dunno3, None)
6479 
6480     def iscontainer(self):
6481         return True
6482 
6483     def containerelements(self):
6484         yield ('slot', self.__field_slot, None)
6485         yield ('dunno1', self.__field_dunno1, None)
6486         yield ('date', self.__field_date, None)
6487         yield ('phonenumlen', self.__field_phonenumlen, None)
6488         yield ('phonenum', self.__field_phonenum, None)
6489         yield ('name', self.__field_name, None)
6490         yield ('dunno2', self.__field_dunno2, None)
6491         yield ('dunno3', self.__field_dunno3, None)
6492 
6493 
6494 
6495 
6496 class historyresponse(BaseProtogenClass):
6497     __fields=['header', 'entry', 'pad']
6498 
6499     def __init__(self, *args, **kwargs):
6500         dict={}
6501         # What was supplied to this function
6502         dict.update(kwargs)
6503         # Parent constructor
6504         super(historyresponse,self).__init__(**dict)
6505         if self.__class__ is historyresponse:
6506             self._update(args,dict)
6507 
6508 
6509     def getfields(self):
6510         return self.__fields
6511 
6512 
6513     def _update(self, args, kwargs):
6514         super(historyresponse,self)._update(args,kwargs)
6515         keys=kwargs.keys()
6516         for key in keys:
6517             if key in self.__fields:
6518                 setattr(self, key, kwargs[key])
6519                 del kwargs[key]
6520         # Were any unrecognized kwargs passed in?
6521         if __debug__:
6522             self._complainaboutunusedargs(historyresponse,kwargs)
6523         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
6524         # Make all P fields that haven't already been constructed
6525 
6526 
6527     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
6528         'Writes this packet to the supplied buffer'
6529         self._bufferstartoffset=buf.getcurrentoffset()
6530         self.__field_header.writetobuffer(buf)
6531         self.__field_entry.writetobuffer(buf)
6532         self.__field_pad.writetobuffer(buf)
6533         self._bufferendoffset=buf.getcurrentoffset()
6534         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
6535 
6536 
6537     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
6538         'Reads this packet from the supplied buffer'
6539         self._bufferstartoffset=buf.getcurrentoffset()
6540         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
6541         self.__field_header=sanyoheader()
6542         self.__field_header.readfrombuffer(buf)
6543         self.__field_entry=historyentry()
6544         self.__field_entry.readfrombuffer(buf)
6545         self.__field_pad=UNKNOWN(**{'sizeinbytes': 428})
6546         self.__field_pad.readfrombuffer(buf)
6547         self._bufferendoffset=buf.getcurrentoffset()
6548 
6549 
6550     def __getfield_header(self):
6551         return self.__field_header.getvalue()
6552 
6553     def __setfield_header(self, value):
6554         if isinstance(value,sanyoheader):
6555             self.__field_header=value
6556         else:
6557             self.__field_header=sanyoheader(value,)
6558 
6559     def __delfield_header(self): del self.__field_header
6560 
6561     header=property(__getfield_header, __setfield_header, __delfield_header, None)
6562 
6563     def __getfield_entry(self):
6564         return self.__field_entry.getvalue()
6565 
6566     def __setfield_entry(self, value):
6567         if isinstance(value,historyentry):
6568             self.__field_entry=value
6569         else:
6570             self.__field_entry=historyentry(value,)
6571 
6572     def __delfield_entry(self): del self.__field_entry
6573 
6574     entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None)
6575 
6576     def __getfield_pad(self):
6577         return self.__field_pad.getvalue()
6578 
6579     def __setfield_pad(self, value):
6580         if isinstance(value,UNKNOWN):
6581             self.__field_pad=value
6582         else:
6583             self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 428})
6584 
6585     def __delfield_pad(self): del self.__field_pad
6586 
6587     pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None)
6588 
6589     def iscontainer(self):
6590         return True
6591 
6592     def containerelements(self):
6593         yield ('header', self.__field_header, None)
6594         yield ('entry', self.__field_entry, None)
6595         yield ('pad', self.__field_pad, None)
6596 
6597 
6598 
6599 
6600 class historymiscentry(BaseProtogenClass):
6601     __fields=['slot', 'pbslotandtype', 'dunno1', 'dunno2', 'dunno3', 'dunno4']
6602 
6603     def __init__(self, *args, **kwargs):
6604         dict={}
6605         # What was supplied to this function
6606         dict.update(kwargs)
6607         # Parent constructor
6608         super(historymiscentry,self).__init__(**dict)
6609         if self.__class__ is historymiscentry:
6610             self._update(args,dict)
6611 
6612 
6613     def getfields(self):
6614         return self.__fields
6615 
6616 
6617     def _update(self, args, kwargs):
6618         super(historymiscentry,self)._update(args,kwargs)
6619         keys=kwargs.keys()
6620         for key in keys:
6621             if key in self.__fields:
6622                 setattr(self, key, kwargs[key])
6623                 del kwargs[key]
6624         # Were any unrecognized kwargs passed in?
6625         if __debug__:
6626             self._complainaboutunusedargs(historymiscentry,kwargs)
6627         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
6628         # Make all P fields that haven't already been constructed
6629 
6630 
6631     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
6632         'Writes this packet to the supplied buffer'
6633         self._bufferstartoffset=buf.getcurrentoffset()
6634         self.__field_slot.writetobuffer(buf)
6635         self.__field_pbslotandtype.writetobuffer(buf)
6636         self.__field_dunno1.writetobuffer(buf)
6637         self.__field_dunno2.writetobuffer(buf)
6638         self.__field_dunno3.writetobuffer(buf)
6639         self.__field_dunno4.writetobuffer(buf)
6640         self._bufferendoffset=buf.getcurrentoffset()
6641         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
6642 
6643 
6644     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
6645         'Reads this packet from the supplied buffer'
6646         self._bufferstartoffset=buf.getcurrentoffset()
6647         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
6648         self.__field_slot=UINT(**{'sizeinbytes': 2})
6649         self.__field_slot.readfrombuffer(buf)
6650         self.__field_pbslotandtype=UINT(**{'sizeinbytes': 2})
6651         self.__field_pbslotandtype.readfrombuffer(buf)
6652         self.__field_dunno1=UINT(**{'sizeinbytes': 2})
6653         self.__field_dunno1.readfrombuffer(buf)
6654         self.__field_dunno2=UINT(**{'sizeinbytes': 1})
6655         self.__field_dunno2.readfrombuffer(buf)
6656         self.__field_dunno3=UINT(**{'sizeinbytes': 1})
6657         self.__field_dunno3.readfrombuffer(buf)
6658         self.__field_dunno4=UINT(**{'sizeinbytes': 1})
6659         self.__field_dunno4.readfrombuffer(buf)
6660         self._bufferendoffset=buf.getcurrentoffset()
6661 
6662 
6663     def __getfield_slot(self):
6664         return self.__field_slot.getvalue()
6665 
6666     def __setfield_slot(self, value):
6667         if isinstance(value,UINT):
6668             self.__field_slot=value
6669         else:
6670             self.__field_slot=UINT(value,**{'sizeinbytes': 2})
6671 
6672     def __delfield_slot(self): del self.__field_slot
6673 
6674     slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None)
6675 
6676     def __getfield_pbslotandtype(self):
6677         return self.__field_pbslotandtype.getvalue()
6678 
6679     def __setfield_pbslotandtype(self, value):
6680         if isinstance(value,UINT):
6681             self.__field_pbslotandtype=value
6682         else:
6683             self.__field_pbslotandtype=UINT(value,**{'sizeinbytes': 2})
6684 
6685     def __delfield_pbslotandtype(self): del self.__field_pbslotandtype
6686 
6687     pbslotandtype=property(__getfield_pbslotandtype, __setfield_pbslotandtype, __delfield_pbslotandtype, None)
6688 
6689     def __getfield_dunno1(self):
6690         return self.__field_dunno1.getvalue()
6691 
6692     def __setfield_dunno1(self, value):
6693         if isinstance(value,UINT):
6694             self.__field_dunno1=value
6695         else:
6696             self.__field_dunno1=UINT(value,**{'sizeinbytes': 2})
6697 
6698     def __delfield_dunno1(self): del self.__field_dunno1
6699 
6700     dunno1=property(__getfield_dunno1, __setfield_dunno1, __delfield_dunno1, None)
6701 
6702     def __getfield_dunno2(self):
6703         return self.__field_dunno2.getvalue()
6704 
6705     def __setfield_dunno2(self, value):
6706         if isinstance(value,UINT):
6707             self.__field_dunno2=value
6708         else:
6709             self.__field_dunno2=UINT(value,**{'sizeinbytes': 1})
6710 
6711     def __delfield_dunno2(self): del self.__field_dunno2
6712 
6713     dunno2=property(__getfield_dunno2, __setfield_dunno2, __delfield_dunno2, None)
6714 
6715     def __getfield_dunno3(self):
6716         return self.__field_dunno3.getvalue()
6717 
6718     def __setfield_dunno3(self, value):
6719         if isinstance(value,UINT):
6720             self.__field_dunno3=value
6721         else:
6722             self.__field_dunno3=UINT(value,**{'sizeinbytes': 1})
6723 
6724     def __delfield_dunno3(self): del self.__field_dunno3
6725 
6726     dunno3=property(__getfield_dunno3, __setfield_dunno3, __delfield_dunno3, None)
6727 
6728     def __getfield_dunno4(self):
6729         return self.__field_dunno4.getvalue()
6730 
6731     def __setfield_dunno4(self, value):
6732         if isinstance(value,UINT):
6733             self.__field_dunno4=value
6734         else:
6735             self.__field_dunno4=UINT(value,**{'sizeinbytes': 1})
6736 
6737     def __delfield_dunno4(self): del self.__field_dunno4
6738 
6739     dunno4=property(__getfield_dunno4, __setfield_dunno4, __delfield_dunno4, None)
6740 
6741     def iscontainer(self):
6742         return True
6743 
6744     def containerelements(self):
6745         yield ('slot', self.__field_slot, None)
6746         yield ('pbslotandtype', self.__field_pbslotandtype, None)
6747         yield ('dunno1', self.__field_dunno1, None)
6748         yield ('dunno2', self.__field_dunno2, None)
6749         yield ('dunno3', self.__field_dunno3, None)
6750         yield ('dunno4', self.__field_dunno4, None)
6751 
6752 
6753 
6754 
6755 class historymiscresponse(BaseProtogenClass):
6756     __fields=['header', 'entry', 'pad']
6757 
6758     def __init__(self, *args, **kwargs):
6759         dict={}
6760         # What was supplied to this function
6761         dict.update(kwargs)
6762         # Parent constructor
6763         super(historymiscresponse,self).__init__(**dict)
6764         if self.__class__ is historymiscresponse:
6765             self._update(args,dict)
6766 
6767 
6768     def getfields(self):
6769         return self.__fields
6770 
6771 
6772     def _update(self, args, kwargs):
6773         super(historymiscresponse,self)._update(args,kwargs)
6774         keys=kwargs.keys()
6775         for key in keys:
6776             if key in self.__fields:
6777                 setattr(self, key, kwargs[key])
6778                 del kwargs[key]
6779         # Were any unrecognized kwargs passed in?
6780         if __debug__:
6781             self._complainaboutunusedargs(historymiscresponse,kwargs)
6782         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
6783         # Make all P fields that haven't already been constructed
6784 
6785 
6786     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
6787         'Writes this packet to the supplied buffer'
6788         self._bufferstartoffset=buf.getcurrentoffset()
6789         self.__field_header.writetobuffer(buf)
6790         self.__field_entry.writetobuffer(buf)
6791         self.__field_pad.writetobuffer(buf)
6792         self._bufferendoffset=buf.getcurrentoffset()
6793         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
6794 
6795 
6796     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
6797         'Reads this packet from the supplied buffer'
6798         self._bufferstartoffset=buf.getcurrentoffset()
6799         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
6800         self.__field_header=sanyoheader()
6801         self.__field_header.readfrombuffer(buf)
6802         self.__field_entry=historymiscentry()
6803         self.__field_entry.readfrombuffer(buf)
6804         self.__field_pad=UNKNOWN(**{'sizeinbytes': 493})
6805         self.__field_pad.readfrombuffer(buf)
6806         self._bufferendoffset=buf.getcurrentoffset()
6807 
6808 
6809     def __getfield_header(self):
6810         return self.__field_header.getvalue()
6811 
6812     def __setfield_header(self, value):
6813         if isinstance(value,sanyoheader):
6814             self.__field_header=value
6815         else:
6816             self.__field_header=sanyoheader(value,)
6817 
6818     def __delfield_header(self): del self.__field_header
6819 
6820     header=property(__getfield_header, __setfield_header, __delfield_header, None)
6821 
6822     def __getfield_entry(self):
6823         return self.__field_entry.getvalue()
6824 
6825     def __setfield_entry(self, value):
6826         if isinstance(value,historymiscentry):
6827             self.__field_entry=value
6828         else:
6829             self.__field_entry=historymiscentry(value,)
6830 
6831     def __delfield_entry(self): del self.__field_entry
6832 
6833     entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None)
6834 
6835     def __getfield_pad(self):
6836         return self.__field_pad.getvalue()
6837 
6838     def __setfield_pad(self, value):
6839         if isinstance(value,UNKNOWN):
6840             self.__field_pad=value
6841         else:
6842             self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 493})
6843 
6844     def __delfield_pad(self): del self.__field_pad
6845 
6846     pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None)
6847 
6848     def iscontainer(self):
6849         return True
6850 
6851     def containerelements(self):
6852         yield ('header', self.__field_header, None)
6853         yield ('entry', self.__field_entry, None)
6854         yield ('pad', self.__field_pad, None)
6855 
6856 
6857 
6858 
6859 class bufferpartrequest(BaseProtogenClass):
6860     __fields=['bufpartsize', 'header', 'pad']
6861 
6862     def __init__(self, *args, **kwargs):
6863         dict={}
6864         # What was supplied to this function
6865         dict.update(kwargs)
6866         # Parent constructor
6867         super(bufferpartrequest,self).__init__(**dict)
6868         if self.__class__ is bufferpartrequest:
6869             self._update(args,dict)
6870 
6871 
6872     def getfields(self):
6873         return self.__fields
6874 
6875 
6876     def _update(self, args, kwargs):
6877         super(bufferpartrequest,self)._update(args,kwargs)
6878         keys=kwargs.keys()
6879         for key in keys:
6880             if key in self.__fields:
6881                 setattr(self, key, kwargs[key])
6882                 del kwargs[key]
6883         # Were any unrecognized kwargs passed in?
6884         if __debug__:
6885             self._complainaboutunusedargs(bufferpartrequest,kwargs)
6886         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
6887         # Make all P fields that haven't already been constructed
6888         try: self.__field_bufpartsize
6889         except:
6890             self.__field_bufpartsize=UINT(**{'constant': 500})
6891 
6892 
6893     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
6894         'Writes this packet to the supplied buffer'
6895         self._bufferstartoffset=buf.getcurrentoffset()
6896         try: self.__field_header
6897         except:
6898             self.__field_header=sanyoheader(**{'packettype': 0x0f})
6899         self.__field_header.writetobuffer(buf)
6900         try: self.__field_pad
6901         except:
6902             self.__field_pad=UNKNOWN(**{'sizeinbytes': 502})
6903         self.__field_pad.writetobuffer(buf)
6904         self._bufferendoffset=buf.getcurrentoffset()
6905         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
6906 
6907 
6908     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
6909         'Reads this packet from the supplied buffer'
6910         self._bufferstartoffset=buf.getcurrentoffset()
6911         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
6912         self.__field_header=sanyoheader(**{'packettype': 0x0f})
6913         self.__field_header.readfrombuffer(buf)
6914         self.__field_pad=UNKNOWN(**{'sizeinbytes': 502})
6915         self.__field_pad.readfrombuffer(buf)
6916         self._bufferendoffset=buf.getcurrentoffset()
6917 
6918 
6919     def __getfield_bufpartsize(self):
6920         return self.__field_bufpartsize.getvalue()
6921 
6922     def __setfield_bufpartsize(self, value):
6923         if isinstance(value,UINT):
6924             self.__field_bufpartsize=value
6925         else:
6926             self.__field_bufpartsize=UINT(value,**{'constant': 500})
6927 
6928     def __delfield_bufpartsize(self): del self.__field_bufpartsize
6929 
6930     bufpartsize=property(__getfield_bufpartsize, __setfield_bufpartsize, __delfield_bufpartsize, None)
6931 
6932     def __getfield_header(self):
6933         try: self.__field_header
6934         except:
6935             self.__field_header=sanyoheader(**{'packettype': 0x0f})
6936         return self.__field_header.getvalue()
6937 
6938     def __setfield_header(self, value):
6939         if isinstance(value,sanyoheader):
6940             self.__field_header=value
6941         else:
6942             self.__field_header=sanyoheader(value,**{'packettype': 0x0f})
6943 
6944     def __delfield_header(self): del self.__field_header
6945 
6946     header=property(__getfield_header, __setfield_header, __delfield_header, None)
6947 
6948     def __getfield_pad(self):
6949         try: self.__field_pad
6950         except:
6951             self.__field_pad=UNKNOWN(**{'sizeinbytes': 502})
6952         return self.__field_pad.getvalue()
6953 
6954     def __setfield_pad(self, value):
6955         if isinstance(value,UNKNOWN):
6956             self.__field_pad=value
6957         else:
6958             self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 502})
6959 
6960     def __delfield_pad(self): del self.__field_pad
6961 
6962     pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None)
6963 
6964     def iscontainer(self):
6965         return True
6966 
6967     def containerelements(self):
6968         yield ('bufpartsize', self.__field_bufpartsize, None)
6969         yield ('header', self.__field_header, None)
6970         yield ('pad', self.__field_pad, None)
6971 
6972 
6973 
6974 
6975 class bufferpartresponse(BaseProtogenClass):
6976     __fields=['bufpartsize', 'header', 'data', 'pad']
6977 
6978     def __init__(self, *args, **kwargs):
6979         dict={}
6980         # What was supplied to this function
6981         dict.update(kwargs)
6982         # Parent constructor
6983         super(bufferpartresponse,self).__init__(**dict)
6984         if self.__class__ is bufferpartresponse:
6985             self._update(args,dict)
6986 
6987 
6988     def getfields(self):
6989         return self.__fields
6990 
6991 
6992     def _update(self, args, kwargs):
6993         super(bufferpartresponse,self)._update(args,kwargs)
6994         keys=kwargs.keys()
6995         for key in keys:
6996             if key in self.__fields:
6997                 setattr(self, key, kwargs[key])
6998                 del kwargs[key]
6999         # Were any unrecognized kwargs passed in?
7000         if __debug__:
7001             self._complainaboutunusedargs(bufferpartresponse,kwargs)
7002         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
7003         # Make all P fields that haven't already been constructed
7004         try: self.__field_bufpartsize
7005         except:
7006             self.__field_bufpartsize=UINT(**{'constant': 500})
7007 
7008 
7009     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
7010         'Writes this packet to the supplied buffer'
7011         self._bufferstartoffset=buf.getcurrentoffset()
7012         self.__field_header.writetobuffer(buf)
7013         self.__field_data.writetobuffer(buf)
7014         self.__field_pad.writetobuffer(buf)
7015         self._bufferendoffset=buf.getcurrentoffset()
7016         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
7017 
7018 
7019     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
7020         'Reads this packet from the supplied buffer'
7021         self._bufferstartoffset=buf.getcurrentoffset()
7022         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
7023         self.__field_header=sanyoheader()
7024         self.__field_header.readfrombuffer(buf)
7025         self.__field_data=DATA(**{'sizeinbytes': self.bufpartsize})
7026         self.__field_data.readfrombuffer(buf)
7027         self.__field_pad=UNKNOWN(**{'sizeinbytes': 2})
7028         self.__field_pad.readfrombuffer(buf)
7029         self._bufferendoffset=buf.getcurrentoffset()
7030 
7031 
7032     def __getfield_bufpartsize(self):
7033         return self.__field_bufpartsize.getvalue()
7034 
7035     def __setfield_bufpartsize(self, value):
7036         if isinstance(value,UINT):
7037             self.__field_bufpartsize=value
7038         else:
7039             self.__field_bufpartsize=UINT(value,**{'constant': 500})
7040 
7041     def __delfield_bufpartsize(self): del self.__field_bufpartsize
7042 
7043     bufpartsize=property(__getfield_bufpartsize, __setfield_bufpartsize, __delfield_bufpartsize, None)
7044 
7045     def __getfield_header(self):
7046         return self.__field_header.getvalue()
7047 
7048     def __setfield_header(self, value):
7049         if isinstance(value,sanyoheader):
7050             self.__field_header=value
7051         else:
7052             self.__field_header=sanyoheader(value,)
7053 
7054     def __delfield_header(self): del self.__field_header
7055 
7056     header=property(__getfield_header, __setfield_header, __delfield_header, None)
7057 
7058     def __getfield_data(self):
7059         return self.__field_data.getvalue()
7060 
7061     def __setfield_data(self, value):
7062         if isinstance(value,DATA):
7063             self.__field_data=value
7064         else:
7065             self.__field_data=DATA(value,**{'sizeinbytes': self.bufpartsize})
7066 
7067     def __delfield_data(self): del self.__field_data
7068 
7069     data=property(__getfield_data, __setfield_data, __delfield_data, None)
7070 
7071     def __getfield_pad(self):
7072         return self.__field_pad.getvalue()
7073 
7074     def __setfield_pad(self, value):
7075         if isinstance(value,UNKNOWN):
7076             self.__field_pad=value
7077         else:
7078             self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 2})
7079 
7080     def __delfield_pad(self): del self.__field_pad
7081 
7082     pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None)
7083 
7084     def iscontainer(self):
7085         return True
7086 
7087     def containerelements(self):
7088         yield ('bufpartsize', self.__field_bufpartsize, None)
7089         yield ('header', self.__field_header, None)
7090         yield ('data', self.__field_data, None)
7091         yield ('pad', self.__field_pad, None)
7092 
7093 
7094 
7095 
7096 class bufferpartupdaterequest(BaseProtogenClass):
7097     __fields=['bufpartsize', 'header', 'data', 'pad']
7098 
7099     def __init__(self, *args, **kwargs):
7100         dict={}
7101         # What was supplied to this function
7102         dict.update(kwargs)
7103         # Parent constructor
7104         super(bufferpartupdaterequest,self).__init__(**dict)
7105         if self.__class__ is bufferpartupdaterequest:
7106             self._update(args,dict)
7107 
7108 
7109     def getfields(self):
7110         return self.__fields
7111 
7112 
7113     def _update(self, args, kwargs):
7114         super(bufferpartupdaterequest,self)._update(args,kwargs)
7115         keys=kwargs.keys()
7116         for key in keys:
7117             if key in self.__fields:
7118                 setattr(self, key, kwargs[key])
7119                 del kwargs[key]
7120         # Were any unrecognized kwargs passed in?
7121         if __debug__:
7122             self._complainaboutunusedargs(bufferpartupdaterequest,kwargs)
7123         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
7124         # Make all P fields that haven't already been constructed
7125         try: self.__field_bufpartsize
7126         except:
7127             self.__field_bufpartsize=UINT(**{'constant': 500})
7128 
7129 
7130     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
7131         'Writes this packet to the supplied buffer'
7132         self._bufferstartoffset=buf.getcurrentoffset()
7133         try: self.__field_header
7134         except:
7135             self.__field_header=sanyoheader(**{'readwrite': 0x0e, 'packettype': 0x0f})
7136         self.__field_header.writetobuffer(buf)
7137         self.__field_data.writetobuffer(buf)
7138         try: self.__field_pad
7139         except:
7140             self.__field_pad=UNKNOWN(**{'sizeinbytes': 2})
7141         self.__field_pad.writetobuffer(buf)
7142         self._bufferendoffset=buf.getcurrentoffset()
7143         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
7144 
7145 
7146     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
7147         'Reads this packet from the supplied buffer'
7148         self._bufferstartoffset=buf.getcurrentoffset()
7149         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
7150         self.__field_header=sanyoheader(**{'readwrite': 0x0e, 'packettype': 0x0f})
7151         self.__field_header.readfrombuffer(buf)
7152         self.__field_data=DATA(**{'sizeinbytes': self.bufpartsize})
7153         self.__field_data.readfrombuffer(buf)
7154         self.__field_pad=UNKNOWN(**{'sizeinbytes': 2})
7155         self.__field_pad.readfrombuffer(buf)
7156         self._bufferendoffset=buf.getcurrentoffset()
7157 
7158 
7159     def __getfield_bufpartsize(self):
7160         return self.__field_bufpartsize.getvalue()
7161 
7162     def __setfield_bufpartsize(self, value):
7163         if isinstance(value,UINT):
7164             self.__field_bufpartsize=value
7165         else:
7166             self.__field_bufpartsize=UINT(value,**{'constant': 500})
7167 
7168     def __delfield_bufpartsize(self): del self.__field_bufpartsize
7169 
7170     bufpartsize=property(__getfield_bufpartsize, __setfield_bufpartsize, __delfield_bufpartsize, None)
7171 
7172     def __getfield_header(self):
7173         try: self.__field_header
7174         except:
7175             self.__field_header=sanyoheader(**{'readwrite': 0x0e, 'packettype': 0x0f})
7176         return self.__field_header.getvalue()
7177 
7178     def __setfield_header(self, value):
7179         if isinstance(value,sanyoheader):
7180             self.__field_header=value
7181         else:
7182             self.__field_header=sanyoheader(value,**{'readwrite': 0x0e, 'packettype': 0x0f})
7183 
7184     def __delfield_header(self): del self.__field_header
7185 
7186     header=property(__getfield_header, __setfield_header, __delfield_header, None)
7187 
7188     def __getfield_data(self):
7189         return self.__field_data.getvalue()
7190 
7191     def __setfield_data(self, value):
7192         if isinstance(value,DATA):
7193             self.__field_data=value
7194         else:
7195             self.__field_data=DATA(value,**{'sizeinbytes': self.bufpartsize})
7196 
7197     def __delfield_data(self): del self.__field_data
7198 
7199     data=property(__getfield_data, __setfield_data, __delfield_data, None)
7200 
7201     def __getfield_pad(self):
7202         try: self.__field_pad
7203         except:
7204             self.__field_pad=UNKNOWN(**{'sizeinbytes': 2})
7205         return self.__field_pad.getvalue()
7206 
7207     def __setfield_pad(self, value):
7208         if isinstance(value,UNKNOWN):
7209             self.__field_pad=value
7210         else:
7211             self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 2})
7212 
7213     def __delfield_pad(self): del self.__field_pad
7214 
7215     pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None)
7216 
7217     def iscontainer(self):
7218         return True
7219 
7220     def containerelements(self):
7221         yield ('bufpartsize', self.__field_bufpartsize, None)
7222         yield ('header', self.__field_header, None)
7223         yield ('data', self.__field_data, None)
7224         yield ('pad', self.__field_pad, None)
7225 
7226 
7227 
7228 
7229 class phonebookslotrequest(BaseProtogenClass):
7230     __fields=['header', 'slot', 'pad']
7231 
7232     def __init__(self, *args, **kwargs):
7233         dict={}
7234         # What was supplied to this function
7235         dict.update(kwargs)
7236         # Parent constructor
7237         super(phonebookslotrequest,self).__init__(**dict)
7238         if self.__class__ is phonebookslotrequest:
7239             self._update(args,dict)
7240 
7241 
7242     def getfields(self):
7243         return self.__fields
7244 
7245 
7246     def _update(self, args, kwargs):
7247         super(phonebookslotrequest,self)._update(args,kwargs)
7248         keys=kwargs.keys()
7249         for key in keys:
7250             if key in self.__fields:
7251                 setattr(self, key, kwargs[key])
7252                 del kwargs[key]
7253         # Were any unrecognized kwargs passed in?
7254         if __debug__:
7255             self._complainaboutunusedargs(phonebookslotrequest,kwargs)
7256         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
7257         # Make all P fields that haven't already been constructed
7258 
7259 
7260     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
7261         'Writes this packet to the supplied buffer'
7262         self._bufferstartoffset=buf.getcurrentoffset()
7263         try: self.__field_header
7264         except:
7265             self.__field_header=sanyoheader(**{'packettype': 0x0c,                   'command': 0x28})
7266         self.__field_header.writetobuffer(buf)
7267         self.__field_slot.writetobuffer(buf)
7268         try: self.__field_pad
7269         except:
7270             self.__field_pad=UNKNOWN(**{'sizeinbytes': 500})
7271         self.__field_pad.writetobuffer(buf)
7272         self._bufferendoffset=buf.getcurrentoffset()
7273         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
7274 
7275 
7276     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
7277         'Reads this packet from the supplied buffer'
7278         self._bufferstartoffset=buf.getcurrentoffset()
7279         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
7280         self.__field_header=sanyoheader(**{'packettype': 0x0c,                   'command': 0x28})
7281         self.__field_header.readfrombuffer(buf)
7282         self.__field_slot=UINT(**{'sizeinbytes': 2})
7283         self.__field_slot.readfrombuffer(buf)
7284         self.__field_pad=UNKNOWN(**{'sizeinbytes': 500})
7285         self.__field_pad.readfrombuffer(buf)
7286         self._bufferendoffset=buf.getcurrentoffset()
7287 
7288 
7289     def __getfield_header(self):
7290         try: self.__field_header
7291         except:
7292             self.__field_header=sanyoheader(**{'packettype': 0x0c,                   'command': 0x28})
7293         return self.__field_header.getvalue()
7294 
7295     def __setfield_header(self, value):
7296         if isinstance(value,sanyoheader):
7297             self.__field_header=value
7298         else:
7299             self.__field_header=sanyoheader(value,**{'packettype': 0x0c,                   'command': 0x28})
7300 
7301     def __delfield_header(self): del self.__field_header
7302 
7303     header=property(__getfield_header, __setfield_header, __delfield_header, None)
7304 
7305     def __getfield_slot(self):
7306         return self.__field_slot.getvalue()
7307 
7308     def __setfield_slot(self, value):
7309         if isinstance(value,UINT):
7310             self.__field_slot=value
7311         else:
7312             self.__field_slot=UINT(value,**{'sizeinbytes': 2})
7313 
7314     def __delfield_slot(self): del self.__field_slot
7315 
7316     slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None)
7317 
7318     def __getfield_pad(self):
7319         try: self.__field_pad
7320         except:
7321             self.__field_pad=UNKNOWN(**{'sizeinbytes': 500})
7322         return self.__field_pad.getvalue()
7323 
7324     def __setfield_pad(self, value):
7325         if isinstance(value,UNKNOWN):
7326             self.__field_pad=value
7327         else:
7328             self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 500})
7329 
7330     def __delfield_pad(self): del self.__field_pad
7331 
7332     pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None)
7333 
7334     def iscontainer(self):
7335         return True
7336 
7337     def containerelements(self):
7338         yield ('header', self.__field_header, None)
7339         yield ('slot', self.__field_slot, None)
7340         yield ('pad', self.__field_pad, None)
7341 
7342 
7343 
7344 
7345 class phonenumber(BaseProtogenClass):
7346     __fields=['number_len', 'number']
7347 
7348     def __init__(self, *args, **kwargs):
7349         dict={}
7350         # What was supplied to this function
7351         dict.update(kwargs)
7352         # Parent constructor
7353         super(phonenumber,self).__init__(**dict)
7354         if self.__class__ is phonenumber:
7355             self._update(args,dict)
7356 
7357 
7358     def getfields(self):
7359         return self.__fields
7360 
7361 
7362     def _update(self, args, kwargs):
7363         super(phonenumber,self)._update(args,kwargs)
7364         keys=kwargs.keys()
7365         for key in keys:
7366             if key in self.__fields:
7367                 setattr(self, key, kwargs[key])
7368                 del kwargs[key]
7369         # Were any unrecognized kwargs passed in?
7370         if __debug__:
7371             self._complainaboutunusedargs(phonenumber,kwargs)
7372         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
7373         # Make all P fields that haven't already been constructed
7374 
7375 
7376     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
7377         'Writes this packet to the supplied buffer'
7378         self._bufferstartoffset=buf.getcurrentoffset()
7379         try: self.__field_number_len
7380         except:
7381             self.__field_number_len=UINT(**{'sizeinbytes': 1, 'default': 0})
7382         self.__field_number_len.writetobuffer(buf)
7383         try: self.__field_number
7384         except:
7385             self.__field_number=USTRING(**{'sizeinbytes': 49, 'default': ""})
7386         self.__field_number.writetobuffer(buf)
7387         self._bufferendoffset=buf.getcurrentoffset()
7388         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
7389 
7390 
7391     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
7392         'Reads this packet from the supplied buffer'
7393         self._bufferstartoffset=buf.getcurrentoffset()
7394         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
7395         self.__field_number_len=UINT(**{'sizeinbytes': 1, 'default': 0})
7396         self.__field_number_len.readfrombuffer(buf)
7397         self.__field_number=USTRING(**{'sizeinbytes': 49, 'default': ""})
7398         self.__field_number.readfrombuffer(buf)
7399         self._bufferendoffset=buf.getcurrentoffset()
7400 
7401 
7402     def __getfield_number_len(self):
7403         try: self.__field_number_len
7404         except:
7405             self.__field_number_len=UINT(**{'sizeinbytes': 1, 'default': 0})
7406         return self.__field_number_len.getvalue()
7407 
7408     def __setfield_number_len(self, value):
7409         if isinstance(value,UINT):
7410             self.__field_number_len=value
7411         else:
7412             self.__field_number_len=UINT(value,**{'sizeinbytes': 1, 'default': 0})
7413 
7414     def __delfield_number_len(self): del self.__field_number_len
7415 
7416     number_len=property(__getfield_number_len, __setfield_number_len, __delfield_number_len, None)
7417 
7418     def __getfield_number(self):
7419         try: self.__field_number
7420         except:
7421             self.__field_number=USTRING(**{'sizeinbytes': 49, 'default': ""})
7422         return self.__field_number.getvalue()
7423 
7424     def __setfield_number(self, value):
7425         if isinstance(value,USTRING):
7426             self.__field_number=value
7427         else:
7428             self.__field_number=USTRING(value,**{'sizeinbytes': 49, 'default': ""})
7429 
7430     def __delfield_number(self): del self.__field_number
7431 
7432     number=property(__getfield_number, __setfield_number, __delfield_number, None)
7433 
7434     def iscontainer(self):
7435         return True
7436 
7437     def containerelements(self):
7438         yield ('number_len', self.__field_number_len, None)
7439         yield ('number', self.__field_number, None)
7440 
7441 
7442 
7443 
7444 class phonebookentry(BaseProtogenClass):
7445     __fields=['slot', 'slotdup', 'name', 'numbers', 'email_len', 'email', 'url_len', 'url', 'secret', 'name_len']
7446 
7447     def __init__(self, *args, **kwargs):
7448         dict={}
7449         # What was supplied to this function
7450         dict.update(kwargs)
7451         # Parent constructor
7452         super(phonebookentry,self).__init__(**dict)
7453         if self.__class__ is phonebookentry:
7454             self._update(args,dict)
7455 
7456 
7457     def getfields(self):
7458         return self.__fields
7459 
7460 
7461     def _update(self, args, kwargs):
7462         super(phonebookentry,self)._update(args,kwargs)
7463         keys=kwargs.keys()
7464         for key in keys:
7465             if key in self.__fields:
7466                 setattr(self, key, kwargs[key])
7467                 del kwargs[key]
7468         # Were any unrecognized kwargs passed in?
7469         if __debug__:
7470             self._complainaboutunusedargs(phonebookentry,kwargs)
7471         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
7472         # Make all P fields that haven't already been constructed
7473 
7474 
7475     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
7476         'Writes this packet to the supplied buffer'
7477         self._bufferstartoffset=buf.getcurrentoffset()
7478         self.__field_slot.writetobuffer(buf)
7479         self.__field_slotdup.writetobuffer(buf)
7480         self.__field_name.writetobuffer(buf)
7481         try: self.__field_numbers
7482         except:
7483             self.__field_numbers=LIST(**{'length': 7, 'createdefault': True, 'elementclass': phonenumber})
7484         self.__field_numbers.writetobuffer(buf)
7485         try: self.__field_email_len
7486         except:
7487             self.__field_email_len=UINT(**{'sizeinbytes': 1})
7488         self.__field_email_len.writetobuffer(buf)
7489         try: self.__field_email
7490         except:
7491             self.__field_email=USTRING(**{'sizeinbytes': 49, 'default': ""})
7492         self.__field_email.writetobuffer(buf)
7493         try: self.__field_url_len
7494         except:
7495             self.__field_url_len=UINT(**{'sizeinbytes': 1})
7496         self.__field_url_len.writetobuffer(buf)
7497         try: self.__field_url
7498         except:
7499             self.__field_url=USTRING(**{'sizeinbytes': 49, 'default': ""})
7500         self.__field_url.writetobuffer(buf)
7501         try: self.__field_secret
7502         except:
7503             self.__field_secret=BOOL(**{'sizeinbytes': 1})
7504         self.__field_secret.writetobuffer(buf)
7505         self.__field_name_len.writetobuffer(buf)
7506         self._bufferendoffset=buf.getcurrentoffset()
7507         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
7508 
7509 
7510     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
7511         'Reads this packet from the supplied buffer'
7512         self._bufferstartoffset=buf.getcurrentoffset()
7513         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
7514         self.__field_slot=UINT(**{'sizeinbytes': 2})
7515         self.__field_slot.readfrombuffer(buf)
7516         self.__field_slotdup=UINT(**{'sizeinbytes': 2})
7517         self.__field_slotdup.readfrombuffer(buf)
7518         self.__field_name=USTRING(**{'sizeinbytes': 16, 'raiseonunterminatedread': False, 'raiseontruncate': False, 'terminator': None})
7519         self.__field_name.readfrombuffer(buf)
7520         self.__field_numbers=LIST(**{'length': 7, 'createdefault': True, 'elementclass': phonenumber})
7521         self.__field_numbers.readfrombuffer(buf)
7522         self.__field_email_len=UINT(**{'sizeinbytes': 1})
7523         self.__field_email_len.readfrombuffer(buf)
7524         self.__field_email=USTRING(**{'sizeinbytes': 49, 'default': ""})
7525         self.__field_email.readfrombuffer(buf)
7526         self.__field_url_len=UINT(**{'sizeinbytes': 1})
7527         self.__field_url_len.readfrombuffer(buf)
7528         self.__field_url=USTRING(**{'sizeinbytes': 49, 'default': ""})
7529         self.__field_url.readfrombuffer(buf)
7530         self.__field_secret=BOOL(**{'sizeinbytes': 1})
7531         self.__field_secret.readfrombuffer(buf)
7532         self.__field_name_len=UINT(**{'sizeinbytes': 1})
7533         self.__field_name_len.readfrombuffer(buf)
7534         self._bufferendoffset=buf.getcurrentoffset()
7535 
7536 
7537     def __getfield_slot(self):
7538         return self.__field_slot.getvalue()
7539 
7540     def __setfield_slot(self, value):
7541         if isinstance(value,UINT):
7542             self.__field_slot=value
7543         else:
7544             self.__field_slot=UINT(value,**{'sizeinbytes': 2})
7545 
7546     def __delfield_slot(self): del self.__field_slot
7547 
7548     slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None)
7549 
7550     def __getfield_slotdup(self):
7551         return self.__field_slotdup.getvalue()
7552 
7553     def __setfield_slotdup(self, value):
7554         if isinstance(value,UINT):
7555             self.__field_slotdup=value
7556         else:
7557             self.__field_slotdup=UINT(value,**{'sizeinbytes': 2})
7558 
7559     def __delfield_slotdup(self): del self.__field_slotdup
7560 
7561     slotdup=property(__getfield_slotdup, __setfield_slotdup, __delfield_slotdup, None)
7562 
7563     def __getfield_name(self):
7564         return self.__field_name.getvalue()
7565 
7566     def __setfield_name(self, value):
7567         if isinstance(value,USTRING):
7568             self.__field_name=value
7569         else:
7570             self.__field_name=USTRING(value,**{'sizeinbytes': 16, 'raiseonunterminatedread': False, 'raiseontruncate': False, 'terminator': None})
7571 
7572     def __delfield_name(self): del self.__field_name
7573 
7574     name=property(__getfield_name, __setfield_name, __delfield_name, None)
7575 
7576     def __getfield_numbers(self):
7577         try: self.__field_numbers
7578         except:
7579             self.__field_numbers=LIST(**{'length': 7, 'createdefault': True, 'elementclass': phonenumber})
7580         return self.__field_numbers.getvalue()
7581 
7582     def __setfield_numbers(self, value):
7583         if isinstance(value,LIST):
7584             self.__field_numbers=value
7585         else:
7586             self.__field_numbers=LIST(value,**{'length': 7, 'createdefault': True, 'elementclass': phonenumber})
7587 
7588     def __delfield_numbers(self): del self.__field_numbers
7589 
7590     numbers=property(__getfield_numbers, __setfield_numbers, __delfield_numbers, None)
7591 
7592     def __getfield_email_len(self):
7593         try: self.__field_email_len
7594         except:
7595             self.__field_email_len=UINT(**{'sizeinbytes': 1})
7596         return self.__field_email_len.getvalue()
7597 
7598     def __setfield_email_len(self, value):
7599         if isinstance(value,UINT):
7600             self.__field_email_len=value
7601         else:
7602             self.__field_email_len=UINT(value,**{'sizeinbytes': 1})
7603 
7604     def __delfield_email_len(self): del self.__field_email_len
7605 
7606     email_len=property(__getfield_email_len, __setfield_email_len, __delfield_email_len, None)
7607 
7608     def __getfield_email(self):
7609         try: self.__field_email
7610         except:
7611             self.__field_email=USTRING(**{'sizeinbytes': 49, 'default': ""})
7612         return self.__field_email.getvalue()
7613 
7614     def __setfield_email(self, value):
7615         if isinstance(value,USTRING):
7616             self.__field_email=value
7617         else:
7618             self.__field_email=USTRING(value,**{'sizeinbytes': 49, 'default': ""})
7619 
7620     def __delfield_email(self): del self.__field_email
7621 
7622     email=property(__getfield_email, __setfield_email, __delfield_email, None)
7623 
7624     def __getfield_url_len(self):
7625         try: self.__field_url_len
7626         except:
7627             self.__field_url_len=UINT(**{'sizeinbytes': 1})
7628         return self.__field_url_len.getvalue()
7629 
7630     def __setfield_url_len(self, value):
7631         if isinstance(value,UINT):
7632             self.__field_url_len=value
7633         else:
7634             self.__field_url_len=UINT(value,**{'sizeinbytes': 1})
7635 
7636     def __delfield_url_len(self): del self.__field_url_len
7637 
7638     url_len=property(__getfield_url_len, __setfield_url_len, __delfield_url_len, None)
7639 
7640     def __getfield_url(self):
7641         try: self.__field_url
7642         except:
7643             self.__field_url=USTRING(**{'sizeinbytes': 49, 'default': ""})
7644         return self.__field_url.getvalue()
7645 
7646     def __setfield_url(self, value):
7647         if isinstance(value,USTRING):
7648             self.__field_url=value
7649         else:
7650             self.__field_url=USTRING(value,**{'sizeinbytes': 49, 'default': ""})
7651 
7652     def __delfield_url(self): del self.__field_url
7653 
7654     url=property(__getfield_url, __setfield_url, __delfield_url, None)
7655 
7656     def __getfield_secret(self):
7657         try: self.__field_secret
7658         except:
7659             self.__field_secret=BOOL(**{'sizeinbytes': 1})
7660         return self.__field_secret.getvalue()
7661 
7662     def __setfield_secret(self, value):
7663         if isinstance(value,BOOL):
7664             self.__field_secret=value
7665         else:
7666             self.__field_secret=BOOL(value,**{'sizeinbytes': 1})
7667 
7668     def __delfield_secret(self): del self.__field_secret
7669 
7670     secret=property(__getfield_secret, __setfield_secret, __delfield_secret, None)
7671 
7672     def __getfield_name_len(self):
7673         return self.__field_name_len.getvalue()
7674 
7675     def __setfield_name_len(self, value):
7676         if isinstance(value,UINT):
7677             self.__field_name_len=value
7678         else:
7679             self.__field_name_len=UINT(value,**{'sizeinbytes': 1})
7680 
7681     def __delfield_name_len(self): del self.__field_name_len
7682 
7683     name_len=property(__getfield_name_len, __setfield_name_len, __delfield_name_len, None)
7684 
7685     def iscontainer(self):
7686         return True
7687 
7688     def containerelements(self):
7689         yield ('slot', self.__field_slot, None)
7690         yield ('slotdup', self.__field_slotdup, None)
7691         yield ('name', self.__field_name, None)
7692         yield ('numbers', self.__field_numbers, None)
7693         yield ('email_len', self.__field_email_len, None)
7694         yield ('email', self.__field_email, None)
7695         yield ('url_len', self.__field_url_len, None)
7696         yield ('url', self.__field_url, None)
7697         yield ('secret', self.__field_secret, None)
7698         yield ('name_len', self.__field_name_len, None)
7699 
7700 
7701 
7702 
7703 class phonebookslotresponse(BaseProtogenClass):
7704     __fields=['header', 'entry', 'pad']
7705 
7706     def __init__(self, *args, **kwargs):
7707         dict={}
7708         # What was supplied to this function
7709         dict.update(kwargs)
7710         # Parent constructor
7711         super(phonebookslotresponse,self).__init__(**dict)
7712         if self.__class__ is phonebookslotresponse:
7713             self._update(args,dict)
7714 
7715 
7716     def getfields(self):
7717         return self.__fields
7718 
7719 
7720     def _update(self, args, kwargs):
7721         super(phonebookslotresponse,self)._update(args,kwargs)
7722         keys=kwargs.keys()
7723         for key in keys:
7724             if key in self.__fields:
7725                 setattr(self, key, kwargs[key])
7726                 del kwargs[key]
7727         # Were any unrecognized kwargs passed in?
7728         if __debug__:
7729             self._complainaboutunusedargs(phonebookslotresponse,kwargs)
7730         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
7731         # Make all P fields that haven't already been constructed
7732 
7733 
7734     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
7735         'Writes this packet to the supplied buffer'
7736         self._bufferstartoffset=buf.getcurrentoffset()
7737         self.__field_header.writetobuffer(buf)
7738         self.__field_entry.writetobuffer(buf)
7739         self.__field_pad.writetobuffer(buf)
7740         self._bufferendoffset=buf.getcurrentoffset()
7741         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
7742 
7743 
7744     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
7745         'Reads this packet from the supplied buffer'
7746         self._bufferstartoffset=buf.getcurrentoffset()
7747         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
7748         self.__field_header=sanyoheader()
7749         self.__field_header.readfrombuffer(buf)
7750         self.__field_entry=phonebookentry()
7751         self.__field_entry.readfrombuffer(buf)
7752         self.__field_pad=UNKNOWN(**{'sizeinbytes': 30})
7753         self.__field_pad.readfrombuffer(buf)
7754         self._bufferendoffset=buf.getcurrentoffset()
7755 
7756 
7757     def __getfield_header(self):
7758         return self.__field_header.getvalue()
7759 
7760     def __setfield_header(self, value):
7761         if isinstance(value,sanyoheader):
7762             self.__field_header=value
7763         else:
7764             self.__field_header=sanyoheader(value,)
7765 
7766     def __delfield_header(self): del self.__field_header
7767 
7768     header=property(__getfield_header, __setfield_header, __delfield_header, None)
7769 
7770     def __getfield_entry(self):
7771         return self.__field_entry.getvalue()
7772 
7773     def __setfield_entry(self, value):
7774         if isinstance(value,phonebookentry):
7775             self.__field_entry=value
7776         else:
7777             self.__field_entry=phonebookentry(value,)
7778 
7779     def __delfield_entry(self): del self.__field_entry
7780 
7781     entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None)
7782 
7783     def __getfield_pad(self):
7784         return self.__field_pad.getvalue()
7785 
7786     def __setfield_pad(self, value):
7787         if isinstance(value,UNKNOWN):
7788             self.__field_pad=value
7789         else:
7790             self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 30})
7791 
7792     def __delfield_pad(self): del self.__field_pad
7793 
7794     pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None)
7795 
7796     def iscontainer(self):
7797         return True
7798 
7799     def containerelements(self):
7800         yield ('header', self.__field_header, None)
7801         yield ('entry', self.__field_entry, None)
7802         yield ('pad', self.__field_pad, None)
7803 
7804 
7805 
7806 
7807 class phonebookslotupdaterequest(BaseProtogenClass):
7808     __fields=['header', 'entry', 'pad']
7809 
7810     def __init__(self, *args, **kwargs):
7811         dict={}
7812         # What was supplied to this function
7813         dict.update(kwargs)
7814         # Parent constructor
7815         super(phonebookslotupdaterequest,self).__init__(**dict)
7816         if self.__class__ is phonebookslotupdaterequest:
7817             self._update(args,dict)
7818 
7819 
7820     def getfields(self):
7821         return self.__fields
7822 
7823 
7824     def _update(self, args, kwargs):
7825         super(phonebookslotupdaterequest,self)._update(args,kwargs)
7826         keys=kwargs.keys()
7827         for key in keys:
7828             if key in self.__fields:
7829                 setattr(self, key, kwargs[key])
7830                 del kwargs[key]
7831         # Were any unrecognized kwargs passed in?
7832         if __debug__:
7833             self._complainaboutunusedargs(phonebookslotupdaterequest,kwargs)
7834         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
7835         # Make all P fields that haven't already been constructed
7836 
7837 
7838     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
7839         'Writes this packet to the supplied buffer'
7840         self._bufferstartoffset=buf.getcurrentoffset()
7841         try: self.__field_header
7842         except:
7843             self.__field_header=sanyoheader(**{'packettype': 0x0c, 'readwrite': 0x0e,                   'command': 0x28})
7844         self.__field_header.writetobuffer(buf)
7845         self.__field_entry.writetobuffer(buf)
7846         try: self.__field_pad
7847         except:
7848             self.__field_pad=UNKNOWN(**{'sizeinbytes': 30})
7849         self.__field_pad.writetobuffer(buf)
7850         self._bufferendoffset=buf.getcurrentoffset()
7851         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
7852 
7853 
7854     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
7855         'Reads this packet from the supplied buffer'
7856         self._bufferstartoffset=buf.getcurrentoffset()
7857         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
7858         self.__field_header=sanyoheader(**{'packettype': 0x0c, 'readwrite': 0x0e,                   'command': 0x28})
7859         self.__field_header.readfrombuffer(buf)
7860         self.__field_entry=phonebookentry()
7861         self.__field_entry.readfrombuffer(buf)
7862         self.__field_pad=UNKNOWN(**{'sizeinbytes': 30})
7863         self.__field_pad.readfrombuffer(buf)
7864         self._bufferendoffset=buf.getcurrentoffset()
7865 
7866 
7867     def __getfield_header(self):
7868         try: self.__field_header
7869         except:
7870             self.__field_header=sanyoheader(**{'packettype': 0x0c, 'readwrite': 0x0e,                   'command': 0x28})
7871         return self.__field_header.getvalue()
7872 
7873     def __setfield_header(self, value):
7874         if isinstance(value,sanyoheader):
7875             self.__field_header=value
7876         else:
7877             self.__field_header=sanyoheader(value,**{'packettype': 0x0c, 'readwrite': 0x0e,                   'command': 0x28})
7878 
7879     def __delfield_header(self): del self.__field_header
7880 
7881     header=property(__getfield_header, __setfield_header, __delfield_header, None)
7882 
7883     def __getfield_entry(self):
7884         return self.__field_entry.getvalue()
7885 
7886     def __setfield_entry(self, value):
7887         if isinstance(value,phonebookentry):
7888             self.__field_entry=value
7889         else:
7890             self.__field_entry=phonebookentry(value,)
7891 
7892     def __delfield_entry(self): del self.__field_entry
7893 
7894     entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None)
7895 
7896     def __getfield_pad(self):
7897         try: self.__field_pad
7898         except:
7899             self.__field_pad=UNKNOWN(**{'sizeinbytes': 30})
7900         return self.__field_pad.getvalue()
7901 
7902     def __setfield_pad(self, value):
7903         if isinstance(value,UNKNOWN):
7904             self.__field_pad=value
7905         else:
7906             self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 30})
7907 
7908     def __delfield_pad(self): del self.__field_pad
7909 
7910     pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None)
7911 
7912     def iscontainer(self):
7913         return True
7914 
7915     def containerelements(self):
7916         yield ('header', self.__field_header, None)
7917         yield ('entry', self.__field_entry, None)
7918         yield ('pad', self.__field_pad, None)
7919 
7920 
7921 
7922 
7923 class voicedialrequest(BaseProtogenClass):
7924     __fields=['header', 'slot', 'pad']
7925 
7926     def __init__(self, *args, **kwargs):
7927         dict={}
7928         # What was supplied to this function
7929         dict.update(kwargs)
7930         # Parent constructor
7931         super(voicedialrequest,self).__init__(**dict)
7932         if self.__class__ is voicedialrequest:
7933             self._update(args,dict)
7934 
7935 
7936     def getfields(self):
7937         return self.__fields
7938 
7939 
7940     def _update(self, args, kwargs):
7941         super(voicedialrequest,self)._update(args,kwargs)
7942         keys=kwargs.keys()
7943         for key in keys:
7944             if key in self.__fields:
7945                 setattr(self, key, kwargs[key])
7946                 del kwargs[key]
7947         # Were any unrecognized kwargs passed in?
7948         if __debug__:
7949             self._complainaboutunusedargs(voicedialrequest,kwargs)
7950         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
7951         # Make all P fields that haven't already been constructed
7952 
7953 
7954     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
7955         'Writes this packet to the supplied buffer'
7956         self._bufferstartoffset=buf.getcurrentoffset()
7957         try: self.__field_header
7958         except:
7959             self.__field_header=sanyoheader(**{'packettype': 0x0b,                   'command': 0xed})
7960         self.__field_header.writetobuffer(buf)
7961         self.__field_slot.writetobuffer(buf)
7962         try: self.__field_pad
7963         except:
7964             self.__field_pad=UNKNOWN(**{'sizeinbytes': 501})
7965         self.__field_pad.writetobuffer(buf)
7966         self._bufferendoffset=buf.getcurrentoffset()
7967         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
7968 
7969 
7970     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
7971         'Reads this packet from the supplied buffer'
7972         self._bufferstartoffset=buf.getcurrentoffset()
7973         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
7974         self.__field_header=sanyoheader(**{'packettype': 0x0b,                   'command': 0xed})
7975         self.__field_header.readfrombuffer(buf)
7976         self.__field_slot=UINT(**{'sizeinbytes': 1})
7977         self.__field_slot.readfrombuffer(buf)
7978         self.__field_pad=UNKNOWN(**{'sizeinbytes': 501})
7979         self.__field_pad.readfrombuffer(buf)
7980         self._bufferendoffset=buf.getcurrentoffset()
7981 
7982 
7983     def __getfield_header(self):
7984         try: self.__field_header
7985         except:
7986             self.__field_header=sanyoheader(**{'packettype': 0x0b,                   'command': 0xed})
7987         return self.__field_header.getvalue()
7988 
7989     def __setfield_header(self, value):
7990         if isinstance(value,sanyoheader):
7991             self.__field_header=value
7992         else:
7993             self.__field_header=sanyoheader(value,**{'packettype': 0x0b,                   'command': 0xed})
7994 
7995     def __delfield_header(self): del self.__field_header
7996 
7997     header=property(__getfield_header, __setfield_header, __delfield_header, None)
7998 
7999     def __getfield_slot(self):
8000         return self.__field_slot.getvalue()
8001 
8002     def __setfield_slot(self, value):
8003         if isinstance(value,UINT):
8004             self.__field_slot=value
8005         else:
8006             self.__field_slot=UINT(value,**{'sizeinbytes': 1})
8007 
8008     def __delfield_slot(self): del self.__field_slot
8009 
8010     slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None)
8011 
8012     def __getfield_pad(self):
8013         try: self.__field_pad
8014         except:
8015             self.__field_pad=UNKNOWN(**{'sizeinbytes': 501})
8016         return self.__field_pad.getvalue()
8017 
8018     def __setfield_pad(self, value):
8019         if isinstance(value,UNKNOWN):
8020             self.__field_pad=value
8021         else:
8022             self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 501})
8023 
8024     def __delfield_pad(self): del self.__field_pad
8025 
8026     pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None)
8027 
8028     def iscontainer(self):
8029         return True
8030 
8031     def containerelements(self):
8032         yield ('header', self.__field_header, None)
8033         yield ('slot', self.__field_slot, None)
8034         yield ('pad', self.__field_pad, None)
8035 
8036 
8037 
8038 
8039 class voicedialentry(BaseProtogenClass):
8040     __fields=['slot', 'flag', 'pad1', 'phonenumberslot', 'phonenumbertype']
8041 
8042     def __init__(self, *args, **kwargs):
8043         dict={}
8044         # What was supplied to this function
8045         dict.update(kwargs)
8046         # Parent constructor
8047         super(voicedialentry,self).__init__(**dict)
8048         if self.__class__ is voicedialentry:
8049             self._update(args,dict)
8050 
8051 
8052     def getfields(self):
8053         return self.__fields
8054 
8055 
8056     def _update(self, args, kwargs):
8057         super(voicedialentry,self)._update(args,kwargs)
8058         keys=kwargs.keys()
8059         for key in keys:
8060             if key in self.__fields:
8061                 setattr(self, key, kwargs[key])
8062                 del kwargs[key]
8063         # Were any unrecognized kwargs passed in?
8064         if __debug__:
8065             self._complainaboutunusedargs(voicedialentry,kwargs)
8066         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
8067         # Make all P fields that haven't already been constructed
8068 
8069 
8070     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
8071         'Writes this packet to the supplied buffer'
8072         self._bufferstartoffset=buf.getcurrentoffset()
8073         self.__field_slot.writetobuffer(buf)
8074         self.__field_flag.writetobuffer(buf)
8075         self.__field_pad1.writetobuffer(buf)
8076         self.__field_phonenumberslot.writetobuffer(buf)
8077         self.__field_phonenumbertype.writetobuffer(buf)
8078         self._bufferendoffset=buf.getcurrentoffset()
8079         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
8080 
8081 
8082     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
8083         'Reads this packet from the supplied buffer'
8084         self._bufferstartoffset=buf.getcurrentoffset()
8085         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
8086         self.__field_slot=UINT(**{'sizeinbytes': 1})
8087         self.__field_slot.readfrombuffer(buf)
8088         self.__field_flag=UINT(**{'sizeinbytes': 1})
8089         self.__field_flag.readfrombuffer(buf)
8090         self.__field_pad1=UNKNOWN(**{'sizeinbytes': 2})
8091         self.__field_pad1.readfrombuffer(buf)
8092         self.__field_phonenumberslot=UINT(**{'sizeinbytes': 2})
8093         self.__field_phonenumberslot.readfrombuffer(buf)
8094         self.__field_phonenumbertype=UINT(**{'sizeinbytes': 1})
8095         self.__field_phonenumbertype.readfrombuffer(buf)
8096         self._bufferendoffset=buf.getcurrentoffset()
8097 
8098 
8099     def __getfield_slot(self):
8100         return self.__field_slot.getvalue()
8101 
8102     def __setfield_slot(self, value):
8103         if isinstance(value,UINT):
8104             self.__field_slot=value
8105         else:
8106             self.__field_slot=UINT(value,**{'sizeinbytes': 1})
8107 
8108     def __delfield_slot(self): del self.__field_slot
8109 
8110     slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None)
8111 
8112     def __getfield_flag(self):
8113         return self.__field_flag.getvalue()
8114 
8115     def __setfield_flag(self, value):
8116         if isinstance(value,UINT):
8117             self.__field_flag=value
8118         else:
8119             self.__field_flag=UINT(value,**{'sizeinbytes': 1})
8120 
8121     def __delfield_flag(self): del self.__field_flag
8122 
8123     flag=property(__getfield_flag, __setfield_flag, __delfield_flag, "1 if voice dial slot in use")
8124 
8125     def __getfield_pad1(self):
8126         return self.__field_pad1.getvalue()
8127 
8128     def __setfield_pad1(self, value):
8129         if isinstance(value,UNKNOWN):
8130             self.__field_pad1=value
8131         else:
8132             self.__field_pad1=UNKNOWN(value,**{'sizeinbytes': 2})
8133 
8134     def __delfield_pad1(self): del self.__field_pad1
8135 
8136     pad1=property(__getfield_pad1, __setfield_pad1, __delfield_pad1, None)
8137 
8138     def __getfield_phonenumberslot(self):
8139         return self.__field_phonenumberslot.getvalue()
8140 
8141     def __setfield_phonenumberslot(self, value):
8142         if isinstance(value,UINT):
8143             self.__field_phonenumberslot=value
8144         else:
8145             self.__field_phonenumberslot=UINT(value,**{'sizeinbytes': 2})
8146 
8147     def __delfield_phonenumberslot(self): del self.__field_phonenumberslot
8148 
8149     phonenumberslot=property(__getfield_phonenumberslot, __setfield_phonenumberslot, __delfield_phonenumberslot, None)
8150 
8151     def __getfield_phonenumbertype(self):
8152         return self.__field_phonenumbertype.getvalue()
8153 
8154     def __setfield_phonenumbertype(self, value):
8155         if isinstance(value,UINT):
8156             self.__field_phonenumbertype=value
8157         else:
8158             self.__field_phonenumbertype=UINT(value,**{'sizeinbytes': 1})
8159 
8160     def __delfield_phonenumbertype(self): del self.__field_phonenumbertype
8161 
8162     phonenumbertype=property(__getfield_phonenumbertype, __setfield_phonenumbertype, __delfield_phonenumbertype, "1: Home, 2: Work, ...")
8163 
8164     def iscontainer(self):
8165         return True
8166 
8167     def containerelements(self):
8168         yield ('slot', self.__field_slot, None)
8169         yield ('flag', self.__field_flag, "1 if voice dial slot in use")
8170         yield ('pad1', self.__field_pad1, None)
8171         yield ('phonenumberslot', self.__field_phonenumberslot, None)
8172         yield ('phonenumbertype', self.__field_phonenumbertype, "1: Home, 2: Work, ...")
8173 
8174 
8175 
8176 
8177 class voicedialresponse(BaseProtogenClass):
8178     __fields=['header', 'entry', 'pad2']
8179 
8180     def __init__(self, *args, **kwargs):
8181         dict={}
8182         # What was supplied to this function
8183         dict.update(kwargs)
8184         # Parent constructor
8185         super(voicedialresponse,self).__init__(**dict)
8186         if self.__class__ is voicedialresponse:
8187             self._update(args,dict)
8188 
8189 
8190     def getfields(self):
8191         return self.__fields
8192 
8193 
8194     def _update(self, args, kwargs):
8195         super(voicedialresponse,self)._update(args,kwargs)
8196         keys=kwargs.keys()
8197         for key in keys:
8198             if key in self.__fields:
8199                 setattr(self, key, kwargs[key])
8200                 del kwargs[key]
8201         # Were any unrecognized kwargs passed in?
8202         if __debug__:
8203             self._complainaboutunusedargs(voicedialresponse,kwargs)
8204         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
8205         # Make all P fields that haven't already been constructed
8206 
8207 
8208     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
8209         'Writes this packet to the supplied buffer'
8210         self._bufferstartoffset=buf.getcurrentoffset()
8211         self.__field_header.writetobuffer(buf)
8212         self.__field_entry.writetobuffer(buf)
8213         self.__field_pad2.writetobuffer(buf)
8214         self._bufferendoffset=buf.getcurrentoffset()
8215         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
8216 
8217 
8218     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
8219         'Reads this packet from the supplied buffer'
8220         self._bufferstartoffset=buf.getcurrentoffset()
8221         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
8222         self.__field_header=sanyoheader()
8223         self.__field_header.readfrombuffer(buf)
8224         self.__field_entry=voicedialentry()
8225         self.__field_entry.readfrombuffer(buf)
8226         self.__field_pad2=UNKNOWN(**{'sizeinbytes': 495})
8227         self.__field_pad2.readfrombuffer(buf)
8228         self._bufferendoffset=buf.getcurrentoffset()
8229 
8230 
8231     def __getfield_header(self):
8232         return self.__field_header.getvalue()
8233 
8234     def __setfield_header(self, value):
8235         if isinstance(value,sanyoheader):
8236             self.__field_header=value
8237         else:
8238             self.__field_header=sanyoheader(value,)
8239 
8240     def __delfield_header(self): del self.__field_header
8241 
8242     header=property(__getfield_header, __setfield_header, __delfield_header, None)
8243 
8244     def __getfield_entry(self):
8245         return self.__field_entry.getvalue()
8246 
8247     def __setfield_entry(self, value):
8248         if isinstance(value,voicedialentry):
8249             self.__field_entry=value
8250         else:
8251             self.__field_entry=voicedialentry(value,)
8252 
8253     def __delfield_entry(self): del self.__field_entry
8254 
8255     entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None)
8256 
8257     def __getfield_pad2(self):
8258         return self.__field_pad2.getvalue()
8259 
8260     def __setfield_pad2(self, value):
8261         if isinstance(value,UNKNOWN):
8262             self.__field_pad2=value
8263         else:
8264             self.__field_pad2=UNKNOWN(value,**{'sizeinbytes': 495})
8265 
8266     def __delfield_pad2(self): del self.__field_pad2
8267 
8268     pad2=property(__getfield_pad2, __setfield_pad2, __delfield_pad2, None)
8269 
8270     def iscontainer(self):
8271         return True
8272 
8273     def containerelements(self):
8274         yield ('header', self.__field_header, None)
8275         yield ('entry', self.__field_entry, None)
8276         yield ('pad2', self.__field_pad2, None)
8277 
8278 
8279 
8280 
8281 class t9request(BaseProtogenClass):
8282     __fields=['unknown']
8283 
8284     def __init__(self, *args, **kwargs):
8285         dict={}
8286         # What was supplied to this function
8287         dict.update(kwargs)
8288         # Parent constructor
8289         super(t9request,self).__init__(**dict)
8290         if self.__class__ is t9request:
8291             self._update(args,dict)
8292 
8293 
8294     def getfields(self):
8295         return self.__fields
8296 
8297 
8298     def _update(self, args, kwargs):
8299         super(t9request,self)._update(args,kwargs)
8300         keys=kwargs.keys()
8301         for key in keys:
8302             if key in self.__fields:
8303                 setattr(self, key, kwargs[key])
8304                 del kwargs[key]
8305         # Were any unrecognized kwargs passed in?
8306         if __debug__:
8307             self._complainaboutunusedargs(t9request,kwargs)
8308         if len(args):
8309             dict2={}
8310             dict2.update(kwargs)
8311             kwargs=dict2
8312             self.__field_unknown=UNKNOWN(*args,**dict2)
8313         # Make all P fields that haven't already been constructed
8314 
8315 
8316     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
8317         'Writes this packet to the supplied buffer'
8318         self._bufferstartoffset=buf.getcurrentoffset()
8319         self.__field_unknown.writetobuffer(buf)
8320         self._bufferendoffset=buf.getcurrentoffset()
8321         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
8322 
8323 
8324     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
8325         'Reads this packet from the supplied buffer'
8326         self._bufferstartoffset=buf.getcurrentoffset()
8327         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
8328         self.__field_unknown=UNKNOWN()
8329         self.__field_unknown.readfrombuffer(buf)
8330         self._bufferendoffset=buf.getcurrentoffset()
8331 
8332 
8333     def __getfield_unknown(self):
8334         return self.__field_unknown.getvalue()
8335 
8336     def __setfield_unknown(self, value):
8337         if isinstance(value,UNKNOWN):
8338             self.__field_unknown=value
8339         else:
8340             self.__field_unknown=UNKNOWN(value,)
8341 
8342     def __delfield_unknown(self): del self.__field_unknown
8343 
8344     unknown=property(__getfield_unknown, __setfield_unknown, __delfield_unknown, None)
8345 
8346     def iscontainer(self):
8347         return True
8348 
8349     def containerelements(self):
8350         yield ('unknown', self.__field_unknown, None)
8351 
8352 
8353 
8354 
8355 class t9response(BaseProtogenClass):
8356     __fields=['unknown']
8357 
8358     def __init__(self, *args, **kwargs):
8359         dict={}
8360         # What was supplied to this function
8361         dict.update(kwargs)
8362         # Parent constructor
8363         super(t9response,self).__init__(**dict)
8364         if self.__class__ is t9response:
8365             self._update(args,dict)
8366 
8367 
8368     def getfields(self):
8369         return self.__fields
8370 
8371 
8372     def _update(self, args, kwargs):
8373         super(t9response,self)._update(args,kwargs)
8374         keys=kwargs.keys()
8375         for key in keys:
8376             if key in self.__fields:
8377                 setattr(self, key, kwargs[key])
8378                 del kwargs[key]
8379         # Were any unrecognized kwargs passed in?
8380         if __debug__:
8381             self._complainaboutunusedargs(t9response,kwargs)
8382         if len(args):
8383             dict2={}
8384             dict2.update(kwargs)
8385             kwargs=dict2
8386             self.__field_unknown=UNKNOWN(*args,**dict2)
8387         # Make all P fields that haven't already been constructed
8388 
8389 
8390     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
8391         'Writes this packet to the supplied buffer'
8392         self._bufferstartoffset=buf.getcurrentoffset()
8393         self.__field_unknown.writetobuffer(buf)
8394         self._bufferendoffset=buf.getcurrentoffset()
8395         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
8396 
8397 
8398     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
8399         'Reads this packet from the supplied buffer'
8400         self._bufferstartoffset=buf.getcurrentoffset()
8401         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
8402         self.__field_unknown=UNKNOWN()
8403         self.__field_unknown.readfrombuffer(buf)
8404         self._bufferendoffset=buf.getcurrentoffset()
8405 
8406 
8407     def __getfield_unknown(self):
8408         return self.__field_unknown.getvalue()
8409 
8410     def __setfield_unknown(self, value):
8411         if isinstance(value,UNKNOWN):
8412             self.__field_unknown=value
8413         else:
8414             self.__field_unknown=UNKNOWN(value,)
8415 
8416     def __delfield_unknown(self): del self.__field_unknown
8417 
8418     unknown=property(__getfield_unknown, __setfield_unknown, __delfield_unknown, None)
8419 
8420     def iscontainer(self):
8421         return True
8422 
8423     def containerelements(self):
8424         yield ('unknown', self.__field_unknown, None)
8425 
8426 
8427 
8428 
8429 class calleridentry(BaseProtogenClass):
8430     __fields=['pbslotandtype', 'actualnumberlen', 'numberfragment']
8431 
8432     def __init__(self, *args, **kwargs):
8433         dict={}
8434         # What was supplied to this function
8435         dict.update(kwargs)
8436         # Parent constructor
8437         super(calleridentry,self).__init__(**dict)
8438         if self.__class__ is calleridentry:
8439             self._update(args,dict)
8440 
8441 
8442     def getfields(self):
8443         return self.__fields
8444 
8445 
8446     def _update(self, args, kwargs):
8447         super(calleridentry,self)._update(args,kwargs)
8448         keys=kwargs.keys()
8449         for key in keys:
8450             if key in self.__fields:
8451                 setattr(self, key, kwargs[key])
8452                 del kwargs[key]
8453         # Were any unrecognized kwargs passed in?
8454         if __debug__:
8455             self._complainaboutunusedargs(calleridentry,kwargs)
8456         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
8457         # Make all P fields that haven't already been constructed
8458 
8459 
8460     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
8461         'Writes this packet to the supplied buffer'
8462         self._bufferstartoffset=buf.getcurrentoffset()
8463         try: self.__field_pbslotandtype
8464         except:
8465             self.__field_pbslotandtype=UINT(**{'sizeinbytes': 2, 'default': 0xffff})
8466         self.__field_pbslotandtype.writetobuffer(buf)
8467         try: self.__field_actualnumberlen
8468         except:
8469             self.__field_actualnumberlen=UINT(**{'sizeinbytes': 1, 'default': 0})
8470         self.__field_actualnumberlen.writetobuffer(buf)
8471         try: self.__field_numberfragment
8472         except:
8473             self.__field_numberfragment=USTRING(**{'sizeinbytes': 10, 'raiseonunterminatedread': False, 'raiseontruncate': False, 'default': "", 'terminator': None})
8474         self.__field_numberfragment.writetobuffer(buf)
8475         self._bufferendoffset=buf.getcurrentoffset()
8476         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
8477 
8478 
8479     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
8480         'Reads this packet from the supplied buffer'
8481         self._bufferstartoffset=buf.getcurrentoffset()
8482         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
8483         self.__field_pbslotandtype=UINT(**{'sizeinbytes': 2, 'default': 0xffff})
8484         self.__field_pbslotandtype.readfrombuffer(buf)
8485         self.__field_actualnumberlen=UINT(**{'sizeinbytes': 1, 'default': 0})
8486         self.__field_actualnumberlen.readfrombuffer(buf)
8487         self.__field_numberfragment=USTRING(**{'sizeinbytes': 10, 'raiseonunterminatedread': False, 'raiseontruncate': False, 'default': "", 'terminator': None})
8488         self.__field_numberfragment.readfrombuffer(buf)
8489         self._bufferendoffset=buf.getcurrentoffset()
8490 
8491 
8492     def __getfield_pbslotandtype(self):
8493         try: self.__field_pbslotandtype
8494         except:
8495             self.__field_pbslotandtype=UINT(**{'sizeinbytes': 2, 'default': 0xffff})
8496         return self.__field_pbslotandtype.getvalue()
8497 
8498     def __setfield_pbslotandtype(self, value):
8499         if isinstance(value,UINT):
8500             self.__field_pbslotandtype=value
8501         else:
8502             self.__field_pbslotandtype=UINT(value,**{'sizeinbytes': 2, 'default': 0xffff})
8503 
8504     def __delfield_pbslotandtype(self): del self.__field_pbslotandtype
8505 
8506     pbslotandtype=property(__getfield_pbslotandtype, __setfield_pbslotandtype, __delfield_pbslotandtype, "Low 12 bits, slotnum, top 4 bits, type")
8507 
8508     def __getfield_actualnumberlen(self):
8509         try: self.__field_actualnumberlen
8510         except:
8511             self.__field_actualnumberlen=UINT(**{'sizeinbytes': 1, 'default': 0})
8512         return self.__field_actualnumberlen.getvalue()
8513 
8514     def __setfield_actualnumberlen(self, value):
8515         if isinstance(value,UINT):
8516             self.__field_actualnumberlen=value
8517         else:
8518             self.__field_actualnumberlen=UINT(value,**{'sizeinbytes': 1, 'default': 0})
8519 
8520     def __delfield_actualnumberlen(self): del self.__field_actualnumberlen
8521 
8522     actualnumberlen=property(__getfield_actualnumberlen, __setfield_actualnumberlen, __delfield_actualnumberlen, "Length of the actual phone number")
8523 
8524     def __getfield_numberfragment(self):
8525         try: self.__field_numberfragment
8526         except:
8527             self.__field_numberfragment=USTRING(**{'sizeinbytes': 10, 'raiseonunterminatedread': False, 'raiseontruncate': False, 'default': "", 'terminator': None})
8528         return self.__field_numberfragment.getvalue()
8529 
8530     def __setfield_numberfragment(self, value):
8531         if isinstance(value,USTRING):
8532             self.__field_numberfragment=value
8533         else:
8534             self.__field_numberfragment=USTRING(value,**{'sizeinbytes': 10, 'raiseonunterminatedread': False, 'raiseontruncate': False, 'default': "", 'terminator': None})
8535 
8536     def __delfield_numberfragment(self): del self.__field_numberfragment
8537 
8538     numberfragment=property(__getfield_numberfragment, __setfield_numberfragment, __delfield_numberfragment, None)
8539 
8540     def iscontainer(self):
8541         return True
8542 
8543     def containerelements(self):
8544         yield ('pbslotandtype', self.__field_pbslotandtype, "Low 12 bits, slotnum, top 4 bits, type")
8545         yield ('actualnumberlen', self.__field_actualnumberlen, "Length of the actual phone number")
8546         yield ('numberfragment', self.__field_numberfragment, None)
8547 
8548 
8549 
8550 
8551 class calleridbuffer(BaseProtogenClass):
8552     "Index so that phone can show a name instead of number"
8553     __fields=['maxentries', 'startcommand', 'bufsize', 'comment', 'numentries', 'items', 'pad']
8554 
8555     def __init__(self, *args, **kwargs):
8556         dict={}
8557         # What was supplied to this function
8558         dict.update(kwargs)
8559         # Parent constructor
8560         super(calleridbuffer,self).__init__(**dict)
8561         if self.__class__ is calleridbuffer:
8562             self._update(args,dict)
8563 
8564 
8565     def getfields(self):
8566         return self.__fields
8567 
8568 
8569     def _update(self, args, kwargs):
8570         super(calleridbuffer,self)._update(args,kwargs)
8571         keys=kwargs.keys()
8572         for key in keys:
8573             if key in self.__fields:
8574                 setattr(self, key, kwargs[key])
8575                 del kwargs[key]
8576         # Were any unrecognized kwargs passed in?
8577         if __debug__:
8578             self._complainaboutunusedargs(calleridbuffer,kwargs)
8579         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
8580         # Make all P fields that haven't already been constructed
8581         try: self.__field_maxentries
8582         except:
8583             self.__field_maxentries=UINT(**{'constant': 500})
8584         try: self.__field_startcommand
8585         except:
8586             self.__field_startcommand=UINT(**{'constant': 0x50})
8587         try: self.__field_bufsize
8588         except:
8589             self.__field_bufsize=UINT(**{'constant': 7000})
8590         try: self.__field_comment
8591         except:
8592             self.__field_comment=USTRING(**{'default': "callerid"})
8593 
8594 
8595     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
8596         'Writes this packet to the supplied buffer'
8597         self._bufferstartoffset=buf.getcurrentoffset()
8598         self.__field_numentries.writetobuffer(buf)
8599         try: self.__field_items
8600         except:
8601             self.__field_items=LIST(**{'length': self.maxentries, 'elementclass': calleridentry, 'createdefault': True})
8602         self.__field_items.writetobuffer(buf)
8603         try: self.__field_pad
8604         except:
8605             self.__field_pad=UNKNOWN(**{'sizeinbytes': 498})
8606         self.__field_pad.writetobuffer(buf)
8607         self._bufferendoffset=buf.getcurrentoffset()
8608         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
8609 
8610 
8611     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
8612         'Reads this packet from the supplied buffer'
8613         self._bufferstartoffset=buf.getcurrentoffset()
8614         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
8615         self.__field_numentries=UINT(**{'sizeinbytes': 2})
8616         self.__field_numentries.readfrombuffer(buf)
8617         self.__field_items=LIST(**{'length': self.maxentries, 'elementclass': calleridentry, 'createdefault': True})
8618         self.__field_items.readfrombuffer(buf)
8619         self.__field_pad=UNKNOWN(**{'sizeinbytes': 498})
8620         self.__field_pad.readfrombuffer(buf)
8621         self._bufferendoffset=buf.getcurrentoffset()
8622 
8623 
8624     def __getfield_maxentries(self):
8625         return self.__field_maxentries.getvalue()
8626 
8627     def __setfield_maxentries(self, value):
8628         if isinstance(value,UINT):
8629             self.__field_maxentries=value
8630         else:
8631             self.__field_maxentries=UINT(value,**{'constant': 500})
8632 
8633     def __delfield_maxentries(self): del self.__field_maxentries
8634 
8635     maxentries=property(__getfield_maxentries, __setfield_maxentries, __delfield_maxentries, None)
8636 
8637     def __getfield_startcommand(self):
8638         return self.__field_startcommand.getvalue()
8639 
8640     def __setfield_startcommand(self, value):
8641         if isinstance(value,UINT):
8642             self.__field_startcommand=value
8643         else:
8644             self.__field_startcommand=UINT(value,**{'constant': 0x50})
8645 
8646     def __delfield_startcommand(self): del self.__field_startcommand
8647 
8648     startcommand=property(__getfield_startcommand, __setfield_startcommand, __delfield_startcommand, "Starting command for R/W buf parts")
8649 
8650     def __getfield_bufsize(self):
8651         return self.__field_bufsize.getvalue()
8652 
8653     def __setfield_bufsize(self, value):
8654         if isinstance(value,UINT):
8655             self.__field_bufsize=value
8656         else:
8657             self.__field_bufsize=UINT(value,**{'constant': 7000})
8658 
8659     def __delfield_bufsize(self): del self.__field_bufsize
8660 
8661     bufsize=property(__getfield_bufsize, __setfield_bufsize, __delfield_bufsize, None)
8662 
8663     def __getfield_comment(self):
8664         try: self.__field_comment
8665         except:
8666             self.__field_comment=USTRING(**{'default': "callerid"})
8667         return self.__field_comment.getvalue()
8668 
8669     def __setfield_comment(self, value):
8670         if isinstance(value,USTRING):
8671             self.__field_comment=value
8672         else:
8673             self.__field_comment=USTRING(value,**{'default': "callerid"})
8674 
8675     def __delfield_comment(self): del self.__field_comment
8676 
8677     comment=property(__getfield_comment, __setfield_comment, __delfield_comment, None)
8678 
8679     def __getfield_numentries(self):
8680         return self.__field_numentries.getvalue()
8681 
8682     def __setfield_numentries(self, value):
8683         if isinstance(value,UINT):
8684             self.__field_numentries=value
8685         else:
8686             self.__field_numentries=UINT(value,**{'sizeinbytes': 2})
8687 
8688     def __delfield_numentries(self): del self.__field_numentries
8689 
8690     numentries=property(__getfield_numentries, __setfield_numentries, __delfield_numentries, "Number phone numbers")
8691 
8692     def __getfield_items(self):
8693         try: self.__field_items
8694         except:
8695             self.__field_items=LIST(**{'length': self.maxentries, 'elementclass': calleridentry, 'createdefault': True})
8696         return self.__field_items.getvalue()
8697 
8698     def __setfield_items(self, value):
8699         if isinstance(value,LIST):
8700             self.__field_items=value
8701         else:
8702             self.__field_items=LIST(value,**{'length': self.maxentries, 'elementclass': calleridentry, 'createdefault': True})
8703 
8704     def __delfield_items(self): del self.__field_items
8705 
8706     items=property(__getfield_items, __setfield_items, __delfield_items, None)
8707 
8708     def __getfield_pad(self):
8709         try: self.__field_pad
8710         except:
8711             self.__field_pad=UNKNOWN(**{'sizeinbytes': 498})
8712         return self.__field_pad.getvalue()
8713 
8714     def __setfield_pad(self, value):
8715         if isinstance(value,UNKNOWN):
8716             self.__field_pad=value
8717         else:
8718             self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 498})
8719 
8720     def __delfield_pad(self): del self.__field_pad
8721 
8722     pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None)
8723 
8724     def iscontainer(self):
8725         return True
8726 
8727     def containerelements(self):
8728         yield ('maxentries', self.__field_maxentries, None)
8729         yield ('startcommand', self.__field_startcommand, "Starting command for R/W buf parts")
8730         yield ('bufsize', self.__field_bufsize, None)
8731         yield ('comment', self.__field_comment, None)
8732         yield ('numentries', self.__field_numentries, "Number phone numbers")
8733         yield ('items', self.__field_items, None)
8734         yield ('pad', self.__field_pad, None)
8735 
8736 
8737 
8738 
8739 class ringerpicbuffer(BaseProtogenClass):
8740     "Index of ringer and picture assignments"
8741     __fields=['numpbslots', 'startcommand', 'bufsize', 'comment', 'ringtones', 'wallpapers', 'pad']
8742 
8743     def __init__(self, *args, **kwargs):
8744         dict={}
8745         # What was supplied to this function
8746         dict.update(kwargs)
8747         # Parent constructor
8748         super(ringerpicbuffer,self).__init__(**dict)
8749         if self.__class__ is ringerpicbuffer:
8750             self._update(args,dict)
8751 
8752 
8753     def getfields(self):
8754         return self.__fields
8755 
8756 
8757     def _update(self, args, kwargs):
8758         super(ringerpicbuffer,self)._update(args,kwargs)
8759         keys=kwargs.keys()
8760         for key in keys:
8761             if key in self.__fields:
8762                 setattr(self, key, kwargs[key])
8763                 del kwargs[key]
8764         # Were any unrecognized kwargs passed in?
8765         if __debug__:
8766             self._complainaboutunusedargs(ringerpicbuffer,kwargs)
8767         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
8768         # Make all P fields that haven't already been constructed
8769         try: self.__field_numpbslots
8770         except:
8771             self.__field_numpbslots=UINT(**{'constant': _NUMPBSLOTS})
8772         try: self.__field_startcommand
8773         except:
8774             self.__field_startcommand=UINT(**{'constant': 0x46})
8775         try: self.__field_bufsize
8776         except:
8777             self.__field_bufsize=UINT(**{'constant': 1000})
8778         try: self.__field_comment
8779         except:
8780             self.__field_comment=USTRING(**{'default': "ringer/picture assignments"})
8781 
8782 
8783     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
8784         'Writes this packet to the supplied buffer'
8785         self._bufferstartoffset=buf.getcurrentoffset()
8786         try: self.__field_ringtones
8787         except:
8788             self.__field_ringtones=LIST(**{'elementclass': _gen_p_sanyo_506, 'length': _NUMPBSLOTS})
8789         self.__field_ringtones.writetobuffer(buf)
8790         try: self.__field_wallpapers
8791         except:
8792             self.__field_wallpapers=LIST(**{'elementclass': _gen_p_sanyo_508, 'length': _NUMPBSLOTS})
8793         self.__field_wallpapers.writetobuffer(buf)
8794         try: self.__field_pad
8795         except:
8796             self.__field_pad=UNKNOWN(**{'sizeinbytes': 400})
8797         self.__field_pad.writetobuffer(buf)
8798         self._bufferendoffset=buf.getcurrentoffset()
8799         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
8800 
8801 
8802     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
8803         'Reads this packet from the supplied buffer'
8804         self._bufferstartoffset=buf.getcurrentoffset()
8805         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
8806         self.__field_ringtones=LIST(**{'elementclass': _gen_p_sanyo_506, 'length': _NUMPBSLOTS})
8807         self.__field_ringtones.readfrombuffer(buf)
8808         self.__field_wallpapers=LIST(**{'elementclass': _gen_p_sanyo_508, 'length': _NUMPBSLOTS})
8809         self.__field_wallpapers.readfrombuffer(buf)
8810         self.__field_pad=UNKNOWN(**{'sizeinbytes': 400})
8811         self.__field_pad.readfrombuffer(buf)
8812         self._bufferendoffset=buf.getcurrentoffset()
8813 
8814 
8815     def __getfield_numpbslots(self):
8816         return self.__field_numpbslots.getvalue()
8817 
8818     def __setfield_numpbslots(self, value):
8819         if isinstance(value,UINT):
8820             self.__field_numpbslots=value
8821         else:
8822             self.__field_numpbslots=UINT(value,**{'constant': _NUMPBSLOTS})
8823 
8824     def __delfield_numpbslots(self): del self.__field_numpbslots
8825 
8826     numpbslots=property(__getfield_numpbslots, __setfield_numpbslots, __delfield_numpbslots, "Number of phone book slots")
8827 
8828     def __getfield_startcommand(self):
8829         return self.__field_startcommand.getvalue()
8830 
8831     def __setfield_startcommand(self, value):
8832         if isinstance(value,UINT):
8833             self.__field_startcommand=value
8834         else:
8835             self.__field_startcommand=UINT(value,**{'constant': 0x46})
8836 
8837     def __delfield_startcommand(self): del self.__field_startcommand
8838 
8839     startcommand=property(__getfield_startcommand, __setfield_startcommand, __delfield_startcommand, "Starting command for R/W buf parts")
8840 
8841     def __getfield_bufsize(self):
8842         return self.__field_bufsize.getvalue()
8843 
8844     def __setfield_bufsize(self, value):
8845         if isinstance(value,UINT):
8846             self.__field_bufsize=value
8847         else:
8848             self.__field_bufsize=UINT(value,**{'constant': 1000})
8849 
8850     def __delfield_bufsize(self): del self.__field_bufsize
8851 
8852     bufsize=property(__getfield_bufsize, __setfield_bufsize, __delfield_bufsize, None)
8853 
8854     def __getfield_comment(self):
8855         try: self.__field_comment
8856         except:
8857             self.__field_comment=USTRING(**{'default': "ringer/picture assignments"})
8858         return self.__field_comment.getvalue()
8859 
8860     def __setfield_comment(self, value):
8861         if isinstance(value,USTRING):
8862             self.__field_comment=value
8863         else:
8864             self.__field_comment=USTRING(value,**{'default': "ringer/picture assignments"})
8865 
8866     def __delfield_comment(self): del self.__field_comment
8867 
8868     comment=property(__getfield_comment, __setfield_comment, __delfield_comment, None)
8869 
8870     def __getfield_ringtones(self):
8871         try: self.__field_ringtones
8872         except:
8873             self.__field_ringtones=LIST(**{'elementclass': _gen_p_sanyo_506, 'length': _NUMPBSLOTS})
8874         return self.__field_ringtones.getvalue()
8875 
8876     def __setfield_ringtones(self, value):
8877         if isinstance(value,LIST):
8878             self.__field_ringtones=value
8879         else:
8880             self.__field_ringtones=LIST(value,**{'elementclass': _gen_p_sanyo_506, 'length': _NUMPBSLOTS})
8881 
8882     def __delfield_ringtones(self): del self.__field_ringtones
8883 
8884     ringtones=property(__getfield_ringtones, __setfield_ringtones, __delfield_ringtones, None)
8885 
8886     def __getfield_wallpapers(self):
8887         try: self.__field_wallpapers
8888         except:
8889             self.__field_wallpapers=LIST(**{'elementclass': _gen_p_sanyo_508, 'length': _NUMPBSLOTS})
8890         return self.__field_wallpapers.getvalue()
8891 
8892     def __setfield_wallpapers(self, value):
8893         if isinstance(value,LIST):
8894             self.__field_wallpapers=value
8895         else:
8896             self.__field_wallpapers=LIST(value,**{'elementclass': _gen_p_sanyo_508, 'length': _NUMPBSLOTS})
8897 
8898     def __delfield_wallpapers(self): del self.__field_wallpapers
8899 
8900     wallpapers=property(__getfield_wallpapers, __setfield_wallpapers, __delfield_wallpapers, None)
8901 
8902     def __getfield_pad(self):
8903         try: self.__field_pad
8904         except:
8905             self.__field_pad=UNKNOWN(**{'sizeinbytes': 400})
8906         return self.__field_pad.getvalue()
8907 
8908     def __setfield_pad(self, value):
8909         if isinstance(value,UNKNOWN):
8910             self.__field_pad=value
8911         else:
8912             self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 400})
8913 
8914     def __delfield_pad(self): del self.__field_pad
8915 
8916     pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None)
8917 
8918     def iscontainer(self):
8919         return True
8920 
8921     def containerelements(self):
8922         yield ('numpbslots', self.__field_numpbslots, "Number of phone book slots")
8923         yield ('startcommand', self.__field_startcommand, "Starting command for R/W buf parts")
8924         yield ('bufsize', self.__field_bufsize, None)
8925         yield ('comment', self.__field_comment, None)
8926         yield ('ringtones', self.__field_ringtones, None)
8927         yield ('wallpapers', self.__field_wallpapers, None)
8928         yield ('pad', self.__field_pad, None)
8929 
8930 
8931 
8932 
8933 class _gen_p_sanyo_506(BaseProtogenClass):
8934     'Anonymous inner class'
8935     __fields=['ringtone']
8936 
8937     def __init__(self, *args, **kwargs):
8938         dict={}
8939         # What was supplied to this function
8940         dict.update(kwargs)
8941         # Parent constructor
8942         super(_gen_p_sanyo_506,self).__init__(**dict)
8943         if self.__class__ is _gen_p_sanyo_506:
8944             self._update(args,dict)
8945 
8946 
8947     def getfields(self):
8948         return self.__fields
8949 
8950 
8951     def _update(self, args, kwargs):
8952         super(_gen_p_sanyo_506,self)._update(args,kwargs)
8953         keys=kwargs.keys()
8954         for key in keys:
8955             if key in self.__fields:
8956                 setattr(self, key, kwargs[key])
8957                 del kwargs[key]
8958         # Were any unrecognized kwargs passed in?
8959         if __debug__:
8960             self._complainaboutunusedargs(_gen_p_sanyo_506,kwargs)
8961         if len(args):
8962             dict2={'sizeinbytes': 1}
8963             dict2.update(kwargs)
8964             kwargs=dict2
8965             self.__field_ringtone=UINT(*args,**dict2)
8966         # Make all P fields that haven't already been constructed
8967 
8968 
8969     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
8970         'Writes this packet to the supplied buffer'
8971         self._bufferstartoffset=buf.getcurrentoffset()
8972         self.__field_ringtone.writetobuffer(buf)
8973         self._bufferendoffset=buf.getcurrentoffset()
8974         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
8975 
8976 
8977     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
8978         'Reads this packet from the supplied buffer'
8979         self._bufferstartoffset=buf.getcurrentoffset()
8980         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
8981         self.__field_ringtone=UINT(**{'sizeinbytes': 1})
8982         self.__field_ringtone.readfrombuffer(buf)
8983         self._bufferendoffset=buf.getcurrentoffset()
8984 
8985 
8986     def __getfield_ringtone(self):
8987         return self.__field_ringtone.getvalue()
8988 
8989     def __setfield_ringtone(self, value):
8990         if isinstance(value,UINT):
8991             self.__field_ringtone=value
8992         else:
8993             self.__field_ringtone=UINT(value,**{'sizeinbytes': 1})
8994 
8995     def __delfield_ringtone(self): del self.__field_ringtone
8996 
8997     ringtone=property(__getfield_ringtone, __setfield_ringtone, __delfield_ringtone, "ringtone index")
8998 
8999     def iscontainer(self):
9000         return True
9001 
9002     def containerelements(self):
9003         yield ('ringtone', self.__field_ringtone, "ringtone index")
9004 
9005 
9006 
9007 
9008 class _gen_p_sanyo_508(BaseProtogenClass):
9009     'Anonymous inner class'
9010     __fields=['wallpaper']
9011 
9012     def __init__(self, *args, **kwargs):
9013         dict={}
9014         # What was supplied to this function
9015         dict.update(kwargs)
9016         # Parent constructor
9017         super(_gen_p_sanyo_508,self).__init__(**dict)
9018         if self.__class__ is _gen_p_sanyo_508:
9019             self._update(args,dict)
9020 
9021 
9022     def getfields(self):
9023         return self.__fields
9024 
9025 
9026     def _update(self, args, kwargs):
9027         super(_gen_p_sanyo_508,self)._update(args,kwargs)
9028         keys=kwargs.keys()
9029         for key in keys:
9030             if key in self.__fields:
9031                 setattr(self, key, kwargs[key])
9032                 del kwargs[key]
9033         # Were any unrecognized kwargs passed in?
9034         if __debug__:
9035             self._complainaboutunusedargs(_gen_p_sanyo_508,kwargs)
9036         if len(args):
9037             dict2={'sizeinbytes': 1}
9038             dict2.update(kwargs)
9039             kwargs=dict2
9040             self.__field_wallpaper=UINT(*args,**dict2)
9041         # Make all P fields that haven't already been constructed
9042 
9043 
9044     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
9045         'Writes this packet to the supplied buffer'
9046         self._bufferstartoffset=buf.getcurrentoffset()
9047         self.__field_wallpaper.writetobuffer(buf)
9048         self._bufferendoffset=buf.getcurrentoffset()
9049         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
9050 
9051 
9052     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
9053         'Reads this packet from the supplied buffer'
9054         self._bufferstartoffset=buf.getcurrentoffset()
9055         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
9056         self.__field_wallpaper=UINT(**{'sizeinbytes': 1})
9057         self.__field_wallpaper.readfrombuffer(buf)
9058         self._bufferendoffset=buf.getcurrentoffset()
9059 
9060 
9061     def __getfield_wallpaper(self):
9062         return self.__field_wallpaper.getvalue()
9063 
9064     def __setfield_wallpaper(self, value):
9065         if isinstance(value,UINT):
9066             self.__field_wallpaper=value
9067         else:
9068             self.__field_wallpaper=UINT(value,**{'sizeinbytes': 1})
9069 
9070     def __delfield_wallpaper(self): del self.__field_wallpaper
9071 
9072     wallpaper=property(__getfield_wallpaper, __setfield_wallpaper, __delfield_wallpaper, "wallpaper index")
9073 
9074     def iscontainer(self):
9075         return True
9076 
9077     def containerelements(self):
9078         yield ('wallpaper', self.__field_wallpaper, "wallpaper index")
9079 
9080 
9081 
9082 
9083 class wallpaperbuffer(BaseProtogenClass):
9084     "Addition buffer of wallpaper assignment info"
9085     __fields=['numpbslots', 'startcommand', 'bufsize', 'comment', 'wallpapers']
9086 
9087     def __init__(self, *args, **kwargs):
9088         dict={}
9089         # What was supplied to this function
9090         dict.update(kwargs)
9091         # Parent constructor
9092         super(wallpaperbuffer,self).__init__(**dict)
9093         if self.__class__ is wallpaperbuffer:
9094             self._update(args,dict)
9095 
9096 
9097     def getfields(self):
9098         return self.__fields
9099 
9100 
9101     def _update(self, args, kwargs):
9102         super(wallpaperbuffer,self)._update(args,kwargs)
9103         keys=kwargs.keys()
9104         for key in keys:
9105             if key in self.__fields:
9106                 setattr(self, key, kwargs[key])
9107                 del kwargs[key]
9108         # Were any unrecognized kwargs passed in?
9109         if __debug__:
9110             self._complainaboutunusedargs(wallpaperbuffer,kwargs)
9111         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
9112         # Make all P fields that haven't already been constructed
9113         try: self.__field_numpbslots
9114         except:
9115             self.__field_numpbslots=UINT(**{'constant': _NUMPBSLOTS})
9116         try: self.__field_startcommand
9117         except:
9118             self.__field_startcommand=UINT(**{'constant': 0x69})
9119         try: self.__field_bufsize
9120         except:
9121             self.__field_bufsize=UINT(**{'constant': 1500})
9122         try: self.__field_comment
9123         except:
9124             self.__field_comment=USTRING(**{'default': "wallpaper assignment info"})
9125 
9126 
9127     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
9128         'Writes this packet to the supplied buffer'
9129         self._bufferstartoffset=buf.getcurrentoffset()
9130         try: self.__field_wallpapers
9131         except:
9132             self.__field_wallpapers=LIST(**{'length': _NUMPBSLOTS, 'elementclass': wallpaperinfo})
9133         self.__field_wallpapers.writetobuffer(buf)
9134         self._bufferendoffset=buf.getcurrentoffset()
9135         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
9136 
9137 
9138     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
9139         'Reads this packet from the supplied buffer'
9140         self._bufferstartoffset=buf.getcurrentoffset()
9141         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
9142         self.__field_wallpapers=LIST(**{'length': _NUMPBSLOTS, 'elementclass': wallpaperinfo})
9143         self.__field_wallpapers.readfrombuffer(buf)
9144         self._bufferendoffset=buf.getcurrentoffset()
9145 
9146 
9147     def __getfield_numpbslots(self):
9148         return self.__field_numpbslots.getvalue()
9149 
9150     def __setfield_numpbslots(self, value):
9151         if isinstance(value,UINT):
9152             self.__field_numpbslots=value
9153         else:
9154             self.__field_numpbslots=UINT(value,**{'constant': _NUMPBSLOTS})
9155 
9156     def __delfield_numpbslots(self): del self.__field_numpbslots
9157 
9158     numpbslots=property(__getfield_numpbslots, __setfield_numpbslots, __delfield_numpbslots, "Number of phone book slots")
9159 
9160     def __getfield_startcommand(self):
9161         return self.__field_startcommand.getvalue()
9162 
9163     def __setfield_startcommand(self, value):
9164         if isinstance(value,UINT):
9165             self.__field_startcommand=value
9166         else:
9167             self.__field_startcommand=UINT(value,**{'constant': 0x69})
9168 
9169     def __delfield_startcommand(self): del self.__field_startcommand
9170 
9171     startcommand=property(__getfield_startcommand, __setfield_startcommand, __delfield_startcommand, "Starting command for R/W buf parts")
9172 
9173     def __getfield_bufsize(self):
9174         return self.__field_bufsize.getvalue()
9175 
9176     def __setfield_bufsize(self, value):
9177         if isinstance(value,UINT):
9178             self.__field_bufsize=value
9179         else:
9180             self.__field_bufsize=UINT(value,**{'constant': 1500})
9181 
9182     def __delfield_bufsize(self): del self.__field_bufsize
9183 
9184     bufsize=property(__getfield_bufsize, __setfield_bufsize, __delfield_bufsize, None)
9185 
9186     def __getfield_comment(self):
9187         try: self.__field_comment
9188         except:
9189             self.__field_comment=USTRING(**{'default': "wallpaper assignment info"})
9190         return self.__field_comment.getvalue()
9191 
9192     def __setfield_comment(self, value):
9193         if isinstance(value,USTRING):
9194             self.__field_comment=value
9195         else:
9196             self.__field_comment=USTRING(value,**{'default': "wallpaper assignment info"})
9197 
9198     def __delfield_comment(self): del self.__field_comment
9199 
9200     comment=property(__getfield_comment, __setfield_comment, __delfield_comment, None)
9201 
9202     def __getfield_wallpapers(self):
9203         try: self.__field_wallpapers
9204         except:
9205             self.__field_wallpapers=LIST(**{'length': _NUMPBSLOTS, 'elementclass': wallpaperinfo})
9206         return self.__field_wallpapers.getvalue()
9207 
9208     def __setfield_wallpapers(self, value):
9209         if isinstance(value,LIST):
9210             self.__field_wallpapers=value
9211         else:
9212             self.__field_wallpapers=LIST(value,**{'length': _NUMPBSLOTS, 'elementclass': wallpaperinfo})
9213 
9214     def __delfield_wallpapers(self): del self.__field_wallpapers
9215 
9216     wallpapers=property(__getfield_wallpapers, __setfield_wallpapers, __delfield_wallpapers, None)
9217 
9218     def iscontainer(self):
9219         return True
9220 
9221     def containerelements(self):
9222         yield ('numpbslots', self.__field_numpbslots, "Number of phone book slots")
9223         yield ('startcommand', self.__field_startcommand, "Starting command for R/W buf parts")
9224         yield ('bufsize', self.__field_bufsize, None)
9225         yield ('comment', self.__field_comment, None)
9226         yield ('wallpapers', self.__field_wallpapers, None)
9227 
9228 
9229 
9230 
9231 class wallpaperinfo(BaseProtogenClass):
9232     "5 byte structure with info about wallpaper assignments"
9233     __fields=['flag', 'word1', 'word2']
9234 
9235     def __init__(self, *args, **kwargs):
9236         dict={}
9237         # What was supplied to this function
9238         dict.update(kwargs)
9239         # Parent constructor
9240         super(wallpaperinfo,self).__init__(**dict)
9241         if self.__class__ is wallpaperinfo:
9242             self._update(args,dict)
9243 
9244 
9245     def getfields(self):
9246         return self.__fields
9247 
9248 
9249     def _update(self, args, kwargs):
9250         super(wallpaperinfo,self)._update(args,kwargs)
9251         keys=kwargs.keys()
9252         for key in keys:
9253             if key in self.__fields:
9254                 setattr(self, key, kwargs[key])
9255                 del kwargs[key]
9256         # Were any unrecognized kwargs passed in?
9257         if __debug__:
9258             self._complainaboutunusedargs(wallpaperinfo,kwargs)
9259         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
9260         # Make all P fields that haven't already been constructed
9261 
9262 
9263     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
9264         'Writes this packet to the supplied buffer'
9265         self._bufferstartoffset=buf.getcurrentoffset()
9266         self.__field_flag.writetobuffer(buf)
9267         self.__field_word1.writetobuffer(buf)
9268         self.__field_word2.writetobuffer(buf)
9269         self._bufferendoffset=buf.getcurrentoffset()
9270         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
9271 
9272 
9273     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
9274         'Reads this packet from the supplied buffer'
9275         self._bufferstartoffset=buf.getcurrentoffset()
9276         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
9277         self.__field_flag=UINT(**{'sizeinbytes': 1})
9278         self.__field_flag.readfrombuffer(buf)
9279         self.__field_word1=UINT(**{'sizeinbytes': 2})
9280         self.__field_word1.readfrombuffer(buf)
9281         self.__field_word2=UINT(**{'sizeinbytes': 2})
9282         self.__field_word2.readfrombuffer(buf)
9283         self._bufferendoffset=buf.getcurrentoffset()
9284 
9285 
9286     def __getfield_flag(self):
9287         return self.__field_flag.getvalue()
9288 
9289     def __setfield_flag(self, value):
9290         if isinstance(value,UINT):
9291             self.__field_flag=value
9292         else:
9293             self.__field_flag=UINT(value,**{'sizeinbytes': 1})
9294 
9295     def __delfield_flag(self): del self.__field_flag
9296 
9297     flag=property(__getfield_flag, __setfield_flag, __delfield_flag, None)
9298 
9299     def __getfield_word1(self):
9300         return self.__field_word1.getvalue()
9301 
9302     def __setfield_word1(self, value):
9303         if isinstance(value,UINT):
9304             self.__field_word1=value
9305         else:
9306             self.__field_word1=UINT(value,**{'sizeinbytes': 2})
9307 
9308     def __delfield_word1(self): del self.__field_word1
9309 
9310     word1=property(__getfield_word1, __setfield_word1, __delfield_word1, None)
9311 
9312     def __getfield_word2(self):
9313         return self.__field_word2.getvalue()
9314 
9315     def __setfield_word2(self, value):
9316         if isinstance(value,UINT):
9317             self.__field_word2=value
9318         else:
9319             self.__field_word2=UINT(value,**{'sizeinbytes': 2})
9320 
9321     def __delfield_word2(self): del self.__field_word2
9322 
9323     word2=property(__getfield_word2, __setfield_word2, __delfield_word2, None)
9324 
9325     def iscontainer(self):
9326         return True
9327 
9328     def containerelements(self):
9329         yield ('flag', self.__field_flag, None)
9330         yield ('word1', self.__field_word1, None)
9331         yield ('word2', self.__field_word2, None)
9332 
9333 
9334 
9335 
9336 class pbsortbuffer(BaseProtogenClass):
9337     "Various arrays for sorting the phone book, speed dial, determining which"
9338     __fields=['startcommand', 'bufsize', 'comment', 'usedflags', 'slotsused', 'slotsused2', 'numemail', 'numurl', 'firsttypes', 'sortorder', 'pbfirstletters', 'sortorder2', 'speeddialindex', 'longnumbersindex', 'emails', 'emailfirstletters', 'urls', 'urlfirstletters', 'pad']
9339 
9340     def __init__(self, *args, **kwargs):
9341         dict={}
9342         # What was supplied to this function
9343         dict.update(kwargs)
9344         # Parent constructor
9345         super(pbsortbuffer,self).__init__(**dict)
9346         if self.__class__ is pbsortbuffer:
9347             self._update(args,dict)
9348 
9349 
9350     def getfields(self):
9351         return self.__fields
9352 
9353 
9354     def _update(self, args, kwargs):
9355         super(pbsortbuffer,self)._update(args,kwargs)
9356         keys=kwargs.keys()
9357         for key in keys:
9358             if key in self.__fields:
9359                 setattr(self, key, kwargs[key])
9360                 del kwargs[key]
9361         # Were any unrecognized kwargs passed in?
9362         if __debug__:
9363             self._complainaboutunusedargs(pbsortbuffer,kwargs)
9364         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
9365         # Make all P fields that haven't already been constructed
9366         try: self.__field_startcommand
9367         except:
9368             self.__field_startcommand=UINT(**{'constant': 0x3c})
9369         try: self.__field_bufsize
9370         except:
9371             self.__field_bufsize=UINT(**{'constant': 4000})
9372         try: self.__field_comment
9373         except:
9374             self.__field_comment=USTRING(**{'default': "sort buffer"})
9375 
9376 
9377     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
9378         'Writes this packet to the supplied buffer'
9379         self._bufferstartoffset=buf.getcurrentoffset()
9380         try: self.__field_usedflags
9381         except:
9382             self.__field_usedflags=LIST(**{'elementclass': _gen_p_sanyo_535, 'length': _NUMPBSLOTS, 'createdefault': True})
9383         self.__field_usedflags.writetobuffer(buf)
9384         self.__field_slotsused.writetobuffer(buf)
9385         self.__field_slotsused2.writetobuffer(buf)
9386         self.__field_numemail.writetobuffer(buf)
9387         self.__field_numurl.writetobuffer(buf)
9388         try: self.__field_firsttypes
9389         except:
9390             self.__field_firsttypes=LIST(**{'elementclass': _gen_p_sanyo_541, 'length': _NUMPBSLOTS})
9391         self.__field_firsttypes.writetobuffer(buf)
9392         try: self.__field_sortorder
9393         except:
9394             self.__field_sortorder=LIST(**{'elementclass': _gen_p_sanyo_543, 'length': _NUMPBSLOTS})
9395         self.__field_sortorder.writetobuffer(buf)
9396         self.__field_pbfirstletters.writetobuffer(buf)
9397         try: self.__field_sortorder2
9398         except:
9399             self.__field_sortorder2=LIST(**{'elementclass': _gen_p_sanyo_546, 'length': _NUMPBSLOTS})
9400         self.__field_sortorder2.writetobuffer(buf)
9401         try: self.__field_speeddialindex
9402         except:
9403             self.__field_speeddialindex=LIST(**{'elementclass': _gen_p_sanyo_548, 'length': _NUMSPEEDDIALS})
9404         self.__field_speeddialindex.writetobuffer(buf)
9405         try: self.__field_longnumbersindex
9406         except:
9407             self.__field_longnumbersindex=LIST(**{'elementclass': _gen_p_sanyo_550, 'length': _NUMLONGNUMBERS})
9408         self.__field_longnumbersindex.writetobuffer(buf)
9409         try: self.__field_emails
9410         except:
9411             self.__field_emails=LIST(**{'elementclass': _gen_p_sanyo_552, 'length': _NUMPBSLOTS})
9412         self.__field_emails.writetobuffer(buf)
9413         self.__field_emailfirstletters.writetobuffer(buf)
9414         try: self.__field_urls
9415         except:
9416             self.__field_urls=LIST(**{'elementclass': _gen_p_sanyo_555, 'length': _NUMPBSLOTS})
9417         self.__field_urls.writetobuffer(buf)
9418         self.__field_urlfirstletters.writetobuffer(buf)
9419         try: self.__field_pad
9420         except:
9421             self.__field_pad=UNKNOWN(**{'sizeinbytes': 66})
9422         self.__field_pad.writetobuffer(buf)
9423         self._bufferendoffset=buf.getcurrentoffset()
9424         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
9425 
9426 
9427     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
9428         'Reads this packet from the supplied buffer'
9429         self._bufferstartoffset=buf.getcurrentoffset()
9430         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
9431         self.__field_usedflags=LIST(**{'elementclass': _gen_p_sanyo_535, 'length': _NUMPBSLOTS, 'createdefault': True})
9432         self.__field_usedflags.readfrombuffer(buf)
9433         self.__field_slotsused=UINT(**{'sizeinbytes': 2})
9434         self.__field_slotsused.readfrombuffer(buf)
9435         self.__field_slotsused2=UINT(**{'sizeinbytes': 2})
9436         self.__field_slotsused2.readfrombuffer(buf)
9437         self.__field_numemail=UINT(**{'sizeinbytes': 2})
9438         self.__field_numemail.readfrombuffer(buf)
9439         self.__field_numurl=UINT(**{'sizeinbytes': 2})
9440         self.__field_numurl.readfrombuffer(buf)
9441         self.__field_firsttypes=LIST(**{'elementclass': _gen_p_sanyo_541, 'length': _NUMPBSLOTS})
9442         self.__field_firsttypes.readfrombuffer(buf)
9443         self.__field_sortorder=LIST(**{'elementclass': _gen_p_sanyo_543, 'length': _NUMPBSLOTS})
9444         self.__field_sortorder.readfrombuffer(buf)
9445         self.__field_pbfirstletters=USTRING(**{'terminator': None, 'sizeinbytes': _NUMPBSLOTS})
9446         self.__field_pbfirstletters.readfrombuffer(buf)
9447         self.__field_sortorder2=LIST(**{'elementclass': _gen_p_sanyo_546, 'length': _NUMPBSLOTS})
9448         self.__field_sortorder2.readfrombuffer(buf)
9449         self.__field_speeddialindex=LIST(**{'elementclass': _gen_p_sanyo_548, 'length': _NUMSPEEDDIALS})
9450         self.__field_speeddialindex.readfrombuffer(buf)
9451         self.__field_longnumbersindex=LIST(**{'elementclass': _gen_p_sanyo_550, 'length': _NUMLONGNUMBERS})
9452         self.__field_longnumbersindex.readfrombuffer(buf)
9453         self.__field_emails=LIST(**{'elementclass': _gen_p_sanyo_552, 'length': _NUMPBSLOTS})
9454         self.__field_emails.readfrombuffer(buf)
9455         self.__field_emailfirstletters=USTRING(**{'terminator': None, 'sizeinbytes': _NUMPBSLOTS})
9456         self.__field_emailfirstletters.readfrombuffer(buf)
9457         self.__field_urls=LIST(**{'elementclass': _gen_p_sanyo_555, 'length': _NUMPBSLOTS})
9458         self.__field_urls.readfrombuffer(buf)
9459         self.__field_urlfirstletters=USTRING(**{'terminator': None, 'sizeinbytes': _NUMPBSLOTS})
9460         self.__field_urlfirstletters.readfrombuffer(buf)
9461         self.__field_pad=UNKNOWN(**{'sizeinbytes': 66})
9462         self.__field_pad.readfrombuffer(buf)
9463         self._bufferendoffset=buf.getcurrentoffset()
9464 
9465 
9466     def __getfield_startcommand(self):
9467         return self.__field_startcommand.getvalue()
9468 
9469     def __setfield_startcommand(self, value):
9470         if isinstance(value,UINT):
9471             self.__field_startcommand=value
9472         else:
9473             self.__field_startcommand=UINT(value,**{'constant': 0x3c})
9474 
9475     def __delfield_startcommand(self): del self.__field_startcommand
9476 
9477     startcommand=property(__getfield_startcommand, __setfield_startcommand, __delfield_startcommand, "Starting command for R/W buf parts")
9478 
9479     def __getfield_bufsize(self):
9480         return self.__field_bufsize.getvalue()
9481 
9482     def __setfield_bufsize(self, value):
9483         if isinstance(value,UINT):
9484             self.__field_bufsize=value
9485         else:
9486             self.__field_bufsize=UINT(value,**{'constant': 4000})
9487 
9488     def __delfield_bufsize(self): del self.__field_bufsize
9489 
9490     bufsize=property(__getfield_bufsize, __setfield_bufsize, __delfield_bufsize, None)
9491 
9492     def __getfield_comment(self):
9493         try: self.__field_comment
9494         except:
9495             self.__field_comment=USTRING(**{'default': "sort buffer"})
9496         return self.__field_comment.getvalue()
9497 
9498     def __setfield_comment(self, value):
9499         if isinstance(value,USTRING):
9500             self.__field_comment=value
9501         else:
9502             self.__field_comment=USTRING(value,**{'default': "sort buffer"})
9503 
9504     def __delfield_comment(self): del self.__field_comment
9505 
9506     comment=property(__getfield_comment, __setfield_comment, __delfield_comment, None)
9507 
9508     def __getfield_usedflags(self):
9509         try: self.__field_usedflags
9510         except:
9511             self.__field_usedflags=LIST(**{'elementclass': _gen_p_sanyo_535, 'length': _NUMPBSLOTS, 'createdefault': True})
9512         return self.__field_usedflags.getvalue()
9513 
9514     def __setfield_usedflags(self, value):
9515         if isinstance(value,LIST):
9516             self.__field_usedflags=value
9517         else:
9518             self.__field_usedflags=LIST(value,**{'elementclass': _gen_p_sanyo_535, 'length': _NUMPBSLOTS, 'createdefault': True})
9519 
9520     def __delfield_usedflags(self): del self.__field_usedflags
9521 
9522     usedflags=property(__getfield_usedflags, __setfield_usedflags, __delfield_usedflags, None)
9523 
9524     def __getfield_slotsused(self):
9525         return self.__field_slotsused.getvalue()
9526 
9527     def __setfield_slotsused(self, value):
9528         if isinstance(value,UINT):
9529             self.__field_slotsused=value
9530         else:
9531             self.__field_slotsused=UINT(value,**{'sizeinbytes': 2})
9532 
9533     def __delfield_slotsused(self): del self.__field_slotsused
9534 
9535     slotsused=property(__getfield_slotsused, __setfield_slotsused, __delfield_slotsused, None)
9536 
9537     def __getfield_slotsused2(self):
9538         return self.__field_slotsused2.getvalue()
9539 
9540     def __setfield_slotsused2(self, value):
9541         if isinstance(value,UINT):
9542             self.__field_slotsused2=value
9543         else:
9544             self.__field_slotsused2=UINT(value,**{'sizeinbytes': 2})
9545 
9546     def __delfield_slotsused2(self): del self.__field_slotsused2
9547 
9548     slotsused2=property(__getfield_slotsused2, __setfield_slotsused2, __delfield_slotsused2, "# slots containing a phone number")
9549 
9550     def __getfield_numemail(self):
9551         return self.__field_numemail.getvalue()
9552 
9553     def __setfield_numemail(self, value):
9554         if isinstance(value,UINT):
9555             self.__field_numemail=value
9556         else:
9557             self.__field_numemail=UINT(value,**{'sizeinbytes': 2})
9558 
9559     def __delfield_numemail(self): del self.__field_numemail
9560 
9561     numemail=property(__getfield_numemail, __setfield_numemail, __delfield_numemail, "Num of slots with email")
9562 
9563     def __getfield_numurl(self):
9564         return self.__field_numurl.getvalue()
9565 
9566     def __setfield_numurl(self, value):
9567         if isinstance(value,UINT):
9568             self.__field_numurl=value
9569         else:
9570             self.__field_numurl=UINT(value,**{'sizeinbytes': 2})
9571 
9572     def __delfield_numurl(self): del self.__field_numurl
9573 
9574     numurl=property(__getfield_numurl, __setfield_numurl, __delfield_numurl, "Num of slots with URL")
9575 
9576     def __getfield_firsttypes(self):
9577         try: self.__field_firsttypes
9578         except:
9579             self.__field_firsttypes=LIST(**{'elementclass': _gen_p_sanyo_541, 'length': _NUMPBSLOTS})
9580         return self.__field_firsttypes.getvalue()
9581 
9582     def __setfield_firsttypes(self, value):
9583         if isinstance(value,LIST):
9584             self.__field_firsttypes=value
9585         else:
9586             self.__field_firsttypes=LIST(value,**{'elementclass': _gen_p_sanyo_541, 'length': _NUMPBSLOTS})
9587 
9588     def __delfield_firsttypes(self): del self.__field_firsttypes
9589 
9590     firsttypes=property(__getfield_firsttypes, __setfield_firsttypes, __delfield_firsttypes, None)
9591 
9592     def __getfield_sortorder(self):
9593         try: self.__field_sortorder
9594         except:
9595             self.__field_sortorder=LIST(**{'elementclass': _gen_p_sanyo_543, 'length': _NUMPBSLOTS})
9596         return self.__field_sortorder.getvalue()
9597 
9598     def __setfield_sortorder(self, value):
9599         if isinstance(value,LIST):
9600             self.__field_sortorder=value
9601         else:
9602             self.__field_sortorder=LIST(value,**{'elementclass': _gen_p_sanyo_543, 'length': _NUMPBSLOTS})
9603 
9604     def __delfield_sortorder(self): del self.__field_sortorder
9605 
9606     sortorder=property(__getfield_sortorder, __setfield_sortorder, __delfield_sortorder, None)
9607 
9608     def __getfield_pbfirstletters(self):
9609         return self.__field_pbfirstletters.getvalue()
9610 
9611     def __setfield_pbfirstletters(self, value):
9612         if isinstance(value,USTRING):
9613             self.__field_pbfirstletters=value
9614         else:
9615             self.__field_pbfirstletters=USTRING(value,**{'terminator': None, 'sizeinbytes': _NUMPBSLOTS})
9616 
9617     def __delfield_pbfirstletters(self): del self.__field_pbfirstletters
9618 
9619     pbfirstletters=property(__getfield_pbfirstletters, __setfield_pbfirstletters, __delfield_pbfirstletters, None)
9620 
9621     def __getfield_sortorder2(self):
9622         try: self.__field_sortorder2
9623         except:
9624             self.__field_sortorder2=LIST(**{'elementclass': _gen_p_sanyo_546, 'length': _NUMPBSLOTS})
9625         return self.__field_sortorder2.getvalue()
9626 
9627     def __setfield_sortorder2(self, value):
9628         if isinstance(value,LIST):
9629             self.__field_sortorder2=value
9630         else:
9631             self.__field_sortorder2=LIST(value,**{'elementclass': _gen_p_sanyo_546, 'length': _NUMPBSLOTS})
9632 
9633     def __delfield_sortorder2(self): del self.__field_sortorder2
9634 
9635     sortorder2=property(__getfield_sortorder2, __setfield_sortorder2, __delfield_sortorder2, "Sort order for entries with phone numbers")
9636 
9637     def __getfield_speeddialindex(self):
9638         try: self.__field_speeddialindex
9639         except:
9640             self.__field_speeddialindex=LIST(**{'elementclass': _gen_p_sanyo_548, 'length': _NUMSPEEDDIALS})
9641         return self.__field_speeddialindex.getvalue()
9642 
9643     def __setfield_speeddialindex(self, value):
9644         if isinstance(value,LIST):
9645             self.__field_speeddialindex=value
9646         else:
9647             self.__field_speeddialindex=LIST(value,**{'elementclass': _gen_p_sanyo_548, 'length': _NUMSPEEDDIALS})
9648 
9649     def __delfield_speeddialindex(self): del self.__field_speeddialindex
9650 
9651     speeddialindex=property(__getfield_speeddialindex, __setfield_speeddialindex, __delfield_speeddialindex, None)
9652 
9653     def __getfield_longnumbersindex(self):
9654         try: self.__field_longnumbersindex
9655         except:
9656             self.__field_longnumbersindex=LIST(**{'elementclass': _gen_p_sanyo_550, 'length': _NUMLONGNUMBERS})
9657         return self.__field_longnumbersindex.getvalue()
9658 
9659     def __setfield_longnumbersindex(self, value):
9660         if isinstance(value,LIST):
9661             self.__field_longnumbersindex=value
9662         else:
9663             self.__field_longnumbersindex=LIST(value,**{'elementclass': _gen_p_sanyo_550, 'length': _NUMLONGNUMBERS})
9664 
9665     def __delfield_longnumbersindex(self): del self.__field_longnumbersindex
9666 
9667     longnumbersindex=property(__getfield_longnumbersindex, __setfield_longnumbersindex, __delfield_longnumbersindex, None)
9668 
9669     def __getfield_emails(self):
9670         try: self.__field_emails
9671         except:
9672             self.__field_emails=LIST(**{'elementclass': _gen_p_sanyo_552, 'length': _NUMPBSLOTS})
9673         return self.__field_emails.getvalue()
9674 
9675     def __setfield_emails(self, value):
9676         if isinstance(value,LIST):
9677             self.__field_emails=value
9678         else:
9679             self.__field_emails=LIST(value,**{'elementclass': _gen_p_sanyo_552, 'length': _NUMPBSLOTS})
9680 
9681     def __delfield_emails(self): del self.__field_emails
9682 
9683     emails=property(__getfield_emails, __setfield_emails, __delfield_emails, "Sorted list of slots with Email")
9684 
9685     def __getfield_emailfirstletters(self):
9686         return self.__field_emailfirstletters.getvalue()
9687 
9688     def __setfield_emailfirstletters(self, value):
9689         if isinstance(value,USTRING):
9690             self.__field_emailfirstletters=value
9691         else:
9692             self.__field_emailfirstletters=USTRING(value,**{'terminator': None, 'sizeinbytes': _NUMPBSLOTS})
9693 
9694     def __delfield_emailfirstletters(self): del self.__field_emailfirstletters
9695 
9696     emailfirstletters=property(__getfield_emailfirstletters, __setfield_emailfirstletters, __delfield_emailfirstletters, "First letters in sort order")
9697 
9698     def __getfield_urls(self):
9699         try: self.__field_urls
9700         except:
9701             self.__field_urls=LIST(**{'elementclass': _gen_p_sanyo_555, 'length': _NUMPBSLOTS})
9702         return self.__field_urls.getvalue()
9703 
9704     def __setfield_urls(self, value):
9705         if isinstance(value,LIST):
9706             self.__field_urls=value
9707         else:
9708             self.__field_urls=LIST(value,**{'elementclass': _gen_p_sanyo_555, 'length': _NUMPBSLOTS})
9709 
9710     def __delfield_urls(self): del self.__field_urls
9711 
9712     urls=property(__getfield_urls, __setfield_urls, __delfield_urls, "Sorted list of slots with a URL")
9713 
9714     def __getfield_urlfirstletters(self):
9715         return self.__field_urlfirstletters.getvalue()
9716 
9717     def __setfield_urlfirstletters(self, value):
9718         if isinstance(value,USTRING):
9719             self.__field_urlfirstletters=value
9720         else:
9721             self.__field_urlfirstletters=USTRING(value,**{'terminator': None, 'sizeinbytes': _NUMPBSLOTS})
9722 
9723     def __delfield_urlfirstletters(self): del self.__field_urlfirstletters
9724 
9725     urlfirstletters=property(__getfield_urlfirstletters, __setfield_urlfirstletters, __delfield_urlfirstletters, "First letters in sort order")
9726 
9727     def __getfield_pad(self):
9728         try: self.__field_pad
9729         except:
9730             self.__field_pad=UNKNOWN(**{'sizeinbytes': 66})
9731         return self.__field_pad.getvalue()
9732 
9733     def __setfield_pad(self, value):
9734         if isinstance(value,UNKNOWN):
9735             self.__field_pad=value
9736         else:
9737             self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 66})
9738 
9739     def __delfield_pad(self): del self.__field_pad
9740 
9741     pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None)
9742 
9743     def iscontainer(self):
9744         return True
9745 
9746     def containerelements(self):
9747         yield ('startcommand', self.__field_startcommand, "Starting command for R/W buf parts")
9748         yield ('bufsize', self.__field_bufsize, None)
9749         yield ('comment', self.__field_comment, None)
9750         yield ('usedflags', self.__field_usedflags, None)
9751         yield ('slotsused', self.__field_slotsused, None)
9752         yield ('slotsused2', self.__field_slotsused2, "# slots containing a phone number")
9753         yield ('numemail', self.__field_numemail, "Num of slots with email")
9754         yield ('numurl', self.__field_numurl, "Num of slots with URL")
9755         yield ('firsttypes', self.__field_firsttypes, None)
9756         yield ('sortorder', self.__field_sortorder, None)
9757         yield ('pbfirstletters', self.__field_pbfirstletters, None)
9758         yield ('sortorder2', self.__field_sortorder2, "Sort order for entries with phone numbers")
9759         yield ('speeddialindex', self.__field_speeddialindex, None)
9760         yield ('longnumbersindex', self.__field_longnumbersindex, None)
9761         yield ('emails', self.__field_emails, "Sorted list of slots with Email")
9762         yield ('emailfirstletters', self.__field_emailfirstletters, "First letters in sort order")
9763         yield ('urls', self.__field_urls, "Sorted list of slots with a URL")
9764         yield ('urlfirstletters', self.__field_urlfirstletters, "First letters in sort order")
9765         yield ('pad', self.__field_pad, None)
9766 
9767 
9768 
9769 
9770 class _gen_p_sanyo_535(BaseProtogenClass):
9771     'Anonymous inner class'
9772     __fields=['used']
9773 
9774     def __init__(self, *args, **kwargs):
9775         dict={}
9776         # What was supplied to this function
9777         dict.update(kwargs)
9778         # Parent constructor
9779         super(_gen_p_sanyo_535,self).__init__(**dict)
9780         if self.__class__ is _gen_p_sanyo_535:
9781             self._update(args,dict)
9782 
9783 
9784     def getfields(self):
9785         return self.__fields
9786 
9787 
9788     def _update(self, args, kwargs):
9789         super(_gen_p_sanyo_535,self)._update(args,kwargs)
9790         keys=kwargs.keys()
9791         for key in keys:
9792             if key in self.__fields:
9793                 setattr(self, key, kwargs[key])
9794                 del kwargs[key]
9795         # Were any unrecognized kwargs passed in?
9796         if __debug__:
9797             self._complainaboutunusedargs(_gen_p_sanyo_535,kwargs)
9798         if len(args):
9799             dict2={'sizeinbytes': 1}
9800             dict2.update(kwargs)
9801             kwargs=dict2
9802             self.__field_used=UINT(*args,**dict2)
9803         # Make all P fields that haven't already been constructed
9804 
9805 
9806     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
9807         'Writes this packet to the supplied buffer'
9808         self._bufferstartoffset=buf.getcurrentoffset()
9809         self.__field_used.writetobuffer(buf)
9810         self._bufferendoffset=buf.getcurrentoffset()
9811         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
9812 
9813 
9814     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
9815         'Reads this packet from the supplied buffer'
9816         self._bufferstartoffset=buf.getcurrentoffset()
9817         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
9818         self.__field_used=UINT(**{'sizeinbytes': 1})
9819         self.__field_used.readfrombuffer(buf)
9820         self._bufferendoffset=buf.getcurrentoffset()
9821 
9822 
9823     def __getfield_used(self):
9824         return self.__field_used.getvalue()
9825 
9826     def __setfield_used(self, value):
9827         if isinstance(value,UINT):
9828             self.__field_used=value
9829         else:
9830             self.__field_used=UINT(value,**{'sizeinbytes': 1})
9831 
9832     def __delfield_used(self): del self.__field_used
9833 
9834     used=property(__getfield_used, __setfield_used, __delfield_used, "1 if slot in use")
9835 
9836     def iscontainer(self):
9837         return True
9838 
9839     def containerelements(self):
9840         yield ('used', self.__field_used, "1 if slot in use")
9841 
9842 
9843 
9844 
9845 class _gen_p_sanyo_541(BaseProtogenClass):
9846     'Anonymous inner class'
9847     __fields=['firsttype']
9848 
9849     def __init__(self, *args, **kwargs):
9850         dict={}
9851         # What was supplied to this function
9852         dict.update(kwargs)
9853         # Parent constructor
9854         super(_gen_p_sanyo_541,self).__init__(**dict)
9855         if self.__class__ is _gen_p_sanyo_541:
9856             self._update(args,dict)
9857 
9858 
9859     def getfields(self):
9860         return self.__fields
9861 
9862 
9863     def _update(self, args, kwargs):
9864         super(_gen_p_sanyo_541,self)._update(args,kwargs)
9865         keys=kwargs.keys()
9866         for key in keys:
9867             if key in self.__fields:
9868                 setattr(self, key, kwargs[key])
9869                 del kwargs[key]
9870         # Were any unrecognized kwargs passed in?
9871         if __debug__:
9872             self._complainaboutunusedargs(_gen_p_sanyo_541,kwargs)
9873         if len(args):
9874             dict2={'sizeinbytes': 1}
9875             dict2.update(kwargs)
9876             kwargs=dict2
9877             self.__field_firsttype=UINT(*args,**dict2)
9878         # Make all P fields that haven't already been constructed
9879 
9880 
9881     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
9882         'Writes this packet to the supplied buffer'
9883         self._bufferstartoffset=buf.getcurrentoffset()
9884         self.__field_firsttype.writetobuffer(buf)
9885         self._bufferendoffset=buf.getcurrentoffset()
9886         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
9887 
9888 
9889     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
9890         'Reads this packet from the supplied buffer'
9891         self._bufferstartoffset=buf.getcurrentoffset()
9892         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
9893         self.__field_firsttype=UINT(**{'sizeinbytes': 1})
9894         self.__field_firsttype.readfrombuffer(buf)
9895         self._bufferendoffset=buf.getcurrentoffset()
9896 
9897 
9898     def __getfield_firsttype(self):
9899         return self.__field_firsttype.getvalue()
9900 
9901     def __setfield_firsttype(self, value):
9902         if isinstance(value,UINT):
9903             self.__field_firsttype=value
9904         else:
9905             self.__field_firsttype=UINT(value,**{'sizeinbytes': 1})
9906 
9907     def __delfield_firsttype(self): del self.__field_firsttype
9908 
9909     firsttype=property(__getfield_firsttype, __setfield_firsttype, __delfield_firsttype, "First phone number type in each slot")
9910 
9911     def iscontainer(self):
9912         return True
9913 
9914     def containerelements(self):
9915         yield ('firsttype', self.__field_firsttype, "First phone number type in each slot")
9916 
9917 
9918 
9919 
9920 class _gen_p_sanyo_543(BaseProtogenClass):
9921     'Anonymous inner class'
9922     __fields=['pbslot']
9923 
9924     def __init__(self, *args, **kwargs):
9925         dict={}
9926         # What was supplied to this function
9927         dict.update(kwargs)
9928         # Parent constructor
9929         super(_gen_p_sanyo_543,self).__init__(**dict)
9930         if self.__class__ is _gen_p_sanyo_543:
9931             self._update(args,dict)
9932 
9933 
9934     def getfields(self):
9935         return self.__fields
9936 
9937 
9938     def _update(self, args, kwargs):
9939         super(_gen_p_sanyo_543,self)._update(args,kwargs)
9940         keys=kwargs.keys()
9941         for key in keys:
9942             if key in self.__fields:
9943                 setattr(self, key, kwargs[key])
9944                 del kwargs[key]
9945         # Were any unrecognized kwargs passed in?
9946         if __debug__:
9947             self._complainaboutunusedargs(_gen_p_sanyo_543,kwargs)
9948         if len(args):
9949             dict2={'sizeinbytes': 2, 'default': 0xffff}
9950             dict2.update(kwargs)
9951             kwargs=dict2
9952             self.__field_pbslot=UINT(*args,**dict2)
9953         # Make all P fields that haven't already been constructed
9954 
9955 
9956     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
9957         'Writes this packet to the supplied buffer'
9958         self._bufferstartoffset=buf.getcurrentoffset()
9959         self.__field_pbslot.writetobuffer(buf)
9960         self._bufferendoffset=buf.getcurrentoffset()
9961         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
9962 
9963 
9964     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
9965         'Reads this packet from the supplied buffer'
9966         self._bufferstartoffset=buf.getcurrentoffset()
9967         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
9968         self.__field_pbslot=UINT(**{'sizeinbytes': 2, 'default': 0xffff})
9969         self.__field_pbslot.readfrombuffer(buf)
9970         self._bufferendoffset=buf.getcurrentoffset()
9971 
9972 
9973     def __getfield_pbslot(self):
9974         return self.__field_pbslot.getvalue()
9975 
9976     def __setfield_pbslot(self, value):
9977         if isinstance(value,UINT):
9978             self.__field_pbslot=value
9979         else:
9980             self.__field_pbslot=UINT(value,**{'sizeinbytes': 2, 'default': 0xffff})
9981 
9982     def __delfield_pbslot(self): del self.__field_pbslot
9983 
9984     pbslot=property(__getfield_pbslot, __setfield_pbslot, __delfield_pbslot, None)
9985 
9986     def iscontainer(self):
9987         return True
9988 
9989     def containerelements(self):
9990         yield ('pbslot', self.__field_pbslot, None)
9991 
9992 
9993 
9994 
9995 class _gen_p_sanyo_546(BaseProtogenClass):
9996     'Anonymous inner class'
9997     __fields=['pbslot']
9998 
9999     def __init__(self, *args, **kwargs):
10000         dict={}
10001         # What was supplied to this function
10002         dict.update(kwargs)
10003         # Parent constructor
10004         super(_gen_p_sanyo_546,self).__init__(**dict)
10005         if self.__class__ is _gen_p_sanyo_546:
10006             self._update(args,dict)
10007 
10008 
10009     def getfields(self):
10010         return self.__fields
10011 
10012 
10013     def _update(self, args, kwargs):
10014         super(_gen_p_sanyo_546,self)._update(args,kwargs)
10015         keys=kwargs.keys()
10016         for key in keys:
10017             if key in self.__fields:
10018                 setattr(self, key, kwargs[key])
10019                 del kwargs[key]
10020         # Were any unrecognized kwargs passed in?
10021         if __debug__:
10022             self._complainaboutunusedargs(_gen_p_sanyo_546,kwargs)
10023         if len(args):
10024             dict2={'sizeinbytes': 2, 'default': 0xffff}
10025             dict2.update(kwargs)
10026             kwargs=dict2
10027             self.__field_pbslot=UINT(*args,**dict2)
10028         # Make all P fields that haven't already been constructed
10029 
10030 
10031     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
10032         'Writes this packet to the supplied buffer'
10033         self._bufferstartoffset=buf.getcurrentoffset()
10034         self.__field_pbslot.writetobuffer(buf)
10035         self._bufferendoffset=buf.getcurrentoffset()
10036         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
10037 
10038 
10039     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
10040         'Reads this packet from the supplied buffer'
10041         self._bufferstartoffset=buf.getcurrentoffset()
10042         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
10043         self.__field_pbslot=UINT(**{'sizeinbytes': 2, 'default': 0xffff})
10044         self.__field_pbslot.readfrombuffer(buf)
10045         self._bufferendoffset=buf.getcurrentoffset()
10046 
10047 
10048     def __getfield_pbslot(self):
10049         return self.__field_pbslot.getvalue()
10050 
10051     def __setfield_pbslot(self, value):
10052         if isinstance(value,UINT):
10053             self.__field_pbslot=value
10054         else:
10055             self.__field_pbslot=UINT(value,**{'sizeinbytes': 2, 'default': 0xffff})
10056 
10057     def __delfield_pbslot(self): del self.__field_pbslot
10058 
10059     pbslot=property(__getfield_pbslot, __setfield_pbslot, __delfield_pbslot, None)
10060 
10061     def iscontainer(self):
10062         return True
10063 
10064     def containerelements(self):
10065         yield ('pbslot', self.__field_pbslot, None)
10066 
10067 
10068 
10069 
10070 class _gen_p_sanyo_548(BaseProtogenClass):
10071     'Anonymous inner class'
10072     __fields=['pbslotandtype']
10073 
10074     def __init__(self, *args, **kwargs):
10075         dict={}
10076         # What was supplied to this function
10077         dict.update(kwargs)
10078         # Parent constructor
10079         super(_gen_p_sanyo_548,self).__init__(**dict)
10080         if self.__class__ is _gen_p_sanyo_548:
10081             self._update(args,dict)
10082 
10083 
10084     def getfields(self):
10085         return self.__fields
10086 
10087 
10088     def _update(self, args, kwargs):
10089         super(_gen_p_sanyo_548,self)._update(args,kwargs)
10090         keys=kwargs.keys()
10091         for key in keys:
10092             if key in self.__fields:
10093                 setattr(self, key, kwargs[key])
10094                 del kwargs[key]
10095         # Were any unrecognized kwargs passed in?
10096         if __debug__:
10097             self._complainaboutunusedargs(_gen_p_sanyo_548,kwargs)
10098         if len(args):
10099             dict2={'sizeinbytes': 2, 'default': 0xffff}
10100             dict2.update(kwargs)
10101             kwargs=dict2
10102             self.__field_pbslotandtype=UINT(*args,**dict2)
10103         # Make all P fields that haven't already been constructed
10104 
10105 
10106     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
10107         'Writes this packet to the supplied buffer'
10108         self._bufferstartoffset=buf.getcurrentoffset()
10109         self.__field_pbslotandtype.writetobuffer(buf)
10110         self._bufferendoffset=buf.getcurrentoffset()
10111         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
10112 
10113 
10114     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
10115         'Reads this packet from the supplied buffer'
10116         self._bufferstartoffset=buf.getcurrentoffset()
10117         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
10118         self.__field_pbslotandtype=UINT(**{'sizeinbytes': 2, 'default': 0xffff})
10119         self.__field_pbslotandtype.readfrombuffer(buf)
10120         self._bufferendoffset=buf.getcurrentoffset()
10121 
10122 
10123     def __getfield_pbslotandtype(self):
10124         return self.__field_pbslotandtype.getvalue()
10125 
10126     def __setfield_pbslotandtype(self, value):
10127         if isinstance(value,UINT):
10128             self.__field_pbslotandtype=value
10129         else:
10130             self.__field_pbslotandtype=UINT(value,**{'sizeinbytes': 2, 'default': 0xffff})
10131 
10132     def __delfield_pbslotandtype(self): del self.__field_pbslotandtype
10133 
10134     pbslotandtype=property(__getfield_pbslotandtype, __setfield_pbslotandtype, __delfield_pbslotandtype, None)
10135 
10136     def iscontainer(self):
10137         return True
10138 
10139     def containerelements(self):
10140         yield ('pbslotandtype', self.__field_pbslotandtype, None)
10141 
10142 
10143 
10144 
10145 class _gen_p_sanyo_550(BaseProtogenClass):
10146     'Anonymous inner class'
10147     __fields=['pbslotandtype']
10148 
10149     def __init__(self, *args, **kwargs):
10150         dict={}
10151         # What was supplied to this function
10152         dict.update(kwargs)
10153         # Parent constructor
10154         super(_gen_p_sanyo_550,self).__init__(**dict)
10155         if self.__class__ is _gen_p_sanyo_550:
10156             self._update(args,dict)
10157 
10158 
10159     def getfields(self):
10160         return self.__fields
10161 
10162 
10163     def _update(self, args, kwargs):
10164         super(_gen_p_sanyo_550,self)._update(args,kwargs)
10165         keys=kwargs.keys()
10166         for key in keys:
10167             if key in self.__fields:
10168                 setattr(self, key, kwargs[key])
10169                 del kwargs[key]
10170         # Were any unrecognized kwargs passed in?
10171         if __debug__:
10172             self._complainaboutunusedargs(_gen_p_sanyo_550,kwargs)
10173         if len(args):
10174             dict2={'sizeinbytes': 2, 'default': 0xffff}
10175             dict2.update(kwargs)
10176             kwargs=dict2
10177             self.__field_pbslotandtype=UINT(*args,**dict2)
10178         # Make all P fields that haven't already been constructed
10179 
10180 
10181     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
10182         'Writes this packet to the supplied buffer'
10183         self._bufferstartoffset=buf.getcurrentoffset()
10184         self.__field_pbslotandtype.writetobuffer(buf)
10185         self._bufferendoffset=buf.getcurrentoffset()
10186         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
10187 
10188 
10189     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
10190         'Reads this packet from the supplied buffer'
10191         self._bufferstartoffset=buf.getcurrentoffset()
10192         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
10193         self.__field_pbslotandtype=UINT(**{'sizeinbytes': 2, 'default': 0xffff})
10194         self.__field_pbslotandtype.readfrombuffer(buf)
10195         self._bufferendoffset=buf.getcurrentoffset()
10196 
10197 
10198     def __getfield_pbslotandtype(self):
10199         return self.__field_pbslotandtype.getvalue()
10200 
10201     def __setfield_pbslotandtype(self, value):
10202         if isinstance(value,UINT):
10203             self.__field_pbslotandtype=value
10204         else:
10205             self.__field_pbslotandtype=UINT(value,**{'sizeinbytes': 2, 'default': 0xffff})
10206 
10207     def __delfield_pbslotandtype(self): del self.__field_pbslotandtype
10208 
10209     pbslotandtype=property(__getfield_pbslotandtype, __setfield_pbslotandtype, __delfield_pbslotandtype, None)
10210 
10211     def iscontainer(self):
10212         return True
10213 
10214     def containerelements(self):
10215         yield ('pbslotandtype', self.__field_pbslotandtype, None)
10216 
10217 
10218 
10219 
10220 class _gen_p_sanyo_552(BaseProtogenClass):
10221     'Anonymous inner class'
10222     __fields=['pbslot']
10223 
10224     def __init__(self, *args, **kwargs):
10225         dict={}
10226         # What was supplied to this function
10227         dict.update(kwargs)
10228         # Parent constructor
10229         super(_gen_p_sanyo_552,self).__init__(**dict)
10230         if self.__class__ is _gen_p_sanyo_552:
10231             self._update(args,dict)
10232 
10233 
10234     def getfields(self):
10235         return self.__fields
10236 
10237 
10238     def _update(self, args, kwargs):
10239         super(_gen_p_sanyo_552,self)._update(args,kwargs)
10240         keys=kwargs.keys()
10241         for key in keys:
10242             if key in self.__fields:
10243                 setattr(self, key, kwargs[key])
10244                 del kwargs[key]
10245         # Were any unrecognized kwargs passed in?
10246         if __debug__:
10247             self._complainaboutunusedargs(_gen_p_sanyo_552,kwargs)
10248         if len(args):
10249             dict2={'sizeinbytes': 2, 'default': 0xffff}
10250             dict2.update(kwargs)
10251             kwargs=dict2
10252             self.__field_pbslot=UINT(*args,**dict2)
10253         # Make all P fields that haven't already been constructed
10254 
10255 
10256     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
10257         'Writes this packet to the supplied buffer'
10258         self._bufferstartoffset=buf.getcurrentoffset()
10259         self.__field_pbslot.writetobuffer(buf)
10260         self._bufferendoffset=buf.getcurrentoffset()
10261         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
10262 
10263 
10264     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
10265         'Reads this packet from the supplied buffer'
10266         self._bufferstartoffset=buf.getcurrentoffset()
10267         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
10268         self.__field_pbslot=UINT(**{'sizeinbytes': 2, 'default': 0xffff})
10269         self.__field_pbslot.readfrombuffer(buf)
10270         self._bufferendoffset=buf.getcurrentoffset()
10271 
10272 
10273     def __getfield_pbslot(self):
10274         return self.__field_pbslot.getvalue()
10275 
10276     def __setfield_pbslot(self, value):
10277         if isinstance(value,UINT):
10278             self.__field_pbslot=value
10279         else:
10280             self.__field_pbslot=UINT(value,**{'sizeinbytes': 2, 'default': 0xffff})
10281 
10282     def __delfield_pbslot(self): del self.__field_pbslot
10283 
10284     pbslot=property(__getfield_pbslot, __setfield_pbslot, __delfield_pbslot, None)
10285 
10286     def iscontainer(self):
10287         return True
10288 
10289     def containerelements(self):
10290         yield ('pbslot', self.__field_pbslot, None)
10291 
10292 
10293 
10294 
10295 class _gen_p_sanyo_555(BaseProtogenClass):
10296     'Anonymous inner class'
10297     __fields=['pbslot']
10298 
10299     def __init__(self, *args, **kwargs):
10300         dict={}
10301         # What was supplied to this function
10302         dict.update(kwargs)
10303         # Parent constructor
10304         super(_gen_p_sanyo_555,self).__init__(**dict)
10305         if self.__class__ is _gen_p_sanyo_555:
10306             self._update(args,dict)
10307 
10308 
10309     def getfields(self):
10310         return self.__fields
10311 
10312 
10313     def _update(self, args, kwargs):
10314         super(_gen_p_sanyo_555,self)._update(args,kwargs)
10315         keys=kwargs.keys()
10316         for key in keys:
10317             if key in self.__fields:
10318                 setattr(self, key, kwargs[key])
10319                 del kwargs[key]
10320         # Were any unrecognized kwargs passed in?
10321         if __debug__:
10322             self._complainaboutunusedargs(_gen_p_sanyo_555,kwargs)
10323         if len(args):
10324             dict2={'sizeinbytes': 2, 'default': 0xffff}
10325             dict2.update(kwargs)
10326             kwargs=dict2
10327             self.__field_pbslot=UINT(*args,**dict2)
10328         # Make all P fields that haven't already been constructed
10329 
10330 
10331     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
10332         'Writes this packet to the supplied buffer'
10333         self._bufferstartoffset=buf.getcurrentoffset()
10334         self.__field_pbslot.writetobuffer(buf)
10335         self._bufferendoffset=buf.getcurrentoffset()
10336         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
10337 
10338 
10339     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
10340         'Reads this packet from the supplied buffer'
10341         self._bufferstartoffset=buf.getcurrentoffset()
10342         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
10343         self.__field_pbslot=UINT(**{'sizeinbytes': 2, 'default': 0xffff})
10344         self.__field_pbslot.readfrombuffer(buf)
10345         self._bufferendoffset=buf.getcurrentoffset()
10346 
10347 
10348     def __getfield_pbslot(self):
10349         return self.__field_pbslot.getvalue()
10350 
10351     def __setfield_pbslot(self, value):
10352         if isinstance(value,UINT):
10353             self.__field_pbslot=value
10354         else:
10355             self.__field_pbslot=UINT(value,**{'sizeinbytes': 2, 'default': 0xffff})
10356 
10357     def __delfield_pbslot(self): del self.__field_pbslot
10358 
10359     pbslot=property(__getfield_pbslot, __setfield_pbslot, __delfield_pbslot, None)
10360 
10361     def iscontainer(self):
10362         return True
10363 
10364     def containerelements(self):
10365         yield ('pbslot', self.__field_pbslot, None)
10366 
10367 
10368 
10369 
10370 class sanyomediaheader(BaseProtogenClass):
10371     __fields=['fa', 'faset', 'command', 'pad']
10372 
10373     def __init__(self, *args, **kwargs):
10374         dict={}
10375         # What was supplied to this function
10376         dict.update(kwargs)
10377         # Parent constructor
10378         super(sanyomediaheader,self).__init__(**dict)
10379         if self.__class__ is sanyomediaheader:
10380             self._update(args,dict)
10381 
10382 
10383     def getfields(self):
10384         return self.__fields
10385 
10386 
10387     def _update(self, args, kwargs):
10388         super(sanyomediaheader,self)._update(args,kwargs)
10389         keys=kwargs.keys()
10390         for key in keys:
10391             if key in self.__fields:
10392                 setattr(self, key, kwargs[key])
10393                 del kwargs[key]
10394         # Were any unrecognized kwargs passed in?
10395         if __debug__:
10396             self._complainaboutunusedargs(sanyomediaheader,kwargs)
10397         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
10398         # Make all P fields that haven't already been constructed
10399 
10400 
10401     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
10402         'Writes this packet to the supplied buffer'
10403         self._bufferstartoffset=buf.getcurrentoffset()
10404         try: self.__field_fa
10405         except:
10406             self.__field_fa=UINT(**{'sizeinbytes': 2, 'constant': 0xfa})
10407         self.__field_fa.writetobuffer(buf)
10408         try: self.__field_faset
10409         except:
10410             self.__field_faset=UINT(**{'sizeinbytes': 1, 'default': 0x05})
10411         self.__field_faset.writetobuffer(buf)
10412         self.__field_command.writetobuffer(buf)
10413         try: self.__field_pad
10414         except:
10415             self.__field_pad=UNKNOWN(**{'sizeinbytes': 2})
10416         self.__field_pad.writetobuffer(buf)
10417         self._bufferendoffset=buf.getcurrentoffset()
10418         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
10419 
10420 
10421     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
10422         'Reads this packet from the supplied buffer'
10423         self._bufferstartoffset=buf.getcurrentoffset()
10424         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
10425         self.__field_fa=UINT(**{'sizeinbytes': 2, 'constant': 0xfa})
10426         self.__field_fa.readfrombuffer(buf)
10427         self.__field_faset=UINT(**{'sizeinbytes': 1, 'default': 0x05})
10428         self.__field_faset.readfrombuffer(buf)
10429         self.__field_command=UINT(**{'sizeinbytes': 2})
10430         self.__field_command.readfrombuffer(buf)
10431         self.__field_pad=UNKNOWN(**{'sizeinbytes': 2})
10432         self.__field_pad.readfrombuffer(buf)
10433         self._bufferendoffset=buf.getcurrentoffset()
10434 
10435 
10436     def __getfield_fa(self):
10437         try: self.__field_fa
10438         except:
10439             self.__field_fa=UINT(**{'sizeinbytes': 2, 'constant': 0xfa})
10440         return self.__field_fa.getvalue()
10441 
10442     def __setfield_fa(self, value):
10443         if isinstance(value,UINT):
10444             self.__field_fa=value
10445         else:
10446             self.__field_fa=UINT(value,**{'sizeinbytes': 2, 'constant': 0xfa})
10447 
10448     def __delfield_fa(self): del self.__field_fa
10449 
10450     fa=property(__getfield_fa, __setfield_fa, __delfield_fa, None)
10451 
10452     def __getfield_faset(self):
10453         try: self.__field_faset
10454         except:
10455             self.__field_faset=UINT(**{'sizeinbytes': 1, 'default': 0x05})
10456         return self.__field_faset.getvalue()
10457 
10458     def __setfield_faset(self, value):
10459         if isinstance(value,UINT):
10460             self.__field_faset=value
10461         else:
10462             self.__field_faset=UINT(value,**{'sizeinbytes': 1, 'default': 0x05})
10463 
10464     def __delfield_faset(self): del self.__field_faset
10465 
10466     faset=property(__getfield_faset, __setfield_faset, __delfield_faset, None)
10467 
10468     def __getfield_command(self):
10469         return self.__field_command.getvalue()
10470 
10471     def __setfield_command(self, value):
10472         if isinstance(value,UINT):
10473             self.__field_command=value
10474         else:
10475             self.__field_command=UINT(value,**{'sizeinbytes': 2})
10476 
10477     def __delfield_command(self): del self.__field_command
10478 
10479     command=property(__getfield_command, __setfield_command, __delfield_command, None)
10480 
10481     def __getfield_pad(self):
10482         try: self.__field_pad
10483         except:
10484             self.__field_pad=UNKNOWN(**{'sizeinbytes': 2})
10485         return self.__field_pad.getvalue()
10486 
10487     def __setfield_pad(self, value):
10488         if isinstance(value,UNKNOWN):
10489             self.__field_pad=value
10490         else:
10491             self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 2})
10492 
10493     def __delfield_pad(self): del self.__field_pad
10494 
10495     pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None)
10496 
10497     def iscontainer(self):
10498         return True
10499 
10500     def containerelements(self):
10501         yield ('fa', self.__field_fa, None)
10502         yield ('faset', self.__field_faset, None)
10503         yield ('command', self.__field_command, None)
10504         yield ('pad', self.__field_pad, None)
10505 
10506 
10507 
10508 
10509 class sanyosendfilename(BaseProtogenClass):
10510     __fields=['header', 'payloadsize', 'filename']
10511 
10512     def __init__(self, *args, **kwargs):
10513         dict={}
10514         # What was supplied to this function
10515         dict.update(kwargs)
10516         # Parent constructor
10517         super(sanyosendfilename,self).__init__(**dict)
10518         if self.__class__ is sanyosendfilename:
10519             self._update(args,dict)
10520 
10521 
10522     def getfields(self):
10523         return self.__fields
10524 
10525 
10526     def _update(self, args, kwargs):
10527         super(sanyosendfilename,self)._update(args,kwargs)
10528         keys=kwargs.keys()
10529         for key in keys:
10530             if key in self.__fields:
10531                 setattr(self, key, kwargs[key])
10532                 del kwargs[key]
10533         # Were any unrecognized kwargs passed in?
10534         if __debug__:
10535             self._complainaboutunusedargs(sanyosendfilename,kwargs)
10536         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
10537         # Make all P fields that haven't already been constructed
10538 
10539 
10540     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
10541         'Writes this packet to the supplied buffer'
10542         self._bufferstartoffset=buf.getcurrentoffset()
10543         try: self.__field_header
10544         except:
10545             self.__field_header=sanyomediaheader(**{'command': 0xffa1})
10546         self.__field_header.writetobuffer(buf)
10547         try: self.__field_payloadsize
10548         except:
10549             self.__field_payloadsize=UINT(**{'sizeinbytes': 1, 'constant': 0x20})
10550         self.__field_payloadsize.writetobuffer(buf)
10551         try: self.__field_filename
10552         except:
10553             self.__field_filename=USTRING(**{'sizeinbytes': 32, 'default': ""})
10554         self.__field_filename.writetobuffer(buf)
10555         self._bufferendoffset=buf.getcurrentoffset()
10556         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
10557 
10558 
10559     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
10560         'Reads this packet from the supplied buffer'
10561         self._bufferstartoffset=buf.getcurrentoffset()
10562         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
10563         self.__field_header=sanyomediaheader(**{'command': 0xffa1})
10564         self.__field_header.readfrombuffer(buf)
10565         self.__field_payloadsize=UINT(**{'sizeinbytes': 1, 'constant': 0x20})
10566         self.__field_payloadsize.readfrombuffer(buf)
10567         self.__field_filename=USTRING(**{'sizeinbytes': 32, 'default': ""})
10568         self.__field_filename.readfrombuffer(buf)
10569         self._bufferendoffset=buf.getcurrentoffset()
10570 
10571 
10572     def __getfield_header(self):
10573         try: self.__field_header
10574         except:
10575             self.__field_header=sanyomediaheader(**{'command': 0xffa1})
10576         return self.__field_header.getvalue()
10577 
10578     def __setfield_header(self, value):
10579         if isinstance(value,sanyomediaheader):
10580             self.__field_header=value
10581         else:
10582             self.__field_header=sanyomediaheader(value,**{'command': 0xffa1})
10583 
10584     def __delfield_header(self): del self.__field_header
10585 
10586     header=property(__getfield_header, __setfield_header, __delfield_header, None)
10587 
10588     def __getfield_payloadsize(self):
10589         try: self.__field_payloadsize
10590         except:
10591             self.__field_payloadsize=UINT(**{'sizeinbytes': 1, 'constant': 0x20})
10592         return self.__field_payloadsize.getvalue()
10593 
10594     def __setfield_payloadsize(self, value):
10595         if isinstance(value,UINT):
10596             self.__field_payloadsize=value
10597         else:
10598             self.__field_payloadsize=UINT(value,**{'sizeinbytes': 1, 'constant': 0x20})
10599 
10600     def __delfield_payloadsize(self): del self.__field_payloadsize
10601 
10602     payloadsize=property(__getfield_payloadsize, __setfield_payloadsize, __delfield_payloadsize, None)
10603 
10604     def __getfield_filename(self):
10605         try: self.__field_filename
10606         except:
10607             self.__field_filename=USTRING(**{'sizeinbytes': 32, 'default': ""})
10608         return self.__field_filename.getvalue()
10609 
10610     def __setfield_filename(self, value):
10611         if isinstance(value,USTRING):
10612             self.__field_filename=value
10613         else:
10614             self.__field_filename=USTRING(value,**{'sizeinbytes': 32, 'default': ""})
10615 
10616     def __delfield_filename(self): del self.__field_filename
10617 
10618     filename=property(__getfield_filename, __setfield_filename, __delfield_filename, None)
10619 
10620     def iscontainer(self):
10621         return True
10622 
10623     def containerelements(self):
10624         yield ('header', self.__field_header, None)
10625         yield ('payloadsize', self.__field_payloadsize, None)
10626         yield ('filename', self.__field_filename, None)
10627 
10628 
10629 
10630 
10631 class sanyosendfilesize(BaseProtogenClass):
10632     __fields=['header', 'payloadsize', 'pad1', 'filesize', 'pad2']
10633 
10634     def __init__(self, *args, **kwargs):
10635         dict={}
10636         # What was supplied to this function
10637         dict.update(kwargs)
10638         # Parent constructor
10639         super(sanyosendfilesize,self).__init__(**dict)
10640         if self.__class__ is sanyosendfilesize:
10641             self._update(args,dict)
10642 
10643 
10644     def getfields(self):
10645         return self.__fields
10646 
10647 
10648     def _update(self, args, kwargs):
10649         super(sanyosendfilesize,self)._update(args,kwargs)
10650         keys=kwargs.keys()
10651         for key in keys:
10652             if key in self.__fields:
10653                 setattr(self, key, kwargs[key])
10654                 del kwargs[key]
10655         # Were any unrecognized kwargs passed in?
10656         if __debug__:
10657             self._complainaboutunusedargs(sanyosendfilesize,kwargs)
10658         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
10659         # Make all P fields that haven't already been constructed
10660 
10661 
10662     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
10663         'Writes this packet to the supplied buffer'
10664         self._bufferstartoffset=buf.getcurrentoffset()
10665         try: self.__field_header
10666         except:
10667             self.__field_header=sanyomediaheader(**{'command': 0xffc1})
10668         self.__field_header.writetobuffer(buf)
10669         try: self.__field_payloadsize
10670         except:
10671             self.__field_payloadsize=UINT(**{'sizeinbytes': 1, 'constant': 0x20})
10672         self.__field_payloadsize.writetobuffer(buf)
10673         try: self.__field_pad1
10674         except:
10675             self.__field_pad1=UNKNOWN(**{'sizeinbytes': 1})
10676         self.__field_pad1.writetobuffer(buf)
10677         self.__field_filesize.writetobuffer(buf)
10678         try: self.__field_pad2
10679         except:
10680             self.__field_pad2=UNKNOWN(**{'sizeinbytes': 29})
10681         self.__field_pad2.writetobuffer(buf)
10682         self._bufferendoffset=buf.getcurrentoffset()
10683         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
10684 
10685 
10686     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
10687         'Reads this packet from the supplied buffer'
10688         self._bufferstartoffset=buf.getcurrentoffset()
10689         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
10690         self.__field_header=sanyomediaheader(**{'command': 0xffc1})
10691         self.__field_header.readfrombuffer(buf)
10692         self.__field_payloadsize=UINT(**{'sizeinbytes': 1, 'constant': 0x20})
10693         self.__field_payloadsize.readfrombuffer(buf)
10694         self.__field_pad1=UNKNOWN(**{'sizeinbytes': 1})
10695         self.__field_pad1.readfrombuffer(buf)
10696         self.__field_filesize=UINT(**{'sizeinbytes': 2})
10697         self.__field_filesize.readfrombuffer(buf)
10698         self.__field_pad2=UNKNOWN(**{'sizeinbytes': 29})
10699         self.__field_pad2.readfrombuffer(buf)
10700         self._bufferendoffset=buf.getcurrentoffset()
10701 
10702 
10703     def __getfield_header(self):
10704         try: self.__field_header
10705         except:
10706             self.__field_header=sanyomediaheader(**{'command': 0xffc1})
10707         return self.__field_header.getvalue()
10708 
10709     def __setfield_header(self, value):
10710         if isinstance(value,sanyomediaheader):
10711             self.__field_header=value
10712         else:
10713             self.__field_header=sanyomediaheader(value,**{'command': 0xffc1})
10714 
10715     def __delfield_header(self): del self.__field_header
10716 
10717     header=property(__getfield_header, __setfield_header, __delfield_header, None)
10718 
10719     def __getfield_payloadsize(self):
10720         try: self.__field_payloadsize
10721         except:
10722             self.__field_payloadsize=UINT(**{'sizeinbytes': 1, 'constant': 0x20})
10723         return self.__field_payloadsize.getvalue()
10724 
10725     def __setfield_payloadsize(self, value):
10726         if isinstance(value,UINT):
10727             self.__field_payloadsize=value
10728         else:
10729             self.__field_payloadsize=UINT(value,**{'sizeinbytes': 1, 'constant': 0x20})
10730 
10731     def __delfield_payloadsize(self): del self.__field_payloadsize
10732 
10733     payloadsize=property(__getfield_payloadsize, __setfield_payloadsize, __delfield_payloadsize, None)
10734 
10735     def __getfield_pad1(self):
10736         try: self.__field_pad1
10737         except:
10738             self.__field_pad1=UNKNOWN(**{'sizeinbytes': 1})
10739         return self.__field_pad1.getvalue()
10740 
10741     def __setfield_pad1(self, value):
10742         if isinstance(value,UNKNOWN):
10743             self.__field_pad1=value
10744         else:
10745             self.__field_pad1=UNKNOWN(value,**{'sizeinbytes': 1})
10746 
10747     def __delfield_pad1(self): del self.__field_pad1
10748 
10749     pad1=property(__getfield_pad1, __setfield_pad1, __delfield_pad1, None)
10750 
10751     def __getfield_filesize(self):
10752         return self.__field_filesize.getvalue()
10753 
10754     def __setfield_filesize(self, value):
10755         if isinstance(value,UINT):
10756             self.__field_filesize=value
10757         else:
10758             self.__field_filesize=UINT(value,**{'sizeinbytes': 2})
10759 
10760     def __delfield_filesize(self): del self.__field_filesize
10761 
10762     filesize=property(__getfield_filesize, __setfield_filesize, __delfield_filesize, None)
10763 
10764     def __getfield_pad2(self):
10765         try: self.__field_pad2
10766         except:
10767             self.__field_pad2=UNKNOWN(**{'sizeinbytes': 29})
10768         return self.__field_pad2.getvalue()
10769 
10770     def __setfield_pad2(self, value):
10771         if isinstance(value,UNKNOWN):
10772             self.__field_pad2=value
10773         else:
10774             self.__field_pad2=UNKNOWN(value,**{'sizeinbytes': 29})
10775 
10776     def __delfield_pad2(self): del self.__field_pad2
10777 
10778     pad2=property(__getfield_pad2, __setfield_pad2, __delfield_pad2, None)
10779 
10780     def iscontainer(self):
10781         return True
10782 
10783     def containerelements(self):
10784         yield ('header', self.__field_header, None)
10785         yield ('payloadsize', self.__field_payloadsize, None)
10786         yield ('pad1', self.__field_pad1, None)
10787         yield ('filesize', self.__field_filesize, None)
10788         yield ('pad2', self.__field_pad2, None)
10789 
10790 
10791 
10792 
10793 class sanyosendfilefragment(BaseProtogenClass):
10794     __fields=['header', 'payloadsize', 'data']
10795 
10796     def __init__(self, *args, **kwargs):
10797         dict={}
10798         # What was supplied to this function
10799         dict.update(kwargs)
10800         # Parent constructor
10801         super(sanyosendfilefragment,self).__init__(**dict)
10802         if self.__class__ is sanyosendfilefragment:
10803             self._update(args,dict)
10804 
10805 
10806     def getfields(self):
10807         return self.__fields
10808 
10809 
10810     def _update(self, args, kwargs):
10811         super(sanyosendfilefragment,self)._update(args,kwargs)
10812         keys=kwargs.keys()
10813         for key in keys:
10814             if key in self.__fields:
10815                 setattr(self, key, kwargs[key])
10816                 del kwargs[key]
10817         # Were any unrecognized kwargs passed in?
10818         if __debug__:
10819             self._complainaboutunusedargs(sanyosendfilefragment,kwargs)
10820         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
10821         # Make all P fields that haven't already been constructed
10822 
10823 
10824     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
10825         'Writes this packet to the supplied buffer'
10826         self._bufferstartoffset=buf.getcurrentoffset()
10827         try: self.__field_header
10828         except:
10829             self.__field_header=sanyomediaheader()
10830         self.__field_header.writetobuffer(buf)
10831         try: self.__field_payloadsize
10832         except:
10833             self.__field_payloadsize=UINT(**{'sizeinbytes': 1, 'constant': 0x20})
10834         self.__field_payloadsize.writetobuffer(buf)
10835         self.__field_data.writetobuffer(buf)
10836         self._bufferendoffset=buf.getcurrentoffset()
10837         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
10838 
10839 
10840     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
10841         'Reads this packet from the supplied buffer'
10842         self._bufferstartoffset=buf.getcurrentoffset()
10843         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
10844         self.__field_header=sanyomediaheader()
10845         self.__field_header.readfrombuffer(buf)
10846         self.__field_payloadsize=UINT(**{'sizeinbytes': 1, 'constant': 0x20})
10847         self.__field_payloadsize.readfrombuffer(buf)
10848         self.__field_data=DATA(**{'sizeinbytes': 32})
10849         self.__field_data.readfrombuffer(buf)
10850         self._bufferendoffset=buf.getcurrentoffset()
10851 
10852 
10853     def __getfield_header(self):
10854         try: self.__field_header
10855         except:
10856             self.__field_header=sanyomediaheader()
10857         return self.__field_header.getvalue()
10858 
10859     def __setfield_header(self, value):
10860         if isinstance(value,sanyomediaheader):
10861             self.__field_header=value
10862         else:
10863             self.__field_header=sanyomediaheader(value,)
10864 
10865     def __delfield_header(self): del self.__field_header
10866 
10867     header=property(__getfield_header, __setfield_header, __delfield_header, None)
10868 
10869     def __getfield_payloadsize(self):
10870         try: self.__field_payloadsize
10871         except:
10872             self.__field_payloadsize=UINT(**{'sizeinbytes': 1, 'constant': 0x20})
10873         return self.__field_payloadsize.getvalue()
10874 
10875     def __setfield_payloadsize(self, value):
10876         if isinstance(value,UINT):
10877             self.__field_payloadsize=value
10878         else:
10879             self.__field_payloadsize=UINT(value,**{'sizeinbytes': 1, 'constant': 0x20})
10880 
10881     def __delfield_payloadsize(self): del self.__field_payloadsize
10882 
10883     payloadsize=property(__getfield_payloadsize, __setfield_payloadsize, __delfield_payloadsize, None)
10884 
10885     def __getfield_data(self):
10886         return self.__field_data.getvalue()
10887 
10888     def __setfield_data(self, value):
10889         if isinstance(value,DATA):
10890             self.__field_data=value
10891         else:
10892             self.__field_data=DATA(value,**{'sizeinbytes': 32})
10893 
10894     def __delfield_data(self): del self.__field_data
10895 
10896     data=property(__getfield_data, __setfield_data, __delfield_data, None)
10897 
10898     def iscontainer(self):
10899         return True
10900 
10901     def containerelements(self):
10902         yield ('header', self.__field_header, None)
10903         yield ('payloadsize', self.__field_payloadsize, None)
10904         yield ('data', self.__field_data, None)
10905 
10906 
10907 
10908 
10909 class sanyosendfileterminator(BaseProtogenClass):
10910     __fields=['header', 'payloadsize', 'pad']
10911 
10912     def __init__(self, *args, **kwargs):
10913         dict={}
10914         # What was supplied to this function
10915         dict.update(kwargs)
10916         # Parent constructor
10917         super(sanyosendfileterminator,self).__init__(**dict)
10918         if self.__class__ is sanyosendfileterminator:
10919             self._update(args,dict)
10920 
10921 
10922     def getfields(self):
10923         return self.__fields
10924 
10925 
10926     def _update(self, args, kwargs):
10927         super(sanyosendfileterminator,self)._update(args,kwargs)
10928         keys=kwargs.keys()
10929         for key in keys:
10930             if key in self.__fields:
10931                 setattr(self, key, kwargs[key])
10932                 del kwargs[key]
10933         # Were any unrecognized kwargs passed in?
10934         if __debug__:
10935             self._complainaboutunusedargs(sanyosendfileterminator,kwargs)
10936         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
10937         # Make all P fields that haven't already been constructed
10938 
10939 
10940     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
10941         'Writes this packet to the supplied buffer'
10942         self._bufferstartoffset=buf.getcurrentoffset()
10943         try: self.__field_header
10944         except:
10945             self.__field_header=sanyomediaheader(**{'command': 0xffe1})
10946         self.__field_header.writetobuffer(buf)
10947         try: self.__field_payloadsize
10948         except:
10949             self.__field_payloadsize=UINT(**{'sizeinbytes': 1, 'constant': 0x20})
10950         self.__field_payloadsize.writetobuffer(buf)
10951         try: self.__field_pad
10952         except:
10953             self.__field_pad=UNKNOWN(**{'sizeinbytes': 32})
10954         self.__field_pad.writetobuffer(buf)
10955         self._bufferendoffset=buf.getcurrentoffset()
10956         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
10957 
10958 
10959     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
10960         'Reads this packet from the supplied buffer'
10961         self._bufferstartoffset=buf.getcurrentoffset()
10962         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
10963         self.__field_header=sanyomediaheader(**{'command': 0xffe1})
10964         self.__field_header.readfrombuffer(buf)
10965         self.__field_payloadsize=UINT(**{'sizeinbytes': 1, 'constant': 0x20})
10966         self.__field_payloadsize.readfrombuffer(buf)
10967         self.__field_pad=UNKNOWN(**{'sizeinbytes': 32})
10968         self.__field_pad.readfrombuffer(buf)
10969         self._bufferendoffset=buf.getcurrentoffset()
10970 
10971 
10972     def __getfield_header(self):
10973         try: self.__field_header
10974         except:
10975             self.__field_header=sanyomediaheader(**{'command': 0xffe1})
10976         return self.__field_header.getvalue()
10977 
10978     def __setfield_header(self, value):
10979         if isinstance(value,sanyomediaheader):
10980             self.__field_header=value
10981         else:
10982             self.__field_header=sanyomediaheader(value,**{'command': 0xffe1})
10983 
10984     def __delfield_header(self): del self.__field_header
10985 
10986     header=property(__getfield_header, __setfield_header, __delfield_header, None)
10987 
10988     def __getfield_payloadsize(self):
10989         try: self.__field_payloadsize
10990         except:
10991             self.__field_payloadsize=UINT(**{'sizeinbytes': 1, 'constant': 0x20})
10992         return self.__field_payloadsize.getvalue()
10993 
10994     def __setfield_payloadsize(self, value):
10995         if isinstance(value,UINT):
10996             self.__field_payloadsize=value
10997         else:
10998             self.__field_payloadsize=UINT(value,**{'sizeinbytes': 1, 'constant': 0x20})
10999 
11000     def __delfield_payloadsize(self): del self.__field_payloadsize
11001 
11002     payloadsize=property(__getfield_payloadsize, __setfield_payloadsize, __delfield_payloadsize, None)
11003 
11004     def __getfield_pad(self):
11005         try: self.__field_pad
11006         except:
11007             self.__field_pad=UNKNOWN(**{'sizeinbytes': 32})
11008         return self.__field_pad.getvalue()
11009 
11010     def __setfield_pad(self, value):
11011         if isinstance(value,UNKNOWN):
11012             self.__field_pad=value
11013         else:
11014             self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 32})
11015 
11016     def __delfield_pad(self): del self.__field_pad
11017 
11018     pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None)
11019 
11020     def iscontainer(self):
11021         return True
11022 
11023     def containerelements(self):
11024         yield ('header', self.__field_header, None)
11025         yield ('payloadsize', self.__field_payloadsize, None)
11026         yield ('pad', self.__field_pad, None)
11027 
11028 
11029 
11030 
11031 class sanyosendfileresponse(BaseProtogenClass):
11032     __fields=['header', 'payloadsize', 'pad']
11033 
11034     def __init__(self, *args, **kwargs):
11035         dict={}
11036         # What was supplied to this function
11037         dict.update(kwargs)
11038         # Parent constructor
11039         super(sanyosendfileresponse,self).__init__(**dict)
11040         if self.__class__ is sanyosendfileresponse:
11041             self._update(args,dict)
11042 
11043 
11044     def getfields(self):
11045         return self.__fields
11046 
11047 
11048     def _update(self, args, kwargs):
11049         super(sanyosendfileresponse,self)._update(args,kwargs)
11050         keys=kwargs.keys()
11051         for key in keys:
11052             if key in self.__fields:
11053                 setattr(self, key, kwargs[key])
11054                 del kwargs[key]
11055         # Were any unrecognized kwargs passed in?
11056         if __debug__:
11057             self._complainaboutunusedargs(sanyosendfileresponse,kwargs)
11058         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
11059         # Make all P fields that haven't already been constructed
11060 
11061 
11062     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
11063         'Writes this packet to the supplied buffer'
11064         self._bufferstartoffset=buf.getcurrentoffset()
11065         try: self.__field_header
11066         except:
11067             self.__field_header=sanyomediaheader()
11068         self.__field_header.writetobuffer(buf)
11069         self.__field_payloadsize.writetobuffer(buf)
11070         self.__field_pad.writetobuffer(buf)
11071         self._bufferendoffset=buf.getcurrentoffset()
11072         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
11073 
11074 
11075     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
11076         'Reads this packet from the supplied buffer'
11077         self._bufferstartoffset=buf.getcurrentoffset()
11078         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
11079         self.__field_header=sanyomediaheader()
11080         self.__field_header.readfrombuffer(buf)
11081         self.__field_payloadsize=UINT(**{'sizeinbytes': 1})
11082         self.__field_payloadsize.readfrombuffer(buf)
11083         self.__field_pad=UNKNOWN(**{'sizeinbytes': 32})
11084         self.__field_pad.readfrombuffer(buf)
11085         self._bufferendoffset=buf.getcurrentoffset()
11086 
11087 
11088     def __getfield_header(self):
11089         try: self.__field_header
11090         except:
11091             self.__field_header=sanyomediaheader()
11092         return self.__field_header.getvalue()
11093 
11094     def __setfield_header(self, value):
11095         if isinstance(value,sanyomediaheader):
11096             self.__field_header=value
11097         else:
11098             self.__field_header=sanyomediaheader(value,)
11099 
11100     def __delfield_header(self): del self.__field_header
11101 
11102     header=property(__getfield_header, __setfield_header, __delfield_header, None)
11103 
11104     def __getfield_payloadsize(self):
11105         return self.__field_payloadsize.getvalue()
11106 
11107     def __setfield_payloadsize(self, value):
11108         if isinstance(value,UINT):
11109             self.__field_payloadsize=value
11110         else:
11111             self.__field_payloadsize=UINT(value,**{'sizeinbytes': 1})
11112 
11113     def __delfield_payloadsize(self): del self.__field_payloadsize
11114 
11115     payloadsize=property(__getfield_payloadsize, __setfield_payloadsize, __delfield_payloadsize, None)
11116 
11117     def __getfield_pad(self):
11118         return self.__field_pad.getvalue()
11119 
11120     def __setfield_pad(self, value):
11121         if isinstance(value,UNKNOWN):
11122             self.__field_pad=value
11123         else:
11124             self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 32})
11125 
11126     def __delfield_pad(self): del self.__field_pad
11127 
11128     pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None)
11129 
11130     def iscontainer(self):
11131         return True
11132 
11133     def containerelements(self):
11134         yield ('header', self.__field_header, None)
11135         yield ('payloadsize', self.__field_payloadsize, None)
11136         yield ('pad', self.__field_pad, None)
11137 
11138 
11139 
11140 
11141 class study(BaseProtogenClass):
11142     __fields=['header', 'slot', 'pad']
11143 
11144     def __init__(self, *args, **kwargs):
11145         dict={}
11146         # What was supplied to this function
11147         dict.update(kwargs)
11148         # Parent constructor
11149         super(study,self).__init__(**dict)
11150         if self.__class__ is study:
11151             self._update(args,dict)
11152 
11153 
11154     def getfields(self):
11155         return self.__fields
11156 
11157 
11158     def _update(self, args, kwargs):
11159         super(study,self)._update(args,kwargs)
11160         keys=kwargs.keys()
11161         for key in keys:
11162             if key in self.__fields:
11163                 setattr(self, key, kwargs[key])
11164                 del kwargs[key]
11165         # Were any unrecognized kwargs passed in?
11166         if __debug__:
11167             self._complainaboutunusedargs(study,kwargs)
11168         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
11169         # Make all P fields that haven't already been constructed
11170 
11171 
11172     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
11173         'Writes this packet to the supplied buffer'
11174         self._bufferstartoffset=buf.getcurrentoffset()
11175         try: self.__field_header
11176         except:
11177             self.__field_header=sanyoheader()
11178         self.__field_header.writetobuffer(buf)
11179         self.__field_slot.writetobuffer(buf)
11180         try: self.__field_pad
11181         except:
11182             self.__field_pad=UNKNOWN(**{'sizeinbytes': 500})
11183         self.__field_pad.writetobuffer(buf)
11184         self._bufferendoffset=buf.getcurrentoffset()
11185         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
11186 
11187 
11188     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
11189         'Reads this packet from the supplied buffer'
11190         self._bufferstartoffset=buf.getcurrentoffset()
11191         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
11192         self.__field_header=sanyoheader()
11193         self.__field_header.readfrombuffer(buf)
11194         self.__field_slot=UINT(**{'sizeinbytes': 2})
11195         self.__field_slot.readfrombuffer(buf)
11196         self.__field_pad=UNKNOWN(**{'sizeinbytes': 500})
11197         self.__field_pad.readfrombuffer(buf)
11198         self._bufferendoffset=buf.getcurrentoffset()
11199 
11200 
11201     def __getfield_header(self):
11202         try: self.__field_header
11203         except:
11204             self.__field_header=sanyoheader()
11205         return self.__field_header.getvalue()
11206 
11207     def __setfield_header(self, value):
11208         if isinstance(value,sanyoheader):
11209             self.__field_header=value
11210         else:
11211             self.__field_header=sanyoheader(value,)
11212 
11213     def __delfield_header(self): del self.__field_header
11214 
11215     header=property(__getfield_header, __setfield_header, __delfield_header, None)
11216 
11217     def __getfield_slot(self):
11218         return self.__field_slot.getvalue()
11219 
11220     def __setfield_slot(self, value):
11221         if isinstance(value,UINT):
11222             self.__field_slot=value
11223         else:
11224             self.__field_slot=UINT(value,**{'sizeinbytes': 2})
11225 
11226     def __delfield_slot(self): del self.__field_slot
11227 
11228     slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None)
11229 
11230     def __getfield_pad(self):
11231         try: self.__field_pad
11232         except:
11233             self.__field_pad=UNKNOWN(**{'sizeinbytes': 500})
11234         return self.__field_pad.getvalue()
11235 
11236     def __setfield_pad(self, value):
11237         if isinstance(value,UNKNOWN):
11238             self.__field_pad=value
11239         else:
11240             self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 500})
11241 
11242     def __delfield_pad(self): del self.__field_pad
11243 
11244     pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None)
11245 
11246     def iscontainer(self):
11247         return True
11248 
11249     def containerelements(self):
11250         yield ('header', self.__field_header, None)
11251         yield ('slot', self.__field_slot, None)
11252         yield ('pad', self.__field_pad, None)
11253 
11254 
11255 
11256 
11257 class studyresponse(BaseProtogenClass):
11258     __fields=['header', 'data']
11259 
11260     def __init__(self, *args, **kwargs):
11261         dict={}
11262         # What was supplied to this function
11263         dict.update(kwargs)
11264         # Parent constructor
11265         super(studyresponse,self).__init__(**dict)
11266         if self.__class__ is studyresponse:
11267             self._update(args,dict)
11268 
11269 
11270     def getfields(self):
11271         return self.__fields
11272 
11273 
11274     def _update(self, args, kwargs):
11275         super(studyresponse,self)._update(args,kwargs)
11276         keys=kwargs.keys()
11277         for key in keys:
11278             if key in self.__fields:
11279                 setattr(self, key, kwargs[key])
11280                 del kwargs[key]
11281         # Were any unrecognized kwargs passed in?
11282         if __debug__:
11283             self._complainaboutunusedargs(studyresponse,kwargs)
11284         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
11285         # Make all P fields that haven't already been constructed
11286 
11287 
11288     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
11289         'Writes this packet to the supplied buffer'
11290         self._bufferstartoffset=buf.getcurrentoffset()
11291         self.__field_header.writetobuffer(buf)
11292         self.__field_data.writetobuffer(buf)
11293         self._bufferendoffset=buf.getcurrentoffset()
11294         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
11295 
11296 
11297     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
11298         'Reads this packet from the supplied buffer'
11299         self._bufferstartoffset=buf.getcurrentoffset()
11300         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
11301         self.__field_header=sanyoheader()
11302         self.__field_header.readfrombuffer(buf)
11303         self.__field_data=UNKNOWN()
11304         self.__field_data.readfrombuffer(buf)
11305         self._bufferendoffset=buf.getcurrentoffset()
11306 
11307 
11308     def __getfield_header(self):
11309         return self.__field_header.getvalue()
11310 
11311     def __setfield_header(self, value):
11312         if isinstance(value,sanyoheader):
11313             self.__field_header=value
11314         else:
11315             self.__field_header=sanyoheader(value,)
11316 
11317     def __delfield_header(self): del self.__field_header
11318 
11319     header=property(__getfield_header, __setfield_header, __delfield_header, None)
11320 
11321     def __getfield_data(self):
11322         return self.__field_data.getvalue()
11323 
11324     def __setfield_data(self, value):
11325         if isinstance(value,UNKNOWN):
11326             self.__field_data=value
11327         else:
11328             self.__field_data=UNKNOWN(value,)
11329 
11330     def __delfield_data(self): del self.__field_data
11331 
11332     data=property(__getfield_data, __setfield_data, __delfield_data, None)
11333 
11334     def iscontainer(self):
11335         return True
11336 
11337     def containerelements(self):
11338         yield ('header', self.__field_header, None)
11339         yield ('data', self.__field_data, None)
11340 
11341 
11342 
11343 
11344