Reference Manual

All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Pages

Functions
def	bsBugFix

def	costumFormatter

def	fillContentTemplate

def	generateTree

def	generateTreeViewPage

def	getClasses

def	getFiles

def	getPackages

def	prepareTemplate

Variables
tuple	classes = getClasses("%s/classes.html" % htmlFilePath)

	cmsswVersion = None

	contentTmpl = None

	contentTmplOrg = None

	data = None

string	dataSrc = 'http://cmsdoxy.web.cern.ch/cmsdoxy/cmssw/'

tuple	file = file.replace('.h', '')

tuple	files = getFiles("%s/files.html" % htmlFilePath)

tuple	fName = domain.replace(' ', '')

string	githubBase = 'https://github.com/cms-sw/cmssw/tree/{0}/{1}'

	htmlFileName = None

	htmlFilePath = None

	htmlFullPath = None

	htmlPage = None

tuple	link = githubBase.format(cmsswVersion, '%s/%s'%(l1,l2))

int	loopLimit = loopLimit-1

tuple	packages = getPackages('%s/pages.html' % htmlFilePath)

tuple	page = generateTreeViewPage(tree[domain], domain)

int	successFlag = 3

tuple	tree = copy.copy(data['CMSSW_CATEGORIES'])

	treeViewTmpl = None

Function Documentation

def MainPageGenerator.bsBugFix ( )

Definition at line 125 of file MainPageGenerator.py.

 
 def bsBugFix():
     # this function fixes script tag bug of beautifulsoup (bs). bs is escaping
     # javascript operators according to the html escape characters, such as
     # > -> "&gt;". The method to ged rid of this issue is to replace script
     # tags with their original versions in the string level
     html = str(htmlPage)
     for scriptTag in BeautifulSoup(contentTmplOrg).findAll('script'):
         js = scriptTag.text
         html = html.replace(str(scriptTag), '<script>%s</script>' % js)
     return html

BeautifulSoup.BeautifulSoup

Definition: BeautifulSoup.py:1470

MainPageGenerator.bsBugFix

def bsBugFix

Definition: MainPageGenerator.py:125

def MainPageGenerator.costumFormatter ( inp )

Definition at line 121 of file MainPageGenerator.py.

 
 def costumFormatter(inp):
     if inp.find_parent("script") is None: return EntitySubstitution.substitute_html(inp) 
     else: return inp

MainPageGenerator.costumFormatter

def costumFormatter

Definition: MainPageGenerator.py:121

def MainPageGenerator.fillContentTemplate ( domains )

Definition at line 136 of file MainPageGenerator.py.

References bitset_utilities.append(), and relativeConstraints.keys.

 
 def fillContentTemplate(domains):
     rows = ''
     rowTmpl = '<tr id="{0}"><td width="50%">{1}</td><td>{2}</td></tr>'
     aTmpl = """<tr style="padding:0"><td colspan="2" style="padding:0">
                <div class="accordion" id="{0}">
                <iframe width="100%" height="250px" frameborder="0" 
                data-src="iframes/{0}.html"> </iframe>
                </div></td></tr>"""
     domainNames = domains.keys()
     domainNames.sort()
     for domain in domainNames:
         persons = domains[domain].keys()
         persons.sort() 
         cCell = ''
         for person in persons:
             email = domains[domain][person]
             cCell = cCell+'<a href="mailto:{0}">{0}<a/>, '.format(person,email)
         cCell = cCell.rstrip(', ')
         escapedDomainName = domain.replace(' ', '')
         rows  = rows + rowTmpl.format(escapedDomainName, domain, cCell)
         rows  = rows + aTmpl.format(escapedDomainName)
     contentTmpl.find('table').append(BeautifulSoup(rows))
     # put cmssw version
     contentTmpl.find('h2', {'id' : 'version'}).append(cmsswVersion)
     content = htmlPage.find('div', {'class' : 'contents'})
     content.append(contentTmpl)

bitset_utilities::append

boost::dynamic_bitset append(const boost::dynamic_bitset<> &bs1, const boost::dynamic_bitset<> &bs2)

this method takes two bitsets bs1 and bs2 and returns result of bs2 appended to the end of bs1 ...

Definition: bitset_append.cc:10

MainPageGenerator.fillContentTemplate

def fillContentTemplate

Definition: MainPageGenerator.py:136

BeautifulSoup.BeautifulSoup

Definition: BeautifulSoup.py:1470

format

relativeConstraints.keys

tuple keys

Definition: relativeConstraints.py:88

def MainPageGenerator.generateTree ( tree )

Definition at line 163 of file MainPageGenerator.py.

Referenced by generateTreeViewPage().

 
 def generateTree(tree):
     if type(tree) == dict and len(tree) == 0: return BeautifulSoup('')
     # our recursive function to generate domain tree views
     root = BeautifulSoup('<ul></ul>')
     names = tree.keys(); names.sort()
     for name in names:
         node = BeautifulSoup('<li><div></div></li>')
         if type(tree[name]) == dict:
             title = BeautifulSoup('<span class="folder"></span>')
             title.span.append(name)
             node.li.append(title)
             # __git__ and __packageDoc__ are special keys which address links,
             # github and packade documentation links. please see in the section
             # that we merge all what we have (under the __main__ block)
             for i in ['__git__', '__packageDoc__']:
                 if not i in tree[name]: continue
                 link = BeautifulSoup(' <a></a>')
                 link.a['target'] = '_blank'
                 link.a['href']   = tree[name][i]
                 link.a.append('[%s]' % i.replace('_', ''))
                 del tree[name][i]
                 title.span.append(link)
             if len(tree[name]) == 0:
                 title.span['class'] = 'emptyFolder'
             else: node.li.div['class'] = 'hitarea expandable-hitarea'
             node.li.append(generateTree(tree[name]))
         elif type(tree[name]) == str or type(tree[name]) == unicode:
             link = BeautifulSoup('<a><span class="file"></span></a>')
             link.a['target'] = '_blank'
             link.a['href']   = tree[name]
             link.a.span.append(name)
             node.li.append(link)
         else:
             node.li.append(name)
         root.ul.append(node)
     return root

