PyXR

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



0001 # THIS FILE IS AUTOMATICALLY GENERATED.  EDIT THE SOURCE FILE NOT THIS ONE
0002 
0003 """Various descriptions of data specific to Sanyo phones"""
0004 
0005 from prototypes import *
0006 
0007 # We use LSB for all integer like fields
0008 
0009 UINT=UINTlsb
0010 BOOL=BOOLlsb
0011 
0012 NUMCALENDAREVENTS=70
0013 NUMTODOENTRIES=9
0014 NUMMEMOENTRIES=9
0015 
0016 DEFAULT_RINGTONE=20
0017 DEFAULT_WALLPAPER=20
0018 
0019 class phonenumber(BaseProtogenClass):
0020     __fields=['number', 'secret']
0021 
0022     def __init__(self, *args, **kwargs):
0023         dict={}
0024         # What was supplied to this function
0025         dict.update(kwargs)
0026         # Parent constructor
0027         super(phonenumber,self).__init__(**dict)
0028         if self.__class__ is phonenumber:
0029             self._update(args,dict)
0030 
0031 
0032     def getfields(self):
0033         return self.__fields
0034 
0035 
0036     def _update(self, args, kwargs):
0037         super(phonenumber,self)._update(args,kwargs)
0038         keys=kwargs.keys()
0039         for key in keys:
0040             if key in self.__fields:
0041                 setattr(self, key, kwargs[key])
0042                 del kwargs[key]
0043         # Were any unrecognized kwargs passed in?
0044         if __debug__:
0045             self._complainaboutunusedargs(phonenumber,kwargs)
0046         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0047         # Make all P fields that haven't already been constructed
0048 
0049 
0050     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0051         'Writes this packet to the supplied buffer'
0052         self._bufferstartoffset=buf.getcurrentoffset()
0053         try: self.__field_number
0054         except:
0055             self.__field_number=CSVSTRING(**{'quotechar': None, 'default': ""})
0056         self.__field_number.writetobuffer(buf)
0057         try: self.__field_secret
0058         except:
0059             self.__field_secret=CSVINT(**{'default': 0})
0060         self.__field_secret.writetobuffer(buf)
0061         self._bufferendoffset=buf.getcurrentoffset()
0062         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0063 
0064 
0065     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0066         'Reads this packet from the supplied buffer'
0067         self._bufferstartoffset=buf.getcurrentoffset()
0068         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0069         self.__field_number=CSVSTRING(**{'quotechar': None, 'default': ""})
0070         self.__field_number.readfrombuffer(buf)
0071         self.__field_secret=CSVINT(**{'default': 0})
0072         self.__field_secret.readfrombuffer(buf)
0073         self._bufferendoffset=buf.getcurrentoffset()
0074 
0075 
0076     def __getfield_number(self):
0077         try: self.__field_number
0078         except:
0079             self.__field_number=CSVSTRING(**{'quotechar': None, 'default': ""})
0080         return self.__field_number.getvalue()
0081 
0082     def __setfield_number(self, value):
0083         if isinstance(value,CSVSTRING):
0084             self.__field_number=value
0085         else:
0086             self.__field_number=CSVSTRING(value,**{'quotechar': None, 'default': ""})
0087 
0088     def __delfield_number(self): del self.__field_number
0089 
0090     number=property(__getfield_number, __setfield_number, __delfield_number, None)
0091 
0092     def __getfield_secret(self):
0093         try: self.__field_secret
0094         except:
0095             self.__field_secret=CSVINT(**{'default': 0})
0096         return self.__field_secret.getvalue()
0097 
0098     def __setfield_secret(self, value):
0099         if isinstance(value,CSVINT):
0100             self.__field_secret=value
0101         else:
0102             self.__field_secret=CSVINT(value,**{'default': 0})
0103 
0104     def __delfield_secret(self): del self.__field_secret
0105 
0106     secret=property(__getfield_secret, __setfield_secret, __delfield_secret, None)
0107 
0108     def iscontainer(self):
0109         return True
0110 
0111     def containerelements(self):
0112         yield ('number', self.__field_number, None)
0113         yield ('secret', self.__field_secret, None)
0114 
0115 
0116 
0117 
0118 class phonebookslotrequest(BaseProtogenClass):
0119     __fields=['command', 'slot']
0120 
0121     def __init__(self, *args, **kwargs):
0122         dict={}
0123         # What was supplied to this function
0124         dict.update(kwargs)
0125         # Parent constructor
0126         super(phonebookslotrequest,self).__init__(**dict)
0127         if self.__class__ is phonebookslotrequest:
0128             self._update(args,dict)
0129 
0130 
0131     def getfields(self):
0132         return self.__fields
0133 
0134 
0135     def _update(self, args, kwargs):
0136         super(phonebookslotrequest,self)._update(args,kwargs)
0137         keys=kwargs.keys()
0138         for key in keys:
0139             if key in self.__fields:
0140                 setattr(self, key, kwargs[key])
0141                 del kwargs[key]
0142         # Were any unrecognized kwargs passed in?
0143         if __debug__:
0144             self._complainaboutunusedargs(phonebookslotrequest,kwargs)
0145         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0146         # Make all P fields that haven't already been constructed
0147 
0148 
0149     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0150         'Writes this packet to the supplied buffer'
0151         self._bufferstartoffset=buf.getcurrentoffset()
0152         try: self.__field_command
0153         except:
0154             self.__field_command=CSVSTRING(**{'quotechar': None, 'terminator': None, 'default': '#PBOKR='})
0155         self.__field_command.writetobuffer(buf)
0156         try: self.__field_slot
0157         except:
0158             self.__field_slot=CSVINT(**{'terminator': None})
0159         self.__field_slot.writetobuffer(buf)
0160         self._bufferendoffset=buf.getcurrentoffset()
0161         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0162 
0163 
0164     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0165         'Reads this packet from the supplied buffer'
0166         self._bufferstartoffset=buf.getcurrentoffset()
0167         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0168         self.__field_command=CSVSTRING(**{'quotechar': None, 'terminator': None, 'default': '#PBOKR='})
0169         self.__field_command.readfrombuffer(buf)
0170         self.__field_slot=CSVINT(**{'terminator': None})
0171         self.__field_slot.readfrombuffer(buf)
0172         self._bufferendoffset=buf.getcurrentoffset()
0173 
0174 
0175     def __getfield_command(self):
0176         try: self.__field_command
0177         except:
0178             self.__field_command=CSVSTRING(**{'quotechar': None, 'terminator': None, 'default': '#PBOKR='})
0179         return self.__field_command.getvalue()
0180 
0181     def __setfield_command(self, value):
0182         if isinstance(value,CSVSTRING):
0183             self.__field_command=value
0184         else:
0185             self.__field_command=CSVSTRING(value,**{'quotechar': None, 'terminator': None, 'default': '#PBOKR='})
0186 
0187     def __delfield_command(self): del self.__field_command
0188 
0189     command=property(__getfield_command, __setfield_command, __delfield_command, None)
0190 
0191     def __getfield_slot(self):
0192         try: self.__field_slot
0193         except:
0194             self.__field_slot=CSVINT(**{'terminator': None})
0195         return self.__field_slot.getvalue()
0196 
0197     def __setfield_slot(self, value):
0198         if isinstance(value,CSVINT):
0199             self.__field_slot=value
0200         else:
0201             self.__field_slot=CSVINT(value,**{'terminator': None})
0202 
0203     def __delfield_slot(self): del self.__field_slot
0204 
0205     slot=property(__getfield_slot, __setfield_slot, __delfield_slot, "Internal Slot")
0206 
0207     def iscontainer(self):
0208         return True
0209 
0210     def containerelements(self):
0211         yield ('command', self.__field_command, None)
0212         yield ('slot', self.__field_slot, "Internal Slot")
0213 
0214 
0215 
0216 
0217 class phonebooksloterase(BaseProtogenClass):
0218     __fields=['command', 'slot']
0219 
0220     def __init__(self, *args, **kwargs):
0221         dict={}
0222         # What was supplied to this function
0223         dict.update(kwargs)
0224         # Parent constructor
0225         super(phonebooksloterase,self).__init__(**dict)
0226         if self.__class__ is phonebooksloterase:
0227             self._update(args,dict)
0228 
0229 
0230     def getfields(self):
0231         return self.__fields
0232 
0233 
0234     def _update(self, args, kwargs):
0235         super(phonebooksloterase,self)._update(args,kwargs)
0236         keys=kwargs.keys()
0237         for key in keys:
0238             if key in self.__fields:
0239                 setattr(self, key, kwargs[key])
0240                 del kwargs[key]
0241         # Were any unrecognized kwargs passed in?
0242         if __debug__:
0243             self._complainaboutunusedargs(phonebooksloterase,kwargs)
0244         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0245         # Make all P fields that haven't already been constructed
0246 
0247 
0248     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0249         'Writes this packet to the supplied buffer'
0250         self._bufferstartoffset=buf.getcurrentoffset()
0251         try: self.__field_command
0252         except:
0253             self.__field_command=CSVSTRING(**{'quotechar': None, 'terminator': None, 'default': '#PBOKW='})
0254         self.__field_command.writetobuffer(buf)
0255         try: self.__field_slot
0256         except:
0257             self.__field_slot=CSVINT(**{'terminator': None})
0258         self.__field_slot.writetobuffer(buf)
0259         self._bufferendoffset=buf.getcurrentoffset()
0260         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0261 
0262 
0263     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0264         'Reads this packet from the supplied buffer'
0265         self._bufferstartoffset=buf.getcurrentoffset()
0266         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0267         self.__field_command=CSVSTRING(**{'quotechar': None, 'terminator': None, 'default': '#PBOKW='})
0268         self.__field_command.readfrombuffer(buf)
0269         self.__field_slot=CSVINT(**{'terminator': None})
0270         self.__field_slot.readfrombuffer(buf)
0271         self._bufferendoffset=buf.getcurrentoffset()
0272 
0273 
0274     def __getfield_command(self):
0275         try: self.__field_command
0276         except:
0277             self.__field_command=CSVSTRING(**{'quotechar': None, 'terminator': None, 'default': '#PBOKW='})
0278         return self.__field_command.getvalue()
0279 
0280     def __setfield_command(self, value):
0281         if isinstance(value,CSVSTRING):
0282             self.__field_command=value
0283         else:
0284             self.__field_command=CSVSTRING(value,**{'quotechar': None, 'terminator': None, 'default': '#PBOKW='})
0285 
0286     def __delfield_command(self): del self.__field_command
0287 
0288     command=property(__getfield_command, __setfield_command, __delfield_command, None)
0289 
0290     def __getfield_slot(self):
0291         try: self.__field_slot
0292         except:
0293             self.__field_slot=CSVINT(**{'terminator': None})
0294         return self.__field_slot.getvalue()
0295 
0296     def __setfield_slot(self, value):
0297         if isinstance(value,CSVINT):
0298             self.__field_slot=value
0299         else:
0300             self.__field_slot=CSVINT(value,**{'terminator': None})
0301 
0302     def __delfield_slot(self): del self.__field_slot
0303 
0304     slot=property(__getfield_slot, __setfield_slot, __delfield_slot, "Internal Slot")
0305 
0306     def iscontainer(self):
0307         return True
0308 
0309     def containerelements(self):
0310         yield ('command', self.__field_command, None)
0311         yield ('slot', self.__field_slot, "Internal Slot")
0312 
0313 
0314 
0315 
0316 class phonebookslotupdateresponse(BaseProtogenClass):
0317     __fields=['pad']
0318 
0319     def __init__(self, *args, **kwargs):
0320         dict={}
0321         # What was supplied to this function
0322         dict.update(kwargs)
0323         # Parent constructor
0324         super(phonebookslotupdateresponse,self).__init__(**dict)
0325         if self.__class__ is phonebookslotupdateresponse:
0326             self._update(args,dict)
0327 
0328 
0329     def getfields(self):
0330         return self.__fields
0331 
0332 
0333     def _update(self, args, kwargs):
0334         super(phonebookslotupdateresponse,self)._update(args,kwargs)
0335         keys=kwargs.keys()
0336         for key in keys:
0337             if key in self.__fields:
0338                 setattr(self, key, kwargs[key])
0339                 del kwargs[key]
0340         # Were any unrecognized kwargs passed in?
0341         if __debug__:
0342             self._complainaboutunusedargs(phonebookslotupdateresponse,kwargs)
0343         if len(args):
0344             dict2={}
0345             dict2.update(kwargs)
0346             kwargs=dict2
0347             self.__field_pad=UNKNOWN(*args,**dict2)
0348         # Make all P fields that haven't already been constructed
0349 
0350 
0351     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0352         'Writes this packet to the supplied buffer'
0353         self._bufferstartoffset=buf.getcurrentoffset()
0354         self.__field_pad.writetobuffer(buf)
0355         self._bufferendoffset=buf.getcurrentoffset()
0356         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0357 
0358 
0359     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0360         'Reads this packet from the supplied buffer'
0361         self._bufferstartoffset=buf.getcurrentoffset()
0362         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0363         self.__field_pad=UNKNOWN()
0364         self.__field_pad.readfrombuffer(buf)
0365         self._bufferendoffset=buf.getcurrentoffset()
0366 
0367 
0368     def __getfield_pad(self):
0369         return self.__field_pad.getvalue()
0370 
0371     def __setfield_pad(self, value):
0372         if isinstance(value,UNKNOWN):
0373             self.__field_pad=value
0374         else:
0375             self.__field_pad=UNKNOWN(value,)
0376 
0377     def __delfield_pad(self): del self.__field_pad
0378 
0379     pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None)
0380 
0381     def iscontainer(self):
0382         return True
0383 
0384     def containerelements(self):
0385         yield ('pad', self.__field_pad, None)
0386 
0387 
0388 
0389 
0390 class groupnamerequest(BaseProtogenClass):
0391     __fields=['command', 'gid']
0392 
0393     def __init__(self, *args, **kwargs):
0394         dict={}
0395         # What was supplied to this function
0396         dict.update(kwargs)
0397         # Parent constructor
0398         super(groupnamerequest,self).__init__(**dict)
0399         if self.__class__ is groupnamerequest:
0400             self._update(args,dict)
0401 
0402 
0403     def getfields(self):
0404         return self.__fields
0405 
0406 
0407     def _update(self, args, kwargs):
0408         super(groupnamerequest,self)._update(args,kwargs)
0409         keys=kwargs.keys()
0410         for key in keys:
0411             if key in self.__fields:
0412                 setattr(self, key, kwargs[key])
0413                 del kwargs[key]
0414         # Were any unrecognized kwargs passed in?
0415         if __debug__:
0416             self._complainaboutunusedargs(groupnamerequest,kwargs)
0417         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0418         # Make all P fields that haven't already been constructed
0419 
0420 
0421     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0422         'Writes this packet to the supplied buffer'
0423         self._bufferstartoffset=buf.getcurrentoffset()
0424         try: self.__field_command
0425         except:
0426             self.__field_command=CSVSTRING(**{'quotechar': None, 'terminator': None, 'default': '#PBGRR='})
0427         self.__field_command.writetobuffer(buf)
0428         try: self.__field_gid
0429         except:
0430             self.__field_gid=CSVINT(**{'terminator': None})
0431         self.__field_gid.writetobuffer(buf)
0432         self._bufferendoffset=buf.getcurrentoffset()
0433         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0434 
0435 
0436     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0437         'Reads this packet from the supplied buffer'
0438         self._bufferstartoffset=buf.getcurrentoffset()
0439         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0440         self.__field_command=CSVSTRING(**{'quotechar': None, 'terminator': None, 'default': '#PBGRR='})
0441         self.__field_command.readfrombuffer(buf)
0442         self.__field_gid=CSVINT(**{'terminator': None})
0443         self.__field_gid.readfrombuffer(buf)
0444         self._bufferendoffset=buf.getcurrentoffset()
0445 
0446 
0447     def __getfield_command(self):
0448         try: self.__field_command
0449         except:
0450             self.__field_command=CSVSTRING(**{'quotechar': None, 'terminator': None, 'default': '#PBGRR='})
0451         return self.__field_command.getvalue()
0452 
0453     def __setfield_command(self, value):
0454         if isinstance(value,CSVSTRING):
0455             self.__field_command=value
0456         else:
0457             self.__field_command=CSVSTRING(value,**{'quotechar': None, 'terminator': None, 'default': '#PBGRR='})
0458 
0459     def __delfield_command(self): del self.__field_command
0460 
0461     command=property(__getfield_command, __setfield_command, __delfield_command, None)
0462 
0463     def __getfield_gid(self):
0464         try: self.__field_gid
0465         except:
0466             self.__field_gid=CSVINT(**{'terminator': None})
0467         return self.__field_gid.getvalue()
0468 
0469     def __setfield_gid(self, value):
0470         if isinstance(value,CSVINT):
0471             self.__field_gid=value
0472         else:
0473             self.__field_gid=CSVINT(value,**{'terminator': None})
0474 
0475     def __delfield_gid(self): del self.__field_gid
0476 
0477     gid=property(__getfield_gid, __setfield_gid, __delfield_gid, "Group #")
0478 
0479     def iscontainer(self):
0480         return True
0481 
0482     def containerelements(self):
0483         yield ('command', self.__field_command, None)
0484         yield ('gid', self.__field_gid, "Group #")
0485 
0486 
0487 
0488 
0489 class groupnamesetrequest(BaseProtogenClass):
0490     __fields=['command', 'gid', 'groupname', 'ringtone']
0491 
0492     def __init__(self, *args, **kwargs):
0493         dict={}
0494         # What was supplied to this function
0495         dict.update(kwargs)
0496         # Parent constructor
0497         super(groupnamesetrequest,self).__init__(**dict)
0498         if self.__class__ is groupnamesetrequest:
0499             self._update(args,dict)
0500 
0501 
0502     def getfields(self):
0503         return self.__fields
0504 
0505 
0506     def _update(self, args, kwargs):
0507         super(groupnamesetrequest,self)._update(args,kwargs)
0508         keys=kwargs.keys()
0509         for key in keys:
0510             if key in self.__fields:
0511                 setattr(self, key, kwargs[key])
0512                 del kwargs[key]
0513         # Were any unrecognized kwargs passed in?
0514         if __debug__:
0515             self._complainaboutunusedargs(groupnamesetrequest,kwargs)
0516         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0517         # Make all P fields that haven't already been constructed
0518 
0519 
0520     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0521         'Writes this packet to the supplied buffer'
0522         self._bufferstartoffset=buf.getcurrentoffset()
0523         try: self.__field_command
0524         except:
0525             self.__field_command=CSVSTRING(**{'quotechar': None, 'terminator': None, 'default': '#PBGRW='})
0526         self.__field_command.writetobuffer(buf)
0527         try: self.__field_gid
0528         except:
0529             self.__field_gid=CSVINT()
0530         self.__field_gid.writetobuffer(buf)
0531         try: self.__field_groupname
0532         except:
0533             self.__field_groupname=CSVSTRING()
0534         self.__field_groupname.writetobuffer(buf)
0535         try: self.__field_ringtone
0536         except:
0537             self.__field_ringtone=CSVINT(**{'terminator': None, 'default': 0})
0538         self.__field_ringtone.writetobuffer(buf)
0539         self._bufferendoffset=buf.getcurrentoffset()
0540         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0541 
0542 
0543     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0544         'Reads this packet from the supplied buffer'
0545         self._bufferstartoffset=buf.getcurrentoffset()
0546         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0547         self.__field_command=CSVSTRING(**{'quotechar': None, 'terminator': None, 'default': '#PBGRW='})
0548         self.__field_command.readfrombuffer(buf)
0549         self.__field_gid=CSVINT()
0550         self.__field_gid.readfrombuffer(buf)
0551         self.__field_groupname=CSVSTRING()
0552         self.__field_groupname.readfrombuffer(buf)
0553         self.__field_ringtone=CSVINT(**{'terminator': None, 'default': 0})
0554         self.__field_ringtone.readfrombuffer(buf)
0555         self._bufferendoffset=buf.getcurrentoffset()
0556 
0557 
0558     def __getfield_command(self):
0559         try: self.__field_command
0560         except:
0561             self.__field_command=CSVSTRING(**{'quotechar': None, 'terminator': None, 'default': '#PBGRW='})
0562         return self.__field_command.getvalue()
0563 
0564     def __setfield_command(self, value):
0565         if isinstance(value,CSVSTRING):
0566             self.__field_command=value
0567         else:
0568             self.__field_command=CSVSTRING(value,**{'quotechar': None, 'terminator': None, 'default': '#PBGRW='})
0569 
0570     def __delfield_command(self): del self.__field_command
0571 
0572     command=property(__getfield_command, __setfield_command, __delfield_command, None)
0573 
0574     def __getfield_gid(self):
0575         try: self.__field_gid
0576         except:
0577             self.__field_gid=CSVINT()
0578         return self.__field_gid.getvalue()
0579 
0580     def __setfield_gid(self, value):
0581         if isinstance(value,CSVINT):
0582             self.__field_gid=value
0583         else:
0584             self.__field_gid=CSVINT(value,)
0585 
0586     def __delfield_gid(self): del self.__field_gid
0587 
0588     gid=property(__getfield_gid, __setfield_gid, __delfield_gid, "Group #")
0589 
0590     def __getfield_groupname(self):
0591         try: self.__field_groupname
0592         except:
0593             self.__field_groupname=CSVSTRING()
0594         return self.__field_groupname.getvalue()
0595 
0596     def __setfield_groupname(self, value):
0597         if isinstance(value,CSVSTRING):
0598             self.__field_groupname=value
0599         else:
0600             self.__field_groupname=CSVSTRING(value,)
0601 
0602     def __delfield_groupname(self): del self.__field_groupname
0603 
0604     groupname=property(__getfield_groupname, __setfield_groupname, __delfield_groupname, None)
0605 
0606     def __getfield_ringtone(self):
0607         try: self.__field_ringtone
0608         except:
0609             self.__field_ringtone=CSVINT(**{'terminator': None, 'default': 0})
0610         return self.__field_ringtone.getvalue()
0611 
0612     def __setfield_ringtone(self, value):
0613         if isinstance(value,CSVINT):
0614             self.__field_ringtone=value
0615         else:
0616             self.__field_ringtone=CSVINT(value,**{'terminator': None, 'default': 0})
0617 
0618     def __delfield_ringtone(self): del self.__field_ringtone
0619 
0620     ringtone=property(__getfield_ringtone, __setfield_ringtone, __delfield_ringtone, "Ringtone assignment")
0621 
0622     def iscontainer(self):
0623         return True
0624 
0625     def containerelements(self):
0626         yield ('command', self.__field_command, None)
0627         yield ('gid', self.__field_gid, "Group #")
0628         yield ('groupname', self.__field_groupname, None)
0629         yield ('ringtone', self.__field_ringtone, "Ringtone assignment")
0630 
0631 
0632 
0633 
0634 class groupnamesetrequest(BaseProtogenClass):
0635     __fields=['command', 'gid', 'groupname', 'ringtone']
0636 
0637     def __init__(self, *args, **kwargs):
0638         dict={}
0639         # What was supplied to this function
0640         dict.update(kwargs)
0641         # Parent constructor
0642         super(groupnamesetrequest,self).__init__(**dict)
0643         if self.__class__ is groupnamesetrequest:
0644             self._update(args,dict)
0645 
0646 
0647     def getfields(self):
0648         return self.__fields
0649 
0650 
0651     def _update(self, args, kwargs):
0652         super(groupnamesetrequest,self)._update(args,kwargs)
0653         keys=kwargs.keys()
0654         for key in keys:
0655             if key in self.__fields:
0656                 setattr(self, key, kwargs[key])
0657                 del kwargs[key]
0658         # Were any unrecognized kwargs passed in?
0659         if __debug__:
0660             self._complainaboutunusedargs(groupnamesetrequest,kwargs)
0661         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0662         # Make all P fields that haven't already been constructed
0663 
0664 
0665     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0666         'Writes this packet to the supplied buffer'
0667         self._bufferstartoffset=buf.getcurrentoffset()
0668         try: self.__field_command
0669         except:
0670             self.__field_command=CSVSTRING(**{'quotechar': None, 'terminator': None, 'default': '#PBGRW='})
0671         self.__field_command.writetobuffer(buf)
0672         try: self.__field_gid
0673         except:
0674             self.__field_gid=CSVINT()
0675         self.__field_gid.writetobuffer(buf)
0676         try: self.__field_groupname
0677         except:
0678             self.__field_groupname=CSVSTRING()
0679         self.__field_groupname.writetobuffer(buf)
0680         try: self.__field_ringtone
0681         except:
0682             self.__field_ringtone=CSVINT(**{'terminator': None, 'default': 0})
0683         self.__field_ringtone.writetobuffer(buf)
0684         self._bufferendoffset=buf.getcurrentoffset()
0685         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0686 
0687 
0688     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0689         'Reads this packet from the supplied buffer'
0690         self._bufferstartoffset=buf.getcurrentoffset()
0691         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0692         self.__field_command=CSVSTRING(**{'quotechar': None, 'terminator': None, 'default': '#PBGRW='})
0693         self.__field_command.readfrombuffer(buf)
0694         self.__field_gid=CSVINT()
0695         self.__field_gid.readfrombuffer(buf)
0696         self.__field_groupname=CSVSTRING()
0697         self.__field_groupname.readfrombuffer(buf)
0698         self.__field_ringtone=CSVINT(**{'terminator': None, 'default': 0})
0699         self.__field_ringtone.readfrombuffer(buf)
0700         self._bufferendoffset=buf.getcurrentoffset()
0701 
0702 
0703     def __getfield_command(self):
0704         try: self.__field_command
0705         except:
0706             self.__field_command=CSVSTRING(**{'quotechar': None, 'terminator': None, 'default': '#PBGRW='})
0707         return self.__field_command.getvalue()
0708 
0709     def __setfield_command(self, value):
0710         if isinstance(value,CSVSTRING):
0711             self.__field_command=value
0712         else:
0713             self.__field_command=CSVSTRING(value,**{'quotechar': None, 'terminator': None, 'default': '#PBGRW='})
0714 
0715     def __delfield_command(self): del self.__field_command
0716 
0717     command=property(__getfield_command, __setfield_command, __delfield_command, None)
0718 
0719     def __getfield_gid(self):
0720         try: self.__field_gid
0721         except:
0722             self.__field_gid=CSVINT()
0723         return self.__field_gid.getvalue()
0724 
0725     def __setfield_gid(self, value):
0726         if isinstance(value,CSVINT):
0727             self.__field_gid=value
0728         else:
0729             self.__field_gid=CSVINT(value,)
0730 
0731     def __delfield_gid(self): del self.__field_gid
0732 
0733     gid=property(__getfield_gid, __setfield_gid, __delfield_gid, "Group #")
0734 
0735     def __getfield_groupname(self):
0736         try: self.__field_groupname
0737         except:
0738             self.__field_groupname=CSVSTRING()
0739         return self.__field_groupname.getvalue()
0740 
0741     def __setfield_groupname(self, value):
0742         if isinstance(value,CSVSTRING):
0743             self.__field_groupname=value
0744         else:
0745             self.__field_groupname=CSVSTRING(value,)
0746 
0747     def __delfield_groupname(self): del self.__field_groupname
0748 
0749     groupname=property(__getfield_groupname, __setfield_groupname, __delfield_groupname, None)
0750 
0751     def __getfield_ringtone(self):
0752         try: self.__field_ringtone
0753         except:
0754             self.__field_ringtone=CSVINT(**{'terminator': None, 'default': 0})
0755         return self.__field_ringtone.getvalue()
0756 
0757     def __setfield_ringtone(self, value):
0758         if isinstance(value,CSVINT):
0759             self.__field_ringtone=value
0760         else:
0761             self.__field_ringtone=CSVINT(value,**{'terminator': None, 'default': 0})
0762 
0763     def __delfield_ringtone(self): del self.__field_ringtone
0764 
0765     ringtone=property(__getfield_ringtone, __setfield_ringtone, __delfield_ringtone, "Ringtone assignment")
0766 
0767     def iscontainer(self):
0768         return True
0769 
0770     def containerelements(self):
0771         yield ('command', self.__field_command, None)
0772         yield ('gid', self.__field_gid, "Group #")
0773         yield ('groupname', self.__field_groupname, None)
0774         yield ('ringtone', self.__field_ringtone, "Ringtone assignment")
0775 
0776 
0777 
0778 
0779 class eventrequest(BaseProtogenClass):
0780     __fields=['command', 'slot']
0781 
0782     def __init__(self, *args, **kwargs):
0783         dict={}
0784         # What was supplied to this function
0785         dict.update(kwargs)
0786         # Parent constructor
0787         super(eventrequest,self).__init__(**dict)
0788         if self.__class__ is eventrequest:
0789             self._update(args,dict)
0790 
0791 
0792     def getfields(self):
0793         return self.__fields
0794 
0795 
0796     def _update(self, args, kwargs):
0797         super(eventrequest,self)._update(args,kwargs)
0798         keys=kwargs.keys()
0799         for key in keys:
0800             if key in self.__fields:
0801                 setattr(self, key, kwargs[key])
0802                 del kwargs[key]
0803         # Were any unrecognized kwargs passed in?
0804         if __debug__:
0805             self._complainaboutunusedargs(eventrequest,kwargs)
0806         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0807         # Make all P fields that haven't already been constructed
0808 
0809 
0810     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0811         'Writes this packet to the supplied buffer'
0812         self._bufferstartoffset=buf.getcurrentoffset()
0813         try: self.__field_command
0814         except:
0815             self.__field_command=CSVSTRING(**{'quotechar': None, 'terminator': None, 'default': '#PISHR='})
0816         self.__field_command.writetobuffer(buf)
0817         try: self.__field_slot
0818         except:
0819             self.__field_slot=CSVINT(**{'terminator': None})
0820         self.__field_slot.writetobuffer(buf)
0821         self._bufferendoffset=buf.getcurrentoffset()
0822         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0823 
0824 
0825     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0826         'Reads this packet from the supplied buffer'
0827         self._bufferstartoffset=buf.getcurrentoffset()
0828         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0829         self.__field_command=CSVSTRING(**{'quotechar': None, 'terminator': None, 'default': '#PISHR='})
0830         self.__field_command.readfrombuffer(buf)
0831         self.__field_slot=CSVINT(**{'terminator': None})
0832         self.__field_slot.readfrombuffer(buf)
0833         self._bufferendoffset=buf.getcurrentoffset()
0834 
0835 
0836     def __getfield_command(self):
0837         try: self.__field_command
0838         except:
0839             self.__field_command=CSVSTRING(**{'quotechar': None, 'terminator': None, 'default': '#PISHR='})
0840         return self.__field_command.getvalue()
0841 
0842     def __setfield_command(self, value):
0843         if isinstance(value,CSVSTRING):
0844             self.__field_command=value
0845         else:
0846             self.__field_command=CSVSTRING(value,**{'quotechar': None, 'terminator': None, 'default': '#PISHR='})
0847 
0848     def __delfield_command(self): del self.__field_command
0849 
0850     command=property(__getfield_command, __setfield_command, __delfield_command, None)
0851 
0852     def __getfield_slot(self):
0853         try: self.__field_slot
0854         except:
0855             self.__field_slot=CSVINT(**{'terminator': None})
0856         return self.__field_slot.getvalue()
0857 
0858     def __setfield_slot(self, value):
0859         if isinstance(value,CSVINT):
0860             self.__field_slot=value
0861         else:
0862             self.__field_slot=CSVINT(value,**{'terminator': None})
0863 
0864     def __delfield_slot(self): del self.__field_slot
0865 
0866     slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None)
0867 
0868     def iscontainer(self):
0869         return True
0870 
0871     def containerelements(self):
0872         yield ('command', self.__field_command, None)
0873         yield ('slot', self.__field_slot, None)
0874 
0875 
0876 
0877 
0878 class eventresponse(BaseProtogenClass):
0879     __fields=['command', 'slot', 'start', 'end', 'timestamp', 'alarm', 'dunno', 'eventname']
0880 
0881     def __init__(self, *args, **kwargs):
0882         dict={}
0883         # What was supplied to this function
0884         dict.update(kwargs)
0885         # Parent constructor
0886         super(eventresponse,self).__init__(**dict)
0887         if self.__class__ is eventresponse:
0888             self._update(args,dict)
0889 
0890 
0891     def getfields(self):
0892         return self.__fields
0893 
0894 
0895     def _update(self, args, kwargs):
0896         super(eventresponse,self)._update(args,kwargs)
0897         keys=kwargs.keys()
0898         for key in keys:
0899             if key in self.__fields:
0900                 setattr(self, key, kwargs[key])
0901                 del kwargs[key]
0902         # Were any unrecognized kwargs passed in?
0903         if __debug__:
0904             self._complainaboutunusedargs(eventresponse,kwargs)
0905         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0906         # Make all P fields that haven't already been constructed
0907 
0908 
0909     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0910         'Writes this packet to the supplied buffer'
0911         self._bufferstartoffset=buf.getcurrentoffset()
0912         self.__field_command.writetobuffer(buf)
0913         self.__field_slot.writetobuffer(buf)
0914         self.__field_start.writetobuffer(buf)
0915         self.__field_end.writetobuffer(buf)
0916         self.__field_timestamp.writetobuffer(buf)
0917         self.__field_alarm.writetobuffer(buf)
0918         self.__field_dunno.writetobuffer(buf)
0919         self.__field_eventname.writetobuffer(buf)
0920         self._bufferendoffset=buf.getcurrentoffset()
0921         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0922 
0923 
0924     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0925         'Reads this packet from the supplied buffer'
0926         self._bufferstartoffset=buf.getcurrentoffset()
0927         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0928         self.__field_command=CSVSTRING(**{'quotechar': None, 'terminator': ord(' '), 'constant': '#PISHR:'})
0929         self.__field_command.readfrombuffer(buf)
0930         self.__field_slot=CSVINT()
0931         self.__field_slot.readfrombuffer(buf)
0932         self.__field_start=CSVTIME()
0933         self.__field_start.readfrombuffer(buf)
0934         self.__field_end=CSVTIME()
0935         self.__field_end.readfrombuffer(buf)
0936         self.__field_timestamp=CSVTIME()
0937         self.__field_timestamp.readfrombuffer(buf)
0938         self.__field_alarm=CSVINT()
0939         self.__field_alarm.readfrombuffer(buf)
0940         self.__field_dunno=CSVSTRING(**{'quotechar': None})
0941         self.__field_dunno.readfrombuffer(buf)
0942         self.__field_eventname=CSVSTRING(**{'terminator': None})
0943         self.__field_eventname.readfrombuffer(buf)
0944         self._bufferendoffset=buf.getcurrentoffset()
0945 
0946 
0947     def __getfield_command(self):
0948         return self.__field_command.getvalue()
0949 
0950     def __setfield_command(self, value):
0951         if isinstance(value,CSVSTRING):
0952             self.__field_command=value
0953         else:
0954             self.__field_command=CSVSTRING(value,**{'quotechar': None, 'terminator': ord(' '), 'constant': '#PISHR:'})
0955 
0956     def __delfield_command(self): del self.__field_command
0957 
0958     command=property(__getfield_command, __setfield_command, __delfield_command, None)
0959 
0960     def __getfield_slot(self):
0961         return self.__field_slot.getvalue()
0962 
0963     def __setfield_slot(self, value):
0964         if isinstance(value,CSVINT):
0965             self.__field_slot=value
0966         else:
0967             self.__field_slot=CSVINT(value,)
0968 
0969     def __delfield_slot(self): del self.__field_slot
0970 
0971     slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None)
0972 
0973     def __getfield_start(self):
0974         return self.__field_start.getvalue()
0975 
0976     def __setfield_start(self, value):
0977         if isinstance(value,CSVTIME):
0978             self.__field_start=value
0979         else:
0980             self.__field_start=CSVTIME(value,)
0981 
0982     def __delfield_start(self): del self.__field_start
0983 
0984     start=property(__getfield_start, __setfield_start, __delfield_start, None)
0985 
0986     def __getfield_end(self):
0987         return self.__field_end.getvalue()
0988 
0989     def __setfield_end(self, value):
0990         if isinstance(value,CSVTIME):
0991             self.__field_end=value
0992         else:
0993             self.__field_end=CSVTIME(value,)
0994 
0995     def __delfield_end(self): del self.__field_end
0996 
0997     end=property(__getfield_end, __setfield_end, __delfield_end, None)
0998 
0999     def __getfield_timestamp(self):
1000         return self.__field_timestamp.getvalue()
1001 
1002     def __setfield_timestamp(self, value):
1003         if isinstance(value,CSVTIME):
1004             self.__field_timestamp=value
1005         else:
1006             self.__field_timestamp=CSVTIME(value,)
1007 
1008     def __delfield_timestamp(self): del self.__field_timestamp
1009 
1010     timestamp=property(__getfield_timestamp, __setfield_timestamp, __delfield_timestamp, None)
1011 
1012     def __getfield_alarm(self):
1013         return self.__field_alarm.getvalue()
1014 
1015     def __setfield_alarm(self, value):
1016         if isinstance(value,CSVINT):
1017             self.__field_alarm=value
1018         else:
1019             self.__field_alarm=CSVINT(value,)
1020 
1021     def __delfield_alarm(self): del self.__field_alarm
1022 
1023     alarm=property(__getfield_alarm, __setfield_alarm, __delfield_alarm, "0: 10 minutes, 1: 30 minutes, 2: 60 minutes, 3: No Alarm, 4: On Time")
1024 
1025     def __getfield_dunno(self):
1026         return self.__field_dunno.getvalue()
1027 
1028     def __setfield_dunno(self, value):
1029         if isinstance(value,CSVSTRING):
1030             self.__field_dunno=value
1031         else:
1032             self.__field_dunno=CSVSTRING(value,**{'quotechar': None})
1033 
1034     def __delfield_dunno(self): del self.__field_dunno
1035 
1036     dunno=property(__getfield_dunno, __setfield_dunno, __delfield_dunno, None)
1037 
1038     def __getfield_eventname(self):
1039         return self.__field_eventname.getvalue()
1040 
1041     def __setfield_eventname(self, value):
1042         if isinstance(value,CSVSTRING):
1043             self.__field_eventname=value
1044         else:
1045             self.__field_eventname=CSVSTRING(value,**{'terminator': None})
1046 
1047     def __delfield_eventname(self): del self.__field_eventname
1048 
1049     eventname=property(__getfield_eventname, __setfield_eventname, __delfield_eventname, None)
1050 
1051     def iscontainer(self):
1052         return True
1053 
1054     def containerelements(self):
1055         yield ('command', self.__field_command, None)
1056         yield ('slot', self.__field_slot, None)
1057         yield ('start', self.__field_start, None)
1058         yield ('end', self.__field_end, None)
1059         yield ('timestamp', self.__field_timestamp, None)
1060         yield ('alarm', self.__field_alarm, "0: 10 minutes, 1: 30 minutes, 2: 60 minutes, 3: No Alarm, 4: On Time")
1061         yield ('dunno', self.__field_dunno, None)
1062         yield ('eventname', self.__field_eventname, None)
1063 
1064 
1065 
1066 
1067 class eventupdaterequest(BaseProtogenClass):
1068     __fields=['command', 'slot', 'start', 'end', 'timestamp', 'alarm', 'eventname']
1069 
1070     def __init__(self, *args, **kwargs):
1071         dict={}
1072         # What was supplied to this function
1073         dict.update(kwargs)
1074         # Parent constructor
1075         super(eventupdaterequest,self).__init__(**dict)
1076         if self.__class__ is eventupdaterequest:
1077             self._update(args,dict)
1078 
1079 
1080     def getfields(self):
1081         return self.__fields
1082 
1083 
1084     def _update(self, args, kwargs):
1085         super(eventupdaterequest,self)._update(args,kwargs)
1086         keys=kwargs.keys()
1087         for key in keys:
1088             if key in self.__fields:
1089                 setattr(self, key, kwargs[key])
1090                 del kwargs[key]
1091         # Were any unrecognized kwargs passed in?
1092         if __debug__:
1093             self._complainaboutunusedargs(eventupdaterequest,kwargs)
1094         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
1095         # Make all P fields that haven't already been constructed
1096 
1097 
1098     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1099         'Writes this packet to the supplied buffer'
1100         self._bufferstartoffset=buf.getcurrentoffset()
1101         try: self.__field_command
1102         except:
1103             self.__field_command=CSVSTRING(**{'quotechar': None, 'terminator': None, 'default': '#PISHW='})
1104         self.__field_command.writetobuffer(buf)
1105         self.__field_slot.writetobuffer(buf)
1106         self.__field_start.writetobuffer(buf)
1107         self.__field_end.writetobuffer(buf)
1108         self.__field_timestamp.writetobuffer(buf)
1109         self.__field_alarm.writetobuffer(buf)
1110         self.__field_eventname.writetobuffer(buf)
1111         self._bufferendoffset=buf.getcurrentoffset()
1112         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1113 
1114 
1115     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1116         'Reads this packet from the supplied buffer'
1117         self._bufferstartoffset=buf.getcurrentoffset()
1118         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1119         self.__field_command=CSVSTRING(**{'quotechar': None, 'terminator': None, 'default': '#PISHW='})
1120         self.__field_command.readfrombuffer(buf)
1121         self.__field_slot=CSVINT()
1122         self.__field_slot.readfrombuffer(buf)
1123         self.__field_start=CSVTIME()
1124         self.__field_start.readfrombuffer(buf)
1125         self.__field_end=CSVTIME()
1126         self.__field_end.readfrombuffer(buf)
1127         self.__field_timestamp=CSVTIME()
1128         self.__field_timestamp.readfrombuffer(buf)
1129         self.__field_alarm=CSVINT()
1130         self.__field_alarm.readfrombuffer(buf)
1131         self.__field_eventname=CSVSTRING(**{'terminator': None})
1132         self.__field_eventname.readfrombuffer(buf)
1133         self._bufferendoffset=buf.getcurrentoffset()
1134 
1135 
1136     def __getfield_command(self):
1137         try: self.__field_command
1138         except:
1139             self.__field_command=CSVSTRING(**{'quotechar': None, 'terminator': None, 'default': '#PISHW='})
1140         return self.__field_command.getvalue()
1141 
1142     def __setfield_command(self, value):
1143         if isinstance(value,CSVSTRING):
1144             self.__field_command=value
1145         else:
1146             self.__field_command=CSVSTRING(value,**{'quotechar': None, 'terminator': None, 'default': '#PISHW='})
1147 
1148     def __delfield_command(self): del self.__field_command
1149 
1150     command=property(__getfield_command, __setfield_command, __delfield_command, None)
1151 
1152     def __getfield_slot(self):
1153         return self.__field_slot.getvalue()
1154 
1155     def __setfield_slot(self, value):
1156         if isinstance(value,CSVINT):
1157             self.__field_slot=value
1158         else:
1159             self.__field_slot=CSVINT(value,)
1160 
1161     def __delfield_slot(self): del self.__field_slot
1162 
1163     slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None)
1164 
1165     def __getfield_start(self):
1166         return self.__field_start.getvalue()
1167 
1168     def __setfield_start(self, value):
1169         if isinstance(value,CSVTIME):
1170             self.__field_start=value
1171         else:
1172             self.__field_start=CSVTIME(value,)
1173 
1174     def __delfield_start(self): del self.__field_start
1175 
1176     start=property(__getfield_start, __setfield_start, __delfield_start, None)
1177 
1178     def __getfield_end(self):
1179         return self.__field_end.getvalue()
1180 
1181     def __setfield_end(self, value):
1182         if isinstance(value,CSVTIME):
1183             self.__field_end=value
1184         else:
1185             self.__field_end=CSVTIME(value,)
1186 
1187     def __delfield_end(self): del self.__field_end
1188 
1189     end=property(__getfield_end, __setfield_end, __delfield_end, None)
1190 
1191     def __getfield_timestamp(self):
1192         return self.__field_timestamp.getvalue()
1193 
1194     def __setfield_timestamp(self, value):
1195         if isinstance(value,CSVTIME):
1196             self.__field_timestamp=value
1197         else:
1198             self.__field_timestamp=CSVTIME(value,)
1199 
1200     def __delfield_timestamp(self): del self.__field_timestamp
1201 
1202     timestamp=property(__getfield_timestamp, __setfield_timestamp, __delfield_timestamp, None)
1203 
1204     def __getfield_alarm(self):
1205         return self.__field_alarm.getvalue()
1206 
1207     def __setfield_alarm(self, value):
1208         if isinstance(value,CSVINT):
1209             self.__field_alarm=value
1210         else:
1211             self.__field_alarm=CSVINT(value,)
1212 
1213     def __delfield_alarm(self): del self.__field_alarm
1214 
1215     alarm=property(__getfield_alarm, __setfield_alarm, __delfield_alarm, "0: 10 minutes, 1: 30 minutes, 2: 60 minutes, 3: No Alarm, 4: On Time")
1216 
1217     def __getfield_eventname(self):
1218         return self.__field_eventname.getvalue()
1219 
1220     def __setfield_eventname(self, value):
1221         if isinstance(value,CSVSTRING):
1222             self.__field_eventname=value
1223         else:
1224             self.__field_eventname=CSVSTRING(value,**{'terminator': None})
1225 
1226     def __delfield_eventname(self): del self.__field_eventname
1227 
1228     eventname=property(__getfield_eventname, __setfield_eventname, __delfield_eventname, None)
1229 
1230     def iscontainer(self):
1231         return True
1232 
1233     def containerelements(self):
1234         yield ('command', self.__field_command, None)
1235         yield ('slot', self.__field_slot, None)
1236         yield ('start', self.__field_start, None)
1237         yield ('end', self.__field_end, None)
1238         yield ('timestamp', self.__field_timestamp, None)
1239         yield ('alarm', self.__field_alarm, "0: 10 minutes, 1: 30 minutes, 2: 60 minutes, 3: No Alarm, 4: On Time")
1240         yield ('eventname', self.__field_eventname, None)
1241 
1242 
1243 
1244 
1245 class eventsloterase(BaseProtogenClass):
1246     __fields=['command', 'slot']
1247 
1248     def __init__(self, *args, **kwargs):
1249         dict={}
1250         # What was supplied to this function
1251         dict.update(kwargs)
1252         # Parent constructor
1253         super(eventsloterase,self).__init__(**dict)
1254         if self.__class__ is eventsloterase:
1255             self._update(args,dict)
1256 
1257 
1258     def getfields(self):
1259         return self.__fields
1260 
1261 
1262     def _update(self, args, kwargs):
1263         super(eventsloterase,self)._update(args,kwargs)
1264         keys=kwargs.keys()
1265         for key in keys:
1266             if key in self.__fields:
1267                 setattr(self, key, kwargs[key])
1268                 del kwargs[key]
1269         # Were any unrecognized kwargs passed in?
1270         if __debug__:
1271             self._complainaboutunusedargs(eventsloterase,kwargs)
1272         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
1273         # Make all P fields that haven't already been constructed
1274 
1275 
1276     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1277         'Writes this packet to the supplied buffer'
1278         self._bufferstartoffset=buf.getcurrentoffset()
1279         try: self.__field_command
1280         except:
1281             self.__field_command=CSVSTRING(**{'quotechar': None, 'terminator': None, 'default': '#PISHW='})
1282         self.__field_command.writetobuffer(buf)
1283         try: self.__field_slot
1284         except:
1285             self.__field_slot=CSVINT(**{'terminator': None})
1286         self.__field_slot.writetobuffer(buf)
1287         self._bufferendoffset=buf.getcurrentoffset()
1288         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1289 
1290 
1291     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1292         'Reads this packet from the supplied buffer'
1293         self._bufferstartoffset=buf.getcurrentoffset()
1294         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1295         self.__field_command=CSVSTRING(**{'quotechar': None, 'terminator': None, 'default': '#PISHW='})
1296         self.__field_command.readfrombuffer(buf)
1297         self.__field_slot=CSVINT(**{'terminator': None})
1298         self.__field_slot.readfrombuffer(buf)
1299         self._bufferendoffset=buf.getcurrentoffset()
1300 
1301 
1302     def __getfield_command(self):
1303         try: self.__field_command
1304         except:
1305             self.__field_command=CSVSTRING(**{'quotechar': None, 'terminator': None, 'default': '#PISHW='})
1306         return self.__field_command.getvalue()
1307 
1308     def __setfield_command(self, value):
1309         if isinstance(value,CSVSTRING):
1310             self.__field_command=value
1311         else:
1312             self.__field_command=CSVSTRING(value,**{'quotechar': None, 'terminator': None, 'default': '#PISHW='})
1313 
1314     def __delfield_command(self): del self.__field_command
1315 
1316     command=property(__getfield_command, __setfield_command, __delfield_command, None)
1317 
1318     def __getfield_slot(self):
1319         try: self.__field_slot
1320         except:
1321             self.__field_slot=CSVINT(**{'terminator': None})
1322         return self.__field_slot.getvalue()
1323 
1324     def __setfield_slot(self, value):
1325         if isinstance(value,CSVINT):
1326             self.__field_slot=value
1327         else:
1328             self.__field_slot=CSVINT(value,**{'terminator': None})
1329 
1330     def __delfield_slot(self): del self.__field_slot
1331 
1332     slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None)
1333 
1334     def iscontainer(self):
1335         return True
1336 
1337     def containerelements(self):
1338         yield ('command', self.__field_command, None)
1339         yield ('slot', self.__field_slot, None)
1340 
1341 
1342 
1343 
1344 class eventupdateresponse(BaseProtogenClass):
1345     __fields=['pad']
1346 
1347     def __init__(self, *args, **kwargs):
1348         dict={}
1349         # What was supplied to this function
1350         dict.update(kwargs)
1351         # Parent constructor
1352         super(eventupdateresponse,self).__init__(**dict)
1353         if self.__class__ is eventupdateresponse:
1354             self._update(args,dict)
1355 
1356 
1357     def getfields(self):
1358         return self.__fields
1359 
1360 
1361     def _update(self, args, kwargs):
1362         super(eventupdateresponse,self)._update(args,kwargs)
1363         keys=kwargs.keys()
1364         for key in keys:
1365             if key in self.__fields:
1366                 setattr(self, key, kwargs[key])
1367                 del kwargs[key]
1368         # Were any unrecognized kwargs passed in?
1369         if __debug__:
1370             self._complainaboutunusedargs(eventupdateresponse,kwargs)
1371         if len(args):
1372             dict2={}
1373             dict2.update(kwargs)
1374             kwargs=dict2
1375             self.__field_pad=UNKNOWN(*args,**dict2)
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_pad.writetobuffer(buf)
1383         self._bufferendoffset=buf.getcurrentoffset()
1384         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1385 
1386 
1387     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1388         'Reads this packet from the supplied buffer'
1389         self._bufferstartoffset=buf.getcurrentoffset()
1390         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1391         self.__field_pad=UNKNOWN()
1392         self.__field_pad.readfrombuffer(buf)
1393         self._bufferendoffset=buf.getcurrentoffset()
1394 
1395 
1396     def __getfield_pad(self):
1397         return self.__field_pad.getvalue()
1398 
1399     def __setfield_pad(self, value):
1400         if isinstance(value,UNKNOWN):
1401             self.__field_pad=value
1402         else:
1403             self.__field_pad=UNKNOWN(value,)
1404 
1405     def __delfield_pad(self): del self.__field_pad
1406 
1407     pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None)
1408 
1409     def iscontainer(self):
1410         return True
1411 
1412     def containerelements(self):
1413         yield ('pad', self.__field_pad, None)
1414 
1415 
1416 
1417 
1418 class todorequest(BaseProtogenClass):
1419     __fields=['command', 'slot']
1420 
1421     def __init__(self, *args, **kwargs):
1422         dict={}
1423         # What was supplied to this function
1424         dict.update(kwargs)
1425         # Parent constructor
1426         super(todorequest,self).__init__(**dict)
1427         if self.__class__ is todorequest:
1428             self._update(args,dict)
1429 
1430 
1431     def getfields(self):
1432         return self.__fields
1433 
1434 
1435     def _update(self, args, kwargs):
1436         super(todorequest,self)._update(args,kwargs)
1437         keys=kwargs.keys()
1438         for key in keys:
1439             if key in self.__fields:
1440                 setattr(self, key, kwargs[key])
1441                 del kwargs[key]
1442         # Were any unrecognized kwargs passed in?
1443         if __debug__:
1444             self._complainaboutunusedargs(todorequest,kwargs)
1445         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
1446         # Make all P fields that haven't already been constructed
1447 
1448 
1449     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1450         'Writes this packet to the supplied buffer'
1451         self._bufferstartoffset=buf.getcurrentoffset()
1452         try: self.__field_command
1453         except:
1454             self.__field_command=CSVSTRING(**{'quotechar': None, 'terminator': None, 'default': '#PITDR='})
1455         self.__field_command.writetobuffer(buf)
1456         try: self.__field_slot
1457         except:
1458             self.__field_slot=CSVINT(**{'terminator': None})
1459         self.__field_slot.writetobuffer(buf)
1460         self._bufferendoffset=buf.getcurrentoffset()
1461         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1462 
1463 
1464     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1465         'Reads this packet from the supplied buffer'
1466         self._bufferstartoffset=buf.getcurrentoffset()
1467         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1468         self.__field_command=CSVSTRING(**{'quotechar': None, 'terminator': None, 'default': '#PITDR='})
1469         self.__field_command.readfrombuffer(buf)
1470         self.__field_slot=CSVINT(**{'terminator': None})
1471         self.__field_slot.readfrombuffer(buf)
1472         self._bufferendoffset=buf.getcurrentoffset()
1473 
1474 
1475     def __getfield_command(self):
1476         try: self.__field_command
1477         except:
1478             self.__field_command=CSVSTRING(**{'quotechar': None, 'terminator': None, 'default': '#PITDR='})
1479         return self.__field_command.getvalue()
1480 
1481     def __setfield_command(self, value):
1482         if isinstance(value,CSVSTRING):
1483             self.__field_command=value
1484         else:
1485             self.__field_command=CSVSTRING(value,**{'quotechar': None, 'terminator': None, 'default': '#PITDR='})
1486 
1487     def __delfield_command(self): del self.__field_command
1488 
1489     command=property(__getfield_command, __setfield_command, __delfield_command, None)
1490 
1491     def __getfield_slot(self):
1492         try: self.__field_slot
1493         except:
1494             self.__field_slot=CSVINT(**{'terminator': None})
1495         return self.__field_slot.getvalue()
1496 
1497     def __setfield_slot(self, value):
1498         if isinstance(value,CSVINT):
1499             self.__field_slot=value
1500         else:
1501             self.__field_slot=CSVINT(value,**{'terminator': None})
1502 
1503     def __delfield_slot(self): del self.__field_slot
1504 
1505     slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None)
1506 
1507     def iscontainer(self):
1508         return True
1509 
1510     def containerelements(self):
1511         yield ('command', self.__field_command, None)
1512         yield ('slot', self.__field_slot, None)
1513 
1514 
1515 
1516 
1517 class todoresponse(BaseProtogenClass):
1518     __fields=['command', 'slot', 'priority', 'duedate', 'timestamp', 'status', 'subject']
1519 
1520     def __init__(self, *args, **kwargs):
1521         dict={}
1522         # What was supplied to this function
1523         dict.update(kwargs)
1524         # Parent constructor
1525         super(todoresponse,self).__init__(**dict)
1526         if self.__class__ is todoresponse:
1527             self._update(args,dict)
1528 
1529 
1530     def getfields(self):
1531         return self.__fields
1532 
1533 
1534     def _update(self, args, kwargs):
1535         super(todoresponse,self)._update(args,kwargs)
1536         keys=kwargs.keys()
1537         for key in keys:
1538             if key in self.__fields:
1539                 setattr(self, key, kwargs[key])
1540                 del kwargs[key]
1541         # Were any unrecognized kwargs passed in?
1542         if __debug__:
1543             self._complainaboutunusedargs(todoresponse,kwargs)
1544         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
1545         # Make all P fields that haven't already been constructed
1546 
1547 
1548     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1549         'Writes this packet to the supplied buffer'
1550         self._bufferstartoffset=buf.getcurrentoffset()
1551         self.__field_command.writetobuffer(buf)
1552         self.__field_slot.writetobuffer(buf)
1553         self.__field_priority.writetobuffer(buf)
1554         self.__field_duedate.writetobuffer(buf)
1555         self.__field_timestamp.writetobuffer(buf)
1556         self.__field_status.writetobuffer(buf)
1557         self.__field_subject.writetobuffer(buf)
1558         self._bufferendoffset=buf.getcurrentoffset()
1559         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1560 
1561 
1562     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1563         'Reads this packet from the supplied buffer'
1564         self._bufferstartoffset=buf.getcurrentoffset()
1565         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1566         self.__field_command=CSVSTRING(**{'quotechar': None, 'terminator': ord(' '), 'default': '#PITDR:'})
1567         self.__field_command.readfrombuffer(buf)
1568         self.__field_slot=CSVINT()
1569         self.__field_slot.readfrombuffer(buf)
1570         self.__field_priority=CSVINT()
1571         self.__field_priority.readfrombuffer(buf)
1572         self.__field_duedate=CSVTIME()
1573         self.__field_duedate.readfrombuffer(buf)
1574         self.__field_timestamp=CSVTIME()
1575         self.__field_timestamp.readfrombuffer(buf)
1576         self.__field_status=CSVSTRING(**{'quotechar': None})
1577         self.__field_status.readfrombuffer(buf)
1578         self.__field_subject=CSVSTRING(**{'terminator': None})
1579         self.__field_subject.readfrombuffer(buf)
1580         self._bufferendoffset=buf.getcurrentoffset()
1581 
1582 
1583     def __getfield_command(self):
1584         return self.__field_command.getvalue()
1585 
1586     def __setfield_command(self, value):
1587         if isinstance(value,CSVSTRING):
1588             self.__field_command=value
1589         else:
1590             self.__field_command=CSVSTRING(value,**{'quotechar': None, 'terminator': ord(' '), 'default': '#PITDR:'})
1591 
1592     def __delfield_command(self): del self.__field_command
1593 
1594     command=property(__getfield_command, __setfield_command, __delfield_command, None)
1595 
1596     def __getfield_slot(self):
1597         return self.__field_slot.getvalue()
1598 
1599     def __setfield_slot(self, value):
1600         if isinstance(value,CSVINT):
1601             self.__field_slot=value
1602         else:
1603             self.__field_slot=CSVINT(value,)
1604 
1605     def __delfield_slot(self): del self.__field_slot
1606 
1607     slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None)
1608 
1609     def __getfield_priority(self):
1610         return self.__field_priority.getvalue()
1611 
1612     def __setfield_priority(self, value):
1613         if isinstance(value,CSVINT):
1614             self.__field_priority=value
1615         else:
1616             self.__field_priority=CSVINT(value,)
1617 
1618     def __delfield_priority(self): del self.__field_priority
1619 
1620     priority=property(__getfield_priority, __setfield_priority, __delfield_priority, None)
1621 
1622     def __getfield_duedate(self):
1623         return self.__field_duedate.getvalue()
1624 
1625     def __setfield_duedate(self, value):
1626         if isinstance(value,CSVTIME):
1627             self.__field_duedate=value
1628         else:
1629             self.__field_duedate=CSVTIME(value,)
1630 
1631     def __delfield_duedate(self): del self.__field_duedate
1632 
1633     duedate=property(__getfield_duedate, __setfield_duedate, __delfield_duedate, None)
1634 
1635     def __getfield_timestamp(self):
1636         return self.__field_timestamp.getvalue()
1637 
1638     def __setfield_timestamp(self, value):
1639         if isinstance(value,CSVTIME):
1640             self.__field_timestamp=value
1641         else:
1642             self.__field_timestamp=CSVTIME(value,)
1643 
1644     def __delfield_timestamp(self): del self.__field_timestamp
1645 
1646     timestamp=property(__getfield_timestamp, __setfield_timestamp, __delfield_timestamp, None)
1647 
1648     def __getfield_status(self):
1649         return self.__field_status.getvalue()
1650 
1651     def __setfield_status(self, value):
1652         if isinstance(value,CSVSTRING):
1653             self.__field_status=value
1654         else:
1655             self.__field_status=CSVSTRING(value,**{'quotechar': None})
1656 
1657     def __delfield_status(self): del self.__field_status
1658 
1659     status=property(__getfield_status, __setfield_status, __delfield_status, None)
1660 
1661     def __getfield_subject(self):
1662         return self.__field_subject.getvalue()
1663 
1664     def __setfield_subject(self, value):
1665         if isinstance(value,CSVSTRING):
1666             self.__field_subject=value
1667         else:
1668             self.__field_subject=CSVSTRING(value,**{'terminator': None})
1669 
1670     def __delfield_subject(self): del self.__field_subject
1671 
1672     subject=property(__getfield_subject, __setfield_subject, __delfield_subject, None)
1673 
1674     def iscontainer(self):
1675         return True
1676 
1677     def containerelements(self):
1678         yield ('command', self.__field_command, None)
1679         yield ('slot', self.__field_slot, None)
1680         yield ('priority', self.__field_priority, None)
1681         yield ('duedate', self.__field_duedate, None)
1682         yield ('timestamp', self.__field_timestamp, None)
1683         yield ('status', self.__field_status, None)
1684         yield ('subject', self.__field_subject, None)
1685 
1686 
1687 
1688 
1689 class todoupdaterequest(BaseProtogenClass):
1690     __fields=['command', 'slot', 'priority', 'duedate', 'timestamp', 'subject']
1691 
1692     def __init__(self, *args, **kwargs):
1693         dict={}
1694         # What was supplied to this function
1695         dict.update(kwargs)
1696         # Parent constructor
1697         super(todoupdaterequest,self).__init__(**dict)
1698         if self.__class__ is todoupdaterequest:
1699             self._update(args,dict)
1700 
1701 
1702     def getfields(self):
1703         return self.__fields
1704 
1705 
1706     def _update(self, args, kwargs):
1707         super(todoupdaterequest,self)._update(args,kwargs)
1708         keys=kwargs.keys()
1709         for key in keys:
1710             if key in self.__fields:
1711                 setattr(self, key, kwargs[key])
1712                 del kwargs[key]
1713         # Were any unrecognized kwargs passed in?
1714         if __debug__:
1715             self._complainaboutunusedargs(todoupdaterequest,kwargs)
1716         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
1717         # Make all P fields that haven't already been constructed
1718 
1719 
1720     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1721         'Writes this packet to the supplied buffer'
1722         self._bufferstartoffset=buf.getcurrentoffset()
1723         try: self.__field_command
1724         except:
1725             self.__field_command=CSVSTRING(**{'quotechar': None, 'terminator': None, 'default': '#PITDW='})
1726         self.__field_command.writetobuffer(buf)
1727         self.__field_slot.writetobuffer(buf)
1728         self.__field_priority.writetobuffer(buf)
1729         self.__field_duedate.writetobuffer(buf)
1730         self.__field_timestamp.writetobuffer(buf)
1731         self.__field_subject.writetobuffer(buf)
1732         self._bufferendoffset=buf.getcurrentoffset()
1733         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1734 
1735 
1736     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1737         'Reads this packet from the supplied buffer'
1738         self._bufferstartoffset=buf.getcurrentoffset()
1739         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1740         self.__field_command=CSVSTRING(**{'quotechar': None, 'terminator': None, 'default': '#PITDW='})
1741         self.__field_command.readfrombuffer(buf)
1742         self.__field_slot=CSVINT()
1743         self.__field_slot.readfrombuffer(buf)
1744         self.__field_priority=CSVINT()
1745         self.__field_priority.readfrombuffer(buf)
1746         self.__field_duedate=CSVTIME()
1747         self.__field_duedate.readfrombuffer(buf)
1748         self.__field_timestamp=CSVTIME()
1749         self.__field_timestamp.readfrombuffer(buf)
1750         self.__field_subject=CSVSTRING(**{'terminator': None})
1751         self.__field_subject.readfrombuffer(buf)
1752         self._bufferendoffset=buf.getcurrentoffset()
1753 
1754 
1755     def __getfield_command(self):
1756         try: self.__field_command
1757         except:
1758             self.__field_command=CSVSTRING(**{'quotechar': None, 'terminator': None, 'default': '#PITDW='})
1759         return self.__field_command.getvalue()
1760 
1761     def __setfield_command(self, value):
1762         if isinstance(value,CSVSTRING):
1763             self.__field_command=value
1764         else:
1765             self.__field_command=CSVSTRING(value,**{'quotechar': None, 'terminator': None, 'default': '#PITDW='})
1766 
1767     def __delfield_command(self): del self.__field_command
1768 
1769     command=property(__getfield_command, __setfield_command, __delfield_command, None)
1770 
1771     def __getfield_slot(self):
1772         return self.__field_slot.getvalue()
1773 
1774     def __setfield_slot(self, value):
1775         if isinstance(value,CSVINT):
1776             self.__field_slot=value
1777         else:
1778             self.__field_slot=CSVINT(value,)
1779 
1780     def __delfield_slot(self): del self.__field_slot
1781 
1782     slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None)
1783 
1784     def __getfield_priority(self):
1785         return self.__field_priority.getvalue()
1786 
1787     def __setfield_priority(self, value):
1788         if isinstance(value,CSVINT):
1789             self.__field_priority=value
1790         else:
1791             self.__field_priority=CSVINT(value,)
1792 
1793     def __delfield_priority(self): del self.__field_priority
1794 
1795     priority=property(__getfield_priority, __setfield_priority, __delfield_priority, None)
1796 
1797     def __getfield_duedate(self):
1798         return self.__field_duedate.getvalue()
1799 
1800     def __setfield_duedate(self, value):
1801         if isinstance(value,CSVTIME):
1802             self.__field_duedate=value
1803         else:
1804             self.__field_duedate=CSVTIME(value,)
1805 
1806     def __delfield_duedate(self): del self.__field_duedate
1807 
1808     duedate=property(__getfield_duedate, __setfield_duedate, __delfield_duedate, None)
1809 
1810     def __getfield_timestamp(self):
1811         return self.__field_timestamp.getvalue()
1812 
1813     def __setfield_timestamp(self, value):
1814         if isinstance(value,CSVTIME):
1815             self.__field_timestamp=value
1816         else:
1817             self.__field_timestamp=CSVTIME(value,)
1818 
1819     def __delfield_timestamp(self): del self.__field_timestamp
1820 
1821     timestamp=property(__getfield_timestamp, __setfield_timestamp, __delfield_timestamp, None)
1822 
1823     def __getfield_subject(self):
1824         return self.__field_subject.getvalue()
1825 
1826     def __setfield_subject(self, value):
1827         if isinstance(value,CSVSTRING):
1828             self.__field_subject=value
1829         else:
1830             self.__field_subject=CSVSTRING(value,**{'terminator': None})
1831 
1832     def __delfield_subject(self): del self.__field_subject
1833 
1834     subject=property(__getfield_subject, __setfield_subject, __delfield_subject, None)
1835 
1836     def iscontainer(self):
1837         return True
1838 
1839     def containerelements(self):
1840         yield ('command', self.__field_command, None)
1841         yield ('slot', self.__field_slot, None)
1842         yield ('priority', self.__field_priority, None)
1843         yield ('duedate', self.__field_duedate, None)
1844         yield ('timestamp', self.__field_timestamp, None)
1845         yield ('subject', self.__field_subject, None)
1846 
1847 
1848 
1849 
1850 class todoerase(BaseProtogenClass):
1851     __fields=['command', 'slot']
1852 
1853     def __init__(self, *args, **kwargs):
1854         dict={}
1855         # What was supplied to this function
1856         dict.update(kwargs)
1857         # Parent constructor
1858         super(todoerase,self).__init__(**dict)
1859         if self.__class__ is todoerase:
1860             self._update(args,dict)
1861 
1862 
1863     def getfields(self):
1864         return self.__fields
1865 
1866 
1867     def _update(self, args, kwargs):
1868         super(todoerase,self)._update(args,kwargs)
1869         keys=kwargs.keys()
1870         for key in keys:
1871             if key in self.__fields:
1872                 setattr(self, key, kwargs[key])
1873                 del kwargs[key]
1874         # Were any unrecognized kwargs passed in?
1875         if __debug__:
1876             self._complainaboutunusedargs(todoerase,kwargs)
1877         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
1878         # Make all P fields that haven't already been constructed
1879 
1880 
1881     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1882         'Writes this packet to the supplied buffer'
1883         self._bufferstartoffset=buf.getcurrentoffset()
1884         try: self.__field_command
1885         except:
1886             self.__field_command=CSVSTRING(**{'quotechar': None, 'terminator': None, 'default': '#PITDW='})
1887         self.__field_command.writetobuffer(buf)
1888         self.__field_slot.writetobuffer(buf)
1889         self._bufferendoffset=buf.getcurrentoffset()
1890         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1891 
1892 
1893     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1894         'Reads this packet from the supplied buffer'
1895         self._bufferstartoffset=buf.getcurrentoffset()
1896         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1897         self.__field_command=CSVSTRING(**{'quotechar': None, 'terminator': None, 'default': '#PITDW='})
1898         self.__field_command.readfrombuffer(buf)
1899         self.__field_slot=CSVINT(**{'terminator': None})
1900         self.__field_slot.readfrombuffer(buf)
1901         self._bufferendoffset=buf.getcurrentoffset()
1902 
1903 
1904     def __getfield_command(self):
1905         try: self.__field_command
1906         except:
1907             self.__field_command=CSVSTRING(**{'quotechar': None, 'terminator': None, 'default': '#PITDW='})
1908         return self.__field_command.getvalue()
1909 
1910     def __setfield_command(self, value):
1911         if isinstance(value,CSVSTRING):
1912             self.__field_command=value
1913         else:
1914             self.__field_command=CSVSTRING(value,**{'quotechar': None, 'terminator': None, 'default': '#PITDW='})
1915 
1916     def __delfield_command(self): del self.__field_command
1917 
1918     command=property(__getfield_command, __setfield_command, __delfield_command, None)
1919 
1920     def __getfield_slot(self):
1921         return self.__field_slot.getvalue()
1922 
1923     def __setfield_slot(self, value):
1924         if isinstance(value,CSVINT):
1925             self.__field_slot=value
1926         else:
1927             self.__field_slot=CSVINT(value,**{'terminator': None})
1928 
1929     def __delfield_slot(self): del self.__field_slot
1930 
1931     slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None)
1932 
1933     def iscontainer(self):
1934         return True
1935 
1936     def containerelements(self):
1937         yield ('command', self.__field_command, None)
1938         yield ('slot', self.__field_slot, None)
1939 
1940 
1941 
1942 
1943 class todoupdateresponse(BaseProtogenClass):
1944     __fields=['pad']
1945 
1946     def __init__(self, *args, **kwargs):
1947         dict={}
1948         # What was supplied to this function
1949         dict.update(kwargs)
1950         # Parent constructor
1951         super(todoupdateresponse,self).__init__(**dict)
1952         if self.__class__ is todoupdateresponse:
1953             self._update(args,dict)
1954 
1955 
1956     def getfields(self):
1957         return self.__fields
1958 
1959 
1960     def _update(self, args, kwargs):
1961         super(todoupdateresponse,self)._update(args,kwargs)
1962         keys=kwargs.keys()
1963         for key in keys:
1964             if key in self.__fields:
1965                 setattr(self, key, kwargs[key])
1966                 del kwargs[key]
1967         # Were any unrecognized kwargs passed in?
1968         if __debug__:
1969             self._complainaboutunusedargs(todoupdateresponse,kwargs)
1970         if len(args):
1971             dict2={}
1972             dict2.update(kwargs)
1973             kwargs=dict2
1974             self.__field_pad=UNKNOWN(*args,**dict2)
1975         # Make all P fields that haven't already been constructed
1976 
1977 
1978     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1979         'Writes this packet to the supplied buffer'
1980         self._bufferstartoffset=buf.getcurrentoffset()
1981         self.__field_pad.writetobuffer(buf)
1982         self._bufferendoffset=buf.getcurrentoffset()
1983         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1984 
1985 
1986     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1987         'Reads this packet from the supplied buffer'
1988         self._bufferstartoffset=buf.getcurrentoffset()
1989         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1990         self.__field_pad=UNKNOWN()
1991         self.__field_pad.readfrombuffer(buf)
1992         self._bufferendoffset=buf.getcurrentoffset()
1993 
1994 
1995     def __getfield_pad(self):
1996         return self.__field_pad.getvalue()
1997 
1998     def __setfield_pad(self, value):
1999         if isinstance(value,UNKNOWN):
2000             self.__field_pad=value
2001         else:
2002             self.__field_pad=UNKNOWN(value,)
2003 
2004     def __delfield_pad(self): del self.__field_pad
2005 
2006     pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None)
2007 
2008     def iscontainer(self):
2009         return True
2010 
2011     def containerelements(self):
2012         yield ('pad', self.__field_pad, None)
2013 
2014 
2015 
2016 
2017 class memorequest(BaseProtogenClass):
2018     __fields=['command', 'slot']
2019 
2020     def __init__(self, *args, **kwargs):
2021         dict={}
2022         # What was supplied to this function
2023         dict.update(kwargs)
2024         # Parent constructor
2025         super(memorequest,self).__init__(**dict)
2026         if self.__class__ is memorequest:
2027             self._update(args,dict)
2028 
2029 
2030     def getfields(self):
2031         return self.__fields
2032 
2033 
2034     def _update(self, args, kwargs):
2035         super(memorequest,self)._update(args,kwargs)
2036         keys=kwargs.keys()
2037         for key in keys:
2038             if key in self.__fields:
2039                 setattr(self, key, kwargs[key])
2040                 del kwargs[key]
2041         # Were any unrecognized kwargs passed in?
2042         if __debug__:
2043             self._complainaboutunusedargs(memorequest,kwargs)
2044         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
2045         # Make all P fields that haven't already been constructed
2046 
2047 
2048     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
2049         'Writes this packet to the supplied buffer'
2050         self._bufferstartoffset=buf.getcurrentoffset()
2051         try: self.__field_command
2052         except:
2053             self.__field_command=CSVSTRING(**{'quotechar': None, 'terminator': None, 'default': '#PIMMR='})
2054         self.__field_command.writetobuffer(buf)
2055         try: self.__field_slot
2056         except:
2057             self.__field_slot=CSVINT(**{'terminator': None})
2058         self.__field_slot.writetobuffer(buf)
2059         self._bufferendoffset=buf.getcurrentoffset()
2060         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
2061 
2062 
2063     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
2064         'Reads this packet from the supplied buffer'
2065         self._bufferstartoffset=buf.getcurrentoffset()
2066         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
2067         self.__field_command=CSVSTRING(**{'quotechar': None, 'terminator': None, 'default': '#PIMMR='})
2068         self.__field_command.readfrombuffer(buf)
2069         self.__field_slot=CSVINT(**{'terminator': None})
2070         self.__field_slot.readfrombuffer(buf)
2071         self._bufferendoffset=buf.getcurrentoffset()
2072 
2073 
2074     def __getfield_command(self):
2075         try: self.__field_command
2076         except:
2077             self.__field_command=CSVSTRING(**{'quotechar': None, 'terminator': None, 'default': '#PIMMR='})
2078         return self.__field_command.getvalue()
2079 
2080     def __setfield_command(self, value):
2081         if isinstance(value,CSVSTRING):
2082             self.__field_command=value
2083         else:
2084             self.__field_command=CSVSTRING(value,**{'quotechar': None, 'terminator': None, 'default': '#PIMMR='})
2085 
2086     def __delfield_command(self): del self.__field_command
2087 
2088     command=property(__getfield_command, __setfield_command, __delfield_command, None)
2089 
2090     def __getfield_slot(self):
2091         try: self.__field_slot
2092         except:
2093             self.__field_slot=CSVINT(**{'terminator': None})
2094         return self.__field_slot.getvalue()
2095 
2096     def __setfield_slot(self, value):
2097         if isinstance(value,CSVINT):
2098             self.__field_slot=value
2099         else:
2100             self.__field_slot=CSVINT(value,**{'terminator': None})
2101 
2102     def __delfield_slot(self): del self.__field_slot
2103 
2104     slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None)
2105 
2106     def iscontainer(self):
2107         return True
2108 
2109     def containerelements(self):
2110         yield ('command', self.__field_command, None)
2111         yield ('slot', self.__field_slot, None)
2112 
2113 
2114 
2115 
2116 class memoresponse(BaseProtogenClass):
2117     __fields=['command', 'slot', 'timestamp', 'status', 'text']
2118 
2119     def __init__(self, *args, **kwargs):
2120         dict={}
2121         # What was supplied to this function
2122         dict.update(kwargs)
2123         # Parent constructor
2124         super(memoresponse,self).__init__(**dict)
2125         if self.__class__ is memoresponse:
2126             self._update(args,dict)
2127 
2128 
2129     def getfields(self):
2130         return self.__fields
2131 
2132 
2133     def _update(self, args, kwargs):
2134         super(memoresponse,self)._update(args,kwargs)
2135         keys=kwargs.keys()
2136         for key in keys:
2137             if key in self.__fields:
2138                 setattr(self, key, kwargs[key])
2139                 del kwargs[key]
2140         # Were any unrecognized kwargs passed in?
2141         if __debug__:
2142             self._complainaboutunusedargs(memoresponse,kwargs)
2143         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
2144         # Make all P fields that haven't already been constructed
2145 
2146 
2147     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
2148         'Writes this packet to the supplied buffer'
2149         self._bufferstartoffset=buf.getcurrentoffset()
2150         self.__field_command.writetobuffer(buf)
2151         self.__field_slot.writetobuffer(buf)
2152         self.__field_timestamp.writetobuffer(buf)
2153         self.__field_status.writetobuffer(buf)
2154         self.__field_text.writetobuffer(buf)
2155         self._bufferendoffset=buf.getcurrentoffset()
2156         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
2157 
2158 
2159     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
2160         'Reads this packet from the supplied buffer'
2161         self._bufferstartoffset=buf.getcurrentoffset()
2162         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
2163         self.__field_command=CSVSTRING(**{'quotechar': None, 'terminator': ord(' '), 'default': '#PIMMR:'})
2164         self.__field_command.readfrombuffer(buf)
2165         self.__field_slot=CSVINT()
2166         self.__field_slot.readfrombuffer(buf)
2167         self.__field_timestamp=CSVTIME()
2168         self.__field_timestamp.readfrombuffer(buf)
2169         self.__field_status=CSVSTRING(**{'quotechar': None})
2170         self.__field_status.readfrombuffer(buf)
2171         self.__field_text=CSVSTRING(**{'terminator': None})
2172         self.__field_text.readfrombuffer(buf)
2173         self._bufferendoffset=buf.getcurrentoffset()
2174 
2175 
2176     def __getfield_command(self):
2177         return self.__field_command.getvalue()
2178 
2179     def __setfield_command(self, value):
2180         if isinstance(value,CSVSTRING):
2181             self.__field_command=value
2182         else:
2183             self.__field_command=CSVSTRING(value,**{'quotechar': None, 'terminator': ord(' '), 'default': '#PIMMR:'})
2184 
2185     def __delfield_command(self): del self.__field_command
2186 
2187     command=property(__getfield_command, __setfield_command, __delfield_command, None)
2188 
2189     def __getfield_slot(self):
2190         return self.__field_slot.getvalue()
2191 
2192     def __setfield_slot(self, value):
2193         if isinstance(value,CSVINT):
2194             self.__field_slot=value
2195         else:
2196             self.__field_slot=CSVINT(value,)
2197 
2198     def __delfield_slot(self): del self.__field_slot
2199 
2200     slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None)
2201 
2202     def __getfield_timestamp(self):
2203         return self.__field_timestamp.getvalue()
2204 
2205     def __setfield_timestamp(self, value):
2206         if isinstance(value,CSVTIME):
2207             self.__field_timestamp=value
2208         else:
2209             self.__field_timestamp=CSVTIME(value,)
2210 
2211     def __delfield_timestamp(self): del self.__field_timestamp
2212 
2213     timestamp=property(__getfield_timestamp, __setfield_timestamp, __delfield_timestamp, None)
2214 
2215     def __getfield_status(self):
2216         return self.__field_status.getvalue()
2217 
2218     def __setfield_status(self, value):
2219         if isinstance(value,CSVSTRING):
2220             self.__field_status=value
2221         else:
2222             self.__field_status=CSVSTRING(value,**{'quotechar': None})
2223 
2224     def __delfield_status(self): del self.__field_status
2225 
2226     status=property(__getfield_status, __setfield_status, __delfield_status, None)
2227 
2228     def __getfield_text(self):
2229         return self.__field_text.getvalue()
2230 
2231     def __setfield_text(self, value):
2232         if isinstance(value,CSVSTRING):
2233             self.__field_text=value
2234         else:
2235             self.__field_text=CSVSTRING(value,**{'terminator': None})
2236 
2237     def __delfield_text(self): del self.__field_text
2238 
2239     text=property(__getfield_text, __setfield_text, __delfield_text, None)
2240 
2241     def iscontainer(self):
2242         return True
2243 
2244     def containerelements(self):
2245         yield ('command', self.__field_command, None)
2246         yield ('slot', self.__field_slot, None)
2247         yield ('timestamp', self.__field_timestamp, None)
2248         yield ('status', self.__field_status, None)
2249         yield ('text', self.__field_text, None)
2250 
2251 
2252 
2253 
2254 class memoupdaterequest(BaseProtogenClass):
2255     __fields=['command', 'slot', 'timestamp', 'text']
2256 
2257     def __init__(self, *args, **kwargs):
2258         dict={}
2259         # What was supplied to this function
2260         dict.update(kwargs)
2261         # Parent constructor
2262         super(memoupdaterequest,self).__init__(**dict)
2263         if self.__class__ is memoupdaterequest:
2264             self._update(args,dict)
2265 
2266 
2267     def getfields(self):
2268         return self.__fields
2269 
2270 
2271     def _update(self, args, kwargs):
2272         super(memoupdaterequest,self)._update(args,kwargs)
2273         keys=kwargs.keys()
2274         for key in keys:
2275             if key in self.__fields:
2276                 setattr(self, key, kwargs[key])
2277                 del kwargs[key]
2278         # Were any unrecognized kwargs passed in?
2279         if __debug__:
2280             self._complainaboutunusedargs(memoupdaterequest,kwargs)
2281         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
2282         # Make all P fields that haven't already been constructed
2283 
2284 
2285     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
2286         'Writes this packet to the supplied buffer'
2287         self._bufferstartoffset=buf.getcurrentoffset()
2288         try: self.__field_command
2289         except:
2290             self.__field_command=CSVSTRING(**{'quotechar': None, 'terminator': None, 'default': '#PIMMW='})
2291         self.__field_command.writetobuffer(buf)
2292         self.__field_slot.writetobuffer(buf)
2293         self.__field_timestamp.writetobuffer(buf)
2294         self.__field_text.writetobuffer(buf)
2295         self._bufferendoffset=buf.getcurrentoffset()
2296         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
2297 
2298 
2299     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
2300         'Reads this packet from the supplied buffer'
2301         self._bufferstartoffset=buf.getcurrentoffset()
2302         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
2303         self.__field_command=CSVSTRING(**{'quotechar': None, 'terminator': None, 'default': '#PIMMW='})
2304         self.__field_command.readfrombuffer(buf)
2305         self.__field_slot=CSVINT()
2306         self.__field_slot.readfrombuffer(buf)
2307         self.__field_timestamp=CSVTIME()
2308         self.__field_timestamp.readfrombuffer(buf)
2309         self.__field_text=CSVSTRING(**{'terminator': None})
2310         self.__field_text.readfrombuffer(buf)
2311         self._bufferendoffset=buf.getcurrentoffset()
2312 
2313 
2314     def __getfield_command(self):
2315         try: self.__field_command
2316         except:
2317             self.__field_command=CSVSTRING(**{'quotechar': None, 'terminator': None, 'default': '#PIMMW='})
2318         return self.__field_command.getvalue()
2319 
2320     def __setfield_command(self, value):
2321         if isinstance(value,CSVSTRING):
2322             self.__field_command=value
2323         else:
2324             self.__field_command=CSVSTRING(value,**{'quotechar': None, 'terminator': None, 'default': '#PIMMW='})
2325 
2326     def __delfield_command(self): del self.__field_command
2327 
2328     command=property(__getfield_command, __setfield_command, __delfield_command, None)
2329 
2330     def __getfield_slot(self):
2331         return self.__field_slot.getvalue()
2332 
2333     def __setfield_slot(self, value):
2334         if isinstance(value,CSVINT):
2335             self.__field_slot=value
2336         else:
2337             self.__field_slot=CSVINT(value,)
2338 
2339     def __delfield_slot(self): del self.__field_slot
2340 
2341     slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None)
2342 
2343     def __getfield_timestamp(self):
2344         return self.__field_timestamp.getvalue()
2345 
2346     def __setfield_timestamp(self, value):
2347         if isinstance(value,CSVTIME):
2348             self.__field_timestamp=value
2349         else:
2350             self.__field_timestamp=CSVTIME(value,)
2351 
2352     def __delfield_timestamp(self): del self.__field_timestamp
2353 
2354     timestamp=property(__getfield_timestamp, __setfield_timestamp, __delfield_timestamp, None)
2355 
2356     def __getfield_text(self):
2357         return self.__field_text.getvalue()
2358 
2359     def __setfield_text(self, value):
2360         if isinstance(value,CSVSTRING):
2361             self.__field_text=value
2362         else:
2363             self.__field_text=CSVSTRING(value,**{'terminator': None})
2364 
2365     def __delfield_text(self): del self.__field_text
2366 
2367     text=property(__getfield_text, __setfield_text, __delfield_text, None)
2368 
2369     def iscontainer(self):
2370         return True
2371 
2372     def containerelements(self):
2373         yield ('command', self.__field_command, None)
2374         yield ('slot', self.__field_slot, None)
2375         yield ('timestamp', self.__field_timestamp, None)
2376         yield ('text', self.__field_text, None)
2377 
2378 
2379 
2380 
2381 class memoerase(BaseProtogenClass):
2382     __fields=['command', 'slot']
2383 
2384     def __init__(self, *args, **kwargs):
2385         dict={}
2386         # What was supplied to this function
2387         dict.update(kwargs)
2388         # Parent constructor
2389         super(memoerase,self).__init__(**dict)
2390         if self.__class__ is memoerase:
2391             self._update(args,dict)
2392 
2393 
2394     def getfields(self):
2395         return self.__fields
2396 
2397 
2398     def _update(self, args, kwargs):
2399         super(memoerase,self)._update(args,kwargs)
2400         keys=kwargs.keys()
2401         for key in keys:
2402             if key in self.__fields:
2403                 setattr(self, key, kwargs[key])
2404                 del kwargs[key]
2405         # Were any unrecognized kwargs passed in?
2406         if __debug__:
2407             self._complainaboutunusedargs(memoerase,kwargs)
2408         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
2409         # Make all P fields that haven't already been constructed
2410 
2411 
2412     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
2413         'Writes this packet to the supplied buffer'
2414         self._bufferstartoffset=buf.getcurrentoffset()
2415         try: self.__field_command
2416         except:
2417             self.__field_command=CSVSTRING(**{'quotechar': None, 'terminator': None, 'default': '#PIMMW='})
2418         self.__field_command.writetobuffer(buf)
2419         self.__field_slot.writetobuffer(buf)
2420         self._bufferendoffset=buf.getcurrentoffset()
2421         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
2422 
2423 
2424     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
2425         'Reads this packet from the supplied buffer'
2426         self._bufferstartoffset=buf.getcurrentoffset()
2427         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
2428         self.__field_command=CSVSTRING(**{'quotechar': None, 'terminator': None, 'default': '#PIMMW='})
2429         self.__field_command.readfrombuffer(buf)
2430         self.__field_slot=CSVINT(**{'terminator': None})
2431         self.__field_slot.readfrombuffer(buf)
2432         self._bufferendoffset=buf.getcurrentoffset()
2433 
2434 
2435     def __getfield_command(self):
2436         try: self.__field_command
2437         except:
2438             self.__field_command=CSVSTRING(**{'quotechar': None, 'terminator': None, 'default': '#PIMMW='})
2439         return self.__field_command.getvalue()
2440 
2441     def __setfield_command(self, value):
2442         if isinstance(value,CSVSTRING):
2443             self.__field_command=value
2444         else:
2445             self.__field_command=CSVSTRING(value,**{'quotechar': None, 'terminator': None, 'default': '#PIMMW='})
2446 
2447     def __delfield_command(self): del self.__field_command
2448 
2449     command=property(__getfield_command, __setfield_command, __delfield_command, None)
2450 
2451     def __getfield_slot(self):
2452         return self.__field_slot.getvalue()
2453 
2454     def __setfield_slot(self, value):
2455         if isinstance(value,CSVINT):
2456             self.__field_slot=value
2457         else:
2458             self.__field_slot=CSVINT(value,**{'terminator': None})
2459 
2460     def __delfield_slot(self): del self.__field_slot
2461 
2462     slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None)
2463 
2464     def iscontainer(self):
2465         return True
2466 
2467     def containerelements(self):
2468         yield ('command', self.__field_command, None)
2469         yield ('slot', self.__field_slot, None)
2470 
2471 
2472 
2473 
2474 class memoupdateresponse(BaseProtogenClass):
2475     __fields=['pad']
2476 
2477     def __init__(self, *args, **kwargs):
2478         dict={}
2479         # What was supplied to this function
2480         dict.update(kwargs)
2481         # Parent constructor
2482         super(memoupdateresponse,self).__init__(**dict)
2483         if self.__class__ is memoupdateresponse:
2484             self._update(args,dict)
2485 
2486 
2487     def getfields(self):
2488         return self.__fields
2489 
2490 
2491     def _update(self, args, kwargs):
2492         super(memoupdateresponse,self)._update(args,kwargs)
2493         keys=kwargs.keys()
2494         for key in keys:
2495             if key in self.__fields:
2496                 setattr(self, key, kwargs[key])
2497                 del kwargs[key]
2498         # Were any unrecognized kwargs passed in?
2499         if __debug__:
2500             self._complainaboutunusedargs(memoupdateresponse,kwargs)
2501         if len(args):
2502             dict2={}
2503             dict2.update(kwargs)
2504             kwargs=dict2
2505             self.__field_pad=UNKNOWN(*args,**dict2)
2506         # Make all P fields that haven't already been constructed
2507 
2508 
2509     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
2510         'Writes this packet to the supplied buffer'
2511         self._bufferstartoffset=buf.getcurrentoffset()
2512         self.__field_pad.writetobuffer(buf)
2513         self._bufferendoffset=buf.getcurrentoffset()
2514         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
2515 
2516 
2517     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
2518         'Reads this packet from the supplied buffer'
2519         self._bufferstartoffset=buf.getcurrentoffset()
2520         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
2521         self.__field_pad=UNKNOWN()
2522         self.__field_pad.readfrombuffer(buf)
2523         self._bufferendoffset=buf.getcurrentoffset()
2524 
2525 
2526     def __getfield_pad(self):
2527         return self.__field_pad.getvalue()
2528 
2529     def __setfield_pad(self, value):
2530         if isinstance(value,UNKNOWN):
2531             self.__field_pad=value
2532         else:
2533             self.__field_pad=UNKNOWN(value,)
2534 
2535     def __delfield_pad(self): del self.__field_pad
2536 
2537     pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None)
2538 
2539     def iscontainer(self):
2540         return True
2541 
2542     def containerelements(self):
2543         yield ('pad', self.__field_pad, None)
2544 
2545 
2546 
2547 
2548 class esnrequest(BaseProtogenClass):
2549     __fields=['command']
2550 
2551     def __init__(self, *args, **kwargs):
2552         dict={}
2553         # What was supplied to this function
2554         dict.update(kwargs)
2555         # Parent constructor
2556         super(esnrequest,self).__init__(**dict)
2557         if self.__class__ is esnrequest:
2558             self._update(args,dict)
2559 
2560 
2561     def getfields(self):
2562         return self.__fields
2563 
2564 
2565     def _update(self, args, kwargs):
2566         super(esnrequest,self)._update(args,kwargs)
2567         keys=kwargs.keys()
2568         for key in keys:
2569             if key in self.__fields:
2570                 setattr(self, key, kwargs[key])
2571                 del kwargs[key]
2572         # Were any unrecognized kwargs passed in?
2573         if __debug__:
2574             self._complainaboutunusedargs(esnrequest,kwargs)
2575         if len(args):
2576             dict2={'quotechar': None, 'terminator': None, 'default': '+GSN'}
2577             dict2.update(kwargs)
2578             kwargs=dict2
2579             self.__field_command=CSVSTRING(*args,**dict2)
2580         # Make all P fields that haven't already been constructed
2581 
2582 
2583     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
2584         'Writes this packet to the supplied buffer'
2585         self._bufferstartoffset=buf.getcurrentoffset()
2586         try: self.__field_command
2587         except:
2588             self.__field_command=CSVSTRING(**{'quotechar': None, 'terminator': None, 'default': '+GSN'})
2589         self.__field_command.writetobuffer(buf)
2590         self._bufferendoffset=buf.getcurrentoffset()
2591         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
2592 
2593 
2594     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
2595         'Reads this packet from the supplied buffer'
2596         self._bufferstartoffset=buf.getcurrentoffset()
2597         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
2598         self.__field_command=CSVSTRING(**{'quotechar': None, 'terminator': None, 'default': '+GSN'})
2599         self.__field_command.readfrombuffer(buf)
2600         self._bufferendoffset=buf.getcurrentoffset()
2601 
2602 
2603     def __getfield_command(self):
2604         try: self.__field_command
2605         except:
2606             self.__field_command=CSVSTRING(**{'quotechar': None, 'terminator': None, 'default': '+GSN'})
2607         return self.__field_command.getvalue()
2608 
2609     def __setfield_command(self, value):
2610         if isinstance(value,CSVSTRING):
2611             self.__field_command=value
2612         else:
2613             self.__field_command=CSVSTRING(value,**{'quotechar': None, 'terminator': None, 'default': '+GSN'})
2614 
2615     def __delfield_command(self): del self.__field_command
2616 
2617     command=property(__getfield_command, __setfield_command, __delfield_command, None)
2618 
2619     def iscontainer(self):
2620         return True
2621 
2622     def containerelements(self):
2623         yield ('command', self.__field_command, None)
2624 
2625 
2626 
2627 
2628 class esnresponse(BaseProtogenClass):
2629     __fields=['command', 'esn']
2630 
2631     def __init__(self, *args, **kwargs):
2632         dict={}
2633         # What was supplied to this function
2634         dict.update(kwargs)
2635         # Parent constructor
2636         super(esnresponse,self).__init__(**dict)
2637         if self.__class__ is esnresponse:
2638             self._update(args,dict)
2639 
2640 
2641     def getfields(self):
2642         return self.__fields
2643 
2644 
2645     def _update(self, args, kwargs):
2646         super(esnresponse,self)._update(args,kwargs)
2647         keys=kwargs.keys()
2648         for key in keys:
2649             if key in self.__fields:
2650                 setattr(self, key, kwargs[key])
2651                 del kwargs[key]
2652         # Were any unrecognized kwargs passed in?
2653         if __debug__:
2654             self._complainaboutunusedargs(esnresponse,kwargs)
2655         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
2656         # Make all P fields that haven't already been constructed
2657 
2658 
2659     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
2660         'Writes this packet to the supplied buffer'
2661         self._bufferstartoffset=buf.getcurrentoffset()
2662         self.__field_command.writetobuffer(buf)
2663         self.__field_esn.writetobuffer(buf)
2664         self._bufferendoffset=buf.getcurrentoffset()
2665         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
2666 
2667 
2668     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
2669         'Reads this packet from the supplied buffer'
2670         self._bufferstartoffset=buf.getcurrentoffset()
2671         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
2672         self.__field_command=CSVSTRING(**{'quotechar': None, 'terminator': ord(' '), 'default': '+GSN'})
2673         self.__field_command.readfrombuffer(buf)
2674         self.__field_esn=CSVSTRING(**{'quotechar': None, 'terminator': None})
2675         self.__field_esn.readfrombuffer(buf)
2676         self._bufferendoffset=buf.getcurrentoffset()
2677 
2678 
2679     def __getfield_command(self):
2680         return self.__field_command.getvalue()
2681 
2682     def __setfield_command(self, value):
2683         if isinstance(value,CSVSTRING):
2684             self.__field_command=value
2685         else:
2686             self.__field_command=CSVSTRING(value,**{'quotechar': None, 'terminator': ord(' '), 'default': '+GSN'})
2687 
2688     def __delfield_command(self): del self.__field_command
2689 
2690     command=property(__getfield_command, __setfield_command, __delfield_command, None)
2691 
2692     def __getfield_esn(self):
2693         return self.__field_esn.getvalue()
2694 
2695     def __setfield_esn(self, value):
2696         if isinstance(value,CSVSTRING):
2697             self.__field_esn=value
2698         else:
2699             self.__field_esn=CSVSTRING(value,**{'quotechar': None, 'terminator': None})
2700 
2701     def __delfield_esn(self): del self.__field_esn
2702 
2703     esn=property(__getfield_esn, __setfield_esn, __delfield_esn, None)
2704 
2705     def iscontainer(self):
2706         return True
2707 
2708     def containerelements(self):
2709         yield ('command', self.__field_command, None)
2710         yield ('esn', self.__field_esn, None)
2711 
2712 
2713 
2714 
2715 class manufacturerreq(BaseProtogenClass):
2716     __fields=['command']
2717 
2718     def __init__(self, *args, **kwargs):
2719         dict={}
2720         # What was supplied to this function
2721         dict.update(kwargs)
2722         # Parent constructor
2723         super(manufacturerreq,self).__init__(**dict)
2724         if self.__class__ is manufacturerreq:
2725             self._update(args,dict)
2726 
2727 
2728     def getfields(self):
2729         return self.__fields
2730 
2731 
2732     def _update(self, args, kwargs):
2733         super(manufacturerreq,self)._update(args,kwargs)
2734         keys=kwargs.keys()
2735         for key in keys:
2736             if key in self.__fields:
2737                 setattr(self, key, kwargs[key])
2738                 del kwargs[key]
2739         # Were any unrecognized kwargs passed in?
2740         if __debug__:
2741             self._complainaboutunusedargs(manufacturerreq,kwargs)
2742         if len(args):
2743             dict2={ 'quotechar': None,                  'terminator': None,                  'default': '+GMI' }
2744             dict2.update(kwargs)
2745             kwargs=dict2
2746             self.__field_command=CSVSTRING(*args,**dict2)
2747         # Make all P fields that haven't already been constructed
2748 
2749 
2750     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
2751         'Writes this packet to the supplied buffer'
2752         self._bufferstartoffset=buf.getcurrentoffset()
2753         try: self.__field_command
2754         except:
2755             self.__field_command=CSVSTRING(**{ 'quotechar': None,                  'terminator': None,                  'default': '+GMI' })
2756         self.__field_command.writetobuffer(buf)
2757         self._bufferendoffset=buf.getcurrentoffset()
2758         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
2759 
2760 
2761     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
2762         'Reads this packet from the supplied buffer'
2763         self._bufferstartoffset=buf.getcurrentoffset()
2764         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
2765         self.__field_command=CSVSTRING(**{ 'quotechar': None,                  'terminator': None,                  'default': '+GMI' })
2766         self.__field_command.readfrombuffer(buf)
2767         self._bufferendoffset=buf.getcurrentoffset()
2768 
2769 
2770     def __getfield_command(self):
2771         try: self.__field_command
2772         except:
2773             self.__field_command=CSVSTRING(**{ 'quotechar': None,                  'terminator': None,                  'default': '+GMI' })
2774         return self.__field_command.getvalue()
2775 
2776     def __setfield_command(self, value):
2777         if isinstance(value,CSVSTRING):
2778             self.__field_command=value
2779         else:
2780             self.__field_command=CSVSTRING(value,**{ 'quotechar': None,                  'terminator': None,                  'default': '+GMI' })
2781 
2782     def __delfield_command(self): del self.__field_command
2783 
2784     command=property(__getfield_command, __setfield_command, __delfield_command, None)
2785 
2786     def iscontainer(self):
2787         return True
2788 
2789     def containerelements(self):
2790         yield ('command', self.__field_command, None)
2791 
2792 
2793 
2794 
2795 class manufacturerresp(BaseProtogenClass):
2796     __fields=['command', 'manufacturer']
2797 
2798     def __init__(self, *args, **kwargs):
2799         dict={}
2800         # What was supplied to this function
2801         dict.update(kwargs)
2802         # Parent constructor
2803         super(manufacturerresp,self).__init__(**dict)
2804         if self.__class__ is manufacturerresp:
2805             self._update(args,dict)
2806 
2807 
2808     def getfields(self):
2809         return self.__fields
2810 
2811 
2812     def _update(self, args, kwargs):
2813         super(manufacturerresp,self)._update(args,kwargs)
2814         keys=kwargs.keys()
2815         for key in keys:
2816             if key in self.__fields:
2817                 setattr(self, key, kwargs[key])
2818                 del kwargs[key]
2819         # Were any unrecognized kwargs passed in?
2820         if __debug__:
2821             self._complainaboutunusedargs(manufacturerresp,kwargs)
2822         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
2823         # Make all P fields that haven't already been constructed
2824 
2825 
2826     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
2827         'Writes this packet to the supplied buffer'
2828         self._bufferstartoffset=buf.getcurrentoffset()
2829         self.__field_command.writetobuffer(buf)
2830         self.__field_manufacturer.writetobuffer(buf)
2831         self._bufferendoffset=buf.getcurrentoffset()
2832         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
2833 
2834 
2835     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
2836         'Reads this packet from the supplied buffer'
2837         self._bufferstartoffset=buf.getcurrentoffset()
2838         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
2839         self.__field_command=CSVSTRING(**{ 'quotechar': None,                  'terminator': ord(' ') })
2840         self.__field_command.readfrombuffer(buf)
2841         self.__field_manufacturer=STRING(**{'terminator': None })
2842         self.__field_manufacturer.readfrombuffer(buf)
2843         self._bufferendoffset=buf.getcurrentoffset()
2844 
2845 
2846     def __getfield_command(self):
2847         return self.__field_command.getvalue()
2848 
2849     def __setfield_command(self, value):
2850         if isinstance(value,CSVSTRING):
2851             self.__field_command=value
2852         else:
2853             self.__field_command=CSVSTRING(value,**{ 'quotechar': None,                  'terminator': ord(' ') })
2854 
2855     def __delfield_command(self): del self.__field_command
2856 
2857     command=property(__getfield_command, __setfield_command, __delfield_command, None)
2858 
2859     def __getfield_manufacturer(self):
2860         return self.__field_manufacturer.getvalue()
2861 
2862     def __setfield_manufacturer(self, value):
2863         if isinstance(value,STRING):
2864             self.__field_manufacturer=value
2865         else:
2866             self.__field_manufacturer=STRING(value,**{'terminator': None })
2867 
2868     def __delfield_manufacturer(self): del self.__field_manufacturer
2869 
2870     manufacturer=property(__getfield_manufacturer, __setfield_manufacturer, __delfield_manufacturer, None)
2871 
2872     def iscontainer(self):
2873         return True
2874 
2875     def containerelements(self):
2876         yield ('command', self.__field_command, None)
2877         yield ('manufacturer', self.__field_manufacturer, None)
2878 
2879 
2880 
2881 
2882 class modelreq(BaseProtogenClass):
2883     __fields=['command']
2884 
2885     def __init__(self, *args, **kwargs):
2886         dict={}
2887         # What was supplied to this function
2888         dict.update(kwargs)
2889         # Parent constructor
2890         super(modelreq,self).__init__(**dict)
2891         if self.__class__ is modelreq:
2892             self._update(args,dict)
2893 
2894 
2895     def getfields(self):
2896         return self.__fields
2897 
2898 
2899     def _update(self, args, kwargs):
2900         super(modelreq,self)._update(args,kwargs)
2901         keys=kwargs.keys()
2902         for key in keys:
2903             if key in self.__fields:
2904                 setattr(self, key, kwargs[key])
2905                 del kwargs[key]
2906         # Were any unrecognized kwargs passed in?
2907         if __debug__:
2908             self._complainaboutunusedargs(modelreq,kwargs)
2909         if len(args):
2910             dict2={ 'terminator': None,               'default': '+GMM' }
2911             dict2.update(kwargs)
2912             kwargs=dict2
2913             self.__field_command=STRING(*args,**dict2)
2914         # Make all P fields that haven't already been constructed
2915 
2916 
2917     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
2918         'Writes this packet to the supplied buffer'
2919         self._bufferstartoffset=buf.getcurrentoffset()
2920         try: self.__field_command
2921         except:
2922             self.__field_command=STRING(**{ 'terminator': None,               'default': '+GMM' })
2923         self.__field_command.writetobuffer(buf)
2924         self._bufferendoffset=buf.getcurrentoffset()
2925         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
2926 
2927 
2928     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
2929         'Reads this packet from the supplied buffer'
2930         self._bufferstartoffset=buf.getcurrentoffset()
2931         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
2932         self.__field_command=STRING(**{ 'terminator': None,               'default': '+GMM' })
2933         self.__field_command.readfrombuffer(buf)
2934         self._bufferendoffset=buf.getcurrentoffset()
2935 
2936 
2937     def __getfield_command(self):
2938         try: self.__field_command
2939         except:
2940             self.__field_command=STRING(**{ 'terminator': None,               'default': '+GMM' })
2941         return self.__field_command.getvalue()
2942 
2943     def __setfield_command(self, value):
2944         if isinstance(value,STRING):
2945             self.__field_command=value
2946         else:
2947             self.__field_command=STRING(value,**{ 'terminator': None,               'default': '+GMM' })
2948 
2949     def __delfield_command(self): del self.__field_command
2950 
2951     command=property(__getfield_command, __setfield_command, __delfield_command, None)
2952 
2953     def iscontainer(self):
2954         return True
2955 
2956     def containerelements(self):
2957         yield ('command', self.__field_command, None)
2958 
2959 
2960 
2961 
2962 class modelresp(BaseProtogenClass):
2963     __fields=['command', 'model']
2964 
2965     def __init__(self, *args, **kwargs):
2966         dict={}
2967         # What was supplied to this function
2968         dict.update(kwargs)
2969         # Parent constructor
2970         super(modelresp,self).__init__(**dict)
2971         if self.__class__ is modelresp:
2972             self._update(args,dict)
2973 
2974 
2975     def getfields(self):
2976         return self.__fields
2977 
2978 
2979     def _update(self, args, kwargs):
2980         super(modelresp,self)._update(args,kwargs)
2981         keys=kwargs.keys()
2982         for key in keys:
2983             if key in self.__fields:
2984                 setattr(self, key, kwargs[key])
2985                 del kwargs[key]
2986         # Were any unrecognized kwargs passed in?
2987         if __debug__:
2988             self._complainaboutunusedargs(modelresp,kwargs)
2989         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
2990         # Make all P fields that haven't already been constructed
2991 
2992 
2993     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
2994         'Writes this packet to the supplied buffer'
2995         self._bufferstartoffset=buf.getcurrentoffset()
2996         self.__field_command.writetobuffer(buf)
2997         self.__field_model.writetobuffer(buf)
2998         self._bufferendoffset=buf.getcurrentoffset()
2999         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
3000 
3001 
3002     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
3003         'Reads this packet from the supplied buffer'
3004         self._bufferstartoffset=buf.getcurrentoffset()
3005         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
3006         self.__field_command=STRING(**{ 'terminator': ord(' ') })
3007         self.__field_command.readfrombuffer(buf)
3008         self.__field_model=STRING(**{ 'terminator': None })
3009         self.__field_model.readfrombuffer(buf)
3010         self._bufferendoffset=buf.getcurrentoffset()
3011 
3012 
3013     def __getfield_command(self):
3014         return self.__field_command.getvalue()
3015 
3016     def __setfield_command(self, value):
3017         if isinstance(value,STRING):
3018             self.__field_command=value
3019         else:
3020             self.__field_command=STRING(value,**{ 'terminator': ord(' ') })
3021 
3022     def __delfield_command(self): del self.__field_command
3023 
3024     command=property(__getfield_command, __setfield_command, __delfield_command, None)
3025 
3026     def __getfield_model(self):
3027         return self.__field_model.getvalue()
3028 
3029     def __setfield_model(self, value):
3030         if isinstance(value,STRING):
3031             self.__field_model=value
3032         else:
3033             self.__field_model=STRING(value,**{ 'terminator': None })
3034 
3035     def __delfield_model(self): del self.__field_model
3036 
3037     model=property(__getfield_model, __setfield_model, __delfield_model, None)
3038 
3039     def iscontainer(self):
3040         return True
3041 
3042     def containerelements(self):
3043         yield ('command', self.__field_command, None)
3044         yield ('model', self.__field_model, None)
3045 
3046 
3047 
3048 
3049 class batterylevelreq(BaseProtogenClass):
3050     __fields=['command']
3051 
3052     def __init__(self, *args, **kwargs):
3053         dict={}
3054         # What was supplied to this function
3055         dict.update(kwargs)
3056         # Parent constructor
3057         super(batterylevelreq,self).__init__(**dict)
3058         if self.__class__ is batterylevelreq:
3059             self._update(args,dict)
3060 
3061 
3062     def getfields(self):
3063         return self.__fields
3064 
3065 
3066     def _update(self, args, kwargs):
3067         super(batterylevelreq,self)._update(args,kwargs)
3068         keys=kwargs.keys()
3069         for key in keys:
3070             if key in self.__fields:
3071                 setattr(self, key, kwargs[key])
3072                 del kwargs[key]
3073         # Were any unrecognized kwargs passed in?
3074         if __debug__:
3075             self._complainaboutunusedargs(batterylevelreq,kwargs)
3076         if len(args):
3077             dict2={ 'terminator': None,               'default':'+CBC?' }
3078             dict2.update(kwargs)
3079             kwargs=dict2
3080             self.__field_command=STRING(*args,**dict2)
3081         # Make all P fields that haven't already been constructed
3082 
3083 
3084     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
3085         'Writes this packet to the supplied buffer'
3086         self._bufferstartoffset=buf.getcurrentoffset()
3087         try: self.__field_command
3088         except:
3089             self.__field_command=STRING(**{ 'terminator': None,               'default':'+CBC?' })
3090         self.__field_command.writetobuffer(buf)
3091         self._bufferendoffset=buf.getcurrentoffset()
3092         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
3093 
3094 
3095     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
3096         'Reads this packet from the supplied buffer'
3097         self._bufferstartoffset=buf.getcurrentoffset()
3098         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
3099         self.__field_command=STRING(**{ 'terminator': None,               'default':'+CBC?' })
3100         self.__field_command.readfrombuffer(buf)
3101         self._bufferendoffset=buf.getcurrentoffset()
3102 
3103 
3104     def __getfield_command(self):
3105         try: self.__field_command
3106         except:
3107             self.__field_command=STRING(**{ 'terminator': None,               'default':'+CBC?' })
3108         return self.__field_command.getvalue()
3109 
3110     def __setfield_command(self, value):
3111         if isinstance(value,STRING):
3112             self.__field_command=value
3113         else:
3114             self.__field_command=STRING(value,**{ 'terminator': None,               'default':'+CBC?' })
3115 
3116     def __delfield_command(self): del self.__field_command
3117 
3118     command=property(__getfield_command, __setfield_command, __delfield_command, None)
3119 
3120     def iscontainer(self):
3121         return True
3122 
3123     def containerelements(self):
3124         yield ('command', self.__field_command, None)
3125 
3126 
3127 
3128 
3129 class batterylevelresp(BaseProtogenClass):
3130     __fields=['command', 'zero', 'level']
3131 
3132     def __init__(self, *args, **kwargs):
3133         dict={}
3134         # What was supplied to this function
3135         dict.update(kwargs)
3136         # Parent constructor
3137         super(batterylevelresp,self).__init__(**dict)
3138         if self.__class__ is batterylevelresp:
3139             self._update(args,dict)
3140 
3141 
3142     def getfields(self):
3143         return self.__fields
3144 
3145 
3146     def _update(self, args, kwargs):
3147         super(batterylevelresp,self)._update(args,kwargs)
3148         keys=kwargs.keys()
3149         for key in keys:
3150             if key in self.__fields:
3151                 setattr(self, key, kwargs[key])
3152                 del kwargs[key]
3153         # Were any unrecognized kwargs passed in?
3154         if __debug__:
3155             self._complainaboutunusedargs(batterylevelresp,kwargs)
3156         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
3157         # Make all P fields that haven't already been constructed
3158 
3159 
3160     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
3161         'Writes this packet to the supplied buffer'
3162         self._bufferstartoffset=buf.getcurrentoffset()
3163         self.__field_command.writetobuffer(buf)
3164         self.__field_zero.writetobuffer(buf)
3165         self.__field_level.writetobuffer(buf)
3166         self._bufferendoffset=buf.getcurrentoffset()
3167         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
3168 
3169 
3170     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
3171         'Reads this packet from the supplied buffer'
3172         self._bufferstartoffset=buf.getcurrentoffset()
3173         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
3174         self.__field_command=STRING(**{ 'terminator': ord(' ') })
3175         self.__field_command.readfrombuffer(buf)
3176         self.__field_zero=CSVINT()
3177         self.__field_zero.readfrombuffer(buf)
3178         self.__field_level=CSVINT(**{ 'terminator': None })
3179         self.__field_level.readfrombuffer(buf)
3180         self._bufferendoffset=buf.getcurrentoffset()
3181 
3182 
3183     def __getfield_command(self):
3184         return self.__field_command.getvalue()
3185 
3186     def __setfield_command(self, value):
3187         if isinstance(value,STRING):
3188             self.__field_command=value
3189         else:
3190             self.__field_command=STRING(value,**{ 'terminator': ord(' ') })
3191 
3192     def __delfield_command(self): del self.__field_command
3193 
3194     command=property(__getfield_command, __setfield_command, __delfield_command, None)
3195 
3196     def __getfield_zero(self):
3197         return self.__field_zero.getvalue()
3198 
3199     def __setfield_zero(self, value):
3200         if isinstance(value,CSVINT):
3201             self.__field_zero=value
3202         else:
3203             self.__field_zero=CSVINT(value,)
3204 
3205     def __delfield_zero(self): del self.__field_zero
3206 
3207     zero=property(__getfield_zero, __setfield_zero, __delfield_zero, None)
3208 
3209     def __getfield_level(self):
3210         return self.__field_level.getvalue()
3211 
3212     def __setfield_level(self, value):
3213         if isinstance(value,CSVINT):
3214             self.__field_level=value
3215         else:
3216             self.__field_level=CSVINT(value,**{ 'terminator': None })
3217 
3218     def __delfield_level(self): del self.__field_level
3219 
3220     level=property(__getfield_level, __setfield_level, __delfield_level, None)
3221 
3222     def iscontainer(self):
3223         return True
3224 
3225     def containerelements(self):
3226         yield ('command', self.__field_command, None)
3227         yield ('zero', self.__field_zero, None)
3228         yield ('level', self.__field_level, None)
3229 
3230     def _levelstr(self):
3231         return '%d%%'%self.level
3232     levelstr=property(fget=_levelstr)
3233 
3234 
3235 
3236 
3237 

Generated by PyXR 0.9.4