PyXR

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

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