cmt2cmake.Project Class Reference

Inheritance diagram for cmt2cmake.Project:

Collaboration diagram for cmt2cmake.Project:

Public Member Functions
def	__init__

def	packages

def	container

def	name

def	version

def	uses

def	heptools

def	data_packages

def	generate

def	generateToolchain

def	process

Public Attributes
	path

	requirements

Private Attributes
	_packages

	_container

Detailed Description

Definition at line 733 of file cmt2cmake.py.

Constructor & Destructor Documentation

def cmt2cmake.Project.__init__	(	self,
		path
	)

Create a project instance from the root directory of the project.

Definition at line 734 of file cmt2cmake.py.

 
     def __init__(self, path):
         """
         Create a project instance from the root directory of the project.
         """
         self.path = os.path.realpath(path)
         if not isProject(self.path):
             raise ValueError("%s is not a project" % self.path)
         self.requirements = os.path.join(self.path, "cmt", "project.cmt")
         # Private variables for cached properties
         self._packages = None
         self._container = None

Member Function Documentation

def cmt2cmake.Project.container ( self )

Name of the container package of the project.

The name of the container is deduced using the usual LHCb convention
(instead of the content of project.cmt).

Definition at line 762 of file cmt2cmake.py.

 
     def container(self):
         """
         Name of the container package of the project.
 
         The name of the container is deduced using the usual LHCb convention
         (instead of the content of project.cmt).
         """
         if self._container is None:
             for suffix in ["Release", "Sys"]:
                 try:
                     # gets the first package that ends with the suffix, and does
                     # not have a hat.. or raise StopIteration
                     c = (p for p in self.packages
                          if p.endswith(suffix) and "/" not in p).next()
                     self._container = self.packages[c]
                     break
                 except StopIteration:
                     pass
         return self._container

def cmt2cmake.Project.data_packages ( self )

Return the list of data packages used by this project (i.e. by all the
packages in this project) in the form of a dictionary
{name: version_pattern}.

Definition at line 831 of file cmt2cmake.py.

 
     def data_packages(self):
         '''
         Return the list of data packages used by this project (i.e. by all the
         packages in this project) in the form of a dictionary
         {name: version_pattern}.
         '''
         # for debugging we map
         def appendDict(d, kv):
             '''
             helper function to extend a dictionary of lists
             '''
             k, v = kv
             if k in d:
                 d[k].append(v)
             else:
                 d[k] = [v]
             return d
         # dictionary {"data_package": ("user_package", "data_pkg_version")}
         dp2pkg = {}
         for pkgname, pkg in self.packages.items():
             for dpname, dpversion in pkg.data_packages.items():
                 appendDict(dp2pkg, (dpname, (pkgname, dpversion)))
 
         # check and collect the data packages
         result = {}
         for dp in sorted(dp2pkg):
             versions = set([v for _, v in dp2pkg[dp]])
             if versions:
                 version = sorted(versions)[-1]
             else:
                 version = '*'
             if len(versions) != 1:
                 logging.warning('Different versions for data package %s, using %s from %s', dp, version, dp2pkg[dp])
             result[dp] = version
 
         return result

def cmt2cmake.Project.generate ( self )

Definition at line 868 of file cmt2cmake.py.

 
     def generate(self):
         # list containing the lines to write to the file
         data = ["CMAKE_MINIMUM_REQUIRED(VERSION 2.8.5)",
                 "",
                 "#---------------------------------------------------------------",
                 "# Load macros and functions for Gaudi-based projects",
                 "find_package(GaudiProject)",
                 "#---------------------------------------------------------------",
                 "",
                 "# Declare project name and version"]
         l = "gaudi_project(%s %s" % (self.name, self.version)
         use = "\n                  ".join(["%s %s" % u for u in self.uses()])
         if use:
             l += "\n              USE " + use
         # collect data packages
         data_pkgs = []
         for p, v in sorted(self.data_packages.items()):
             if v in ('v*', '*'):
                 data_pkgs.append(p)
             else:
                 data_pkgs.append("%s VERSION %s" % (p, v))
         if data_pkgs:
             l += ("\n              DATA " +
                   "\n                   ".join(data_pkgs))
         l += ")"
         data.append(l)
         return "\n".join(data) + "\n"

def cmt2cmake.Project.generateToolchain ( self )

Definition at line 896 of file cmt2cmake.py.

 
     def generateToolchain(self):
         heptools_version = self.heptools()
         if heptools_version:
             return toolchain_template.format(heptools_version)
         return None

def cmt2cmake.Project.heptools ( self )

Return the version of heptools (LCGCMT) used by this project.

Definition at line 798 of file cmt2cmake.py.

 
     def heptools(self):
         '''
         Return the version of heptools (LCGCMT) used by this project.
         '''
 
         def updateCache(value):
             '''
             helper function to update the cache and return the value
             '''
             k = repr((self.name, self.version))
             d = cache.get(k, {})
             d['heptools'] = value
             cache[k] = d
             return value
 
         # check for a direct dependency
         exp = re.compile(r'^\s*use\s+LCGCMT\s+LCGCMT[_-](\S+)')
         for l in open(self.requirements):
             m = exp.match(l)
             if m:
                 return updateCache(m.group(1))
 
         # try with the projects we use (in the cache),
         # including ourselves (we may already be there)
         for u in list(self.uses()) + [(self.name, self.version)]:
             u = repr(u)
             if u in cache and 'heptools' in cache[u]:
                 return updateCache(cache[u]['heptools'])
 
         # we cannot guess the version of heptools
         return None

def cmt2cmake.Project.name ( self )

Definition at line 783 of file cmt2cmake.py.

 
     def name(self):
         # The name of the project is the same of the container without
         # the 'Release' or 'Sys' suffixes.
         return self.container.name.replace("Release", "").replace("Sys", "")

def cmt2cmake.Project.packages ( self )

Dictionary of packages contained in the project.

Definition at line 747 of file cmt2cmake.py.

 
     def packages(self):
         """
         Dictionary of packages contained in the project.
         """
         if self._packages is None:
             self._packages = {}
             for root, dirs, _files in os.walk(self.path):
                 if isPackage(root):
                     p = Package(root, self)
                     name = os.path.relpath(p.path, self.path)
                     self._packages[name] = p
                     dirs[:] = []
         return self._packages

def cmt2cmake.Project.process	(	self,
		overwrite = `None`
	)

Definition at line 902 of file cmt2cmake.py.

 
     def process(self, overwrite=None):
         # Prepare the project configuration
         def produceFile(name, generator):
             cml = os.path.join(self.path, name)
             if ((overwrite == 'force')
                 or (not os.path.exists(cml))
                 or ((overwrite == 'update')
                     and (os.path.getmtime(cml) < os.path.getmtime(self.requirements)))):
                 # write the file
                 data = generator()
                 if data:
                     writeToFile(cml, data, logging)
                 else:
                     logging.info("file %s not generated (empty)", cml)
             else:
                 logging.warning("file %s already exists", cml)
 
         produceFile("CMakeLists.txt", self.generate)
         produceFile("toolchain.cmake", self.generateToolchain)
 
         # Recurse in the packages
         for p in sorted(self.packages):
             self.packages[p].process(overwrite)
 

def cmt2cmake.Project.uses ( self )

Definition at line 792 of file cmt2cmake.py.

 
     def uses(self):
         for l in open(self.requirements):
             l = l.split()
             if l and l[0] == "use" and l[1] != "LCGCMT" and len(l) == 3:
                 yield (projectCase(l[1]), l[2].rsplit('_', 1)[-1])

Gaudi Framework, version v23r6

Public Member Functions

Public Attributes

Private Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation