1 # Copyright (C) 2009-2019 EDF R&D
3 # This library is free software; you can redistribute it and/or
4 # modify it under the terms of the GNU Lesser General Public
5 # License as published by the Free Software Foundation; either
6 # version 2.1 of the License, or (at your option) any later version.
8 # This library is distributed in the hope that it will be useful,
9 # but WITHOUT ANY WARRANTY; without even the implied warranty of
10 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
11 # Lesser General Public License for more details.
13 # You should have received a copy of the GNU Lesser General Public
14 # License along with this library; if not, write to the Free Software
15 # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17 # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
21 Module that defines CPPComponent for SALOME components implemented in C++
25 from module_generator.gener import Component, Invalid
26 from module_generator.cpp_tmpl import initService, cxxService, hxxCompo, cxxCompo
27 from module_generator.cpp_tmpl import exeCPP, cmake_src_compo_cpp
28 from module_generator.yacstypes import corba_rtn_type, corba_in_type
29 from module_generator import mpi_tmpl
30 from module_generator.cppcompo import CPPComponent
33 from string import Template
35 from module_generator.compat import Template,set
37 class MPIComponent(CPPComponent):
39 A :class:`MPIComponent` instance represents a C++ SALOME component with services given as a list of :class:`Service`
40 instances with the parameter *services*.
42 :param name: gives the name of the component.
44 :param services: the list of services (:class:`Service`) of the component.
45 :param kind: For this type of component, "lib" is the unique valid option. The component is built as a dynamic library.
46 :param libs: list of the additional libraries. see *Library* class.
47 If you want to add "libmylib.so", installed in "/path/to/lib" you should use:
48 libs=[Library(name="mylib", path="/path/to/lib")]
49 For more advanced features, see the documentation of cmake / FIND_LIBRARY
50 :param rlibs: space-separated list specifying the rpath to use in installed targets
51 :param includes: additional include directories, separated by spaces.
52 :param sources: gives all the external source files to add in the compilation step (list of paths).
53 :param exe_path: is only used when kind is "exe" and gives the path to the standalone component.
54 :param compodefs: can be used to add extra definition code in the component for example when using a base class
55 to define the component class by deriving it (see *inheritedclass* parameter)
56 :param inheritedclass: can be used to define a base class for the component. The base class can be defined in external
57 source or with the *compodefs* parameter. The value of the *inheritedclass* parameter is the name of the base class.
58 :param idls: can be used to add extra idl CORBA interfaces to the component. This parameter must gives a list of idl file
59 names that are added into the generated module (idl directory) and compiled with the generated idl of the module.
60 :param interfacedefs: can be used to add idl definitions (or includes of idl files) into the generated idl of the module.
61 :param inheritedinterface: can be used to make the component inherit an extra idl interface that has been included through
62 the *idls* and *interfacedefs* parameters. See the cppgui1 example for how to use these last parameters.
63 :param addedmethods: is a C++ specific parameter that can be used to redefine a component method (DumpPython for example). This
64 parameter is a string that must contain the definition and implementation code of the method. See the cppgui1 example
67 For example, the following call defines a standalone component named "mycompo" with one service s1 (it must have been defined before)::
69 >>> c1 = module_generator.CPPComponent('mycompo', services=[s1,], kind="exe",
70 exe_path="./launch.sh")
72 def __init__(self, name, services=None, libs=[], rlibs="", includes="", kind="lib",
73 exe_path=None, sources=None, inheritedclass="", compodefs="",
74 idls=None,interfacedefs="",inheritedinterface="",addedmethods=""):
75 self.exe_path = exe_path
76 Component.__init__(self, name, services, impl="CPP", libs=libs, rlibs=rlibs,
77 includes=includes, kind=kind, sources=sources,
78 inheritedclass=inheritedclass, compodefs=compodefs, idls=idls,
79 interfacedefs=interfacedefs, inheritedinterface=inheritedinterface,
80 addedmethods=addedmethods)
83 """ validate component definition parameters"""
84 Component.validate(self)
86 if self.kind not in kinds:
87 raise Invalid("kind must be one of %s for component %s" % (kinds,self.name))
89 def libraryName(self):
90 """ Name of the target library
93 if self.kind == "lib":
94 ret = self.name + "Engine"
96 raise Invalid("Invalid kind of component: %s. Supported kinds are 'lib' and 'exe'" % self.name)
99 def makeCompo(self, gen):
100 """generate files for C++ component
102 return a dict where key is the file name and value is the file content
104 (cmake_text, cmake_vars) = self.additionalLibraries()
105 cmake_vars = "${KERNEL_SalomeMPIContainer}\n " + cmake_vars
106 cxxfile = "%s.cxx" % self.name
107 hxxfile = "%s.hxx" % self.name
108 ret = { cxxfile:self.makecxx(gen),
109 hxxfile:self.makehxx(gen)
111 sources = " ".join(map(os.path.basename,self.sources))
112 cmakelist_content = cmake_src_compo_cpp.substitute(
113 module = gen.module.name,
114 component = self.name,
115 componentlib = self.libraryName(),
116 includes = self.includes,
119 find_libs = cmake_text,
120 target_properties = self.targetProperties())
122 ret["CMakeLists.txt"] = cmakelist_content
126 def makeThServiceDeclaration(self, service, module_name):
128 for port in service.inport:
129 name, typ = service.validatePort(port)
130 inputVals.append("%s %s;" % (corba_in_type(typ, module_name), name ))
131 return mpi_tmpl.hxxThreadService.substitute(service=service.name,
132 input_vals="\n".join(inputVals))
134 def makehxx(self, gen):
135 """return a string that is the content of .hxx file
138 compodefs=self.compodefs
139 for serv in self.services:
140 service = " %s %s(" % (corba_rtn_type(serv.ret,gen.module.name),serv.name)
141 service = service+gen.makeArgs(serv)+");"
142 services.append(service)
143 compodefs = compodefs + self.makeThServiceDeclaration(serv,gen.module.name)
145 if self.addedmethods:
146 services.append(self.addedmethods)
147 servicesdef = "\n".join(services)
149 inheritedclass=self.inheritedclass
150 if self.inheritedclass:
151 inheritedclass= " public virtual " + self.inheritedclass + ","
153 return mpi_tmpl.hxxCompo.substitute(component=self.name, module=gen.module.name,
154 servicesdef=servicesdef, inheritedclass=inheritedclass,
157 def makecxx(self, gen):
158 """return a string that is the content of .cxx file
163 for serv in self.services:
164 defs.append(serv.defs)
168 for name, typ in serv.inport:
169 in_vals.append("st->%s = %s;" % (name, name ))
170 call_params.append("st->%s" % name)
172 for name, typ in serv.outport:
173 out_vals.append("%s %s;" % (corba_in_type(typ, gen.module.name), name ))
174 call_params.append(name)
176 service_call = "%s(%s)" % (serv.name, ",".join(call_params))
178 service = mpi_tmpl.cxxService.substitute(module=gen.module.name,
179 component=self.name, service=serv.name,
180 out_vals="\n".join(out_vals),
181 service_call=service_call,
182 in_vals="\n".join(in_vals),
183 parameters=gen.makeArgs(serv),
185 services.append(service)
187 return mpi_tmpl.cxxCompo.substitute(component=self.name,
188 servicesdef="\n".join(defs),
189 servicesimpl="\n".join(services))
191 def getIdlInterfaces(self):
192 services = self.getIdlServices()
193 inheritedinterface=""
194 if self.inheritedinterface:
195 inheritedinterface=self.inheritedinterface+","
196 return mpi_tmpl.interface.substitute(component=self.name,
197 services="\n".join(services),
198 inheritedinterface=inheritedinterface)
200 def getIdlDefs(self):
202 #include "SALOME_MPIObject.idl"
204 if self.interfacedefs:
205 idldefs = idldefs + self.interfacedefs
208 def additionalLibraries(self):
209 cmake_text, cmake_vars = Component.additionalLibraries(self)
210 if "MED" in self.getDependentModules():
211 cmake_vars = cmake_vars + """
212 ${MED_paramedmemcompo}
213 ${MED_paramedcouplingcorba}
215 return cmake_text, cmake_vars