rem stringlengths 0 322k | add stringlengths 0 2.05M | context stringlengths 8 228k |
|---|---|---|
self.log.log('Debug'," ".join(zeile)) | self.loger.log('Debug'," ".join(zeile)) | def _verarbeite_reingehendes(self): '''liest den Buffer aus und verteilt das Reingehende auf die Funktionen erwartet: garnix gibt auch nix zurck, aber liest immer 1024 bytes ein und tut sie zum buffer dazu. die letzte zeile wird wieder zurck in den buffer getan und erst nchste mal verarbeitet, weil vielleicht nicht die... |
if not befehl['befehl'].startswith('_') or befehl['befehl'].startswith('on_'): try: temp = getattr(self,'cmd_%s' % befehl['befehl']) temp(befehl) except AttributeError: self.notice(befehl['quelle']['nickname'],'Befehl nicht gefunden: %s' % befehl['befehl']) else: | try: temp = getattr(self,'cmd_%s' % befehl['befehl']) temp(befehl) self.loger.log('Befehl','Befehl von %s: %s' % (befehl['quelle']['nickname']," ".join([befehl['befehl']," ".join(befehl['argumente'])]))) except AttributeError: | def _teile_befehl(self,zeile): '''teilt Befehle in ein Dictionary auf: befehl['quelle']['host'],['ident'],['nick'] jeweils als string befehl['ziel'] string befehl['befehl'] string befehl['argumente'] liste |
def cmd_die(self,*befehl): | def cmd_die(self,befehl): | def cmd_die(self,*befehl): '''schaltet den Bot ab''' befehl = befehl[0] if befehl['quelle']['ident'] == 'tiax': self.quit('diediedie') else: self.notice(befehl['quelle']['nick'],'Du darfst den Bot nicht abschalten') |
befehl = befehl[0] | def cmd_die(self,*befehl): '''schaltet den Bot ab''' befehl = befehl[0] if befehl['quelle']['ident'] == 'tiax': self.quit('diediedie') else: self.notice(befehl['quelle']['nick'],'Du darfst den Bot nicht abschalten') | |
def cmd_ping(self,*befehl): | def cmd_ping(self,befehl): | def cmd_ping(self,*befehl): '''antwortet mit pong''' if befehl['ziel'].startswith('#'): self.msg(befehl['ziel'],'Pong') else: self.notice(befehl['quelle']['nickname'],'Pong') |
self.log.log('Rausgehend','Raw: %s' % rausgehendes) | self.loger.log('Rausgehend','Raw: %s' % rausgehendes) | def rawsend(self,rausgehendes): '''schickt Daten an den Server erwartet: das, was geschickt werden soll gibt auch nix zurck, erspart uns aber die lstige Fehlersuche, wenn die Zeichen am Zeilenende vergessen worden sind.''' self.so.send('%s\r\n' % rausgehendes) self.log.log('Rausgehend','Raw: %s' % rausgehendes) |
self.log.log('Verbindung','Channel %s betreten' % channel) | self.loger.log('Verbindung','Channel %s betreten' % channel) | def join(self,channel,key=''): '''betritt Channel''' self.log.log('Verbindung','Channel %s betreten' % channel) self.rawsend('JOIN %s %s' % (channel, key)) |
self.log('Rausgehendes','Message an %s:' % befehl['ziel']) | self.loger.log('Rausgehendes','Message an %s: %s' % (ziel,nachricht)) | def msg(self,ziel,nachricht): '''schickt Nachrichten raus''' self.rawsend('PRIVMSG %s :%s' % (ziel, nachricht)) self.log('Rausgehendes','Message an %s:' % befehl['ziel']) |
self.log.log('Rausgehendes','Notice an %s:' % befehl['ziel']) | self.loger.log('Rausgehendes','Notice an %s: %s' % (ziel,nachricht)) | def notice(self,ziel,nachricht): '''schickt eine Nachricht als Notice raus''' self.rawsend('NOTICE %s :%s' % (ziel,nachricht)) self.log.log('Rausgehendes','Notice an %s:' % befehl['ziel']) |
self.log.log('Verbindung','Nickname bereits belegt, alle Nicks sind ausgegangen') | self.loger.log('Verbindung','Nickname bereits belegt, alle Nicks sind ausgegangen') | def on_433(self,zeile): ''' der nickname ist bereits belegt wir holen jetzt weitere nicks aus der anfangs erstellten Liste. Falls die leer wird, beenden wir den Bot''' try: self.currentnickname = self.nicknames.pop(0) except IndexError: self.log.log('Verbindung','Nickname bereits belegt, alle Nicks sind ausgegangen') e... |
self.log.log('Verbindng','Nickname war bereits belegt, %s wird versucht' % self.currentnickname) | self.loger.log('Verbindng','Nickname war bereits belegt, %s wird versucht' % self.currentnickname) | def on_433(self,zeile): ''' der nickname ist bereits belegt wir holen jetzt weitere nicks aus der anfangs erstellten Liste. Falls die leer wird, beenden wir den Bot''' try: self.currentnickname = self.nicknames.pop(0) except IndexError: self.log.log('Verbindung','Nickname bereits belegt, alle Nicks sind ausgegangen') e... |
self.log.log('Verbindung','Verbindung hergestellt') print "Verbindung hergestellt" | self.loger.log('Verbindung','Verbindung hergestellt') print "Verbindung hergestellt" | def on_001(self,zeile): '''die IRC Verbindung ist gerade hergestellt worden Das ist die ideale Gelegenheit, am Anfang auszufuehrende Befehle einzugeben''' self.log.log('Verbindung','Verbindung hergestellt') print "Verbindung hergestellt" pass |
self.log.log('Nachricht','%s <%s!%s@%s> %s' % (zeile['ziel'],zeile['quelle']['nickname'],zeile['quelle']['ident'],zeile['quelle']['host']," ".join(zeile['inhalt']))) print 'Nachricht von %s an %s: %s' % (zeile['quelle']['nickname'], zeile['ziel'], zeile['inhalt']) | self.loger.log('Nachricht','%s <%s!%s@%s> %s' % (zeile['ziel'],zeile['quelle']['nickname'],zeile['quelle']['ident'],zeile['quelle']['host']," ".join(zeile['inhalt']))) | def on_PRIVMSG(self,zeile): '''bearbeitet eingehende Nachrichten''' if zeile['inhalt'][0].startswith(self.currentnickname) or zeile['ziel'] == self.currentnickname: # der bot wird entweder angesprochen oder er kriegt eine private message self._teile_befehl(zeile) self.log.log('Nachricht','%s <%s!%s@%s> %s' % (zeile['zi... |
print 'DEBUG: >> USER %s * * :%s' % (ident, realname) | def _verbinde(self,server,nickname,ident=None,realname=None): '''stellt die Verbindung zum Server her erwartet: server entweder als string (url) oder tuple (url, port) nickname als liste von nicknames ident als string realname als string | |
print 'DEBUG: >> NICK %s' % self.currentnickname | def _verbinde(self,server,nickname,ident=None,realname=None): '''stellt die Verbindung zum Server her erwartet: server entweder als string (url) oder tuple (url, port) nickname als liste von nicknames ident als string realname als string | |
print 'DEBUG: <<%s' % zeile | self.log.log('Debug'," ".join(zeile)) | def _verarbeite_reingehendes(self): '''liest den Buffer aus und verteilt das Reingehende auf die Funktionen erwartet: garnix gibt auch nix zurck, aber liest immer 1024 bytes ein und tut sie zum buffer dazu. die letzte zeile wird wieder zurck in den buffer getan und erst nchste mal verarbeitet, weil vielleicht nicht die... |
print 'DEBUG: >> PONG an den Server geschickt' | def _verarbeite_reingehendes(self): '''liest den Buffer aus und verteilt das Reingehende auf die Funktionen erwartet: garnix gibt auch nix zurck, aber liest immer 1024 bytes ein und tut sie zum buffer dazu. die letzte zeile wird wieder zurck in den buffer getan und erst nchste mal verarbeitet, weil vielleicht nicht die... | |
['quelle']['host'],['ident'],['nickname'] ['event'] ['ziel'] ['inhalt'] | ['quelle']['host'],['ident'],['nickname'] jeweils als string ['event'] string ['ziel'] string ['inhalt'] string | def _teile_zeile(self, zeile): ''' teilt reingehendes in ein Dictionary auf ['quelle']['host'],['ident'],['nickname'] ['event'] ['ziel'] ['inhalt'] ''' temp = {} temp['quelle'] = {} if '@' in zeile[0]: temp['quelle']['nickname'] = zeile[0].split('!')[0].lstrip(':') temp['quelle']['ident'] = zeile[0].split('@')[0].split... |
befehl['quelle']['host'],['ident'],['nick'] befehl['ziel'] befehl['befehl'] befehl['argumente'] | befehl['quelle']['host'],['ident'],['nick'] jeweils als string befehl['ziel'] string befehl['befehl'] string befehl['argumente'] liste | def _teile_befehl(self,zeile): '''teilt Befehle in ein Dictionary auf: befehl['quelle']['host'],['ident'],['nick'] befehl['ziel'] befehl['befehl'] befehl['argumente'] |
print 'DEBUG: << Befehl von %s an %s: %s mit Argumenten %s' % (befehl['quelle'],befehl['ziel'],befehl['befehl'],befehl['argumente']) | def _teile_befehl(self,zeile): '''teilt Befehle in ein Dictionary auf: befehl['quelle']['host'],['ident'],['nick'] befehl['ziel'] befehl['befehl'] befehl['argumente'] | |
print 'DEBUG: >> Joine %s' % channel | self.log.log('Verbindung','Channel %s betreten' % channel) | def join(self,channel,key=''): '''betritt Channel''' print 'DEBUG: >> Joine %s' % channel self.rawsend('JOIN %s %s' % (channel, key)) |
print 'Nachricht an %s: %s' % (ziel, nachricht) | def msg(self,ziel,nachricht): '''schickt Nachrichten raus''' print 'Nachricht an %s: %s' % (ziel, nachricht) self.rawsend('PRIVMSG %s :%s' % (ziel, nachricht)) | |
print 'DEBUG: <> Beende' | print 'Beende' | def quit(self,quitmessage): print 'DEBUG: <> Beende' self.rawsend('quit :%s' % quitmessage) self.so.close() |
print 'DEBUG: Befehl aufgeschnappt' | def on_PRIVMSG(self,zeile): '''bearbeitet eingehende Nachrichten''' if zeile['inhalt'][0].startswith(self.currentnickname) or zeile['ziel'] == self.currentnickname: # der bot wird entweder angesprochen oder er kriegt eine private message print 'DEBUG: Befehl aufgeschnappt' self._teile_befehl(zeile) # DEBUG elif 'ping' ... | |
elif 'ping' in zeile['inhalt']: self.msg(zeile['ziel'],'%s: pong' % zeile['quelle']['nickname']) | self.log.log('Nachricht','%s <%s!%s@%s> %s' % (zeile['ziel'],zeile['quelle']['nickname'],zeile['quelle']['ident'],zeile['quelle']['host']," ".join(zeile['inhalt']))) | def on_PRIVMSG(self,zeile): '''bearbeitet eingehende Nachrichten''' if zeile['inhalt'][0].startswith(self.currentnickname) or zeile['ziel'] == self.currentnickname: # der bot wird entweder angesprochen oder er kriegt eine private message print 'DEBUG: Befehl aufgeschnappt' self._teile_befehl(zeile) # DEBUG elif 'ping' ... |
self.join(' | pass | def on_001(self,zeile): '''die IRC Verbindung ist gerade hergestellt worden Das ist die ideale Gelegenheit, am Anfang auszufuehrende Befehle einzugeben''' self.join('#tiax') |
if 'die' in zeile['inhalt']: self.quit('diediedie') | def on_PRIVMSG(self,zeile): '''bearbeitet eingehende Nachrichten''' if zeile['inhalt'][0].startswith(self.currentnickname) or zeile['ziel'] == self.currentnickname: # der bot wird entweder angesprochen oder er kriegt eine private message print 'DEBUG: Befehl aufgeschnappt' self._teile_befehl(zeile) # DEBUG if 'die' in ... | |
logger.debug('Verbindung zu %s wird hergestellt' % server) | logger.debug('Verbindung zu %s:%s wird hergestellt' % server) | def __init__(self,server,nickname,ident=None,realname=None): global logger self._buffer = '' logger.debug('Verbindung zu %s wird hergestellt' % server) self.Verbinde(server,nickname,ident,realname) |
logger.info('Verbindung zu %s wurde hergestellt' % server) | logger.info('Verbindung zu %s:%s wurde hergestellt' % server) | def Verbinde(self,server,nickname,ident=None,realname=None): self.nicknames = [] if type(nickname) == type([]): self.nicknames.extend(nickname) else: self.nicknames.append(nickname) self.currentnickname = self.nicknames.pop(0) ident = ident or self.currentnickname realname = realname or self.currentnickname self._socke... |
logstart(1024) | if __name__ == '__main__': if "--daemon" in sys.argv: if not (os.fork()): os.setsid() sys.stdin.close() sys.stdout = open('/home/tiax/daemonlog','w') sys.stderr = sys.stdout if not (os.fork()): ppid = os.getppid() while (ppid != 1): time.sleep(0.5) ppid = os.getppid() else: os._exit(0) else: os.wait() sys.exit() logs... | def notice(self,ziel,message): logger.debug('Notice an %s: %s' % (ziel, message)) self.rawsend('NOTICE %s :%s' % (ziel, message)) |
self.so.send('JOIN print 'DEBUG: >> JOIN | self.join(' | def verbinde(self,server,nickname,ident,realname): '''erwartet: server als tuple serverurl,port nickname als string ident als string realname als string |
return event.quelle['ident'] == 'tiax' and event.quelle['host'] == 'victory-is-life.de' | return event.quelle['ident'] == 'tiax' and event.quelle['host'] == 'tiax.support.xwars' | def _checkfortiax(event): return event.quelle['ident'] == 'tiax' and event.quelle['host'] == 'victory-is-life.de' |
self.notice(event.quelle['nick'],meldung) | event.parent.notice(event.quelle['nick'],meldung) | def parse(event): print event.ziel if event.ziel == '#tdm': try: url = event.befehl['argumente'][0] except IndexError: event.parent.notice(event.quelle['nick'],'Bitte URL angeben') else: logger.info('%s lässt %s parsen' % (event.quelle, url)) kampfbericht = xwars.kampfbericht(url) try: kampfbericht.analyze() except (IO... |
self.notice(event.quelle['nick'],'Ungültige URL') | event.parent.notice(event.quelle['nick'],'Ungültige URL') | def parse(event): print event.ziel if event.ziel == '#tdm': try: url = event.befehl['argumente'][0] except IndexError: event.parent.notice(event.quelle['nick'],'Bitte URL angeben') else: logger.info('%s lässt %s parsen' % (event.quelle, url)) kampfbericht = xwars.kampfbericht(url) try: kampfbericht.analyze() except (IO... |
print the_type | def callback(self, the_type, msg): #print the_type #if(the_type == "global_pose"): # print "global_pose", msg.globalpos.x, msg.globalpos.y pass | |
typeAttrs = type['attrs'] if typeAttrs.has_key('access') and typeAttrs['access'] in ('private','protected') : return type['attrs']['id'] | attrs = type['attrs'] if 'access' in attrs and attrs['access'] in ('private','protected') : return attrs['id'] if 'context' in attrs and self.checkAccessibleType(self.xref[attrs['context']]) : return attrs['id'] | def checkAccessibleType( self, type ): while type['elem'] in ('PointerType','Typedef') : type = self.xref[type['attrs']['type']] typeAttrs = type['attrs'] if typeAttrs.has_key('access') and typeAttrs['access'] in ('private','protected') : return type['attrs']['id'] return 0 |
if inner : cls = attrs['name'] else : cls = self.genTypeName(attrs['id']) | cls = self.genTypeName(attrs['id'],const=True,colon=True) | def genClassShadow(self, attrs, inner = 0 ) : bases = self.getBases( attrs['id'] ) if inner : cls = attrs['name'] else : cls = self.genTypeName(attrs['id']) clt = string.translate(str(cls), self.transtable) self.generated_shadow_classes.append(clt) typ = self.xref[attrs['id']]['elem'].lower() indent = inner * 2 * '... |
self.generated_shadow_classes.append(clt) | def genClassShadow(self, attrs, inner = 0 ) : bases = self.getBases( attrs['id'] ) if inner : cls = attrs['name'] else : cls = self.genTypeName(attrs['id']) clt = string.translate(str(cls), self.transtable) self.generated_shadow_classes.append(clt) typ = self.xref[attrs['id']]['elem'].lower() indent = inner * 2 * '... | |
if member['elem'] in ('Class','Struct'): c += self.genClassShadow(member['attrs'], inner + 1) | if member['elem'] in ('Class','Struct','Union','Enumeration') \ and 'access' in member['attrs'] \ and member['attrs']['access'] in ('private','protected') : cmem = self.genTypeName(member['attrs']['id'],const=True,colon=True) if cmem != cls and cmem not in inner_shadows : inner_shadows[cmem] = string.translate(str(cmem... | def genClassShadow(self, attrs, inner = 0 ) : bases = self.getBases( attrs['id'] ) if inner : cls = attrs['name'] else : cls = self.genTypeName(attrs['id']) clt = string.translate(str(cls), self.transtable) self.generated_shadow_classes.append(clt) typ = self.xref[attrs['id']]['elem'].lower() indent = inner * 2 * '... |
tend = '' while t[-1] in ('*','&') : tend = tend + t[-1] t = t[:-1] t = string.translate(str(t), self.transtable)[2:] t += tend if ( string.translate(str(self.genTypeName(noPubTypeAttrs['id'])), self.transtable) not in self.generated_shadow_classes ): c += self.genClassShadow(noPubTypeAttrs) | cmem = self.genTypeName(noPubTypeAttrs['id'],const=True,colon=True) if cmem != cls and cmem not in inner_shadows : inner_shadows[cmem] = string.translate(str(cmem), self.transtable) c += self.genClassShadow(noPubTypeAttrs, inner + 1) ikeys = inner_shadows.keys() ikeys.sort(lambda x,y : len(y) - len(x)) for ikey in ike... | def genClassShadow(self, attrs, inner = 0 ) : bases = self.getBases( attrs['id'] ) if inner : cls = attrs['name'] else : cls = self.genTypeName(attrs['id']) clt = string.translate(str(cls), self.transtable) self.generated_shadow_classes.append(clt) typ = self.xref[attrs['id']]['elem'].lower() indent = inner * 2 * '... |
shadow = '__shadow__::' + string.translate( str(cls), self.transtable) | shadow = '__shadow__::' + string.translate( str(cl), self.transtable) | def genFieldBuild(self, attrs, childs): type = self.genTypeName(attrs['type'], enum=False, const=False) cl = self.genTypeName(attrs['context'],colon=True) cls = self.genTypeName(attrs['context']) name = attrs['name'] if not name : ftype = self.xref[attrs['type']] # if the member type is an unnamed union we try... |
new_attrs = { 'id':id, 'context':attrs['id'] } | new_attrs = { 'id':id, 'context':attrs['id'], 'artificial':'true' } | def enhanceClass(self, attrs): # Default constructor if 'members' in attrs : members = attrs['members'].split() else : members = [] for m in members : if self.xref[m]['elem'] == 'Constructor' : args = self.xref[m]['subelems'] if len(args) > 0 and 'default' in args[0] : id = u'_x%d' % self.x_id.next() ... |
return ' .AddFunctionMember<void*(void)>("__getNewDelFunctions", method%s)' % (attrs['id']) | mod = self.genModifier(attrs, None) return ' .AddFunctionMember<void*(void)>("__getNewDelFunctions", method%s, 0, 0, %s)' % (attrs['id'], mod) | def genGetNewDelFunctionsBuild( self, attrs, args ) : return ' .AddFunctionMember<void*(void)>("__getNewDelFunctions", method%s)' % (attrs['id']) |
print '--->> genreflex: ERROR: processing file with gccxml. genreflex command failed.' | print '\n--->> genreflex: ERROR: processing file with gccxml. genreflex command failed.' | def process_files(self): total_warnings = 0 file_extension = '_rflx.cpp' #----------Loop oover all the input files-------------- for source in self.files : path, fullname = os.path.split(source) name = fullname[:fullname.find('.')] xmlfile = os.path.join(self.outputDir,name+'.xml') if( self.outputFile ) : dicfile = os.... |
s += ' s_bases.push_back(std::make_pair(seal::reflex::Base( seal::reflex::getType< %s >(), seal::reflex::baseOffset< %s,%s >::get(),%s), %d));\n' % (bname, cl, bname, b[1], b[2]) | s += ' s_bases.push_back(std::make_pair(ROOT::Reflex::Base( ROOT::Reflex::GetType< %s >(), ROOT::Reflex::BaseOffset< %s,%s >::Get(),%s), %d));\n' % (bname, cl, bname, b[1], b[2]) | def genGetBasesTableDef( self, attrs, args ) : cid = attrs['context'] cl = self.genTypeName(cid, colon=True) clt = string.translate(str(cl), self.transtable) s = 'static void* method%s( void*, const std::vector<void*>&, void*)\n{\n' %( attrs['id'], ) s += ' static std::vector<std::pair<ROOT::Reflex::B... |
return ' .addFunctionMember<void*(void)>("__getNewDelFunctions", method%s)' % (attrs['id']) | return ' .AddFunctionMember<void*(void)>("__getNewDelFunctions", method%s)' % (attrs['id']) | def genGetNewDelFunctionsBuild( self, attrs, args ) : return ' .addFunctionMember<void*(void)>("__getNewDelFunctions", method%s)' % (attrs['id']) |
s = 'void* %s_dict::method%s( void*, const std::vector<void*>&, void*)\n{\n' %( clt, attrs['id'] ) | s = 'void* method%s( void*, const std::vector<void*>&, void*)\n{\n' %( attrs['id'] ) | def genGetNewDelFunctionsDef( self, attrs, args ) : cid = attrs['context'] cl = self.genTypeName(cid, colon=True) clt = string.translate(str(cl), self.transtable) s = 'void* %s_dict::method%s( void*, const std::vector<void*>&, void*)\n{\n' %( clt, attrs['id'] ) s += ' static NewDelFunctions s_funcs;\n... |
s += ' s_funcs.fNew = new_T< %s >;\n' % cl s += ' s_funcs.fNewArray = newArray_T< %s >;\n' % cl s += ' s_funcs.fDelete = delete_T< %s >;\n' % cl s += ' s_funcs.fDeleteArray = deleteArray_T< %s >;\n' % cl s += ' s_funcs.fDestructor = destruct_T< %s >;\n' % cl | s += ' s_funcs.fNew = NewDelFunctionsT< %s >::new_T;\n' % cl s += ' s_funcs.fNewArray = NewDelFunctionsT< %s >::newArray_T;\n' % cl s += ' s_funcs.fDelete = NewDelFunctionsT< %s >::delete_T;\n' % cl s += ' s_funcs.fDeleteArray = NewDelFunctionsT< %s >::deleteArray_T;\n' % cl s += ' s_funcs.fDestruc... | def genGetNewDelFunctionsDef( self, attrs, args ) : cid = attrs['context'] cl = self.genTypeName(cid, colon=True) clt = string.translate(str(cl), self.transtable) s = 'void* %s_dict::method%s( void*, const std::vector<void*>&, void*)\n{\n' %( clt, attrs['id'] ) s += ' static NewDelFunctions s_funcs;\n... |
return ' .AddFunctionMember<void*(void)>("getBasesTable", method%s, 0, 0, %s)' % (attrs['id'], mod) | return ' .AddFunctionMember<void*(void)>("__getBasesTable", method%s, 0, 0, %s)' % (attrs['id'], mod) | def genGetBasesTableBuild( self, attrs, args ) : mod = self.genModifier(attrs, None) return ' .AddFunctionMember<void*(void)>("getBasesTable", method%s, 0, 0, %s)' % (attrs['id'], mod) |
s += ' s_bases.push_back(std::make_pair(ROOT::Reflex::Base( ROOT::Reflex::GetType< %s >(), ROOT::Reflex::BaseOffset< %s,%s >::Get(),%s), %d));\n' % (bname, cl, bname, b[1], b[2]) s += ' return &s_bases;\n' | s += ' s_bases.push_back(std::make_pair(seal::reflex::Base( seal::reflex::getType< %s >(), seal::reflex::baseOffset< %s,%s >::get(),%s), %d));\n' % (bname, cl, bname, b[1], b[2]) s += ' }\n return &s_bases;\n' s += '}\n' return s def genGetNewDelFunctionsDecl( self, attrs, args ) : return 'static void* method%s( ... | def genGetBasesTableDef( self, attrs, args ) : cid = attrs['context'] cl = self.genTypeName(cid, colon=True) clt = string.translate(str(cl), self.transtable) s = 'static void* method%s( void*, const std::vector<void*>&, void*)\n{\n' %( attrs['id'], ) s += ' static std::vector<std::pair<ROOT::Reflex::B... |
try: import gccxmlpath self.gccxmlpath = gccxmlpath.gccxmlpath except: pass | def __init__(self): self.files = [] self.output = None self.outputDir = None self.outputFile = None self.capabilities = None self.select = None self.cppopt = '' self.deep = False self.opts = {} self.gccxmlpath = None self.selector = No... | |
if o in ('-f') : | if o in ('-f',) : | def parse_args(self): options = sys.argv[1:] options2 = [] # FIXME: removing again TROOT.h and TMemberInspector.h from the options as they are # passed in by rootcint, but before the options (gnu style doesn't like it) # --> fix is to remove the two headers from the invocation in rootcint.cxx for o in options : if o.fi... |
s += ' s_bases.push_back(std::make_pair(ROOT::Reflex::Base( ROOT::Reflex::GetType< %s >(), ROOT::Reflex::BaseOffset< %s,%s >::Get(),%s), %d));\n' % (bname, cl, bname, b[1], b[2]) | bname2 = self.genTypeName(b[0]) s += ' s_bases.push_back(std::make_pair(ROOT::Reflex::Base( ROOT::Reflex::TypeBuilder("%s"), ROOT::Reflex::BaseOffset< %s,%s >::Get(),%s), %d));\n' % (bname2, cl, bname, b[1], b[2]) | def genGetBasesTableDef( self, attrs, args ) : cid = attrs['context'] cl = self.genTypeName(cid, colon=True) clt = string.translate(str(cl), self.transtable) s = 'static void* method%s( void*, const std::vector<void*>&, void*)\n{\n' %( attrs['id'], ) s += ' static std::vector<std::pair<ROOT::Reflex::B... |
tend = '' while t[-1] in ('*','&') : tend = tend + t[-1] t = t[:-1] t = string.translate(str(t), self.transtable)[2:] t += tend | def genClassShadow(self, attrs, inner = 0 ) : bases = self.getBases( attrs['id'] ) if inner : cls = attrs['name'] else : cls = self.genTypeName(attrs['id']) clt = string.translate(str(cls), self.transtable) self.generated_shadow_classes.append(clt) typ = self.xref[attrs['id']]['elem'].lower() indent = inner * 2 * '... | |
Disable resolving of typedefs in template parameters for selection names. E.g. std::vector<MYINT>. | Disable resolving of typedefs in template parameters for selection names. E.g. std::vector<MYINT>.\n | def help(self) : print """Generates the LCG dictionary file for each header file\n Usage: genreflex headerfile1.h [headerfile2.h] [options] [preprocesor options]\n Options: -s <file>, --selection_file=<file> Class selection file to specify for which classes the dictionary will be generated Format (XML): <lcgdict> [<sel... |
s += sout | gccxmlv = sout.split('\n')[0].split()[-1] if gccxmlv != '0.6.0' and gccxmlv != self.gccxmlvers : print '--->> genreflex: WARNING: gccxml versions differ. Used version: %s. Recommended version: %s. ' % ( gccxmlv, self.gccxmlvers) print '--->> genreflex: WARNING: gccxml binary used: %s' % ( self.gccxml ) s += sout | def genGccxmlInfo(self): s = '' (inp,out,err) = os.popen3(self.gccxml + ' --print') serr = err.read() sout = out.read() if serr : print '--->> genreflex: WARNING: Could not invoke %s --print' % self.gccxml print '--->> genreflex: WARNING: %s' % serr return s s += sout compiler = '' for l in sout.split('\n'): ll = l.spl... |
if t[-1] == ')' : s += t.replace('::*)','::**)').replace('::)','::*)').replace('(*)', '(**)').replace('()','(*)') elif t[-1] == ']' : s += t[:t.find('[')] + '(*)' + t[t.find('['):] | if t[-1] == ')' or t[-7:] == ') const' or t[-10:] == ') volatile' : s += t.replace('::*)','::**)').replace('::)','::*)').replace('(*)', '(**)').replace('()','(*)') elif t[-1] == ']' or t[-7:] == ') const' or t[-10:] == ') volatile' : s += t[:t.find('[')] + '(*)' + t[t.find('['):] | def genTypeName(self, id, enum=False, const=False, colon=False, alltempl=False) : if id[-1] in ['c','v'] : nid = id[:-1] cvdict = {'c':'const','v':'volatile'} prdict = {'PointerType':'*', 'ReferenceType':'&'} nidelem = self.xref[nid]['elem'] if nidelem in ('PointerType','ReferenceType') : if const : return self.genType... |
cnt += s.count('<')-s.count('>') | cnt += s.count('<')+s.count('(')-s.count('>')-s.count(')') | def getTemplateArgs( cl ) : if cl.find('<') == -1 : return [] args, cnt = [], 0 for s in string.split(cl[cl.find('<')+1:cl.rfind('>')],',') : if cnt == 0 : args.append(s) else : args[-1] += ','+ s cnt += s.count('<')-s.count('>') if args[-1][-1] == ' ' : args[-1] = args[-1][:-1] return args |
s += ' s_funcs.fNew = NewDelFunctionsT< %s >::new_T;\n' % cl s += ' s_funcs.fNewArray = NewDelFunctionsT< %s >::newArray_T;\n' % cl | s += ' s_funcs.fNew = NewDelFunctionsT< %s >::new%s_T;\n' % (cl, newc) s += ' s_funcs.fNewArray = NewDelFunctionsT< %s >::newArray%s_T;\n' % (cl, newa) | def genGetNewDelFunctionsDef( self, attrs, args ) : cid = attrs['context'] cl = self.genTypeName(cid, colon=True) clt = string.translate(str(cl), self.transtable) s = 'static void* method%s( void*, const std::vector<void*>&, void*)\n{\n' %( attrs['id'] ) s += ' static NewDelFunctions s_funcs;\n' s += ... |
mod += ' | ' + self.xref[attrs['id']]['elem'].upper() | typ = self.xref[attrs['id']]['elem'].upper() | def genClassDict(self, attrs): members, bases = [], [] cl = attrs['name'] clf = self.genTypeName(attrs['id'],colon=True) cls = self.genTypeName(attrs['id']) clt = string.translate(str(clf), self.transtable) bases = self.getBases( attrs['id'] ) if 'members' in attrs : members = string.split(attrs['members']) mod = self... |
sc += ' ClassBuilder("%s", typeid(Unnamed%s), sizeof(%s), %s)' % ( cls, self.xref[attrs['id']]['elem'], '__shadow__::'+ string.translate(str(clf),self.transtable),mod ) | sc += ' ClassBuilder("%s", typeid(Unnamed%s), sizeof(%s), %s, %s)' % ( cls, self.xref[attrs['id']]['elem'], '__shadow__::'+ string.translate(str(clf),self.transtable), mod, typ ) | def genClassDict(self, attrs): members, bases = [], [] cl = attrs['name'] clf = self.genTypeName(attrs['id'],colon=True) cls = self.genTypeName(attrs['id']) clt = string.translate(str(clf), self.transtable) bases = self.getBases( attrs['id'] ) if 'members' in attrs : members = string.split(attrs['members']) mod = self... |
sc += ' ClassBuilder("%s", typeid(%s%s), sizeof(%s), %s)' % ( cls, self.xref[notAccessibleType]['attrs']['access'].title(), self.xref[attrs['id']]['elem'], '__shadow__::'+ string.translate(str(clf),self.transtable),mod ) | sc += ' ClassBuilder("%s", typeid(%s%s), sizeof(%s), %s, %s)' % ( cls, self.xref[notAccessibleType]['attrs']['access'].title(), self.xref[attrs['id']]['elem'], '__shadow__::'+ string.translate(str(clf),self.transtable), mod, typ ) | def genClassDict(self, attrs): members, bases = [], [] cl = attrs['name'] clf = self.genTypeName(attrs['id'],colon=True) cls = self.genTypeName(attrs['id']) clt = string.translate(str(clf), self.transtable) bases = self.getBases( attrs['id'] ) if 'members' in attrs : members = string.split(attrs['members']) mod = self... |
sc += ' ClassBuilder("%s", typeid(%s), sizeof(%s), %s)' % (cls, cls, cls, mod) | sc += ' ClassBuilder("%s", typeid(%s), sizeof(%s), %s, %s)' % (cls, cls, cls, mod, typ) | def genClassDict(self, attrs): members, bases = [], [] cl = attrs['name'] clf = self.genTypeName(attrs['id'],colon=True) cls = self.genTypeName(attrs['id']) clt = string.translate(str(clf), self.transtable) bases = self.getBases( attrs['id'] ) if 'members' in attrs : members = string.split(attrs['members']) mod = self... |
if bcomp in ('gcc','g++','c++') : vopt = '--version' | if bcomp in ('msvc7','msvc71') : return s elif bcomp in ('gcc','g++','c++') : vopt = '--version' | def genGccxmlInfo(self): s = '' (inp,out,err) = os.popen3(self.gccxml + ' --print') serr = err.read() sout = out.read() if serr : print '--->> genreflex: WARNING: Could not invoke %s --print' % self.gccxml print '--->> genreflex: WARNING: %s' % serr return s s += sout compiler = '' for l in sout.split('\n'): ll = l.spl... |
print '--->> genreflex: WARNING: While trying to retrieve compiler version, found unknow compiler' % compiler | print '--->> genreflex: WARNING: While trying to retrieve compiler version, found unknown compiler %s' % compiler | def genGccxmlInfo(self): s = '' (inp,out,err) = os.popen3(self.gccxml + ' --print') serr = err.read() sout = out.read() if serr : print '--->> genreflex: WARNING: Could not invoke %s --print' % self.gccxml print '--->> genreflex: WARNING: %s' % serr return s s += sout compiler = '' for l in sout.split('\n'): ll = l.spl... |
if 'access' in attr and attr['access'] in ('private','protected') : return True | if attr.get('access') in ('private','protected') : return True else : return False | def isDestructorNonPublic(self, id ) : attrs = self.xref[id]['attrs'] if 'members' in attrs : for m in attrs['members'].split() : elem = self.xref[m]['elem'] attr = self.xref[m]['attrs'] if elem == 'Destructor' : if 'access' in attr and attr['access'] in ('private','protected') : return True if 'bases' in attrs : for b... |
if 'incomplete' in c : continue | if 'incomplete' in c : continue if not c.has_key('members') : continue | def selclasses(self, sel, deep) : selec = [] if sel : self.selector = sel # remember the selector for c in self.classes : if 'incomplete' in c : continue match = self.selector.matchclass( self.genTypeName(c['id']), self.files[c['file']]['name']) if match[0] and not match[1] : c['extra'] = match[0] selec.append(c) for ... |
if 'mangled' in m : | if 'mangled' in m and m['name'].isalpha() : | def completeClass(self, attrs): # Complete class with "instantiated" templated methods or constructors if 'members' in attrs : members = attrs['members'].split() else : members = [] cid = attrs['id'] for c in self.classes : if c['context'] == cid and c['id'] not in members : attrs['members'] += u' ' + ... |
elif t.find(')(') != -1 : c += indent + ' %s;\n' % ( t.replace(')(', ' %s)('%a['name'])) | elif t.find(')(') != -1 and t.find('<') == -1 : c += indent + ' %s;\n' % ( t.replace(')(', ' %s)('%a['name'])) | def genClassShadow(self, attrs, inner = 0 ) : inner_shadows = {} bases = self.getBases( attrs['id'] ) cls = self.genTypeName(attrs['id'],const=True,colon=True) clt = string.translate(str(cls), self.transtable) if self.isUnnamedType(cls) and inner : clt = '' xtyp = self.xref[attrs['id']] typ = xtyp['elem'].lower() inden... |
if name in ('exclusion') : | if name in ('exclusion',) : | def end_element(self, name): if name in ('exclusion') : self.classes = self.sel_classes self.functions = self.sel_functions |
be placed in the given directory. <headerfile>_dict.cpp \n | be placed in the given directory. <headerfile>_rflx.cpp \n | def help(self) : print """Generates the LCG dictionary file for each header file\n Usage: genreflex headerfile1.h [headerfile2.h] [options] [preprocesor options]\n Options: -s <file>, --selection_file=<file> Class selection file to specify for which classes the dictionary will be generated Format (XML): <lcgdict> [<sel... |
elif t.find(')(') != -1 and t.find('<') == -1 : c += indent + ' %s;\n' % ( t.replace(')(', ' %s)('%a['name'])) | elif fPPos : c += indent + ' %s;\n' % ( t[:fPPos] + a['name'] + t[fPPos:] ) | def genClassShadow(self, attrs, inner = 0 ) : inner_shadows = {} bases = self.getBases( attrs['id'] ) cls = self.genTypeName(attrs['id'],const=True,colon=True) clt = string.translate(str(cls), self.transtable) if self.isUnnamedType(cls) and inner : clt = '' xtyp = self.xref[attrs['id']] typ = xtyp['elem'].lower() inden... |
s += ' .AddEnum("%s", "%s", &typeid(UnnamedEnum))' % (name[name.rfind('::')+3:], values) | s += ' .AddEnum("%s", "%s", &typeid(ROOT::Reflex::UnnamedEnum))' % (name[name.rfind('::')+3:], values) | def genEnumerationBuild(self, attrs, childs): s = '' name = self.genTypeName(attrs['id']) values = '' for child in childs : values += child['name'] + '=' + child['init'] +';' values = values[:-1] if self.isUnnamedType(name) : s += ' .AddEnum("%s", "%s", &typeid(UnnamedEnum))' % (name[name.rfind('::')+3:], values) else... |
s += ' .AddEnum("%s", "%s")' % (name, values) | s += ' .AddEnum("%s", "%s", &typeid(ROOT::Reflex::UnknownType))' % (name, values) | def genEnumerationBuild(self, attrs, childs): s = '' name = self.genTypeName(attrs['id']) values = '' for child in childs : values += child['name'] + '=' + child['init'] +';' values = values[:-1] if self.isUnnamedType(name) : s += ' .AddEnum("%s", "%s", &typeid(UnnamedEnum))' % (name[name.rfind('::')+3:], values) else... |
f.write(self.genNamespaces(selclasses)) | f.write(self.genNamespaces(selclasses + selfunctions + selenums + selvariables)) | def generate(self, file, selclasses, selfunctions, selenums, selvariables, cppinfo) : names = [] f = open(file,'w') f.write(self.genHeaders(cppinfo)) f_buffer = '' f_shadow = '\n// Shadow classes to obtain the data member offsets \n' f_shadow += 'namespace __shadow__ {\n' for c in selclasses : if 'incomplete' not in c... |
def genNamespaces(self, selclasses ) : | def genNamespaces(self, selected ) : | def genNamespaces(self, selclasses ) : used_context = [] s = '' for c in selclasses : if 'incomplete' not in c : used_context.append(c['context']) idx = 0 for ns in self.namespaces : if ns['id'] in used_context and ns['name'] != '::' : s += ' NamespaceBuilder nsb%d( "%s" );\n' % (idx, self.genTypeName(ns['id'])) idx +... |
for c in selclasses : | for c in selected : | def genNamespaces(self, selclasses ) : used_context = [] s = '' for c in selclasses : if 'incomplete' not in c : used_context.append(c['context']) idx = 0 for ns in self.namespaces : if ns['id'] in used_context and ns['name'] != '::' : s += ' NamespaceBuilder nsb%d( "%s" );\n' % (idx, self.genTypeName(ns['id'])) idx +... |
c += self.genFunctions(selfunctions) c += self.genEnums(selenums) c += self.genVariables(selvariables) | def genInstantiateDict( self, selclasses, selfunctions, selenums, selvariables) : c = 'namespace {\n struct Dictionaries {\n Dictionaries() {\n' c += self.genFunctions(selfunctions) c += self.genEnums(selenums) c += self.genVariables(selvariables) for attrs in selclasses : if 'incomplete' not in attrs : clf = self.... | |
def test_1decimal(): if not supports('decimalColumn'): return setupClass(DecimalTable) d = DecimalTable(col1=21.12) assert d.col1 == 21.12 if Decimal and supports('decimalColumn'): def test_2Decimal(): | if supports('decimalColumn'): def test_1decimal(): """Tests new instance with a float in col1.""" | def test_1decimal(): if not supports('decimalColumn'): return setupClass(DecimalTable) d = DecimalTable(col1=21.12) assert d.col1 == 21.12 |
for col in soClass.sqlmeta._columns: | for col in soClass.sqlmeta.columnList: | def db_differences(soClass, conn): """ Returns the differences between a class and the table in a connection. Returns [] if no differences are found. This function does the best it can; it can miss many differences. """ # @@: Repeats a lot from CommandStatus.command, but it's hard # to actually factor out the display... |
for col in soClass.sqlmeta._columns: | for col in soClass.sqlmeta.columnList: | def command(self): good = 0 bad = 0 missing_tables = 0 columnsFromSchema_warning = False for soClass in self.classes(): conn = soClass._connection self.printed = False if self.options.verbose: self.print_class(soClass) if not conn.tableExists(soClass.sqlmeta.table): self.print_class(soClass) print ' Does not exist in ... |
kw['default'] = default | if default and t.startswith('int'): kw['default'] = int(default) else: kw['default'] = default | def columnsFromSchema(self, tableName, soClass): colData = self.queryAll("SHOW COLUMNS FROM %s" % tableName) results = [] for field, t, nullAllowed, key, default, extra in colData: if field == 'id': continue colClass, kw = self.guessClass(t) kw['name'] = soClass.sqlmeta.style.dbColumnToPythonAttr(field) kw['notNone'] =... |
if isinstance(value, (datetime.date, datetime.datetime)): | if isinstance(value, (datetime.date, datetime.datetime, sqlbuilder.SQLExpression)): | def fromPython(self, value, state): if value is None: return None if isinstance(value, (datetime.date, datetime.datetime)): return value if hasattr(value, "strftime"): return value.strftime(self.format) raise validators.InvalidField("expected a datetime in the DateTimeCol '%s', got %s instead" % \ (self.name, type(valu... |
if isinstance(value, (datetime.date, datetime.datetime)): | if isinstance(value, (datetime.date, datetime.datetime, sqlbuilder.SQLExpression)): | def toPython(self, value, state): if value is None: return None if isinstance(value, (datetime.date, datetime.datetime)): return value if mxdatetime_available and isinstance(value, DateTimeType): # convert mxDateTime instance to datetime if (self.format.find("%H") >= 0) or (self.format.find("%T")) >= 0: return datetime... |
if isinstance(value, DateTimeType): | if isinstance(value, (DateTimeType, sqlbuilder.SQLExpression)): | def fromPython(self, value, state): if value is None: return None if isinstance(value, DateTimeType): return value if hasattr(value, "strftime"): return value.strftime(self.format) raise validators.InvalidField("expected a mxDateTime in the DateTimeCol '%s', got %s instead" % \ (self.name, type(value)), value, state) |
if isinstance(value, DateTimeType): | if isinstance(value, (DateTimeType, sqlbuilder.SQLExpression)): | def toPython(self, value, state): if value is None: return None if isinstance(value, DateTimeType): return value if datetime_available: # convert datetime instance to mxDateTime if isinstance(value, datetime.datetime): return DateTime.DateTime(value.year, value.month, value.day, value.hour, value.minute, value.second) ... |
assert dt2.col1.hour == _now.hour assert dt2.col1.minute == _now.minute assert dt2.col1.second == int(_now.second) | if getConnection().dbName == "sqlite": assert dt2.col2.hour == _now.hour assert dt2.col2.minute == _now.minute assert dt2.col2.second == int(_now.second) else: assert dt2.col2.hour == 0 assert dt2.col2.minute == 0 assert dt2.col2.second == 0 | def test_mxDateTime(): setupClass(DateTime2) _now = now() dt2 = DateTime2(col1=_now, col2=_now, col3=Time(_now.hour, _now.minute, int(_now.second))) |
pkg_resources.require(egg_spec) dist = pkg_resources.working_set.find(pkg_resources.Requirement(egg_spec)) | dist = pkg_resources.get_distribution(egg_spec) | def config_from_egg(self, egg_spec, warn_no_sqlobject=True): import pkg_resources pkg_resources.require(egg_spec) dist = pkg_resources.working_set.find(pkg_resources.Requirement(egg_spec)) if not dist.has_metadata('sqlobject.txt'): if warn_no_sqlobject: print 'No sqlobject.txt in %s egg info' % egg_spec return None, {}... |
for key in ("unix_socket", "named_pipe", "init_command", | for key in ("unix_socket", "init_command", | def __init__(self, db, user, password='', host='localhost', port=None, **kw): global MySQLdb if MySQLdb is None: import MySQLdb self.module = MySQLdb self.host = host self.port = port self.db = db self.user = user self.password = password if kw.has_key('client_encoding'): self.client_encoding = col.popKey(kw, 'client_e... |
self._obsolete = False | self._obsolete = True | def __init__(self, dbConnection): self._obsolete = False self._dbConnection = dbConnection self._connection = dbConnection.getConnection() self._dbConnection._setAutoCommit(self._connection, 0) self.cache = CacheSet(cache=dbConnection.doCache) self._deletedCache = {} |
id = c.insert_id() | id = c.lastrowid | def _queryInsertID(self, conn, soInstance, id, names, values): table = soInstance._table idName = soInstance._idName c = conn.cursor() if id is not None: names = [idName] + names values = [id] + values q = self._insertSQL(table, names, values) if self.debug: self.printDebug(conn, q, 'QueryIns') self._executeRetry(conn,... |
if e.code == 1146: | if e[0].code == 1146: | def tableExists(self, tableName): try: # Use DESCRIBE instead of SHOW TABLES because SHOW TABLES # assumes there is a default database selected # which is not always True (for an embedded application, e.g.) self.query('DESCRIBE %s' % (tableName)) return True except ProgrammingError, e: if e.code == 1146: # ER_NO_SUCH_T... |
def _iterSelect(self, conn, select, withConnection=None, keepConnection=False): cursor = conn.cursor() query = self.queryForSelect(select) if self.debug: self.printDebug(conn, query, 'Select') cursor.execute(query) while 1: result = cursor.fetchone() if result is None: if not keepConnection: self.releaseConnection(conn... | def _iterSelect(self, conn, select, withConnection=None, keepConnection=False): cursor = conn.cursor() query = self.queryForSelect(select) if self.debug: self.printDebug(conn, query, 'Select') cursor.execute(query) while 1: result = cursor.fetchone() if result is None: if not keepConnection: self.releaseConnection(conn... | |
return self._runWithConnection(self._iterSelect, select, self, False) | return Iteration(self, self.getConnection(), select, keepConnection=False) | def iterSelect(self, select): return self._runWithConnection(self._iterSelect, select, self, False) |
return self._dbConnection._iterSelect( self._connection, select, withConnection=self, keepConnection=True) | return Iteration(self, self._connection, select, keepConnection=True) | def iterSelect(self, select): # @@: Bad stuff here, because the connection will be used # until the iteration is over, or at least a cursor from # the connection, which not all database drivers support. return self._dbConnection._iterSelect( self._connection, select, withConnection=self, keepConnection=True) |
value.setName(attr) | value.name = attr | def __new__(cls, className, bases, d): |
value.setName(attr) | value.joinMethodName = attr | def __new__(cls, className, bases, d): |
for column in newClass._columns[:]: | for column in newClass._columns: if d.has_key(column.name) and d[column.name] is None: newClass._columns.remove(column) for column in newClass._columns: | def __new__(cls, className, bases, d): |
if isinstance(id, long): id = int(id) | id = cls._idType(id) | def get(cls, id, connection=None, selectResults=None): |
getter = eval('lambda self: self._SO_foreignKey(self.%s, self._SO_class_%s)' % (instanceName(name), column.foreignKey)) | getter = eval('lambda self: self._SO_foreignKey(self._SO_loadValue(%r), self._SO_class_%s)' % (instanceName(name), column.foreignKey)) | def addColumn(cls, columnDef, changeSchema=False): column = columnDef.withClass(cls) name = column.name assert name != 'id', "The 'id' column is implicit, and should not be defined as a column" cls._SO_columnDict[name] = column cls._SO_columns.append(column) |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.