0001
0003 """Various descriptions of data specific to Sanyo phones"""
0004
0005 from prototypes import *
0006
0007
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 dict.update(kwargs)
0026 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 if __debug__:
0045 self._complainaboutunusedargs(phonenumber,kwargs)
0046 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0047
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 dict.update(kwargs)
0125 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 if __debug__:
0144 self._complainaboutunusedargs(phonebookslotrequest,kwargs)
0145 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0146
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 dict.update(kwargs)
0224 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 if __debug__:
0243 self._complainaboutunusedargs(phonebooksloterase,kwargs)
0244 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0245
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 dict.update(kwargs)
0323 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 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
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 dict.update(kwargs)
0397 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 if __debug__:
0416 self._complainaboutunusedargs(groupnamerequest,kwargs)
0417 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0418
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 dict.update(kwargs)
0496 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 if __debug__:
0515 self._complainaboutunusedargs(groupnamesetrequest,kwargs)
0516 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0517
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 dict.update(kwargs)
0641 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 if __debug__:
0660 self._complainaboutunusedargs(groupnamesetrequest,kwargs)
0661 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0662
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 dict.update(kwargs)
0786 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 if __debug__:
0805 self._complainaboutunusedargs(eventrequest,kwargs)
0806 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0807
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 dict.update(kwargs)
0885 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 if __debug__:
0904 self._complainaboutunusedargs(eventresponse,kwargs)
0905 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0906
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 dict.update(kwargs)
1074 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 if __debug__:
1093 self._complainaboutunusedargs(eventupdaterequest,kwargs)
1094 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
1095
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 dict.update(kwargs)
1252 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 if __debug__:
1271 self._complainaboutunusedargs(eventsloterase,kwargs)
1272 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
1273
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 dict.update(kwargs)
1351 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 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
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 dict.update(kwargs)
1425 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 if __debug__:
1444 self._complainaboutunusedargs(todorequest,kwargs)
1445 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
1446
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 dict.update(kwargs)
1524 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 if __debug__:
1543 self._complainaboutunusedargs(todoresponse,kwargs)
1544 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
1545
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 dict.update(kwargs)
1696 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 if __debug__:
1715 self._complainaboutunusedargs(todoupdaterequest,kwargs)
1716 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
1717
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 dict.update(kwargs)
1857 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 if __debug__:
1876 self._complainaboutunusedargs(todoerase,kwargs)
1877 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
1878
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 dict.update(kwargs)
1950 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 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
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 dict.update(kwargs)
2024 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 if __debug__:
2043 self._complainaboutunusedargs(memorequest,kwargs)
2044 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
2045
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 dict.update(kwargs)
2123 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 if __debug__:
2142 self._complainaboutunusedargs(memoresponse,kwargs)
2143 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
2144
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 dict.update(kwargs)
2261 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 if __debug__:
2280 self._complainaboutunusedargs(memoupdaterequest,kwargs)
2281 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
2282
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 dict.update(kwargs)
2388 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 if __debug__:
2407 self._complainaboutunusedargs(memoerase,kwargs)
2408 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
2409
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 dict.update(kwargs)
2481 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 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
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 dict.update(kwargs)
2555 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 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
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 dict.update(kwargs)
2635 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 if __debug__:
2654 self._complainaboutunusedargs(esnresponse,kwargs)
2655 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
2656
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 dict.update(kwargs)
2722 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 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
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 dict.update(kwargs)
2802 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 if __debug__:
2821 self._complainaboutunusedargs(manufacturerresp,kwargs)
2822 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
2823
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 dict.update(kwargs)
2889 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 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
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 dict.update(kwargs)
2969 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 if __debug__:
2988 self._complainaboutunusedargs(modelresp,kwargs)
2989 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
2990
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