PyXR

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



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

Generated by PyXR 0.9.4