PyXR

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

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