PyXR

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

0001 # THIS FILE IS AUTOMATICALLY GENERATED.  EDIT THE SOURCE FILE NOT THIS ONE
0002 
0003 """Proposed descriptions of data usign AT commands"""
0004 
0005 from prototypes import *
0006 
0007 # We use LSB for all integer like fields in diagnostic mode
0008 UINT=UINTlsb
0009 BOOL=BOOLlsb
0010 #
0011 
0012 NUMPHONEBOOKENTRIES=500
0013 NUMEMAILS=3
0014 NUMPHONENUMBERS=5
0015 MAXNUMBERLEN=32
0016 NUMTODOENTRIES=9
0017 NUMSMSENTRIES=94
0018 
0019 MAXMEMOLEN=72
0020 
0021 
0022 NUMGROUPS=4
0023 
0024 AMSREGISTRY="ams/AmsRegistry"
0025 
0026 DEFAULT_RINGTONE=0
0027 DEFAULT_WALLPAPER=0
0028 
0029 class firmwarerequest(BaseProtogenClass):
0030     __fields=['command']
0031 
0032     def __init__(self, *args, **kwargs):
0033         dict={}
0034         # What was supplied to this function
0035         dict.update(kwargs)
0036         # Parent constructor
0037         super(firmwarerequest,self).__init__(**dict)
0038         if self.__class__ is firmwarerequest:
0039             self._update(args,dict)
0040 
0041 
0042     def getfields(self):
0043         return self.__fields
0044 
0045 
0046     def _update(self, args, kwargs):
0047         super(firmwarerequest,self)._update(args,kwargs)
0048         keys=kwargs.keys()
0049         for key in keys:
0050             if key in self.__fields:
0051                 setattr(self, key, kwargs[key])
0052                 del kwargs[key]
0053         # Were any unrecognized kwargs passed in?
0054         if __debug__:
0055             self._complainaboutunusedargs(firmwarerequest,kwargs)
0056         if len(args):
0057             dict2={'sizeinbytes': 1, 'constant': 0x00}
0058             dict2.update(kwargs)
0059             kwargs=dict2
0060             self.__field_command=UINT(*args,**dict2)
0061         # Make all P fields that haven't already been constructed
0062 
0063 
0064     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0065         'Writes this packet to the supplied buffer'
0066         self._bufferstartoffset=buf.getcurrentoffset()
0067         try: self.__field_command
0068         except:
0069             self.__field_command=UINT(**{'sizeinbytes': 1, 'constant': 0x00})
0070         self.__field_command.writetobuffer(buf)
0071         self._bufferendoffset=buf.getcurrentoffset()
0072         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0073 
0074 
0075     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0076         'Reads this packet from the supplied buffer'
0077         self._bufferstartoffset=buf.getcurrentoffset()
0078         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0079         self.__field_command=UINT(**{'sizeinbytes': 1, 'constant': 0x00})
0080         self.__field_command.readfrombuffer(buf)
0081         self._bufferendoffset=buf.getcurrentoffset()
0082 
0083 
0084     def __getfield_command(self):
0085         try: self.__field_command
0086         except:
0087             self.__field_command=UINT(**{'sizeinbytes': 1, 'constant': 0x00})
0088         return self.__field_command.getvalue()
0089 
0090     def __setfield_command(self, value):
0091         if isinstance(value,UINT):
0092             self.__field_command=value
0093         else:
0094             self.__field_command=UINT(value,**{'sizeinbytes': 1, 'constant': 0x00})
0095 
0096     def __delfield_command(self): del self.__field_command
0097 
0098     command=property(__getfield_command, __setfield_command, __delfield_command, None)
0099 
0100     def iscontainer(self):
0101         return True
0102 
0103     def containerelements(self):
0104         yield ('command', self.__field_command, None)
0105 
0106 
0107 
0108 
0109 class firmwareresponse(BaseProtogenClass):
0110     __fields=['command', 'unknown']
0111 
0112     def __init__(self, *args, **kwargs):
0113         dict={}
0114         # What was supplied to this function
0115         dict.update(kwargs)
0116         # Parent constructor
0117         super(firmwareresponse,self).__init__(**dict)
0118         if self.__class__ is firmwareresponse:
0119             self._update(args,dict)
0120 
0121 
0122     def getfields(self):
0123         return self.__fields
0124 
0125 
0126     def _update(self, args, kwargs):
0127         super(firmwareresponse,self)._update(args,kwargs)
0128         keys=kwargs.keys()
0129         for key in keys:
0130             if key in self.__fields:
0131                 setattr(self, key, kwargs[key])
0132                 del kwargs[key]
0133         # Were any unrecognized kwargs passed in?
0134         if __debug__:
0135             self._complainaboutunusedargs(firmwareresponse,kwargs)
0136         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0137         # Make all P fields that haven't already been constructed
0138 
0139 
0140     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0141         'Writes this packet to the supplied buffer'
0142         self._bufferstartoffset=buf.getcurrentoffset()
0143         self.__field_command.writetobuffer(buf)
0144         self.__field_unknown.writetobuffer(buf)
0145         self._bufferendoffset=buf.getcurrentoffset()
0146         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0147 
0148 
0149     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0150         'Reads this packet from the supplied buffer'
0151         self._bufferstartoffset=buf.getcurrentoffset()
0152         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0153         self.__field_command=UINT(**{'sizeinbytes': 1})
0154         self.__field_command.readfrombuffer(buf)
0155         self.__field_unknown=UNKNOWN()
0156         self.__field_unknown.readfrombuffer(buf)
0157         self._bufferendoffset=buf.getcurrentoffset()
0158 
0159 
0160     def __getfield_command(self):
0161         return self.__field_command.getvalue()
0162 
0163     def __setfield_command(self, value):
0164         if isinstance(value,UINT):
0165             self.__field_command=value
0166         else:
0167             self.__field_command=UINT(value,**{'sizeinbytes': 1})
0168 
0169     def __delfield_command(self): del self.__field_command
0170 
0171     command=property(__getfield_command, __setfield_command, __delfield_command, None)
0172 
0173     def __getfield_unknown(self):
0174         return self.__field_unknown.getvalue()
0175 
0176     def __setfield_unknown(self, value):
0177         if isinstance(value,UNKNOWN):
0178             self.__field_unknown=value
0179         else:
0180             self.__field_unknown=UNKNOWN(value,)
0181 
0182     def __delfield_unknown(self): del self.__field_unknown
0183 
0184     unknown=property(__getfield_unknown, __setfield_unknown, __delfield_unknown, None)
0185 
0186     def iscontainer(self):
0187         return True
0188 
0189     def containerelements(self):
0190         yield ('command', self.__field_command, None)
0191         yield ('unknown', self.__field_unknown, None)
0192 
0193 
0194 
0195 
0196 class numberheader(BaseProtogenClass):
0197     __fields=['head1', 'head2', 'head3']
0198 
0199     def __init__(self, *args, **kwargs):
0200         dict={}
0201         # What was supplied to this function
0202         dict.update(kwargs)
0203         # Parent constructor
0204         super(numberheader,self).__init__(**dict)
0205         if self.__class__ is numberheader:
0206             self._update(args,dict)
0207 
0208 
0209     def getfields(self):
0210         return self.__fields
0211 
0212 
0213     def _update(self, args, kwargs):
0214         super(numberheader,self)._update(args,kwargs)
0215         keys=kwargs.keys()
0216         for key in keys:
0217             if key in self.__fields:
0218                 setattr(self, key, kwargs[key])
0219                 del kwargs[key]
0220         # Were any unrecognized kwargs passed in?
0221         if __debug__:
0222             self._complainaboutunusedargs(numberheader,kwargs)
0223         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0224         # Make all P fields that haven't already been constructed
0225 
0226 
0227     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0228         'Writes this packet to the supplied buffer'
0229         self._bufferstartoffset=buf.getcurrentoffset()
0230         try: self.__field_head1
0231         except:
0232             self.__field_head1=UINT(**{'sizeinbytes': 1, 'default': 0x26})
0233         self.__field_head1.writetobuffer(buf)
0234         try: self.__field_head2
0235         except:
0236             self.__field_head2=UINT(**{'sizeinbytes': 1, 'constant': 0x39})
0237         self.__field_head2.writetobuffer(buf)
0238         try: self.__field_head3
0239         except:
0240             self.__field_head3=UINT(**{'sizeinbytes': 1, 'constant': 0x0})
0241         self.__field_head3.writetobuffer(buf)
0242         self._bufferendoffset=buf.getcurrentoffset()
0243         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0244 
0245 
0246     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0247         'Reads this packet from the supplied buffer'
0248         self._bufferstartoffset=buf.getcurrentoffset()
0249         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0250         self.__field_head1=UINT(**{'sizeinbytes': 1, 'default': 0x26})
0251         self.__field_head1.readfrombuffer(buf)
0252         self.__field_head2=UINT(**{'sizeinbytes': 1, 'constant': 0x39})
0253         self.__field_head2.readfrombuffer(buf)
0254         self.__field_head3=UINT(**{'sizeinbytes': 1, 'constant': 0x0})
0255         self.__field_head3.readfrombuffer(buf)
0256         self._bufferendoffset=buf.getcurrentoffset()
0257 
0258 
0259     def __getfield_head1(self):
0260         try: self.__field_head1
0261         except:
0262             self.__field_head1=UINT(**{'sizeinbytes': 1, 'default': 0x26})
0263         return self.__field_head1.getvalue()
0264 
0265     def __setfield_head1(self, value):
0266         if isinstance(value,UINT):
0267             self.__field_head1=value
0268         else:
0269             self.__field_head1=UINT(value,**{'sizeinbytes': 1, 'default': 0x26})
0270 
0271     def __delfield_head1(self): del self.__field_head1
0272 
0273     head1=property(__getfield_head1, __setfield_head1, __delfield_head1, None)
0274 
0275     def __getfield_head2(self):
0276         try: self.__field_head2
0277         except:
0278             self.__field_head2=UINT(**{'sizeinbytes': 1, 'constant': 0x39})
0279         return self.__field_head2.getvalue()
0280 
0281     def __setfield_head2(self, value):
0282         if isinstance(value,UINT):
0283             self.__field_head2=value
0284         else:
0285             self.__field_head2=UINT(value,**{'sizeinbytes': 1, 'constant': 0x39})
0286 
0287     def __delfield_head2(self): del self.__field_head2
0288 
0289     head2=property(__getfield_head2, __setfield_head2, __delfield_head2, None)
0290 
0291     def __getfield_head3(self):
0292         try: self.__field_head3
0293         except:
0294             self.__field_head3=UINT(**{'sizeinbytes': 1, 'constant': 0x0})
0295         return self.__field_head3.getvalue()
0296 
0297     def __setfield_head3(self, value):
0298         if isinstance(value,UINT):
0299             self.__field_head3=value
0300         else:
0301             self.__field_head3=UINT(value,**{'sizeinbytes': 1, 'constant': 0x0})
0302 
0303     def __delfield_head3(self): del self.__field_head3
0304 
0305     head3=property(__getfield_head3, __setfield_head3, __delfield_head3, None)
0306 
0307     def iscontainer(self):
0308         return True
0309 
0310     def containerelements(self):
0311         yield ('head1', self.__field_head1, None)
0312         yield ('head2', self.__field_head2, None)
0313         yield ('head3', self.__field_head3, None)
0314 
0315 
0316 
0317 
0318 class nameheader(BaseProtogenClass):
0319     __fields=['head1', 'head2', 'head3']
0320 
0321     def __init__(self, *args, **kwargs):
0322         dict={}
0323         # What was supplied to this function
0324         dict.update(kwargs)
0325         # Parent constructor
0326         super(nameheader,self).__init__(**dict)
0327         if self.__class__ is nameheader:
0328             self._update(args,dict)
0329 
0330 
0331     def getfields(self):
0332         return self.__fields
0333 
0334 
0335     def _update(self, args, kwargs):
0336         super(nameheader,self)._update(args,kwargs)
0337         keys=kwargs.keys()
0338         for key in keys:
0339             if key in self.__fields:
0340                 setattr(self, key, kwargs[key])
0341                 del kwargs[key]
0342         # Were any unrecognized kwargs passed in?
0343         if __debug__:
0344             self._complainaboutunusedargs(nameheader,kwargs)
0345         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0346         # Make all P fields that haven't already been constructed
0347 
0348 
0349     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0350         'Writes this packet to the supplied buffer'
0351         self._bufferstartoffset=buf.getcurrentoffset()
0352         try: self.__field_head1
0353         except:
0354             self.__field_head1=UINT(**{'sizeinbytes': 1, 'default': 0xd3})
0355         self.__field_head1.writetobuffer(buf)
0356         try: self.__field_head2
0357         except:
0358             self.__field_head2=UINT(**{'sizeinbytes': 1, 'constant': 0x59})
0359         self.__field_head2.writetobuffer(buf)
0360         try: self.__field_head3
0361         except:
0362             self.__field_head3=UINT(**{'sizeinbytes': 1, 'constant': 0x0e})
0363         self.__field_head3.writetobuffer(buf)
0364         self._bufferendoffset=buf.getcurrentoffset()
0365         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0366 
0367 
0368     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0369         'Reads this packet from the supplied buffer'
0370         self._bufferstartoffset=buf.getcurrentoffset()
0371         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0372         self.__field_head1=UINT(**{'sizeinbytes': 1, 'default': 0xd3})
0373         self.__field_head1.readfrombuffer(buf)
0374         self.__field_head2=UINT(**{'sizeinbytes': 1, 'constant': 0x59})
0375         self.__field_head2.readfrombuffer(buf)
0376         self.__field_head3=UINT(**{'sizeinbytes': 1, 'constant': 0x0e})
0377         self.__field_head3.readfrombuffer(buf)
0378         self._bufferendoffset=buf.getcurrentoffset()
0379 
0380 
0381     def __getfield_head1(self):
0382         try: self.__field_head1
0383         except:
0384             self.__field_head1=UINT(**{'sizeinbytes': 1, 'default': 0xd3})
0385         return self.__field_head1.getvalue()
0386 
0387     def __setfield_head1(self, value):
0388         if isinstance(value,UINT):
0389             self.__field_head1=value
0390         else:
0391             self.__field_head1=UINT(value,**{'sizeinbytes': 1, 'default': 0xd3})
0392 
0393     def __delfield_head1(self): del self.__field_head1
0394 
0395     head1=property(__getfield_head1, __setfield_head1, __delfield_head1, None)
0396 
0397     def __getfield_head2(self):
0398         try: self.__field_head2
0399         except:
0400             self.__field_head2=UINT(**{'sizeinbytes': 1, 'constant': 0x59})
0401         return self.__field_head2.getvalue()
0402 
0403     def __setfield_head2(self, value):
0404         if isinstance(value,UINT):
0405             self.__field_head2=value
0406         else:
0407             self.__field_head2=UINT(value,**{'sizeinbytes': 1, 'constant': 0x59})
0408 
0409     def __delfield_head2(self): del self.__field_head2
0410 
0411     head2=property(__getfield_head2, __setfield_head2, __delfield_head2, None)
0412 
0413     def __getfield_head3(self):
0414         try: self.__field_head3
0415         except:
0416             self.__field_head3=UINT(**{'sizeinbytes': 1, 'constant': 0x0e})
0417         return self.__field_head3.getvalue()
0418 
0419     def __setfield_head3(self, value):
0420         if isinstance(value,UINT):
0421             self.__field_head3=value
0422         else:
0423             self.__field_head3=UINT(value,**{'sizeinbytes': 1, 'constant': 0x0e})
0424 
0425     def __delfield_head3(self): del self.__field_head3
0426 
0427     head3=property(__getfield_head3, __setfield_head3, __delfield_head3, None)
0428 
0429     def iscontainer(self):
0430         return True
0431 
0432     def containerelements(self):
0433         yield ('head1', self.__field_head1, None)
0434         yield ('head2', self.__field_head2, None)
0435         yield ('head3', self.__field_head3, None)
0436 
0437 
0438 
0439 
0440 class numberrequest(BaseProtogenClass):
0441     __fields=['header', 'slot', 'pad']
0442 
0443     def __init__(self, *args, **kwargs):
0444         dict={}
0445         # What was supplied to this function
0446         dict.update(kwargs)
0447         # Parent constructor
0448         super(numberrequest,self).__init__(**dict)
0449         if self.__class__ is numberrequest:
0450             self._update(args,dict)
0451 
0452 
0453     def getfields(self):
0454         return self.__fields
0455 
0456 
0457     def _update(self, args, kwargs):
0458         super(numberrequest,self)._update(args,kwargs)
0459         keys=kwargs.keys()
0460         for key in keys:
0461             if key in self.__fields:
0462                 setattr(self, key, kwargs[key])
0463                 del kwargs[key]
0464         # Were any unrecognized kwargs passed in?
0465         if __debug__:
0466             self._complainaboutunusedargs(numberrequest,kwargs)
0467         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0468         # Make all P fields that haven't already been constructed
0469 
0470 
0471     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0472         'Writes this packet to the supplied buffer'
0473         self._bufferstartoffset=buf.getcurrentoffset()
0474         try: self.__field_header
0475         except:
0476             self.__field_header=numberheader()
0477         self.__field_header.writetobuffer(buf)
0478         self.__field_slot.writetobuffer(buf)
0479         try: self.__field_pad
0480         except:
0481             self.__field_pad=UNKNOWN(**{'sizeinbytes': 128})
0482         self.__field_pad.writetobuffer(buf)
0483         self._bufferendoffset=buf.getcurrentoffset()
0484         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0485 
0486 
0487     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0488         'Reads this packet from the supplied buffer'
0489         self._bufferstartoffset=buf.getcurrentoffset()
0490         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0491         self.__field_header=numberheader()
0492         self.__field_header.readfrombuffer(buf)
0493         self.__field_slot=UINT(**{'sizeinbytes': 2})
0494         self.__field_slot.readfrombuffer(buf)
0495         self.__field_pad=UNKNOWN(**{'sizeinbytes': 128})
0496         self.__field_pad.readfrombuffer(buf)
0497         self._bufferendoffset=buf.getcurrentoffset()
0498 
0499 
0500     def __getfield_header(self):
0501         try: self.__field_header
0502         except:
0503             self.__field_header=numberheader()
0504         return self.__field_header.getvalue()
0505 
0506     def __setfield_header(self, value):
0507         if isinstance(value,numberheader):
0508             self.__field_header=value
0509         else:
0510             self.__field_header=numberheader(value,)
0511 
0512     def __delfield_header(self): del self.__field_header
0513 
0514     header=property(__getfield_header, __setfield_header, __delfield_header, None)
0515 
0516     def __getfield_slot(self):
0517         return self.__field_slot.getvalue()
0518 
0519     def __setfield_slot(self, value):
0520         if isinstance(value,UINT):
0521             self.__field_slot=value
0522         else:
0523             self.__field_slot=UINT(value,**{'sizeinbytes': 2})
0524 
0525     def __delfield_slot(self): del self.__field_slot
0526 
0527     slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None)
0528 
0529     def __getfield_pad(self):
0530         try: self.__field_pad
0531         except:
0532             self.__field_pad=UNKNOWN(**{'sizeinbytes': 128})
0533         return self.__field_pad.getvalue()
0534 
0535     def __setfield_pad(self, value):
0536         if isinstance(value,UNKNOWN):
0537             self.__field_pad=value
0538         else:
0539             self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 128})
0540 
0541     def __delfield_pad(self): del self.__field_pad
0542 
0543     pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None)
0544 
0545     def iscontainer(self):
0546         return True
0547 
0548     def containerelements(self):
0549         yield ('header', self.__field_header, None)
0550         yield ('slot', self.__field_slot, None)
0551         yield ('pad', self.__field_pad, None)
0552 
0553 
0554 
0555 
0556 class numberresponse(BaseProtogenClass):
0557     __fields=['header', 'slot', 'entry', 'pad']
0558 
0559     def __init__(self, *args, **kwargs):
0560         dict={}
0561         # What was supplied to this function
0562         dict.update(kwargs)
0563         # Parent constructor
0564         super(numberresponse,self).__init__(**dict)
0565         if self.__class__ is numberresponse:
0566             self._update(args,dict)
0567 
0568 
0569     def getfields(self):
0570         return self.__fields
0571 
0572 
0573     def _update(self, args, kwargs):
0574         super(numberresponse,self)._update(args,kwargs)
0575         keys=kwargs.keys()
0576         for key in keys:
0577             if key in self.__fields:
0578                 setattr(self, key, kwargs[key])
0579                 del kwargs[key]
0580         # Were any unrecognized kwargs passed in?
0581         if __debug__:
0582             self._complainaboutunusedargs(numberresponse,kwargs)
0583         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0584         # Make all P fields that haven't already been constructed
0585 
0586 
0587     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0588         'Writes this packet to the supplied buffer'
0589         self._bufferstartoffset=buf.getcurrentoffset()
0590         self.__field_header.writetobuffer(buf)
0591         self.__field_slot.writetobuffer(buf)
0592         self.__field_entry.writetobuffer(buf)
0593         self.__field_pad.writetobuffer(buf)
0594         self._bufferendoffset=buf.getcurrentoffset()
0595         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0596 
0597 
0598     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0599         'Reads this packet from the supplied buffer'
0600         self._bufferstartoffset=buf.getcurrentoffset()
0601         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0602         self.__field_header=numberheader()
0603         self.__field_header.readfrombuffer(buf)
0604         self.__field_slot=UINT(**{'sizeinbytes': 2})
0605         self.__field_slot.readfrombuffer(buf)
0606         self.__field_entry=numberentry()
0607         self.__field_entry.readfrombuffer(buf)
0608         self.__field_pad=UNKNOWN()
0609         self.__field_pad.readfrombuffer(buf)
0610         self._bufferendoffset=buf.getcurrentoffset()
0611 
0612 
0613     def __getfield_header(self):
0614         return self.__field_header.getvalue()
0615 
0616     def __setfield_header(self, value):
0617         if isinstance(value,numberheader):
0618             self.__field_header=value
0619         else:
0620             self.__field_header=numberheader(value,)
0621 
0622     def __delfield_header(self): del self.__field_header
0623 
0624     header=property(__getfield_header, __setfield_header, __delfield_header, None)
0625 
0626     def __getfield_slot(self):
0627         return self.__field_slot.getvalue()
0628 
0629     def __setfield_slot(self, value):
0630         if isinstance(value,UINT):
0631             self.__field_slot=value
0632         else:
0633             self.__field_slot=UINT(value,**{'sizeinbytes': 2})
0634 
0635     def __delfield_slot(self): del self.__field_slot
0636 
0637     slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None)
0638 
0639     def __getfield_entry(self):
0640         return self.__field_entry.getvalue()
0641 
0642     def __setfield_entry(self, value):
0643         if isinstance(value,numberentry):
0644             self.__field_entry=value
0645         else:
0646             self.__field_entry=numberentry(value,)
0647 
0648     def __delfield_entry(self): del self.__field_entry
0649 
0650     entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None)
0651 
0652     def __getfield_pad(self):
0653         return self.__field_pad.getvalue()
0654 
0655     def __setfield_pad(self, value):
0656         if isinstance(value,UNKNOWN):
0657             self.__field_pad=value
0658         else:
0659             self.__field_pad=UNKNOWN(value,)
0660 
0661     def __delfield_pad(self): del self.__field_pad
0662 
0663     pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None)
0664 
0665     def iscontainer(self):
0666         return True
0667 
0668     def containerelements(self):
0669         yield ('header', self.__field_header, None)
0670         yield ('slot', self.__field_slot, None)
0671         yield ('entry', self.__field_entry, None)
0672         yield ('pad', self.__field_pad, None)
0673 
0674 
0675 
0676 
0677 class numberentry(BaseProtogenClass):
0678     __fields=['pad1', 'pos', 'numbertype', 'pad2', 'numlen', 'num']
0679 
0680     def __init__(self, *args, **kwargs):
0681         dict={}
0682         # What was supplied to this function
0683         dict.update(kwargs)
0684         # Parent constructor
0685         super(numberentry,self).__init__(**dict)
0686         if self.__class__ is numberentry:
0687             self._update(args,dict)
0688 
0689 
0690     def getfields(self):
0691         return self.__fields
0692 
0693 
0694     def _update(self, args, kwargs):
0695         super(numberentry,self)._update(args,kwargs)
0696         keys=kwargs.keys()
0697         for key in keys:
0698             if key in self.__fields:
0699                 setattr(self, key, kwargs[key])
0700                 del kwargs[key]
0701         # Were any unrecognized kwargs passed in?
0702         if __debug__:
0703             self._complainaboutunusedargs(numberentry,kwargs)
0704         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0705         # Make all P fields that haven't already been constructed
0706 
0707 
0708     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0709         'Writes this packet to the supplied buffer'
0710         self._bufferstartoffset=buf.getcurrentoffset()
0711         try: self.__field_pad1
0712         except:
0713             self.__field_pad1=UNKNOWN(**{'sizeinbytes': 1})
0714         self.__field_pad1.writetobuffer(buf)
0715         self.__field_pos.writetobuffer(buf)
0716         self.__field_numbertype.writetobuffer(buf)
0717         try: self.__field_pad2
0718         except:
0719             self.__field_pad2=UNKNOWN(**{'sizeinbytes': 2})
0720         self.__field_pad2.writetobuffer(buf)
0721         self.__field_numlen.writetobuffer(buf)
0722         self.__field_num.writetobuffer(buf)
0723         self._bufferendoffset=buf.getcurrentoffset()
0724         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0725 
0726 
0727     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0728         'Reads this packet from the supplied buffer'
0729         self._bufferstartoffset=buf.getcurrentoffset()
0730         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0731         self.__field_pad1=UNKNOWN(**{'sizeinbytes': 1})
0732         self.__field_pad1.readfrombuffer(buf)
0733         self.__field_pos=UINT(**{'sizeinbytes': 1})
0734         self.__field_pos.readfrombuffer(buf)
0735         self.__field_numbertype=UINT(**{'sizeinbytes': 1})
0736         self.__field_numbertype.readfrombuffer(buf)
0737         self.__field_pad2=UNKNOWN(**{'sizeinbytes': 2})
0738         self.__field_pad2.readfrombuffer(buf)
0739         self.__field_numlen=UINT(**{'sizeinbytes': 1})
0740         self.__field_numlen.readfrombuffer(buf)
0741         self.__field_num=USTRING(**{'sizeinbytes': 48, 'raiseonunterminatedread': False})
0742         self.__field_num.readfrombuffer(buf)
0743         self._bufferendoffset=buf.getcurrentoffset()
0744 
0745 
0746     def __getfield_pad1(self):
0747         try: self.__field_pad1
0748         except:
0749             self.__field_pad1=UNKNOWN(**{'sizeinbytes': 1})
0750         return self.__field_pad1.getvalue()
0751 
0752     def __setfield_pad1(self, value):
0753         if isinstance(value,UNKNOWN):
0754             self.__field_pad1=value
0755         else:
0756             self.__field_pad1=UNKNOWN(value,**{'sizeinbytes': 1})
0757 
0758     def __delfield_pad1(self): del self.__field_pad1
0759 
0760     pad1=property(__getfield_pad1, __setfield_pad1, __delfield_pad1, None)
0761 
0762     def __getfield_pos(self):
0763         return self.__field_pos.getvalue()
0764 
0765     def __setfield_pos(self, value):
0766         if isinstance(value,UINT):
0767             self.__field_pos=value
0768         else:
0769             self.__field_pos=UINT(value,**{'sizeinbytes': 1})
0770 
0771     def __delfield_pos(self): del self.__field_pos
0772 
0773     pos=property(__getfield_pos, __setfield_pos, __delfield_pos, None)
0774 
0775     def __getfield_numbertype(self):
0776         return self.__field_numbertype.getvalue()
0777 
0778     def __setfield_numbertype(self, value):
0779         if isinstance(value,UINT):
0780             self.__field_numbertype=value
0781         else:
0782             self.__field_numbertype=UINT(value,**{'sizeinbytes': 1})
0783 
0784     def __delfield_numbertype(self): del self.__field_numbertype
0785 
0786     numbertype=property(__getfield_numbertype, __setfield_numbertype, __delfield_numbertype, None)
0787 
0788     def __getfield_pad2(self):
0789         try: self.__field_pad2
0790         except:
0791             self.__field_pad2=UNKNOWN(**{'sizeinbytes': 2})
0792         return self.__field_pad2.getvalue()
0793 
0794     def __setfield_pad2(self, value):
0795         if isinstance(value,UNKNOWN):
0796             self.__field_pad2=value
0797         else:
0798             self.__field_pad2=UNKNOWN(value,**{'sizeinbytes': 2})
0799 
0800     def __delfield_pad2(self): del self.__field_pad2
0801 
0802     pad2=property(__getfield_pad2, __setfield_pad2, __delfield_pad2, None)
0803 
0804     def __getfield_numlen(self):
0805         return self.__field_numlen.getvalue()
0806 
0807     def __setfield_numlen(self, value):
0808         if isinstance(value,UINT):
0809             self.__field_numlen=value
0810         else:
0811             self.__field_numlen=UINT(value,**{'sizeinbytes': 1})
0812 
0813     def __delfield_numlen(self): del self.__field_numlen
0814 
0815     numlen=property(__getfield_numlen, __setfield_numlen, __delfield_numlen, None)
0816 
0817     def __getfield_num(self):
0818         return self.__field_num.getvalue()
0819 
0820     def __setfield_num(self, value):
0821         if isinstance(value,USTRING):
0822             self.__field_num=value
0823         else:
0824             self.__field_num=USTRING(value,**{'sizeinbytes': 48, 'raiseonunterminatedread': False})
0825 
0826     def __delfield_num(self): del self.__field_num
0827 
0828     num=property(__getfield_num, __setfield_num, __delfield_num, None)
0829 
0830     def iscontainer(self):
0831         return True
0832 
0833     def containerelements(self):
0834         yield ('pad1', self.__field_pad1, None)
0835         yield ('pos', self.__field_pos, None)
0836         yield ('numbertype', self.__field_numbertype, None)
0837         yield ('pad2', self.__field_pad2, None)
0838         yield ('numlen', self.__field_numlen, None)
0839         yield ('num', self.__field_num, None)
0840 
0841 
0842 
0843 
0844 class numberupdaterequest(BaseProtogenClass):
0845     __fields=['header', 'slot', 'entry']
0846 
0847     def __init__(self, *args, **kwargs):
0848         dict={}
0849         # What was supplied to this function
0850         dict.update(kwargs)
0851         # Parent constructor
0852         super(numberupdaterequest,self).__init__(**dict)
0853         if self.__class__ is numberupdaterequest:
0854             self._update(args,dict)
0855 
0856 
0857     def getfields(self):
0858         return self.__fields
0859 
0860 
0861     def _update(self, args, kwargs):
0862         super(numberupdaterequest,self)._update(args,kwargs)
0863         keys=kwargs.keys()
0864         for key in keys:
0865             if key in self.__fields:
0866                 setattr(self, key, kwargs[key])
0867                 del kwargs[key]
0868         # Were any unrecognized kwargs passed in?
0869         if __debug__:
0870             self._complainaboutunusedargs(numberupdaterequest,kwargs)
0871         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0872         # Make all P fields that haven't already been constructed
0873 
0874 
0875     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0876         'Writes this packet to the supplied buffer'
0877         self._bufferstartoffset=buf.getcurrentoffset()
0878         try: self.__field_header
0879         except:
0880             self.__field_header=numberheader(**{'head1': 0x27})
0881         self.__field_header.writetobuffer(buf)
0882         self.__field_slot.writetobuffer(buf)
0883         try: self.__field_entry
0884         except:
0885             self.__field_entry=numberentry()
0886         self.__field_entry.writetobuffer(buf)
0887         self._bufferendoffset=buf.getcurrentoffset()
0888         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0889 
0890 
0891     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0892         'Reads this packet from the supplied buffer'
0893         self._bufferstartoffset=buf.getcurrentoffset()
0894         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0895         self.__field_header=numberheader(**{'head1': 0x27})
0896         self.__field_header.readfrombuffer(buf)
0897         self.__field_slot=UINT(**{'sizeinbytes': 2})
0898         self.__field_slot.readfrombuffer(buf)
0899         self.__field_entry=numberentry()
0900         self.__field_entry.readfrombuffer(buf)
0901         self._bufferendoffset=buf.getcurrentoffset()
0902 
0903 
0904     def __getfield_header(self):
0905         try: self.__field_header
0906         except:
0907             self.__field_header=numberheader(**{'head1': 0x27})
0908         return self.__field_header.getvalue()
0909 
0910     def __setfield_header(self, value):
0911         if isinstance(value,numberheader):
0912             self.__field_header=value
0913         else:
0914             self.__field_header=numberheader(value,**{'head1': 0x27})
0915 
0916     def __delfield_header(self): del self.__field_header
0917 
0918     header=property(__getfield_header, __setfield_header, __delfield_header, None)
0919 
0920     def __getfield_slot(self):
0921         return self.__field_slot.getvalue()
0922 
0923     def __setfield_slot(self, value):
0924         if isinstance(value,UINT):
0925             self.__field_slot=value
0926         else:
0927             self.__field_slot=UINT(value,**{'sizeinbytes': 2})
0928 
0929     def __delfield_slot(self): del self.__field_slot
0930 
0931     slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None)
0932 
0933     def __getfield_entry(self):
0934         try: self.__field_entry
0935         except:
0936             self.__field_entry=numberentry()
0937         return self.__field_entry.getvalue()
0938 
0939     def __setfield_entry(self, value):
0940         if isinstance(value,numberentry):
0941             self.__field_entry=value
0942         else:
0943             self.__field_entry=numberentry(value,)
0944 
0945     def __delfield_entry(self): del self.__field_entry
0946 
0947     entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None)
0948 
0949     def iscontainer(self):
0950         return True
0951 
0952     def containerelements(self):
0953         yield ('header', self.__field_header, None)
0954         yield ('slot', self.__field_slot, None)
0955         yield ('entry', self.__field_entry, None)
0956 
0957 
0958 
0959 
0960 class namerequest(BaseProtogenClass):
0961     __fields=['header', 'slot', 'pad']
0962 
0963     def __init__(self, *args, **kwargs):
0964         dict={}
0965         # What was supplied to this function
0966         dict.update(kwargs)
0967         # Parent constructor
0968         super(namerequest,self).__init__(**dict)
0969         if self.__class__ is namerequest:
0970             self._update(args,dict)
0971 
0972 
0973     def getfields(self):
0974         return self.__fields
0975 
0976 
0977     def _update(self, args, kwargs):
0978         super(namerequest,self)._update(args,kwargs)
0979         keys=kwargs.keys()
0980         for key in keys:
0981             if key in self.__fields:
0982                 setattr(self, key, kwargs[key])
0983                 del kwargs[key]
0984         # Were any unrecognized kwargs passed in?
0985         if __debug__:
0986             self._complainaboutunusedargs(namerequest,kwargs)
0987         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0988         # Make all P fields that haven't already been constructed
0989 
0990 
0991     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0992         'Writes this packet to the supplied buffer'
0993         self._bufferstartoffset=buf.getcurrentoffset()
0994         try: self.__field_header
0995         except:
0996             self.__field_header=nameheader()
0997         self.__field_header.writetobuffer(buf)
0998         self.__field_slot.writetobuffer(buf)
0999         try: self.__field_pad
1000         except:
1001             self.__field_pad=UNKNOWN(**{'sizeinbytes': 140})
1002         self.__field_pad.writetobuffer(buf)
1003         self._bufferendoffset=buf.getcurrentoffset()
1004         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1005 
1006 
1007     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1008         'Reads this packet from the supplied buffer'
1009         self._bufferstartoffset=buf.getcurrentoffset()
1010         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1011         self.__field_header=nameheader()
1012         self.__field_header.readfrombuffer(buf)
1013         self.__field_slot=UINT(**{'sizeinbytes': 2})
1014         self.__field_slot.readfrombuffer(buf)
1015         self.__field_pad=UNKNOWN(**{'sizeinbytes': 140})
1016         self.__field_pad.readfrombuffer(buf)
1017         self._bufferendoffset=buf.getcurrentoffset()
1018 
1019 
1020     def __getfield_header(self):
1021         try: self.__field_header
1022         except:
1023             self.__field_header=nameheader()
1024         return self.__field_header.getvalue()
1025 
1026     def __setfield_header(self, value):
1027         if isinstance(value,nameheader):
1028             self.__field_header=value
1029         else:
1030             self.__field_header=nameheader(value,)
1031 
1032     def __delfield_header(self): del self.__field_header
1033 
1034     header=property(__getfield_header, __setfield_header, __delfield_header, None)
1035 
1036     def __getfield_slot(self):
1037         return self.__field_slot.getvalue()
1038 
1039     def __setfield_slot(self, value):
1040         if isinstance(value,UINT):
1041             self.__field_slot=value
1042         else:
1043             self.__field_slot=UINT(value,**{'sizeinbytes': 2})
1044 
1045     def __delfield_slot(self): del self.__field_slot
1046 
1047     slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None)
1048 
1049     def __getfield_pad(self):
1050         try: self.__field_pad
1051         except:
1052             self.__field_pad=UNKNOWN(**{'sizeinbytes': 140})
1053         return self.__field_pad.getvalue()
1054 
1055     def __setfield_pad(self, value):
1056         if isinstance(value,UNKNOWN):
1057             self.__field_pad=value
1058         else:
1059             self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 140})
1060 
1061     def __delfield_pad(self): del self.__field_pad
1062 
1063     pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None)
1064 
1065     def iscontainer(self):
1066         return True
1067 
1068     def containerelements(self):
1069         yield ('header', self.__field_header, None)
1070         yield ('slot', self.__field_slot, None)
1071         yield ('pad', self.__field_pad, None)
1072 
1073 
1074 
1075 
1076 class nameresponse(BaseProtogenClass):
1077     __fields=['header', 'slot', 'entry', 'pad']
1078 
1079     def __init__(self, *args, **kwargs):
1080         dict={}
1081         # What was supplied to this function
1082         dict.update(kwargs)
1083         # Parent constructor
1084         super(nameresponse,self).__init__(**dict)
1085         if self.__class__ is nameresponse:
1086             self._update(args,dict)
1087 
1088 
1089     def getfields(self):
1090         return self.__fields
1091 
1092 
1093     def _update(self, args, kwargs):
1094         super(nameresponse,self)._update(args,kwargs)
1095         keys=kwargs.keys()
1096         for key in keys:
1097             if key in self.__fields:
1098                 setattr(self, key, kwargs[key])
1099                 del kwargs[key]
1100         # Were any unrecognized kwargs passed in?
1101         if __debug__:
1102             self._complainaboutunusedargs(nameresponse,kwargs)
1103         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
1104         # Make all P fields that haven't already been constructed
1105 
1106 
1107     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1108         'Writes this packet to the supplied buffer'
1109         self._bufferstartoffset=buf.getcurrentoffset()
1110         self.__field_header.writetobuffer(buf)
1111         self.__field_slot.writetobuffer(buf)
1112         self.__field_entry.writetobuffer(buf)
1113         self.__field_pad.writetobuffer(buf)
1114         self._bufferendoffset=buf.getcurrentoffset()
1115         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1116 
1117 
1118     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1119         'Reads this packet from the supplied buffer'
1120         self._bufferstartoffset=buf.getcurrentoffset()
1121         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1122         self.__field_header=nameheader()
1123         self.__field_header.readfrombuffer(buf)
1124         self.__field_slot=UINT(**{'sizeinbytes': 2})
1125         self.__field_slot.readfrombuffer(buf)
1126         self.__field_entry=nameentry()
1127         self.__field_entry.readfrombuffer(buf)
1128         self.__field_pad=UNKNOWN()
1129         self.__field_pad.readfrombuffer(buf)
1130         self._bufferendoffset=buf.getcurrentoffset()
1131 
1132 
1133     def __getfield_header(self):
1134         return self.__field_header.getvalue()
1135 
1136     def __setfield_header(self, value):
1137         if isinstance(value,nameheader):
1138             self.__field_header=value
1139         else:
1140             self.__field_header=nameheader(value,)
1141 
1142     def __delfield_header(self): del self.__field_header
1143 
1144     header=property(__getfield_header, __setfield_header, __delfield_header, None)
1145 
1146     def __getfield_slot(self):
1147         return self.__field_slot.getvalue()
1148 
1149     def __setfield_slot(self, value):
1150         if isinstance(value,UINT):
1151             self.__field_slot=value
1152         else:
1153             self.__field_slot=UINT(value,**{'sizeinbytes': 2})
1154 
1155     def __delfield_slot(self): del self.__field_slot
1156 
1157     slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None)
1158 
1159     def __getfield_entry(self):
1160         return self.__field_entry.getvalue()
1161 
1162     def __setfield_entry(self, value):
1163         if isinstance(value,nameentry):
1164             self.__field_entry=value
1165         else:
1166             self.__field_entry=nameentry(value,)
1167 
1168     def __delfield_entry(self): del self.__field_entry
1169 
1170     entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None)
1171 
1172     def __getfield_pad(self):
1173         return self.__field_pad.getvalue()
1174 
1175     def __setfield_pad(self, value):
1176         if isinstance(value,UNKNOWN):
1177             self.__field_pad=value
1178         else:
1179             self.__field_pad=UNKNOWN(value,)
1180 
1181     def __delfield_pad(self): del self.__field_pad
1182 
1183     pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None)
1184 
1185     def iscontainer(self):
1186         return True
1187 
1188     def containerelements(self):
1189         yield ('header', self.__field_header, None)
1190         yield ('slot', self.__field_slot, None)
1191         yield ('entry', self.__field_entry, None)
1192         yield ('pad', self.__field_pad, None)
1193 
1194 
1195 
1196 
1197 class nameentry(BaseProtogenClass):
1198     __fields=['bitmask', 'p2', 'numberps', 'emailp', 'urlp', 'p3', 'name_len', 'pad1', 'name', 'pad2', 'nickname', 'pad3', 'memo']
1199 
1200     def __init__(self, *args, **kwargs):
1201         dict={}
1202         # What was supplied to this function
1203         dict.update(kwargs)
1204         # Parent constructor
1205         super(nameentry,self).__init__(**dict)
1206         if self.__class__ is nameentry:
1207             self._update(args,dict)
1208 
1209 
1210     def getfields(self):
1211         return self.__fields
1212 
1213 
1214     def _update(self, args, kwargs):
1215         super(nameentry,self)._update(args,kwargs)
1216         keys=kwargs.keys()
1217         for key in keys:
1218             if key in self.__fields:
1219                 setattr(self, key, kwargs[key])
1220                 del kwargs[key]
1221         # Were any unrecognized kwargs passed in?
1222         if __debug__:
1223             self._complainaboutunusedargs(nameentry,kwargs)
1224         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
1225         # Make all P fields that haven't already been constructed
1226 
1227 
1228     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1229         'Writes this packet to the supplied buffer'
1230         self._bufferstartoffset=buf.getcurrentoffset()
1231         self.__field_bitmask.writetobuffer(buf)
1232         try: self.__field_p2
1233         except:
1234             self.__field_p2=UNKNOWN(**{'sizeinbytes': 2})
1235         self.__field_p2.writetobuffer(buf)
1236         try: self.__field_numberps
1237         except:
1238             self.__field_numberps=LIST(**{'elementclass': _gen_p_samsungspha900_96, 'length': NUMPHONENUMBERS})
1239         self.__field_numberps.writetobuffer(buf)
1240         try: self.__field_emailp
1241         except:
1242             self.__field_emailp=UINT(**{'sizeinbytes': 2, 'default': 0})
1243         self.__field_emailp.writetobuffer(buf)
1244         try: self.__field_urlp
1245         except:
1246             self.__field_urlp=UINT(**{'sizeinbytes': 2, 'default': 0})
1247         self.__field_urlp.writetobuffer(buf)
1248         try: self.__field_p3
1249         except:
1250             self.__field_p3=UNKNOWN(**{'sizeinbytes': 2})
1251         self.__field_p3.writetobuffer(buf)
1252         self.__field_name_len.writetobuffer(buf)
1253         try: self.__field_pad1
1254         except:
1255             self.__field_pad1=UNKNOWN(**{'sizeinbytes': 2})
1256         self.__field_pad1.writetobuffer(buf)
1257         self.__field_name.writetobuffer(buf)
1258         try: self.__field_pad2
1259         except:
1260             self.__field_pad2=UNKNOWN(**{'sizeinbytes': 1})
1261         self.__field_pad2.writetobuffer(buf)
1262         try: self.__field_nickname
1263         except:
1264             self.__field_nickname=USTRING(**{'sizeinbytes': 20, 'raiseonunterminatedread': False, 'default': ""})
1265         self.__field_nickname.writetobuffer(buf)
1266         try: self.__field_pad3
1267         except:
1268             self.__field_pad3=UNKNOWN(**{'sizeinbytes': 1})
1269         self.__field_pad3.writetobuffer(buf)
1270         try: self.__field_memo
1271         except:
1272             self.__field_memo=USTRING(**{'sizeinbytes': 72, 'raiseonunterminatedread': False, 'default': "", 'raiseontruncate': False})
1273         self.__field_memo.writetobuffer(buf)
1274         self._bufferendoffset=buf.getcurrentoffset()
1275         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1276 
1277 
1278     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1279         'Reads this packet from the supplied buffer'
1280         self._bufferstartoffset=buf.getcurrentoffset()
1281         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1282         self.__field_bitmask=UINT(**{'sizeinbytes': 2})
1283         self.__field_bitmask.readfrombuffer(buf)
1284         self.__field_p2=UNKNOWN(**{'sizeinbytes': 2})
1285         self.__field_p2.readfrombuffer(buf)
1286         self.__field_numberps=LIST(**{'elementclass': _gen_p_samsungspha900_96, 'length': NUMPHONENUMBERS})
1287         self.__field_numberps.readfrombuffer(buf)
1288         self.__field_emailp=UINT(**{'sizeinbytes': 2, 'default': 0})
1289         self.__field_emailp.readfrombuffer(buf)
1290         self.__field_urlp=UINT(**{'sizeinbytes': 2, 'default': 0})
1291         self.__field_urlp.readfrombuffer(buf)
1292         self.__field_p3=UNKNOWN(**{'sizeinbytes': 2})
1293         self.__field_p3.readfrombuffer(buf)
1294         self.__field_name_len=UINT(**{'sizeinbytes': 1})
1295         self.__field_name_len.readfrombuffer(buf)
1296         self.__field_pad1=UNKNOWN(**{'sizeinbytes': 2})
1297         self.__field_pad1.readfrombuffer(buf)
1298         self.__field_name=USTRING(**{'sizeinbytes': 20, 'raiseonunterminatedread': False, 'raiseontruncate': False})
1299         self.__field_name.readfrombuffer(buf)
1300         self.__field_pad2=UNKNOWN(**{'sizeinbytes': 1})
1301         self.__field_pad2.readfrombuffer(buf)
1302         self.__field_nickname=USTRING(**{'sizeinbytes': 20, 'raiseonunterminatedread': False, 'default': ""})
1303         self.__field_nickname.readfrombuffer(buf)
1304         self.__field_pad3=UNKNOWN(**{'sizeinbytes': 1})
1305         self.__field_pad3.readfrombuffer(buf)
1306         self.__field_memo=USTRING(**{'sizeinbytes': 72, 'raiseonunterminatedread': False, 'default': "", 'raiseontruncate': False})
1307         self.__field_memo.readfrombuffer(buf)
1308         self._bufferendoffset=buf.getcurrentoffset()
1309 
1310 
1311     def __getfield_bitmask(self):
1312         return self.__field_bitmask.getvalue()
1313 
1314     def __setfield_bitmask(self, value):
1315         if isinstance(value,UINT):
1316             self.__field_bitmask=value
1317         else:
1318             self.__field_bitmask=UINT(value,**{'sizeinbytes': 2})
1319 
1320     def __delfield_bitmask(self): del self.__field_bitmask
1321 
1322     bitmask=property(__getfield_bitmask, __setfield_bitmask, __delfield_bitmask, None)
1323 
1324     def __getfield_p2(self):
1325         try: self.__field_p2
1326         except:
1327             self.__field_p2=UNKNOWN(**{'sizeinbytes': 2})
1328         return self.__field_p2.getvalue()
1329 
1330     def __setfield_p2(self, value):
1331         if isinstance(value,UNKNOWN):
1332             self.__field_p2=value
1333         else:
1334             self.__field_p2=UNKNOWN(value,**{'sizeinbytes': 2})
1335 
1336     def __delfield_p2(self): del self.__field_p2
1337 
1338     p2=property(__getfield_p2, __setfield_p2, __delfield_p2, None)
1339 
1340     def __getfield_numberps(self):
1341         try: self.__field_numberps
1342         except:
1343             self.__field_numberps=LIST(**{'elementclass': _gen_p_samsungspha900_96, 'length': NUMPHONENUMBERS})
1344         return self.__field_numberps.getvalue()
1345 
1346     def __setfield_numberps(self, value):
1347         if isinstance(value,LIST):
1348             self.__field_numberps=value
1349         else:
1350             self.__field_numberps=LIST(value,**{'elementclass': _gen_p_samsungspha900_96, 'length': NUMPHONENUMBERS})
1351 
1352     def __delfield_numberps(self): del self.__field_numberps
1353 
1354     numberps=property(__getfield_numberps, __setfield_numberps, __delfield_numberps, None)
1355 
1356     def __getfield_emailp(self):
1357         try: self.__field_emailp
1358         except:
1359             self.__field_emailp=UINT(**{'sizeinbytes': 2, 'default': 0})
1360         return self.__field_emailp.getvalue()
1361 
1362     def __setfield_emailp(self, value):
1363         if isinstance(value,UINT):
1364             self.__field_emailp=value
1365         else:
1366             self.__field_emailp=UINT(value,**{'sizeinbytes': 2, 'default': 0})
1367 
1368     def __delfield_emailp(self): del self.__field_emailp
1369 
1370     emailp=property(__getfield_emailp, __setfield_emailp, __delfield_emailp, None)
1371 
1372     def __getfield_urlp(self):
1373         try: self.__field_urlp
1374         except:
1375             self.__field_urlp=UINT(**{'sizeinbytes': 2, 'default': 0})
1376         return self.__field_urlp.getvalue()
1377 
1378     def __setfield_urlp(self, value):
1379         if isinstance(value,UINT):
1380             self.__field_urlp=value
1381         else:
1382             self.__field_urlp=UINT(value,**{'sizeinbytes': 2, 'default': 0})
1383 
1384     def __delfield_urlp(self): del self.__field_urlp
1385 
1386     urlp=property(__getfield_urlp, __setfield_urlp, __delfield_urlp, None)
1387 
1388     def __getfield_p3(self):
1389         try: self.__field_p3
1390         except:
1391             self.__field_p3=UNKNOWN(**{'sizeinbytes': 2})
1392         return self.__field_p3.getvalue()
1393 
1394     def __setfield_p3(self, value):
1395         if isinstance(value,UNKNOWN):
1396             self.__field_p3=value
1397         else:
1398             self.__field_p3=UNKNOWN(value,**{'sizeinbytes': 2})
1399 
1400     def __delfield_p3(self): del self.__field_p3
1401 
1402     p3=property(__getfield_p3, __setfield_p3, __delfield_p3, None)
1403 
1404     def __getfield_name_len(self):
1405         return self.__field_name_len.getvalue()
1406 
1407     def __setfield_name_len(self, value):
1408         if isinstance(value,UINT):
1409             self.__field_name_len=value
1410         else:
1411             self.__field_name_len=UINT(value,**{'sizeinbytes': 1})
1412 
1413     def __delfield_name_len(self): del self.__field_name_len
1414 
1415     name_len=property(__getfield_name_len, __setfield_name_len, __delfield_name_len, None)
1416 
1417     def __getfield_pad1(self):
1418         try: self.__field_pad1
1419         except:
1420             self.__field_pad1=UNKNOWN(**{'sizeinbytes': 2})
1421         return self.__field_pad1.getvalue()
1422 
1423     def __setfield_pad1(self, value):
1424         if isinstance(value,UNKNOWN):
1425             self.__field_pad1=value
1426         else:
1427             self.__field_pad1=UNKNOWN(value,**{'sizeinbytes': 2})
1428 
1429     def __delfield_pad1(self): del self.__field_pad1
1430 
1431     pad1=property(__getfield_pad1, __setfield_pad1, __delfield_pad1, None)
1432 
1433     def __getfield_name(self):
1434         return self.__field_name.getvalue()
1435 
1436     def __setfield_name(self, value):
1437         if isinstance(value,USTRING):
1438             self.__field_name=value
1439         else:
1440             self.__field_name=USTRING(value,**{'sizeinbytes': 20, 'raiseonunterminatedread': False, 'raiseontruncate': False})
1441 
1442     def __delfield_name(self): del self.__field_name
1443 
1444     name=property(__getfield_name, __setfield_name, __delfield_name, None)
1445 
1446     def __getfield_pad2(self):
1447         try: self.__field_pad2
1448         except:
1449             self.__field_pad2=UNKNOWN(**{'sizeinbytes': 1})
1450         return self.__field_pad2.getvalue()
1451 
1452     def __setfield_pad2(self, value):
1453         if isinstance(value,UNKNOWN):
1454             self.__field_pad2=value
1455         else:
1456             self.__field_pad2=UNKNOWN(value,**{'sizeinbytes': 1})
1457 
1458     def __delfield_pad2(self): del self.__field_pad2
1459 
1460     pad2=property(__getfield_pad2, __setfield_pad2, __delfield_pad2, None)
1461 
1462     def __getfield_nickname(self):
1463         try: self.__field_nickname
1464         except:
1465             self.__field_nickname=USTRING(**{'sizeinbytes': 20, 'raiseonunterminatedread': False, 'default': ""})
1466         return self.__field_nickname.getvalue()
1467 
1468     def __setfield_nickname(self, value):
1469         if isinstance(value,USTRING):
1470             self.__field_nickname=value
1471         else:
1472             self.__field_nickname=USTRING(value,**{'sizeinbytes': 20, 'raiseonunterminatedread': False, 'default': ""})
1473 
1474     def __delfield_nickname(self): del self.__field_nickname
1475 
1476     nickname=property(__getfield_nickname, __setfield_nickname, __delfield_nickname, None)
1477 
1478     def __getfield_pad3(self):
1479         try: self.__field_pad3
1480         except:
1481             self.__field_pad3=UNKNOWN(**{'sizeinbytes': 1})
1482         return self.__field_pad3.getvalue()
1483 
1484     def __setfield_pad3(self, value):
1485         if isinstance(value,UNKNOWN):
1486             self.__field_pad3=value
1487         else:
1488             self.__field_pad3=UNKNOWN(value,**{'sizeinbytes': 1})
1489 
1490     def __delfield_pad3(self): del self.__field_pad3
1491 
1492     pad3=property(__getfield_pad3, __setfield_pad3, __delfield_pad3, None)
1493 
1494     def __getfield_memo(self):
1495         try: self.__field_memo
1496         except:
1497             self.__field_memo=USTRING(**{'sizeinbytes': 72, 'raiseonunterminatedread': False, 'default': "", 'raiseontruncate': False})
1498         return self.__field_memo.getvalue()
1499 
1500     def __setfield_memo(self, value):
1501         if isinstance(value,USTRING):
1502             self.__field_memo=value
1503         else:
1504             self.__field_memo=USTRING(value,**{'sizeinbytes': 72, 'raiseonunterminatedread': False, 'default': "", 'raiseontruncate': False})
1505 
1506     def __delfield_memo(self): del self.__field_memo
1507 
1508     memo=property(__getfield_memo, __setfield_memo, __delfield_memo, None)
1509 
1510     def iscontainer(self):
1511         return True
1512 
1513     def containerelements(self):
1514         yield ('bitmask', self.__field_bitmask, None)
1515         yield ('p2', self.__field_p2, None)
1516         yield ('numberps', self.__field_numberps, None)
1517         yield ('emailp', self.__field_emailp, None)
1518         yield ('urlp', self.__field_urlp, None)
1519         yield ('p3', self.__field_p3, None)
1520         yield ('name_len', self.__field_name_len, None)
1521         yield ('pad1', self.__field_pad1, None)
1522         yield ('name', self.__field_name, None)
1523         yield ('pad2', self.__field_pad2, None)
1524         yield ('nickname', self.__field_nickname, None)
1525         yield ('pad3', self.__field_pad3, None)
1526         yield ('memo', self.__field_memo, None)
1527 
1528 
1529 
1530 
1531 class _gen_p_samsungspha900_96(BaseProtogenClass):
1532     'Anonymous inner class'
1533     __fields=['slot']
1534 
1535     def __init__(self, *args, **kwargs):
1536         dict={}
1537         # What was supplied to this function
1538         dict.update(kwargs)
1539         # Parent constructor
1540         super(_gen_p_samsungspha900_96,self).__init__(**dict)
1541         if self.__class__ is _gen_p_samsungspha900_96:
1542             self._update(args,dict)
1543 
1544 
1545     def getfields(self):
1546         return self.__fields
1547 
1548 
1549     def _update(self, args, kwargs):
1550         super(_gen_p_samsungspha900_96,self)._update(args,kwargs)
1551         keys=kwargs.keys()
1552         for key in keys:
1553             if key in self.__fields:
1554                 setattr(self, key, kwargs[key])
1555                 del kwargs[key]
1556         # Were any unrecognized kwargs passed in?
1557         if __debug__:
1558             self._complainaboutunusedargs(_gen_p_samsungspha900_96,kwargs)
1559         if len(args):
1560             dict2={'sizeinbytes': 2, 'default': 0}
1561             dict2.update(kwargs)
1562             kwargs=dict2
1563             self.__field_slot=UINT(*args,**dict2)
1564         # Make all P fields that haven't already been constructed
1565 
1566 
1567     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1568         'Writes this packet to the supplied buffer'
1569         self._bufferstartoffset=buf.getcurrentoffset()
1570         self.__field_slot.writetobuffer(buf)
1571         self._bufferendoffset=buf.getcurrentoffset()
1572         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1573 
1574 
1575     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1576         'Reads this packet from the supplied buffer'
1577         self._bufferstartoffset=buf.getcurrentoffset()
1578         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1579         self.__field_slot=UINT(**{'sizeinbytes': 2, 'default': 0})
1580         self.__field_slot.readfrombuffer(buf)
1581         self._bufferendoffset=buf.getcurrentoffset()
1582 
1583 
1584     def __getfield_slot(self):
1585         return self.__field_slot.getvalue()
1586 
1587     def __setfield_slot(self, value):
1588         if isinstance(value,UINT):
1589             self.__field_slot=value
1590         else:
1591             self.__field_slot=UINT(value,**{'sizeinbytes': 2, 'default': 0})
1592 
1593     def __delfield_slot(self): del self.__field_slot
1594 
1595     slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None)
1596 
1597     def iscontainer(self):
1598         return True
1599 
1600     def containerelements(self):
1601         yield ('slot', self.__field_slot, None)
1602 
1603 
1604 
1605 
1606 class nameupdaterequest(BaseProtogenClass):
1607     __fields=['header', 'slot', 'entry', 'pad']
1608 
1609     def __init__(self, *args, **kwargs):
1610         dict={}
1611         # What was supplied to this function
1612         dict.update(kwargs)
1613         # Parent constructor
1614         super(nameupdaterequest,self).__init__(**dict)
1615         if self.__class__ is nameupdaterequest:
1616             self._update(args,dict)
1617 
1618 
1619     def getfields(self):
1620         return self.__fields
1621 
1622 
1623     def _update(self, args, kwargs):
1624         super(nameupdaterequest,self)._update(args,kwargs)
1625         keys=kwargs.keys()
1626         for key in keys:
1627             if key in self.__fields:
1628                 setattr(self, key, kwargs[key])
1629                 del kwargs[key]
1630         # Were any unrecognized kwargs passed in?
1631         if __debug__:
1632             self._complainaboutunusedargs(nameupdaterequest,kwargs)
1633         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
1634         # Make all P fields that haven't already been constructed
1635 
1636 
1637     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1638         'Writes this packet to the supplied buffer'
1639         self._bufferstartoffset=buf.getcurrentoffset()
1640         try: self.__field_header
1641         except:
1642             self.__field_header=nameheader(**{'head1': 0xd4})
1643         self.__field_header.writetobuffer(buf)
1644         self.__field_slot.writetobuffer(buf)
1645         try: self.__field_entry
1646         except:
1647             self.__field_entry=nameentry()
1648         self.__field_entry.writetobuffer(buf)
1649         try: self.__field_pad
1650         except:
1651             self.__field_pad=UNKNOWN(**{'sizeinbytes': 3})
1652         self.__field_pad.writetobuffer(buf)
1653         self._bufferendoffset=buf.getcurrentoffset()
1654         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1655 
1656 
1657     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1658         'Reads this packet from the supplied buffer'
1659         self._bufferstartoffset=buf.getcurrentoffset()
1660         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1661         self.__field_header=nameheader(**{'head1': 0xd4})
1662         self.__field_header.readfrombuffer(buf)
1663         self.__field_slot=UINT(**{'sizeinbytes': 2})
1664         self.__field_slot.readfrombuffer(buf)
1665         self.__field_entry=nameentry()
1666         self.__field_entry.readfrombuffer(buf)
1667         self.__field_pad=UNKNOWN(**{'sizeinbytes': 3})
1668         self.__field_pad.readfrombuffer(buf)
1669         self._bufferendoffset=buf.getcurrentoffset()
1670 
1671 
1672     def __getfield_header(self):
1673         try: self.__field_header
1674         except:
1675             self.__field_header=nameheader(**{'head1': 0xd4})
1676         return self.__field_header.getvalue()
1677 
1678     def __setfield_header(self, value):
1679         if isinstance(value,nameheader):
1680             self.__field_header=value
1681         else:
1682             self.__field_header=nameheader(value,**{'head1': 0xd4})
1683 
1684     def __delfield_header(self): del self.__field_header
1685 
1686     header=property(__getfield_header, __setfield_header, __delfield_header, None)
1687 
1688     def __getfield_slot(self):
1689         return self.__field_slot.getvalue()
1690 
1691     def __setfield_slot(self, value):
1692         if isinstance(value,UINT):
1693             self.__field_slot=value
1694         else:
1695             self.__field_slot=UINT(value,**{'sizeinbytes': 2})
1696 
1697     def __delfield_slot(self): del self.__field_slot
1698 
1699     slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None)
1700 
1701     def __getfield_entry(self):
1702         try: self.__field_entry
1703         except:
1704             self.__field_entry=nameentry()
1705         return self.__field_entry.getvalue()
1706 
1707     def __setfield_entry(self, value):
1708         if isinstance(value,nameentry):
1709             self.__field_entry=value
1710         else:
1711             self.__field_entry=nameentry(value,)
1712 
1713     def __delfield_entry(self): del self.__field_entry
1714 
1715     entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None)
1716 
1717     def __getfield_pad(self):
1718         try: self.__field_pad
1719         except:
1720             self.__field_pad=UNKNOWN(**{'sizeinbytes': 3})
1721         return self.__field_pad.getvalue()
1722 
1723     def __setfield_pad(self, value):
1724         if isinstance(value,UNKNOWN):
1725             self.__field_pad=value
1726         else:
1727             self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 3})
1728 
1729     def __delfield_pad(self): del self.__field_pad
1730 
1731     pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None)
1732 
1733     def iscontainer(self):
1734         return True
1735 
1736     def containerelements(self):
1737         yield ('header', self.__field_header, None)
1738         yield ('slot', self.__field_slot, None)
1739         yield ('entry', self.__field_entry, None)
1740         yield ('pad', self.__field_pad, None)
1741 
1742 
1743 
1744 
1745 class beginendupdaterequest(BaseProtogenClass):
1746     __fields=['command', 'beginend']
1747 
1748     def __init__(self, *args, **kwargs):
1749         dict={}
1750         # What was supplied to this function
1751         dict.update(kwargs)
1752         # Parent constructor
1753         super(beginendupdaterequest,self).__init__(**dict)
1754         if self.__class__ is beginendupdaterequest:
1755             self._update(args,dict)
1756 
1757 
1758     def getfields(self):
1759         return self.__fields
1760 
1761 
1762     def _update(self, args, kwargs):
1763         super(beginendupdaterequest,self)._update(args,kwargs)
1764         keys=kwargs.keys()
1765         for key in keys:
1766             if key in self.__fields:
1767                 setattr(self, key, kwargs[key])
1768                 del kwargs[key]
1769         # Were any unrecognized kwargs passed in?
1770         if __debug__:
1771             self._complainaboutunusedargs(beginendupdaterequest,kwargs)
1772         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
1773         # Make all P fields that haven't already been constructed
1774 
1775 
1776     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1777         'Writes this packet to the supplied buffer'
1778         self._bufferstartoffset=buf.getcurrentoffset()
1779         try: self.__field_command
1780         except:
1781             self.__field_command=UINT(**{'sizeinbytes': 1, 'constant': 0x29})
1782         self.__field_command.writetobuffer(buf)
1783         self.__field_beginend.writetobuffer(buf)
1784         self._bufferendoffset=buf.getcurrentoffset()
1785         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1786 
1787 
1788     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1789         'Reads this packet from the supplied buffer'
1790         self._bufferstartoffset=buf.getcurrentoffset()
1791         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1792         self.__field_command=UINT(**{'sizeinbytes': 1, 'constant': 0x29})
1793         self.__field_command.readfrombuffer(buf)
1794         self.__field_beginend=UINT(**{'sizeinbytes': 2})
1795         self.__field_beginend.readfrombuffer(buf)
1796         self._bufferendoffset=buf.getcurrentoffset()
1797 
1798 
1799     def __getfield_command(self):
1800         try: self.__field_command
1801         except:
1802             self.__field_command=UINT(**{'sizeinbytes': 1, 'constant': 0x29})
1803         return self.__field_command.getvalue()
1804 
1805     def __setfield_command(self, value):
1806         if isinstance(value,UINT):
1807             self.__field_command=value
1808         else:
1809             self.__field_command=UINT(value,**{'sizeinbytes': 1, 'constant': 0x29})
1810 
1811     def __delfield_command(self): del self.__field_command
1812 
1813     command=property(__getfield_command, __setfield_command, __delfield_command, None)
1814 
1815     def __getfield_beginend(self):
1816         return self.__field_beginend.getvalue()
1817 
1818     def __setfield_beginend(self, value):
1819         if isinstance(value,UINT):
1820             self.__field_beginend=value
1821         else:
1822             self.__field_beginend=UINT(value,**{'sizeinbytes': 2})
1823 
1824     def __delfield_beginend(self): del self.__field_beginend
1825 
1826     beginend=property(__getfield_beginend, __setfield_beginend, __delfield_beginend, None)
1827 
1828     def iscontainer(self):
1829         return True
1830 
1831     def containerelements(self):
1832         yield ('command', self.__field_command, None)
1833         yield ('beginend', self.__field_beginend, None)
1834 
1835 
1836 
1837 
1838 class beginendupdateresponse(BaseProtogenClass):
1839     __fields=['command', 'beginend']
1840 
1841     def __init__(self, *args, **kwargs):
1842         dict={}
1843         # What was supplied to this function
1844         dict.update(kwargs)
1845         # Parent constructor
1846         super(beginendupdateresponse,self).__init__(**dict)
1847         if self.__class__ is beginendupdateresponse:
1848             self._update(args,dict)
1849 
1850 
1851     def getfields(self):
1852         return self.__fields
1853 
1854 
1855     def _update(self, args, kwargs):
1856         super(beginendupdateresponse,self)._update(args,kwargs)
1857         keys=kwargs.keys()
1858         for key in keys:
1859             if key in self.__fields:
1860                 setattr(self, key, kwargs[key])
1861                 del kwargs[key]
1862         # Were any unrecognized kwargs passed in?
1863         if __debug__:
1864             self._complainaboutunusedargs(beginendupdateresponse,kwargs)
1865         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
1866         # Make all P fields that haven't already been constructed
1867 
1868 
1869     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1870         'Writes this packet to the supplied buffer'
1871         self._bufferstartoffset=buf.getcurrentoffset()
1872         self.__field_command.writetobuffer(buf)
1873         self.__field_beginend.writetobuffer(buf)
1874         self._bufferendoffset=buf.getcurrentoffset()
1875         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1876 
1877 
1878     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1879         'Reads this packet from the supplied buffer'
1880         self._bufferstartoffset=buf.getcurrentoffset()
1881         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1882         self.__field_command=UINT(**{'sizeinbytes': 1})
1883         self.__field_command.readfrombuffer(buf)
1884         self.__field_beginend=UINT(**{'sizeinbytes': 2})
1885         self.__field_beginend.readfrombuffer(buf)
1886         self._bufferendoffset=buf.getcurrentoffset()
1887 
1888 
1889     def __getfield_command(self):
1890         return self.__field_command.getvalue()
1891 
1892     def __setfield_command(self, value):
1893         if isinstance(value,UINT):
1894             self.__field_command=value
1895         else:
1896             self.__field_command=UINT(value,**{'sizeinbytes': 1})
1897 
1898     def __delfield_command(self): del self.__field_command
1899 
1900     command=property(__getfield_command, __setfield_command, __delfield_command, None)
1901 
1902     def __getfield_beginend(self):
1903         return self.__field_beginend.getvalue()
1904 
1905     def __setfield_beginend(self, value):
1906         if isinstance(value,UINT):
1907             self.__field_beginend=value
1908         else:
1909             self.__field_beginend=UINT(value,**{'sizeinbytes': 2})
1910 
1911     def __delfield_beginend(self): del self.__field_beginend
1912 
1913     beginend=property(__getfield_beginend, __setfield_beginend, __delfield_beginend, None)
1914 
1915     def iscontainer(self):
1916         return True
1917 
1918     def containerelements(self):
1919         yield ('command', self.__field_command, None)
1920         yield ('beginend', self.__field_beginend, None)
1921 
1922 
1923 
1924 
1925 class statusrequest(BaseProtogenClass):
1926     __fields=['command']
1927 
1928     def __init__(self, *args, **kwargs):
1929         dict={}
1930         # What was supplied to this function
1931         dict.update(kwargs)
1932         # Parent constructor
1933         super(statusrequest,self).__init__(**dict)
1934         if self.__class__ is statusrequest:
1935             self._update(args,dict)
1936 
1937 
1938     def getfields(self):
1939         return self.__fields
1940 
1941 
1942     def _update(self, args, kwargs):
1943         super(statusrequest,self)._update(args,kwargs)
1944         keys=kwargs.keys()
1945         for key in keys:
1946             if key in self.__fields:
1947                 setattr(self, key, kwargs[key])
1948                 del kwargs[key]
1949         # Were any unrecognized kwargs passed in?
1950         if __debug__:
1951             self._complainaboutunusedargs(statusrequest,kwargs)
1952         if len(args):
1953             dict2={'sizeinbytes': 1, 'constant': 0x0c}
1954             dict2.update(kwargs)
1955             kwargs=dict2
1956             self.__field_command=UINT(*args,**dict2)
1957         # Make all P fields that haven't already been constructed
1958 
1959 
1960     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1961         'Writes this packet to the supplied buffer'
1962         self._bufferstartoffset=buf.getcurrentoffset()
1963         try: self.__field_command
1964         except:
1965             self.__field_command=UINT(**{'sizeinbytes': 1, 'constant': 0x0c})
1966         self.__field_command.writetobuffer(buf)
1967         self._bufferendoffset=buf.getcurrentoffset()
1968         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1969 
1970 
1971     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1972         'Reads this packet from the supplied buffer'
1973         self._bufferstartoffset=buf.getcurrentoffset()
1974         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1975         self.__field_command=UINT(**{'sizeinbytes': 1, 'constant': 0x0c})
1976         self.__field_command.readfrombuffer(buf)
1977         self._bufferendoffset=buf.getcurrentoffset()
1978 
1979 
1980     def __getfield_command(self):
1981         try: self.__field_command
1982         except:
1983             self.__field_command=UINT(**{'sizeinbytes': 1, 'constant': 0x0c})
1984         return self.__field_command.getvalue()
1985 
1986     def __setfield_command(self, value):
1987         if isinstance(value,UINT):
1988             self.__field_command=value
1989         else:
1990             self.__field_command=UINT(value,**{'sizeinbytes': 1, 'constant': 0x0c})
1991 
1992     def __delfield_command(self): del self.__field_command
1993 
1994     command=property(__getfield_command, __setfield_command, __delfield_command, None)
1995 
1996     def iscontainer(self):
1997         return True
1998 
1999     def containerelements(self):
2000         yield ('command', self.__field_command, None)
2001 
2002 
2003 
2004 
2005 class statusresponse(BaseProtogenClass):
2006     __fields=['readyvalue', 'command', 'dunno1', 'esn', 'flag0', 'dunno2', 'ready', 'dunno3', 'flag2', 'dunno4', 'flag3', 'unknown']
2007 
2008     def __init__(self, *args, **kwargs):
2009         dict={}
2010         # What was supplied to this function
2011         dict.update(kwargs)
2012         # Parent constructor
2013         super(statusresponse,self).__init__(**dict)
2014         if self.__class__ is statusresponse:
2015             self._update(args,dict)
2016 
2017 
2018     def getfields(self):
2019         return self.__fields
2020 
2021 
2022     def _update(self, args, kwargs):
2023         super(statusresponse,self)._update(args,kwargs)
2024         keys=kwargs.keys()
2025         for key in keys:
2026             if key in self.__fields:
2027                 setattr(self, key, kwargs[key])
2028                 del kwargs[key]
2029         # Were any unrecognized kwargs passed in?
2030         if __debug__:
2031             self._complainaboutunusedargs(statusresponse,kwargs)
2032         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
2033         # Make all P fields that haven't already been constructed
2034         try: self.__field_readyvalue
2035         except:
2036             self.__field_readyvalue=UINT(**{'constant': 0x0})
2037 
2038 
2039     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
2040         'Writes this packet to the supplied buffer'
2041         self._bufferstartoffset=buf.getcurrentoffset()
2042         self.__field_command.writetobuffer(buf)
2043         self.__field_dunno1.writetobuffer(buf)
2044         self.__field_esn.writetobuffer(buf)
2045         self.__field_flag0.writetobuffer(buf)
2046         self.__field_dunno2.writetobuffer(buf)
2047         self.__field_ready.writetobuffer(buf)
2048         self.__field_dunno3.writetobuffer(buf)
2049         self.__field_flag2.writetobuffer(buf)
2050         self.__field_dunno4.writetobuffer(buf)
2051         self.__field_flag3.writetobuffer(buf)
2052         self.__field_unknown.writetobuffer(buf)
2053         self._bufferendoffset=buf.getcurrentoffset()
2054         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
2055 
2056 
2057     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
2058         'Reads this packet from the supplied buffer'
2059         self._bufferstartoffset=buf.getcurrentoffset()
2060         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
2061         self.__field_command=UINT(**{'sizeinbytes': 1})
2062         self.__field_command.readfrombuffer(buf)
2063         self.__field_dunno1=UNKNOWN(**{'sizeinbytes': 3})
2064         self.__field_dunno1.readfrombuffer(buf)
2065         self.__field_esn=UINT(**{'sizeinbytes': 4})
2066         self.__field_esn.readfrombuffer(buf)
2067         self.__field_flag0=UINT(**{'sizeinbytes': 1})
2068         self.__field_flag0.readfrombuffer(buf)
2069         self.__field_dunno2=UNKNOWN(**{'sizeinbytes': 14})
2070         self.__field_dunno2.readfrombuffer(buf)
2071         self.__field_ready=UINT(**{'sizeinbytes': 1})
2072         self.__field_ready.readfrombuffer(buf)
2073         self.__field_dunno3=UINT(**{'sizeinbytes': 1})
2074         self.__field_dunno3.readfrombuffer(buf)
2075         self.__field_flag2=UINT(**{'sizeinbytes': 1})
2076         self.__field_flag2.readfrombuffer(buf)
2077         self.__field_dunno4=UNKNOWN(**{'sizeinbytes': 6})
2078         self.__field_dunno4.readfrombuffer(buf)
2079         self.__field_flag3=UINT(**{'sizeinbytes': 1})
2080         self.__field_flag3.readfrombuffer(buf)
2081         self.__field_unknown=UNKNOWN()
2082         self.__field_unknown.readfrombuffer(buf)
2083         self._bufferendoffset=buf.getcurrentoffset()
2084 
2085 
2086     def __getfield_readyvalue(self):
2087         return self.__field_readyvalue.getvalue()
2088 
2089     def __setfield_readyvalue(self, value):
2090         if isinstance(value,UINT):
2091             self.__field_readyvalue=value
2092         else:
2093             self.__field_readyvalue=UINT(value,**{'constant': 0x0})
2094 
2095     def __delfield_readyvalue(self): del self.__field_readyvalue
2096 
2097     readyvalue=property(__getfield_readyvalue, __setfield_readyvalue, __delfield_readyvalue, None)
2098 
2099     def __getfield_command(self):
2100         return self.__field_command.getvalue()
2101 
2102     def __setfield_command(self, value):
2103         if isinstance(value,UINT):
2104             self.__field_command=value
2105         else:
2106             self.__field_command=UINT(value,**{'sizeinbytes': 1})
2107 
2108     def __delfield_command(self): del self.__field_command
2109 
2110     command=property(__getfield_command, __setfield_command, __delfield_command, None)
2111 
2112     def __getfield_dunno1(self):
2113         return self.__field_dunno1.getvalue()
2114 
2115     def __setfield_dunno1(self, value):
2116         if isinstance(value,UNKNOWN):
2117             self.__field_dunno1=value
2118         else:
2119             self.__field_dunno1=UNKNOWN(value,**{'sizeinbytes': 3})
2120 
2121     def __delfield_dunno1(self): del self.__field_dunno1
2122 
2123     dunno1=property(__getfield_dunno1, __setfield_dunno1, __delfield_dunno1, None)
2124 
2125     def __getfield_esn(self):
2126         return self.__field_esn.getvalue()
2127 
2128     def __setfield_esn(self, value):
2129         if isinstance(value,UINT):
2130             self.__field_esn=value
2131         else:
2132             self.__field_esn=UINT(value,**{'sizeinbytes': 4})
2133 
2134     def __delfield_esn(self): del self.__field_esn
2135 
2136     esn=property(__getfield_esn, __setfield_esn, __delfield_esn, None)
2137 
2138     def __getfield_flag0(self):
2139         return self.__field_flag0.getvalue()
2140 
2141     def __setfield_flag0(self, value):
2142         if isinstance(value,UINT):
2143             self.__field_flag0=value
2144         else:
2145             self.__field_flag0=UINT(value,**{'sizeinbytes': 1})
2146 
2147     def __delfield_flag0(self): del self.__field_flag0
2148 
2149     flag0=property(__getfield_flag0, __setfield_flag0, __delfield_flag0, None)
2150 
2151     def __getfield_dunno2(self):
2152         return self.__field_dunno2.getvalue()
2153 
2154     def __setfield_dunno2(self, value):
2155         if isinstance(value,UNKNOWN):
2156             self.__field_dunno2=value
2157         else:
2158             self.__field_dunno2=UNKNOWN(value,**{'sizeinbytes': 14})
2159 
2160     def __delfield_dunno2(self): del self.__field_dunno2
2161 
2162     dunno2=property(__getfield_dunno2, __setfield_dunno2, __delfield_dunno2, None)
2163 
2164     def __getfield_ready(self):
2165         return self.__field_ready.getvalue()
2166 
2167     def __setfield_ready(self, value):
2168         if isinstance(value,UINT):
2169             self.__field_ready=value
2170         else:
2171             self.__field_ready=UINT(value,**{'sizeinbytes': 1})
2172 
2173     def __delfield_ready(self): del self.__field_ready
2174 
2175     ready=property(__getfield_ready, __setfield_ready, __delfield_ready, None)
2176 
2177     def __getfield_dunno3(self):
2178         return self.__field_dunno3.getvalue()
2179 
2180     def __setfield_dunno3(self, value):
2181         if isinstance(value,UINT):
2182             self.__field_dunno3=value
2183         else:
2184             self.__field_dunno3=UINT(value,**{'sizeinbytes': 1})
2185 
2186     def __delfield_dunno3(self): del self.__field_dunno3
2187 
2188     dunno3=property(__getfield_dunno3, __setfield_dunno3, __delfield_dunno3, None)
2189 
2190     def __getfield_flag2(self):
2191         return self.__field_flag2.getvalue()
2192 
2193     def __setfield_flag2(self, value):
2194         if isinstance(value,UINT):
2195             self.__field_flag2=value
2196         else:
2197             self.__field_flag2=UINT(value,**{'sizeinbytes': 1})
2198 
2199     def __delfield_flag2(self): del self.__field_flag2
2200 
2201     flag2=property(__getfield_flag2, __setfield_flag2, __delfield_flag2, None)
2202 
2203     def __getfield_dunno4(self):
2204         return self.__field_dunno4.getvalue()
2205 
2206     def __setfield_dunno4(self, value):
2207         if isinstance(value,UNKNOWN):
2208             self.__field_dunno4=value
2209         else:
2210             self.__field_dunno4=UNKNOWN(value,**{'sizeinbytes': 6})
2211 
2212     def __delfield_dunno4(self): del self.__field_dunno4
2213 
2214     dunno4=property(__getfield_dunno4, __setfield_dunno4, __delfield_dunno4, None)
2215 
2216     def __getfield_flag3(self):
2217         return self.__field_flag3.getvalue()
2218 
2219     def __setfield_flag3(self, value):
2220         if isinstance(value,UINT):
2221             self.__field_flag3=value
2222         else:
2223             self.__field_flag3=UINT(value,**{'sizeinbytes': 1})
2224 
2225     def __delfield_flag3(self): del self.__field_flag3
2226 
2227     flag3=property(__getfield_flag3, __setfield_flag3, __delfield_flag3, None)
2228 
2229     def __getfield_unknown(self):
2230         return self.__field_unknown.getvalue()
2231 
2232     def __setfield_unknown(self, value):
2233         if isinstance(value,UNKNOWN):
2234             self.__field_unknown=value
2235         else:
2236             self.__field_unknown=UNKNOWN(value,)
2237 
2238     def __delfield_unknown(self): del self.__field_unknown
2239 
2240     unknown=property(__getfield_unknown, __setfield_unknown, __delfield_unknown, None)
2241 
2242     def iscontainer(self):
2243         return True
2244 
2245     def containerelements(self):
2246         yield ('readyvalue', self.__field_readyvalue, None)
2247         yield ('command', self.__field_command, None)
2248         yield ('dunno1', self.__field_dunno1, None)
2249         yield ('esn', self.__field_esn, None)
2250         yield ('flag0', self.__field_flag0, None)
2251         yield ('dunno2', self.__field_dunno2, None)
2252         yield ('ready', self.__field_ready, None)
2253         yield ('dunno3', self.__field_dunno3, None)
2254         yield ('flag2', self.__field_flag2, None)
2255         yield ('dunno4', self.__field_dunno4, None)
2256         yield ('flag3', self.__field_flag3, None)
2257         yield ('unknown', self.__field_unknown, None)
2258 
2259 
2260 
2261 
2262 class writeenable(BaseProtogenClass):
2263     __fields=['c1', 'c2', 'c3', 'c4', 'c5', 'c6', 'c7', 'c8', 'c9', 'c10', 'c11', 'c12', 'c13', 'c14', 'c15', 'c16']
2264 
2265     def __init__(self, *args, **kwargs):
2266         dict={}
2267         # What was supplied to this function
2268         dict.update(kwargs)
2269         # Parent constructor
2270         super(writeenable,self).__init__(**dict)
2271         if self.__class__ is writeenable:
2272             self._update(args,dict)
2273 
2274 
2275     def getfields(self):
2276         return self.__fields
2277 
2278 
2279     def _update(self, args, kwargs):
2280         super(writeenable,self)._update(args,kwargs)
2281         keys=kwargs.keys()
2282         for key in keys:
2283             if key in self.__fields:
2284                 setattr(self, key, kwargs[key])
2285                 del kwargs[key]
2286         # Were any unrecognized kwargs passed in?
2287         if __debug__:
2288             self._complainaboutunusedargs(writeenable,kwargs)
2289         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
2290         # Make all P fields that haven't already been constructed
2291 
2292 
2293     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
2294         'Writes this packet to the supplied buffer'
2295         self._bufferstartoffset=buf.getcurrentoffset()
2296         try: self.__field_c1
2297         except:
2298             self.__field_c1=UINT(**{'sizeinbytes': 1, 'constant': 0x46})
2299         self.__field_c1.writetobuffer(buf)
2300         try: self.__field_c2
2301         except:
2302             self.__field_c2=UINT(**{'sizeinbytes': 1, 'constant': 0x01})
2303         self.__field_c2.writetobuffer(buf)
2304         try: self.__field_c3
2305         except:
2306             self.__field_c3=UINT(**{'sizeinbytes': 1, 'constant': 0xf2})
2307         self.__field_c3.writetobuffer(buf)
2308         try: self.__field_c4
2309         except:
2310             self.__field_c4=UINT(**{'sizeinbytes': 1, 'constant': 0x03})
2311         self.__field_c4.writetobuffer(buf)
2312         try: self.__field_c5
2313         except:
2314             self.__field_c5=UINT(**{'sizeinbytes': 1, 'constant': 0x0f})
2315         self.__field_c5.writetobuffer(buf)
2316         try: self.__field_c6
2317         except:
2318             self.__field_c6=UINT(**{'sizeinbytes': 1, 'constant': 0x5f})
2319         self.__field_c6.writetobuffer(buf)
2320         try: self.__field_c7
2321         except:
2322             self.__field_c7=UINT(**{'sizeinbytes': 1, 'constant': 0x67})
2323         self.__field_c7.writetobuffer(buf)
2324         try: self.__field_c8
2325         except:
2326             self.__field_c8=UINT(**{'sizeinbytes': 1, 'constant': 0x8f})
2327         self.__field_c8.writetobuffer(buf)
2328         try: self.__field_c9
2329         except:
2330             self.__field_c9=UINT(**{'sizeinbytes': 1, 'constant': 0xf9})
2331         self.__field_c9.writetobuffer(buf)
2332         try: self.__field_c10
2333         except:
2334             self.__field_c10=UINT(**{'sizeinbytes': 1, 'constant': 0xa2})
2335         self.__field_c10.writetobuffer(buf)
2336         try: self.__field_c11
2337         except:
2338             self.__field_c11=UINT(**{'sizeinbytes': 1, 'constant': 0x3f})
2339         self.__field_c11.writetobuffer(buf)
2340         try: self.__field_c12
2341         except:
2342             self.__field_c12=UINT(**{'sizeinbytes': 1, 'constant': 0x7d})
2343         self.__field_c12.writetobuffer(buf)
2344         try: self.__field_c13
2345         except:
2346             self.__field_c13=UINT(**{'sizeinbytes': 1, 'constant': 0x5e})
2347         self.__field_c13.writetobuffer(buf)
2348         try: self.__field_c14
2349         except:
2350             self.__field_c14=UINT(**{'sizeinbytes': 1, 'constant': 0x35})
2351         self.__field_c14.writetobuffer(buf)
2352         try: self.__field_c15
2353         except:
2354             self.__field_c15=UINT(**{'sizeinbytes': 1, 'constant': 0x5c})
2355         self.__field_c15.writetobuffer(buf)
2356         try: self.__field_c16
2357         except:
2358             self.__field_c16=UINT(**{'sizeinbytes': 1, 'constant': 0x7e})
2359         self.__field_c16.writetobuffer(buf)
2360         self._bufferendoffset=buf.getcurrentoffset()
2361         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
2362 
2363 
2364     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
2365         'Reads this packet from the supplied buffer'
2366         self._bufferstartoffset=buf.getcurrentoffset()
2367         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
2368         self.__field_c1=UINT(**{'sizeinbytes': 1, 'constant': 0x46})
2369         self.__field_c1.readfrombuffer(buf)
2370         self.__field_c2=UINT(**{'sizeinbytes': 1, 'constant': 0x01})
2371         self.__field_c2.readfrombuffer(buf)
2372         self.__field_c3=UINT(**{'sizeinbytes': 1, 'constant': 0xf2})
2373         self.__field_c3.readfrombuffer(buf)
2374         self.__field_c4=UINT(**{'sizeinbytes': 1, 'constant': 0x03})
2375         self.__field_c4.readfrombuffer(buf)
2376         self.__field_c5=UINT(**{'sizeinbytes': 1, 'constant': 0x0f})
2377         self.__field_c5.readfrombuffer(buf)
2378         self.__field_c6=UINT(**{'sizeinbytes': 1, 'constant': 0x5f})
2379         self.__field_c6.readfrombuffer(buf)
2380         self.__field_c7=UINT(**{'sizeinbytes': 1, 'constant': 0x67})
2381         self.__field_c7.readfrombuffer(buf)
2382         self.__field_c8=UINT(**{'sizeinbytes': 1, 'constant': 0x8f})
2383         self.__field_c8.readfrombuffer(buf)
2384         self.__field_c9=UINT(**{'sizeinbytes': 1, 'constant': 0xf9})
2385         self.__field_c9.readfrombuffer(buf)
2386         self.__field_c10=UINT(**{'sizeinbytes': 1, 'constant': 0xa2})
2387         self.__field_c10.readfrombuffer(buf)
2388         self.__field_c11=UINT(**{'sizeinbytes': 1, 'constant': 0x3f})
2389         self.__field_c11.readfrombuffer(buf)
2390         self.__field_c12=UINT(**{'sizeinbytes': 1, 'constant': 0x7d})
2391         self.__field_c12.readfrombuffer(buf)
2392         self.__field_c13=UINT(**{'sizeinbytes': 1, 'constant': 0x5e})
2393         self.__field_c13.readfrombuffer(buf)
2394         self.__field_c14=UINT(**{'sizeinbytes': 1, 'constant': 0x35})
2395         self.__field_c14.readfrombuffer(buf)
2396         self.__field_c15=UINT(**{'sizeinbytes': 1, 'constant': 0x5c})
2397         self.__field_c15.readfrombuffer(buf)
2398         self.__field_c16=UINT(**{'sizeinbytes': 1, 'constant': 0x7e})
2399         self.__field_c16.readfrombuffer(buf)
2400         self._bufferendoffset=buf.getcurrentoffset()
2401 
2402 
2403     def __getfield_c1(self):
2404         try: self.__field_c1
2405         except:
2406             self.__field_c1=UINT(**{'sizeinbytes': 1, 'constant': 0x46})
2407         return self.__field_c1.getvalue()
2408 
2409     def __setfield_c1(self, value):
2410         if isinstance(value,UINT):
2411             self.__field_c1=value
2412         else:
2413             self.__field_c1=UINT(value,**{'sizeinbytes': 1, 'constant': 0x46})
2414 
2415     def __delfield_c1(self): del self.__field_c1
2416 
2417     c1=property(__getfield_c1, __setfield_c1, __delfield_c1, None)
2418 
2419     def __getfield_c2(self):
2420         try: self.__field_c2
2421         except:
2422             self.__field_c2=UINT(**{'sizeinbytes': 1, 'constant': 0x01})
2423         return self.__field_c2.getvalue()
2424 
2425     def __setfield_c2(self, value):
2426         if isinstance(value,UINT):
2427             self.__field_c2=value
2428         else:
2429             self.__field_c2=UINT(value,**{'sizeinbytes': 1, 'constant': 0x01})
2430 
2431     def __delfield_c2(self): del self.__field_c2
2432 
2433     c2=property(__getfield_c2, __setfield_c2, __delfield_c2, None)
2434 
2435     def __getfield_c3(self):
2436         try: self.__field_c3
2437         except:
2438             self.__field_c3=UINT(**{'sizeinbytes': 1, 'constant': 0xf2})
2439         return self.__field_c3.getvalue()
2440 
2441     def __setfield_c3(self, value):
2442         if isinstance(value,UINT):
2443             self.__field_c3=value
2444         else:
2445             self.__field_c3=UINT(value,**{'sizeinbytes': 1, 'constant': 0xf2})
2446 
2447     def __delfield_c3(self): del self.__field_c3
2448 
2449     c3=property(__getfield_c3, __setfield_c3, __delfield_c3, None)
2450 
2451     def __getfield_c4(self):
2452         try: self.__field_c4
2453         except:
2454             self.__field_c4=UINT(**{'sizeinbytes': 1, 'constant': 0x03})
2455         return self.__field_c4.getvalue()
2456 
2457     def __setfield_c4(self, value):
2458         if isinstance(value,UINT):
2459             self.__field_c4=value
2460         else:
2461             self.__field_c4=UINT(value,**{'sizeinbytes': 1, 'constant': 0x03})
2462 
2463     def __delfield_c4(self): del self.__field_c4
2464 
2465     c4=property(__getfield_c4, __setfield_c4, __delfield_c4, None)
2466 
2467     def __getfield_c5(self):
2468         try: self.__field_c5
2469         except:
2470             self.__field_c5=UINT(**{'sizeinbytes': 1, 'constant': 0x0f})
2471         return self.__field_c5.getvalue()
2472 
2473     def __setfield_c5(self, value):
2474         if isinstance(value,UINT):
2475             self.__field_c5=value
2476         else:
2477             self.__field_c5=UINT(value,**{'sizeinbytes': 1, 'constant': 0x0f})
2478 
2479     def __delfield_c5(self): del self.__field_c5
2480 
2481     c5=property(__getfield_c5, __setfield_c5, __delfield_c5, None)
2482 
2483     def __getfield_c6(self):
2484         try: self.__field_c6
2485         except:
2486             self.__field_c6=UINT(**{'sizeinbytes': 1, 'constant': 0x5f})
2487         return self.__field_c6.getvalue()
2488 
2489     def __setfield_c6(self, value):
2490         if isinstance(value,UINT):
2491             self.__field_c6=value
2492         else:
2493             self.__field_c6=UINT(value,**{'sizeinbytes': 1, 'constant': 0x5f})
2494 
2495     def __delfield_c6(self): del self.__field_c6
2496 
2497     c6=property(__getfield_c6, __setfield_c6, __delfield_c6, None)
2498 
2499     def __getfield_c7(self):
2500         try: self.__field_c7
2501         except:
2502             self.__field_c7=UINT(**{'sizeinbytes': 1, 'constant': 0x67})
2503         return self.__field_c7.getvalue()
2504 
2505     def __setfield_c7(self, value):
2506         if isinstance(value,UINT):
2507             self.__field_c7=value
2508         else:
2509             self.__field_c7=UINT(value,**{'sizeinbytes': 1, 'constant': 0x67})
2510 
2511     def __delfield_c7(self): del self.__field_c7
2512 
2513     c7=property(__getfield_c7, __setfield_c7, __delfield_c7, None)
2514 
2515     def __getfield_c8(self):
2516         try: self.__field_c8
2517         except:
2518             self.__field_c8=UINT(**{'sizeinbytes': 1, 'constant': 0x8f})
2519         return self.__field_c8.getvalue()
2520 
2521     def __setfield_c8(self, value):
2522         if isinstance(value,UINT):
2523             self.__field_c8=value
2524         else:
2525             self.__field_c8=UINT(value,**{'sizeinbytes': 1, 'constant': 0x8f})
2526 
2527     def __delfield_c8(self): del self.__field_c8
2528 
2529     c8=property(__getfield_c8, __setfield_c8, __delfield_c8, None)
2530 
2531     def __getfield_c9(self):
2532         try: self.__field_c9
2533         except:
2534             self.__field_c9=UINT(**{'sizeinbytes': 1, 'constant': 0xf9})
2535         return self.__field_c9.getvalue()
2536 
2537     def __setfield_c9(self, value):
2538         if isinstance(value,UINT):
2539             self.__field_c9=value
2540         else:
2541             self.__field_c9=UINT(value,**{'sizeinbytes': 1, 'constant': 0xf9})
2542 
2543     def __delfield_c9(self): del self.__field_c9
2544 
2545     c9=property(__getfield_c9, __setfield_c9, __delfield_c9, None)
2546 
2547     def __getfield_c10(self):
2548         try: self.__field_c10
2549         except:
2550             self.__field_c10=UINT(**{'sizeinbytes': 1, 'constant': 0xa2})
2551         return self.__field_c10.getvalue()
2552 
2553     def __setfield_c10(self, value):
2554         if isinstance(value,UINT):
2555             self.__field_c10=value
2556         else:
2557             self.__field_c10=UINT(value,**{'sizeinbytes': 1, 'constant': 0xa2})
2558 
2559     def __delfield_c10(self): del self.__field_c10
2560 
2561     c10=property(__getfield_c10, __setfield_c10, __delfield_c10, None)
2562 
2563     def __getfield_c11(self):
2564         try: self.__field_c11
2565         except:
2566             self.__field_c11=UINT(**{'sizeinbytes': 1, 'constant': 0x3f})
2567         return self.__field_c11.getvalue()
2568 
2569     def __setfield_c11(self, value):
2570         if isinstance(value,UINT):
2571             self.__field_c11=value
2572         else:
2573             self.__field_c11=UINT(value,**{'sizeinbytes': 1, 'constant': 0x3f})
2574 
2575     def __delfield_c11(self): del self.__field_c11
2576 
2577     c11=property(__getfield_c11, __setfield_c11, __delfield_c11, None)
2578 
2579     def __getfield_c12(self):
2580         try: self.__field_c12
2581         except:
2582             self.__field_c12=UINT(**{'sizeinbytes': 1, 'constant': 0x7d})
2583         return self.__field_c12.getvalue()
2584 
2585     def __setfield_c12(self, value):
2586         if isinstance(value,UINT):
2587             self.__field_c12=value
2588         else:
2589             self.__field_c12=UINT(value,**{'sizeinbytes': 1, 'constant': 0x7d})
2590 
2591     def __delfield_c12(self): del self.__field_c12
2592 
2593     c12=property(__getfield_c12, __setfield_c12, __delfield_c12, None)
2594 
2595     def __getfield_c13(self):
2596         try: self.__field_c13
2597         except:
2598             self.__field_c13=UINT(**{'sizeinbytes': 1, 'constant': 0x5e})
2599         return self.__field_c13.getvalue()
2600 
2601     def __setfield_c13(self, value):
2602         if isinstance(value,UINT):
2603             self.__field_c13=value
2604         else:
2605             self.__field_c13=UINT(value,**{'sizeinbytes': 1, 'constant': 0x5e})
2606 
2607     def __delfield_c13(self): del self.__field_c13
2608 
2609     c13=property(__getfield_c13, __setfield_c13, __delfield_c13, None)
2610 
2611     def __getfield_c14(self):
2612         try: self.__field_c14
2613         except:
2614             self.__field_c14=UINT(**{'sizeinbytes': 1, 'constant': 0x35})
2615         return self.__field_c14.getvalue()
2616 
2617     def __setfield_c14(self, value):
2618         if isinstance(value,UINT):
2619             self.__field_c14=value
2620         else:
2621             self.__field_c14=UINT(value,**{'sizeinbytes': 1, 'constant': 0x35})
2622 
2623     def __delfield_c14(self): del self.__field_c14
2624 
2625     c14=property(__getfield_c14, __setfield_c14, __delfield_c14, None)
2626 
2627     def __getfield_c15(self):
2628         try: self.__field_c15
2629         except:
2630             self.__field_c15=UINT(**{'sizeinbytes': 1, 'constant': 0x5c})
2631         return self.__field_c15.getvalue()
2632 
2633     def __setfield_c15(self, value):
2634         if isinstance(value,UINT):
2635             self.__field_c15=value
2636         else:
2637             self.__field_c15=UINT(value,**{'sizeinbytes': 1, 'constant': 0x5c})
2638 
2639     def __delfield_c15(self): del self.__field_c15
2640 
2641     c15=property(__getfield_c15, __setfield_c15, __delfield_c15, None)
2642 
2643     def __getfield_c16(self):
2644         try: self.__field_c16
2645         except:
2646             self.__field_c16=UINT(**{'sizeinbytes': 1, 'constant': 0x7e})
2647         return self.__field_c16.getvalue()
2648 
2649     def __setfield_c16(self, value):
2650         if isinstance(value,UINT):
2651             self.__field_c16=value
2652         else:
2653             self.__field_c16=UINT(value,**{'sizeinbytes': 1, 'constant': 0x7e})
2654 
2655     def __delfield_c16(self): del self.__field_c16
2656 
2657     c16=property(__getfield_c16, __setfield_c16, __delfield_c16, None)
2658 
2659     def iscontainer(self):
2660         return True
2661 
2662     def containerelements(self):
2663         yield ('c1', self.__field_c1, None)
2664         yield ('c2', self.__field_c2, None)
2665         yield ('c3', self.__field_c3, None)
2666         yield ('c4', self.__field_c4, None)
2667         yield ('c5', self.__field_c5, None)
2668         yield ('c6', self.__field_c6, None)
2669         yield ('c7', self.__field_c7, None)
2670         yield ('c8', self.__field_c8, None)
2671         yield ('c9', self.__field_c9, None)
2672         yield ('c10', self.__field_c10, None)
2673         yield ('c11', self.__field_c11, None)
2674         yield ('c12', self.__field_c12, None)
2675         yield ('c13', self.__field_c13, None)
2676         yield ('c14', self.__field_c14, None)
2677         yield ('c15', self.__field_c15, None)
2678         yield ('c16', self.__field_c16, None)
2679 
2680 
2681 
2682 
2683 class writeenableresponse(BaseProtogenClass):
2684     __fields=['unknown']
2685 
2686     def __init__(self, *args, **kwargs):
2687         dict={}
2688         # What was supplied to this function
2689         dict.update(kwargs)
2690         # Parent constructor
2691         super(writeenableresponse,self).__init__(**dict)
2692         if self.__class__ is writeenableresponse:
2693             self._update(args,dict)
2694 
2695 
2696     def getfields(self):
2697         return self.__fields
2698 
2699 
2700     def _update(self, args, kwargs):
2701         super(writeenableresponse,self)._update(args,kwargs)
2702         keys=kwargs.keys()
2703         for key in keys:
2704             if key in self.__fields:
2705                 setattr(self, key, kwargs[key])
2706                 del kwargs[key]
2707         # Were any unrecognized kwargs passed in?
2708         if __debug__:
2709             self._complainaboutunusedargs(writeenableresponse,kwargs)
2710         if len(args):
2711             dict2={}
2712             dict2.update(kwargs)
2713             kwargs=dict2
2714             self.__field_unknown=UNKNOWN(*args,**dict2)
2715         # Make all P fields that haven't already been constructed
2716 
2717 
2718     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
2719         'Writes this packet to the supplied buffer'
2720         self._bufferstartoffset=buf.getcurrentoffset()
2721         self.__field_unknown.writetobuffer(buf)
2722         self._bufferendoffset=buf.getcurrentoffset()
2723         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
2724 
2725 
2726     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
2727         'Reads this packet from the supplied buffer'
2728         self._bufferstartoffset=buf.getcurrentoffset()
2729         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
2730         self.__field_unknown=UNKNOWN()
2731         self.__field_unknown.readfrombuffer(buf)
2732         self._bufferendoffset=buf.getcurrentoffset()
2733 
2734 
2735     def __getfield_unknown(self):
2736         return self.__field_unknown.getvalue()
2737 
2738     def __setfield_unknown(self, value):
2739         if isinstance(value,UNKNOWN):
2740             self.__field_unknown=value
2741         else:
2742             self.__field_unknown=UNKNOWN(value,)
2743 
2744     def __delfield_unknown(self): del self.__field_unknown
2745 
2746     unknown=property(__getfield_unknown, __setfield_unknown, __delfield_unknown, None)
2747 
2748     def iscontainer(self):
2749         return True
2750 
2751     def containerelements(self):
2752         yield ('unknown', self.__field_unknown, None)
2753 
2754 
2755 
2756 
2757