BeautifulSoup.BeautifulSoup

Definition: BeautifulSoup.py:1470

MainPageGenerator.generateTree

def generateTree

Definition: MainPageGenerator.py:163

def MainPageGenerator.generateTreeViewPage	(	tree,
		name
	)

Definition at line 200 of file MainPageGenerator.py.

References generateTree().

 
 def generateTreeViewPage(tree, name):
     page = BeautifulSoup(treeViewTmpl)
     treeTag = page.find('ul', {'id' : 'browser'})
     treeTag.append(generateTree(tree))
     twikiLink = page.find('a', {'id' : 'twiki'})
     if name in data['TWIKI_PAGES']:
         twikiLink['href'] = data['TWIKI_PAGES'][name]
     else:
         twikiLink.extract()
     return page
     

MainPageGenerator.generateTreeViewPage

def generateTreeViewPage

Definition: MainPageGenerator.py:200

BeautifulSoup.BeautifulSoup

Definition: BeautifulSoup.py:1470

MainPageGenerator.generateTree

def generateTree

Definition: MainPageGenerator.py:163

def MainPageGenerator.getClasses ( classesPagePath )

Definition at line 99 of file MainPageGenerator.py.

 
 def getClasses(classesPagePath):
     data = {}
     with open(classesPagePath) as f: page = f.read()
     page  = BeautifulSoup(page)
     content = page.find('div', {'class' : 'contents'})
     for cell in content.findAll('td'):
         aTag = cell.find('a')
         if not aTag or not aTag.has_key('href'): continue
         data[aTag.text] = '../' + aTag['href']
     return data

BeautifulSoup.BeautifulSoup

Definition: BeautifulSoup.py:1470

MainPageGenerator.getClasses

def getClasses

Definition: MainPageGenerator.py:99

def MainPageGenerator.getFiles ( filesPagePath )

Definition at line 40 of file MainPageGenerator.py.

 
 def getFiles(filesPagePath):
     data = {}
     # read and parse files.html to get the file hierarchy
     with open(filesPagePath) as f: page = f.read()
     page = BeautifulSoup(page)
     # please have a look at the files.html page to understand the approach.
     # in short, we use number of '_' character in the id attr to read the
     # file hierarchy.
     table     = page.find('table', {'class' : 'directory'})
     level     = 0
     path      = []
     for row in table.findAll('tr'):
         # first cell is the cell where the info is stored
         id   = row['id']; cell = row.find('td') 
         text = cell.text; url  = '../' + cell.find('a')['href']
         currentLevel = id.count('_')
         # if current level is more than old one, push current item
         if currentLevel > level:
             path.append(text)
         # if current level equals to old one, pop anmd push (replace)
         elif currentLevel == level:
             path.pop(len(path) - 1)
             path.append(text)
         else:
         # if current level is less than old one, pop all items to blance
         # the level. 'plus one' in the loop is to replace last item
             for i in range(level - currentLevel + 1):
                 path.pop(len(path) - 1)
             path.append(text)
         level = id.count('_')
         # skip files which are not interface
         if not 'interface' in path: continue
         # no need to have 'interface' node on the tree
         pathWithoutInterface = copy.copy(path)
         pathWithoutInterface.remove('interface')
         # conver the path into tree structure
         node = data
         for i in pathWithoutInterface:
             if not node.has_key(i):
                 node[i] = {}
             node = node[i]
     return data

MainPageGenerator.getFiles

def getFiles

Definition: MainPageGenerator.py:40

BeautifulSoup.BeautifulSoup

Definition: BeautifulSoup.py:1470

def MainPageGenerator.getPackages ( packagesPagePath )

Definition at line 83 of file MainPageGenerator.py.

References split.

 
 def getPackages(packagesPagePath):
     data = {}
     with open(packagesPagePath) as f: page = f.read()
     page  = BeautifulSoup(page)
     table = page.find('table', {'class' : 'directory'})
     for row in table.findAll('tr'):
         cell = row.find('td')
         url  = '../' + cell.find('a')['href']
         # yeah, it is not that good method to parse a string but it is
         # simple... please see the pages.html file.
         pkg = cell.text.replace('Package ', '').split('/')
         if not data.has_key(pkg[0]): data[pkg[0]] = {}
         if len(pkg) == 2: data[pkg[0]][pkg[1]] = url
         else: data[pkg[0]][pkg[0]] = url
     return data

MainPageGenerator.getPackages

def getPackages

Definition: MainPageGenerator.py:83

BeautifulSoup.BeautifulSoup

Definition: BeautifulSoup.py:1470

split

double split

Definition: MVATrainer.cc:139

def MainPageGenerator.prepareTemplate ( )

Definition at line 110 of file MainPageGenerator.py.

 
 def prepareTemplate():
     # please notice the following hard coded tags and class names, you may need
     # to change them in future if doxygen changes its html output structure
     header  = htmlPage.find('div', {'class' : 'header'})
     content = htmlPage.find('div', {'class' : 'contents'})
 
     for tag in header.findAll():
         tag.extract()
     for tag in content.findAll():
         tag.extract()