IceGridXmlGenerator.cpp
Go to the documentation of this file.
1/*
2 * This file is part of ArmarX.
3 *
4 * Copyright (C) 2011-2016, High Performance Humanoid Technologies (H2T), Karlsruhe Institute of Technology (KIT), all rights reserved.
5 *
6 * ArmarX is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License version 2 as
8 * published by the Free Software Foundation.
9 *
10 * ArmarX is distributed in the hope that it will be useful, but
11 * WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
14 *
15 * You should have received a copy of the GNU General Public License
16 * along with this program. If not, see <http://www.gnu.org/licenses/>.
17 *
18 * @package ArmarXCore::core
19 * @author Cedric Seehausen
20 * @date 2016
21 * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
22 * GNU General Public License
23 */
24#include "ArmarXCore/util/ScenarioManagerCommon/generator/IceGridXmlGenerator.h"
25
26#include <fstream>
27#include <sstream>
28
29#include "ArmarXCore/util/ScenarioManagerCommon/parser/DependenciesGenerator.h"
30#include <ArmarXCore/core/IceGridAdmin.h>
31#include <ArmarXCore/core/IceManager.h>
32#include <ArmarXCore/core/exceptions/local/ExpressionException.h>
33#include <ArmarXCore/core/rapidxml/wrapper/RapidXmlReader.h>
34#include <ArmarXCore/core/rapidxml/wrapper/RapidXmlWriter.h>
35#include <ArmarXCore/core/system/ArmarXDataPath.h>
36#include <ArmarXCore/core/system/cmake/CMakePackageFinder.h>
37#include <ArmarXCore/util/ScenarioManagerCommon/executor/IceStatusReader.h>
38
39using namespace ScenarioManager;
40using namespace Generator;
41using namespace armarx;
42
43void
44IceGridXmlGenerator::generateLocalApplication(Data_Structure::ScenarioPtr scenario)
45{
46 RapidXmlWriter writer;
47 RapidXmlWriterNode rootNode = writer.createRootNode("icegrid");
48 CMakePackageFinder finder(scenario->getPackage()->getName());
49
50 RapidXmlWriterNode applicationNode = rootNode.append_node("application");
51 applicationNode.append_attribute("name", scenario->getName());
52 applicationNode.append_attribute("import-default-templates", "true");
53
54 RapidXmlWriterNode includeNode = applicationNode.append_node("include");
55 includeNode.append_attribute(
56 "file", ArmarXDataPath::GetDefaultUserConfigPath() + "/icegrid-sync-variables.icegrid.xml");
57
58 RapidXmlWriterNode variableScenarioDirNode = applicationNode.append_node("variable");
59 variableScenarioDirNode.append_attribute("name", "ARMARX_SCENARIO_DIR");
60 variableScenarioDirNode.append_attribute("value", scenario->getFolder());
61
62 RapidXmlWriterNode variableScenarioDependencyNode = applicationNode.append_node("variable");
63 variableScenarioDependencyNode.append_attribute("name", "ARMARX_SCENARIO_DEPENDENCY_CONFIG");
64 variableScenarioDependencyNode.append_attribute("value", "dependencies.cfg");
65
66 RapidXmlWriterNode variablePackageConfigDir = applicationNode.append_node("variable");
67 variablePackageConfigDir.append_attribute("name", "ARMARX_PACKAGE_CONFIG_DIR");
68 variablePackageConfigDir.append_attribute("value", finder.getConfigDir());
69
70 RapidXmlWriterNode variableArmarXLDPath = applicationNode.append_node("variable");
71 variableArmarXLDPath.append_attribute("name", "ArmarX_LD_LIB_PATH");
72 variableArmarXLDPath.append_attribute("value", "");
73 // variableArmarXLDPath.append_attribute("value", "${ARMARX_SYNC_DIR}/lib:${ARMARX_SYNC_DIR}/usr/lib");
74
75 RapidXmlWriterNode variableArmarXPath = applicationNode.append_node("variable");
76 variableArmarXPath.append_attribute("name", "ArmarX_PATH");
77 variableArmarXPath.append_attribute("value", "");
78 // variableArmarXPath.append_attribute("value", "${ARMARX_SYNC_DIR}/bin:${ARMARX_SYNC_DIR}/usr/bin");
79
80 for (auto dep :
81 Parser::DependenciesGenerator::getDependencieTree(scenario->getPackage()->getName()))
82 {
83 CMakePackageFinder currentFinder(dep);
84 RapidXmlWriterNode binDirNode = applicationNode.append_node("variable");
85 binDirNode.append_attribute("name", dep + "_BIN_DIR");
86 binDirNode.append_attribute("value", currentFinder.getBinaryDir());
87 }
88
89 std::map<std::string, RapidXmlWriterNode> existingNodes;
90
91 for (auto app : *scenario->getApplications())
92 {
93 if (!existingNodes.count(app->getEffectiveNodeName()))
94 {
95 RapidXmlWriterNode node = applicationNode.append_node("node");
96 node.append_attribute("name", app->getEffectiveNodeName());
97 existingNodes.insert(make_pair(app->getEffectiveNodeName(), node));
98 }
99
100 generateComponent(app);
101 RapidXmlWriterNode includeAppNode =
102 existingNodes.find(app->getEffectiveNodeName())->second.append_node("include");
103 if (app->getInstanceName().empty())
104 {
105 includeAppNode.append_attribute("file", "icegrid/" + app->getName() + ".icegrid.xml");
106 }
107 else
108 {
109 includeAppNode.append_attribute("file",
110 "icegrid/" + app->getName() + "." +
111 app->getInstanceName() + ".icegrid.xml");
112 }
113 }
114
115 writer.saveToFile(scenario->getFolder() + "/" + scenario->getName() + ".icegrid.xml", true);
116}
117
118void
119IceGridXmlGenerator::generateRemoteApplication(Data_Structure::ScenarioPtr scenario)
120{
121 RapidXmlWriter writer;
122 RapidXmlWriterNode rootNode = writer.createRootNode("icegrid");
123 CMakePackageFinder finder(scenario->getPackage()->getName());
124
125 RapidXmlWriterNode applicationNode = rootNode.append_node("application");
126 applicationNode.append_attribute("name", scenario->getName());
127 applicationNode.append_attribute("import-default-templates", "true");
128
129 RapidXmlWriterNode includeNode = applicationNode.append_node("include");
130 includeNode.append_attribute(
131 "file", ArmarXDataPath::GetDefaultUserConfigPath() + "/icegrid-sync-variables.icegrid.xml");
132
133 RapidXmlWriterNode variableScenarioDirNode = applicationNode.append_node("variable");
134 variableScenarioDirNode.append_attribute("name", "ARMARX_SCENARIO_DIR");
135 variableScenarioDirNode.append_attribute("value",
136 "${ARMARX_SYNC_DIR}/share/" +
137 scenario->getPackage()->getName() + "/scenarios/" +
138 scenario->getName());
139
140 RapidXmlWriterNode variableScenarioDependencyNode = applicationNode.append_node("variable");
141 variableScenarioDependencyNode.append_attribute("name", "ARMARX_SCENARIO_DEPENDENCY_CONFIG");
142 variableScenarioDependencyNode.append_attribute("value", "dependencies.remote.cfg");
143
144 RapidXmlWriterNode variablePackageConfigDir = applicationNode.append_node("variable");
145 variablePackageConfigDir.append_attribute("name", "ARMARX_PACKAGE_CONFIG_DIR");
146 variablePackageConfigDir.append_attribute(
147 "value", "${ARMARX_SYNC_DIR}/share/" + scenario->getPackage()->getName() + "/config");
148
149 RapidXmlWriterNode variableArmarXLDPath = applicationNode.append_node("variable");
150 variableArmarXLDPath.append_attribute("name", "ArmarX_LD_LIB_PATH");
151 variableArmarXLDPath.append_attribute("value", "${ARMARX_SYNC_DIR}/lib");
152
153 RapidXmlWriterNode variableArmarXPath = applicationNode.append_node("variable");
154 variableArmarXPath.append_attribute("name", "ArmarX_PATH");
155 variableArmarXPath.append_attribute("value", "");
156 // variableArmarXPath.append_attribute("value", "${ARMARX_SYNC_DIR}/bin:${ARMARX_SYNC_DIR}/usr/bin");
157
158 for (auto dep :
159 Parser::DependenciesGenerator::getDependencieTree(scenario->getPackage()->getName()))
160 {
161 RapidXmlWriterNode binDirNode = applicationNode.append_node("variable");
162 binDirNode.append_attribute("name", dep + "_BIN_DIR");
163 binDirNode.append_attribute("value", "${ARMARX_SYNC_DIR}/bin");
164 }
165
166 std::map<std::string, RapidXmlWriterNode> existingNodes;
167
168 for (auto app : *scenario->getApplications())
169 {
170 if (!existingNodes.count(app->getEffectiveNodeName()))
171 {
172 RapidXmlWriterNode node = applicationNode.append_node("node");
173 node.append_attribute("name", app->getEffectiveNodeName());
174 existingNodes.insert(make_pair(app->getEffectiveNodeName(), node));
175 }
176
177 generateComponent(app);
178 RapidXmlWriterNode includeAppNode =
179 existingNodes.find(app->getEffectiveNodeName())->second.append_node("include");
180 if (app->getInstanceName().empty())
181 {
182 includeAppNode.append_attribute("file", "icegrid/" + app->getName() + ".icegrid.xml");
183 }
184 else
185 {
186 includeAppNode.append_attribute("file",
187 "icegrid/" + app->getName() + "." +
188 app->getInstanceName() + ".icegrid.xml");
189 }
190 }
191
192 writer.saveToFile(scenario->getFolder() + "/" + scenario->getName() + ".remote.icegrid.xml",
193 true);
194}
195
196void
197IceGridXmlGenerator::generateComponent(Data_Structure::ApplicationInstancePtr app)
198{
199 RapidXmlWriter writer;
200 RapidXmlWriterNode rootNode = writer.createRootNode("icegrid");
201
202 RapidXmlWriterNode applicationNode = rootNode.append_node("server-instance");
203 applicationNode.append_attribute("template", "ArmarXComponentTemplate");
204 applicationNode.append_attribute("component", app->getName());
205 applicationNode.append_attribute("componentId", Exec::IceStatusReader::GetApplicationId(app));
206 applicationNode.append_attribute("componentExeDir", "${" + app->getPackageName() + "_BIN_DIR}");
207 applicationNode.append_attribute("configDomain", app->getConfigDomain());
208
209 std::string armarXConfigValue =
210 (app->getScenario()->isGlobalConfigFileexistent()
211 ? app->getScenario()->getGlobalConfigPath() + ","
212 : "") +
213 (app->getInstanceName().empty() ? "${ARMARX_SCENARIO_DIR}/config/" + app->getName() + ".cfg"
214 : "${ARMARX_SCENARIO_DIR}/config/" + app->getName() + "." +
215 app->getInstanceName() + ".cfg");
216
217 applicationNode.append_attribute("ArmarXConfig", armarXConfigValue);
218
219
220 // if (app->getInstanceName().empty())
221 // {
222 // armarXConfigValue
223 // applicationNode.append_attribute("ArmarXConfig", "${ARMARX_SCENARIO_DIR}/config/global.cfg,${ARMARX_SCENARIO_DIR}/config/" + app->getName() + ".cfg");
224 // }
225 // else
226 // {
227 // applicationNode.append_attribute("ArmarXConfig", "${ARMARX_SCENARIO_DIR}/config/global.cfg,${ARMARX_SCENARIO_DIR}/config/" + app->getName() + "." + app->getInstanceName() + ".cfg");
228 // }
229
230 applicationNode.append_attribute(
231 "ArmarXDependenciesConfig",
232 "${ARMARX_PACKAGE_CONFIG_DIR}/${ARMARX_SCENARIO_DEPENDENCY_CONFIG}");
233 applicationNode.append_attribute("ArmarXLoggingGroup", app->getScenario()->getName());
234
235 std::filesystem::create_directory(app->getScenario()->getFolder() + "/icegrid");
236 if (app->getInstanceName().empty())
237 {
238 writer.saveToFile(
239 app->getScenario()->getFolder() + "/icegrid/" + app->getName() + ".icegrid.xml", true);
240 }
241 else
242 {
243 writer.saveToFile(app->getScenario()->getFolder() + "/icegrid/" + app->getName() + "." +
244 app->getInstanceName() + ".icegrid.xml",
245 true);
246 }
247}
248
249IceGrid::ApplicationDescriptor
250IceGridXmlGenerator::generateEmptyLocalApplicationDescriptor(Data_Structure::ScenarioPtr scenario,
251 const IceGrid::AdminPrx iceAdmin)
252{
253 CMakePackageFinder finder(scenario->getPackage()->getName());
254
255 IceGrid::ApplicationDescriptor result;
256 result.name = scenario->getName();
257
258 IceGrid::StringStringDict variables;
259 variables["ARMARX_SYNC_DIR"] = getDefaultSyncFile();
260 variables["ARMARX_SCENARIO_DIR"] = scenario->getFolder();
261 variables["ARMARX_SCENARIO_DEPENDENCY_CONFIG"] = "dependencies.cfg";
262 variables["ARMARX_PACKAGE_CONFIG_DIR"] = finder.getConfigDir();
263 variables["ArmarX_LD_LIB_PATH"] = ""; //"${ARMARX_SYNC_DIR}/lib:${ARMARX_SYNC_DIR}/usr/lib";
264 variables["ArmarX_PATH"] = ""; //"${ARMARX_SYNC_DIR}/bin:${ARMARX_SYNC_DIR}/usr/bin";
265 variables["ARMARX_LOGGING_GROUP"] = scenario->getName();
266
267 for (auto dep :
268 Parser::DependenciesGenerator::getDependencieTree(scenario->getPackage()->getName()))
269 {
270 CMakePackageFinder currentFinder(dep);
271 variables[dep + "_BIN_DIR"] = currentFinder.getBinaryDir();
272 }
273
274 result.variables = variables;
275
276 IceGrid::ApplicationDescriptor defaultDesc = iceAdmin->getDefaultApplicationDescriptor();
277 result.serverTemplates = defaultDesc.serverTemplates;
278 auto v = IceGrid::ServerDescriptorPtr::dynamicCast(
279 result.serverTemplates["ArmarXComponentTemplate"].descriptor.get());
280 ARMARX_CHECK_EXPRESSION(v);
281
282 result.serviceTemplates = defaultDesc.serviceTemplates;
283
284 return result;
285}
286
287IceGrid::ApplicationDescriptor
288IceGridXmlGenerator::generateLocalApplicationDescriptor(Data_Structure::ScenarioPtr scenario,
289 const IceGrid::AdminPrx iceAdmin)
290{
291 IceGrid::ApplicationDescriptor result =
292 generateEmptyLocalApplicationDescriptor(scenario, iceAdmin);
293
294 for (auto app : *scenario->getApplications())
295 {
296 if (!app->getEnabled())
297 {
298 continue;
299 }
300
301 result.nodes[app->getEffectiveNodeName()].serverInstances.push_back(
302 generateComponentNode(app));
303 }
304
305 return result;
306}
307
308IceGrid::ApplicationDescriptor
309IceGridXmlGenerator::generateEmptyRemoteApplicationDescriptor(Data_Structure::ScenarioPtr scenario,
310 const IceGrid::AdminPrx iceAdmin)
311{
312 IceGrid::ApplicationDescriptor result;
313 result.name = scenario->getName();
314
315 IceGrid::StringStringDict variables;
316 variables["ARMARX_SYNC_DIR"] = getDefaultSyncFile();
317 variables["ARMARX_SCENARIO_DIR"] = "${ARMARX_SYNC_DIR}/share/" +
318 scenario->getPackage()->getName() + "/scenarios/" +
319 scenario->getName();
320 variables["ARMARX_SCENARIO_DEPENDENCY_CONFIG"] = "dependencies.remote.cfg";
321 variables["ARMARX_PACKAGE_CONFIG_DIR"] =
322 "${ARMARX_SYNC_DIR}/share/" + scenario->getPackage()->getName() + "/config";
323 variables["ArmarX_LD_LIB_PATH"] = "${ARMARX_SYNC_DIR}/lib:${ARMARX_SYNC_DIR}/usr/lib";
324 variables["ArmarX_PATH"] = "${ARMARX_SYNC_DIR}/bin:${ARMARX_SYNC_DIR}/usr/bin";
325 variables["ARMARX_LOGGING_GROUP"] = scenario->getName();
326 // variables["CMAKE_PREFIX_PATH"] = "${ARMARX_SYNC_DIR}";
327
328
329 for (auto dep :
330 Parser::DependenciesGenerator::getDependencieTree(scenario->getPackage()->getName()))
331 {
332 variables[dep + "_BIN_DIR"] = "${ARMARX_SYNC_DIR}/bin";
333 }
334
335 result.variables = variables;
336
337 IceGrid::ApplicationDescriptor defaultDesc = iceAdmin->getDefaultApplicationDescriptor();
338 result.serverTemplates = defaultDesc.serverTemplates;
339 auto v = IceGrid::ServerDescriptorPtr::dynamicCast(
340 result.serverTemplates["ArmarXComponentTemplate"].descriptor.get());
341 ARMARX_CHECK_EXPRESSION(v);
342
343
344 result.serviceTemplates = defaultDesc.serviceTemplates;
345
346 return result;
347}
348
349IceGrid::ApplicationDescriptor
350IceGridXmlGenerator::generateRemoteApplicationDescriptor(Data_Structure::ScenarioPtr scenario,
351 const IceGrid::AdminPrx iceAdmin)
352{
353 //CMakePackageFinder finder(scenario->getPackage()->getName());
354
355 IceGrid::ApplicationDescriptor result =
356 generateEmptyRemoteApplicationDescriptor(scenario, iceAdmin);
357
358 for (auto app : *scenario->getApplications())
359 {
360 if (!app->getEnabled())
361 {
362 continue;
363 }
364 result.nodes[app->getEffectiveNodeName()].serverInstances.push_back(
365 generateComponentNode(app));
366 }
367
368 return result;
369}
370
371IceGrid::ServerInstanceDescriptor
372IceGridXmlGenerator::generateComponentNode(Data_Structure::ApplicationInstancePtr app)
373{
374 IceGrid::ServerInstanceDescriptor result;
375 result._cpp_template = "ArmarXComponentTemplate";
376 result.parameterValues["component"] = app->getName();
377 result.parameterValues["componentId"] = Exec::IceStatusReader::GetApplicationId(app);
378 result.parameterValues["componentExeDir"] = "${" + app->getPackageName() + "_BIN_DIR}";
379
380 std::string armarXConfigValue =
381 (app->getScenario()->isGlobalConfigFileexistent()
382 ? app->getScenario()->getGlobalConfigPath() + ","
383 : "") +
384 (app->getInstanceName().empty() ? "${ARMARX_SCENARIO_DIR}/config/" + app->getName() + ".cfg"
385 : "${ARMARX_SCENARIO_DIR}/config/" + app->getName() + "." +
386 app->getInstanceName() + ".cfg");
387
388 result.parameterValues["configDomain"] = app->getConfigDomain();
389 result.parameterValues["ArmarXConfig"] = armarXConfigValue;
390 result.parameterValues["ArmarXDependenciesConfig"] =
391 "${ARMARX_PACKAGE_CONFIG_DIR}/${ARMARX_SCENARIO_DEPENDENCY_CONFIG}";
392 result.parameterValues["ArmarXLoggingGroup"] = app->getScenario()->getName();
393 result.parameterValues["activationTimeout"] = "10";
394
395
396 return result;
397}
398
399std::string
400IceGridXmlGenerator::getSyncDirFromFile(std::string path)
401{
402 RapidXmlReaderPtr doc = RapidXmlReader::FromFile(path);
403 RapidXmlReaderNode rootNode = doc->getRoot();
404 try
405 {
406 return rootNode.first_node("variable").attribute_value("value");
407 }
408 catch (exceptions::local::RapidXmlReaderException& exception)
409 {
410 ARMARX_DEBUG_S << "Your icegrid-sync-variables file is ill formatted (Error: "
411 << exception.what() << ")";
412 return "";
413 }
414}
415
416void
417IceGridXmlGenerator::setDefaultSyncFileDir(std::string path)
418{
419 RapidXmlWriter doc;
420 RapidXmlWriterNode root = doc.createRootNode("icegrid");
421 RapidXmlWriterNode variableNode = root.append_node("variable");
422 variableNode.append_attribute("name", "ARMARX_SYNC_DIR");
423 variableNode.append_attribute("value", path);
424
425 doc.saveToFile(
426 ArmarXDataPath::GetDefaultUserConfigPath() + "/icegrid-sync-variables.icegrid.xml", true);
427}
428
429IceGrid::ApplicationUpdateDescriptor
430IceGridXmlGenerator::generateUpdateDescriptor(IceGrid::ApplicationDescriptor descriptor)
431{
432 IceGrid::ApplicationUpdateDescriptor result;
433 result.name = descriptor.name;
434 //There is currently no simple way to deep copy these constructs so just reuse the needed ones
435 for (auto nodes : descriptor.nodes)
436 {
437 IceGrid::NodeUpdateDescriptor nodeUpdate;
438 nodeUpdate.name = nodes.first;
439 nodeUpdate.serverInstances = nodes.second.serverInstances;
440 //nodeUpdate.description = nodes.second.description;
441 nodeUpdate.propertySets = nodes.second.propertySets;
442 nodeUpdate.serverInstances = nodes.second.serverInstances;
443 nodeUpdate.servers = nodes.second.servers;
444 nodeUpdate.variables = nodes.second.variables;
445 result.nodes.push_back(nodeUpdate);
446 }
447
448 result.serverTemplates = descriptor.serverTemplates;
449 result.serviceTemplates = descriptor.serviceTemplates;
450 result.variables = result.variables;
451
452 return result;
453}
454
455std::string
456IceGridXmlGenerator::getDefaultSyncFile()
457{
458 return getSyncDirFromFile(ArmarXDataPath::GetDefaultUserConfigPath() +
459 "/icegrid-sync-variables.icegrid.xml");
460}
ScenarioManager::Exec::IceStatusReader::GetApplicationId
static std::string GetApplicationId(const ApplicationInstancePtr &application)
Definition IceStatusReader.cpp:15
ScenarioManager::Generator::IceGridXmlGenerator::generateEmptyRemoteApplicationDescriptor
IceGrid::ApplicationDescriptor generateEmptyRemoteApplicationDescriptor(Data_Structure::ScenarioPtr scenario, const IceGrid::AdminPrx iceAdmin)
Definition IceGridXmlGenerator.cpp:309
ScenarioManager::Generator::IceGridXmlGenerator::generateLocalApplicationDescriptor
IceGrid::ApplicationDescriptor generateLocalApplicationDescriptor(Data_Structure::ScenarioPtr scenario, const IceGrid::AdminPrx iceAdmin)
Definition IceGridXmlGenerator.cpp:288
ScenarioManager::Generator::IceGridXmlGenerator::generateUpdateDescriptor
IceGrid::ApplicationUpdateDescriptor generateUpdateDescriptor(IceGrid::ApplicationDescriptor descriptor)
Definition IceGridXmlGenerator.cpp:430
ScenarioManager::Generator::IceGridXmlGenerator::generateComponent
void generateComponent(Data_Structure::ApplicationInstancePtr app)
Definition IceGridXmlGenerator.cpp:197
ScenarioManager::Generator::IceGridXmlGenerator::generateLocalApplication
void generateLocalApplication(Data_Structure::ScenarioPtr scenario)
Definition IceGridXmlGenerator.cpp:44
ScenarioManager::Generator::IceGridXmlGenerator::generateRemoteApplication
void generateRemoteApplication(Data_Structure::ScenarioPtr scenario)
Definition IceGridXmlGenerator.cpp:119
ScenarioManager::Generator::IceGridXmlGenerator::generateEmptyLocalApplicationDescriptor
IceGrid::ApplicationDescriptor generateEmptyLocalApplicationDescriptor(Data_Structure::ScenarioPtr scenario, const IceGrid::AdminPrx iceAdmin)
Definition IceGridXmlGenerator.cpp:250
ScenarioManager::Generator::IceGridXmlGenerator::generateComponentNode
IceGrid::ServerInstanceDescriptor generateComponentNode(Data_Structure::ApplicationInstancePtr app)
Definition IceGridXmlGenerator.cpp:372
ScenarioManager::Generator::IceGridXmlGenerator::generateRemoteApplicationDescriptor
IceGrid::ApplicationDescriptor generateRemoteApplicationDescriptor(Data_Structure::ScenarioPtr scenario, const IceGrid::AdminPrx iceAdmin)
Definition IceGridXmlGenerator.cpp:350
ScenarioManager::Parser::DependenciesGenerator::getDependencieTree
static DependencyTree getDependencieTree(std::string packageName)
Definition DependenciesGenerator.cpp:48
armarx::ArmarXDataPath::GetDefaultUserConfigPath
static std::string GetDefaultUserConfigPath()
The user config directory of ArmarX.
Definition ArmarXDataPath.cpp:777
armarx::CMakePackageFinder
The CMakePackageFinder class provides an interface to the CMake Package finder capabilities.
Definition CMakePackageFinder.h:53
armarx::CMakePackageFinder::getBinaryDir
std::string getBinaryDir() const
Definition CMakePackageFinder.h:174
armarx::CMakePackageFinder::getConfigDir
std::string getConfigDir() const
Returns the path needed to find this package with cmake, i.e.
Definition CMakePackageFinder.h:105
armarx::RapidXmlReaderNode::first_node
RapidXmlReaderNode first_node(const char *name=nullptr) const
Definition RapidXmlReader.h:156
armarx::RapidXmlReaderNode::attribute_value
std::string attribute_value(const char *attrName) const
Definition RapidXmlReader.h:230
armarx::RapidXmlReader::FromFile
static RapidXmlReaderPtr FromFile(const std::string &path)
Definition RapidXmlReader.h:573
armarx::RapidXmlWriterNode::append_node
RapidXmlWriterNode append_node(const std::string &name)
Definition RapidXmlWriter.h:91
armarx::RapidXmlWriterNode::append_attribute
RapidXmlWriterNode & append_attribute(const std::string &name, const std::string &value)
Definition RapidXmlWriter.h:59
armarx::RapidXmlWriter::saveToFile
void saveToFile(const std::string &path, bool indent)
Definition RapidXmlWriter.h:154
armarx::RapidXmlWriter::createRootNode
RapidXmlWriterNode createRootNode(const std::string &name)
Definition RapidXmlWriter.h:137
ARMARX_CHECK_EXPRESSION
#define ARMARX_CHECK_EXPRESSION(expression)
This macro evaluates the expression and if it turns out to be false it will throw an ExpressionExcept...
Definition ExpressionException.h:73
ARMARX_DEBUG_S
#define ARMARX_DEBUG_S
The logging level for output that is only interesting while debugging.
Definition Logging.h:205
ScenarioManager::Data_Structure::ScenarioPtr
std::shared_ptr< Scenario > ScenarioPtr
Definition Scenario.h:35
ScenarioManager::Data_Structure::ApplicationInstancePtr
std::shared_ptr< ApplicationInstance > ApplicationInstancePtr
Definition ApplicationInstance.h:33
armarx
This file offers overloads of toIce() and fromIce() functions for STL container types.
Definition ArmarXTimeserver.cpp:28
armarx::RapidXmlReaderPtr
std::shared_ptr< RapidXmlReader > RapidXmlReaderPtr
Definition RapidXmlReader.h:67