-# Copyright (C) 2009-2013 EDF R&D
+# Copyright (C) 2009-2015 EDF R&D
#
# This library is free software; you can redistribute it and/or
# modify it under the terms of the GNU Lesser General Public
# License as published by the Free Software Foundation; either
-# version 2.1 of the License.
+# version 2.1 of the License, or (at your option) any later version.
#
# This library is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
import os
from gener import Component, Invalid
from cpp_tmpl import initService, cxxService, hxxCompo, cxxCompo
-from cpp_tmpl import exeCPP, compoEXEMakefile, compoMakefile
+from cpp_tmpl import exeCPP, cmake_src_compo_cpp
from yacstypes import corba_rtn_type
+try:
+ from string import Template
+except:
+ from compat import Template,set
+
class CPPComponent(Component):
"""
A :class:`CPPComponent` instance represents a C++ SALOME component with services given as a list of :class:`Service`
:param services: the list of services (:class:`Service`) of the component.
:param kind: If it is given and has the value "exe", the component will be built as a standalone
component (executable or shell script). The default is to build the component as a dynamic library.
- :param libs: gives all the libraries options to add when linking the generated component (-L...).
- :param rlibs: gives all the runtime libraries options to add when linking the generated component (-R...).
- :param includes: gives all the include options to add when compiling the generated component (-I...).
+ :param libs: list of the additional libraries. see *Library* class.
+ If you want to add "libmylib.so", installed in "/path/to/lib" you should use:
+ libs=[Library(name="mylib", path="/path/to/lib")]
+ For more advanced features, see the documentation of cmake / FIND_LIBRARY
+ :param rlibs: space-separated list specifying the rpath to use in installed targets
+ :param includes: additional include directories, separated by spaces.
:param sources: gives all the external source files to add in the compilation step (list of paths).
:param exe_path: is only used when kind is "exe" and gives the path to the standalone component.
:param compodefs: can be used to add extra definition code in the component for example when using a base class
:param interfacedefs: can be used to add idl definitions (or includes of idl files) into the generated idl of the module.
:param inheritedinterface: can be used to make the component inherit an extra idl interface that has been included through
the *idls* and *interfacedefs* parameters. See the cppgui1 example for how to use these last parameters.
- :param addmethods: is a C++ specific parameter that can be used to redefine a component method (DumpPython for example). This
+ :param addedmethods: is a C++ specific parameter that can be used to redefine a component method (DumpPython for example). This
parameter is a string that must contain the definition and implementation code of the method. See the cppgui1 example
for how to use it.
:param calciumextendedinterface: if you want to use the Calcium extended interface for C++ as defined by the header CalciumInterface.hxx
>>> c1 = module_generator.CPPComponent('mycompo', services=[s1,], kind="exe",
exe_path="./launch.sh")
"""
- def __init__(self, name, services=None, libs="", rlibs="", includes="", kind="lib",
+ def __init__(self, name, services=None, libs=[], rlibs="", includes="", kind="lib",
exe_path=None, sources=None, inheritedclass="", compodefs="",
idls=None,interfacedefs="",inheritedinterface="",addedmethods="",
calciumextendedinterface=0):
if not self.exe_path:
raise Invalid("exe_path must be defined for component %s" % self.name)
+ def targetProperties(self):
+ """ define the rpath property of the target using self.rlibs
+ return
+ string containing the commands to add to cmake
+ """
+ text=""
+ if self.rlibs.strip() :
+ text="SET_TARGET_PROPERTIES( %sEngine PROPERTIES INSTALL_RPATH %s)\n" % (self.name, self.rlibs)
+ return text
+
+ def libraryName(self):
+ """ Name of the target library
+ """
+ ret=""
+ if self.kind == "lib":
+ ret = self.name + "Engine"
+ elif self.kind == "exe":
+ ret = self.name + "Exelib"
+ else:
+ raise Invalid("Invalid kind of component: %s. Supported kinds are 'lib' and 'exe'" % self.name)
+ return ret
+
def makeCompo(self, gen):
"""generate files for C++ component
- return a dict where key is the file name and value is the content of the file
+ return a dict where key is the file name and value is the file content
"""
+ (cmake_text, cmake_vars) = self.additionalLibraries()
+ # DSC_libs are needed for datastream ports only
+ DSC_libs = """${KERNEL_SalomeDSCContainer}
+ ${KERNEL_SalomeDSCSuperv}
+ ${KERNEL_SalomeDatastream}
+ ${KERNEL_SalomeDSCSupervBasic}
+ ${KERNEL_CalciumC}
+ """
+ cmake_vars = DSC_libs + cmake_vars
cxxfile = "%s.cxx" % self.name
hxxfile = "%s.hxx" % self.name
- if self.kind == "lib":
- sources = " ".join(map(os.path.basename,self.sources))
- return {"Makefile.am":gen.makeMakefile(self.getMakefileItems(gen)),
- cxxfile:self.makecxx(gen),
- hxxfile:self.makehxx(gen)
- }
if self.kind == "exe":
- return {"Makefile.am":gen.makeMakefile(self.getMakefileItems(gen)),
- self.name+".exe":exeCPP.substitute(compoexe=self.exe_path),
- cxxfile:self.makecxx(gen, 1),
- hxxfile:self.makehxx(gen)
- }
-
- def getMakefileItems(self,gen):
- makefileItems={"header":"""
-include $(top_srcdir)/adm_local/make_common_starter.am
-
-AM_CFLAGS=$(SALOME_INCLUDES) -fexceptions
-"""}
- if self.kind == "lib":
- makefileItems["lib_LTLIBRARIES"]=["lib"+self.name+"Engine.la"]
- makefileItems["salomeinclude_HEADERS"]=[self.name+".hxx"]
- makefileItems["body"]=compoMakefile.substitute(module=gen.module.name,
- component=self.name,
- libs=self.libs,
- rlibs=self.rlibs,
- sources= " ".join(map(os.path.basename,self.sources)),
- includes=self.includes)
- elif self.kind == "exe":
- makefileItems["lib_LTLIBRARIES"]=["lib"+self.name+"Exelib.la"]
- makefileItems["salomeinclude_HEADERS"]=[self.name+".hxx"]
- makefileItems["dist_salomescript_SCRIPTS"]=[self.name+".exe"]
- makefileItems["body"]=compoEXEMakefile.substitute(module=gen.module.name,
- component=self.name,
- libs=self.libs,
- rlibs=self.rlibs,
- includes=self.includes)
- return makefileItems
+ exe_opt = 1
+ else:
+ exe_opt = 0
+ ret = { cxxfile:self.makecxx(gen, exe_opt),
+ hxxfile:self.makehxx(gen)
+ }
+ sources = " ".join(map(os.path.basename,self.sources))
+ cmakelist_content = cmake_src_compo_cpp.substitute(
+ module = gen.module.name,
+ component = self.name,
+ componentlib = self.libraryName(),
+ includes = self.includes,
+ sources = sources,
+ libs = cmake_vars,
+ find_libs = cmake_text,
+ target_properties = self.targetProperties())
+ if self.kind == "exe":
+ exe_file = self.name+".exe"
+ install_commande = "\nINSTALL(PROGRAMS %s DESTINATION ${SALOME_INSTALL_BINS})\n" % exe_file
+ cmakelist_content = cmakelist_content + install_commande
+ ret[exe_file] = exeCPP.substitute(compoexe=self.exe_path)
+ pass
+
+ ret["CMakeLists.txt"] = cmakelist_content
+
+ return ret
def makehxx(self, gen):
"""return a string that is the content of .hxx file
