PyXR

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

0001 # THIS FILE IS AUTOMATICALLY GENERATED.  EDIT THE SOURCE FILE NOT THIS ONE
0002 
0003 """Descriptions of packets specific to newer Sanyo phone like the SCP-5500"""
0004 
0005 from prototypes import *
0006 
0007 # Make all sanyo stuff available in this module as well
0008 from p_sanyo import *
0009 from p_sanyomedia import *
0010 
0011 # We use LSB for all integer like fields
0012 UINT=UINTlsb
0013 BOOL=BOOLlsb
0014 _NUMPBSLOTS=300
0015 _NUMSPEEDDIALS=8
0016 _NUMLONGNUMBERS=5
0017 _LONGPHONENUMBERLEN=30
0018 _NUMEVENTSLOTS=100
0019 _NUMCALLALARMSLOTS=15
0020  # Need to check.  Is max phone will hold 32/96 or 33/97
0021 _MAXNUMBERLEN=32
0022 _MAXEMAILLEN=96
0023 NUMMESSAGESLOTS=256
0024 class sanyofirmwarerequest(BaseProtogenClass):
0025     __fields=['fa', 'command']
0026 
0027     def __init__(self, *args, **kwargs):
0028         dict={}
0029         # What was supplied to this function
0030         dict.update(kwargs)
0031         # Parent constructor
0032         super(sanyofirmwarerequest,self).__init__(**dict)
0033         if self.__class__ is sanyofirmwarerequest:
0034             self._update(args,dict)
0035 
0036 
0037     def getfields(self):
0038         return self.__fields
0039 
0040 
0041     def _update(self, args, kwargs):
0042         super(sanyofirmwarerequest,self)._update(args,kwargs)
0043         keys=kwargs.keys()
0044         for key in keys:
0045             if key in self.__fields:
0046                 setattr(self, key, kwargs[key])
0047                 del kwargs[key]
0048         # Were any unrecognized kwargs passed in?
0049         if __debug__:
0050             self._complainaboutunusedargs(sanyofirmwarerequest,kwargs)
0051         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0052         # Make all P fields that haven't already been constructed
0053 
0054 
0055     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0056         'Writes this packet to the supplied buffer'
0057         self._bufferstartoffset=buf.getcurrentoffset()
0058         try: self.__field_fa
0059         except:
0060             self.__field_fa=UINT(**{'sizeinbytes': 1, 'constant': 0xfa})
0061         self.__field_fa.writetobuffer(buf)
0062         try: self.__field_command
0063         except:
0064             self.__field_command=UINT(**{'sizeinbytes': 2, 'constant': 0x00})
0065         self.__field_command.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_fa=UINT(**{'sizeinbytes': 1, 'constant': 0xfa})
0075         self.__field_fa.readfrombuffer(buf)
0076         self.__field_command=UINT(**{'sizeinbytes': 2, 'constant': 0x00})
0077         self.__field_command.readfrombuffer(buf)
0078         self._bufferendoffset=buf.getcurrentoffset()
0079 
0080 
0081     def __getfield_fa(self):
0082         try: self.__field_fa
0083         except:
0084             self.__field_fa=UINT(**{'sizeinbytes': 1, 'constant': 0xfa})
0085         return self.__field_fa.getvalue()
0086 
0087     def __setfield_fa(self, value):
0088         if isinstance(value,UINT):
0089             self.__field_fa=value
0090         else:
0091             self.__field_fa=UINT(value,**{'sizeinbytes': 1, 'constant': 0xfa})
0092 
0093     def __delfield_fa(self): del self.__field_fa
0094 
0095     fa=property(__getfield_fa, __setfield_fa, __delfield_fa, None)
0096 
0097     def __getfield_command(self):
0098         try: self.__field_command
0099         except:
0100             self.__field_command=UINT(**{'sizeinbytes': 2, 'constant': 0x00})
0101         return self.__field_command.getvalue()
0102 
0103     def __setfield_command(self, value):
0104         if isinstance(value,UINT):
0105             self.__field_command=value
0106         else:
0107             self.__field_command=UINT(value,**{'sizeinbytes': 2, 'constant': 0x00})
0108 
0109     def __delfield_command(self): del self.__field_command
0110 
0111     command=property(__getfield_command, __setfield_command, __delfield_command, None)
0112 
0113     def iscontainer(self):
0114         return True
0115 
0116     def containerelements(self):
0117         yield ('fa', self.__field_fa, None)
0118         yield ('command', self.__field_command, None)
0119 
0120 
0121 
0122 
0123 class sanyofirmwareresponse(BaseProtogenClass):
0124     __fields=['fa', 'command', 'date1', 'time1', 'date2', 'time2', 'string1', 'dunno1', 'date3', 'dunno2', 'time3', 'dunno3', 'firmware', 'dunno4', 'phonemodel', 'pad']
0125 
0126     def __init__(self, *args, **kwargs):
0127         dict={}
0128         # What was supplied to this function
0129         dict.update(kwargs)
0130         # Parent constructor
0131         super(sanyofirmwareresponse,self).__init__(**dict)
0132         if self.__class__ is sanyofirmwareresponse:
0133             self._update(args,dict)
0134 
0135 
0136     def getfields(self):
0137         return self.__fields
0138 
0139 
0140     def _update(self, args, kwargs):
0141         super(sanyofirmwareresponse,self)._update(args,kwargs)
0142         keys=kwargs.keys()
0143         for key in keys:
0144             if key in self.__fields:
0145                 setattr(self, key, kwargs[key])
0146                 del kwargs[key]
0147         # Were any unrecognized kwargs passed in?
0148         if __debug__:
0149             self._complainaboutunusedargs(sanyofirmwareresponse,kwargs)
0150         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0151         # Make all P fields that haven't already been constructed
0152 
0153 
0154     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0155         'Writes this packet to the supplied buffer'
0156         self._bufferstartoffset=buf.getcurrentoffset()
0157         self.__field_fa.writetobuffer(buf)
0158         self.__field_command.writetobuffer(buf)
0159         self.__field_date1.writetobuffer(buf)
0160         self.__field_time1.writetobuffer(buf)
0161         self.__field_date2.writetobuffer(buf)
0162         self.__field_time2.writetobuffer(buf)
0163         self.__field_string1.writetobuffer(buf)
0164         self.__field_dunno1.writetobuffer(buf)
0165         self.__field_date3.writetobuffer(buf)
0166         self.__field_dunno2.writetobuffer(buf)
0167         self.__field_time3.writetobuffer(buf)
0168         self.__field_dunno3.writetobuffer(buf)
0169         self.__field_firmware.writetobuffer(buf)
0170         self.__field_dunno4.writetobuffer(buf)
0171         self.__field_phonemodel.writetobuffer(buf)
0172         self.__field_pad.writetobuffer(buf)
0173         self._bufferendoffset=buf.getcurrentoffset()
0174         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0175 
0176 
0177     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0178         'Reads this packet from the supplied buffer'
0179         self._bufferstartoffset=buf.getcurrentoffset()
0180         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0181         self.__field_fa=UINT(**{'sizeinbytes': 1})
0182         self.__field_fa.readfrombuffer(buf)
0183         self.__field_command=UINT(**{'sizeinbytes': 2})
0184         self.__field_command.readfrombuffer(buf)
0185         self.__field_date1=USTRING(**{'sizeinbytes': 11, 'terminator': None})
0186         self.__field_date1.readfrombuffer(buf)
0187         self.__field_time1=USTRING(**{'sizeinbytes': 8, 'terminator': None})
0188         self.__field_time1.readfrombuffer(buf)
0189         self.__field_date2=USTRING(**{'sizeinbytes': 11, 'terminator': None})
0190         self.__field_date2.readfrombuffer(buf)
0191         self.__field_time2=USTRING(**{'sizeinbytes': 8, 'terminator': None})
0192         self.__field_time2.readfrombuffer(buf)
0193         self.__field_string1=USTRING(**{'sizeinbytes': 8, 'terminator': None})
0194         self.__field_string1.readfrombuffer(buf)
0195         self.__field_dunno1=UNKNOWN(**{'sizeinbytes': 1})
0196         self.__field_dunno1.readfrombuffer(buf)
0197         self.__field_date3=USTRING(**{'sizeinbytes': 11, 'terminator': None})
0198         self.__field_date3.readfrombuffer(buf)
0199         self.__field_dunno2=UNKNOWN(**{'sizeinbytes': 1})
0200         self.__field_dunno2.readfrombuffer(buf)
0201         self.__field_time3=USTRING(**{'sizeinbytes': 8, 'terminator': None})
0202         self.__field_time3.readfrombuffer(buf)
0203         self.__field_dunno3=UNKNOWN(**{'sizeinbytes': 11})
0204         self.__field_dunno3.readfrombuffer(buf)
0205         self.__field_firmware=USTRING(**{'sizeinbytes': 10, 'terminator': None})
0206         self.__field_firmware.readfrombuffer(buf)
0207         self.__field_dunno4=UNKNOWN(**{'sizeinbytes': 7})
0208         self.__field_dunno4.readfrombuffer(buf)
0209         self.__field_phonemodel=USTRING(**{'sizeinbytes': 16, 'terminator': None})
0210         self.__field_phonemodel.readfrombuffer(buf)
0211         self.__field_pad=UNKNOWN()
0212         self.__field_pad.readfrombuffer(buf)
0213         self._bufferendoffset=buf.getcurrentoffset()
0214 
0215 
0216     def __getfield_fa(self):
0217         return self.__field_fa.getvalue()
0218 
0219     def __setfield_fa(self, value):
0220         if isinstance(value,UINT):
0221             self.__field_fa=value
0222         else:
0223             self.__field_fa=UINT(value,**{'sizeinbytes': 1})
0224 
0225     def __delfield_fa(self): del self.__field_fa
0226 
0227     fa=property(__getfield_fa, __setfield_fa, __delfield_fa, None)
0228 
0229     def __getfield_command(self):
0230         return self.__field_command.getvalue()
0231 
0232     def __setfield_command(self, value):
0233         if isinstance(value,UINT):
0234             self.__field_command=value
0235         else:
0236             self.__field_command=UINT(value,**{'sizeinbytes': 2})
0237 
0238     def __delfield_command(self): del self.__field_command
0239 
0240     command=property(__getfield_command, __setfield_command, __delfield_command, None)
0241 
0242     def __getfield_date1(self):
0243         return self.__field_date1.getvalue()
0244 
0245     def __setfield_date1(self, value):
0246         if isinstance(value,USTRING):
0247             self.__field_date1=value
0248         else:
0249             self.__field_date1=USTRING(value,**{'sizeinbytes': 11, 'terminator': None})
0250 
0251     def __delfield_date1(self): del self.__field_date1
0252 
0253     date1=property(__getfield_date1, __setfield_date1, __delfield_date1, None)
0254 
0255     def __getfield_time1(self):
0256         return self.__field_time1.getvalue()
0257 
0258     def __setfield_time1(self, value):
0259         if isinstance(value,USTRING):
0260             self.__field_time1=value
0261         else:
0262             self.__field_time1=USTRING(value,**{'sizeinbytes': 8, 'terminator': None})
0263 
0264     def __delfield_time1(self): del self.__field_time1
0265 
0266     time1=property(__getfield_time1, __setfield_time1, __delfield_time1, None)
0267 
0268     def __getfield_date2(self):
0269         return self.__field_date2.getvalue()
0270 
0271     def __setfield_date2(self, value):
0272         if isinstance(value,USTRING):
0273             self.__field_date2=value
0274         else:
0275             self.__field_date2=USTRING(value,**{'sizeinbytes': 11, 'terminator': None})
0276 
0277     def __delfield_date2(self): del self.__field_date2
0278 
0279     date2=property(__getfield_date2, __setfield_date2, __delfield_date2, None)
0280 
0281     def __getfield_time2(self):
0282         return self.__field_time2.getvalue()
0283 
0284     def __setfield_time2(self, value):
0285         if isinstance(value,USTRING):
0286             self.__field_time2=value
0287         else:
0288             self.__field_time2=USTRING(value,**{'sizeinbytes': 8, 'terminator': None})
0289 
0290     def __delfield_time2(self): del self.__field_time2
0291 
0292     time2=property(__getfield_time2, __setfield_time2, __delfield_time2, None)
0293 
0294     def __getfield_string1(self):
0295         return self.__field_string1.getvalue()
0296 
0297     def __setfield_string1(self, value):
0298         if isinstance(value,USTRING):
0299             self.__field_string1=value
0300         else:
0301             self.__field_string1=USTRING(value,**{'sizeinbytes': 8, 'terminator': None})
0302 
0303     def __delfield_string1(self): del self.__field_string1
0304 
0305     string1=property(__getfield_string1, __setfield_string1, __delfield_string1, None)
0306 
0307     def __getfield_dunno1(self):
0308         return self.__field_dunno1.getvalue()
0309 
0310     def __setfield_dunno1(self, value):
0311         if isinstance(value,UNKNOWN):
0312             self.__field_dunno1=value
0313         else:
0314             self.__field_dunno1=UNKNOWN(value,**{'sizeinbytes': 1})
0315 
0316     def __delfield_dunno1(self): del self.__field_dunno1
0317 
0318     dunno1=property(__getfield_dunno1, __setfield_dunno1, __delfield_dunno1, None)
0319 
0320     def __getfield_date3(self):
0321         return self.__field_date3.getvalue()
0322 
0323     def __setfield_date3(self, value):
0324         if isinstance(value,USTRING):
0325             self.__field_date3=value
0326         else:
0327             self.__field_date3=USTRING(value,**{'sizeinbytes': 11, 'terminator': None})
0328 
0329     def __delfield_date3(self): del self.__field_date3
0330 
0331     date3=property(__getfield_date3, __setfield_date3, __delfield_date3, None)
0332 
0333     def __getfield_dunno2(self):
0334         return self.__field_dunno2.getvalue()
0335 
0336     def __setfield_dunno2(self, value):
0337         if isinstance(value,UNKNOWN):
0338             self.__field_dunno2=value
0339         else:
0340             self.__field_dunno2=UNKNOWN(value,**{'sizeinbytes': 1})
0341 
0342     def __delfield_dunno2(self): del self.__field_dunno2
0343 
0344     dunno2=property(__getfield_dunno2, __setfield_dunno2, __delfield_dunno2, None)
0345 
0346     def __getfield_time3(self):
0347         return self.__field_time3.getvalue()
0348 
0349     def __setfield_time3(self, value):
0350         if isinstance(value,USTRING):
0351             self.__field_time3=value
0352         else:
0353             self.__field_time3=USTRING(value,**{'sizeinbytes': 8, 'terminator': None})
0354 
0355     def __delfield_time3(self): del self.__field_time3
0356 
0357     time3=property(__getfield_time3, __setfield_time3, __delfield_time3, None)
0358 
0359     def __getfield_dunno3(self):
0360         return self.__field_dunno3.getvalue()
0361 
0362     def __setfield_dunno3(self, value):
0363         if isinstance(value,UNKNOWN):
0364             self.__field_dunno3=value
0365         else:
0366             self.__field_dunno3=UNKNOWN(value,**{'sizeinbytes': 11})
0367 
0368     def __delfield_dunno3(self): del self.__field_dunno3
0369 
0370     dunno3=property(__getfield_dunno3, __setfield_dunno3, __delfield_dunno3, None)
0371 
0372     def __getfield_firmware(self):
0373         return self.__field_firmware.getvalue()
0374 
0375     def __setfield_firmware(self, value):
0376         if isinstance(value,USTRING):
0377             self.__field_firmware=value
0378         else:
0379             self.__field_firmware=USTRING(value,**{'sizeinbytes': 10, 'terminator': None})
0380 
0381     def __delfield_firmware(self): del self.__field_firmware
0382 
0383     firmware=property(__getfield_firmware, __setfield_firmware, __delfield_firmware, None)
0384 
0385     def __getfield_dunno4(self):
0386         return self.__field_dunno4.getvalue()
0387 
0388     def __setfield_dunno4(self, value):
0389         if isinstance(value,UNKNOWN):
0390             self.__field_dunno4=value
0391         else:
0392             self.__field_dunno4=UNKNOWN(value,**{'sizeinbytes': 7})
0393 
0394     def __delfield_dunno4(self): del self.__field_dunno4
0395 
0396     dunno4=property(__getfield_dunno4, __setfield_dunno4, __delfield_dunno4, None)
0397 
0398     def __getfield_phonemodel(self):
0399         return self.__field_phonemodel.getvalue()
0400 
0401     def __setfield_phonemodel(self, value):
0402         if isinstance(value,USTRING):
0403             self.__field_phonemodel=value
0404         else:
0405             self.__field_phonemodel=USTRING(value,**{'sizeinbytes': 16, 'terminator': None})
0406 
0407     def __delfield_phonemodel(self): del self.__field_phonemodel
0408 
0409     phonemodel=property(__getfield_phonemodel, __setfield_phonemodel, __delfield_phonemodel, None)
0410 
0411     def __getfield_pad(self):
0412         return self.__field_pad.getvalue()
0413 
0414     def __setfield_pad(self, value):
0415         if isinstance(value,UNKNOWN):
0416             self.__field_pad=value
0417         else:
0418             self.__field_pad=UNKNOWN(value,)
0419 
0420     def __delfield_pad(self): del self.__field_pad
0421 
0422     pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None)
0423 
0424     def iscontainer(self):
0425         return True
0426 
0427     def containerelements(self):
0428         yield ('fa', self.__field_fa, None)
0429         yield ('command', self.__field_command, None)
0430         yield ('date1', self.__field_date1, None)
0431         yield ('time1', self.__field_time1, None)
0432         yield ('date2', self.__field_date2, None)
0433         yield ('time2', self.__field_time2, None)
0434         yield ('string1', self.__field_string1, None)
0435         yield ('dunno1', self.__field_dunno1, None)
0436         yield ('date3', self.__field_date3, None)
0437         yield ('dunno2', self.__field_dunno2, None)
0438         yield ('time3', self.__field_time3, None)
0439         yield ('dunno3', self.__field_dunno3, None)
0440         yield ('firmware', self.__field_firmware, None)
0441         yield ('dunno4', self.__field_dunno4, None)
0442         yield ('phonemodel', self.__field_phonemodel, None)
0443         yield ('pad', self.__field_pad, None)
0444 
0445 
0446 
0447 
0448 class sanyofaheader(BaseProtogenClass):
0449     __fields=['fa', 'faset']
0450 
0451     def __init__(self, *args, **kwargs):
0452         dict={}
0453         # What was supplied to this function
0454         dict.update(kwargs)
0455         # Parent constructor
0456         super(sanyofaheader,self).__init__(**dict)
0457         if self.__class__ is sanyofaheader:
0458             self._update(args,dict)
0459 
0460 
0461     def getfields(self):
0462         return self.__fields
0463 
0464 
0465     def _update(self, args, kwargs):
0466         super(sanyofaheader,self)._update(args,kwargs)
0467         keys=kwargs.keys()
0468         for key in keys:
0469             if key in self.__fields:
0470                 setattr(self, key, kwargs[key])
0471                 del kwargs[key]
0472         # Were any unrecognized kwargs passed in?
0473         if __debug__:
0474             self._complainaboutunusedargs(sanyofaheader,kwargs)
0475         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0476         # Make all P fields that haven't already been constructed
0477 
0478 
0479     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0480         'Writes this packet to the supplied buffer'
0481         self._bufferstartoffset=buf.getcurrentoffset()
0482         try: self.__field_fa
0483         except:
0484             self.__field_fa=UINT(**{'sizeinbytes': 2, 'constant': 0x00fa})
0485         self.__field_fa.writetobuffer(buf)
0486         self.__field_faset.writetobuffer(buf)
0487         self._bufferendoffset=buf.getcurrentoffset()
0488         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0489 
0490 
0491     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0492         'Reads this packet from the supplied buffer'
0493         self._bufferstartoffset=buf.getcurrentoffset()
0494         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0495         self.__field_fa=UINT(**{'sizeinbytes': 2, 'constant': 0x00fa})
0496         self.__field_fa.readfrombuffer(buf)
0497         self.__field_faset=UINT(**{'sizeinbytes': 1})
0498         self.__field_faset.readfrombuffer(buf)
0499         self._bufferendoffset=buf.getcurrentoffset()
0500 
0501 
0502     def __getfield_fa(self):
0503         try: self.__field_fa
0504         except:
0505             self.__field_fa=UINT(**{'sizeinbytes': 2, 'constant': 0x00fa})
0506         return self.__field_fa.getvalue()
0507 
0508     def __setfield_fa(self, value):
0509         if isinstance(value,UINT):
0510             self.__field_fa=value
0511         else:
0512             self.__field_fa=UINT(value,**{'sizeinbytes': 2, 'constant': 0x00fa})
0513 
0514     def __delfield_fa(self): del self.__field_fa
0515 
0516     fa=property(__getfield_fa, __setfield_fa, __delfield_fa, None)
0517 
0518     def __getfield_faset(self):
0519         return self.__field_faset.getvalue()
0520 
0521     def __setfield_faset(self, value):
0522         if isinstance(value,UINT):
0523             self.__field_faset=value
0524         else:
0525             self.__field_faset=UINT(value,**{'sizeinbytes': 1})
0526 
0527     def __delfield_faset(self): del self.__field_faset
0528 
0529     faset=property(__getfield_faset, __setfield_faset, __delfield_faset, None)
0530 
0531     def iscontainer(self):
0532         return True
0533 
0534     def containerelements(self):
0535         yield ('fa', self.__field_fa, None)
0536         yield ('faset', self.__field_faset, None)
0537 
0538 
0539 
0540 
0541 class sanyoheader(BaseProtogenClass):
0542     __fields=['preamble', 'command', 'packettype']
0543 
0544     def __init__(self, *args, **kwargs):
0545         dict={}
0546         # What was supplied to this function
0547         dict.update(kwargs)
0548         # Parent constructor
0549         super(sanyoheader,self).__init__(**dict)
0550         if self.__class__ is sanyoheader:
0551             self._update(args,dict)
0552 
0553 
0554     def getfields(self):
0555         return self.__fields
0556 
0557 
0558     def _update(self, args, kwargs):
0559         super(sanyoheader,self)._update(args,kwargs)
0560         keys=kwargs.keys()
0561         for key in keys:
0562             if key in self.__fields:
0563                 setattr(self, key, kwargs[key])
0564                 del kwargs[key]
0565         # Were any unrecognized kwargs passed in?
0566         if __debug__:
0567             self._complainaboutunusedargs(sanyoheader,kwargs)
0568         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0569         # Make all P fields that haven't already been constructed
0570 
0571 
0572     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0573         'Writes this packet to the supplied buffer'
0574         self._bufferstartoffset=buf.getcurrentoffset()
0575         try: self.__field_preamble
0576         except:
0577             self.__field_preamble=sanyofaheader(**{'faset': 0x02})
0578         self.__field_preamble.writetobuffer(buf)
0579         self.__field_command.writetobuffer(buf)
0580         self.__field_packettype.writetobuffer(buf)
0581         self._bufferendoffset=buf.getcurrentoffset()
0582         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0583 
0584 
0585     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0586         'Reads this packet from the supplied buffer'
0587         self._bufferstartoffset=buf.getcurrentoffset()
0588         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0589         self.__field_preamble=sanyofaheader(**{'faset': 0x02})
0590         self.__field_preamble.readfrombuffer(buf)
0591         self.__field_command=UINT(**{'sizeinbytes': 1})
0592         self.__field_command.readfrombuffer(buf)
0593         self.__field_packettype=UINT(**{'sizeinbytes': 1})
0594         self.__field_packettype.readfrombuffer(buf)
0595         self._bufferendoffset=buf.getcurrentoffset()
0596 
0597 
0598     def __getfield_preamble(self):
0599         try: self.__field_preamble
0600         except:
0601             self.__field_preamble=sanyofaheader(**{'faset': 0x02})
0602         return self.__field_preamble.getvalue()
0603 
0604     def __setfield_preamble(self, value):
0605         if isinstance(value,sanyofaheader):
0606             self.__field_preamble=value
0607         else:
0608             self.__field_preamble=sanyofaheader(value,**{'faset': 0x02})
0609 
0610     def __delfield_preamble(self): del self.__field_preamble
0611 
0612     preamble=property(__getfield_preamble, __setfield_preamble, __delfield_preamble, None)
0613 
0614     def __getfield_command(self):
0615         return self.__field_command.getvalue()
0616 
0617     def __setfield_command(self, value):
0618         if isinstance(value,UINT):
0619             self.__field_command=value
0620         else:
0621             self.__field_command=UINT(value,**{'sizeinbytes': 1})
0622 
0623     def __delfield_command(self): del self.__field_command
0624 
0625     command=property(__getfield_command, __setfield_command, __delfield_command, None)
0626 
0627     def __getfield_packettype(self):
0628         return self.__field_packettype.getvalue()
0629 
0630     def __setfield_packettype(self, value):
0631         if isinstance(value,UINT):
0632             self.__field_packettype=value
0633         else:
0634             self.__field_packettype=UINT(value,**{'sizeinbytes': 1})
0635 
0636     def __delfield_packettype(self): del self.__field_packettype
0637 
0638     packettype=property(__getfield_packettype, __setfield_packettype, __delfield_packettype, None)
0639 
0640     def iscontainer(self):
0641         return True
0642 
0643     def containerelements(self):
0644         yield ('preamble', self.__field_preamble, None)
0645         yield ('command', self.__field_command, None)
0646         yield ('packettype', self.__field_packettype, None)
0647 
0648 
0649 
0650 
0651 class sanyowriteheader(BaseProtogenClass):
0652     __fields=['preamble', 'command', 'packettype']
0653 
0654     def __init__(self, *args, **kwargs):
0655         dict={}
0656         # What was supplied to this function
0657         dict.update(kwargs)
0658         # Parent constructor
0659         super(sanyowriteheader,self).__init__(**dict)
0660         if self.__class__ is sanyowriteheader:
0661             self._update(args,dict)
0662 
0663 
0664     def getfields(self):
0665         return self.__fields
0666 
0667 
0668     def _update(self, args, kwargs):
0669         super(sanyowriteheader,self)._update(args,kwargs)
0670         keys=kwargs.keys()
0671         for key in keys:
0672             if key in self.__fields:
0673                 setattr(self, key, kwargs[key])
0674                 del kwargs[key]
0675         # Were any unrecognized kwargs passed in?
0676         if __debug__:
0677             self._complainaboutunusedargs(sanyowriteheader,kwargs)
0678         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0679         # Make all P fields that haven't already been constructed
0680 
0681 
0682     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0683         'Writes this packet to the supplied buffer'
0684         self._bufferstartoffset=buf.getcurrentoffset()
0685         try: self.__field_preamble
0686         except:
0687             self.__field_preamble=sanyofaheader(**{'faset': 0x03})
0688         self.__field_preamble.writetobuffer(buf)
0689         self.__field_command.writetobuffer(buf)
0690         self.__field_packettype.writetobuffer(buf)
0691         self._bufferendoffset=buf.getcurrentoffset()
0692         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0693 
0694 
0695     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0696         'Reads this packet from the supplied buffer'
0697         self._bufferstartoffset=buf.getcurrentoffset()
0698         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0699         self.__field_preamble=sanyofaheader(**{'faset': 0x03})
0700         self.__field_preamble.readfrombuffer(buf)
0701         self.__field_command=UINT(**{'sizeinbytes': 1})
0702         self.__field_command.readfrombuffer(buf)
0703         self.__field_packettype=UINT(**{'sizeinbytes': 1})
0704         self.__field_packettype.readfrombuffer(buf)
0705         self._bufferendoffset=buf.getcurrentoffset()
0706 
0707 
0708     def __getfield_preamble(self):
0709         try: self.__field_preamble
0710         except:
0711             self.__field_preamble=sanyofaheader(**{'faset': 0x03})
0712         return self.__field_preamble.getvalue()
0713 
0714     def __setfield_preamble(self, value):
0715         if isinstance(value,sanyofaheader):
0716             self.__field_preamble=value
0717         else:
0718             self.__field_preamble=sanyofaheader(value,**{'faset': 0x03})
0719 
0720     def __delfield_preamble(self): del self.__field_preamble
0721 
0722     preamble=property(__getfield_preamble, __setfield_preamble, __delfield_preamble, None)
0723 
0724     def __getfield_command(self):
0725         return self.__field_command.getvalue()
0726 
0727     def __setfield_command(self, value):
0728         if isinstance(value,UINT):
0729             self.__field_command=value
0730         else:
0731             self.__field_command=UINT(value,**{'sizeinbytes': 1})
0732 
0733     def __delfield_command(self): del self.__field_command
0734 
0735     command=property(__getfield_command, __setfield_command, __delfield_command, None)
0736 
0737     def __getfield_packettype(self):
0738         return self.__field_packettype.getvalue()
0739 
0740     def __setfield_packettype(self, value):
0741         if isinstance(value,UINT):
0742             self.__field_packettype=value
0743         else:
0744             self.__field_packettype=UINT(value,**{'sizeinbytes': 1})
0745 
0746     def __delfield_packettype(self): del self.__field_packettype
0747 
0748     packettype=property(__getfield_packettype, __setfield_packettype, __delfield_packettype, None)
0749 
0750     def iscontainer(self):
0751         return True
0752 
0753     def containerelements(self):
0754         yield ('preamble', self.__field_preamble, None)
0755         yield ('command', self.__field_command, None)
0756         yield ('packettype', self.__field_packettype, None)
0757 
0758 
0759 
0760 
0761 class study(BaseProtogenClass):
0762     __fields=['header', 'slot', 'pad']
0763 
0764     def __init__(self, *args, **kwargs):
0765         dict={}
0766         # What was supplied to this function
0767         dict.update(kwargs)
0768         # Parent constructor
0769         super(study,self).__init__(**dict)
0770         if self.__class__ is study:
0771             self._update(args,dict)
0772 
0773 
0774     def getfields(self):
0775         return self.__fields
0776 
0777 
0778     def _update(self, args, kwargs):
0779         super(study,self)._update(args,kwargs)
0780         keys=kwargs.keys()
0781         for key in keys:
0782             if key in self.__fields:
0783                 setattr(self, key, kwargs[key])
0784                 del kwargs[key]
0785         # Were any unrecognized kwargs passed in?
0786         if __debug__:
0787             self._complainaboutunusedargs(study,kwargs)
0788         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0789         # Make all P fields that haven't already been constructed
0790 
0791 
0792     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0793         'Writes this packet to the supplied buffer'
0794         self._bufferstartoffset=buf.getcurrentoffset()
0795         try: self.__field_header
0796         except:
0797             self.__field_header=sanyoheader()
0798         self.__field_header.writetobuffer(buf)
0799         self.__field_slot.writetobuffer(buf)
0800         try: self.__field_pad
0801         except:
0802             self.__field_pad=UNKNOWN(**{'sizeinbytes': 1024})
0803         self.__field_pad.writetobuffer(buf)
0804         self._bufferendoffset=buf.getcurrentoffset()
0805         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0806 
0807 
0808     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0809         'Reads this packet from the supplied buffer'
0810         self._bufferstartoffset=buf.getcurrentoffset()
0811         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0812         self.__field_header=sanyoheader()
0813         self.__field_header.readfrombuffer(buf)
0814         self.__field_slot=UINT(**{'sizeinbytes': 2})
0815         self.__field_slot.readfrombuffer(buf)
0816         self.__field_pad=UNKNOWN(**{'sizeinbytes': 1024})
0817         self.__field_pad.readfrombuffer(buf)
0818         self._bufferendoffset=buf.getcurrentoffset()
0819 
0820 
0821     def __getfield_header(self):
0822         try: self.__field_header
0823         except:
0824             self.__field_header=sanyoheader()
0825         return self.__field_header.getvalue()
0826 
0827     def __setfield_header(self, value):
0828         if isinstance(value,sanyoheader):
0829             self.__field_header=value
0830         else:
0831             self.__field_header=sanyoheader(value,)
0832 
0833     def __delfield_header(self): del self.__field_header
0834 
0835     header=property(__getfield_header, __setfield_header, __delfield_header, None)
0836 
0837     def __getfield_slot(self):
0838         return self.__field_slot.getvalue()
0839 
0840     def __setfield_slot(self, value):
0841         if isinstance(value,UINT):
0842             self.__field_slot=value
0843         else:
0844             self.__field_slot=UINT(value,**{'sizeinbytes': 2})
0845 
0846     def __delfield_slot(self): del self.__field_slot
0847 
0848     slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None)
0849 
0850     def __getfield_pad(self):
0851         try: self.__field_pad
0852         except:
0853             self.__field_pad=UNKNOWN(**{'sizeinbytes': 1024})
0854         return self.__field_pad.getvalue()
0855 
0856     def __setfield_pad(self, value):
0857         if isinstance(value,UNKNOWN):
0858             self.__field_pad=value
0859         else:
0860             self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 1024})
0861 
0862     def __delfield_pad(self): del self.__field_pad
0863 
0864     pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None)
0865 
0866     def iscontainer(self):
0867         return True
0868 
0869     def containerelements(self):
0870         yield ('header', self.__field_header, None)
0871         yield ('slot', self.__field_slot, None)
0872         yield ('pad', self.__field_pad, None)
0873 
0874 
0875 
0876 
0877 class studyresponse(BaseProtogenClass):
0878     __fields=['header', 'data']
0879 
0880     def __init__(self, *args, **kwargs):
0881         dict={}
0882         # What was supplied to this function
0883         dict.update(kwargs)
0884         # Parent constructor
0885         super(studyresponse,self).__init__(**dict)
0886         if self.__class__ is studyresponse:
0887             self._update(args,dict)
0888 
0889 
0890     def getfields(self):
0891         return self.__fields
0892 
0893 
0894     def _update(self, args, kwargs):
0895         super(studyresponse,self)._update(args,kwargs)
0896         keys=kwargs.keys()
0897         for key in keys:
0898             if key in self.__fields:
0899                 setattr(self, key, kwargs[key])
0900                 del kwargs[key]
0901         # Were any unrecognized kwargs passed in?
0902         if __debug__:
0903             self._complainaboutunusedargs(studyresponse,kwargs)
0904         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0905         # Make all P fields that haven't already been constructed
0906 
0907 
0908     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0909         'Writes this packet to the supplied buffer'
0910         self._bufferstartoffset=buf.getcurrentoffset()
0911         self.__field_header.writetobuffer(buf)
0912         self.__field_data.writetobuffer(buf)
0913         self._bufferendoffset=buf.getcurrentoffset()
0914         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0915 
0916 
0917     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0918         'Reads this packet from the supplied buffer'
0919         self._bufferstartoffset=buf.getcurrentoffset()
0920         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0921         self.__field_header=sanyoheader()
0922         self.__field_header.readfrombuffer(buf)
0923         self.__field_data=UNKNOWN()
0924         self.__field_data.readfrombuffer(buf)
0925         self._bufferendoffset=buf.getcurrentoffset()
0926 
0927 
0928     def __getfield_header(self):
0929         return self.__field_header.getvalue()
0930 
0931     def __setfield_header(self, value):
0932         if isinstance(value,sanyoheader):
0933             self.__field_header=value
0934         else:
0935             self.__field_header=sanyoheader(value,)
0936 
0937     def __delfield_header(self): del self.__field_header
0938 
0939     header=property(__getfield_header, __setfield_header, __delfield_header, None)
0940 
0941     def __getfield_data(self):
0942         return self.__field_data.getvalue()
0943 
0944     def __setfield_data(self, value):
0945         if isinstance(value,UNKNOWN):
0946             self.__field_data=value
0947         else:
0948             self.__field_data=UNKNOWN(value,)
0949 
0950     def __delfield_data(self): del self.__field_data
0951 
0952     data=property(__getfield_data, __setfield_data, __delfield_data, None)
0953 
0954     def iscontainer(self):
0955         return True
0956 
0957     def containerelements(self):
0958         yield ('header', self.__field_header, None)
0959         yield ('data', self.__field_data, None)
0960 
0961 
0962 
0963 
0964 class phonebookslotrequest(BaseProtogenClass):
0965     __fields=['header', 'slot', 'pad']
0966 
0967     def __init__(self, *args, **kwargs):
0968         dict={}
0969         # What was supplied to this function
0970         dict.update(kwargs)
0971         # Parent constructor
0972         super(phonebookslotrequest,self).__init__(**dict)
0973         if self.__class__ is phonebookslotrequest:
0974             self._update(args,dict)
0975 
0976 
0977     def getfields(self):
0978         return self.__fields
0979 
0980 
0981     def _update(self, args, kwargs):
0982         super(phonebookslotrequest,self)._update(args,kwargs)
0983         keys=kwargs.keys()
0984         for key in keys:
0985             if key in self.__fields:
0986                 setattr(self, key, kwargs[key])
0987                 del kwargs[key]
0988         # Were any unrecognized kwargs passed in?
0989         if __debug__:
0990             self._complainaboutunusedargs(phonebookslotrequest,kwargs)
0991         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0992         # Make all P fields that haven't already been constructed
0993 
0994 
0995     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0996         'Writes this packet to the supplied buffer'
0997         self._bufferstartoffset=buf.getcurrentoffset()
0998         try: self.__field_header
0999         except:
1000             self.__field_header=sanyoheader(**{'packettype': 0x0c,                   'command': 0x28})
1001         self.__field_header.writetobuffer(buf)
1002         self.__field_slot.writetobuffer(buf)
1003         try: self.__field_pad
1004         except:
1005             self.__field_pad=UNKNOWN(**{'sizeinbytes': 512})
1006         self.__field_pad.writetobuffer(buf)
1007         self._bufferendoffset=buf.getcurrentoffset()
1008         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1009 
1010 
1011     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1012         'Reads this packet from the supplied buffer'
1013         self._bufferstartoffset=buf.getcurrentoffset()
1014         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1015         self.__field_header=sanyoheader(**{'packettype': 0x0c,                   'command': 0x28})
1016         self.__field_header.readfrombuffer(buf)
1017         self.__field_slot=UINT(**{'sizeinbytes': 2})
1018         self.__field_slot.readfrombuffer(buf)
1019         self.__field_pad=UNKNOWN(**{'sizeinbytes': 512})
1020         self.__field_pad.readfrombuffer(buf)
1021         self._bufferendoffset=buf.getcurrentoffset()
1022 
1023 
1024     def __getfield_header(self):
1025         try: self.__field_header
1026         except:
1027             self.__field_header=sanyoheader(**{'packettype': 0x0c,                   'command': 0x28})
1028         return self.__field_header.getvalue()
1029 
1030     def __setfield_header(self, value):
1031         if isinstance(value,sanyoheader):
1032             self.__field_header=value
1033         else:
1034             self.__field_header=sanyoheader(value,**{'packettype': 0x0c,                   'command': 0x28})
1035 
1036     def __delfield_header(self): del self.__field_header
1037 
1038     header=property(__getfield_header, __setfield_header, __delfield_header, None)
1039 
1040     def __getfield_slot(self):
1041         return self.__field_slot.getvalue()
1042 
1043     def __setfield_slot(self, value):
1044         if isinstance(value,UINT):
1045             self.__field_slot=value
1046         else:
1047             self.__field_slot=UINT(value,**{'sizeinbytes': 2})
1048 
1049     def __delfield_slot(self): del self.__field_slot
1050 
1051     slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None)
1052 
1053     def __getfield_pad(self):
1054         try: self.__field_pad
1055         except:
1056             self.__field_pad=UNKNOWN(**{'sizeinbytes': 512})
1057         return self.__field_pad.getvalue()
1058 
1059     def __setfield_pad(self, value):
1060         if isinstance(value,UNKNOWN):
1061             self.__field_pad=value
1062         else:
1063             self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 512})
1064 
1065     def __delfield_pad(self): del self.__field_pad
1066 
1067     pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None)
1068 
1069     def iscontainer(self):
1070         return True
1071 
1072     def containerelements(self):
1073         yield ('header', self.__field_header, None)
1074         yield ('slot', self.__field_slot, None)
1075         yield ('pad', self.__field_pad, None)
1076 
1077 
1078 
1079 
1080 class phonebookslotupdaterequest(BaseProtogenClass):
1081     __fields=['header', 'entry', 'pad']
1082 
1083     def __init__(self, *args, **kwargs):
1084         dict={}
1085         # What was supplied to this function
1086         dict.update(kwargs)
1087         # Parent constructor
1088         super(phonebookslotupdaterequest,self).__init__(**dict)
1089         if self.__class__ is phonebookslotupdaterequest:
1090             self._update(args,dict)
1091 
1092 
1093     def getfields(self):
1094         return self.__fields
1095 
1096 
1097     def _update(self, args, kwargs):
1098         super(phonebookslotupdaterequest,self)._update(args,kwargs)
1099         keys=kwargs.keys()
1100         for key in keys:
1101             if key in self.__fields:
1102                 setattr(self, key, kwargs[key])
1103                 del kwargs[key]
1104         # Were any unrecognized kwargs passed in?
1105         if __debug__:
1106             self._complainaboutunusedargs(phonebookslotupdaterequest,kwargs)
1107         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
1108         # Make all P fields that haven't already been constructed
1109 
1110 
1111     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1112         'Writes this packet to the supplied buffer'
1113         self._bufferstartoffset=buf.getcurrentoffset()
1114         try: self.__field_header
1115         except:
1116             self.__field_header=sanyowriteheader(**{'packettype': 0x0c, 'command': 0x28})
1117         self.__field_header.writetobuffer(buf)
1118         self.__field_entry.writetobuffer(buf)
1119         try: self.__field_pad
1120         except:
1121             self.__field_pad=UNKNOWN(**{'sizeinbytes': 569})
1122         self.__field_pad.writetobuffer(buf)
1123         self._bufferendoffset=buf.getcurrentoffset()
1124         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1125 
1126 
1127     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1128         'Reads this packet from the supplied buffer'
1129         self._bufferstartoffset=buf.getcurrentoffset()
1130         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1131         self.__field_header=sanyowriteheader(**{'packettype': 0x0c, 'command': 0x28})
1132         self.__field_header.readfrombuffer(buf)
1133         self.__field_entry=phonebookentry()
1134         self.__field_entry.readfrombuffer(buf)
1135         self.__field_pad=UNKNOWN(**{'sizeinbytes': 569})
1136         self.__field_pad.readfrombuffer(buf)
1137         self._bufferendoffset=buf.getcurrentoffset()
1138 
1139 
1140     def __getfield_header(self):
1141         try: self.__field_header
1142         except:
1143             self.__field_header=sanyowriteheader(**{'packettype': 0x0c, 'command': 0x28})
1144         return self.__field_header.getvalue()
1145 
1146     def __setfield_header(self, value):
1147         if isinstance(value,sanyowriteheader):
1148             self.__field_header=value
1149         else:
1150             self.__field_header=sanyowriteheader(value,**{'packettype': 0x0c, 'command': 0x28})
1151 
1152     def __delfield_header(self): del self.__field_header
1153 
1154     header=property(__getfield_header, __setfield_header, __delfield_header, None)
1155 
1156     def __getfield_entry(self):
1157         return self.__field_entry.getvalue()
1158 
1159     def __setfield_entry(self, value):
1160         if isinstance(value,phonebookentry):
1161             self.__field_entry=value
1162         else:
1163             self.__field_entry=phonebookentry(value,)
1164 
1165     def __delfield_entry(self): del self.__field_entry
1166 
1167     entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None)
1168 
1169     def __getfield_pad(self):
1170         try: self.__field_pad
1171         except:
1172             self.__field_pad=UNKNOWN(**{'sizeinbytes': 569})
1173         return self.__field_pad.getvalue()
1174 
1175     def __setfield_pad(self, value):
1176         if isinstance(value,UNKNOWN):
1177             self.__field_pad=value
1178         else:
1179             self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 569})
1180 
1181     def __delfield_pad(self): del self.__field_pad
1182 
1183     pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None)
1184 
1185     def iscontainer(self):
1186         return True
1187 
1188     def containerelements(self):
1189         yield ('header', self.__field_header, None)
1190         yield ('entry', self.__field_entry, None)
1191         yield ('pad', self.__field_pad, None)
1192 
1193 
1194 
1195 
1196 class phonenumber(BaseProtogenClass):
1197     __fields=['number_len', 'number']
1198 
1199     def __init__(self, *args, **kwargs):
1200         dict={}
1201         # What was supplied to this function
1202         dict.update(kwargs)
1203         # Parent constructor
1204         super(phonenumber,self).__init__(**dict)
1205         if self.__class__ is phonenumber:
1206             self._update(args,dict)
1207 
1208 
1209     def getfields(self):
1210         return self.__fields
1211 
1212 
1213     def _update(self, args, kwargs):
1214         super(phonenumber,self)._update(args,kwargs)
1215         keys=kwargs.keys()
1216         for key in keys:
1217             if key in self.__fields:
1218                 setattr(self, key, kwargs[key])
1219                 del kwargs[key]
1220         # Were any unrecognized kwargs passed in?
1221         if __debug__:
1222             self._complainaboutunusedargs(phonenumber,kwargs)
1223         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
1224         # Make all P fields that haven't already been constructed
1225 
1226 
1227     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1228         'Writes this packet to the supplied buffer'
1229         self._bufferstartoffset=buf.getcurrentoffset()
1230         try: self.__field_number_len
1231         except:
1232             self.__field_number_len=UINT(**{'sizeinbytes': 1, 'default': 0})
1233         self.__field_number_len.writetobuffer(buf)
1234         try: self.__field_number
1235         except:
1236             self.__field_number=USTRING(**{'sizeinbytes': 33, 'default': ""})
1237         self.__field_number.writetobuffer(buf)
1238         self._bufferendoffset=buf.getcurrentoffset()
1239         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1240 
1241 
1242     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1243         'Reads this packet from the supplied buffer'
1244         self._bufferstartoffset=buf.getcurrentoffset()
1245         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1246         self.__field_number_len=UINT(**{'sizeinbytes': 1, 'default': 0})
1247         self.__field_number_len.readfrombuffer(buf)
1248         self.__field_number=USTRING(**{'sizeinbytes': 33, 'default': ""})
1249         self.__field_number.readfrombuffer(buf)
1250         self._bufferendoffset=buf.getcurrentoffset()
1251 
1252 
1253     def __getfield_number_len(self):
1254         try: self.__field_number_len
1255         except:
1256             self.__field_number_len=UINT(**{'sizeinbytes': 1, 'default': 0})
1257         return self.__field_number_len.getvalue()
1258 
1259     def __setfield_number_len(self, value):
1260         if isinstance(value,UINT):
1261             self.__field_number_len=value
1262         else:
1263             self.__field_number_len=UINT(value,**{'sizeinbytes': 1, 'default': 0})
1264 
1265     def __delfield_number_len(self): del self.__field_number_len
1266 
1267     number_len=property(__getfield_number_len, __setfield_number_len, __delfield_number_len, None)
1268 
1269     def __getfield_number(self):
1270         try: self.__field_number
1271         except:
1272             self.__field_number=USTRING(**{'sizeinbytes': 33, 'default': ""})
1273         return self.__field_number.getvalue()
1274 
1275     def __setfield_number(self, value):
1276         if isinstance(value,USTRING):
1277             self.__field_number=value
1278         else:
1279             self.__field_number=USTRING(value,**{'sizeinbytes': 33, 'default': ""})
1280 
1281     def __delfield_number(self): del self.__field_number
1282 
1283     number=property(__getfield_number, __setfield_number, __delfield_number, None)
1284 
1285     def iscontainer(self):
1286         return True
1287 
1288     def containerelements(self):
1289         yield ('number_len', self.__field_number_len, None)
1290         yield ('number', self.__field_number, None)
1291 
1292 
1293 
1294 
1295 class phonebookentry(BaseProtogenClass):
1296     __fields=['slot', 'slotdup', 'name_len', 'name', 'numbers', 'email_len', 'email', 'url_len', 'url', 'defaultnum', 'secret']
1297 
1298     def __init__(self, *args, **kwargs):
1299         dict={}
1300         # What was supplied to this function
1301         dict.update(kwargs)
1302         # Parent constructor
1303         super(phonebookentry,self).__init__(**dict)
1304         if self.__class__ is phonebookentry:
1305             self._update(args,dict)
1306 
1307 
1308     def getfields(self):
1309         return self.__fields
1310 
1311 
1312     def _update(self, args, kwargs):
1313         super(phonebookentry,self)._update(args,kwargs)
1314         keys=kwargs.keys()
1315         for key in keys:
1316             if key in self.__fields:
1317                 setattr(self, key, kwargs[key])
1318                 del kwargs[key]
1319         # Were any unrecognized kwargs passed in?
1320         if __debug__:
1321             self._complainaboutunusedargs(phonebookentry,kwargs)
1322         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
1323         # Make all P fields that haven't already been constructed
1324 
1325 
1326     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1327         'Writes this packet to the supplied buffer'
1328         self._bufferstartoffset=buf.getcurrentoffset()
1329         self.__field_slot.writetobuffer(buf)
1330         self.__field_slotdup.writetobuffer(buf)
1331         self.__field_name_len.writetobuffer(buf)
1332         self.__field_name.writetobuffer(buf)
1333         try: self.__field_numbers
1334         except:
1335             self.__field_numbers=LIST(**{'length': 7, 'createdefault': True, 'elementclass': phonenumber})
1336         self.__field_numbers.writetobuffer(buf)
1337         try: self.__field_email_len
1338         except:
1339             self.__field_email_len=UINT(**{'sizeinbytes': 1})
1340         self.__field_email_len.writetobuffer(buf)
1341         try: self.__field_email
1342         except:
1343             self.__field_email=USTRING(**{'sizeinbytes': 97, 'default': ""})
1344         self.__field_email.writetobuffer(buf)
1345         try: self.__field_url_len
1346         except:
1347             self.__field_url_len=UINT(**{'sizeinbytes': 1})
1348         self.__field_url_len.writetobuffer(buf)
1349         try: self.__field_url
1350         except:
1351             self.__field_url=USTRING(**{'sizeinbytes': 97, 'default': ""})
1352         self.__field_url.writetobuffer(buf)
1353         try: self.__field_defaultnum
1354         except:
1355             self.__field_defaultnum=UINT(**{'sizeinbytes': 1, 'default': 1})
1356         self.__field_defaultnum.writetobuffer(buf)
1357         try: self.__field_secret
1358         except:
1359             self.__field_secret=BOOL(**{'sizeinbytes': 1})
1360         self.__field_secret.writetobuffer(buf)
1361         self._bufferendoffset=buf.getcurrentoffset()
1362         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1363 
1364 
1365     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1366         'Reads this packet from the supplied buffer'
1367         self._bufferstartoffset=buf.getcurrentoffset()
1368         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1369         self.__field_slot=UINT(**{'sizeinbytes': 2})
1370         self.__field_slot.readfrombuffer(buf)
1371         self.__field_slotdup=UINT(**{'sizeinbytes': 2})
1372         self.__field_slotdup.readfrombuffer(buf)
1373         self.__field_name_len=UINT(**{'sizeinbytes': 1})
1374         self.__field_name_len.readfrombuffer(buf)
1375         self.__field_name=USTRING(**{'sizeinbytes': 16, 'raiseonunterminatedread': False, 'raiseontruncate': False, 'terminator': None})
1376         self.__field_name.readfrombuffer(buf)
1377         self.__field_numbers=LIST(**{'length': 7, 'createdefault': True, 'elementclass': phonenumber})
1378         self.__field_numbers.readfrombuffer(buf)
1379         self.__field_email_len=UINT(**{'sizeinbytes': 1})
1380         self.__field_email_len.readfrombuffer(buf)
1381         self.__field_email=USTRING(**{'sizeinbytes': 97, 'default': ""})
1382         self.__field_email.readfrombuffer(buf)
1383         self.__field_url_len=UINT(**{'sizeinbytes': 1})
1384         self.__field_url_len.readfrombuffer(buf)
1385         self.__field_url=USTRING(**{'sizeinbytes': 97, 'default': ""})
1386         self.__field_url.readfrombuffer(buf)
1387         self.__field_defaultnum=UINT(**{'sizeinbytes': 1, 'default': 1})
1388         self.__field_defaultnum.readfrombuffer(buf)
1389         self.__field_secret=BOOL(**{'sizeinbytes': 1})
1390         self.__field_secret.readfrombuffer(buf)
1391         self._bufferendoffset=buf.getcurrentoffset()
1392 
1393 
1394     def __getfield_slot(self):
1395         return self.__field_slot.getvalue()
1396 
1397     def __setfield_slot(self, value):
1398         if isinstance(value,UINT):
1399             self.__field_slot=value
1400         else:
1401             self.__field_slot=UINT(value,**{'sizeinbytes': 2})
1402 
1403     def __delfield_slot(self): del self.__field_slot
1404 
1405     slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None)
1406 
1407     def __getfield_slotdup(self):
1408         return self.__field_slotdup.getvalue()
1409 
1410     def __setfield_slotdup(self, value):
1411         if isinstance(value,UINT):
1412             self.__field_slotdup=value
1413         else:
1414             self.__field_slotdup=UINT(value,**{'sizeinbytes': 2})
1415 
1416     def __delfield_slotdup(self): del self.__field_slotdup
1417 
1418     slotdup=property(__getfield_slotdup, __setfield_slotdup, __delfield_slotdup, None)
1419 
1420     def __getfield_name_len(self):
1421         return self.__field_name_len.getvalue()
1422 
1423     def __setfield_name_len(self, value):
1424         if isinstance(value,UINT):
1425             self.__field_name_len=value
1426         else:
1427             self.__field_name_len=UINT(value,**{'sizeinbytes': 1})
1428 
1429     def __delfield_name_len(self): del self.__field_name_len
1430 
1431     name_len=property(__getfield_name_len, __setfield_name_len, __delfield_name_len, None)
1432 
1433     def __getfield_name(self):
1434         return self.__field_name.getvalue()
1435 
1436     def __setfield_name(self, value):
1437         if isinstance(value,USTRING):
1438             self.__field_name=value
1439         else:
1440             self.__field_name=USTRING(value,**{'sizeinbytes': 16, 'raiseonunterminatedread': False, 'raiseontruncate': False, 'terminator': None})
1441 
1442     def __delfield_name(self): del self.__field_name
1443 
1444     name=property(__getfield_name, __setfield_name, __delfield_name, None)
1445 
1446     def __getfield_numbers(self):
1447         try: self.__field_numbers
1448         except:
1449             self.__field_numbers=LIST(**{'length': 7, 'createdefault': True, 'elementclass': phonenumber})
1450         return self.__field_numbers.getvalue()
1451 
1452     def __setfield_numbers(self, value):
1453         if isinstance(value,LIST):
1454             self.__field_numbers=value
1455         else:
1456             self.__field_numbers=LIST(value,**{'length': 7, 'createdefault': True, 'elementclass': phonenumber})
1457 
1458     def __delfield_numbers(self): del self.__field_numbers
1459 
1460     numbers=property(__getfield_numbers, __setfield_numbers, __delfield_numbers, None)
1461 
1462     def __getfield_email_len(self):
1463         try: self.__field_email_len
1464         except:
1465             self.__field_email_len=UINT(**{'sizeinbytes': 1})
1466         return self.__field_email_len.getvalue()
1467 
1468     def __setfield_email_len(self, value):
1469         if isinstance(value,UINT):
1470             self.__field_email_len=value
1471         else:
1472             self.__field_email_len=UINT(value,**{'sizeinbytes': 1})
1473 
1474     def __delfield_email_len(self): del self.__field_email_len
1475 
1476     email_len=property(__getfield_email_len, __setfield_email_len, __delfield_email_len, None)
1477 
1478     def __getfield_email(self):
1479         try: self.__field_email
1480         except:
1481             self.__field_email=USTRING(**{'sizeinbytes': 97, 'default': ""})
1482         return self.__field_email.getvalue()
1483 
1484     def __setfield_email(self, value):
1485         if isinstance(value,USTRING):
1486             self.__field_email=value
1487         else:
1488             self.__field_email=USTRING(value,**{'sizeinbytes': 97, 'default': ""})
1489 
1490     def __delfield_email(self): del self.__field_email
1491 
1492     email=property(__getfield_email, __setfield_email, __delfield_email, None)
1493 
1494     def __getfield_url_len(self):
1495         try: self.__field_url_len
1496         except:
1497             self.__field_url_len=UINT(**{'sizeinbytes': 1})
1498         return self.__field_url_len.getvalue()
1499 
1500     def __setfield_url_len(self, value):
1501         if isinstance(value,UINT):
1502             self.__field_url_len=value
1503         else:
1504             self.__field_url_len=UINT(value,**{'sizeinbytes': 1})
1505 
1506     def __delfield_url_len(self): del self.__field_url_len
1507 
1508     url_len=property(__getfield_url_len, __setfield_url_len, __delfield_url_len, None)
1509 
1510     def __getfield_url(self):
1511         try: self.__field_url
1512         except:
1513             self.__field_url=USTRING(**{'sizeinbytes': 97, 'default': ""})
1514         return self.__field_url.getvalue()
1515 
1516     def __setfield_url(self, value):
1517         if isinstance(value,USTRING):
1518             self.__field_url=value
1519         else:
1520             self.__field_url=USTRING(value,**{'sizeinbytes': 97, 'default': ""})
1521 
1522     def __delfield_url(self): del self.__field_url
1523 
1524     url=property(__getfield_url, __setfield_url, __delfield_url, None)
1525 
1526     def __getfield_defaultnum(self):
1527         try: self.__field_defaultnum
1528         except:
1529             self.__field_defaultnum=UINT(**{'sizeinbytes': 1, 'default': 1})
1530         return self.__field_defaultnum.getvalue()
1531 
1532     def __setfield_defaultnum(self, value):
1533         if isinstance(value,UINT):
1534             self.__field_defaultnum=value
1535         else:
1536             self.__field_defaultnum=UINT(value,**{'sizeinbytes': 1, 'default': 1})
1537 
1538     def __delfield_defaultnum(self): del self.__field_defaultnum
1539 
1540     defaultnum=property(__getfield_defaultnum, __setfield_defaultnum, __delfield_defaultnum, None)
1541 
1542     def __getfield_secret(self):
1543         try: self.__field_secret
1544         except:
1545             self.__field_secret=BOOL(**{'sizeinbytes': 1})
1546         return self.__field_secret.getvalue()
1547 
1548     def __setfield_secret(self, value):
1549         if isinstance(value,BOOL):
1550             self.__field_secret=value
1551         else:
1552             self.__field_secret=BOOL(value,**{'sizeinbytes': 1})
1553 
1554     def __delfield_secret(self): del self.__field_secret
1555 
1556     secret=property(__getfield_secret, __setfield_secret, __delfield_secret, None)
1557 
1558     def iscontainer(self):
1559         return True
1560 
1561     def containerelements(self):
1562         yield ('slot', self.__field_slot, None)
1563         yield ('slotdup', self.__field_slotdup, None)
1564         yield ('name_len', self.__field_name_len, None)
1565         yield ('name', self.__field_name, None)
1566         yield ('numbers', self.__field_numbers, None)
1567         yield ('email_len', self.__field_email_len, None)
1568         yield ('email', self.__field_email, None)
1569         yield ('url_len', self.__field_url_len, None)
1570         yield ('url', self.__field_url, None)
1571         yield ('defaultnum', self.__field_defaultnum, None)
1572         yield ('secret', self.__field_secret, None)
1573 
1574 
1575 
1576 
1577 class phonebookslotresponse(BaseProtogenClass):
1578     __fields=['header', 'entry', 'pad']
1579 
1580     def __init__(self, *args, **kwargs):
1581         dict={}
1582         # What was supplied to this function
1583         dict.update(kwargs)
1584         # Parent constructor
1585         super(phonebookslotresponse,self).__init__(**dict)
1586         if self.__class__ is phonebookslotresponse:
1587             self._update(args,dict)
1588 
1589 
1590     def getfields(self):
1591         return self.__fields
1592 
1593 
1594     def _update(self, args, kwargs):
1595         super(phonebookslotresponse,self)._update(args,kwargs)
1596         keys=kwargs.keys()
1597         for key in keys:
1598             if key in self.__fields:
1599                 setattr(self, key, kwargs[key])
1600                 del kwargs[key]
1601         # Were any unrecognized kwargs passed in?
1602         if __debug__:
1603             self._complainaboutunusedargs(phonebookslotresponse,kwargs)
1604         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
1605         # Make all P fields that haven't already been constructed
1606 
1607 
1608     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1609         'Writes this packet to the supplied buffer'
1610         self._bufferstartoffset=buf.getcurrentoffset()
1611         self.__field_header.writetobuffer(buf)
1612         self.__field_entry.writetobuffer(buf)
1613         self.__field_pad.writetobuffer(buf)
1614         self._bufferendoffset=buf.getcurrentoffset()
1615         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1616 
1617 
1618     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1619         'Reads this packet from the supplied buffer'
1620         self._bufferstartoffset=buf.getcurrentoffset()
1621         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1622         self.__field_header=sanyoheader()
1623         self.__field_header.readfrombuffer(buf)
1624         self.__field_entry=phonebookentry()
1625         self.__field_entry.readfrombuffer(buf)
1626         self.__field_pad=UNKNOWN(**{'sizeinbytes': 57})
1627         self.__field_pad.readfrombuffer(buf)
1628         self._bufferendoffset=buf.getcurrentoffset()
1629 
1630 
1631     def __getfield_header(self):
1632         return self.__field_header.getvalue()
1633 
1634     def __setfield_header(self, value):
1635         if isinstance(value,sanyoheader):
1636             self.__field_header=value
1637         else:
1638             self.__field_header=sanyoheader(value,)
1639 
1640     def __delfield_header(self): del self.__field_header
1641 
1642     header=property(__getfield_header, __setfield_header, __delfield_header, None)
1643 
1644     def __getfield_entry(self):
1645         return self.__field_entry.getvalue()
1646 
1647     def __setfield_entry(self, value):
1648         if isinstance(value,phonebookentry):
1649             self.__field_entry=value
1650         else:
1651             self.__field_entry=phonebookentry(value,)
1652 
1653     def __delfield_entry(self): del self.__field_entry
1654 
1655     entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None)
1656 
1657     def __getfield_pad(self):
1658         return self.__field_pad.getvalue()
1659 
1660     def __setfield_pad(self, value):
1661         if isinstance(value,UNKNOWN):
1662             self.__field_pad=value
1663         else:
1664             self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 57})
1665 
1666     def __delfield_pad(self): del self.__field_pad
1667 
1668     pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None)
1669 
1670     def iscontainer(self):
1671         return True
1672 
1673     def containerelements(self):
1674         yield ('header', self.__field_header, None)
1675         yield ('entry', self.__field_entry, None)
1676         yield ('pad', self.__field_pad, None)
1677 
1678 
1679 
1680 
1681 class eventrequest(BaseProtogenClass):
1682     __fields=['header', 'slot', 'pad']
1683 
1684     def __init__(self, *args, **kwargs):
1685         dict={}
1686         # What was supplied to this function
1687         dict.update(kwargs)
1688         # Parent constructor
1689         super(eventrequest,self).__init__(**dict)
1690         if self.__class__ is eventrequest:
1691             self._update(args,dict)
1692 
1693 
1694     def getfields(self):
1695         return self.__fields
1696 
1697 
1698     def _update(self, args, kwargs):
1699         super(eventrequest,self)._update(args,kwargs)
1700         keys=kwargs.keys()
1701         for key in keys:
1702             if key in self.__fields:
1703                 setattr(self, key, kwargs[key])
1704                 del kwargs[key]
1705         # Were any unrecognized kwargs passed in?
1706         if __debug__:
1707             self._complainaboutunusedargs(eventrequest,kwargs)
1708         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
1709         # Make all P fields that haven't already been constructed
1710 
1711 
1712     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1713         'Writes this packet to the supplied buffer'
1714         self._bufferstartoffset=buf.getcurrentoffset()
1715         try: self.__field_header
1716         except:
1717             self.__field_header=sanyoheader(**{'packettype': 0x0c,                'command': 0x23})
1718         self.__field_header.writetobuffer(buf)
1719         self.__field_slot.writetobuffer(buf)
1720         try: self.__field_pad
1721         except:
1722             self.__field_pad=UNKNOWN(**{'sizeinbytes': 501})
1723         self.__field_pad.writetobuffer(buf)
1724         self._bufferendoffset=buf.getcurrentoffset()
1725         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1726 
1727 
1728     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1729         'Reads this packet from the supplied buffer'
1730         self._bufferstartoffset=buf.getcurrentoffset()
1731         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1732         self.__field_header=sanyoheader(**{'packettype': 0x0c,                'command': 0x23})
1733         self.__field_header.readfrombuffer(buf)
1734         self.__field_slot=UINT(**{'sizeinbytes': 1})
1735         self.__field_slot.readfrombuffer(buf)
1736         self.__field_pad=UNKNOWN(**{'sizeinbytes': 501})
1737         self.__field_pad.readfrombuffer(buf)
1738         self._bufferendoffset=buf.getcurrentoffset()
1739 
1740 
1741     def __getfield_header(self):
1742         try: self.__field_header
1743         except:
1744             self.__field_header=sanyoheader(**{'packettype': 0x0c,                'command': 0x23})
1745         return self.__field_header.getvalue()
1746 
1747     def __setfield_header(self, value):
1748         if isinstance(value,sanyoheader):
1749             self.__field_header=value
1750         else:
1751             self.__field_header=sanyoheader(value,**{'packettype': 0x0c,                'command': 0x23})
1752 
1753     def __delfield_header(self): del self.__field_header
1754 
1755     header=property(__getfield_header, __setfield_header, __delfield_header, None)
1756 
1757     def __getfield_slot(self):
1758         return self.__field_slot.getvalue()
1759 
1760     def __setfield_slot(self, value):
1761         if isinstance(value,UINT):
1762             self.__field_slot=value
1763         else:
1764             self.__field_slot=UINT(value,**{'sizeinbytes': 1})
1765 
1766     def __delfield_slot(self): del self.__field_slot
1767 
1768     slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None)
1769 
1770     def __getfield_pad(self):
1771         try: self.__field_pad
1772         except:
1773             self.__field_pad=UNKNOWN(**{'sizeinbytes': 501})
1774         return self.__field_pad.getvalue()
1775 
1776     def __setfield_pad(self, value):
1777         if isinstance(value,UNKNOWN):
1778             self.__field_pad=value
1779         else:
1780             self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 501})
1781 
1782     def __delfield_pad(self): del self.__field_pad
1783 
1784     pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None)
1785 
1786     def iscontainer(self):
1787         return True
1788 
1789     def containerelements(self):
1790         yield ('header', self.__field_header, None)
1791         yield ('slot', self.__field_slot, None)
1792         yield ('pad', self.__field_pad, None)
1793 
1794 
1795 
1796 
1797 class evententry(BaseProtogenClass):
1798     __fields=['slot', 'flag', 'eventname', 'pad1', 'eventname_len', 'start', 'end', 'location', 'pad2', 'location_len', 'pad3', 'alarmdiff', 'period', 'dom', 'alarm', 'serial', 'pad4', 'ringtone']
1799 
1800     def __init__(self, *args, **kwargs):
1801         dict={}
1802         # What was supplied to this function
1803         dict.update(kwargs)
1804         # Parent constructor
1805         super(evententry,self).__init__(**dict)
1806         if self.__class__ is evententry:
1807             self._update(args,dict)
1808 
1809 
1810     def getfields(self):
1811         return self.__fields
1812 
1813 
1814     def _update(self, args, kwargs):
1815         super(evententry,self)._update(args,kwargs)
1816         keys=kwargs.keys()
1817         for key in keys:
1818             if key in self.__fields:
1819                 setattr(self, key, kwargs[key])
1820                 del kwargs[key]
1821         # Were any unrecognized kwargs passed in?
1822         if __debug__:
1823             self._complainaboutunusedargs(evententry,kwargs)
1824         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
1825         # Make all P fields that haven't already been constructed
1826 
1827 
1828     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1829         'Writes this packet to the supplied buffer'
1830         self._bufferstartoffset=buf.getcurrentoffset()
1831         self.__field_slot.writetobuffer(buf)
1832         self.__field_flag.writetobuffer(buf)
1833         self.__field_eventname.writetobuffer(buf)
1834         try: self.__field_pad1
1835         except:
1836             self.__field_pad1=UNKNOWN(**{'sizeinbytes': 7})
1837         self.__field_pad1.writetobuffer(buf)
1838         self.__field_eventname_len.writetobuffer(buf)
1839         self.__field_start.writetobuffer(buf)
1840         self.__field_end.writetobuffer(buf)
1841         self.__field_location.writetobuffer(buf)
1842         try: self.__field_pad2
1843         except:
1844             self.__field_pad2=UNKNOWN(**{'sizeinbytes': 7})
1845         self.__field_pad2.writetobuffer(buf)
1846         self.__field_location_len.writetobuffer(buf)
1847         try: self.__field_pad3
1848         except:
1849             self.__field_pad3=UNKNOWN(**{'sizeinbytes': 1})
1850         self.__field_pad3.writetobuffer(buf)
1851         self.__field_alarmdiff.writetobuffer(buf)
1852         self.__field_period.writetobuffer(buf)
1853         self.__field_dom.writetobuffer(buf)
1854         self.__field_alarm.writetobuffer(buf)
1855         try: self.__field_serial
1856         except:
1857             self.__field_serial=UINT(**{'sizeinbytes': 1, 'default': 0})
1858         self.__field_serial.writetobuffer(buf)
1859         try: self.__field_pad4
1860         except:
1861             self.__field_pad4=UNKNOWN(**{'sizeinbytes': 3})
1862         self.__field_pad4.writetobuffer(buf)
1863         self.__field_ringtone.writetobuffer(buf)
1864         self._bufferendoffset=buf.getcurrentoffset()
1865         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1866 
1867 
1868     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1869         'Reads this packet from the supplied buffer'
1870         self._bufferstartoffset=buf.getcurrentoffset()
1871         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1872         self.__field_slot=UINT(**{'sizeinbytes': 1})
1873         self.__field_slot.readfrombuffer(buf)
1874         self.__field_flag=UINT(**{'sizeinbytes': 1})
1875         self.__field_flag.readfrombuffer(buf)
1876         self.__field_eventname=USTRING(**{'sizeinbytes': 14, 'raiseonunterminatedread': False, 'raiseontruncate': False, 'terminator': None})
1877         self.__field_eventname.readfrombuffer(buf)
1878         self.__field_pad1=UNKNOWN(**{'sizeinbytes': 7})
1879         self.__field_pad1.readfrombuffer(buf)
1880         self.__field_eventname_len=UINT(**{'sizeinbytes': 1})
1881         self.__field_eventname_len.readfrombuffer(buf)
1882         self.__field_start=UINT(**{'sizeinbytes': 4})
1883         self.__field_start.readfrombuffer(buf)
1884         self.__field_end=UINT(**{'sizeinbytes': 4})
1885         self.__field_end.readfrombuffer(buf)
1886         self.__field_location=USTRING(**{'sizeinbytes': 14, 'raiseonunterminatedread': False, 'raiseontruncate': False, 'terminator': None})
1887         self.__field_location.readfrombuffer(buf)
1888         self.__field_pad2=UNKNOWN(**{'sizeinbytes': 7})
1889         self.__field_pad2.readfrombuffer(buf)
1890         self.__field_location_len=UINT(**{'sizeinbytes': 1})
1891         self.__field_location_len.readfrombuffer(buf)
1892         self.__field_pad3=UNKNOWN(**{'sizeinbytes': 1})
1893         self.__field_pad3.readfrombuffer(buf)
1894         self.__field_alarmdiff=UINT(**{'sizeinbytes': 4})
1895         self.__field_alarmdiff.readfrombuffer(buf)
1896         self.__field_period=UINT(**{'sizeinbytes': 1})
1897         self.__field_period.readfrombuffer(buf)
1898         self.__field_dom=UINT(**{'sizeinbytes': 1})
1899         self.__field_dom.readfrombuffer(buf)
1900         self.__field_alarm=UINT(**{'sizeinbytes': 4})
1901         self.__field_alarm.readfrombuffer(buf)
1902         self.__field_serial=UINT(**{'sizeinbytes': 1, 'default': 0})
1903         self.__field_serial.readfrombuffer(buf)
1904         self.__field_pad4=UNKNOWN(**{'sizeinbytes': 3})
1905         self.__field_pad4.readfrombuffer(buf)
1906         self.__field_ringtone=UINT(**{'sizeinbytes': 1})
1907         self.__field_ringtone.readfrombuffer(buf)
1908         self._bufferendoffset=buf.getcurrentoffset()
1909 
1910 
1911     def __getfield_slot(self):
1912         return self.__field_slot.getvalue()
1913 
1914     def __setfield_slot(self, value):
1915         if isinstance(value,UINT):
1916             self.__field_slot=value
1917         else:
1918             self.__field_slot=UINT(value,**{'sizeinbytes': 1})
1919 
1920     def __delfield_slot(self): del self.__field_slot
1921 
1922     slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None)
1923 
1924     def __getfield_flag(self):
1925         return self.__field_flag.getvalue()
1926 
1927     def __setfield_flag(self, value):
1928         if isinstance(value,UINT):
1929             self.__field_flag=value
1930         else:
1931             self.__field_flag=UINT(value,**{'sizeinbytes': 1})
1932 
1933     def __delfield_flag(self): del self.__field_flag
1934 
1935     flag=property(__getfield_flag, __setfield_flag, __delfield_flag, "0: Not used, 1: Scheduled, 2: Already Happened")
1936 
1937     def __getfield_eventname(self):
1938         return self.__field_eventname.getvalue()
1939 
1940     def __setfield_eventname(self, value):
1941         if isinstance(value,USTRING):
1942             self.__field_eventname=value
1943         else:
1944             self.__field_eventname=USTRING(value,**{'sizeinbytes': 14, 'raiseonunterminatedread': False, 'raiseontruncate': False, 'terminator': None})
1945 
1946     def __delfield_eventname(self): del self.__field_eventname
1947 
1948     eventname=property(__getfield_eventname, __setfield_eventname, __delfield_eventname, None)
1949 
1950     def __getfield_pad1(self):
1951         try: self.__field_pad1
1952         except:
1953             self.__field_pad1=UNKNOWN(**{'sizeinbytes': 7})
1954         return self.__field_pad1.getvalue()
1955 
1956     def __setfield_pad1(self, value):
1957         if isinstance(value,UNKNOWN):
1958             self.__field_pad1=value
1959         else:
1960             self.__field_pad1=UNKNOWN(value,**{'sizeinbytes': 7})
1961 
1962     def __delfield_pad1(self): del self.__field_pad1
1963 
1964     pad1=property(__getfield_pad1, __setfield_pad1, __delfield_pad1, None)
1965 
1966     def __getfield_eventname_len(self):
1967         return self.__field_eventname_len.getvalue()
1968 
1969     def __setfield_eventname_len(self, value):
1970         if isinstance(value,UINT):
1971             self.__field_eventname_len=value
1972         else:
1973             self.__field_eventname_len=UINT(value,**{'sizeinbytes': 1})
1974 
1975     def __delfield_eventname_len(self): del self.__field_eventname_len
1976 
1977     eventname_len=property(__getfield_eventname_len, __setfield_eventname_len, __delfield_eventname_len, None)
1978 
1979     def __getfield_start(self):
1980         return self.__field_start.getvalue()
1981 
1982     def __setfield_start(self, value):
1983         if isinstance(value,UINT):
1984             self.__field_start=value
1985         else:
1986             self.__field_start=UINT(value,**{'sizeinbytes': 4})
1987 
1988     def __delfield_start(self): del self.__field_start
1989 
1990     start=property(__getfield_start, __setfield_start, __delfield_start, "# seconds since Jan 1, 1980 approximately")
1991 
1992     def __getfield_end(self):
1993         return self.__field_end.getvalue()
1994 
1995     def __setfield_end(self, value):
1996         if isinstance(value,UINT):
1997             self.__field_end=value
1998         else:
1999             self.__field_end=UINT(value,**{'sizeinbytes': 4})
2000 
2001     def __delfield_end(self): del self.__field_end
2002 
2003     end=property(__getfield_end, __setfield_end, __delfield_end, None)
2004 
2005     def __getfield_location(self):
2006         return self.__field_location.getvalue()
2007 
2008     def __setfield_location(self, value):
2009         if isinstance(value,USTRING):
2010             self.__field_location=value
2011         else:
2012             self.__field_location=USTRING(value,**{'sizeinbytes': 14, 'raiseonunterminatedread': False, 'raiseontruncate': False, 'terminator': None})
2013 
2014     def __delfield_location(self): del self.__field_location
2015 
2016     location=property(__getfield_location, __setfield_location, __delfield_location, None)
2017 
2018     def __getfield_pad2(self):
2019         try: self.__field_pad2
2020         except:
2021             self.__field_pad2=UNKNOWN(**{'sizeinbytes': 7})
2022         return self.__field_pad2.getvalue()
2023 
2024     def __setfield_pad2(self, value):
2025         if isinstance(value,UNKNOWN):
2026             self.__field_pad2=value
2027         else:
2028             self.__field_pad2=UNKNOWN(value,**{'sizeinbytes': 7})
2029 
2030     def __delfield_pad2(self): del self.__field_pad2
2031 
2032     pad2=property(__getfield_pad2, __setfield_pad2, __delfield_pad2, None)
2033 
2034     def __getfield_location_len(self):
2035         return self.__field_location_len.getvalue()
2036 
2037     def __setfield_location_len(self, value):
2038         if isinstance(value,UINT):
2039             self.__field_location_len=value
2040         else:
2041             self.__field_location_len=UINT(value,**{'sizeinbytes': 1})
2042 
2043     def __delfield_location_len(self): del self.__field_location_len
2044 
2045     location_len=property(__getfield_location_len, __setfield_location_len, __delfield_location_len, None)
2046 
2047     def __getfield_pad3(self):
2048         try: self.__field_pad3
2049         except:
2050             self.__field_pad3=UNKNOWN(**{'sizeinbytes': 1})
2051         return self.__field_pad3.getvalue()
2052 
2053     def __setfield_pad3(self, value):
2054         if isinstance(value,UNKNOWN):
2055             self.__field_pad3=value
2056         else:
2057             self.__field_pad3=UNKNOWN(value,**{'sizeinbytes': 1})
2058 
2059     def __delfield_pad3(self): del self.__field_pad3
2060 
2061     pad3=property(__getfield_pad3, __setfield_pad3, __delfield_pad3, None)
2062 
2063     def __getfield_alarmdiff(self):
2064         return self.__field_alarmdiff.getvalue()
2065 
2066     def __setfield_alarmdiff(self, value):
2067         if isinstance(value,UINT):
2068             self.__field_alarmdiff=value
2069         else:
2070             self.__field_alarmdiff=UINT(value,**{'sizeinbytes': 4})
2071 
2072     def __delfield_alarmdiff(self): del self.__field_alarmdiff
2073 
2074     alarmdiff=property(__getfield_alarmdiff, __setfield_alarmdiff, __delfield_alarmdiff, "Displayed alarm time")
2075 
2076     def __getfield_period(self):
2077         return self.__field_period.getvalue()
2078 
2079     def __setfield_period(self, value):
2080         if isinstance(value,UINT):
2081             self.__field_period=value
2082         else:
2083             self.__field_period=UINT(value,**{'sizeinbytes': 1})
2084 
2085     def __delfield_period(self): del self.__field_period
2086 
2087     period=property(__getfield_period, __setfield_period, __delfield_period, "No, Daily, Weekly, Monthly, Yearly")
2088 
2089     def __getfield_dom(self):
2090         return self.__field_dom.getvalue()
2091 
2092     def __setfield_dom(self, value):
2093         if isinstance(value,UINT):
2094             self.__field_dom=value
2095         else:
2096             self.__field_dom=UINT(value,**{'sizeinbytes': 1})
2097 
2098     def __delfield_dom(self): del self.__field_dom
2099 
2100     dom=property(__getfield_dom, __setfield_dom, __delfield_dom, "Day of month for the event")
2101 
2102     def __getfield_alarm(self):
2103         return self.__field_alarm.getvalue()
2104 
2105     def __setfield_alarm(self, value):
2106         if isinstance(value,UINT):
2107             self.__field_alarm=value
2108         else:
2109             self.__field_alarm=UINT(value,**{'sizeinbytes': 4})
2110 
2111     def __delfield_alarm(self): del self.__field_alarm
2112 
2113     alarm=property(__getfield_alarm, __setfield_alarm, __delfield_alarm, None)
2114 
2115     def __getfield_serial(self):
2116         try: self.__field_serial
2117         except:
2118             self.__field_serial=UINT(**{'sizeinbytes': 1, 'default': 0})
2119         return self.__field_serial.getvalue()
2120 
2121     def __setfield_serial(self, value):
2122         if isinstance(value,UINT):
2123             self.__field_serial=value
2124         else:
2125             self.__field_serial=UINT(value,**{'sizeinbytes': 1, 'default': 0})
2126 
2127     def __delfield_serial(self): del self.__field_serial
2128 
2129     serial=property(__getfield_serial, __setfield_serial, __delfield_serial, "Some kind of serial number")
2130 
2131     def __getfield_pad4(self):
2132         try: self.__field_pad4
2133         except:
2134             self.__field_pad4=UNKNOWN(**{'sizeinbytes': 3})
2135         return self.__field_pad4.getvalue()
2136 
2137     def __setfield_pad4(self, value):
2138         if isinstance(value,UNKNOWN):
2139             self.__field_pad4=value
2140         else:
2141             self.__field_pad4=UNKNOWN(value,**{'sizeinbytes': 3})
2142 
2143     def __delfield_pad4(self): del self.__field_pad4
2144 
2145     pad4=property(__getfield_pad4, __setfield_pad4, __delfield_pad4, None)
2146 
2147     def __getfield_ringtone(self):
2148         return self.__field_ringtone.getvalue()
2149 
2150     def __setfield_ringtone(self, value):
2151         if isinstance(value,UINT):
2152             self.__field_ringtone=value
2153         else:
2154             self.__field_ringtone=UINT(value,**{'sizeinbytes': 1})
2155 
2156     def __delfield_ringtone(self): del self.__field_ringtone
2157 
2158     ringtone=property(__getfield_ringtone, __setfield_ringtone, __delfield_ringtone, None)
2159 
2160     def iscontainer(self):
2161         return True
2162 
2163     def containerelements(self):
2164         yield ('slot', self.__field_slot, None)
2165         yield ('flag', self.__field_flag, "0: Not used, 1: Scheduled, 2: Already Happened")
2166         yield ('eventname', self.__field_eventname, None)
2167         yield ('pad1', self.__field_pad1, None)
2168         yield ('eventname_len', self.__field_eventname_len, None)
2169         yield ('start', self.__field_start, "# seconds since Jan 1, 1980 approximately")
2170         yield ('end', self.__field_end, None)
2171         yield ('location', self.__field_location, None)
2172         yield ('pad2', self.__field_pad2, None)
2173         yield ('location_len', self.__field_location_len, None)
2174         yield ('pad3', self.__field_pad3, None)
2175         yield ('alarmdiff', self.__field_alarmdiff, "Displayed alarm time")
2176         yield ('period', self.__field_period, "No, Daily, Weekly, Monthly, Yearly")
2177         yield ('dom', self.__field_dom, "Day of month for the event")
2178         yield ('alarm', self.__field_alarm, None)
2179         yield ('serial', self.__field_serial, "Some kind of serial number")
2180         yield ('pad4', self.__field_pad4, None)
2181         yield ('ringtone', self.__field_ringtone, None)
2182 
2183 
2184 
2185 
2186 class eventresponse(BaseProtogenClass):
2187     __fields=['header', 'entry', 'pad']
2188 
2189     def __init__(self, *args, **kwargs):
2190         dict={}
2191         # What was supplied to this function
2192         dict.update(kwargs)
2193         # Parent constructor
2194         super(eventresponse,self).__init__(**dict)
2195         if self.__class__ is eventresponse:
2196             self._update(args,dict)
2197 
2198 
2199     def getfields(self):
2200         return self.__fields
2201 
2202 
2203     def _update(self, args, kwargs):
2204         super(eventresponse,self)._update(args,kwargs)
2205         keys=kwargs.keys()
2206         for key in keys:
2207             if key in self.__fields:
2208                 setattr(self, key, kwargs[key])
2209                 del kwargs[key]
2210         # Were any unrecognized kwargs passed in?
2211         if __debug__:
2212             self._complainaboutunusedargs(eventresponse,kwargs)
2213         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
2214         # Make all P fields that haven't already been constructed
2215 
2216 
2217     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
2218         'Writes this packet to the supplied buffer'
2219         self._bufferstartoffset=buf.getcurrentoffset()
2220         self.__field_header.writetobuffer(buf)
2221         self.__field_entry.writetobuffer(buf)
2222         self.__field_pad.writetobuffer(buf)
2223         self._bufferendoffset=buf.getcurrentoffset()
2224         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
2225 
2226 
2227     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
2228         'Reads this packet from the supplied buffer'
2229         self._bufferstartoffset=buf.getcurrentoffset()
2230         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
2231         self.__field_header=sanyoheader()
2232         self.__field_header.readfrombuffer(buf)
2233         self.__field_entry=evententry()
2234         self.__field_entry.readfrombuffer(buf)
2235         self.__field_pad=UNKNOWN(**{'sizeinbytes': 436})
2236         self.__field_pad.readfrombuffer(buf)
2237         self._bufferendoffset=buf.getcurrentoffset()
2238 
2239 
2240     def __getfield_header(self):
2241         return self.__field_header.getvalue()
2242 
2243     def __setfield_header(self, value):
2244         if isinstance(value,sanyoheader):
2245             self.__field_header=value
2246         else:
2247             self.__field_header=sanyoheader(value,)
2248 
2249     def __delfield_header(self): del self.__field_header
2250 
2251     header=property(__getfield_header, __setfield_header, __delfield_header, None)
2252 
2253     def __getfield_entry(self):
2254         return self.__field_entry.getvalue()
2255 
2256     def __setfield_entry(self, value):
2257         if isinstance(value,evententry):
2258             self.__field_entry=value
2259         else:
2260             self.__field_entry=evententry(value,)
2261 
2262     def __delfield_entry(self): del self.__field_entry
2263 
2264     entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None)
2265 
2266     def __getfield_pad(self):
2267         return self.__field_pad.getvalue()
2268 
2269     def __setfield_pad(self, value):
2270         if isinstance(value,UNKNOWN):
2271             self.__field_pad=value
2272         else:
2273             self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 436})
2274 
2275     def __delfield_pad(self): del self.__field_pad
2276 
2277     pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None)
2278 
2279     def iscontainer(self):
2280         return True
2281 
2282     def containerelements(self):
2283         yield ('header', self.__field_header, None)
2284         yield ('entry', self.__field_entry, None)
2285         yield ('pad', self.__field_pad, None)
2286 
2287 
2288 
2289 
2290 class eventupdaterequest(BaseProtogenClass):
2291     __fields=['header', 'entry', 'pad']
2292 
2293     def __init__(self, *args, **kwargs):
2294         dict={}
2295         # What was supplied to this function
2296         dict.update(kwargs)
2297         # Parent constructor
2298         super(eventupdaterequest,self).__init__(**dict)
2299         if self.__class__ is eventupdaterequest:
2300             self._update(args,dict)
2301 
2302 
2303     def getfields(self):
2304         return self.__fields
2305 
2306 
2307     def _update(self, args, kwargs):
2308         super(eventupdaterequest,self)._update(args,kwargs)
2309         keys=kwargs.keys()
2310         for key in keys:
2311             if key in self.__fields:
2312                 setattr(self, key, kwargs[key])
2313                 del kwargs[key]
2314         # Were any unrecognized kwargs passed in?
2315         if __debug__:
2316             self._complainaboutunusedargs(eventupdaterequest,kwargs)
2317         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
2318         # Make all P fields that haven't already been constructed
2319 
2320 
2321     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
2322         'Writes this packet to the supplied buffer'
2323         self._bufferstartoffset=buf.getcurrentoffset()
2324         try: self.__field_header
2325         except:
2326             self.__field_header=sanyowriteheader(**{'packettype': 0x0c, 'command':0x23})
2327         self.__field_header.writetobuffer(buf)
2328         self.__field_entry.writetobuffer(buf)
2329         try: self.__field_pad
2330         except:
2331             self.__field_pad=UNKNOWN(**{'sizeinbytes': 436})
2332         self.__field_pad.writetobuffer(buf)
2333         self._bufferendoffset=buf.getcurrentoffset()
2334         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
2335 
2336 
2337     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
2338         'Reads this packet from the supplied buffer'
2339         self._bufferstartoffset=buf.getcurrentoffset()
2340         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
2341         self.__field_header=sanyowriteheader(**{'packettype': 0x0c, 'command':0x23})
2342         self.__field_header.readfrombuffer(buf)
2343         self.__field_entry=evententry()
2344         self.__field_entry.readfrombuffer(buf)
2345         self.__field_pad=UNKNOWN(**{'sizeinbytes': 436})
2346         self.__field_pad.readfrombuffer(buf)
2347         self._bufferendoffset=buf.getcurrentoffset()
2348 
2349 
2350     def __getfield_header(self):
2351         try: self.__field_header
2352         except:
2353             self.__field_header=sanyowriteheader(**{'packettype': 0x0c, 'command':0x23})
2354         return self.__field_header.getvalue()
2355 
2356     def __setfield_header(self, value):
2357         if isinstance(value,sanyowriteheader):
2358             self.__field_header=value
2359         else:
2360             self.__field_header=sanyowriteheader(value,**{'packettype': 0x0c, 'command':0x23})
2361 
2362     def __delfield_header(self): del self.__field_header
2363 
2364     header=property(__getfield_header, __setfield_header, __delfield_header, None)
2365 
2366     def __getfield_entry(self):
2367         return self.__field_entry.getvalue()
2368 
2369     def __setfield_entry(self, value):
2370         if isinstance(value,evententry):
2371             self.__field_entry=value
2372         else:
2373             self.__field_entry=evententry(value,)
2374 
2375     def __delfield_entry(self): del self.__field_entry
2376 
2377     entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None)
2378 
2379     def __getfield_pad(self):
2380         try: self.__field_pad
2381         except:
2382             self.__field_pad=UNKNOWN(**{'sizeinbytes': 436})
2383         return self.__field_pad.getvalue()
2384 
2385     def __setfield_pad(self, value):
2386         if isinstance(value,UNKNOWN):
2387             self.__field_pad=value
2388         else:
2389             self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 436})
2390 
2391     def __delfield_pad(self): del self.__field_pad
2392 
2393     pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None)
2394 
2395     def iscontainer(self):
2396         return True
2397 
2398     def containerelements(self):
2399         yield ('header', self.__field_header, None)
2400         yield ('entry', self.__field_entry, None)
2401         yield ('pad', self.__field_pad, None)
2402 
2403 
2404 
2405 
2406 class callalarmrequest(BaseProtogenClass):
2407     __fields=['header', 'slot', 'pad']
2408 
2409     def __init__(self, *args, **kwargs):
2410         dict={}
2411         # What was supplied to this function
2412         dict.update(kwargs)
2413         # Parent constructor
2414         super(callalarmrequest,self).__init__(**dict)
2415         if self.__class__ is callalarmrequest:
2416             self._update(args,dict)
2417 
2418 
2419     def getfields(self):
2420         return self.__fields
2421 
2422 
2423     def _update(self, args, kwargs):
2424         super(callalarmrequest,self)._update(args,kwargs)
2425         keys=kwargs.keys()
2426         for key in keys:
2427             if key in self.__fields:
2428                 setattr(self, key, kwargs[key])
2429                 del kwargs[key]
2430         # Were any unrecognized kwargs passed in?
2431         if __debug__:
2432             self._complainaboutunusedargs(callalarmrequest,kwargs)
2433         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
2434         # Make all P fields that haven't already been constructed
2435 
2436 
2437     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
2438         'Writes this packet to the supplied buffer'
2439         self._bufferstartoffset=buf.getcurrentoffset()
2440         try: self.__field_header
2441         except:
2442             self.__field_header=sanyoheader(**{'packettype': 0x0c,                'command': 0x24})
2443         self.__field_header.writetobuffer(buf)
2444         self.__field_slot.writetobuffer(buf)
2445         try: self.__field_pad
2446         except:
2447             self.__field_pad=UNKNOWN(**{'sizeinbytes': 501})
2448         self.__field_pad.writetobuffer(buf)
2449         self._bufferendoffset=buf.getcurrentoffset()
2450         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
2451 
2452 
2453     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
2454         'Reads this packet from the supplied buffer'
2455         self._bufferstartoffset=buf.getcurrentoffset()
2456         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
2457         self.__field_header=sanyoheader(**{'packettype': 0x0c,                'command': 0x24})
2458         self.__field_header.readfrombuffer(buf)
2459         self.__field_slot=UINT(**{'sizeinbytes': 1})
2460         self.__field_slot.readfrombuffer(buf)
2461         self.__field_pad=UNKNOWN(**{'sizeinbytes': 501})
2462         self.__field_pad.readfrombuffer(buf)
2463         self._bufferendoffset=buf.getcurrentoffset()
2464 
2465 
2466     def __getfield_header(self):
2467         try: self.__field_header
2468         except:
2469             self.__field_header=sanyoheader(**{'packettype': 0x0c,                'command': 0x24})
2470         return self.__field_header.getvalue()
2471 
2472     def __setfield_header(self, value):
2473         if isinstance(value,sanyoheader):
2474             self.__field_header=value
2475         else:
2476             self.__field_header=sanyoheader(value,**{'packettype': 0x0c,                'command': 0x24})
2477 
2478     def __delfield_header(self): del self.__field_header
2479 
2480     header=property(__getfield_header, __setfield_header, __delfield_header, None)
2481 
2482     def __getfield_slot(self):
2483         return self.__field_slot.getvalue()
2484 
2485     def __setfield_slot(self, value):
2486         if isinstance(value,UINT):
2487             self.__field_slot=value
2488         else:
2489             self.__field_slot=UINT(value,**{'sizeinbytes': 1})
2490 
2491     def __delfield_slot(self): del self.__field_slot
2492 
2493     slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None)
2494 
2495     def __getfield_pad(self):
2496         try: self.__field_pad
2497         except:
2498             self.__field_pad=UNKNOWN(**{'sizeinbytes': 501})
2499         return self.__field_pad.getvalue()
2500 
2501     def __setfield_pad(self, value):
2502         if isinstance(value,UNKNOWN):
2503             self.__field_pad=value
2504         else:
2505             self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 501})
2506 
2507     def __delfield_pad(self): del self.__field_pad
2508 
2509     pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None)
2510 
2511     def iscontainer(self):
2512         return True
2513 
2514     def containerelements(self):
2515         yield ('header', self.__field_header, None)
2516         yield ('slot', self.__field_slot, None)
2517         yield ('pad', self.__field_pad, None)
2518 
2519 
2520 
2521 
2522 class callalarmentry(BaseProtogenClass):
2523     __fields=['slot', 'flag', 'dunno1', 'phonenum', 'phonenum_len', 'date', 'period', 'dom', 'datedup', 'name', 'pad1', 'name_len', 'phonenumbertype', 'phonenumberslot', 'serial', 'pad2', 'ringtone']
2524 
2525     def __init__(self, *args, **kwargs):
2526         dict={}
2527         # What was supplied to this function
2528         dict.update(kwargs)
2529         # Parent constructor
2530         super(callalarmentry,self).__init__(**dict)
2531         if self.__class__ is callalarmentry:
2532             self._update(args,dict)
2533 
2534 
2535     def getfields(self):
2536         return self.__fields
2537 
2538 
2539     def _update(self, args, kwargs):
2540         super(callalarmentry,self)._update(args,kwargs)
2541         keys=kwargs.keys()
2542         for key in keys:
2543             if key in self.__fields:
2544                 setattr(self, key, kwargs[key])
2545                 del kwargs[key]
2546         # Were any unrecognized kwargs passed in?
2547         if __debug__:
2548             self._complainaboutunusedargs(callalarmentry,kwargs)
2549         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
2550         # Make all P fields that haven't already been constructed
2551 
2552 
2553     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
2554         'Writes this packet to the supplied buffer'
2555         self._bufferstartoffset=buf.getcurrentoffset()
2556         self.__field_slot.writetobuffer(buf)
2557         self.__field_flag.writetobuffer(buf)
2558         try: self.__field_dunno1
2559         except:
2560             self.__field_dunno1=UINT(**{'sizeinbytes': 1, 'default': 0})
2561         self.__field_dunno1.writetobuffer(buf)
2562         self.__field_phonenum.writetobuffer(buf)
2563         self.__field_phonenum_len.writetobuffer(buf)
2564         self.__field_date.writetobuffer(buf)
2565         self.__field_period.writetobuffer(buf)
2566         self.__field_dom.writetobuffer(buf)
2567         self.__field_datedup.writetobuffer(buf)
2568         self.__field_name.writetobuffer(buf)
2569         try: self.__field_pad1
2570         except:
2571             self.__field_pad1=UNKNOWN(**{'sizeinbytes': 1})
2572         self.__field_pad1.writetobuffer(buf)
2573         self.__field_name_len.writetobuffer(buf)
2574         self.__field_phonenumbertype.writetobuffer(buf)
2575         self.__field_phonenumberslot.writetobuffer(buf)
2576         try: self.__field_serial
2577         except:
2578             self.__field_serial=UINT(**{'sizeinbytes': 1, 'default': 0})
2579         self.__field_serial.writetobuffer(buf)
2580         try: self.__field_pad2
2581         except:
2582             self.__field_pad2=UNKNOWN(**{'sizeinbytes': 3})
2583         self.__field_pad2.writetobuffer(buf)
2584         self.__field_ringtone.writetobuffer(buf)
2585         self._bufferendoffset=buf.getcurrentoffset()
2586         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
2587 
2588 
2589     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
2590         'Reads this packet from the supplied buffer'
2591         self._bufferstartoffset=buf.getcurrentoffset()
2592         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
2593         self.__field_slot=UINT(**{'sizeinbytes': 1})
2594         self.__field_slot.readfrombuffer(buf)
2595         self.__field_flag=UINT(**{'sizeinbytes': 1})
2596         self.__field_flag.readfrombuffer(buf)
2597         self.__field_dunno1=UINT(**{'sizeinbytes': 1, 'default': 0})
2598         self.__field_dunno1.readfrombuffer(buf)
2599         self.__field_phonenum=USTRING(**{'sizeinbytes': 49, 'raiseonunterminatedread': False})
2600         self.__field_phonenum.readfrombuffer(buf)
2601         self.__field_phonenum_len=UINT(**{'sizeinbytes': 1})
2602         self.__field_phonenum_len.readfrombuffer(buf)
2603         self.__field_date=UINT(**{'sizeinbytes': 4})
2604         self.__field_date.readfrombuffer(buf)
2605         self.__field_period=UINT(**{'sizeinbytes': 1})
2606         self.__field_period.readfrombuffer(buf)
2607         self.__field_dom=UINT(**{'sizeinbytes': 1})
2608         self.__field_dom.readfrombuffer(buf)
2609         self.__field_datedup=UINT(**{'sizeinbytes': 4})
2610         self.__field_datedup.readfrombuffer(buf)
2611         self.__field_name=USTRING(**{'sizeinbytes': 16, 'raiseonunterminatedread': False, 'raiseontruncate': False, 'terminator': None})
2612         self.__field_name.readfrombuffer(buf)
2613         self.__field_pad1=UNKNOWN(**{'sizeinbytes': 1})
2614         self.__field_pad1.readfrombuffer(buf)
2615         self.__field_name_len=UINT(**{'sizeinbytes': 1})
2616         self.__field_name_len.readfrombuffer(buf)
2617         self.__field_phonenumbertype=UINT(**{'sizeinbytes': 1})
2618         self.__field_phonenumbertype.readfrombuffer(buf)
2619         self.__field_phonenumberslot=UINT(**{'sizeinbytes': 2})
2620         self.__field_phonenumberslot.readfrombuffer(buf)
2621         self.__field_serial=UINT(**{'sizeinbytes': 1, 'default': 0})
2622         self.__field_serial.readfrombuffer(buf)
2623         self.__field_pad2=UNKNOWN(**{'sizeinbytes': 3})
2624         self.__field_pad2.readfrombuffer(buf)
2625         self.__field_ringtone=UINT(**{'sizeinbytes': 1})
2626         self.__field_ringtone.readfrombuffer(buf)
2627         self._bufferendoffset=buf.getcurrentoffset()
2628 
2629 
2630     def __getfield_slot(self):
2631         return self.__field_slot.getvalue()
2632 
2633     def __setfield_slot(self, value):
2634         if isinstance(value,UINT):
2635             self.__field_slot=value
2636         else:
2637             self.__field_slot=UINT(value,**{'sizeinbytes': 1})
2638 
2639     def __delfield_slot(self): del self.__field_slot
2640 
2641     slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None)
2642 
2643     def __getfield_flag(self):
2644         return self.__field_flag.getvalue()
2645 
2646     def __setfield_flag(self, value):
2647         if isinstance(value,UINT):
2648             self.__field_flag=value
2649         else:
2650             self.__field_flag=UINT(value,**{'sizeinbytes': 1})
2651 
2652     def __delfield_flag(self): del self.__field_flag
2653 
2654     flag=property(__getfield_flag, __setfield_flag, __delfield_flag, "0: Not used, 1: Scheduled, 2: Already Happened")
2655 
2656     def __getfield_dunno1(self):
2657         try: self.__field_dunno1
2658         except:
2659             self.__field_dunno1=UINT(**{'sizeinbytes': 1, 'default': 0})
2660         return self.__field_dunno1.getvalue()
2661 
2662     def __setfield_dunno1(self, value):
2663         if isinstance(value,UINT):
2664             self.__field_dunno1=value
2665         else:
2666             self.__field_dunno1=UINT(value,**{'sizeinbytes': 1, 'default': 0})
2667 
2668     def __delfield_dunno1(self): del self.__field_dunno1
2669 
2670     dunno1=property(__getfield_dunno1, __setfield_dunno1, __delfield_dunno1, "Related to Snooze?")
2671 
2672     def __getfield_phonenum(self):
2673         return self.__field_phonenum.getvalue()
2674 
2675     def __setfield_phonenum(self, value):
2676         if isinstance(value,USTRING):
2677             self.__field_phonenum=value
2678         else:
2679             self.__field_phonenum=USTRING(value,**{'sizeinbytes': 49, 'raiseonunterminatedread': False})
2680 
2681     def __delfield_phonenum(self): del self.__field_phonenum
2682 
2683     phonenum=property(__getfield_phonenum, __setfield_phonenum, __delfield_phonenum, None)
2684 
2685     def __getfield_phonenum_len(self):
2686         return self.__field_phonenum_len.getvalue()
2687 
2688     def __setfield_phonenum_len(self, value):
2689         if isinstance(value,UINT):
2690             self.__field_phonenum_len=value
2691         else:
2692             self.__field_phonenum_len=UINT(value,**{'sizeinbytes': 1})
2693 
2694     def __delfield_phonenum_len(self): del self.__field_phonenum_len
2695 
2696     phonenum_len=property(__getfield_phonenum_len, __setfield_phonenum_len, __delfield_phonenum_len, None)
2697 
2698     def __getfield_date(self):
2699         return self.__field_date.getvalue()
2700 
2701     def __setfield_date(self, value):
2702         if isinstance(value,UINT):
2703             self.__field_date=value
2704         else:
2705             self.__field_date=UINT(value,**{'sizeinbytes': 4})
2706 
2707     def __delfield_date(self): del self.__field_date
2708 
2709     date=property(__getfield_date, __setfield_date, __delfield_date, "# seconds since Jan 1, 1980 approximately")
2710 
2711     def __getfield_period(self):
2712         return self.__field_period.getvalue()
2713 
2714     def __setfield_period(self, value):
2715         if isinstance(value,UINT):
2716             self.__field_period=value
2717         else:
2718             self.__field_period=UINT(value,**{'sizeinbytes': 1})
2719 
2720     def __delfield_period(self): del self.__field_period
2721 
2722     period=property(__getfield_period, __setfield_period, __delfield_period, "No, Daily, Weekly, Monthly, Yearly")
2723 
2724     def __getfield_dom(self):
2725         return self.__field_dom.getvalue()
2726 
2727     def __setfield_dom(self, value):
2728         if isinstance(value,UINT):
2729             self.__field_dom=value
2730         else:
2731             self.__field_dom=UINT(value,**{'sizeinbytes': 1})
2732 
2733     def __delfield_dom(self): del self.__field_dom
2734 
2735     dom=property(__getfield_dom, __setfield_dom, __delfield_dom, "Day of month for the event")
2736 
2737     def __getfield_datedup(self):
2738         return self.__field_datedup.getvalue()
2739 
2740     def __setfield_datedup(self, value):
2741         if isinstance(value,UINT):
2742             self.__field_datedup=value
2743         else:
2744             self.__field_datedup=UINT(value,**{'sizeinbytes': 4})
2745 
2746     def __delfield_datedup(self): del self.__field_datedup
2747 
2748     datedup=property(__getfield_datedup, __setfield_datedup, __delfield_datedup, "Copy of the date.  Always the same???")
2749 
2750     def __getfield_name(self):
2751         return self.__field_name.getvalue()
2752 
2753     def __setfield_name(self, value):
2754         if isinstance(value,USTRING):
2755             self.__field_name=value
2756         else:
2757             self.__field_name=USTRING(value,**{'sizeinbytes': 16, 'raiseonunterminatedread': False, 'raiseontruncate': False, 'terminator': None})
2758 
2759     def __delfield_name(self): del self.__field_name
2760 
2761     name=property(__getfield_name, __setfield_name, __delfield_name, None)
2762 
2763     def __getfield_pad1(self):
2764         try: self.__field_pad1
2765         except:
2766             self.__field_pad1=UNKNOWN(**{'sizeinbytes': 1})
2767         return self.__field_pad1.getvalue()
2768 
2769     def __setfield_pad1(self, value):
2770         if isinstance(value,UNKNOWN):
2771             self.__field_pad1=value
2772         else:
2773             self.__field_pad1=UNKNOWN(value,**{'sizeinbytes': 1})
2774 
2775     def __delfield_pad1(self): del self.__field_pad1
2776 
2777     pad1=property(__getfield_pad1, __setfield_pad1, __delfield_pad1, None)
2778 
2779     def __getfield_name_len(self):
2780         return self.__field_name_len.getvalue()
2781 
2782     def __setfield_name_len(self, value):
2783         if isinstance(value,UINT):
2784             self.__field_name_len=value
2785         else:
2786             self.__field_name_len=UINT(value,**{'sizeinbytes': 1})
2787 
2788     def __delfield_name_len(self): del self.__field_name_len
2789 
2790     name_len=property(__getfield_name_len, __setfield_name_len, __delfield_name_len, None)
2791 
2792     def __getfield_phonenumbertype(self):
2793         return self.__field_phonenumbertype.getvalue()
2794 
2795     def __setfield_phonenumbertype(self, value):
2796         if isinstance(value,UINT):
2797             self.__field_phonenumbertype=value
2798         else:
2799             self.__field_phonenumbertype=UINT(value,**{'sizeinbytes': 1})
2800 
2801     def __delfield_phonenumbertype(self): del self.__field_phonenumbertype
2802 
2803     phonenumbertype=property(__getfield_phonenumbertype, __setfield_phonenumbertype, __delfield_phonenumbertype, "1: Home, 2: Work, ...")
2804 
2805     def __getfield_phonenumberslot(self):
2806         return self.__field_phonenumberslot.getvalue()
2807 
2808     def __setfield_phonenumberslot(self, value):
2809         if isinstance(value,UINT):
2810             self.__field_phonenumberslot=value
2811         else:
2812             self.__field_phonenumberslot=UINT(value,**{'sizeinbytes': 2})
2813 
2814     def __delfield_phonenumberslot(self): del self.__field_phonenumberslot
2815 
2816     phonenumberslot=property(__getfield_phonenumberslot, __setfield_phonenumberslot, __delfield_phonenumberslot, None)
2817 
2818     def __getfield_serial(self):
2819         try: self.__field_serial
2820         except:
2821             self.__field_serial=UINT(**{'sizeinbytes': 1, 'default': 0})
2822         return self.__field_serial.getvalue()
2823 
2824     def __setfield_serial(self, value):
2825         if isinstance(value,UINT):
2826             self.__field_serial=value
2827         else:
2828             self.__field_serial=UINT(value,**{'sizeinbytes': 1, 'default': 0})
2829 
2830     def __delfield_serial(self): del self.__field_serial
2831 
2832     serial=property(__getfield_serial, __setfield_serial, __delfield_serial, None)
2833 
2834     def __getfield_pad2(self):
2835         try: self.__field_pad2
2836         except:
2837             self.__field_pad2=UNKNOWN(**{'sizeinbytes': 3})
2838         return self.__field_pad2.getvalue()
2839 
2840     def __setfield_pad2(self, value):
2841         if isinstance(value,UNKNOWN):
2842             self.__field_pad2=value
2843         else:
2844             self.__field_pad2=UNKNOWN(value,**{'sizeinbytes': 3})
2845 
2846     def __delfield_pad2(self): del self.__field_pad2
2847 
2848     pad2=property(__getfield_pad2, __setfield_pad2, __delfield_pad2, None)
2849 
2850     def __getfield_ringtone(self):
2851         return self.__field_ringtone.getvalue()
2852 
2853     def __setfield_ringtone(self, value):
2854         if isinstance(value,UINT):
2855             self.__field_ringtone=value
2856         else:
2857             self.__field_ringtone=UINT(value,**{'sizeinbytes': 1})
2858 
2859     def __delfield_ringtone(self): del self.__field_ringtone
2860 
2861     ringtone=property(__getfield_ringtone, __setfield_ringtone, __delfield_ringtone, None)
2862 
2863     def iscontainer(self):
2864         return True
2865 
2866     def containerelements(self):
2867         yield ('slot', self.__field_slot, None)
2868         yield ('flag', self.__field_flag, "0: Not used, 1: Scheduled, 2: Already Happened")
2869         yield ('dunno1', self.__field_dunno1, "Related to Snooze?")
2870         yield ('phonenum', self.__field_phonenum, None)
2871         yield ('phonenum_len', self.__field_phonenum_len, None)
2872         yield ('date', self.__field_date, "# seconds since Jan 1, 1980 approximately")
2873         yield ('period', self.__field_period, "No, Daily, Weekly, Monthly, Yearly")
2874         yield ('dom', self.__field_dom, "Day of month for the event")
2875         yield ('datedup', self.__field_datedup, "Copy of the date.  Always the same???")
2876         yield ('name', self.__field_name, None)
2877         yield ('pad1', self.__field_pad1, None)
2878         yield ('name_len', self.__field_name_len, None)
2879         yield ('phonenumbertype', self.__field_phonenumbertype, "1: Home, 2: Work, ...")
2880         yield ('phonenumberslot', self.__field_phonenumberslot, None)
2881         yield ('serial', self.__field_serial, None)
2882         yield ('pad2', self.__field_pad2, None)
2883         yield ('ringtone', self.__field_ringtone, None)
2884 
2885 
2886 
2887 
2888 class callalarmresponse(BaseProtogenClass):
2889     __fields=['header', 'entry', 'pad']
2890 
2891     def __init__(self, *args, **kwargs):
2892         dict={}
2893         # What was supplied to this function
2894         dict.update(kwargs)
2895         # Parent constructor
2896         super(callalarmresponse,self).__init__(**dict)
2897         if self.__class__ is callalarmresponse:
2898             self._update(args,dict)
2899 
2900 
2901     def getfields(self):
2902         return self.__fields
2903 
2904 
2905     def _update(self, args, kwargs):
2906         super(callalarmresponse,self)._update(args,kwargs)
2907         keys=kwargs.keys()
2908         for key in keys:
2909             if key in self.__fields:
2910                 setattr(self, key, kwargs[key])
2911                 del kwargs[key]
2912         # Were any unrecognized kwargs passed in?
2913         if __debug__:
2914             self._complainaboutunusedargs(callalarmresponse,kwargs)
2915         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
2916         # Make all P fields that haven't already been constructed
2917 
2918 
2919     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
2920         'Writes this packet to the supplied buffer'
2921         self._bufferstartoffset=buf.getcurrentoffset()
2922         self.__field_header.writetobuffer(buf)
2923         self.__field_entry.writetobuffer(buf)
2924         self.__field_pad.writetobuffer(buf)
2925         self._bufferendoffset=buf.getcurrentoffset()
2926         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
2927 
2928 
2929     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
2930         'Reads this packet from the supplied buffer'
2931         self._bufferstartoffset=buf.getcurrentoffset()
2932         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
2933         self.__field_header=sanyoheader()
2934         self.__field_header.readfrombuffer(buf)
2935         self.__field_entry=callalarmentry()
2936         self.__field_entry.readfrombuffer(buf)
2937         self.__field_pad=UNKNOWN(**{'sizeinbytes': 417})
2938         self.__field_pad.readfrombuffer(buf)
2939         self._bufferendoffset=buf.getcurrentoffset()
2940 
2941 
2942     def __getfield_header(self):
2943         return self.__field_header.getvalue()
2944 
2945     def __setfield_header(self, value):
2946         if isinstance(value,sanyoheader):
2947             self.__field_header=value
2948         else:
2949             self.__field_header=sanyoheader(value,)
2950 
2951     def __delfield_header(self): del self.__field_header
2952 
2953     header=property(__getfield_header, __setfield_header, __delfield_header, None)
2954 
2955     def __getfield_entry(self):
2956         return self.__field_entry.getvalue()
2957 
2958     def __setfield_entry(self, value):
2959         if isinstance(value,callalarmentry):
2960             self.__field_entry=value
2961         else:
2962             self.__field_entry=callalarmentry(value,)
2963 
2964     def __delfield_entry(self): del self.__field_entry
2965 
2966     entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None)
2967 
2968     def __getfield_pad(self):
2969         return self.__field_pad.getvalue()
2970 
2971     def __setfield_pad(self, value):
2972         if isinstance(value,UNKNOWN):
2973             self.__field_pad=value
2974         else:
2975             self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 417})
2976 
2977     def __delfield_pad(self): del self.__field_pad
2978 
2979     pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None)
2980 
2981     def iscontainer(self):
2982         return True
2983 
2984     def containerelements(self):
2985         yield ('header', self.__field_header, None)
2986         yield ('entry', self.__field_entry, None)
2987         yield ('pad', self.__field_pad, None)
2988 
2989 
2990 
2991 
2992 class callalarmupdaterequest(BaseProtogenClass):
2993     __fields=['header', 'entry', 'pad']
2994 
2995     def __init__(self, *args, **kwargs):
2996         dict={}
2997         # What was supplied to this function
2998         dict.update(kwargs)
2999         # Parent constructor
3000         super(callalarmupdaterequest,self).__init__(**dict)
3001         if self.__class__ is callalarmupdaterequest:
3002             self._update(args,dict)
3003 
3004 
3005     def getfields(self):
3006         return self.__fields
3007 
3008 
3009     def _update(self, args, kwargs):
3010         super(callalarmupdaterequest,self)._update(args,kwargs)
3011         keys=kwargs.keys()
3012         for key in keys:
3013             if key in self.__fields:
3014                 setattr(self, key, kwargs[key])
3015                 del kwargs[key]
3016         # Were any unrecognized kwargs passed in?
3017         if __debug__:
3018             self._complainaboutunusedargs(callalarmupdaterequest,kwargs)
3019         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
3020         # Make all P fields that haven't already been constructed
3021 
3022 
3023     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
3024         'Writes this packet to the supplied buffer'
3025         self._bufferstartoffset=buf.getcurrentoffset()
3026         try: self.__field_header
3027         except:
3028             self.__field_header=sanyowriteheader(**{'packettype': 0x0c, 'command':0x24})
3029         self.__field_header.writetobuffer(buf)
3030         self.__field_entry.writetobuffer(buf)
3031         try: self.__field_pad
3032         except:
3033             self.__field_pad=UNKNOWN(**{'sizeinbytes': 417})
3034         self.__field_pad.writetobuffer(buf)
3035         self._bufferendoffset=buf.getcurrentoffset()
3036         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
3037 
3038 
3039     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
3040         'Reads this packet from the supplied buffer'
3041         self._bufferstartoffset=buf.getcurrentoffset()
3042         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
3043         self.__field_header=sanyowriteheader(**{'packettype': 0x0c, 'command':0x24})
3044         self.__field_header.readfrombuffer(buf)
3045         self.__field_entry=callalarmentry()
3046         self.__field_entry.readfrombuffer(buf)
3047         self.__field_pad=UNKNOWN(**{'sizeinbytes': 417})
3048         self.__field_pad.readfrombuffer(buf)
3049         self._bufferendoffset=buf.getcurrentoffset()
3050 
3051 
3052     def __getfield_header(self):
3053         try: self.__field_header
3054         except:
3055             self.__field_header=sanyowriteheader(**{'packettype': 0x0c, 'command':0x24})
3056         return self.__field_header.getvalue()
3057 
3058     def __setfield_header(self, value):
3059         if isinstance(value,sanyowriteheader):
3060             self.__field_header=value
3061         else:
3062             self.__field_header=sanyowriteheader(value,**{'packettype': 0x0c, 'command':0x24})
3063 
3064     def __delfield_header(self): del self.__field_header
3065 
3066     header=property(__getfield_header, __setfield_header, __delfield_header, None)
3067 
3068     def __getfield_entry(self):
3069         return self.__field_entry.getvalue()
3070 
3071     def __setfield_entry(self, value):
3072         if isinstance(value,callalarmentry):
3073             self.__field_entry=value
3074         else:
3075             self.__field_entry=callalarmentry(value,)
3076 
3077     def __delfield_entry(self): del self.__field_entry
3078 
3079     entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None)
3080 
3081     def __getfield_pad(self):
3082         try: self.__field_pad
3083         except:
3084             self.__field_pad=UNKNOWN(**{'sizeinbytes': 417})
3085         return self.__field_pad.getvalue()
3086 
3087     def __setfield_pad(self, value):
3088         if isinstance(value,UNKNOWN):
3089             self.__field_pad=value
3090         else:
3091             self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 417})
3092 
3093     def __delfield_pad(self): del self.__field_pad
3094 
3095     pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None)
3096 
3097     def iscontainer(self):
3098         return True
3099 
3100     def containerelements(self):
3101         yield ('header', self.__field_header, None)
3102         yield ('entry', self.__field_entry, None)
3103         yield ('pad', self.__field_pad, None)
3104 
3105 
3106 
3107 
3108 class bufferpartrequest(BaseProtogenClass):
3109     __fields=['bufpartsize', 'header', 'pad']
3110 
3111     def __init__(self, *args, **kwargs):
3112         dict={}
3113         # What was supplied to this function
3114         dict.update(kwargs)
3115         # Parent constructor
3116         super(bufferpartrequest,self).__init__(**dict)
3117         if self.__class__ is bufferpartrequest:
3118             self._update(args,dict)
3119 
3120 
3121     def getfields(self):
3122         return self.__fields
3123 
3124 
3125     def _update(self, args, kwargs):
3126         super(bufferpartrequest,self)._update(args,kwargs)
3127         keys=kwargs.keys()
3128         for key in keys:
3129             if key in self.__fields:
3130                 setattr(self, key, kwargs[key])
3131                 del kwargs[key]
3132         # Were any unrecognized kwargs passed in?
3133         if __debug__:
3134             self._complainaboutunusedargs(bufferpartrequest,kwargs)
3135         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
3136         # Make all P fields that haven't already been constructed
3137         try: self.__field_bufpartsize
3138         except:
3139             self.__field_bufpartsize=UINT(**{'constant': 1024})
3140 
3141 
3142     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
3143         'Writes this packet to the supplied buffer'
3144         self._bufferstartoffset=buf.getcurrentoffset()
3145         try: self.__field_header
3146         except:
3147             self.__field_header=sanyoheader(**{'packettype': 0x0f})
3148         self.__field_header.writetobuffer(buf)
3149         try: self.__field_pad
3150         except:
3151             self.__field_pad=UNKNOWN(**{'sizeinbytes': 1026})
3152         self.__field_pad.writetobuffer(buf)
3153         self._bufferendoffset=buf.getcurrentoffset()
3154         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
3155 
3156 
3157     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
3158         'Reads this packet from the supplied buffer'
3159         self._bufferstartoffset=buf.getcurrentoffset()
3160         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
3161         self.__field_header=sanyoheader(**{'packettype': 0x0f})
3162         self.__field_header.readfrombuffer(buf)
3163         self.__field_pad=UNKNOWN(**{'sizeinbytes': 1026})
3164         self.__field_pad.readfrombuffer(buf)
3165         self._bufferendoffset=buf.getcurrentoffset()
3166 
3167 
3168     def __getfield_bufpartsize(self):
3169         return self.__field_bufpartsize.getvalue()
3170 
3171     def __setfield_bufpartsize(self, value):
3172         if isinstance(value,UINT):
3173             self.__field_bufpartsize=value
3174         else:
3175             self.__field_bufpartsize=UINT(value,**{'constant': 1024})
3176 
3177     def __delfield_bufpartsize(self): del self.__field_bufpartsize
3178 
3179     bufpartsize=property(__getfield_bufpartsize, __setfield_bufpartsize, __delfield_bufpartsize, None)
3180 
3181     def __getfield_header(self):
3182         try: self.__field_header
3183         except:
3184             self.__field_header=sanyoheader(**{'packettype': 0x0f})
3185         return self.__field_header.getvalue()
3186 
3187     def __setfield_header(self, value):
3188         if isinstance(value,sanyoheader):
3189             self.__field_header=value
3190         else:
3191             self.__field_header=sanyoheader(value,**{'packettype': 0x0f})
3192 
3193     def __delfield_header(self): del self.__field_header
3194 
3195     header=property(__getfield_header, __setfield_header, __delfield_header, None)
3196 
3197     def __getfield_pad(self):
3198         try: self.__field_pad
3199         except:
3200             self.__field_pad=UNKNOWN(**{'sizeinbytes': 1026})
3201         return self.__field_pad.getvalue()
3202 
3203     def __setfield_pad(self, value):
3204         if isinstance(value,UNKNOWN):
3205             self.__field_pad=value
3206         else:
3207             self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 1026})
3208 
3209     def __delfield_pad(self): del self.__field_pad
3210 
3211     pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None)
3212 
3213     def iscontainer(self):
3214         return True
3215 
3216     def containerelements(self):
3217         yield ('bufpartsize', self.__field_bufpartsize, None)
3218         yield ('header', self.__field_header, None)
3219         yield ('pad', self.__field_pad, None)
3220 
3221 
3222 
3223 
3224 class bufferpartresponse(BaseProtogenClass):
3225     __fields=['bufpartsize', 'header', 'data', 'pad']
3226 
3227     def __init__(self, *args, **kwargs):
3228         dict={}
3229         # What was supplied to this function
3230         dict.update(kwargs)
3231         # Parent constructor
3232         super(bufferpartresponse,self).__init__(**dict)
3233         if self.__class__ is bufferpartresponse:
3234             self._update(args,dict)
3235 
3236 
3237     def getfields(self):
3238         return self.__fields
3239 
3240 
3241     def _update(self, args, kwargs):
3242         super(bufferpartresponse,self)._update(args,kwargs)
3243         keys=kwargs.keys()
3244         for key in keys:
3245             if key in self.__fields:
3246                 setattr(self, key, kwargs[key])
3247                 del kwargs[key]
3248         # Were any unrecognized kwargs passed in?
3249         if __debug__:
3250             self._complainaboutunusedargs(bufferpartresponse,kwargs)
3251         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
3252         # Make all P fields that haven't already been constructed
3253         try: self.__field_bufpartsize
3254         except:
3255             self.__field_bufpartsize=UINT(**{'constant': 1024})
3256 
3257 
3258     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
3259         'Writes this packet to the supplied buffer'
3260         self._bufferstartoffset=buf.getcurrentoffset()
3261         self.__field_header.writetobuffer(buf)
3262         self.__field_data.writetobuffer(buf)
3263         self.__field_pad.writetobuffer(buf)
3264         self._bufferendoffset=buf.getcurrentoffset()
3265         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
3266 
3267 
3268     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
3269         'Reads this packet from the supplied buffer'
3270         self._bufferstartoffset=buf.getcurrentoffset()
3271         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
3272         self.__field_header=sanyoheader()
3273         self.__field_header.readfrombuffer(buf)
3274         self.__field_data=DATA(**{'sizeinbytes': self.bufpartsize})
3275         self.__field_data.readfrombuffer(buf)
3276         self.__field_pad=UNKNOWN(**{'sizeinbytes': 2})
3277         self.__field_pad.readfrombuffer(buf)
3278         self._bufferendoffset=buf.getcurrentoffset()
3279 
3280 
3281     def __getfield_bufpartsize(self):
3282         return self.__field_bufpartsize.getvalue()
3283 
3284     def __setfield_bufpartsize(self, value):
3285         if isinstance(value,UINT):
3286             self.__field_bufpartsize=value
3287         else:
3288             self.__field_bufpartsize=UINT(value,**{'constant': 1024})
3289 
3290     def __delfield_bufpartsize(self): del self.__field_bufpartsize
3291 
3292     bufpartsize=property(__getfield_bufpartsize, __setfield_bufpartsize, __delfield_bufpartsize, None)
3293 
3294     def __getfield_header(self):
3295         return self.__field_header.getvalue()
3296 
3297     def __setfield_header(self, value):
3298         if isinstance(value,sanyoheader):
3299             self.__field_header=value
3300         else:
3301             self.__field_header=sanyoheader(value,)
3302 
3303     def __delfield_header(self): del self.__field_header
3304 
3305     header=property(__getfield_header, __setfield_header, __delfield_header, None)
3306 
3307     def __getfield_data(self):
3308         return self.__field_data.getvalue()
3309 
3310     def __setfield_data(self, value):
3311         if isinstance(value,DATA):
3312             self.__field_data=value
3313         else:
3314             self.__field_data=DATA(value,**{'sizeinbytes': self.bufpartsize})
3315 
3316     def __delfield_data(self): del self.__field_data
3317 
3318     data=property(__getfield_data, __setfield_data, __delfield_data, None)
3319 
3320     def __getfield_pad(self):
3321         return self.__field_pad.getvalue()
3322 
3323     def __setfield_pad(self, value):
3324         if isinstance(value,UNKNOWN):
3325             self.__field_pad=value
3326         else:
3327             self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 2})
3328 
3329     def __delfield_pad(self): del self.__field_pad
3330 
3331     pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None)
3332 
3333     def iscontainer(self):
3334         return True
3335 
3336     def containerelements(self):
3337         yield ('bufpartsize', self.__field_bufpartsize, None)
3338         yield ('header', self.__field_header, None)
3339         yield ('data', self.__field_data, None)
3340         yield ('pad', self.__field_pad, None)
3341 
3342 
3343 
3344 
3345 class bufferpartupdaterequest(BaseProtogenClass):
3346     __fields=['bufpartsize', 'header', 'data', 'pad']
3347 
3348     def __init__(self, *args, **kwargs):
3349         dict={}
3350         # What was supplied to this function
3351         dict.update(kwargs)
3352         # Parent constructor
3353         super(bufferpartupdaterequest,self).__init__(**dict)
3354         if self.__class__ is bufferpartupdaterequest:
3355             self._update(args,dict)
3356 
3357 
3358     def getfields(self):
3359         return self.__fields
3360 
3361 
3362     def _update(self, args, kwargs):
3363         super(bufferpartupdaterequest,self)._update(args,kwargs)
3364         keys=kwargs.keys()
3365         for key in keys:
3366             if key in self.__fields:
3367                 setattr(self, key, kwargs[key])
3368                 del kwargs[key]
3369         # Were any unrecognized kwargs passed in?
3370         if __debug__:
3371             self._complainaboutunusedargs(bufferpartupdaterequest,kwargs)
3372         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
3373         # Make all P fields that haven't already been constructed
3374         try: self.__field_bufpartsize
3375         except:
3376             self.__field_bufpartsize=UINT(**{'constant': 1024})
3377 
3378 
3379     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
3380         'Writes this packet to the supplied buffer'
3381         self._bufferstartoffset=buf.getcurrentoffset()
3382         try: self.__field_header
3383         except:
3384             self.__field_header=sanyowriteheader(**{'packettype': 0x0f})
3385         self.__field_header.writetobuffer(buf)
3386         self.__field_data.writetobuffer(buf)
3387         try: self.__field_pad
3388         except:
3389             self.__field_pad=UNKNOWN(**{'sizeinbytes': 2})
3390         self.__field_pad.writetobuffer(buf)
3391         self._bufferendoffset=buf.getcurrentoffset()
3392         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
3393 
3394 
3395     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
3396         'Reads this packet from the supplied buffer'
3397         self._bufferstartoffset=buf.getcurrentoffset()
3398         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
3399         self.__field_header=sanyowriteheader(**{'packettype': 0x0f})
3400         self.__field_header.readfrombuffer(buf)
3401         self.__field_data=DATA(**{'sizeinbytes': self.bufpartsize})
3402         self.__field_data.readfrombuffer(buf)
3403         self.__field_pad=UNKNOWN(**{'sizeinbytes': 2})
3404         self.__field_pad.readfrombuffer(buf)
3405         self._bufferendoffset=buf.getcurrentoffset()
3406 
3407 
3408     def __getfield_bufpartsize(self):
3409         return self.__field_bufpartsize.getvalue()
3410 
3411     def __setfield_bufpartsize(self, value):
3412         if isinstance(value,UINT):
3413             self.__field_bufpartsize=value
3414         else:
3415             self.__field_bufpartsize=UINT(value,**{'constant': 1024})
3416 
3417     def __delfield_bufpartsize(self): del self.__field_bufpartsize
3418 
3419     bufpartsize=property(__getfield_bufpartsize, __setfield_bufpartsize, __delfield_bufpartsize, None)
3420 
3421     def __getfield_header(self):
3422         try: self.__field_header
3423         except:
3424             self.__field_header=sanyowriteheader(**{'packettype': 0x0f})
3425         return self.__field_header.getvalue()
3426 
3427     def __setfield_header(self, value):
3428         if isinstance(value,sanyowriteheader):
3429             self.__field_header=value
3430         else:
3431             self.__field_header=sanyowriteheader(value,**{'packettype': 0x0f})
3432 
3433     def __delfield_header(self): del self.__field_header
3434 
3435     header=property(__getfield_header, __setfield_header, __delfield_header, None)
3436 
3437     def __getfield_data(self):
3438         return self.__field_data.getvalue()
3439 
3440     def __setfield_data(self, value):
3441         if isinstance(value,DATA):
3442             self.__field_data=value
3443         else:
3444             self.__field_data=DATA(value,**{'sizeinbytes': self.bufpartsize})
3445 
3446     def __delfield_data(self): del self.__field_data
3447 
3448     data=property(__getfield_data, __setfield_data, __delfield_data, None)
3449 
3450     def __getfield_pad(self):
3451         try: self.__field_pad
3452         except:
3453             self.__field_pad=UNKNOWN(**{'sizeinbytes': 2})
3454         return self.__field_pad.getvalue()
3455 
3456     def __setfield_pad(self, value):
3457         if isinstance(value,UNKNOWN):
3458             self.__field_pad=value
3459         else:
3460             self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 2})
3461 
3462     def __delfield_pad(self): del self.__field_pad
3463 
3464     pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None)
3465 
3466     def iscontainer(self):
3467         return True
3468 
3469     def containerelements(self):
3470         yield ('bufpartsize', self.__field_bufpartsize, None)
3471         yield ('header', self.__field_header, None)
3472         yield ('data', self.__field_data, None)
3473         yield ('pad', self.__field_pad, None)
3474 
3475 
3476 
3477 
3478 class calleridbuffer(BaseProtogenClass):
3479     "Index so that phone can show a name instead of number"
3480     __fields=['maxentries', 'startcommand', 'bufsize', 'comment', 'numentries', 'items', 'pad']
3481 
3482     def __init__(self, *args, **kwargs):
3483         dict={}
3484         # What was supplied to this function
3485         dict.update(kwargs)
3486         # Parent constructor
3487         super(calleridbuffer,self).__init__(**dict)
3488         if self.__class__ is calleridbuffer:
3489             self._update(args,dict)
3490 
3491 
3492     def getfields(self):
3493         return self.__fields
3494 
3495 
3496     def _update(self, args, kwargs):
3497         super(calleridbuffer,self)._update(args,kwargs)
3498         keys=kwargs.keys()
3499         for key in keys:
3500             if key in self.__fields:
3501                 setattr(self, key, kwargs[key])
3502                 del kwargs[key]
3503         # Were any unrecognized kwargs passed in?
3504         if __debug__:
3505             self._complainaboutunusedargs(calleridbuffer,kwargs)
3506         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
3507         # Make all P fields that haven't already been constructed
3508         try: self.__field_maxentries
3509         except:
3510             self.__field_maxentries=UINT(**{'constant': 500})
3511         try: self.__field_startcommand
3512         except:
3513             self.__field_startcommand=UINT(**{'constant': 0x46})
3514         try: self.__field_bufsize
3515         except:
3516             self.__field_bufsize=UINT(**{'constant': 7168})
3517         try: self.__field_comment
3518         except:
3519             self.__field_comment=USTRING(**{'default': "callerid"})
3520 
3521 
3522     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
3523         'Writes this packet to the supplied buffer'
3524         self._bufferstartoffset=buf.getcurrentoffset()
3525         self.__field_numentries.writetobuffer(buf)
3526         try: self.__field_items
3527         except:
3528             self.__field_items=LIST(**{'length': self.maxentries, 'elementclass': calleridentry, 'createdefault': True})
3529         self.__field_items.writetobuffer(buf)
3530         try: self.__field_pad
3531         except:
3532             self.__field_pad=UNKNOWN(**{'sizeinbytes': 666})
3533         self.__field_pad.writetobuffer(buf)
3534         self._bufferendoffset=buf.getcurrentoffset()
3535         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
3536 
3537 
3538     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
3539         'Reads this packet from the supplied buffer'
3540         self._bufferstartoffset=buf.getcurrentoffset()
3541         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
3542         self.__field_numentries=UINT(**{'sizeinbytes': 2})
3543         self.__field_numentries.readfrombuffer(buf)
3544         self.__field_items=LIST(**{'length': self.maxentries, 'elementclass': calleridentry, 'createdefault': True})
3545         self.__field_items.readfrombuffer(buf)
3546         self.__field_pad=UNKNOWN(**{'sizeinbytes': 666})
3547         self.__field_pad.readfrombuffer(buf)
3548         self._bufferendoffset=buf.getcurrentoffset()
3549 
3550 
3551     def __getfield_maxentries(self):
3552         return self.__field_maxentries.getvalue()
3553 
3554     def __setfield_maxentries(self, value):
3555         if isinstance(value,UINT):
3556             self.__field_maxentries=value
3557         else:
3558             self.__field_maxentries=UINT(value,**{'constant': 500})
3559 
3560     def __delfield_maxentries(self): del self.__field_maxentries
3561 
3562     maxentries=property(__getfield_maxentries, __setfield_maxentries, __delfield_maxentries, None)
3563 
3564     def __getfield_startcommand(self):
3565         return self.__field_startcommand.getvalue()
3566 
3567     def __setfield_startcommand(self, value):
3568         if isinstance(value,UINT):
3569             self.__field_startcommand=value
3570         else:
3571             self.__field_startcommand=UINT(value,**{'constant': 0x46})
3572 
3573     def __delfield_startcommand(self): del self.__field_startcommand
3574 
3575     startcommand=property(__getfield_startcommand, __setfield_startcommand, __delfield_startcommand, "Starting command for R/W buf parts")
3576 
3577     def __getfield_bufsize(self):
3578         return self.__field_bufsize.getvalue()
3579 
3580     def __setfield_bufsize(self, value):
3581         if isinstance(value,UINT):
3582             self.__field_bufsize=value
3583         else:
3584             self.__field_bufsize=UINT(value,**{'constant': 7168})
3585 
3586     def __delfield_bufsize(self): del self.__field_bufsize
3587 
3588     bufsize=property(__getfield_bufsize, __setfield_bufsize, __delfield_bufsize, None)
3589 
3590     def __getfield_comment(self):
3591         try: self.__field_comment
3592         except:
3593             self.__field_comment=USTRING(**{'default': "callerid"})
3594         return self.__field_comment.getvalue()
3595 
3596     def __setfield_comment(self, value):
3597         if isinstance(value,USTRING):
3598             self.__field_comment=value
3599         else:
3600             self.__field_comment=USTRING(value,**{'default': "callerid"})
3601 
3602     def __delfield_comment(self): del self.__field_comment
3603 
3604     comment=property(__getfield_comment, __setfield_comment, __delfield_comment, None)
3605 
3606     def __getfield_numentries(self):
3607         return self.__field_numentries.getvalue()
3608 
3609     def __setfield_numentries(self, value):
3610         if isinstance(value,UINT):
3611             self.__field_numentries=value
3612         else:
3613             self.__field_numentries=UINT(value,**{'sizeinbytes': 2})
3614 
3615     def __delfield_numentries(self): del self.__field_numentries
3616 
3617     numentries=property(__getfield_numentries, __setfield_numentries, __delfield_numentries, "Number phone numbers")
3618 
3619     def __getfield_items(self):
3620         try: self.__field_items
3621         except:
3622             self.__field_items=LIST(**{'length': self.maxentries, 'elementclass': calleridentry, 'createdefault': True})
3623         return self.__field_items.getvalue()
3624 
3625     def __setfield_items(self, value):
3626         if isinstance(value,LIST):
3627             self.__field_items=value
3628         else:
3629             self.__field_items=LIST(value,**{'length': self.maxentries, 'elementclass': calleridentry, 'createdefault': True})
3630 
3631     def __delfield_items(self): del self.__field_items
3632 
3633     items=property(__getfield_items, __setfield_items, __delfield_items, None)
3634 
3635     def __getfield_pad(self):
3636         try: self.__field_pad
3637         except:
3638             self.__field_pad=UNKNOWN(**{'sizeinbytes': 666})
3639         return self.__field_pad.getvalue()
3640 
3641     def __setfield_pad(self, value):
3642         if isinstance(value,UNKNOWN):
3643             self.__field_pad=value
3644         else:
3645             self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 666})
3646 
3647     def __delfield_pad(self): del self.__field_pad
3648 
3649     pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None)
3650 
3651     def iscontainer(self):
3652         return True
3653 
3654     def containerelements(self):
3655         yield ('maxentries', self.__field_maxentries, None)
3656         yield ('startcommand', self.__field_startcommand, "Starting command for R/W buf parts")
3657         yield ('bufsize', self.__field_bufsize, None)
3658         yield ('comment', self.__field_comment, None)
3659         yield ('numentries', self.__field_numentries, "Number phone numbers")
3660         yield ('items', self.__field_items, None)
3661         yield ('pad', self.__field_pad, None)
3662 
3663 
3664 
3665 
3666 class ringerpicbuffer(BaseProtogenClass):
3667     "Index of ringer and picture assignments"
3668     __fields=['numpbslots', 'startcommand', 'packettype', 'bufsize', 'comment', 'ringtones', 'wallpapers', 'pad']
3669 
3670     def __init__(self, *args, **kwargs):
3671         dict={}
3672         # What was supplied to this function
3673         dict.update(kwargs)
3674         # Parent constructor
3675         super(ringerpicbuffer,self).__init__(**dict)
3676         if self.__class__ is ringerpicbuffer:
3677             self._update(args,dict)
3678 
3679 
3680     def getfields(self):
3681         return self.__fields
3682 
3683 
3684     def _update(self, args, kwargs):
3685         super(ringerpicbuffer,self)._update(args,kwargs)
3686         keys=kwargs.keys()
3687         for key in keys:
3688             if key in self.__fields:
3689                 setattr(self, key, kwargs[key])
3690                 del kwargs[key]
3691         # Were any unrecognized kwargs passed in?
3692         if __debug__:
3693             self._complainaboutunusedargs(ringerpicbuffer,kwargs)
3694         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
3695         # Make all P fields that haven't already been constructed
3696         try: self.__field_numpbslots
3697         except:
3698             self.__field_numpbslots=UINT(**{'constant': _NUMPBSLOTS})
3699         try: self.__field_startcommand
3700         except:
3701             self.__field_startcommand=UINT(**{'constant': 0xd7})
3702         try: self.__field_packettype
3703         except:
3704             self.__field_packettype=UINT(**{'constant': 0x0f})
3705         try: self.__field_bufsize
3706         except:
3707             self.__field_bufsize=UINT(**{'constant': 1024})
3708         try: self.__field_comment
3709         except:
3710             self.__field_comment=USTRING(**{'default': "ringer/picture assignments"})
3711 
3712 
3713     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
3714         'Writes this packet to the supplied buffer'
3715         self._bufferstartoffset=buf.getcurrentoffset()
3716         try: self.__field_ringtones
3717         except:
3718             self.__field_ringtones=LIST(**{'elementclass': _gen_p_sanyonewer_234, 'length': _NUMPBSLOTS})
3719         self.__field_ringtones.writetobuffer(buf)
3720         try: self.__field_wallpapers
3721         except:
3722             self.__field_wallpapers=LIST(**{'elementclass': _gen_p_sanyonewer_236, 'length': _NUMPBSLOTS})
3723         self.__field_wallpapers.writetobuffer(buf)
3724         try: self.__field_pad
3725         except:
3726             self.__field_pad=UNKNOWN(**{'sizeinbytes': 424})
3727         self.__field_pad.writetobuffer(buf)
3728         self._bufferendoffset=buf.getcurrentoffset()
3729         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
3730 
3731 
3732     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
3733         'Reads this packet from the supplied buffer'
3734         self._bufferstartoffset=buf.getcurrentoffset()
3735         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
3736         self.__field_ringtones=LIST(**{'elementclass': _gen_p_sanyonewer_234, 'length': _NUMPBSLOTS})
3737         self.__field_ringtones.readfrombuffer(buf)
3738         self.__field_wallpapers=LIST(**{'elementclass': _gen_p_sanyonewer_236, 'length': _NUMPBSLOTS})
3739         self.__field_wallpapers.readfrombuffer(buf)
3740         self.__field_pad=UNKNOWN(**{'sizeinbytes': 424})
3741         self.__field_pad.readfrombuffer(buf)
3742         self._bufferendoffset=buf.getcurrentoffset()
3743 
3744 
3745     def __getfield_numpbslots(self):
3746         return self.__field_numpbslots.getvalue()
3747 
3748     def __setfield_numpbslots(self, value):
3749         if isinstance(value,UINT):
3750             self.__field_numpbslots=value
3751         else:
3752             self.__field_numpbslots=UINT(value,**{'constant': _NUMPBSLOTS})
3753 
3754     def __delfield_numpbslots(self): del self.__field_numpbslots
3755 
3756     numpbslots=property(__getfield_numpbslots, __setfield_numpbslots, __delfield_numpbslots, "Number of phone book slots")
3757 
3758     def __getfield_startcommand(self):
3759         return self.__field_startcommand.getvalue()
3760 
3761     def __setfield_startcommand(self, value):
3762         if isinstance(value,UINT):
3763             self.__field_startcommand=value
3764         else:
3765             self.__field_startcommand=UINT(value,**{'constant': 0xd7})
3766 
3767     def __delfield_startcommand(self): del self.__field_startcommand
3768 
3769     startcommand=property(__getfield_startcommand, __setfield_startcommand, __delfield_startcommand, "Starting command for R/W buf parts")
3770 
3771     def __getfield_packettype(self):
3772         return self.__field_packettype.getvalue()
3773 
3774     def __setfield_packettype(self, value):
3775         if isinstance(value,UINT):
3776             self.__field_packettype=value
3777         else:
3778             self.__field_packettype=UINT(value,**{'constant': 0x0f})
3779 
3780     def __delfield_packettype(self): del self.__field_packettype
3781 
3782     packettype=property(__getfield_packettype, __setfield_packettype, __delfield_packettype, "Non standard packet type")
3783 
3784     def __getfield_bufsize(self):
3785         return self.__field_bufsize.getvalue()
3786 
3787     def __setfield_bufsize(self, value):
3788         if isinstance(value,UINT):
3789             self.__field_bufsize=value
3790         else:
3791             self.__field_bufsize=UINT(value,**{'constant': 1024})
3792 
3793     def __delfield_bufsize(self): del self.__field_bufsize
3794 
3795     bufsize=property(__getfield_bufsize, __setfield_bufsize, __delfield_bufsize, None)
3796 
3797     def __getfield_comment(self):
3798         try: self.__field_comment
3799         except:
3800             self.__field_comment=USTRING(**{'default': "ringer/picture assignments"})
3801         return self.__field_comment.getvalue()
3802 
3803     def __setfield_comment(self, value):
3804         if isinstance(value,USTRING):
3805             self.__field_comment=value
3806         else:
3807             self.__field_comment=USTRING(value,**{'default': "ringer/picture assignments"})
3808 
3809     def __delfield_comment(self): del self.__field_comment
3810 
3811     comment=property(__getfield_comment, __setfield_comment, __delfield_comment, None)
3812 
3813     def __getfield_ringtones(self):
3814         try: self.__field_ringtones
3815         except:
3816             self.__field_ringtones=LIST(**{'elementclass': _gen_p_sanyonewer_234, 'length': _NUMPBSLOTS})
3817         return self.__field_ringtones.getvalue()
3818 
3819     def __setfield_ringtones(self, value):
3820         if isinstance(value,LIST):
3821             self.__field_ringtones=value
3822         else:
3823             self.__field_ringtones=LIST(value,**{'elementclass': _gen_p_sanyonewer_234, 'length': _NUMPBSLOTS})
3824 
3825     def __delfield_ringtones(self): del self.__field_ringtones
3826 
3827     ringtones=property(__getfield_ringtones, __setfield_ringtones, __delfield_ringtones, None)
3828 
3829     def __getfield_wallpapers(self):
3830         try: self.__field_wallpapers
3831         except:
3832             self.__field_wallpapers=LIST(**{'elementclass': _gen_p_sanyonewer_236, 'length': _NUMPBSLOTS})
3833         return self.__field_wallpapers.getvalue()
3834 
3835     def __setfield_wallpapers(self, value):
3836         if isinstance(value,LIST):
3837             self.__field_wallpapers=value
3838         else:
3839             self.__field_wallpapers=LIST(value,**{'elementclass': _gen_p_sanyonewer_236, 'length': _NUMPBSLOTS})
3840 
3841     def __delfield_wallpapers(self): del self.__field_wallpapers
3842 
3843     wallpapers=property(__getfield_wallpapers, __setfield_wallpapers, __delfield_wallpapers, None)
3844 
3845     def __getfield_pad(self):
3846         try: self.__field_pad
3847         except:
3848             self.__field_pad=UNKNOWN(**{'sizeinbytes': 424})
3849         return self.__field_pad.getvalue()
3850 
3851     def __setfield_pad(self, value):
3852         if isinstance(value,UNKNOWN):
3853             self.__field_pad=value
3854         else:
3855             self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 424})
3856 
3857     def __delfield_pad(self): del self.__field_pad
3858 
3859     pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None)
3860 
3861     def iscontainer(self):
3862         return True
3863 
3864     def containerelements(self):
3865         yield ('numpbslots', self.__field_numpbslots, "Number of phone book slots")
3866         yield ('startcommand', self.__field_startcommand, "Starting command for R/W buf parts")
3867         yield ('packettype', self.__field_packettype, "Non standard packet type")
3868         yield ('bufsize', self.__field_bufsize, None)
3869         yield ('comment', self.__field_comment, None)
3870         yield ('ringtones', self.__field_ringtones, None)
3871         yield ('wallpapers', self.__field_wallpapers, None)
3872         yield ('pad', self.__field_pad, None)
3873 
3874 
3875 
3876 
3877 class _gen_p_sanyonewer_234(BaseProtogenClass):
3878     'Anonymous inner class'
3879     __fields=['ringtone']
3880 
3881     def __init__(self, *args, **kwargs):
3882         dict={}
3883         # What was supplied to this function
3884         dict.update(kwargs)
3885         # Parent constructor
3886         super(_gen_p_sanyonewer_234,self).__init__(**dict)
3887         if self.__class__ is _gen_p_sanyonewer_234:
3888             self._update(args,dict)
3889 
3890 
3891     def getfields(self):
3892         return self.__fields
3893 
3894 
3895     def _update(self, args, kwargs):
3896         super(_gen_p_sanyonewer_234,self)._update(args,kwargs)
3897         keys=kwargs.keys()
3898         for key in keys:
3899             if key in self.__fields:
3900                 setattr(self, key, kwargs[key])
3901                 del kwargs[key]
3902         # Were any unrecognized kwargs passed in?
3903         if __debug__:
3904             self._complainaboutunusedargs(_gen_p_sanyonewer_234,kwargs)
3905         if len(args):
3906             dict2={'sizeinbytes': 1}
3907             dict2.update(kwargs)
3908             kwargs=dict2
3909             self.__field_ringtone=UINT(*args,**dict2)
3910         # Make all P fields that haven't already been constructed
3911 
3912 
3913     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
3914         'Writes this packet to the supplied buffer'
3915         self._bufferstartoffset=buf.getcurrentoffset()
3916         self.__field_ringtone.writetobuffer(buf)
3917         self._bufferendoffset=buf.getcurrentoffset()
3918         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
3919 
3920 
3921     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
3922         'Reads this packet from the supplied buffer'
3923         self._bufferstartoffset=buf.getcurrentoffset()
3924         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
3925         self.__field_ringtone=UINT(**{'sizeinbytes': 1})
3926         self.__field_ringtone.readfrombuffer(buf)
3927         self._bufferendoffset=buf.getcurrentoffset()
3928 
3929 
3930     def __getfield_ringtone(self):
3931         return self.__field_ringtone.getvalue()
3932 
3933     def __setfield_ringtone(self, value):
3934         if isinstance(value,UINT):
3935             self.__field_ringtone=value
3936         else:
3937             self.__field_ringtone=UINT(value,**{'sizeinbytes': 1})
3938 
3939     def __delfield_ringtone(self): del self.__field_ringtone
3940 
3941     ringtone=property(__getfield_ringtone, __setfield_ringtone, __delfield_ringtone, "ringtone index")
3942 
3943     def iscontainer(self):
3944         return True
3945 
3946     def containerelements(self):
3947         yield ('ringtone', self.__field_ringtone, "ringtone index")
3948 
3949 
3950 
3951 
3952 class _gen_p_sanyonewer_236(BaseProtogenClass):
3953     'Anonymous inner class'
3954     __fields=['wallpaper']
3955 
3956     def __init__(self, *args, **kwargs):
3957         dict={}
3958         # What was supplied to this function
3959         dict.update(kwargs)
3960         # Parent constructor
3961         super(_gen_p_sanyonewer_236,self).__init__(**dict)
3962         if self.__class__ is _gen_p_sanyonewer_236:
3963             self._update(args,dict)
3964 
3965 
3966     def getfields(self):
3967         return self.__fields
3968 
3969 
3970     def _update(self, args, kwargs):
3971         super(_gen_p_sanyonewer_236,self)._update(args,kwargs)
3972         keys=kwargs.keys()
3973         for key in keys:
3974             if key in self.__fields:
3975                 setattr(self, key, kwargs[key])
3976                 del kwargs[key]
3977         # Were any unrecognized kwargs passed in?
3978         if __debug__:
3979             self._complainaboutunusedargs(_gen_p_sanyonewer_236,kwargs)
3980         if len(args):
3981             dict2={'sizeinbytes': 1}
3982             dict2.update(kwargs)
3983             kwargs=dict2
3984             self.__field_wallpaper=UINT(*args,**dict2)
3985         # Make all P fields that haven't already been constructed
3986 
3987 
3988     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
3989         'Writes this packet to the supplied buffer'
3990         self._bufferstartoffset=buf.getcurrentoffset()
3991         self.__field_wallpaper.writetobuffer(buf)
3992         self._bufferendoffset=buf.getcurrentoffset()
3993         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
3994 
3995 
3996     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
3997         'Reads this packet from the supplied buffer'
3998         self._bufferstartoffset=buf.getcurrentoffset()
3999         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
4000         self.__field_wallpaper=UINT(**{'sizeinbytes': 1})
4001         self.__field_wallpaper.readfrombuffer(buf)
4002         self._bufferendoffset=buf.getcurrentoffset()
4003 
4004 
4005     def __getfield_wallpaper(self):
4006         return self.__field_wallpaper.getvalue()
4007 
4008     def __setfield_wallpaper(self, value):
4009         if isinstance(value,UINT):
4010             self.__field_wallpaper=value
4011         else:
4012             self.__field_wallpaper=UINT(value,**{'sizeinbytes': 1})
4013 
4014     def __delfield_wallpaper(self): del self.__field_wallpaper
4015 
4016     wallpaper=property(__getfield_wallpaper, __setfield_wallpaper, __delfield_wallpaper, "wallpaper index")
4017 
4018     def iscontainer(self):
4019         return True
4020 
4021     def containerelements(self):
4022         yield ('wallpaper', self.__field_wallpaper, "wallpaper index")
4023 
4024 
4025 
4026 
4027 class pbsortbuffer(BaseProtogenClass):
4028     "Various arrays for sorting the phone book, speed dial, determining which"
4029     __fields=['startcommand', 'bufsize', 'comment', 'usedflags', 'slotsused', 'slotsused2', 'numemail', 'numurl', 'firsttypes', 'sortorder', 'pbfirstletters', 'sortorder2', 'speeddialindex', 'longnumbersindex', 'emails', 'emailfirstletters', 'urls', 'urlfirstletters', 'pad']
4030 
4031     def __init__(self, *args, **kwargs):
4032         dict={}
4033         # What was supplied to this function
4034         dict.update(kwargs)
4035         # Parent constructor
4036         super(pbsortbuffer,self).__init__(**dict)
4037         if self.__class__ is pbsortbuffer:
4038             self._update(args,dict)
4039 
4040 
4041     def getfields(self):
4042         return self.__fields
4043 
4044 
4045     def _update(self, args, kwargs):
4046         super(pbsortbuffer,self)._update(args,kwargs)
4047         keys=kwargs.keys()
4048         for key in keys:
4049             if key in self.__fields:
4050                 setattr(self, key, kwargs[key])
4051                 del kwargs[key]
4052         # Were any unrecognized kwargs passed in?
4053         if __debug__:
4054             self._complainaboutunusedargs(pbsortbuffer,kwargs)
4055         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
4056         # Make all P fields that haven't already been constructed
4057         try: self.__field_startcommand
4058         except:
4059             self.__field_startcommand=UINT(**{'constant': 0x3c})
4060         try: self.__field_bufsize
4061         except:
4062             self.__field_bufsize=UINT(**{'constant': 4096})
4063         try: self.__field_comment
4064         except:
4065             self.__field_comment=USTRING(**{'default': "sort buffer"})
4066 
4067 
4068     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
4069         'Writes this packet to the supplied buffer'
4070         self._bufferstartoffset=buf.getcurrentoffset()
4071         try: self.__field_usedflags
4072         except:
4073             self.__field_usedflags=LIST(**{'elementclass': _gen_p_sanyonewer_257, 'length': _NUMPBSLOTS, 'createdefault': True})
4074         self.__field_usedflags.writetobuffer(buf)
4075         self.__field_slotsused.writetobuffer(buf)
4076         self.__field_slotsused2.writetobuffer(buf)
4077         self.__field_numemail.writetobuffer(buf)
4078         self.__field_numurl.writetobuffer(buf)
4079         try: self.__field_firsttypes
4080         except:
4081             self.__field_firsttypes=LIST(**{'elementclass': _gen_p_sanyonewer_263, 'length': _NUMPBSLOTS})
4082         self.__field_firsttypes.writetobuffer(buf)
4083         try: self.__field_sortorder
4084         except:
4085             self.__field_sortorder=LIST(**{'elementclass': _gen_p_sanyonewer_265, 'length': _NUMPBSLOTS})
4086         self.__field_sortorder.writetobuffer(buf)
4087         self.__field_pbfirstletters.writetobuffer(buf)
4088         try: self.__field_sortorder2
4089         except:
4090             self.__field_sortorder2=LIST(**{'elementclass': _gen_p_sanyonewer_268, 'length': _NUMPBSLOTS})
4091         self.__field_sortorder2.writetobuffer(buf)
4092         try: self.__field_speeddialindex
4093         except:
4094             self.__field_speeddialindex=LIST(**{'elementclass': _gen_p_sanyonewer_270, 'length': _NUMSPEEDDIALS})
4095         self.__field_speeddialindex.writetobuffer(buf)
4096         try: self.__field_longnumbersindex
4097         except:
4098             self.__field_longnumbersindex=LIST(**{'elementclass': _gen_p_sanyonewer_272, 'length': _NUMLONGNUMBERS})
4099         self.__field_longnumbersindex.writetobuffer(buf)
4100         try: self.__field_emails
4101         except:
4102             self.__field_emails=LIST(**{'elementclass': _gen_p_sanyonewer_274, 'length': _NUMPBSLOTS})
4103         self.__field_emails.writetobuffer(buf)
4104         self.__field_emailfirstletters.writetobuffer(buf)
4105         try: self.__field_urls
4106         except:
4107             self.__field_urls=LIST(**{'elementclass': _gen_p_sanyonewer_277, 'length': _NUMPBSLOTS})
4108         self.__field_urls.writetobuffer(buf)
4109         self.__field_urlfirstletters.writetobuffer(buf)
4110         try: self.__field_pad
4111         except:
4112             self.__field_pad=UNKNOWN(**{'sizeinbytes': 162})
4113         self.__field_pad.writetobuffer(buf)
4114         self._bufferendoffset=buf.getcurrentoffset()
4115         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
4116 
4117 
4118     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
4119         'Reads this packet from the supplied buffer'
4120         self._bufferstartoffset=buf.getcurrentoffset()
4121         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
4122         self.__field_usedflags=LIST(**{'elementclass': _gen_p_sanyonewer_257, 'length': _NUMPBSLOTS, 'createdefault': True})
4123         self.__field_usedflags.readfrombuffer(buf)
4124         self.__field_slotsused=UINT(**{'sizeinbytes': 2})
4125         self.__field_slotsused.readfrombuffer(buf)
4126         self.__field_slotsused2=UINT(**{'sizeinbytes': 2})
4127         self.__field_slotsused2.readfrombuffer(buf)
4128         self.__field_numemail=UINT(**{'sizeinbytes': 2})
4129         self.__field_numemail.readfrombuffer(buf)
4130         self.__field_numurl=UINT(**{'sizeinbytes': 2})
4131         self.__field_numurl.readfrombuffer(buf)
4132         self.__field_firsttypes=LIST(**{'elementclass': _gen_p_sanyonewer_263, 'length': _NUMPBSLOTS})
4133         self.__field_firsttypes.readfrombuffer(buf)
4134         self.__field_sortorder=LIST(**{'elementclass': _gen_p_sanyonewer_265, 'length': _NUMPBSLOTS})
4135         self.__field_sortorder.readfrombuffer(buf)
4136         self.__field_pbfirstletters=USTRING(**{'terminator': None, 'sizeinbytes': _NUMPBSLOTS})
4137         self.__field_pbfirstletters.readfrombuffer(buf)
4138         self.__field_sortorder2=LIST(**{'elementclass': _gen_p_sanyonewer_268, 'length': _NUMPBSLOTS})
4139         self.__field_sortorder2.readfrombuffer(buf)
4140         self.__field_speeddialindex=LIST(**{'elementclass': _gen_p_sanyonewer_270, 'length': _NUMSPEEDDIALS})
4141         self.__field_speeddialindex.readfrombuffer(buf)
4142         self.__field_longnumbersindex=LIST(**{'elementclass': _gen_p_sanyonewer_272, 'length': _NUMLONGNUMBERS})
4143         self.__field_longnumbersindex.readfrombuffer(buf)
4144         self.__field_emails=LIST(**{'elementclass': _gen_p_sanyonewer_274, 'length': _NUMPBSLOTS})
4145         self.__field_emails.readfrombuffer(buf)
4146         self.__field_emailfirstletters=USTRING(**{'terminator': None, 'sizeinbytes': _NUMPBSLOTS})
4147         self.__field_emailfirstletters.readfrombuffer(buf)
4148         self.__field_urls=LIST(**{'elementclass': _gen_p_sanyonewer_277, 'length': _NUMPBSLOTS})
4149         self.__field_urls.readfrombuffer(buf)
4150         self.__field_urlfirstletters=USTRING(**{'terminator': None, 'sizeinbytes': _NUMPBSLOTS})
4151         self.__field_urlfirstletters.readfrombuffer(buf)
4152         self.__field_pad=UNKNOWN(**{'sizeinbytes': 162})
4153         self.__field_pad.readfrombuffer(buf)
4154         self._bufferendoffset=buf.getcurrentoffset()
4155 
4156 
4157     def __getfield_startcommand(self):
4158         return self.__field_startcommand.getvalue()
4159 
4160     def __setfield_startcommand(self, value):
4161         if isinstance(value,UINT):
4162             self.__field_startcommand=value
4163         else:
4164             self.__field_startcommand=UINT(value,**{'constant': 0x3c})
4165 
4166     def __delfield_startcommand(self): del self.__field_startcommand
4167 
4168     startcommand=property(__getfield_startcommand, __setfield_startcommand, __delfield_startcommand, "Starting command for R/W buf parts")
4169 
4170     def __getfield_bufsize(self):
4171         return self.__field_bufsize.getvalue()
4172 
4173     def __setfield_bufsize(self, value):
4174         if isinstance(value,UINT):
4175             self.__field_bufsize=value
4176         else:
4177             self.__field_bufsize=UINT(value,**{'constant': 4096})
4178 
4179     def __delfield_bufsize(self): del self.__field_bufsize
4180 
4181     bufsize=property(__getfield_bufsize, __setfield_bufsize, __delfield_bufsize, None)
4182 
4183     def __getfield_comment(self):
4184         try: self.__field_comment
4185         except:
4186             self.__field_comment=USTRING(**{'default': "sort buffer"})
4187         return self.__field_comment.getvalue()
4188 
4189     def __setfield_comment(self, value):
4190         if isinstance(value,USTRING):
4191             self.__field_comment=value
4192         else:
4193             self.__field_comment=USTRING(value,**{'default': "sort buffer"})
4194 
4195     def __delfield_comment(self): del self.__field_comment
4196 
4197     comment=property(__getfield_comment, __setfield_comment, __delfield_comment, None)
4198 
4199     def __getfield_usedflags(self):
4200         try: self.__field_usedflags
4201         except:
4202             self.__field_usedflags=LIST(**{'elementclass': _gen_p_sanyonewer_257, 'length': _NUMPBSLOTS, 'createdefault': True})
4203         return self.__field_usedflags.getvalue()
4204 
4205     def __setfield_usedflags(self, value):
4206         if isinstance(value,LIST):
4207             self.__field_usedflags=value
4208         else:
4209             self.__field_usedflags=LIST(value,**{'elementclass': _gen_p_sanyonewer_257, 'length': _NUMPBSLOTS, 'createdefault': True})
4210 
4211     def __delfield_usedflags(self): del self.__field_usedflags
4212 
4213     usedflags=property(__getfield_usedflags, __setfield_usedflags, __delfield_usedflags, None)
4214 
4215     def __getfield_slotsused(self):
4216         return self.__field_slotsused.getvalue()
4217 
4218     def __setfield_slotsused(self, value):
4219         if isinstance(value,UINT):
4220             self.__field_slotsused=value
4221         else:
4222             self.__field_slotsused=UINT(value,**{'sizeinbytes': 2})
4223 
4224     def __delfield_slotsused(self): del self.__field_slotsused
4225 
4226     slotsused=property(__getfield_slotsused, __setfield_slotsused, __delfield_slotsused, None)
4227 
4228     def __getfield_slotsused2(self):
4229         return self.__field_slotsused2.getvalue()
4230 
4231     def __setfield_slotsused2(self, value):
4232         if isinstance(value,UINT):
4233             self.__field_slotsused2=value
4234         else:
4235             self.__field_slotsused2=UINT(value,**{'sizeinbytes': 2})
4236 
4237     def __delfield_slotsused2(self): del self.__field_slotsused2
4238 
4239     slotsused2=property(__getfield_slotsused2, __setfield_slotsused2, __delfield_slotsused2, "Always seems to be the same.  Why duplicated?")
4240 
4241     def __getfield_numemail(self):
4242         return self.__field_numemail.getvalue()
4243 
4244     def __setfield_numemail(self, value):
4245         if isinstance(value,UINT):
4246             self.__field_numemail=value
4247         else:
4248             self.__field_numemail=UINT(value,**{'sizeinbytes': 2})
4249 
4250     def __delfield_numemail(self): del self.__field_numemail
4251 
4252     numemail=property(__getfield_numemail, __setfield_numemail, __delfield_numemail, "Num of slots with email")
4253 
4254     def __getfield_numurl(self):
4255         return self.__field_numurl.getvalue()
4256 
4257     def __setfield_numurl(self, value):
4258         if isinstance(value,UINT):
4259             self.__field_numurl=value
4260         else:
4261             self.__field_numurl=UINT(value,**{'sizeinbytes': 2})
4262 
4263     def __delfield_numurl(self): del self.__field_numurl
4264 
4265     numurl=property(__getfield_numurl, __setfield_numurl, __delfield_numurl, "Num of slots with URL")
4266 
4267     def __getfield_firsttypes(self):
4268         try: self.__field_firsttypes
4269         except:
4270             self.__field_firsttypes=LIST(**{'elementclass': _gen_p_sanyonewer_263, 'length': _NUMPBSLOTS})
4271         return self.__field_firsttypes.getvalue()
4272 
4273     def __setfield_firsttypes(self, value):
4274         if isinstance(value,LIST):
4275             self.__field_firsttypes=value
4276         else:
4277             self.__field_firsttypes=LIST(value,**{'elementclass': _gen_p_sanyonewer_263, 'length': _NUMPBSLOTS})
4278 
4279     def __delfield_firsttypes(self): del self.__field_firsttypes
4280 
4281     firsttypes=property(__getfield_firsttypes, __setfield_firsttypes, __delfield_firsttypes, None)
4282 
4283     def __getfield_sortorder(self):
4284         try: self.__field_sortorder
4285         except:
4286             self.__field_sortorder=LIST(**{'elementclass': _gen_p_sanyonewer_265, 'length': _NUMPBSLOTS})
4287         return self.__field_sortorder.getvalue()
4288 
4289     def __setfield_sortorder(self, value):
4290         if isinstance(value,LIST):
4291             self.__field_sortorder=value
4292         else:
4293             self.__field_sortorder=LIST(value,**{'elementclass': _gen_p_sanyonewer_265, 'length': _NUMPBSLOTS})
4294 
4295     def __delfield_sortorder(self): del self.__field_sortorder
4296 
4297     sortorder=property(__getfield_sortorder, __setfield_sortorder, __delfield_sortorder, None)
4298 
4299     def __getfield_pbfirstletters(self):
4300         return self.__field_pbfirstletters.getvalue()
4301 
4302     def __setfield_pbfirstletters(self, value):
4303         if isinstance(value,USTRING):
4304             self.__field_pbfirstletters=value
4305         else:
4306             self.__field_pbfirstletters=USTRING(value,**{'terminator': None, 'sizeinbytes': _NUMPBSLOTS})
4307 
4308     def __delfield_pbfirstletters(self): del self.__field_pbfirstletters
4309 
4310     pbfirstletters=property(__getfield_pbfirstletters, __setfield_pbfirstletters, __delfield_pbfirstletters, None)
4311 
4312     def __getfield_sortorder2(self):
4313         try: self.__field_sortorder2
4314         except:
4315             self.__field_sortorder2=LIST(**{'elementclass': _gen_p_sanyonewer_268, 'length': _NUMPBSLOTS})
4316         return self.__field_sortorder2.getvalue()
4317 
4318     def __setfield_sortorder2(self, value):
4319         if isinstance(value,LIST):
4320             self.__field_sortorder2=value
4321         else:
4322             self.__field_sortorder2=LIST(value,**{'elementclass': _gen_p_sanyonewer_268, 'length': _NUMPBSLOTS})
4323 
4324     def __delfield_sortorder2(self): del self.__field_sortorder2
4325 
4326     sortorder2=property(__getfield_sortorder2, __setfield_sortorder2, __delfield_sortorder2, "Is this the same")
4327 
4328     def __getfield_speeddialindex(self):
4329         try: self.__field_speeddialindex
4330         except:
4331             self.__field_speeddialindex=LIST(**{'elementclass': _gen_p_sanyonewer_270, 'length': _NUMSPEEDDIALS})
4332         return self.__field_speeddialindex.getvalue()
4333 
4334     def __setfield_speeddialindex(self, value):
4335         if isinstance(value,LIST):
4336             self.__field_speeddialindex=value
4337         else:
4338             self.__field_speeddialindex=LIST(value,**{'elementclass': _gen_p_sanyonewer_270, 'length': _NUMSPEEDDIALS})
4339 
4340     def __delfield_speeddialindex(self): del self.__field_speeddialindex
4341 
4342     speeddialindex=property(__getfield_speeddialindex, __setfield_speeddialindex, __delfield_speeddialindex, None)
4343 
4344     def __getfield_longnumbersindex(self):
4345         try: self.__field_longnumbersindex
4346         except:
4347             self.__field_longnumbersindex=LIST(**{'elementclass': _gen_p_sanyonewer_272, 'length': _NUMLONGNUMBERS})
4348         return self.__field_longnumbersindex.getvalue()
4349 
4350     def __setfield_longnumbersindex(self, value):
4351         if isinstance(value,LIST):
4352             self.__field_longnumbersindex=value
4353         else:
4354             self.__field_longnumbersindex=LIST(value,**{'elementclass': _gen_p_sanyonewer_272, 'length': _NUMLONGNUMBERS})
4355 
4356     def __delfield_longnumbersindex(self): del self.__field_longnumbersindex
4357 
4358     longnumbersindex=property(__getfield_longnumbersindex, __setfield_longnumbersindex, __delfield_longnumbersindex, None)
4359 
4360     def __getfield_emails(self):
4361         try: self.__field_emails
4362         except:
4363             self.__field_emails=LIST(**{'elementclass': _gen_p_sanyonewer_274, 'length': _NUMPBSLOTS})
4364         return self.__field_emails.getvalue()
4365 
4366     def __setfield_emails(self, value):
4367         if isinstance(value,LIST):
4368             self.__field_emails=value
4369         else:
4370             self.__field_emails=LIST(value,**{'elementclass': _gen_p_sanyonewer_274, 'length': _NUMPBSLOTS})
4371 
4372     def __delfield_emails(self): del self.__field_emails
4373 
4374     emails=property(__getfield_emails, __setfield_emails, __delfield_emails, "Sorted list of slots with Email")
4375 
4376     def __getfield_emailfirstletters(self):
4377         return self.__field_emailfirstletters.getvalue()
4378 
4379     def __setfield_emailfirstletters(self, value):
4380         if isinstance(value,USTRING):
4381             self.__field_emailfirstletters=value
4382         else:
4383             self.__field_emailfirstletters=USTRING(value,**{'terminator': None, 'sizeinbytes': _NUMPBSLOTS})
4384 
4385     def __delfield_emailfirstletters(self): del self.__field_emailfirstletters
4386 
4387     emailfirstletters=property(__getfield_emailfirstletters, __setfield_emailfirstletters, __delfield_emailfirstletters, "First letters in sort order")
4388 
4389     def __getfield_urls(self):
4390         try: self.__field_urls
4391         except:
4392             self.__field_urls=LIST(**{'elementclass': _gen_p_sanyonewer_277, 'length': _NUMPBSLOTS})
4393         return self.__field_urls.getvalue()
4394 
4395     def __setfield_urls(self, value):
4396         if isinstance(value,LIST):
4397             self.__field_urls=value
4398         else:
4399             self.__field_urls=LIST(value,**{'elementclass': _gen_p_sanyonewer_277, 'length': _NUMPBSLOTS})
4400 
4401     def __delfield_urls(self): del self.__field_urls
4402 
4403     urls=property(__getfield_urls, __setfield_urls, __delfield_urls, "Sorted list of slots with a URL")
4404 
4405     def __getfield_urlfirstletters(self):
4406         return self.__field_urlfirstletters.getvalue()
4407 
4408     def __setfield_urlfirstletters(self, value):
4409         if isinstance(value,USTRING):
4410             self.__field_urlfirstletters=value
4411         else:
4412             self.__field_urlfirstletters=USTRING(value,**{'terminator': None, 'sizeinbytes': _NUMPBSLOTS})
4413 
4414     def __delfield_urlfirstletters(self): del self.__field_urlfirstletters
4415 
4416     urlfirstletters=property(__getfield_urlfirstletters, __setfield_urlfirstletters, __delfield_urlfirstletters, "First letters in sort order")
4417 
4418     def __getfield_pad(self):
4419         try: self.__field_pad
4420         except:
4421             self.__field_pad=UNKNOWN(**{'sizeinbytes': 162})
4422         return self.__field_pad.getvalue()
4423 
4424     def __setfield_pad(self, value):
4425         if isinstance(value,UNKNOWN):
4426             self.__field_pad=value
4427         else:
4428             self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 162})
4429 
4430     def __delfield_pad(self): del self.__field_pad
4431 
4432     pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None)
4433 
4434     def iscontainer(self):
4435         return True
4436 
4437     def containerelements(self):
4438         yield ('startcommand', self.__field_startcommand, "Starting command for R/W buf parts")
4439         yield ('bufsize', self.__field_bufsize, None)
4440         yield ('comment', self.__field_comment, None)
4441         yield ('usedflags', self.__field_usedflags, None)
4442         yield ('slotsused', self.__field_slotsused, None)
4443         yield ('slotsused2', self.__field_slotsused2, "Always seems to be the same.  Why duplicated?")
4444         yield ('numemail', self.__field_numemail, "Num of slots with email")
4445         yield ('numurl', self.__field_numurl, "Num of slots with URL")
4446         yield ('firsttypes', self.__field_firsttypes, None)
4447         yield ('sortorder', self.__field_sortorder, None)
4448         yield ('pbfirstletters', self.__field_pbfirstletters, None)
4449         yield ('sortorder2', self.__field_sortorder2, "Is this the same")
4450         yield ('speeddialindex', self.__field_speeddialindex, None)
4451         yield ('longnumbersindex', self.__field_longnumbersindex, None)
4452         yield ('emails', self.__field_emails, "Sorted list of slots with Email")
4453         yield ('emailfirstletters', self.__field_emailfirstletters, "First letters in sort order")
4454         yield ('urls', self.__field_urls, "Sorted list of slots with a URL")
4455         yield ('urlfirstletters', self.__field_urlfirstletters, "First letters in sort order")
4456         yield ('pad', self.__field_pad, None)
4457 
4458 
4459 
4460 
4461 class _gen_p_sanyonewer_257(BaseProtogenClass):
4462     'Anonymous inner class'
4463     __fields=['used']
4464 
4465     def __init__(self, *args, **kwargs):
4466         dict={}
4467         # What was supplied to this function
4468         dict.update(kwargs)
4469         # Parent constructor
4470         super(_gen_p_sanyonewer_257,self).__init__(**dict)
4471         if self.__class__ is _gen_p_sanyonewer_257:
4472             self._update(args,dict)
4473 
4474 
4475     def getfields(self):
4476         return self.__fields
4477 
4478 
4479     def _update(self, args, kwargs):
4480         super(_gen_p_sanyonewer_257,self)._update(args,kwargs)
4481         keys=kwargs.keys()
4482         for key in keys:
4483             if key in self.__fields:
4484                 setattr(self, key, kwargs[key])
4485                 del kwargs[key]
4486         # Were any unrecognized kwargs passed in?
4487         if __debug__:
4488             self._complainaboutunusedargs(_gen_p_sanyonewer_257,kwargs)
4489         if len(args):
4490             dict2={'sizeinbytes': 1}
4491             dict2.update(kwargs)
4492             kwargs=dict2
4493             self.__field_used=UINT(*args,**dict2)
4494         # Make all P fields that haven't already been constructed
4495 
4496 
4497     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
4498         'Writes this packet to the supplied buffer'
4499         self._bufferstartoffset=buf.getcurrentoffset()
4500         self.__field_used.writetobuffer(buf)
4501         self._bufferendoffset=buf.getcurrentoffset()
4502         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
4503 
4504 
4505     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
4506         'Reads this packet from the supplied buffer'
4507         self._bufferstartoffset=buf.getcurrentoffset()
4508         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
4509         self.__field_used=UINT(**{'sizeinbytes': 1})
4510         self.__field_used.readfrombuffer(buf)
4511         self._bufferendoffset=buf.getcurrentoffset()
4512 
4513 
4514     def __getfield_used(self):
4515         return self.__field_used.getvalue()
4516 
4517     def __setfield_used(self, value):
4518         if isinstance(value,UINT):
4519             self.__field_used=value
4520         else:
4521             self.__field_used=UINT(value,**{'sizeinbytes': 1})
4522 
4523     def __delfield_used(self): del self.__field_used
4524 
4525     used=property(__getfield_used, __setfield_used, __delfield_used, "1 if slot in use")
4526 
4527     def iscontainer(self):
4528         return True
4529 
4530     def containerelements(self):
4531         yield ('used', self.__field_used, "1 if slot in use")
4532 
4533 
4534 
4535 
4536 class _gen_p_sanyonewer_263(BaseProtogenClass):
4537     'Anonymous inner class'
4538     __fields=['firsttype']
4539 
4540     def __init__(self, *args, **kwargs):
4541         dict={}
4542         # What was supplied to this function
4543         dict.update(kwargs)
4544         # Parent constructor
4545         super(_gen_p_sanyonewer_263,self).__init__(**dict)
4546         if self.__class__ is _gen_p_sanyonewer_263:
4547             self._update(args,dict)
4548 
4549 
4550     def getfields(self):
4551         return self.__fields
4552 
4553 
4554     def _update(self, args, kwargs):
4555         super(_gen_p_sanyonewer_263,self)._update(args,kwargs)
4556         keys=kwargs.keys()
4557         for key in keys:
4558             if key in self.__fields:
4559                 setattr(self, key, kwargs[key])
4560                 del kwargs[key]
4561         # Were any unrecognized kwargs passed in?
4562         if __debug__:
4563             self._complainaboutunusedargs(_gen_p_sanyonewer_263,kwargs)
4564         if len(args):
4565             dict2={'sizeinbytes': 1}
4566             dict2.update(kwargs)
4567             kwargs=dict2
4568             self.__field_firsttype=UINT(*args,**dict2)
4569         # Make all P fields that haven't already been constructed
4570 
4571 
4572     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
4573         'Writes this packet to the supplied buffer'
4574         self._bufferstartoffset=buf.getcurrentoffset()
4575         self.__field_firsttype.writetobuffer(buf)
4576         self._bufferendoffset=buf.getcurrentoffset()
4577         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
4578 
4579 
4580     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
4581         'Reads this packet from the supplied buffer'
4582         self._bufferstartoffset=buf.getcurrentoffset()
4583         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
4584         self.__field_firsttype=UINT(**{'sizeinbytes': 1})
4585         self.__field_firsttype.readfrombuffer(buf)
4586         self._bufferendoffset=buf.getcurrentoffset()
4587 
4588 
4589     def __getfield_firsttype(self):
4590         return self.__field_firsttype.getvalue()
4591 
4592     def __setfield_firsttype(self, value):
4593         if isinstance(value,UINT):
4594             self.__field_firsttype=value
4595         else:
4596             self.__field_firsttype=UINT(value,**{'sizeinbytes': 1})
4597 
4598     def __delfield_firsttype(self): del self.__field_firsttype
4599 
4600     firsttype=property(__getfield_firsttype, __setfield_firsttype, __delfield_firsttype, "First phone number type in each slot")
4601 
4602     def iscontainer(self):
4603         return True
4604 
4605     def containerelements(self):
4606         yield ('firsttype', self.__field_firsttype, "First phone number type in each slot")
4607 
4608 
4609 
4610 
4611 class _gen_p_sanyonewer_265(BaseProtogenClass):
4612     'Anonymous inner class'
4613     __fields=['pbslot']
4614 
4615     def __init__(self, *args, **kwargs):
4616         dict={}
4617         # What was supplied to this function
4618         dict.update(kwargs)
4619         # Parent constructor
4620         super(_gen_p_sanyonewer_265,self).__init__(**dict)
4621         if self.__class__ is _gen_p_sanyonewer_265:
4622             self._update(args,dict)
4623 
4624 
4625     def getfields(self):
4626         return self.__fields
4627 
4628 
4629     def _update(self, args, kwargs):
4630         super(_gen_p_sanyonewer_265,self)._update(args,kwargs)
4631         keys=kwargs.keys()
4632         for key in keys:
4633             if key in self.__fields:
4634                 setattr(self, key, kwargs[key])
4635                 del kwargs[key]
4636         # Were any unrecognized kwargs passed in?
4637         if __debug__:
4638             self._complainaboutunusedargs(_gen_p_sanyonewer_265,kwargs)
4639         if len(args):
4640             dict2={'sizeinbytes': 2, 'default': 0xffff}
4641             dict2.update(kwargs)
4642             kwargs=dict2
4643             self.__field_pbslot=UINT(*args,**dict2)
4644         # Make all P fields that haven't already been constructed
4645 
4646 
4647     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
4648         'Writes this packet to the supplied buffer'
4649         self._bufferstartoffset=buf.getcurrentoffset()
4650         self.__field_pbslot.writetobuffer(buf)
4651         self._bufferendoffset=buf.getcurrentoffset()
4652         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
4653 
4654 
4655     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
4656         'Reads this packet from the supplied buffer'
4657         self._bufferstartoffset=buf.getcurrentoffset()
4658         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
4659         self.__field_pbslot=UINT(**{'sizeinbytes': 2, 'default': 0xffff})
4660         self.__field_pbslot.readfrombuffer(buf)
4661         self._bufferendoffset=buf.getcurrentoffset()
4662 
4663 
4664     def __getfield_pbslot(self):
4665         return self.__field_pbslot.getvalue()
4666 
4667     def __setfield_pbslot(self, value):
4668         if isinstance(value,UINT):
4669             self.__field_pbslot=value
4670         else:
4671             self.__field_pbslot=UINT(value,**{'sizeinbytes': 2, 'default': 0xffff})
4672 
4673     def __delfield_pbslot(self): del self.__field_pbslot
4674 
4675     pbslot=property(__getfield_pbslot, __setfield_pbslot, __delfield_pbslot, None)
4676 
4677     def iscontainer(self):
4678         return True
4679 
4680     def containerelements(self):
4681         yield ('pbslot', self.__field_pbslot, None)
4682 
4683 
4684 
4685 
4686 class _gen_p_sanyonewer_268(BaseProtogenClass):
4687     'Anonymous inner class'
4688     __fields=['pbslot']
4689 
4690     def __init__(self, *args, **kwargs):
4691         dict={}
4692         # What was supplied to this function
4693         dict.update(kwargs)
4694         # Parent constructor
4695         super(_gen_p_sanyonewer_268,self).__init__(**dict)
4696         if self.__class__ is _gen_p_sanyonewer_268:
4697             self._update(args,dict)
4698 
4699 
4700     def getfields(self):
4701         return self.__fields
4702 
4703 
4704     def _update(self, args, kwargs):
4705         super(_gen_p_sanyonewer_268,self)._update(args,kwargs)
4706         keys=kwargs.keys()
4707         for key in keys:
4708             if key in self.__fields:
4709                 setattr(self, key, kwargs[key])
4710                 del kwargs[key]
4711         # Were any unrecognized kwargs passed in?
4712         if __debug__:
4713             self._complainaboutunusedargs(_gen_p_sanyonewer_268,kwargs)
4714         if len(args):
4715             dict2={'sizeinbytes': 2, 'default': 0xffff}
4716             dict2.update(kwargs)
4717             kwargs=dict2
4718             self.__field_pbslot=UINT(*args,**dict2)
4719         # Make all P fields that haven't already been constructed
4720 
4721 
4722     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
4723         'Writes this packet to the supplied buffer'
4724         self._bufferstartoffset=buf.getcurrentoffset()
4725         self.__field_pbslot.writetobuffer(buf)
4726         self._bufferendoffset=buf.getcurrentoffset()
4727         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
4728 
4729 
4730     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
4731         'Reads this packet from the supplied buffer'
4732         self._bufferstartoffset=buf.getcurrentoffset()
4733         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
4734         self.__field_pbslot=UINT(**{'sizeinbytes': 2, 'default': 0xffff})
4735         self.__field_pbslot.readfrombuffer(buf)
4736         self._bufferendoffset=buf.getcurrentoffset()
4737 
4738 
4739     def __getfield_pbslot(self):
4740         return self.__field_pbslot.getvalue()
4741 
4742     def __setfield_pbslot(self, value):
4743         if isinstance(value,UINT):
4744             self.__field_pbslot=value
4745         else:
4746             self.__field_pbslot=UINT(value,**{'sizeinbytes': 2, 'default': 0xffff})
4747 
4748     def __delfield_pbslot(self): del self.__field_pbslot
4749 
4750     pbslot=property(__getfield_pbslot, __setfield_pbslot, __delfield_pbslot, None)
4751 
4752     def iscontainer(self):
4753         return True
4754 
4755     def containerelements(self):
4756         yield ('pbslot', self.__field_pbslot, None)
4757 
4758 
4759 
4760 
4761 class _gen_p_sanyonewer_270(BaseProtogenClass):
4762     'Anonymous inner class'
4763     __fields=['pbslotandtype']
4764 
4765     def __init__(self, *args, **kwargs):
4766         dict={}
4767         # What was supplied to this function
4768         dict.update(kwargs)
4769         # Parent constructor
4770         super(_gen_p_sanyonewer_270,self).__init__(**dict)
4771         if self.__class__ is _gen_p_sanyonewer_270:
4772             self._update(args,dict)
4773 
4774 
4775     def getfields(self):
4776         return self.__fields
4777 
4778 
4779     def _update(self, args, kwargs):
4780         super(_gen_p_sanyonewer_270,self)._update(args,kwargs)
4781         keys=kwargs.keys()
4782         for key in keys:
4783             if key in self.__fields:
4784                 setattr(self, key, kwargs[key])
4785                 del kwargs[key]
4786         # Were any unrecognized kwargs passed in?
4787         if __debug__:
4788             self._complainaboutunusedargs(_gen_p_sanyonewer_270,kwargs)
4789         if len(args):
4790             dict2={'sizeinbytes': 2, 'default': 0xffff}
4791             dict2.update(kwargs)
4792             kwargs=dict2
4793             self.__field_pbslotandtype=UINT(*args,**dict2)
4794         # Make all P fields that haven't already been constructed
4795 
4796 
4797     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
4798         'Writes this packet to the supplied buffer'
4799         self._bufferstartoffset=buf.getcurrentoffset()
4800         self.__field_pbslotandtype.writetobuffer(buf)
4801         self._bufferendoffset=buf.getcurrentoffset()
4802         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
4803 
4804 
4805     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
4806         'Reads this packet from the supplied buffer'
4807         self._bufferstartoffset=buf.getcurrentoffset()
4808         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
4809         self.__field_pbslotandtype=UINT(**{'sizeinbytes': 2, 'default': 0xffff})
4810         self.__field_pbslotandtype.readfrombuffer(buf)
4811         self._bufferendoffset=buf.getcurrentoffset()
4812 
4813 
4814     def __getfield_pbslotandtype(self):
4815         return self.__field_pbslotandtype.getvalue()
4816 
4817     def __setfield_pbslotandtype(self, value):
4818         if isinstance(value,UINT):
4819             self.__field_pbslotandtype=value
4820         else:
4821             self.__field_pbslotandtype=UINT(value,**{'sizeinbytes': 2, 'default': 0xffff})
4822 
4823     def __delfield_pbslotandtype(self): del self.__field_pbslotandtype
4824 
4825     pbslotandtype=property(__getfield_pbslotandtype, __setfield_pbslotandtype, __delfield_pbslotandtype, None)
4826 
4827     def iscontainer(self):
4828         return True
4829 
4830     def containerelements(self):
4831         yield ('pbslotandtype', self.__field_pbslotandtype, None)
4832 
4833 
4834 
4835 
4836 class _gen_p_sanyonewer_272(BaseProtogenClass):
4837     'Anonymous inner class'
4838     __fields=['pbslotandtype']
4839 
4840     def __init__(self, *args, **kwargs):
4841         dict={}
4842         # What was supplied to this function
4843         dict.update(kwargs)
4844         # Parent constructor
4845         super(_gen_p_sanyonewer_272,self).__init__(**dict)
4846         if self.__class__ is _gen_p_sanyonewer_272:
4847             self._update(args,dict)
4848 
4849 
4850     def getfields(self):
4851         return self.__fields
4852 
4853 
4854     def _update(self, args, kwargs):
4855         super(_gen_p_sanyonewer_272,self)._update(args,kwargs)
4856         keys=kwargs.keys()
4857         for key in keys:
4858             if key in self.__fields:
4859                 setattr(self, key, kwargs[key])
4860                 del kwargs[key]
4861         # Were any unrecognized kwargs passed in?
4862         if __debug__:
4863             self._complainaboutunusedargs(_gen_p_sanyonewer_272,kwargs)
4864         if len(args):
4865             dict2={'sizeinbytes': 2, 'default': 0xffff}
4866             dict2.update(kwargs)
4867             kwargs=dict2
4868             self.__field_pbslotandtype=UINT(*args,**dict2)
4869         # Make all P fields that haven't already been constructed
4870 
4871 
4872     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
4873         'Writes this packet to the supplied buffer'
4874         self._bufferstartoffset=buf.getcurrentoffset()
4875         self.__field_pbslotandtype.writetobuffer(buf)
4876         self._bufferendoffset=buf.getcurrentoffset()
4877         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
4878 
4879 
4880     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
4881         'Reads this packet from the supplied buffer'
4882         self._bufferstartoffset=buf.getcurrentoffset()
4883         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
4884         self.__field_pbslotandtype=UINT(**{'sizeinbytes': 2, 'default': 0xffff})
4885         self.__field_pbslotandtype.readfrombuffer(buf)
4886         self._bufferendoffset=buf.getcurrentoffset()
4887 
4888 
4889     def __getfield_pbslotandtype(self):
4890         return self.__field_pbslotandtype.getvalue()
4891 
4892     def __setfield_pbslotandtype(self, value):
4893         if isinstance(value,UINT):
4894             self.__field_pbslotandtype=value
4895         else:
4896             self.__field_pbslotandtype=UINT(value,**{'sizeinbytes': 2, 'default': 0xffff})
4897 
4898     def __delfield_pbslotandtype(self): del self.__field_pbslotandtype
4899 
4900     pbslotandtype=property(__getfield_pbslotandtype, __setfield_pbslotandtype, __delfield_pbslotandtype, None)
4901 
4902     def iscontainer(self):
4903         return True
4904 
4905     def containerelements(self):
4906         yield ('pbslotandtype', self.__field_pbslotandtype, None)
4907 
4908 
4909 
4910 
4911 class _gen_p_sanyonewer_274(BaseProtogenClass):
4912     'Anonymous inner class'
4913     __fields=['pbslot']
4914 
4915     def __init__(self, *args, **kwargs):
4916         dict={}
4917         # What was supplied to this function
4918         dict.update(kwargs)
4919         # Parent constructor
4920         super(_gen_p_sanyonewer_274,self).__init__(**dict)
4921         if self.__class__ is _gen_p_sanyonewer_274:
4922             self._update(args,dict)
4923 
4924 
4925     def getfields(self):
4926         return self.__fields
4927 
4928 
4929     def _update(self, args, kwargs):
4930         super(_gen_p_sanyonewer_274,self)._update(args,kwargs)
4931         keys=kwargs.keys()
4932         for key in keys:
4933             if key in self.__fields:
4934                 setattr(self, key, kwargs[key])
4935                 del kwargs[key]
4936         # Were any unrecognized kwargs passed in?
4937         if __debug__:
4938             self._complainaboutunusedargs(_gen_p_sanyonewer_274,kwargs)
4939         if len(args):
4940             dict2={'sizeinbytes': 2, 'default': 0xffff}
4941             dict2.update(kwargs)
4942             kwargs=dict2
4943             self.__field_pbslot=UINT(*args,**dict2)
4944         # Make all P fields that haven't already been constructed
4945 
4946 
4947     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
4948         'Writes this packet to the supplied buffer'
4949         self._bufferstartoffset=buf.getcurrentoffset()
4950         self.__field_pbslot.writetobuffer(buf)
4951         self._bufferendoffset=buf.getcurrentoffset()
4952         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
4953 
4954 
4955     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
4956         'Reads this packet from the supplied buffer'
4957         self._bufferstartoffset=buf.getcurrentoffset()
4958         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
4959         self.__field_pbslot=UINT(**{'sizeinbytes': 2, 'default': 0xffff})
4960         self.__field_pbslot.readfrombuffer(buf)
4961         self._bufferendoffset=buf.getcurrentoffset()
4962 
4963 
4964     def __getfield_pbslot(self):
4965         return self.__field_pbslot.getvalue()
4966 
4967     def __setfield_pbslot(self, value):
4968         if isinstance(value,UINT):
4969             self.__field_pbslot=value
4970         else:
4971             self.__field_pbslot=UINT(value,**{'sizeinbytes': 2, 'default': 0xffff})
4972 
4973     def __delfield_pbslot(self): del self.__field_pbslot
4974 
4975     pbslot=property(__getfield_pbslot, __setfield_pbslot, __delfield_pbslot, None)
4976 
4977     def iscontainer(self):
4978         return True
4979 
4980     def containerelements(self):
4981         yield ('pbslot', self.__field_pbslot, None)
4982 
4983 
4984 
4985 
4986 class _gen_p_sanyonewer_277(BaseProtogenClass):
4987     'Anonymous inner class'
4988     __fields=['pbslot']
4989 
4990     def __init__(self, *args, **kwargs):
4991         dict={}
4992         # What was supplied to this function
4993         dict.update(kwargs)
4994         # Parent constructor
4995         super(_gen_p_sanyonewer_277,self).__init__(**dict)
4996         if self.__class__ is _gen_p_sanyonewer_277:
4997             self._update(args,dict)
4998 
4999 
5000     def getfields(self):
5001         return self.__fields
5002 
5003 
5004     def _update(self, args, kwargs):
5005         super(_gen_p_sanyonewer_277,self)._update(args,kwargs)
5006         keys=kwargs.keys()
5007         for key in keys:
5008             if key in self.__fields:
5009                 setattr(self, key, kwargs[key])
5010                 del kwargs[key]
5011         # Were any unrecognized kwargs passed in?
5012         if __debug__:
5013             self._complainaboutunusedargs(_gen_p_sanyonewer_277,kwargs)
5014         if len(args):
5015             dict2={'sizeinbytes': 2, 'default': 0xffff}
5016             dict2.update(kwargs)
5017             kwargs=dict2
5018             self.__field_pbslot=UINT(*args,**dict2)
5019         # Make all P fields that haven't already been constructed
5020 
5021 
5022     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
5023         'Writes this packet to the supplied buffer'
5024         self._bufferstartoffset=buf.getcurrentoffset()
5025         self.__field_pbslot.writetobuffer(buf)
5026         self._bufferendoffset=buf.getcurrentoffset()
5027         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
5028 
5029 
5030     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
5031         'Reads this packet from the supplied buffer'
5032         self._bufferstartoffset=buf.getcurrentoffset()
5033         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
5034         self.__field_pbslot=UINT(**{'sizeinbytes': 2, 'default': 0xffff})
5035         self.__field_pbslot.readfrombuffer(buf)
5036         self._bufferendoffset=buf.getcurrentoffset()
5037 
5038 
5039     def __getfield_pbslot(self):
5040         return self.__field_pbslot.getvalue()
5041 
5042     def __setfield_pbslot(self, value):
5043         if isinstance(value,UINT):
5044             self.__field_pbslot=value
5045         else:
5046             self.__field_pbslot=UINT(value,**{'sizeinbytes': 2, 'default': 0xffff})
5047 
5048     def __delfield_pbslot(self): del self.__field_pbslot
5049 
5050     pbslot=property(__getfield_pbslot, __setfield_pbslot, __delfield_pbslot, None)
5051 
5052     def iscontainer(self):
5053         return True
5054 
5055     def containerelements(self):
5056         yield ('pbslot', self.__field_pbslot, None)
5057 
5058 
5059 
5060 
5061 class wallpaperbuffer(BaseProtogenClass):
5062     "Addition buffer of wallpaper assignment info"
5063     __fields=['numpbslots', 'startcommand', 'bufsize', 'comment', 'wallpapers', 'pad']
5064 
5065     def __init__(self, *args, **kwargs):
5066         dict={}
5067         # What was supplied to this function
5068         dict.update(kwargs)
5069         # Parent constructor
5070         super(wallpaperbuffer,self).__init__(**dict)
5071         if self.__class__ is wallpaperbuffer:
5072             self._update(args,dict)
5073 
5074 
5075     def getfields(self):
5076         return self.__fields
5077 
5078 
5079     def _update(self, args, kwargs):
5080         super(wallpaperbuffer,self)._update(args,kwargs)
5081         keys=kwargs.keys()
5082         for key in keys:
5083             if key in self.__fields:
5084                 setattr(self, key, kwargs[key])
5085                 del kwargs[key]
5086         # Were any unrecognized kwargs passed in?
5087         if __debug__:
5088             self._complainaboutunusedargs(wallpaperbuffer,kwargs)
5089         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
5090         # Make all P fields that haven't already been constructed
5091         try: self.__field_numpbslots
5092         except:
5093             self.__field_numpbslots=UINT(**{'constant': _NUMPBSLOTS})
5094         try: self.__field_startcommand
5095         except:
5096             self.__field_startcommand=UINT(**{'constant': 0x69})
5097         try: self.__field_bufsize
5098         except:
5099             self.__field_bufsize=UINT(**{'constant': 2048})
5100         try: self.__field_comment
5101         except:
5102             self.__field_comment=USTRING(**{'default': "wallpaper assignment info"})
5103 
5104 
5105     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
5106         'Writes this packet to the supplied buffer'
5107         self._bufferstartoffset=buf.getcurrentoffset()
5108         try: self.__field_wallpapers
5109         except:
5110             self.__field_wallpapers=LIST(**{'length': _NUMPBSLOTS, 'elementclass': wallpaperinfo})
5111         self.__field_wallpapers.writetobuffer(buf)
5112         try: self.__field_pad
5113         except:
5114             self.__field_pad=UNKNOWN(**{'sizeinbytes': 548})
5115         self.__field_pad.writetobuffer(buf)
5116         self._bufferendoffset=buf.getcurrentoffset()
5117         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
5118 
5119 
5120     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
5121         'Reads this packet from the supplied buffer'
5122         self._bufferstartoffset=buf.getcurrentoffset()
5123         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
5124         self.__field_wallpapers=LIST(**{'length': _NUMPBSLOTS, 'elementclass': wallpaperinfo})
5125         self.__field_wallpapers.readfrombuffer(buf)
5126         self.__field_pad=UNKNOWN(**{'sizeinbytes': 548})
5127         self.__field_pad.readfrombuffer(buf)
5128         self._bufferendoffset=buf.getcurrentoffset()
5129 
5130 
5131     def __getfield_numpbslots(self):
5132         return self.__field_numpbslots.getvalue()
5133 
5134     def __setfield_numpbslots(self, value):
5135         if isinstance(value,UINT):
5136             self.__field_numpbslots=value
5137         else:
5138             self.__field_numpbslots=UINT(value,**{'constant': _NUMPBSLOTS})
5139 
5140     def __delfield_numpbslots(self): del self.__field_numpbslots
5141 
5142     numpbslots=property(__getfield_numpbslots, __setfield_numpbslots, __delfield_numpbslots, "Number of phone book slots")
5143 
5144     def __getfield_startcommand(self):
5145         return self.__field_startcommand.getvalue()
5146 
5147     def __setfield_startcommand(self, value):
5148         if isinstance(value,UINT):
5149             self.__field_startcommand=value
5150         else:
5151             self.__field_startcommand=UINT(value,**{'constant': 0x69})
5152 
5153     def __delfield_startcommand(self): del self.__field_startcommand
5154 
5155     startcommand=property(__getfield_startcommand, __setfield_startcommand, __delfield_startcommand, "Starting command for R/W buf parts")
5156 
5157     def __getfield_bufsize(self):
5158         return self.__field_bufsize.getvalue()
5159 
5160     def __setfield_bufsize(self, value):
5161         if isinstance(value,UINT):
5162             self.__field_bufsize=value
5163         else:
5164             self.__field_bufsize=UINT(value,**{'constant': 2048})
5165 
5166     def __delfield_bufsize(self): del self.__field_bufsize
5167 
5168     bufsize=property(__getfield_bufsize, __setfield_bufsize, __delfield_bufsize, None)
5169 
5170     def __getfield_comment(self):
5171         try: self.__field_comment
5172         except:
5173             self.__field_comment=USTRING(**{'default': "wallpaper assignment info"})
5174         return self.__field_comment.getvalue()
5175 
5176     def __setfield_comment(self, value):
5177         if isinstance(value,USTRING):
5178             self.__field_comment=value
5179         else:
5180             self.__field_comment=USTRING(value,**{'default': "wallpaper assignment info"})
5181 
5182     def __delfield_comment(self): del self.__field_comment
5183 
5184     comment=property(__getfield_comment, __setfield_comment, __delfield_comment, None)
5185 
5186     def __getfield_wallpapers(self):
5187         try: self.__field_wallpapers
5188         except:
5189             self.__field_wallpapers=LIST(**{'length': _NUMPBSLOTS, 'elementclass': wallpaperinfo})
5190         return self.__field_wallpapers.getvalue()
5191 
5192     def __setfield_wallpapers(self, value):
5193         if isinstance(value,LIST):
5194             self.__field_wallpapers=value
5195         else:
5196             self.__field_wallpapers=LIST(value,**{'length': _NUMPBSLOTS, 'elementclass': wallpaperinfo})
5197 
5198     def __delfield_wallpapers(self): del self.__field_wallpapers
5199 
5200     wallpapers=property(__getfield_wallpapers, __setfield_wallpapers, __delfield_wallpapers, None)
5201 
5202     def __getfield_pad(self):
5203         try: self.__field_pad
5204         except:
5205             self.__field_pad=UNKNOWN(**{'sizeinbytes': 548})
5206         return self.__field_pad.getvalue()
5207 
5208     def __setfield_pad(self, value):
5209         if isinstance(value,UNKNOWN):
5210             self.__field_pad=value
5211         else:
5212             self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 548})
5213 
5214     def __delfield_pad(self): del self.__field_pad
5215 
5216     pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None)
5217 
5218     def iscontainer(self):
5219         return True
5220 
5221     def containerelements(self):
5222         yield ('numpbslots', self.__field_numpbslots, "Number of phone book slots")
5223         yield ('startcommand', self.__field_startcommand, "Starting command for R/W buf parts")
5224         yield ('bufsize', self.__field_bufsize, None)
5225         yield ('comment', self.__field_comment, None)
5226         yield ('wallpapers', self.__field_wallpapers, None)
5227         yield ('pad', self.__field_pad, None)
5228 
5229 
5230 
5231 
5232 class messagerequest(BaseProtogenClass):
5233     __fields=['header', 'slot', 'pad']
5234 
5235     def __init__(self, *args, **kwargs):
5236         dict={}
5237         # What was supplied to this function
5238         dict.update(kwargs)
5239         # Parent constructor
5240         super(messagerequest,self).__init__(**dict)
5241         if self.__class__ is messagerequest:
5242             self._update(args,dict)
5243 
5244 
5245     def getfields(self):
5246         return self.__fields
5247 
5248 
5249     def _update(self, args, kwargs):
5250         super(messagerequest,self)._update(args,kwargs)
5251         keys=kwargs.keys()
5252         for key in keys:
5253             if key in self.__fields:
5254                 setattr(self, key, kwargs[key])
5255                 del kwargs[key]
5256         # Were any unrecognized kwargs passed in?
5257         if __debug__:
5258             self._complainaboutunusedargs(messagerequest,kwargs)
5259         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
5260         # Make all P fields that haven't already been constructed
5261 
5262 
5263     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
5264         'Writes this packet to the supplied buffer'
5265         self._bufferstartoffset=buf.getcurrentoffset()
5266         try: self.__field_header
5267         except:
5268             self.__field_header=sanyoheader(**{'packettype': 0x0c,                   'command': 0xe1})
5269         self.__field_header.writetobuffer(buf)
5270         self.__field_slot.writetobuffer(buf)
5271         try: self.__field_pad
5272         except:
5273             self.__field_pad=UNKNOWN(**{'sizeinbytes': 501})
5274         self.__field_pad.writetobuffer(buf)
5275         self._bufferendoffset=buf.getcurrentoffset()
5276         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
5277 
5278 
5279     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
5280         'Reads this packet from the supplied buffer'
5281         self._bufferstartoffset=buf.getcurrentoffset()
5282         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
5283         self.__field_header=sanyoheader(**{'packettype': 0x0c,                   'command': 0xe1})
5284         self.__field_header.readfrombuffer(buf)
5285         self.__field_slot=UINT(**{'sizeinbytes': 1})
5286         self.__field_slot.readfrombuffer(buf)
5287         self.__field_pad=UNKNOWN(**{'sizeinbytes': 501})
5288         self.__field_pad.readfrombuffer(buf)
5289         self._bufferendoffset=buf.getcurrentoffset()
5290 
5291 
5292     def __getfield_header(self):
5293         try: self.__field_header
5294         except:
5295             self.__field_header=sanyoheader(**{'packettype': 0x0c,                   'command': 0xe1})
5296         return self.__field_header.getvalue()
5297 
5298     def __setfield_header(self, value):
5299         if isinstance(value,sanyoheader):
5300             self.__field_header=value
5301         else:
5302             self.__field_header=sanyoheader(value,**{'packettype': 0x0c,                   'command': 0xe1})
5303 
5304     def __delfield_header(self): del self.__field_header
5305 
5306     header=property(__getfield_header, __setfield_header, __delfield_header, None)
5307 
5308     def __getfield_slot(self):
5309         return self.__field_slot.getvalue()
5310 
5311     def __setfield_slot(self, value):
5312         if isinstance(value,UINT):
5313             self.__field_slot=value
5314         else:
5315             self.__field_slot=UINT(value,**{'sizeinbytes': 1})
5316 
5317     def __delfield_slot(self): del self.__field_slot
5318 
5319     slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None)
5320 
5321     def __getfield_pad(self):
5322         try: self.__field_pad
5323         except:
5324             self.__field_pad=UNKNOWN(**{'sizeinbytes': 501})
5325         return self.__field_pad.getvalue()
5326 
5327     def __setfield_pad(self, value):
5328         if isinstance(value,UNKNOWN):
5329             self.__field_pad=value
5330         else:
5331             self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 501})
5332 
5333     def __delfield_pad(self): del self.__field_pad
5334 
5335     pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None)
5336 
5337     def iscontainer(self):
5338         return True
5339 
5340     def containerelements(self):
5341         yield ('header', self.__field_header, None)
5342         yield ('slot', self.__field_slot, None)
5343         yield ('pad', self.__field_pad, None)
5344 
5345 
5346 
5347 
5348 class messagesentrequest(BaseProtogenClass):
5349     __fields=['header', 'slot', 'pad']
5350 
5351     def __init__(self, *args, **kwargs):
5352         dict={}
5353         # What was supplied to this function
5354         dict.update(kwargs)
5355         # Parent constructor
5356         super(messagesentrequest,self).__init__(**dict)
5357         if self.__class__ is messagesentrequest:
5358             self._update(args,dict)
5359 
5360 
5361     def getfields(self):
5362         return self.__fields
5363 
5364 
5365     def _update(self, args, kwargs):
5366         super(messagesentrequest,self)._update(args,kwargs)
5367         keys=kwargs.keys()
5368         for key in keys:
5369             if key in self.__fields:
5370                 setattr(self, key, kwargs[key])
5371                 del kwargs[key]
5372         # Were any unrecognized kwargs passed in?
5373         if __debug__:
5374             self._complainaboutunusedargs(messagesentrequest,kwargs)
5375         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
5376         # Make all P fields that haven't already been constructed
5377 
5378 
5379     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
5380         'Writes this packet to the supplied buffer'
5381         self._bufferstartoffset=buf.getcurrentoffset()
5382         try: self.__field_header
5383         except:
5384             self.__field_header=sanyoheader(**{'packettype': 0x0d,                   'command': 0x55})
5385         self.__field_header.writetobuffer(buf)
5386         self.__field_slot.writetobuffer(buf)
5387         try: self.__field_pad
5388         except:
5389             self.__field_pad=UNKNOWN(**{'sizeinbytes': 501})
5390         self.__field_pad.writetobuffer(buf)
5391         self._bufferendoffset=buf.getcurrentoffset()
5392         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
5393 
5394 
5395     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
5396         'Reads this packet from the supplied buffer'
5397         self._bufferstartoffset=buf.getcurrentoffset()
5398         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
5399         self.__field_header=sanyoheader(**{'packettype': 0x0d,                   'command': 0x55})
5400         self.__field_header.readfrombuffer(buf)
5401         self.__field_slot=UINT(**{'sizeinbytes': 1})
5402         self.__field_slot.readfrombuffer(buf)
5403         self.__field_pad=UNKNOWN(**{'sizeinbytes': 501})
5404         self.__field_pad.readfrombuffer(buf)
5405         self._bufferendoffset=buf.getcurrentoffset()
5406 
5407 
5408     def __getfield_header(self):
5409         try: self.__field_header
5410         except:
5411             self.__field_header=sanyoheader(**{'packettype': 0x0d,                   'command': 0x55})
5412         return self.__field_header.getvalue()
5413 
5414     def __setfield_header(self, value):
5415         if isinstance(value,sanyoheader):
5416             self.__field_header=value
5417         else:
5418             self.__field_header=sanyoheader(value,**{'packettype': 0x0d,                   'command': 0x55})
5419 
5420     def __delfield_header(self): del self.__field_header
5421 
5422     header=property(__getfield_header, __setfield_header, __delfield_header, None)
5423 
5424     def __getfield_slot(self):
5425         return self.__field_slot.getvalue()
5426 
5427     def __setfield_slot(self, value):
5428         if isinstance(value,UINT):
5429             self.__field_slot=value
5430         else:
5431             self.__field_slot=UINT(value,**{'sizeinbytes': 1})
5432 
5433     def __delfield_slot(self): del self.__field_slot
5434 
5435     slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None)
5436 
5437     def __getfield_pad(self):
5438         try: self.__field_pad
5439         except:
5440             self.__field_pad=UNKNOWN(**{'sizeinbytes': 501})
5441         return self.__field_pad.getvalue()
5442 
5443     def __setfield_pad(self, value):
5444         if isinstance(value,UNKNOWN):
5445             self.__field_pad=value
5446         else:
5447             self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 501})
5448 
5449     def __delfield_pad(self): del self.__field_pad
5450 
5451     pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None)
5452 
5453     def iscontainer(self):
5454         return True
5455 
5456     def containerelements(self):
5457         yield ('header', self.__field_header, None)
5458         yield ('slot', self.__field_slot, None)
5459         yield ('pad', self.__field_pad, None)
5460 
5461 
5462 
5463 
5464 class messageentry(BaseProtogenClass):
5465     __fields=['slot', 'read', 'counter', 'pad1', 'dunno1', 'dunno2', 'dunno3', 'pad2', 'dunno4', 'dunno5', 'pad3', 'message_len', 'message', 'pad4', 'year', 'month', 'day', 'hour', 'minute', 'second', 'callback_len', 'callback', 'phonenum_len', 'phonenum', 'dunno6', 'priority', 'pad6', 'dunno7', 'dunno8']
5466 
5467     def __init__(self, *args, **kwargs):
5468         dict={}
5469         # What was supplied to this function
5470         dict.update(kwargs)
5471         # Parent constructor
5472         super(messageentry,self).__init__(**dict)
5473         if self.__class__ is messageentry:
5474             self._update(args,dict)
5475 
5476 
5477     def getfields(self):
5478         return self.__fields
5479 
5480 
5481     def _update(self, args, kwargs):
5482         super(messageentry,self)._update(args,kwargs)
5483         keys=kwargs.keys()
5484         for key in keys:
5485             if key in self.__fields:
5486                 setattr(self, key, kwargs[key])
5487                 del kwargs[key]
5488         # Were any unrecognized kwargs passed in?
5489         if __debug__:
5490             self._complainaboutunusedargs(messageentry,kwargs)
5491         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
5492         # Make all P fields that haven't already been constructed
5493 
5494 
5495     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
5496         'Writes this packet to the supplied buffer'
5497         self._bufferstartoffset=buf.getcurrentoffset()
5498         self.__field_slot.writetobuffer(buf)
5499         self.__field_read.writetobuffer(buf)
5500         self.__field_counter.writetobuffer(buf)
5501         self.__field_pad1.writetobuffer(buf)
5502         self.__field_dunno1.writetobuffer(buf)
5503         self.__field_dunno2.writetobuffer(buf)
5504         self.__field_dunno3.writetobuffer(buf)
5505         self.__field_pad2.writetobuffer(buf)
5506         self.__field_dunno4.writetobuffer(buf)
5507         self.__field_dunno5.writetobuffer(buf)
5508         self.__field_pad3.writetobuffer(buf)
5509         self.__field_message_len.writetobuffer(buf)
5510         self.__field_message.writetobuffer(buf)
5511         self.__field_pad4.writetobuffer(buf)
5512         self.__field_year.writetobuffer(buf)
5513         self.__field_month.writetobuffer(buf)
5514         self.__field_day.writetobuffer(buf)
5515         self.__field_hour.writetobuffer(buf)
5516         self.__field_minute.writetobuffer(buf)
5517         self.__field_second.writetobuffer(buf)
5518         self.__field_callback_len.writetobuffer(buf)
5519         self.__field_callback.writetobuffer(buf)
5520         self.__field_phonenum_len.writetobuffer(buf)
5521         self.__field_phonenum.writetobuffer(buf)
5522         self.__field_dunno6.writetobuffer(buf)
5523         self.__field_priority.writetobuffer(buf)
5524         self.__field_pad6.writetobuffer(buf)
5525         self.__field_dunno7.writetobuffer(buf)
5526         self.__field_dunno8.writetobuffer(buf)
5527         self._bufferendoffset=buf.getcurrentoffset()
5528         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
5529 
5530 
5531     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
5532         'Reads this packet from the supplied buffer'
5533         self._bufferstartoffset=buf.getcurrentoffset()
5534         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
5535         self.__field_slot=UINT(**{'sizeinbytes': 1})
5536         self.__field_slot.readfrombuffer(buf)
5537         self.__field_read=UINT(**{'sizeinbytes': 1})
5538         self.__field_read.readfrombuffer(buf)
5539         self.__field_counter=UINT(**{'sizeinbytes': 1})
5540         self.__field_counter.readfrombuffer(buf)
5541         self.__field_pad1=UNKNOWN(**{'sizeinbytes': 3})
5542         self.__field_pad1.readfrombuffer(buf)
5543         self.__field_dunno1=UINT(**{'sizeinbytes': 1})
5544         self.__field_dunno1.readfrombuffer(buf)
5545         self.__field_dunno2=UINT(**{'sizeinbytes': 1})
5546         self.__field_dunno2.readfrombuffer(buf)
5547         self.__field_dunno3=UINT(**{'sizeinbytes': 1})
5548         self.__field_dunno3.readfrombuffer(buf)
5549         self.__field_pad2=UNKNOWN(**{'sizeinbytes': 1})
5550         self.__field_pad2.readfrombuffer(buf)
5551         self.__field_dunno4=UINT(**{'sizeinbytes': 1})
5552         self.__field_dunno4.readfrombuffer(buf)
5553         self.__field_dunno5=UINT(**{'sizeinbytes': 1})
5554         self.__field_dunno5.readfrombuffer(buf)
5555         self.__field_pad3=UNKNOWN(**{'sizeinbytes': 1})
5556         self.__field_pad3.readfrombuffer(buf)
5557         self.__field_message_len=UINT(**{'sizeinbytes': 1})
5558         self.__field_message_len.readfrombuffer(buf)
5559         self.__field_message=USTRING(**{'sizeinbytes': 255})
5560         self.__field_message.readfrombuffer(buf)
5561         self.__field_pad4=UNKNOWN(**{'sizeinbytes': 1})
5562         self.__field_pad4.readfrombuffer(buf)
5563         self.__field_year=UINT(**{'sizeinbytes': 1})
5564         self.__field_year.readfrombuffer(buf)
5565         self.__field_month=UINT(**{'sizeinbytes': 1})
5566         self.__field_month.readfrombuffer(buf)
5567         self.__field_day=UINT(**{'sizeinbytes': 1})
5568         self.__field_day.readfrombuffer(buf)
5569         self.__field_hour=UINT(**{'sizeinbytes': 1})
5570         self.__field_hour.readfrombuffer(buf)
5571         self.__field_minute=UINT(**{'sizeinbytes': 1})
5572         self.__field_minute.readfrombuffer(buf)
5573         self.__field_second=UINT(**{'sizeinbytes': 1})
5574         self.__field_second.readfrombuffer(buf)
5575         self.__field_callback_len=UINT(**{'sizeinbytes': 1})
5576         self.__field_callback_len.readfrombuffer(buf)
5577         self.__field_callback=USTRING(**{'sizeinbytes': 34})
5578         self.__field_callback.readfrombuffer(buf)
5579         self.__field_phonenum_len=UINT(**{'sizeinbytes': 1})
5580         self.__field_phonenum_len.readfrombuffer(buf)
5581         self.__field_phonenum=USTRING(**{'sizeinbytes': 37})
5582         self.__field_phonenum.readfrombuffer(buf)
5583         self.__field_dunno6=UINT(**{'sizeinbytes': 1})
5584         self.__field_dunno6.readfrombuffer(buf)
5585         self.__field_priority=UINT(**{'sizeinbytes': 1})
5586         self.__field_priority.readfrombuffer(buf)
5587         self.__field_pad6=UNKNOWN(**{'sizeinbytes': 3})
5588         self.__field_pad6.readfrombuffer(buf)
5589         self.__field_dunno7=UINT(**{'sizeinbytes': 1})
5590         self.__field_dunno7.readfrombuffer(buf)
5591         self.__field_dunno8=UINT(**{'sizeinbytes': 1})
5592         self.__field_dunno8.readfrombuffer(buf)
5593         self._bufferendoffset=buf.getcurrentoffset()
5594 
5595 
5596     def __getfield_slot(self):
5597         return self.__field_slot.getvalue()
5598 
5599     def __setfield_slot(self, value):
5600         if isinstance(value,UINT):
5601             self.__field_slot=value
5602         else:
5603             self.__field_slot=UINT(value,**{'sizeinbytes': 1})
5604 
5605     def __delfield_slot(self): del self.__field_slot
5606 
5607     slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None)
5608 
5609     def __getfield_read(self):
5610         return self.__field_read.getvalue()
5611 
5612     def __setfield_read(self, value):
5613         if isinstance(value,UINT):
5614             self.__field_read=value
5615         else:
5616             self.__field_read=UINT(value,**{'sizeinbytes': 1})
5617 
5618     def __delfield_read(self): del self.__field_read
5619 
5620     read=property(__getfield_read, __setfield_read, __delfield_read, None)
5621 
5622     def __getfield_counter(self):
5623         return self.__field_counter.getvalue()
5624 
5625     def __setfield_counter(self, value):
5626         if isinstance(value,UINT):
5627             self.__field_counter=value
5628         else:
5629             self.__field_counter=UINT(value,**{'sizeinbytes': 1})
5630 
5631     def __delfield_counter(self): del self.__field_counter
5632 
5633     counter=property(__getfield_counter, __setfield_counter, __delfield_counter, None)
5634 
5635     def __getfield_pad1(self):
5636         return self.__field_pad1.getvalue()
5637 
5638     def __setfield_pad1(self, value):
5639         if isinstance(value,UNKNOWN):
5640             self.__field_pad1=value
5641         else:
5642             self.__field_pad1=UNKNOWN(value,**{'sizeinbytes': 3})
5643 
5644     def __delfield_pad1(self): del self.__field_pad1
5645 
5646     pad1=property(__getfield_pad1, __setfield_pad1, __delfield_pad1, None)
5647 
5648     def __getfield_dunno1(self):
5649         return self.__field_dunno1.getvalue()
5650 
5651     def __setfield_dunno1(self, value):
5652         if isinstance(value,UINT):
5653             self.__field_dunno1=value
5654         else:
5655             self.__field_dunno1=UINT(value,**{'sizeinbytes': 1})
5656 
5657     def __delfield_dunno1(self): del self.__field_dunno1
5658 
5659     dunno1=property(__getfield_dunno1, __setfield_dunno1, __delfield_dunno1, None)
5660 
5661     def __getfield_dunno2(self):
5662         return self.__field_dunno2.getvalue()
5663 
5664     def __setfield_dunno2(self, value):
5665         if isinstance(value,UINT):
5666             self.__field_dunno2=value
5667         else:
5668             self.__field_dunno2=UINT(value,**{'sizeinbytes': 1})
5669 
5670     def __delfield_dunno2(self): del self.__field_dunno2
5671 
5672     dunno2=property(__getfield_dunno2, __setfield_dunno2, __delfield_dunno2, None)
5673 
5674     def __getfield_dunno3(self):
5675         return self.__field_dunno3.getvalue()
5676 
5677     def __setfield_dunno3(self, value):
5678         if isinstance(value,UINT):
5679             self.__field_dunno3=value
5680         else:
5681             self.__field_dunno3=UINT(value,**{'sizeinbytes': 1})
5682 
5683     def __delfield_dunno3(self): del self.__field_dunno3
5684 
5685     dunno3=property(__getfield_dunno3, __setfield_dunno3, __delfield_dunno3, None)
5686 
5687     def __getfield_pad2(self):
5688         return self.__field_pad2.getvalue()
5689 
5690     def __setfield_pad2(self, value):
5691         if isinstance(value,UNKNOWN):
5692             self.__field_pad2=value
5693         else:
5694             self.__field_pad2=UNKNOWN(value,**{'sizeinbytes': 1})
5695 
5696     def __delfield_pad2(self): del self.__field_pad2
5697 
5698     pad2=property(__getfield_pad2, __setfield_pad2, __delfield_pad2, None)
5699 
5700     def __getfield_dunno4(self):
5701         return self.__field_dunno4.getvalue()
5702 
5703     def __setfield_dunno4(self, value):
5704         if isinstance(value,UINT):
5705             self.__field_dunno4=value
5706         else:
5707             self.__field_dunno4=UINT(value,**{'sizeinbytes': 1})
5708 
5709     def __delfield_dunno4(self): del self.__field_dunno4
5710 
5711     dunno4=property(__getfield_dunno4, __setfield_dunno4, __delfield_dunno4, None)
5712 
5713     def __getfield_dunno5(self):
5714         return self.__field_dunno5.getvalue()
5715 
5716     def __setfield_dunno5(self, value):
5717         if isinstance(value,UINT):
5718             self.__field_dunno5=value
5719         else:
5720             self.__field_dunno5=UINT(value,**{'sizeinbytes': 1})
5721 
5722     def __delfield_dunno5(self): del self.__field_dunno5
5723 
5724     dunno5=property(__getfield_dunno5, __setfield_dunno5, __delfield_dunno5, None)
5725 
5726     def __getfield_pad3(self):
5727         return self.__field_pad3.getvalue()
5728 
5729     def __setfield_pad3(self, value):
5730         if isinstance(value,UNKNOWN):
5731             self.__field_pad3=value
5732         else:
5733             self.__field_pad3=UNKNOWN(value,**{'sizeinbytes': 1})
5734 
5735     def __delfield_pad3(self): del self.__field_pad3
5736 
5737     pad3=property(__getfield_pad3, __setfield_pad3, __delfield_pad3, None)
5738 
5739     def __getfield_message_len(self):
5740         return self.__field_message_len.getvalue()
5741 
5742     def __setfield_message_len(self, value):
5743         if isinstance(value,UINT):
5744             self.__field_message_len=value
5745         else:
5746             self.__field_message_len=UINT(value,**{'sizeinbytes': 1})
5747 
5748     def __delfield_message_len(self): del self.__field_message_len
5749 
5750     message_len=property(__getfield_message_len, __setfield_message_len, __delfield_message_len, None)
5751 
5752     def __getfield_message(self):
5753         return self.__field_message.getvalue()
5754 
5755     def __setfield_message(self, value):
5756         if isinstance(value,USTRING):
5757             self.__field_message=value
5758         else:
5759             self.__field_message=USTRING(value,**{'sizeinbytes': 255})
5760 
5761     def __delfield_message(self): del self.__field_message
5762 
5763     message=property(__getfield_message, __setfield_message, __delfield_message, "Text of the notification")
5764 
5765     def __getfield_pad4(self):
5766         return self.__field_pad4.getvalue()
5767 
5768     def __setfield_pad4(self, value):
5769         if isinstance(value,UNKNOWN):
5770             self.__field_pad4=value
5771         else:
5772             self.__field_pad4=UNKNOWN(value,**{'sizeinbytes': 1})
5773 
5774     def __delfield_pad4(self): del self.__field_pad4
5775 
5776     pad4=property(__getfield_pad4, __setfield_pad4, __delfield_pad4, None)
5777 
5778     def __getfield_year(self):
5779         return self.__field_year.getvalue()
5780 
5781     def __setfield_year(self, value):
5782         if isinstance(value,UINT):
5783             self.__field_year=value
5784         else:
5785             self.__field_year=UINT(value,**{'sizeinbytes': 1})
5786 
5787     def __delfield_year(self): del self.__field_year
5788 
5789     year=property(__getfield_year, __setfield_year, __delfield_year, None)
5790 
5791     def __getfield_month(self):
5792         return self.__field_month.getvalue()
5793 
5794     def __setfield_month(self, value):
5795         if isinstance(value,UINT):
5796             self.__field_month=value
5797         else:
5798             self.__field_month=UINT(value,**{'sizeinbytes': 1})
5799 
5800     def __delfield_month(self): del self.__field_month
5801 
5802     month=property(__getfield_month, __setfield_month, __delfield_month, None)
5803 
5804     def __getfield_day(self):
5805         return self.__field_day.getvalue()
5806 
5807     def __setfield_day(self, value):
5808         if isinstance(value,UINT):
5809             self.__field_day=value
5810         else:
5811             self.__field_day=UINT(value,**{'sizeinbytes': 1})
5812 
5813     def __delfield_day(self): del self.__field_day
5814 
5815     day=property(__getfield_day, __setfield_day, __delfield_day, None)
5816 
5817     def __getfield_hour(self):
5818         return self.__field_hour.getvalue()
5819 
5820     def __setfield_hour(self, value):
5821         if isinstance(value,UINT):
5822             self.__field_hour=value
5823         else:
5824             self.__field_hour=UINT(value,**{'sizeinbytes': 1})
5825 
5826     def __delfield_hour(self): del self.__field_hour
5827 
5828     hour=property(__getfield_hour, __setfield_hour, __delfield_hour, None)
5829 
5830     def __getfield_minute(self):
5831         return self.__field_minute.getvalue()
5832 
5833     def __setfield_minute(self, value):
5834         if isinstance(value,UINT):
5835             self.__field_minute=value
5836         else:
5837             self.__field_minute=UINT(value,**{'sizeinbytes': 1})
5838 
5839     def __delfield_minute(self): del self.__field_minute
5840 
5841     minute=property(__getfield_minute, __setfield_minute, __delfield_minute, None)
5842 
5843     def __getfield_second(self):
5844         return self.__field_second.getvalue()
5845 
5846     def __setfield_second(self, value):
5847         if isinstance(value,UINT):
5848             self.__field_second=value
5849         else:
5850             self.__field_second=UINT(value,**{'sizeinbytes': 1})
5851 
5852     def __delfield_second(self): del self.__field_second
5853 
5854     second=property(__getfield_second, __setfield_second, __delfield_second, None)
5855 
5856     def __getfield_callback_len(self):
5857         return self.__field_callback_len.getvalue()
5858 
5859     def __setfield_callback_len(self, value):
5860         if isinstance(value,UINT):
5861             self.__field_callback_len=value
5862         else:
5863             self.__field_callback_len=UINT(value,**{'sizeinbytes': 1})
5864 
5865     def __delfield_callback_len(self): del self.__field_callback_len
5866 
5867     callback_len=property(__getfield_callback_len, __setfield_callback_len, __delfield_callback_len, None)
5868 
5869     def __getfield_callback(self):
5870         return self.__field_callback.getvalue()
5871 
5872     def __setfield_callback(self, value):
5873         if isinstance(value,USTRING):
5874             self.__field_callback=value
5875         else:
5876             self.__field_callback=USTRING(value,**{'sizeinbytes': 34})
5877 
5878     def __delfield_callback(self): del self.__field_callback
5879 
5880     callback=property(__getfield_callback, __setfield_callback, __delfield_callback, None)
5881 
5882     def __getfield_phonenum_len(self):
5883         return self.__field_phonenum_len.getvalue()
5884 
5885     def __setfield_phonenum_len(self, value):
5886         if isinstance(value,UINT):
5887             self.__field_phonenum_len=value
5888         else:
5889             self.__field_phonenum_len=UINT(value,**{'sizeinbytes': 1})
5890 
5891     def __delfield_phonenum_len(self): del self.__field_phonenum_len
5892 
5893     phonenum_len=property(__getfield_phonenum_len, __setfield_phonenum_len, __delfield_phonenum_len, None)
5894 
5895     def __getfield_phonenum(self):
5896         return self.__field_phonenum.getvalue()
5897 
5898     def __setfield_phonenum(self, value):
5899         if isinstance(value,USTRING):
5900             self.__field_phonenum=value
5901         else:
5902             self.__field_phonenum=USTRING(value,**{'sizeinbytes': 37})
5903 
5904     def __delfield_phonenum(self): del self.__field_phonenum
5905 
5906     phonenum=property(__getfield_phonenum, __setfield_phonenum, __delfield_phonenum, None)
5907 
5908     def __getfield_dunno6(self):
5909         return self.__field_dunno6.getvalue()
5910 
5911     def __setfield_dunno6(self, value):
5912         if isinstance(value,UINT):
5913             self.__field_dunno6=value
5914         else:
5915             self.__field_dunno6=UINT(value,**{'sizeinbytes': 1})
5916 
5917     def __delfield_dunno6(self): del self.__field_dunno6
5918 
5919     dunno6=property(__getfield_dunno6, __setfield_dunno6, __delfield_dunno6, None)
5920 
5921     def __getfield_priority(self):
5922         return self.__field_priority.getvalue()
5923 
5924     def __setfield_priority(self, value):
5925         if isinstance(value,UINT):
5926             self.__field_priority=value
5927         else:
5928             self.__field_priority=UINT(value,**{'sizeinbytes': 1})
5929 
5930     def __delfield_priority(self): del self.__field_priority
5931 
5932     priority=property(__getfield_priority, __setfield_priority, __delfield_priority, None)
5933 
5934     def __getfield_pad6(self):
5935         return self.__field_pad6.getvalue()
5936 
5937     def __setfield_pad6(self, value):
5938         if isinstance(value,UNKNOWN):
5939             self.__field_pad6=value
5940         else:
5941             self.__field_pad6=UNKNOWN(value,**{'sizeinbytes': 3})
5942 
5943     def __delfield_pad6(self): del self.__field_pad6
5944 
5945     pad6=property(__getfield_pad6, __setfield_pad6, __delfield_pad6, None)
5946 
5947     def __getfield_dunno7(self):
5948         return self.__field_dunno7.getvalue()
5949 
5950     def __setfield_dunno7(self, value):
5951         if isinstance(value,UINT):
5952             self.__field_dunno7=value
5953         else:
5954             self.__field_dunno7=UINT(value,**{'sizeinbytes': 1})
5955 
5956     def __delfield_dunno7(self): del self.__field_dunno7
5957 
5958     dunno7=property(__getfield_dunno7, __setfield_dunno7, __delfield_dunno7, None)
5959 
5960     def __getfield_dunno8(self):
5961         return self.__field_dunno8.getvalue()
5962 
5963     def __setfield_dunno8(self, value):
5964         if isinstance(value,UINT):
5965             self.__field_dunno8=value
5966         else:
5967             self.__field_dunno8=UINT(value,**{'sizeinbytes': 1})
5968 
5969     def __delfield_dunno8(self): del self.__field_dunno8
5970 
5971     dunno8=property(__getfield_dunno8, __setfield_dunno8, __delfield_dunno8, None)
5972 
5973     def iscontainer(self):
5974         return True
5975 
5976     def containerelements(self):
5977         yield ('slot', self.__field_slot, None)
5978         yield ('read', self.__field_read, None)
5979         yield ('counter', self.__field_counter, None)
5980         yield ('pad1', self.__field_pad1, None)
5981         yield ('dunno1', self.__field_dunno1, None)
5982         yield ('dunno2', self.__field_dunno2, None)
5983         yield ('dunno3', self.__field_dunno3, None)
5984         yield ('pad2', self.__field_pad2, None)
5985         yield ('dunno4', self.__field_dunno4, None)
5986         yield ('dunno5', self.__field_dunno5, None)
5987         yield ('pad3', self.__field_pad3, None)
5988         yield ('message_len', self.__field_message_len, None)
5989         yield ('message', self.__field_message, "Text of the notification")
5990         yield ('pad4', self.__field_pad4, None)
5991         yield ('year', self.__field_year, None)
5992         yield ('month', self.__field_month, None)
5993         yield ('day', self.__field_day, None)
5994         yield ('hour', self.__field_hour, None)
5995         yield ('minute', self.__field_minute, None)
5996         yield ('second', self.__field_second, None)
5997         yield ('callback_len', self.__field_callback_len, None)
5998         yield ('callback', self.__field_callback, None)
5999         yield ('phonenum_len', self.__field_phonenum_len, None)
6000         yield ('phonenum', self.__field_phonenum, None)
6001         yield ('dunno6', self.__field_dunno6, None)
6002         yield ('priority', self.__field_priority, None)
6003         yield ('pad6', self.__field_pad6, None)
6004         yield ('dunno7', self.__field_dunno7, None)
6005         yield ('dunno8', self.__field_dunno8, None)
6006 
6007 
6008 
6009 
6010 class messageresponse(BaseProtogenClass):
6011     __fields=['header', 'entry', 'pad']
6012 
6013     def __init__(self, *args, **kwargs):
6014         dict={}
6015         # What was supplied to this function
6016         dict.update(kwargs)
6017         # Parent constructor
6018         super(messageresponse,self).__init__(**dict)
6019         if self.__class__ is messageresponse:
6020             self._update(args,dict)
6021 
6022 
6023     def getfields(self):
6024         return self.__fields
6025 
6026 
6027     def _update(self, args, kwargs):
6028         super(messageresponse,self)._update(args,kwargs)
6029         keys=kwargs.keys()
6030         for key in keys:
6031             if key in self.__fields:
6032                 setattr(self, key, kwargs[key])
6033                 del kwargs[key]
6034         # Were any unrecognized kwargs passed in?
6035         if __debug__:
6036             self._complainaboutunusedargs(messageresponse,kwargs)
6037         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
6038         # Make all P fields that haven't already been constructed
6039 
6040 
6041     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
6042         'Writes this packet to the supplied buffer'
6043         self._bufferstartoffset=buf.getcurrentoffset()
6044         self.__field_header.writetobuffer(buf)
6045         self.__field_entry.writetobuffer(buf)
6046         self.__field_pad.writetobuffer(buf)
6047         self._bufferendoffset=buf.getcurrentoffset()
6048         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
6049 
6050 
6051     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
6052         'Reads this packet from the supplied buffer'
6053         self._bufferstartoffset=buf.getcurrentoffset()
6054         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
6055         self.__field_header=sanyoheader()
6056         self.__field_header.readfrombuffer(buf)
6057         self.__field_entry=messageentry()
6058         self.__field_entry.readfrombuffer(buf)
6059         self.__field_pad=UNKNOWN()
6060         self.__field_pad.readfrombuffer(buf)
6061         self._bufferendoffset=buf.getcurrentoffset()
6062 
6063 
6064     def __getfield_header(self):
6065         return self.__field_header.getvalue()
6066 
6067     def __setfield_header(self, value):
6068         if isinstance(value,sanyoheader):
6069             self.__field_header=value
6070         else:
6071             self.__field_header=sanyoheader(value,)
6072 
6073     def __delfield_header(self): del self.__field_header
6074 
6075     header=property(__getfield_header, __setfield_header, __delfield_header, None)
6076 
6077     def __getfield_entry(self):
6078         return self.__field_entry.getvalue()
6079 
6080     def __setfield_entry(self, value):
6081         if isinstance(value,messageentry):
6082             self.__field_entry=value
6083         else:
6084             self.__field_entry=messageentry(value,)
6085 
6086     def __delfield_entry(self): del self.__field_entry
6087 
6088     entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None)
6089 
6090     def __getfield_pad(self):
6091         return self.__field_pad.getvalue()
6092 
6093     def __setfield_pad(self, value):
6094         if isinstance(value,UNKNOWN):
6095             self.__field_pad=value
6096         else:
6097             self.__field_pad=UNKNOWN(value,)
6098 
6099     def __delfield_pad(self): del self.__field_pad
6100 
6101     pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None)
6102 
6103     def iscontainer(self):
6104         return True
6105 
6106     def containerelements(self):
6107         yield ('header', self.__field_header, None)
6108         yield ('entry', self.__field_entry, None)
6109         yield ('pad', self.__field_pad, None)
6110 
6111 
6112 
6113 
6114 class messagesentresponse(BaseProtogenClass):
6115     __fields=['header', 'entry', 'pad']
6116 
6117     def __init__(self, *args, **kwargs):
6118         dict={}
6119         # What was supplied to this function
6120         dict.update(kwargs)
6121         # Parent constructor
6122         super(messagesentresponse,self).__init__(**dict)
6123         if self.__class__ is messagesentresponse:
6124             self._update(args,dict)
6125 
6126 
6127     def getfields(self):
6128         return self.__fields
6129 
6130 
6131     def _update(self, args, kwargs):
6132         super(messagesentresponse,self)._update(args,kwargs)
6133         keys=kwargs.keys()
6134         for key in keys:
6135             if key in self.__fields:
6136                 setattr(self, key, kwargs[key])
6137                 del kwargs[key]
6138         # Were any unrecognized kwargs passed in?
6139         if __debug__:
6140             self._complainaboutunusedargs(messagesentresponse,kwargs)
6141         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
6142         # Make all P fields that haven't already been constructed
6143 
6144 
6145     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
6146         'Writes this packet to the supplied buffer'
6147         self._bufferstartoffset=buf.getcurrentoffset()
6148         self.__field_header.writetobuffer(buf)
6149         self.__field_entry.writetobuffer(buf)
6150         self.__field_pad.writetobuffer(buf)
6151         self._bufferendoffset=buf.getcurrentoffset()
6152         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
6153 
6154 
6155     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
6156         'Reads this packet from the supplied buffer'
6157         self._bufferstartoffset=buf.getcurrentoffset()
6158         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
6159         self.__field_header=sanyoheader()
6160         self.__field_header.readfrombuffer(buf)
6161         self.__field_entry=messageentry()
6162         self.__field_entry.readfrombuffer(buf)
6163         self.__field_pad=UNKNOWN()
6164         self.__field_pad.readfrombuffer(buf)
6165         self._bufferendoffset=buf.getcurrentoffset()
6166 
6167 
6168     def __getfield_header(self):
6169         return self.__field_header.getvalue()
6170 
6171     def __setfield_header(self, value):
6172         if isinstance(value,sanyoheader):
6173             self.__field_header=value
6174         else:
6175             self.__field_header=sanyoheader(value,)
6176 
6177     def __delfield_header(self): del self.__field_header
6178 
6179     header=property(__getfield_header, __setfield_header, __delfield_header, None)
6180 
6181     def __getfield_entry(self):
6182         return self.__field_entry.getvalue()
6183 
6184     def __setfield_entry(self, value):
6185         if isinstance(value,messageentry):
6186             self.__field_entry=value
6187         else:
6188             self.__field_entry=messageentry(value,)
6189 
6190     def __delfield_entry(self): del self.__field_entry
6191 
6192     entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None)
6193 
6194     def __getfield_pad(self):
6195         return self.__field_pad.getvalue()
6196 
6197     def __setfield_pad(self, value):
6198         if isinstance(value,UNKNOWN):
6199             self.__field_pad=value
6200         else:
6201             self.__field_pad=UNKNOWN(value,)
6202 
6203     def __delfield_pad(self): del self.__field_pad
6204 
6205     pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None)
6206 
6207     def iscontainer(self):
6208         return True
6209 
6210     def containerelements(self):
6211         yield ('header', self.__field_header, None)
6212         yield ('entry', self.__field_entry, None)
6213         yield ('pad', self.__field_pad, None)
6214 
6215 
6216 
6217 
6218 class foldernamerequest(BaseProtogenClass):
6219     __fields=['header', 'index', 'pad']
6220 
6221     def __init__(self, *args, **kwargs):
6222         dict={}
6223         # What was supplied to this function
6224         dict.update(kwargs)
6225         # Parent constructor
6226         super(foldernamerequest,self).__init__(**dict)
6227         if self.__class__ is foldernamerequest:
6228             self._update(args,dict)
6229 
6230 
6231     def getfields(self):
6232         return self.__fields
6233 
6234 
6235     def _update(self, args, kwargs):
6236         super(foldernamerequest,self)._update(args,kwargs)
6237         keys=kwargs.keys()
6238         for key in keys:
6239             if key in self.__fields:
6240                 setattr(self, key, kwargs[key])
6241                 del kwargs[key]
6242         # Were any unrecognized kwargs passed in?
6243         if __debug__:
6244             self._complainaboutunusedargs(foldernamerequest,kwargs)
6245         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
6246         # Make all P fields that haven't already been constructed
6247 
6248 
6249     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
6250         'Writes this packet to the supplied buffer'
6251         self._bufferstartoffset=buf.getcurrentoffset()
6252         try: self.__field_header
6253         except:
6254             self.__field_header=sanyoheader(**{'packettype': 0x0b, 'command': 0xef})
6255         self.__field_header.writetobuffer(buf)
6256         self.__field_index.writetobuffer(buf)
6257         try: self.__field_pad
6258         except:
6259             self.__field_pad=UNKNOWN(**{'sizeinbytes': 501})
6260         self.__field_pad.writetobuffer(buf)
6261         self._bufferendoffset=buf.getcurrentoffset()
6262         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
6263 
6264 
6265     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
6266         'Reads this packet from the supplied buffer'
6267         self._bufferstartoffset=buf.getcurrentoffset()
6268         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
6269         self.__field_header=sanyoheader(**{'packettype': 0x0b, 'command': 0xef})
6270         self.__field_header.readfrombuffer(buf)
6271         self.__field_index=UINT(**{'sizeinbytes': 1})
6272         self.__field_index.readfrombuffer(buf)
6273         self.__field_pad=UNKNOWN(**{'sizeinbytes': 501})
6274         self.__field_pad.readfrombuffer(buf)
6275         self._bufferendoffset=buf.getcurrentoffset()
6276 
6277 
6278     def __getfield_header(self):
6279         try: self.__field_header
6280         except:
6281             self.__field_header=sanyoheader(**{'packettype': 0x0b, 'command': 0xef})
6282         return self.__field_header.getvalue()
6283 
6284     def __setfield_header(self, value):
6285         if isinstance(value,sanyoheader):
6286             self.__field_header=value
6287         else:
6288             self.__field_header=sanyoheader(value,**{'packettype': 0x0b, 'command': 0xef})
6289 
6290     def __delfield_header(self): del self.__field_header
6291 
6292     header=property(__getfield_header, __setfield_header, __delfield_header, None)
6293 
6294     def __getfield_index(self):
6295         return self.__field_index.getvalue()
6296 
6297     def __setfield_index(self, value):
6298         if isinstance(value,UINT):
6299             self.__field_index=value
6300         else:
6301             self.__field_index=UINT(value,**{'sizeinbytes': 1})
6302 
6303     def __delfield_index(self): del self.__field_index
6304 
6305     index=property(__getfield_index, __setfield_index, __delfield_index, None)
6306 
6307     def __getfield_pad(self):
6308         try: self.__field_pad
6309         except:
6310             self.__field_pad=UNKNOWN(**{'sizeinbytes': 501})
6311         return self.__field_pad.getvalue()
6312 
6313     def __setfield_pad(self, value):
6314         if isinstance(value,UNKNOWN):
6315             self.__field_pad=value
6316         else:
6317             self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 501})
6318 
6319     def __delfield_pad(self): del self.__field_pad
6320 
6321     pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None)
6322 
6323     def iscontainer(self):
6324         return True
6325 
6326     def containerelements(self):
6327         yield ('header', self.__field_header, None)
6328         yield ('index', self.__field_index, None)
6329         yield ('pad', self.__field_pad, None)
6330 
6331 
6332 
6333 
6334 class foldernameentry(BaseProtogenClass):
6335     __fields=['index', 'flag', 'autofile', 'notify', 'icon', 'name', 'pad', 'keyword']
6336 
6337     def __init__(self, *args, **kwargs):
6338         dict={}
6339         # What was supplied to this function
6340         dict.update(kwargs)
6341         # Parent constructor
6342         super(foldernameentry,self).__init__(**dict)
6343         if self.__class__ is foldernameentry:
6344             self._update(args,dict)
6345 
6346 
6347     def getfields(self):
6348         return self.__fields
6349 
6350 
6351     def _update(self, args, kwargs):
6352         super(foldernameentry,self)._update(args,kwargs)
6353         keys=kwargs.keys()
6354         for key in keys:
6355             if key in self.__fields:
6356                 setattr(self, key, kwargs[key])
6357                 del kwargs[key]
6358         # Were any unrecognized kwargs passed in?
6359         if __debug__:
6360             self._complainaboutunusedargs(foldernameentry,kwargs)
6361         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
6362         # Make all P fields that haven't already been constructed
6363 
6364 
6365     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
6366         'Writes this packet to the supplied buffer'
6367         self._bufferstartoffset=buf.getcurrentoffset()
6368         self.__field_index.writetobuffer(buf)
6369         self.__field_flag.writetobuffer(buf)
6370         self.__field_autofile.writetobuffer(buf)
6371         self.__field_notify.writetobuffer(buf)
6372         self.__field_icon.writetobuffer(buf)
6373         self.__field_name.writetobuffer(buf)
6374         try: self.__field_pad
6375         except:
6376             self.__field_pad=UNKNOWN(**{'sizeinbytes': 3})
6377         self.__field_pad.writetobuffer(buf)
6378         self.__field_keyword.writetobuffer(buf)
6379         self._bufferendoffset=buf.getcurrentoffset()
6380         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
6381 
6382 
6383     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
6384         'Reads this packet from the supplied buffer'
6385         self._bufferstartoffset=buf.getcurrentoffset()
6386         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
6387         self.__field_index=UINT(**{'sizeinbytes': 1})
6388         self.__field_index.readfrombuffer(buf)
6389         self.__field_flag=UINT(**{'sizeinbytes': 1})
6390         self.__field_flag.readfrombuffer(buf)
6391         self.__field_autofile=UINT(**{'sizeinbytes': 1})
6392         self.__field_autofile.readfrombuffer(buf)
6393         self.__field_notify=UINT(**{'sizeinbytes': 1})
6394         self.__field_notify.readfrombuffer(buf)
6395         self.__field_icon=UINT(**{'sizeinbytes': 1})
6396         self.__field_icon.readfrombuffer(buf)
6397         self.__field_name=USTRING(**{'sizeinbytes': 13, 'raiseonunterminatedread': False})
6398         self.__field_name.readfrombuffer(buf)
6399         self.__field_pad=UNKNOWN(**{'sizeinbytes': 3})
6400         self.__field_pad.readfrombuffer(buf)
6401         self.__field_keyword=USTRING(**{'sizeinbytes': 14, 'raiseonunterminatedread': False})
6402         self.__field_keyword.readfrombuffer(buf)
6403         self._bufferendoffset=buf.getcurrentoffset()
6404 
6405 
6406     def __getfield_index(self):
6407         return self.__field_index.getvalue()
6408 
6409     def __setfield_index(self, value):
6410         if isinstance(value,UINT):
6411             self.__field_index=value
6412         else:
6413             self.__field_index=UINT(value,**{'sizeinbytes': 1})
6414 
6415     def __delfield_index(self): del self.__field_index
6416 
6417     index=property(__getfield_index, __setfield_index, __delfield_index, None)
6418 
6419     def __getfield_flag(self):
6420         return self.__field_flag.getvalue()
6421 
6422     def __setfield_flag(self, value):
6423         if isinstance(value,UINT):
6424             self.__field_flag=value
6425         else:
6426             self.__field_flag=UINT(value,**{'sizeinbytes': 1})
6427 
6428     def __delfield_flag(self): del self.__field_flag
6429 
6430     flag=property(__getfield_flag, __setfield_flag, __delfield_flag, "0 if empty, 1 in use")
6431 
6432     def __getfield_autofile(self):
6433         return self.__field_autofile.getvalue()
6434 
6435     def __setfield_autofile(self, value):
6436         if isinstance(value,UINT):
6437             self.__field_autofile=value
6438         else:
6439             self.__field_autofile=UINT(value,**{'sizeinbytes': 1})
6440 
6441     def __delfield_autofile(self): del self.__field_autofile
6442 
6443     autofile=property(__getfield_autofile, __setfield_autofile, __delfield_autofile, "If 1, autofile messages with keyword")
6444 
6445     def __getfield_notify(self):
6446         return self.__field_notify.getvalue()
6447 
6448     def __setfield_notify(self, value):
6449         if isinstance(value,UINT):
6450             self.__field_notify=value
6451         else:
6452             self.__field_notify=UINT(value,**{'sizeinbytes': 1})
6453 
6454     def __delfield_notify(self): del self.__field_notify
6455 
6456     notify=property(__getfield_notify, __setfield_notify, __delfield_notify, None)
6457 
6458     def __getfield_icon(self):
6459         return self.__field_icon.getvalue()
6460 
6461     def __setfield_icon(self, value):
6462         if isinstance(value,UINT):
6463             self.__field_icon=value
6464         else:
6465             self.__field_icon=UINT(value,**{'sizeinbytes': 1})
6466 
6467     def __delfield_icon(self): del self.__field_icon
6468 
6469     icon=property(__getfield_icon, __setfield_icon, __delfield_icon, None)
6470 
6471     def __getfield_name(self):
6472         return self.__field_name.getvalue()
6473 
6474     def __setfield_name(self, value):
6475         if isinstance(value,USTRING):
6476             self.__field_name=value
6477         else:
6478             self.__field_name=USTRING(value,**{'sizeinbytes': 13, 'raiseonunterminatedread': False})
6479 
6480     def __delfield_name(self): del self.__field_name
6481 
6482     name=property(__getfield_name, __setfield_name, __delfield_name, "Name of the folder")
6483 
6484     def __getfield_pad(self):
6485         try: self.__field_pad
6486         except:
6487             self.__field_pad=UNKNOWN(**{'sizeinbytes': 3})
6488         return self.__field_pad.getvalue()
6489 
6490     def __setfield_pad(self, value):
6491         if isinstance(value,UNKNOWN):
6492             self.__field_pad=value
6493         else:
6494             self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 3})
6495 
6496     def __delfield_pad(self): del self.__field_pad
6497 
6498     pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None)
6499 
6500     def __getfield_keyword(self):
6501         return self.__field_keyword.getvalue()
6502 
6503     def __setfield_keyword(self, value):
6504         if isinstance(value,USTRING):
6505             self.__field_keyword=value
6506         else:
6507             self.__field_keyword=USTRING(value,**{'sizeinbytes': 14, 'raiseonunterminatedread': False})
6508 
6509     def __delfield_keyword(self): del self.__field_keyword
6510 
6511     keyword=property(__getfield_keyword, __setfield_keyword, __delfield_keyword, None)
6512 
6513     def iscontainer(self):
6514         return True
6515 
6516     def containerelements(self):
6517         yield ('index', self.__field_index, None)
6518         yield ('flag', self.__field_flag, "0 if empty, 1 in use")
6519         yield ('autofile', self.__field_autofile, "If 1, autofile messages with keyword")
6520         yield ('notify', self.__field_notify, None)
6521         yield ('icon', self.__field_icon, None)
6522         yield ('name', self.__field_name, "Name of the folder")
6523         yield ('pad', self.__field_pad, None)
6524         yield ('keyword', self.__field_keyword, None)
6525 
6526 
6527 
6528 
6529 class foldernameresponse(BaseProtogenClass):
6530     __fields=['header', 'entry', 'pad']
6531 
6532     def __init__(self, *args, **kwargs):
6533         dict={}
6534         # What was supplied to this function
6535         dict.update(kwargs)
6536         # Parent constructor
6537         super(foldernameresponse,self).__init__(**dict)
6538         if self.__class__ is foldernameresponse:
6539             self._update(args,dict)
6540 
6541 
6542     def getfields(self):
6543         return self.__fields
6544 
6545 
6546     def _update(self, args, kwargs):
6547         super(foldernameresponse,self)._update(args,kwargs)
6548         keys=kwargs.keys()
6549         for key in keys:
6550             if key in self.__fields:
6551                 setattr(self, key, kwargs[key])
6552                 del kwargs[key]
6553         # Were any unrecognized kwargs passed in?
6554         if __debug__:
6555             self._complainaboutunusedargs(foldernameresponse,kwargs)
6556         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
6557         # Make all P fields that haven't already been constructed
6558 
6559 
6560     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
6561         'Writes this packet to the supplied buffer'
6562         self._bufferstartoffset=buf.getcurrentoffset()
6563         self.__field_header.writetobuffer(buf)
6564         self.__field_entry.writetobuffer(buf)
6565         self.__field_pad.writetobuffer(buf)
6566         self._bufferendoffset=buf.getcurrentoffset()
6567         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
6568 
6569 
6570     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
6571         'Reads this packet from the supplied buffer'
6572         self._bufferstartoffset=buf.getcurrentoffset()
6573         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
6574         self.__field_header=sanyoheader()
6575         self.__field_header.readfrombuffer(buf)
6576         self.__field_entry=foldernameentry()
6577         self.__field_entry.readfrombuffer(buf)
6578         self.__field_pad=UNKNOWN(**{'sizeinbytes': 467})
6579         self.__field_pad.readfrombuffer(buf)
6580         self._bufferendoffset=buf.getcurrentoffset()
6581 
6582 
6583     def __getfield_header(self):
6584         return self.__field_header.getvalue()
6585 
6586     def __setfield_header(self, value):
6587         if isinstance(value,sanyoheader):
6588             self.__field_header=value
6589         else:
6590             self.__field_header=sanyoheader(value,)
6591 
6592     def __delfield_header(self): del self.__field_header
6593 
6594     header=property(__getfield_header, __setfield_header, __delfield_header, None)
6595 
6596     def __getfield_entry(self):
6597         return self.__field_entry.getvalue()
6598 
6599     def __setfield_entry(self, value):
6600         if isinstance(value,foldernameentry):
6601             self.__field_entry=value
6602         else:
6603             self.__field_entry=foldernameentry(value,)
6604 
6605     def __delfield_entry(self): del self.__field_entry
6606 
6607     entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None)
6608 
6609     def __getfield_pad(self):
6610         return self.__field_pad.getvalue()
6611 
6612     def __setfield_pad(self, value):
6613         if isinstance(value,UNKNOWN):
6614             self.__field_pad=value
6615         else:
6616             self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 467})
6617 
6618     def __delfield_pad(self): del self.__field_pad
6619 
6620     pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None)
6621 
6622     def iscontainer(self):
6623         return True
6624 
6625     def containerelements(self):
6626         yield ('header', self.__field_header, None)
6627         yield ('entry', self.__field_entry, None)
6628         yield ('pad', self.__field_pad, None)
6629 
6630 
6631 
6632 
6633 class todorequest(BaseProtogenClass):
6634     __fields=['header', 'slot', 'pad']
6635 
6636     def __init__(self, *args, **kwargs):
6637         dict={}
6638         # What was supplied to this function
6639         dict.update(kwargs)
6640         # Parent constructor
6641         super(todorequest,self).__init__(**dict)
6642         if self.__class__ is todorequest:
6643             self._update(args,dict)
6644 
6645 
6646     def getfields(self):
6647         return self.__fields
6648 
6649 
6650     def _update(self, args, kwargs):
6651         super(todorequest,self)._update(args,kwargs)
6652         keys=kwargs.keys()
6653         for key in keys:
6654             if key in self.__fields:
6655                 setattr(self, key, kwargs[key])
6656                 del kwargs[key]
6657         # Were any unrecognized kwargs passed in?
6658         if __debug__:
6659             self._complainaboutunusedargs(todorequest,kwargs)
6660         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
6661         # Make all P fields that haven't already been constructed
6662 
6663 
6664     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
6665         'Writes this packet to the supplied buffer'
6666         self._bufferstartoffset=buf.getcurrentoffset()
6667         try: self.__field_header
6668         except:
6669             self.__field_header=sanyoheader(**{'packettype': 0x0c,'command': 0x25})
6670         self.__field_header.writetobuffer(buf)
6671         self.__field_slot.writetobuffer(buf)
6672         try: self.__field_pad
6673         except:
6674             self.__field_pad=UNKNOWN(**{'sizeinbytes': 501})
6675         self.__field_pad.writetobuffer(buf)
6676         self._bufferendoffset=buf.getcurrentoffset()
6677         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
6678 
6679 
6680     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
6681         'Reads this packet from the supplied buffer'
6682         self._bufferstartoffset=buf.getcurrentoffset()
6683         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
6684         self.__field_header=sanyoheader(**{'packettype': 0x0c,'command': 0x25})
6685         self.__field_header.readfrombuffer(buf)
6686         self.__field_slot=UINT(**{'sizeinbytes': 1})
6687         self.__field_slot.readfrombuffer(buf)
6688         self.__field_pad=UNKNOWN(**{'sizeinbytes': 501})
6689         self.__field_pad.readfrombuffer(buf)
6690         self._bufferendoffset=buf.getcurrentoffset()
6691 
6692 
6693     def __getfield_header(self):
6694         try: self.__field_header
6695         except:
6696             self.__field_header=sanyoheader(**{'packettype': 0x0c,'command': 0x25})
6697         return self.__field_header.getvalue()
6698 
6699     def __setfield_header(self, value):
6700         if isinstance(value,sanyoheader):
6701             self.__field_header=value
6702         else:
6703             self.__field_header=sanyoheader(value,**{'packettype': 0x0c,'command': 0x25})
6704 
6705     def __delfield_header(self): del self.__field_header
6706 
6707     header=property(__getfield_header, __setfield_header, __delfield_header, None)
6708 
6709     def __getfield_slot(self):
6710         return self.__field_slot.getvalue()
6711 
6712     def __setfield_slot(self, value):
6713         if isinstance(value,UINT):
6714             self.__field_slot=value
6715         else:
6716             self.__field_slot=UINT(value,**{'sizeinbytes': 1})
6717 
6718     def __delfield_slot(self): del self.__field_slot
6719 
6720     slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None)
6721 
6722     def __getfield_pad(self):
6723         try: self.__field_pad
6724         except:
6725             self.__field_pad=UNKNOWN(**{'sizeinbytes': 501})
6726         return self.__field_pad.getvalue()
6727 
6728     def __setfield_pad(self, value):
6729         if isinstance(value,UNKNOWN):
6730             self.__field_pad=value
6731         else:
6732             self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 501})
6733 
6734     def __delfield_pad(self): del self.__field_pad
6735 
6736     pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None)
6737 
6738     def iscontainer(self):
6739         return True
6740 
6741     def containerelements(self):
6742         yield ('header', self.__field_header, None)
6743         yield ('slot', self.__field_slot, None)
6744         yield ('pad', self.__field_pad, None)
6745 
6746 
6747 
6748 
6749 class todoentry(BaseProtogenClass):
6750     __fields=['slot', 'flag', 'todo', 'pad1', 'todo_len', 'priority', 'dunno', 'order']
6751 
6752     def __init__(self, *args, **kwargs):
6753         dict={}
6754         # What was supplied to this function
6755         dict.update(kwargs)
6756         # Parent constructor
6757         super(todoentry,self).__init__(**dict)
6758         if self.__class__ is todoentry:
6759             self._update(args,dict)
6760 
6761 
6762     def getfields(self):
6763         return self.__fields
6764 
6765 
6766     def _update(self, args, kwargs):
6767         super(todoentry,self)._update(args,kwargs)
6768         keys=kwargs.keys()
6769         for key in keys:
6770             if key in self.__fields:
6771                 setattr(self, key, kwargs[key])
6772                 del kwargs[key]
6773         # Were any unrecognized kwargs passed in?
6774         if __debug__:
6775             self._complainaboutunusedargs(todoentry,kwargs)
6776         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
6777         # Make all P fields that haven't already been constructed
6778 
6779 
6780     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
6781         'Writes this packet to the supplied buffer'
6782         self._bufferstartoffset=buf.getcurrentoffset()
6783         self.__field_slot.writetobuffer(buf)
6784         self.__field_flag.writetobuffer(buf)
6785         self.__field_todo.writetobuffer(buf)
6786         try: self.__field_pad1
6787         except:
6788             self.__field_pad1=UNKNOWN(**{'sizeinbytes': 7})
6789         self.__field_pad1.writetobuffer(buf)
6790         self.__field_todo_len.writetobuffer(buf)
6791         self.__field_priority.writetobuffer(buf)
6792         try: self.__field_dunno
6793         except:
6794             self.__field_dunno=UINT(**{'sizeinbytes': 1})
6795         self.__field_dunno.writetobuffer(buf)
6796         self.__field_order.writetobuffer(buf)
6797         self._bufferendoffset=buf.getcurrentoffset()
6798         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
6799 
6800 
6801     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
6802         'Reads this packet from the supplied buffer'
6803         self._bufferstartoffset=buf.getcurrentoffset()
6804         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
6805         self.__field_slot=UINT(**{'sizeinbytes': 1})
6806         self.__field_slot.readfrombuffer(buf)
6807         self.__field_flag=UINT(**{'sizeinbytes': 1})
6808         self.__field_flag.readfrombuffer(buf)
6809         self.__field_todo=USTRING(**{'sizeinbytes': 14, 'raiseonunterminatedread': False})
6810         self.__field_todo.readfrombuffer(buf)
6811         self.__field_pad1=UNKNOWN(**{'sizeinbytes': 7})
6812         self.__field_pad1.readfrombuffer(buf)
6813         self.__field_todo_len=UINT(**{'sizeinbytes': 1})
6814         self.__field_todo_len.readfrombuffer(buf)
6815         self.__field_priority=UINT(**{'sizeinbytes': 1})
6816         self.__field_priority.readfrombuffer(buf)
6817         self.__field_dunno=UINT(**{'sizeinbytes': 1})
6818         self.__field_dunno.readfrombuffer(buf)
6819         self.__field_order=UINT(**{'sizeinbytes': 1})
6820         self.__field_order.readfrombuffer(buf)
6821         self._bufferendoffset=buf.getcurrentoffset()
6822 
6823 
6824     def __getfield_slot(self):
6825         return self.__field_slot.getvalue()
6826 
6827     def __setfield_slot(self, value):
6828         if isinstance(value,UINT):
6829             self.__field_slot=value
6830         else:
6831             self.__field_slot=UINT(value,**{'sizeinbytes': 1})
6832 
6833     def __delfield_slot(self): del self.__field_slot
6834 
6835     slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None)
6836 
6837     def __getfield_flag(self):
6838         return self.__field_flag.getvalue()
6839 
6840     def __setfield_flag(self, value):
6841         if isinstance(value,UINT):
6842             self.__field_flag=value
6843         else:
6844             self.__field_flag=UINT(value,**{'sizeinbytes': 1})
6845 
6846     def __delfield_flag(self): del self.__field_flag
6847 
6848     flag=property(__getfield_flag, __setfield_flag, __delfield_flag, "0: Not used, 1: Used")
6849 
6850     def __getfield_todo(self):
6851         return self.__field_todo.getvalue()
6852 
6853     def __setfield_todo(self, value):
6854         if isinstance(value,USTRING):
6855             self.__field_todo=value
6856         else:
6857             self.__field_todo=USTRING(value,**{'sizeinbytes': 14, 'raiseonunterminatedread': False})
6858 
6859     def __delfield_todo(self): del self.__field_todo
6860 
6861     todo=property(__getfield_todo, __setfield_todo, __delfield_todo, None)
6862 
6863     def __getfield_pad1(self):
6864         try: self.__field_pad1
6865         except:
6866             self.__field_pad1=UNKNOWN(**{'sizeinbytes': 7})
6867         return self.__field_pad1.getvalue()
6868 
6869     def __setfield_pad1(self, value):
6870         if isinstance(value,UNKNOWN):
6871             self.__field_pad1=value
6872         else:
6873             self.__field_pad1=UNKNOWN(value,**{'sizeinbytes': 7})
6874 
6875     def __delfield_pad1(self): del self.__field_pad1
6876 
6877     pad1=property(__getfield_pad1, __setfield_pad1, __delfield_pad1, None)
6878 
6879     def __getfield_todo_len(self):
6880         return self.__field_todo_len.getvalue()
6881 
6882     def __setfield_todo_len(self, value):
6883         if isinstance(value,UINT):
6884             self.__field_todo_len=value
6885         else:
6886             self.__field_todo_len=UINT(value,**{'sizeinbytes': 1})
6887 
6888     def __delfield_todo_len(self): del self.__field_todo_len
6889 
6890     todo_len=property(__getfield_todo_len, __setfield_todo_len, __delfield_todo_len, None)
6891 
6892     def __getfield_priority(self):
6893         return self.__field_priority.getvalue()
6894 
6895     def __setfield_priority(self, value):
6896         if isinstance(value,UINT):
6897             self.__field_priority=value
6898         else:
6899             self.__field_priority=UINT(value,**{'sizeinbytes': 1})
6900 
6901     def __delfield_priority(self): del self.__field_priority
6902 
6903     priority=property(__getfield_priority, __setfield_priority, __delfield_priority, "0: Normal, 1: Urgent, 2: Done")
6904 
6905     def __getfield_dunno(self):
6906         try: self.__field_dunno
6907         except:
6908             self.__field_dunno=UINT(**{'sizeinbytes': 1})
6909         return self.__field_dunno.getvalue()
6910 
6911     def __setfield_dunno(self, value):
6912         if isinstance(value,UINT):
6913             self.__field_dunno=value
6914         else:
6915             self.__field_dunno=UINT(value,**{'sizeinbytes': 1})
6916 
6917     def __delfield_dunno(self): del self.__field_dunno
6918 
6919     dunno=property(__getfield_dunno, __setfield_dunno, __delfield_dunno, "Maybe always zero")
6920 
6921     def __getfield_order(self):
6922         return self.__field_order.getvalue()
6923 
6924     def __setfield_order(self, value):
6925         if isinstance(value,UINT):
6926             self.__field_order=value
6927         else:
6928             self.__field_order=UINT(value,**{'sizeinbytes': 1})
6929 
6930     def __delfield_order(self): del self.__field_order
6931 
6932     order=property(__getfield_order, __setfield_order, __delfield_order, "Gets sorted on screen in this order")
6933 
6934     def iscontainer(self):
6935         return True
6936 
6937     def containerelements(self):
6938         yield ('slot', self.__field_slot, None)
6939         yield ('flag', self.__field_flag, "0: Not used, 1: Used")
6940         yield ('todo', self.__field_todo, None)
6941         yield ('pad1', self.__field_pad1, None)
6942         yield ('todo_len', self.__field_todo_len, None)
6943         yield ('priority', self.__field_priority, "0: Normal, 1: Urgent, 2: Done")
6944         yield ('dunno', self.__field_dunno, "Maybe always zero")
6945         yield ('order', self.__field_order, "Gets sorted on screen in this order")
6946 
6947 
6948 
6949 
6950 class todoresponse(BaseProtogenClass):
6951     __fields=['header', 'entry', 'pad']
6952 
6953     def __init__(self, *args, **kwargs):
6954         dict={}
6955         # What was supplied to this function
6956         dict.update(kwargs)
6957         # Parent constructor
6958         super(todoresponse,self).__init__(**dict)
6959         if self.__class__ is todoresponse:
6960             self._update(args,dict)
6961 
6962 
6963     def getfields(self):
6964         return self.__fields
6965 
6966 
6967     def _update(self, args, kwargs):
6968         super(todoresponse,self)._update(args,kwargs)
6969         keys=kwargs.keys()
6970         for key in keys:
6971             if key in self.__fields:
6972                 setattr(self, key, kwargs[key])
6973                 del kwargs[key]
6974         # Were any unrecognized kwargs passed in?
6975         if __debug__:
6976             self._complainaboutunusedargs(todoresponse,kwargs)
6977         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
6978         # Make all P fields that haven't already been constructed
6979 
6980 
6981     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
6982         'Writes this packet to the supplied buffer'
6983         self._bufferstartoffset=buf.getcurrentoffset()
6984         self.__field_header.writetobuffer(buf)
6985         self.__field_entry.writetobuffer(buf)
6986         self.__field_pad.writetobuffer(buf)
6987         self._bufferendoffset=buf.getcurrentoffset()
6988         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
6989 
6990 
6991     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
6992         'Reads this packet from the supplied buffer'
6993         self._bufferstartoffset=buf.getcurrentoffset()
6994         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
6995         self.__field_header=sanyoheader()
6996         self.__field_header.readfrombuffer(buf)
6997         self.__field_entry=todoentry()
6998         self.__field_entry.readfrombuffer(buf)
6999         self.__field_pad=UNKNOWN(**{'sizeinbytes': 472})
7000         self.__field_pad.readfrombuffer(buf)
7001         self._bufferendoffset=buf.getcurrentoffset()
7002 
7003 
7004     def __getfield_header(self):
7005         return self.__field_header.getvalue()
7006 
7007     def __setfield_header(self, value):
7008         if isinstance(value,sanyoheader):
7009             self.__field_header=value
7010         else:
7011             self.__field_header=sanyoheader(value,)
7012 
7013     def __delfield_header(self): del self.__field_header
7014 
7015     header=property(__getfield_header, __setfield_header, __delfield_header, None)
7016 
7017     def __getfield_entry(self):
7018         return self.__field_entry.getvalue()
7019 
7020     def __setfield_entry(self, value):
7021         if isinstance(value,todoentry):
7022             self.__field_entry=value
7023         else:
7024             self.__field_entry=todoentry(value,)
7025 
7026     def __delfield_entry(self): del self.__field_entry
7027 
7028     entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None)
7029 
7030     def __getfield_pad(self):
7031         return self.__field_pad.getvalue()
7032 
7033     def __setfield_pad(self, value):
7034         if isinstance(value,UNKNOWN):
7035             self.__field_pad=value
7036         else:
7037             self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 472})
7038 
7039     def __delfield_pad(self): del self.__field_pad
7040 
7041     pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None)
7042 
7043     def iscontainer(self):
7044         return True
7045 
7046     def containerelements(self):
7047         yield ('header', self.__field_header, None)
7048         yield ('entry', self.__field_entry, None)
7049         yield ('pad', self.__field_pad, None)
7050 
7051 
7052 
7053 
7054 class historyrequest(BaseProtogenClass):
7055     __fields=['type', 'header', 'header', 'header', 'slot', 'pad']
7056 
7057     def __init__(self, *args, **kwargs):
7058         dict={}
7059         # What was supplied to this function
7060         dict.update(kwargs)
7061         # Parent constructor
7062         super(historyrequest,self).__init__(**dict)
7063         if self.__class__ is historyrequest:
7064             self._update(args,dict)
7065 
7066 
7067     def getfields(self):
7068         return self.__fields
7069 
7070 
7071     def _update(self, args, kwargs):
7072         super(historyrequest,self)._update(args,kwargs)
7073         keys=kwargs.keys()
7074         for key in keys:
7075             if key in self.__fields:
7076                 setattr(self, key, kwargs[key])
7077                 del kwargs[key]
7078         # Were any unrecognized kwargs passed in?
7079         if __debug__:
7080             self._complainaboutunusedargs(historyrequest,kwargs)
7081         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
7082         # Make all P fields that haven't already been constructed
7083         try: self.__field_type
7084         except:
7085             self.__field_type=UINT()
7086 
7087 
7088     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
7089         'Writes this packet to the supplied buffer'
7090         self._bufferstartoffset=buf.getcurrentoffset()
7091         if self.type==OUTGOING:
7092             try: self.__field_header
7093             except:
7094                 self.__field_header=sanyoheader(**{'packettype': 0x0c, 'command': 0x3d})
7095             self.__field_header.writetobuffer(buf)
7096         if self.type==INCOMING:
7097             try: self.__field_header
7098             except:
7099                 self.__field_header=sanyoheader(**{'packettype': 0x0c, 'command': 0x3e})
7100             self.__field_header.writetobuffer(buf)
7101         if self.type==MISSED:
7102             try: self.__field_header
7103             except:
7104                 self.__field_header=sanyoheader(**{'packettype': 0x0c, 'command': 0x3f})
7105             self.__field_header.writetobuffer(buf)
7106         self.__field_slot.writetobuffer(buf)
7107         try: self.__field_pad
7108         except:
7109             self.__field_pad=UNKNOWN(**{'sizeinbytes': 501})
7110         self.__field_pad.writetobuffer(buf)
7111         self._bufferendoffset=buf.getcurrentoffset()
7112         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
7113 
7114 
7115     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
7116         'Reads this packet from the supplied buffer'
7117         self._bufferstartoffset=buf.getcurrentoffset()
7118         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
7119         if self.type==OUTGOING:
7120             self.__field_header=sanyoheader(**{'packettype': 0x0c, 'command': 0x3d})
7121             self.__field_header.readfrombuffer(buf)
7122         if self.type==INCOMING:
7123             self.__field_header=sanyoheader(**{'packettype': 0x0c, 'command': 0x3e})
7124             self.__field_header.readfrombuffer(buf)
7125         if self.type==MISSED:
7126             self.__field_header=sanyoheader(**{'packettype': 0x0c, 'command': 0x3f})
7127             self.__field_header.readfrombuffer(buf)
7128         self.__field_slot=UINT(**{'sizeinbytes': 1})
7129         self.__field_slot.readfrombuffer(buf)
7130         self.__field_pad=UNKNOWN(**{'sizeinbytes': 501})
7131         self.__field_pad.readfrombuffer(buf)
7132         self._bufferendoffset=buf.getcurrentoffset()
7133 
7134 
7135     def __getfield_type(self):
7136         return self.__field_type.getvalue()
7137 
7138     def __setfield_type(self, value):
7139         if isinstance(value,UINT):
7140             self.__field_type=value
7141         else:
7142             self.__field_type=UINT(value,)
7143 
7144     def __delfield_type(self): del self.__field_type
7145 
7146     type=property(__getfield_type, __setfield_type, __delfield_type, "0: Outgoing, 1: Incoming, 2: Missed")
7147 
7148     def __getfield_header(self):
7149         try: self.__field_header
7150         except:
7151             self.__field_header=sanyoheader(**{'packettype': 0x0c, 'command': 0x3d})
7152         return self.__field_header.getvalue()
7153 
7154     def __setfield_header(self, value):
7155         if isinstance(value,sanyoheader):
7156             self.__field_header=value
7157         else:
7158             self.__field_header=sanyoheader(value,**{'packettype': 0x0c, 'command': 0x3d})
7159 
7160     def __delfield_header(self): del self.__field_header
7161 
7162     header=property(__getfield_header, __setfield_header, __delfield_header, None)
7163 
7164     def __getfield_header(self):
7165         try: self.__field_header
7166         except:
7167             self.__field_header=sanyoheader(**{'packettype': 0x0c, 'command': 0x3e})
7168         return self.__field_header.getvalue()
7169 
7170     def __setfield_header(self, value):
7171         if isinstance(value,sanyoheader):
7172             self.__field_header=value
7173         else:
7174             self.__field_header=sanyoheader(value,**{'packettype': 0x0c, 'command': 0x3e})
7175 
7176     def __delfield_header(self): del self.__field_header
7177 
7178     header=property(__getfield_header, __setfield_header, __delfield_header, None)
7179 
7180     def __getfield_header(self):
7181         try: self.__field_header
7182         except:
7183             self.__field_header=sanyoheader(**{'packettype': 0x0c, 'command': 0x3f})
7184         return self.__field_header.getvalue()
7185 
7186     def __setfield_header(self, value):
7187         if isinstance(value,sanyoheader):
7188             self.__field_header=value
7189         else:
7190             self.__field_header=sanyoheader(value,**{'packettype': 0x0c, 'command': 0x3f})
7191 
7192     def __delfield_header(self): del self.__field_header
7193 
7194     header=property(__getfield_header, __setfield_header, __delfield_header, None)
7195 
7196     def __getfield_slot(self):
7197         return self.__field_slot.getvalue()
7198 
7199     def __setfield_slot(self, value):
7200         if isinstance(value,UINT):
7201             self.__field_slot=value
7202         else:
7203             self.__field_slot=UINT(value,**{'sizeinbytes': 1})
7204 
7205     def __delfield_slot(self): del self.__field_slot
7206 
7207     slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None)
7208 
7209     def __getfield_pad(self):
7210         try: self.__field_pad
7211         except:
7212             self.__field_pad=UNKNOWN(**{'sizeinbytes': 501})
7213         return self.__field_pad.getvalue()
7214 
7215     def __setfield_pad(self, value):
7216         if isinstance(value,UNKNOWN):
7217             self.__field_pad=value
7218         else:
7219             self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 501})
7220 
7221     def __delfield_pad(self): del self.__field_pad
7222 
7223     pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None)
7224 
7225     def iscontainer(self):
7226         return True
7227 
7228     def containerelements(self):
7229         yield ('type', self.__field_type, "0: Outgoing, 1: Incoming, 2: Missed")
7230         if self.type==OUTGOING:
7231             yield ('header', self.__field_header, None)
7232         if self.type==INCOMING:
7233             yield ('header', self.__field_header, None)
7234         if self.type==MISSED:
7235             yield ('header', self.__field_header, None)
7236         yield ('slot', self.__field_slot, None)
7237         yield ('pad', self.__field_pad, None)
7238 
7239 
7240 
7241 
7242 class historymiscrequest(BaseProtogenClass):
7243     __fields=['type', 'header', 'header', 'header', 'slot', 'pad']
7244 
7245     def __init__(self, *args, **kwargs):
7246         dict={}
7247         # What was supplied to this function
7248         dict.update(kwargs)
7249         # Parent constructor
7250         super(historymiscrequest,self).__init__(**dict)
7251         if self.__class__ is historymiscrequest:
7252             self._update(args,dict)
7253 
7254 
7255     def getfields(self):
7256         return self.__fields
7257 
7258 
7259     def _update(self, args, kwargs):
7260         super(historymiscrequest,self)._update(args,kwargs)
7261         keys=kwargs.keys()
7262         for key in keys:
7263             if key in self.__fields:
7264                 setattr(self, key, kwargs[key])
7265                 del kwargs[key]
7266         # Were any unrecognized kwargs passed in?
7267         if __debug__:
7268             self._complainaboutunusedargs(historymiscrequest,kwargs)
7269         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
7270         # Make all P fields that haven't already been constructed
7271         try: self.__field_type
7272         except:
7273             self.__field_type=UINT()
7274 
7275 
7276     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
7277         'Writes this packet to the supplied buffer'
7278         self._bufferstartoffset=buf.getcurrentoffset()
7279         if self.type==OUTGOING:
7280             try: self.__field_header
7281             except:
7282                 self.__field_header=sanyoheader(**{'packettype': 0x0c, 'command': 0x60})
7283             self.__field_header.writetobuffer(buf)
7284         if self.type==INCOMING:
7285             try: self.__field_header
7286             except:
7287                 self.__field_header=sanyoheader(**{'packettype': 0x0c, 'command': 0x61})
7288             self.__field_header.writetobuffer(buf)
7289         if self.type==MISSED:
7290             try: self.__field_header
7291             except:
7292                 self.__field_header=sanyoheader(**{'packettype': 0x0c, 'command': 0x62})
7293             self.__field_header.writetobuffer(buf)
7294         self.__field_slot.writetobuffer(buf)
7295         try: self.__field_pad
7296         except:
7297             self.__field_pad=UNKNOWN(**{'sizeinbytes': 501})
7298         self.__field_pad.writetobuffer(buf)
7299         self._bufferendoffset=buf.getcurrentoffset()
7300         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
7301 
7302 
7303     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
7304         'Reads this packet from the supplied buffer'
7305         self._bufferstartoffset=buf.getcurrentoffset()
7306         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
7307         if self.type==OUTGOING:
7308             self.__field_header=sanyoheader(**{'packettype': 0x0c, 'command': 0x60})
7309             self.__field_header.readfrombuffer(buf)
7310         if self.type==INCOMING:
7311             self.__field_header=sanyoheader(**{'packettype': 0x0c, 'command': 0x61})
7312             self.__field_header.readfrombuffer(buf)
7313         if self.type==MISSED:
7314             self.__field_header=sanyoheader(**{'packettype': 0x0c, 'command': 0x62})
7315             self.__field_header.readfrombuffer(buf)
7316         self.__field_slot=UINT(**{'sizeinbytes': 1})
7317         self.__field_slot.readfrombuffer(buf)
7318         self.__field_pad=UNKNOWN(**{'sizeinbytes': 501})
7319         self.__field_pad.readfrombuffer(buf)
7320         self._bufferendoffset=buf.getcurrentoffset()
7321 
7322 
7323     def __getfield_type(self):
7324         return self.__field_type.getvalue()
7325 
7326     def __setfield_type(self, value):
7327         if isinstance(value,UINT):
7328             self.__field_type=value
7329         else:
7330             self.__field_type=UINT(value,)
7331 
7332     def __delfield_type(self): del self.__field_type
7333 
7334     type=property(__getfield_type, __setfield_type, __delfield_type, "0: Outgoing, 1: Incoming, 2: Missed")
7335 
7336     def __getfield_header(self):
7337         try: self.__field_header
7338         except:
7339             self.__field_header=sanyoheader(**{'packettype': 0x0c, 'command': 0x60})
7340         return self.__field_header.getvalue()
7341 
7342     def __setfield_header(self, value):
7343         if isinstance(value,sanyoheader):
7344             self.__field_header=value
7345         else:
7346             self.__field_header=sanyoheader(value,**{'packettype': 0x0c, 'command': 0x60})
7347 
7348     def __delfield_header(self): del self.__field_header
7349 
7350     header=property(__getfield_header, __setfield_header, __delfield_header, None)
7351 
7352     def __getfield_header(self):
7353         try: self.__field_header
7354         except:
7355             self.__field_header=sanyoheader(**{'packettype': 0x0c, 'command': 0x61})
7356         return self.__field_header.getvalue()
7357 
7358     def __setfield_header(self, value):
7359         if isinstance(value,sanyoheader):
7360             self.__field_header=value
7361         else:
7362             self.__field_header=sanyoheader(value,**{'packettype': 0x0c, 'command': 0x61})
7363 
7364     def __delfield_header(self): del self.__field_header
7365 
7366     header=property(__getfield_header, __setfield_header, __delfield_header, None)
7367 
7368     def __getfield_header(self):
7369         try: self.__field_header
7370         except:
7371             self.__field_header=sanyoheader(**{'packettype': 0x0c, 'command': 0x62})
7372         return self.__field_header.getvalue()
7373 
7374     def __setfield_header(self, value):
7375         if isinstance(value,sanyoheader):
7376             self.__field_header=value
7377         else:
7378             self.__field_header=sanyoheader(value,**{'packettype': 0x0c, 'command': 0x62})
7379 
7380     def __delfield_header(self): del self.__field_header
7381 
7382     header=property(__getfield_header, __setfield_header, __delfield_header, None)
7383 
7384     def __getfield_slot(self):
7385         return self.__field_slot.getvalue()
7386 
7387     def __setfield_slot(self, value):
7388         if isinstance(value,UINT):
7389             self.__field_slot=value
7390         else:
7391             self.__field_slot=UINT(value,**{'sizeinbytes': 1})
7392 
7393     def __delfield_slot(self): del self.__field_slot
7394 
7395     slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None)
7396 
7397     def __getfield_pad(self):
7398         try: self.__field_pad
7399         except:
7400             self.__field_pad=UNKNOWN(**{'sizeinbytes': 501})
7401         return self.__field_pad.getvalue()
7402 
7403     def __setfield_pad(self, value):
7404         if isinstance(value,UNKNOWN):
7405             self.__field_pad=value
7406         else:
7407             self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 501})
7408 
7409     def __delfield_pad(self): del self.__field_pad
7410 
7411     pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None)
7412 
7413     def iscontainer(self):
7414         return True
7415 
7416     def containerelements(self):
7417         yield ('type', self.__field_type, "0: Outgoing, 1: Incoming, 2: Missed")
7418         if self.type==OUTGOING:
7419             yield ('header', self.__field_header, None)
7420         if self.type==INCOMING:
7421             yield ('header', self.__field_header, None)
7422         if self.type==MISSED:
7423             yield ('header', self.__field_header, None)
7424         yield ('slot', self.__field_slot, None)
7425         yield ('pad', self.__field_pad, None)
7426 
7427 
7428 
7429 
7430 class historyentry(BaseProtogenClass):
7431     __fields=['slot', 'dunno1', 'date', 'phonenumlen', 'phonenum', 'name', 'dunno2', 'dunno3']
7432 
7433     def __init__(self, *args, **kwargs):
7434         dict={}
7435         # What was supplied to this function
7436         dict.update(kwargs)
7437         # Parent constructor
7438         super(historyentry,self).__init__(**dict)
7439         if self.__class__ is historyentry:
7440             self._update(args,dict)
7441 
7442 
7443     def getfields(self):
7444         return self.__fields
7445 
7446 
7447     def _update(self, args, kwargs):
7448         super(historyentry,self)._update(args,kwargs)
7449         keys=kwargs.keys()
7450         for key in keys:
7451             if key in self.__fields:
7452                 setattr(self, key, kwargs[key])
7453                 del kwargs[key]
7454         # Were any unrecognized kwargs passed in?
7455         if __debug__:
7456             self._complainaboutunusedargs(historyentry,kwargs)
7457         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
7458         # Make all P fields that haven't already been constructed
7459 
7460 
7461     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
7462         'Writes this packet to the supplied buffer'
7463         self._bufferstartoffset=buf.getcurrentoffset()
7464         self.__field_slot.writetobuffer(buf)
7465         self.__field_dunno1.writetobuffer(buf)
7466         self.__field_date.writetobuffer(buf)
7467         self.__field_phonenumlen.writetobuffer(buf)
7468         self.__field_phonenum.writetobuffer(buf)
7469         self.__field_name.writetobuffer(buf)
7470         self.__field_dunno2.writetobuffer(buf)
7471         self.__field_dunno3.writetobuffer(buf)
7472         self._bufferendoffset=buf.getcurrentoffset()
7473         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
7474 
7475 
7476     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
7477         'Reads this packet from the supplied buffer'
7478         self._bufferstartoffset=buf.getcurrentoffset()
7479         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
7480         self.__field_slot=UINT(**{'sizeinbytes': 2})
7481         self.__field_slot.readfrombuffer(buf)
7482         self.__field_dunno1=UNKNOWN(**{'sizeinbytes': 1})
7483         self.__field_dunno1.readfrombuffer(buf)
7484         self.__field_date=GPSDATE(**{'sizeinbytes': 4})
7485         self.__field_date.readfrombuffer(buf)
7486         self.__field_phonenumlen=UINT(**{'sizeinbytes': 1})
7487         self.__field_phonenumlen.readfrombuffer(buf)
7488         self.__field_phonenum=USTRING(**{'sizeinbytes': 48, 'raiseonunterminatedread': False})
7489         self.__field_phonenum.readfrombuffer(buf)
7490         self.__field_name=USTRING(**{'sizeinbytes': 16, 'raiseonunterminatedread': False, 'raiseontruncate': False, 'terminator': None})
7491         self.__field_name.readfrombuffer(buf)
7492         self.__field_dunno2=UNKNOWN(**{'sizeinbytes': 1})
7493         self.__field_dunno2.readfrombuffer(buf)
7494         self.__field_dunno3=UNKNOWN(**{'sizeinbytes': 1})
7495         self.__field_dunno3.readfrombuffer(buf)
7496         self._bufferendoffset=buf.getcurrentoffset()
7497 
7498 
7499     def __getfield_slot(self):
7500         return self.__field_slot.getvalue()
7501 
7502     def __setfield_slot(self, value):
7503         if isinstance(value,UINT):
7504             self.__field_slot=value
7505         else:
7506             self.__field_slot=UINT(value,**{'sizeinbytes': 2})
7507 
7508     def __delfield_slot(self): del self.__field_slot
7509 
7510     slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None)
7511 
7512     def __getfield_dunno1(self):
7513         return self.__field_dunno1.getvalue()
7514 
7515     def __setfield_dunno1(self, value):
7516         if isinstance(value,UNKNOWN):
7517             self.__field_dunno1=value
7518         else:
7519             self.__field_dunno1=UNKNOWN(value,**{'sizeinbytes': 1})
7520 
7521     def __delfield_dunno1(self): del self.__field_dunno1
7522 
7523     dunno1=property(__getfield_dunno1, __setfield_dunno1, __delfield_dunno1, None)
7524 
7525     def __getfield_date(self):
7526         return self.__field_date.getvalue()
7527 
7528     def __setfield_date(self, value):
7529         if isinstance(value,GPSDATE):
7530             self.__field_date=value
7531         else:
7532             self.__field_date=GPSDATE(value,**{'sizeinbytes': 4})
7533 
7534     def __delfield_date(self): del self.__field_date
7535 
7536     date=property(__getfield_date, __setfield_date, __delfield_date, None)
7537 
7538     def __getfield_phonenumlen(self):
7539         return self.__field_phonenumlen.getvalue()
7540 
7541     def __setfield_phonenumlen(self, value):
7542         if isinstance(value,UINT):
7543             self.__field_phonenumlen=value
7544         else:
7545             self.__field_phonenumlen=UINT(value,**{'sizeinbytes': 1})
7546 
7547     def __delfield_phonenumlen(self): del self.__field_phonenumlen
7548 
7549     phonenumlen=property(__getfield_phonenumlen, __setfield_phonenumlen, __delfield_phonenumlen, None)
7550 
7551     def __getfield_phonenum(self):
7552         return self.__field_phonenum.getvalue()
7553 
7554     def __setfield_phonenum(self, value):
7555         if isinstance(value,USTRING):
7556             self.__field_phonenum=value
7557         else:
7558             self.__field_phonenum=USTRING(value,**{'sizeinbytes': 48, 'raiseonunterminatedread': False})
7559 
7560     def __delfield_phonenum(self): del self.__field_phonenum
7561 
7562     phonenum=property(__getfield_phonenum, __setfield_phonenum, __delfield_phonenum, None)
7563 
7564     def __getfield_name(self):
7565         return self.__field_name.getvalue()
7566 
7567     def __setfield_name(self, value):
7568         if isinstance(value,USTRING):
7569             self.__field_name=value
7570         else:
7571             self.__field_name=USTRING(value,**{'sizeinbytes': 16, 'raiseonunterminatedread': False, 'raiseontruncate': False, 'terminator': None})
7572 
7573     def __delfield_name(self): del self.__field_name
7574 
7575     name=property(__getfield_name, __setfield_name, __delfield_name, None)
7576 
7577     def __getfield_dunno2(self):
7578         return self.__field_dunno2.getvalue()
7579 
7580     def __setfield_dunno2(self, value):
7581         if isinstance(value,UNKNOWN):
7582             self.__field_dunno2=value
7583         else:
7584             self.__field_dunno2=UNKNOWN(value,**{'sizeinbytes': 1})
7585 
7586     def __delfield_dunno2(self): del self.__field_dunno2
7587 
7588     dunno2=property(__getfield_dunno2, __setfield_dunno2, __delfield_dunno2, None)
7589 
7590     def __getfield_dunno3(self):
7591         return self.__field_dunno3.getvalue()
7592 
7593     def __setfield_dunno3(self, value):
7594         if isinstance(value,UNKNOWN):
7595             self.__field_dunno3=value
7596         else:
7597             self.__field_dunno3=UNKNOWN(value,**{'sizeinbytes': 1})
7598 
7599     def __delfield_dunno3(self): del self.__field_dunno3
7600 
7601     dunno3=property(__getfield_dunno3, __setfield_dunno3, __delfield_dunno3, None)
7602 
7603     def iscontainer(self):
7604         return True
7605 
7606     def containerelements(self):
7607         yield ('slot', self.__field_slot, None)
7608         yield ('dunno1', self.__field_dunno1, None)
7609         yield ('date', self.__field_date, None)
7610         yield ('phonenumlen', self.__field_phonenumlen, None)
7611         yield ('phonenum', self.__field_phonenum, None)
7612         yield ('name', self.__field_name, None)
7613         yield ('dunno2', self.__field_dunno2, None)
7614         yield ('dunno3', self.__field_dunno3, None)
7615 
7616 
7617 
7618 
7619 class historyresponse(BaseProtogenClass):
7620     __fields=['header', 'entry', 'pad']
7621 
7622     def __init__(self, *args, **kwargs):
7623         dict={}
7624         # What was supplied to this function
7625         dict.update(kwargs)
7626         # Parent constructor
7627         super(historyresponse,self).__init__(**dict)
7628         if self.__class__ is historyresponse:
7629             self._update(args,dict)
7630 
7631 
7632     def getfields(self):
7633         return self.__fields
7634 
7635 
7636     def _update(self, args, kwargs):
7637         super(historyresponse,self)._update(args,kwargs)
7638         keys=kwargs.keys()
7639         for key in keys:
7640             if key in self.__fields:
7641                 setattr(self, key, kwargs[key])
7642                 del kwargs[key]
7643         # Were any unrecognized kwargs passed in?
7644         if __debug__:
7645             self._complainaboutunusedargs(historyresponse,kwargs)
7646         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
7647         # Make all P fields that haven't already been constructed
7648 
7649 
7650     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
7651         'Writes this packet to the supplied buffer'
7652         self._bufferstartoffset=buf.getcurrentoffset()
7653         self.__field_header.writetobuffer(buf)
7654         self.__field_entry.writetobuffer(buf)
7655         self.__field_pad.writetobuffer(buf)
7656         self._bufferendoffset=buf.getcurrentoffset()
7657         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
7658 
7659 
7660     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
7661         'Reads this packet from the supplied buffer'
7662         self._bufferstartoffset=buf.getcurrentoffset()
7663         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
7664         self.__field_header=sanyoheader()
7665         self.__field_header.readfrombuffer(buf)
7666         self.__field_entry=historyentry()
7667         self.__field_entry.readfrombuffer(buf)
7668         self.__field_pad=UNKNOWN(**{'sizeinbytes': 428})
7669         self.__field_pad.readfrombuffer(buf)
7670         self._bufferendoffset=buf.getcurrentoffset()
7671 
7672 
7673     def __getfield_header(self):
7674         return self.__field_header.getvalue()
7675 
7676     def __setfield_header(self, value):
7677         if isinstance(value,sanyoheader):
7678             self.__field_header=value
7679         else:
7680             self.__field_header=sanyoheader(value,)
7681 
7682     def __delfield_header(self): del self.__field_header
7683 
7684     header=property(__getfield_header, __setfield_header, __delfield_header, None)
7685 
7686     def __getfield_entry(self):
7687         return self.__field_entry.getvalue()
7688 
7689     def __setfield_entry(self, value):
7690         if isinstance(value,historyentry):
7691             self.__field_entry=value
7692         else:
7693             self.__field_entry=historyentry(value,)
7694 
7695     def __delfield_entry(self): del self.__field_entry
7696 
7697     entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None)
7698 
7699     def __getfield_pad(self):
7700         return self.__field_pad.getvalue()
7701 
7702     def __setfield_pad(self, value):
7703         if isinstance(value,UNKNOWN):
7704             self.__field_pad=value
7705         else:
7706             self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 428})
7707 
7708     def __delfield_pad(self): del self.__field_pad
7709 
7710     pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None)
7711 
7712     def iscontainer(self):
7713         return True
7714 
7715     def containerelements(self):
7716         yield ('header', self.__field_header, None)
7717         yield ('entry', self.__field_entry, None)
7718         yield ('pad', self.__field_pad, None)
7719 
7720 
7721 
7722 
7723 class historymiscentry(BaseProtogenClass):
7724     __fields=['slot', 'pbslotandtype', 'dunno1', 'dunno2', 'dunno3', 'dunno4']
7725 
7726     def __init__(self, *args, **kwargs):
7727         dict={}
7728         # What was supplied to this function
7729         dict.update(kwargs)
7730         # Parent constructor
7731         super(historymiscentry,self).__init__(**dict)
7732         if self.__class__ is historymiscentry:
7733             self._update(args,dict)
7734 
7735 
7736     def getfields(self):
7737         return self.__fields
7738 
7739 
7740     def _update(self, args, kwargs):
7741         super(historymiscentry,self)._update(args,kwargs)
7742         keys=kwargs.keys()
7743         for key in keys:
7744             if key in self.__fields:
7745                 setattr(self, key, kwargs[key])
7746                 del kwargs[key]
7747         # Were any unrecognized kwargs passed in?
7748         if __debug__:
7749             self._complainaboutunusedargs(historymiscentry,kwargs)
7750         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
7751         # Make all P fields that haven't already been constructed
7752 
7753 
7754     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
7755         'Writes this packet to the supplied buffer'
7756         self._bufferstartoffset=buf.getcurrentoffset()
7757         self.__field_slot.writetobuffer(buf)
7758         self.__field_pbslotandtype.writetobuffer(buf)
7759         self.__field_dunno1.writetobuffer(buf)
7760         self.__field_dunno2.writetobuffer(buf)
7761         self.__field_dunno3.writetobuffer(buf)
7762         self.__field_dunno4.writetobuffer(buf)
7763         self._bufferendoffset=buf.getcurrentoffset()
7764         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
7765 
7766 
7767     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
7768         'Reads this packet from the supplied buffer'
7769         self._bufferstartoffset=buf.getcurrentoffset()
7770         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
7771         self.__field_slot=UINT(**{'sizeinbytes': 2})
7772         self.__field_slot.readfrombuffer(buf)
7773         self.__field_pbslotandtype=UINT(**{'sizeinbytes': 2})
7774         self.__field_pbslotandtype.readfrombuffer(buf)
7775         self.__field_dunno1=UINT(**{'sizeinbytes': 2})
7776         self.__field_dunno1.readfrombuffer(buf)
7777         self.__field_dunno2=UINT(**{'sizeinbytes': 1})
7778         self.__field_dunno2.readfrombuffer(buf)
7779         self.__field_dunno3=UINT(**{'sizeinbytes': 1})
7780         self.__field_dunno3.readfrombuffer(buf)
7781         self.__field_dunno4=UINT(**{'sizeinbytes': 1})
7782         self.__field_dunno4.readfrombuffer(buf)
7783         self._bufferendoffset=buf.getcurrentoffset()
7784 
7785 
7786     def __getfield_slot(self):
7787         return self.__field_slot.getvalue()
7788 
7789     def __setfield_slot(self, value):
7790         if isinstance(value,UINT):
7791             self.__field_slot=value
7792         else:
7793             self.__field_slot=UINT(value,**{'sizeinbytes': 2})
7794 
7795     def __delfield_slot(self): del self.__field_slot
7796 
7797     slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None)
7798 
7799     def __getfield_pbslotandtype(self):
7800         return self.__field_pbslotandtype.getvalue()
7801 
7802     def __setfield_pbslotandtype(self, value):
7803         if isinstance(value,UINT):
7804             self.__field_pbslotandtype=value
7805         else:
7806             self.__field_pbslotandtype=UINT(value,**{'sizeinbytes': 2})
7807 
7808     def __delfield_pbslotandtype(self): del self.__field_pbslotandtype
7809 
7810     pbslotandtype=property(__getfield_pbslotandtype, __setfield_pbslotandtype, __delfield_pbslotandtype, None)
7811 
7812     def __getfield_dunno1(self):
7813         return self.__field_dunno1.getvalue()
7814 
7815     def __setfield_dunno1(self, value):
7816         if isinstance(value,UINT):
7817             self.__field_dunno1=value
7818         else:
7819             self.__field_dunno1=UINT(value,**{'sizeinbytes': 2})
7820 
7821     def __delfield_dunno1(self): del self.__field_dunno1
7822 
7823     dunno1=property(__getfield_dunno1, __setfield_dunno1, __delfield_dunno1, None)
7824 
7825     def __getfield_dunno2(self):
7826         return self.__field_dunno2.getvalue()
7827 
7828     def __setfield_dunno2(self, value):
7829         if isinstance(value,UINT):
7830             self.__field_dunno2=value
7831         else:
7832             self.__field_dunno2=UINT(value,**{'sizeinbytes': 1})
7833 
7834     def __delfield_dunno2(self): del self.__field_dunno2
7835 
7836     dunno2=property(__getfield_dunno2, __setfield_dunno2, __delfield_dunno2, None)
7837 
7838     def __getfield_dunno3(self):
7839         return self.__field_dunno3.getvalue()
7840 
7841     def __setfield_dunno3(self, value):
7842         if isinstance(value,UINT):
7843             self.__field_dunno3=value
7844         else:
7845             self.__field_dunno3=UINT(value,**{'sizeinbytes': 1})
7846 
7847     def __delfield_dunno3(self): del self.__field_dunno3
7848 
7849     dunno3=property(__getfield_dunno3, __setfield_dunno3, __delfield_dunno3, None)
7850 
7851     def __getfield_dunno4(self):
7852         return self.__field_dunno4.getvalue()
7853 
7854     def __setfield_dunno4(self, value):
7855         if isinstance(value,UINT):
7856             self.__field_dunno4=value
7857         else:
7858             self.__field_dunno4=UINT(value,**{'sizeinbytes': 1})
7859 
7860     def __delfield_dunno4(self): del self.__field_dunno4
7861 
7862     dunno4=property(__getfield_dunno4, __setfield_dunno4, __delfield_dunno4, None)
7863 
7864     def iscontainer(self):
7865         return True
7866 
7867     def containerelements(self):
7868         yield ('slot', self.__field_slot, None)
7869         yield ('pbslotandtype', self.__field_pbslotandtype, None)
7870         yield ('dunno1', self.__field_dunno1, None)
7871         yield ('dunno2', self.__field_dunno2, None)
7872         yield ('dunno3', self.__field_dunno3, None)
7873         yield ('dunno4', self.__field_dunno4, None)
7874 
7875 
7876 
7877 
7878 class historymiscresponse(BaseProtogenClass):
7879     __fields=['header', 'entry', 'pad']
7880 
7881     def __init__(self, *args, **kwargs):
7882         dict={}
7883         # What was supplied to this function
7884         dict.update(kwargs)
7885         # Parent constructor
7886         super(historymiscresponse,self).__init__(**dict)
7887         if self.__class__ is historymiscresponse:
7888             self._update(args,dict)
7889 
7890 
7891     def getfields(self):
7892         return self.__fields
7893 
7894 
7895     def _update(self, args, kwargs):
7896         super(historymiscresponse,self)._update(args,kwargs)
7897         keys=kwargs.keys()
7898         for key in keys:
7899             if key in self.__fields:
7900                 setattr(self, key, kwargs[key])
7901                 del kwargs[key]
7902         # Were any unrecognized kwargs passed in?
7903         if __debug__:
7904             self._complainaboutunusedargs(historymiscresponse,kwargs)
7905         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
7906         # Make all P fields that haven't already been constructed
7907 
7908 
7909     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
7910         'Writes this packet to the supplied buffer'
7911         self._bufferstartoffset=buf.getcurrentoffset()
7912         self.__field_header.writetobuffer(buf)
7913         self.__field_entry.writetobuffer(buf)
7914         self.__field_pad.writetobuffer(buf)
7915         self._bufferendoffset=buf.getcurrentoffset()
7916         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
7917 
7918 
7919     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
7920         'Reads this packet from the supplied buffer'
7921         self._bufferstartoffset=buf.getcurrentoffset()
7922         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
7923         self.__field_header=sanyoheader()
7924         self.__field_header.readfrombuffer(buf)
7925         self.__field_entry=historymiscentry()
7926         self.__field_entry.readfrombuffer(buf)
7927         self.__field_pad=UNKNOWN(**{'sizeinbytes': 493})
7928         self.__field_pad.readfrombuffer(buf)
7929         self._bufferendoffset=buf.getcurrentoffset()
7930 
7931 
7932     def __getfield_header(self):
7933         return self.__field_header.getvalue()
7934 
7935     def __setfield_header(self, value):
7936         if isinstance(value,sanyoheader):
7937             self.__field_header=value
7938         else:
7939             self.__field_header=sanyoheader(value,)
7940 
7941     def __delfield_header(self): del self.__field_header
7942 
7943     header=property(__getfield_header, __setfield_header, __delfield_header, None)
7944 
7945     def __getfield_entry(self):
7946         return self.__field_entry.getvalue()
7947 
7948     def __setfield_entry(self, value):
7949         if isinstance(value,historymiscentry):
7950             self.__field_entry=value
7951         else:
7952             self.__field_entry=historymiscentry(value,)
7953 
7954     def __delfield_entry(self): del self.__field_entry
7955 
7956     entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None)
7957 
7958     def __getfield_pad(self):
7959         return self.__field_pad.getvalue()
7960 
7961     def __setfield_pad(self, value):
7962         if isinstance(value,UNKNOWN):
7963             self.__field_pad=value
7964         else:
7965             self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 493})
7966 
7967     def __delfield_pad(self): del self.__field_pad
7968 
7969     pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None)
7970 
7971     def iscontainer(self):
7972         return True
7973 
7974     def containerelements(self):
7975         yield ('header', self.__field_header, None)
7976         yield ('entry', self.__field_entry, None)
7977         yield ('pad', self.__field_pad, None)
7978 
7979 
7980 
7981 
7982