Parsing nested xml with boost - c++

I have an xml which I like to read into my program, I've seen a lot of exmaples how to read xml using property tree from boost, however I couldn't make it work for the nested xml that I have:
<?xml version="1.0" encoding="UTF-8"?>
<document version="1.3.0">
<chunk>
<sensors>
<sensor id="0" label="unknown" type="frame">
<resolution width="2056" height="2464"/>
<property name="fixed" value="0"/>
<calibration type="frame" class="adjusted">
<resolution width="2056" height="2464"/>
<fx>7349.85579147491</fx>
<fy>7349.85579147491</fy>
<cx>1028</cx>
<cy>1232</cy>
<p1>0.000308132854297239</p1>
<p2>-0.000521332855614243</p2>
</calibration>
</sensor>
</sensors>
<cameras>
<camera id="0" label="img0000.png" sensor_id="0" enabled="1">
<transform>1.0000000000000000e+000 0.0000000000000000e+000 0.0000000000000000e+000 0.0000000000000000e+000 0.0000000000000000e+000 -1.0000000000000000e+000 -1.2246467991473532e-016 0.0000000000000000e+000 0.0000000000000000e+000 1.2246467991473532e-016 -1.0000000000000000e+000 0.0000000000000000e+000 0.0000000000000000e+000 0.0000000000000000e+000 0.0000000000000000e+000 1.0000000000000000e+000</transform>
</camera>
<camera id="1" label="img0011.png" sensor_id="0" enabled="1">
<transform>9.8183676675341047e-001 -2.7892274662900951e-002 -1.8766615162393202e-001 1.3502780959894856e+000 -2.8076662610258110e-002 -9.9960436765543659e-001 1.6760611099915072e-003 -8.8020303958543274e-003 -1.8763865398120155e-001 3.6234208013954891e-003 -9.8223144235654503e-001 -1.1015316085201440e-001 0.0000000000000000e+000 0.0000000000000000e+000 0.0000000000000000e+000 1.0000000000000000e+000</transform>
</camera>
</cameras>
<reference>LOCAL_CS["Local Coordinates (m)",LOCAL_DATUM["Local Datum",0],UNIT["metre",1,AUTHORITY["EPSG","9001"]]]</reference>
<region>
<center>-5.1216167685514069e-002 -7.0600760442627708e-001 -6.9904047240845895e+000</center>
<size>2.1074647950629393e+000 1.5533586459855240e+000 1.0253878730038792e+000</size>
<R>-9.6011547075389880e-001 2.7340714563038887e-001 5.8539008680217816e-002 -2.6221584379471408e-001 -9.5313222127937347e-001 1.5093647677772853e-001 9.7062526662174770e-002 1.2956659089939432e-001 9.8680867671533157e-001</R>
</region>
<settings>
<property name="accuracy_tiepoints" value="1"/>
<property name="accuracy_cameras" value="10"/>
<property name="accuracy_cameras_ypr" value="2"/>
<property name="accuracy_markers" value="0.005"/>
<property name="accuracy_scalebars" value="0.001"/>
<property name="accuracy_projections" value="0.1"/>
</settings>
</chunk>
</document>
I'm only interested in reading the cameras node and their attributes, and I've used the following code for that, but it doesn't work:
using namespace std;
using namespace boost;
using namespace boost::property_tree;
const ptree& empty_ptree() {
static ptree t;
return t;
}
int main()
{
ptree tree;
read_xml(XML_PATH1, tree);
tree = tree.get_child("document.chunk", empty_ptree());
const ptree & formats = tree.get_child("cameras.camera", empty_ptree());
BOOST_FOREACH(const ptree::value_type & f, formats)
{
string at = f.first + ".<xmlattr>";
const ptree & attributes = f.second.get_child("<xmlattr>", empty_ptree());
cout << "Extracting attributes from " << at << ":" << endl;
BOOST_FOREACH(const ptree::value_type &v, attributes)
{
cout << "First: " << v.first.data() << " Second: " << v.second.data() << endl;
}
}
}

so, for each camera you want to iterate over each attribute, don't you ?
if yes, then you need to use equal_range() instead of get_child(); the latter returns a single child, the former a range of associative iterators pointing to all childs with the given key.
so, use get_child() to get document.chunk.cameras, use equal_range('camera') to get all cameras and for each camera use equal_range('xmlattr') to traverse its attributes.

Related

boost graph read_graphml read all arbitrary dynamic properties

What I want to do
Read a graphml file with all node and edge properties that exist in the file (arbitraty in type and count)
Operate on the graph
Add additional properties
Write the Graph to a graphml file again
What I have
Not much, but from what I gathered from other posts and the boost documentation:
#include <boost/graph/adjacency_list.hpp>
#include <boost/graph/graphml.hpp>
#include <fstream>
int main(int argc, char const *argv[]) {
auto filename = argv[1];
std::ifstream input_stream;
input_stream.open(filename, std::ifstream::in);
boost::adjacency_list<boost::setS, boost::setS> graph;
boost::dynamic_properties props;
boost::read_graphml(input_stream, graph, props);
input_stream.close();
// do stuff with the graph
// write it out to a file again
return 0;
}
What's wrong
The code above exits with a property_not_found error. The reason is, that the dynamic_properties were created without a generator_fn to dynamically create a property map whenever a previously unknown property is encountered in the file (as far as I understand it, see the free put function in dynamic_property_map.hpp.
Question
How do I create a boost::dynamic_properties object that knows how to create a dynamic map for vertex / edge attributes that are found in the graphml file?
Maybe I don't even understand the use of boost::dynamic_properties correctly, if so, please point me in the right direction.
Note that the easiest is to use the builtin ignore_other_properties:
Live On Coliru
#include <boost/graph/adjacency_list.hpp>
#include <boost/graph/graphml.hpp>
#include <fstream>
int main() {
boost::adjacency_list<> g;
boost::dynamic_properties props(boost::ignore_other_properties);
{
std::ifstream input_stream("input.xml");
read_graphml(input_stream, g, props);
}
write_graphml(std::cout, g, props);
}
Given input xml of
<?xml version="1.0" encoding="UTF-8"?>
<graphml xmlns="http://graphml.graphdrawing.org/xmlns" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://graphml.graphdrawing.org/xmlns http://graphml.graphdrawing.org/xmlns/1.0/graphml.xsd">
<key id="key0" for="node" attr.name="Name" attr.type="string" />
<graph id="G" edgedefault="directed" parse.nodeids="canonical" parse.edgeids="canonical" parse.order="nodesfirst">
<node id="n0">
<data key="key0">A</data>
</node>
<node id="n1">
<data key="key0">D</data>
</node>
<node id="n2">
<data key="key0">B</data>
</node>
<node id="n3">
<data key="key0">C</data>
</node>
<edge id="e0" source="n0" target="n1">
</edge>
<edge id="e1" source="n2" target="n3">
</edge>
</graph>
</graphml>
Prints
<?xml version="1.0" encoding="UTF-8"?>
<graphml xmlns="http://graphml.graphdrawing.org/xmlns" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://graphml.graphdrawing.org/xmlns http://graphml.graphdrawing.org/xmlns/1.0/graphml.xsd">
<graph id="G" edgedefault="directed" parse.nodeids="free" parse.edgeids="canonical" parse.order="nodesfirst">
<node id="n0">
</node>
<node id="n1">
</node>
<node id="n2">
</node>
<node id="n3">
</node>
<edge id="e0" source="n0" target="n1">
</edge>
<edge id="e1" source="n2" target="n3">
</edge>
</graph>
</graphml>
Caveats!
Has a few caveats.
Your graph model is not equipped with storage for any properties, so I'll assume you want them to be external.
Your graph model assumes directionality and also forbids duplicate edges. This may not be what you need.
Graphviz read/write will not roundtrip. That is, comments will be gone, and edges and nodes will have arbitrarily different keys in the ML. Of course, that should in principle not matter a lot, but depending on your expectations/requirements may be a deal breaker.
Your graph model cannot even be written without an external vertex_index property, since your choice for a node-based vertex container (setS) does not have an implicit one.
How Would You Do It?
I'll drop the opinionated setS choice because of the drawbacks listed above. Note that we still assume directionality. I'll leave that for you to "fix".
A search from my existing answers shows how to use dynamic_properties with dynamic maps. Adapting to your question:
Live On Coliru
#include <boost/graph/adjacency_list.hpp>
#include <boost/graph/graphml.hpp>
#include <boost/property_map/function_property_map.hpp>
#include <fstream>
using Attributes = std::map<std::string, std::string>;
using DynMap = boost::shared_ptr<boost::dynamic_property_map>;
using Graph = boost::adjacency_list<>;
using V = Graph::vertex_descriptor;
using E = Graph::edge_descriptor;
static inline auto make_dyn(auto m) -> DynMap {
using DM = boost::detail::dynamic_property_map_adaptor<decltype(m)>;
auto sp = boost::make_shared<DM>(m);
return boost::static_pointer_cast<boost::dynamic_property_map>(sp);
};
int main() {
std::map<V, Attributes> va;
std::map<E, Attributes> ea;
boost::dynamic_properties props(
[vamap = boost::make_assoc_property_map(va),
eamap = boost::make_assoc_property_map(ea)] //
(std::string const& name, auto&& descriptor, auto&&) -> DynMap {
if (typeid(V) == descriptor.type()) {
return make_dyn(boost::make_function_property_map<V>(
[=](V v) -> std::string& { return vamap[v][name]; }));
} else {
return make_dyn(boost::make_function_property_map<E>(
[=](E e) -> std::string& { return eamap[e][name]; }));
}
});
Graph g;
std::ifstream input_stream("input.xml");
read_graphml(input_stream, g, props);
write_graphml(std::cout, g, props);
}
Now retains the Name attributes as expected:
<?xml version="1.0" encoding="UTF-8"?>
<graphml xmlns="http://graphml.graphdrawing.org/xmlns" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://graphml.graphdrawing.org/xmlns http://graphml.graphdrawing.org/xmlns/1.0/graphml.xsd">
<key id="key0" for="node" attr.name="Name" attr.type="string" />
<graph id="G" edgedefault="directed" parse.nodeids="free" parse.edgeids="canonical" parse.order="nodesfirst">
<node id="n0">
<data key="key0">A</data>
</node>
<node id="n1">
<data key="key0">D</data>
</node>
<node id="n2">
<data key="key0">B</data>
</node>
<node id="n3">
<data key="key0">C</data>
</node>
<edge id="e0" source="n0" target="n1">
</edge>
<edge id="e1" source="n2" target="n3">
</edge>
</graph>
</graphml>
UPDATE: Strongly Typed?
In response to the comment, I added a strongly typed mapper.
It turns out pretty elegant because I kind of "flipped around" the storage making the whole variant access unnecessary (except for storage). The resulting data structures are much harder to use in your own code, that elegance is bit of lie, be warned.
Live On Coliru
#include <boost/graph/adjacency_list.hpp>
#include <boost/graph/graphml.hpp>
#include <boost/property_map/function_property_map.hpp>
#include <boost/variant.hpp>
#include <fstream>
using DynMap = boost::shared_ptr<boost::dynamic_property_map>;
using Graph = boost::adjacency_list<>;
using V = Graph::vertex_descriptor;
using E = Graph::edge_descriptor;
using Name = std::string;
template <typename DescriptorT, typename T> using AttrMap = std::map<DescriptorT, T>;
template <typename DescriptorT, typename... Ts>
using VarAttr = std::map<Name, boost::variant<AttrMap<DescriptorT, Ts>...>>;
using VSupported = VarAttr<V, std::string, double>;
using ESupported = VarAttr<E, std::string, double>;
template <typename VorE, typename... Ts>
inline DynMap instantiate(VarAttr<VorE, Ts...>& supported, Name const& name,
std::type_info const& type) {
auto match_type = [&]<typename T>() -> DynMap {
if (type != typeid(T))
return nullptr; // non-matching
// emplace the appropriately typed map
using Attr = AttrMap<VorE, T>;
auto& [_, variant] = *supported.emplace(name, Attr()).first;
auto& instance = boost::get<Attr>(variant);
return boost::make_shared<
boost::detail::dynamic_property_map_adaptor<boost::associative_property_map<Attr>>>(
instance);
};
for (auto& matched : {match_type.template operator()<Ts>()...})
if (matched)
return matched;
return {};
};
int main() {
VSupported va;
ESupported ea;
boost::dynamic_properties props(
[&](std::string const& name, auto&& descriptor, auto&& value) -> DynMap {
return typeid(V) == descriptor.type() ? instantiate<V>(va, name, value.type())
: instantiate<E>(ea, name, value.type());
});
Graph g;
std::ifstream input_stream("input.xml");
read_graphml(input_stream, g, props);
props.property("Label", boost::make_function_property_map<E>([](E e) {
return boost::lexical_cast<std::string>(e);
}));
write_graphml(std::cout, g, props);
}
When adding a double attribute to edges:
<key id="key1" for="edge" attr.name="Weight" attr.type="double" />
With data like
<edge id="e0" source="n0" target="n1">
<data key="key1">12.3E-2</data>
</edge>
<edge id="e1" source="n2" target="n3">
<data key="key1">23.4E-2</data>
</edge>
Now prints output:
<edge id="e0" source="n0" target="n1">
<data key="key0">(0,1)</data>
<data key="key2">0.123</data>
</edge>
<edge id="e1" source="n2" target="n3">
<data key="key0">(2,3)</data>
<data key="key2">0.234</data>
</edge>
Showing that the attributes are not strings anymore.

boost::property_tree XML issue

I am fighting with getting values from the following XML structure:
<ActionMaps version="1" optionsVersion="2" rebindVersion="2" profileName="full_export">
<CustomisationUIHeader label="full_export" description="" image="">
<devices>
<keyboard instance="1"/>
<mouse instance="1"/>
</devices>
<categories>
<category label="#ui_CCSpaceFlight"/>
<category label="#ui_CGLightControllerDesc"/>
<category label="#ui_CCFPS"/>
<category label="#ui_CCEVA"/>
<category label="#ui_CGOpticalTracking"/>
<category label="#ui_CGInteraction"/>
</categories>
</CustomisationUIHeader>
<options type="keyboard" instance="1" Product="Tastatur {6F1D2B61-D5A0-11CF-BFC7-444553540000}">
<flight_move_yaw exponent="1.5"/>
</options>
<modifiers />
<actionmap name="spaceship_general">
<action name="v_close_all_doors">
<rebind input="kb1_0"/>
</action>
<action name="v_cooler_throttle_down">
<rebind input="kb1_6"/>
</action>
<action name="v_cooler_throttle_up">
<rebind input="kb1_5"/>
</action>
<action name="v_eject">
<rebind input="kb1_1"/>
</action>
...
The code I am using is
const std::string XML_PATH = std::string(fqn_file.mb_str());
boost::property_tree::ptree pt1;
boost::property_tree::read_xml( XML_PATH, pt1 );
// Traverse property tree example
BOOST_FOREACH(boost::property_tree::ptree::value_type const& node,
pt1.get_child( "ActionMaps.actionmap" ) ) {
boost::property_tree::ptree subtree = node.second;
if ( node.first == "actionmap" ) {
BOOST_FOREACH(boost::property_tree::ptree::value_type const& v,
subtree.get_child( "" ) ) {
std::string label = v.first;
if ( label != "<xmlattr>" ) {
std::string value = subtree.get<std::string>( label );
wxString m_value(value);
std::cout << label << ": " << value << std::endl;
wxString m_label(label);
wxLogMessage("DEBUG -> Label = " + m_label + " Value = " + value);
}
}
}
}
If I go for 'action' or 'label' the values are empty which seems to be normal. But how I can access name (#name) from action and input (#input) from rebind?
I expect to get e.g. the pair of values 'v_close_all_doors' and 'kb1_0'. Of course I need a second iteration for the second value but for the first I need to understand how to access these values.
I gave up with boost::property_tree as its seems to be designed to handle simple XML structures only. Made more progress using RapidXML

Boost Read_graphml doesn't read xml properly it gives all the vertices but they are empty

I have a adjacency list of type
boost::adjacency_list<boost::setS, boost::vecS, boost::directedS, GraphData>
Where GraphData is a structure contains name
struct GraphItem
{
std::string Name;
}
I am able to write graph to xml
void WriteGraph() {
boost::dynamic_properties dp;
dp.property("Name", make_transform_value_property_map(&Name,
boost::get(vertex_bundle, graph)));
boost::write_graphml(filename, graph, dp, true);
}
std::string Name(boost::vertex_bundle_type<Graph>::type v) {
std::ostringstream oss;
oss << v.Name;
return oss.str();
}
I get XML as
<graphml>
<key id="key0" for="node" attr.name="Name" attr.type="string" />
<graph id="G" edgedefault="directed" parse.nodeids="canonical"
parse.edgeids="canonical" parse.order="nodesfirst">
<node id="n0">
<data key="key0">A</data>
</node>
<node id="n1">
<data key="key0">D</data>
</node>
<node id="n2">
<data key="key0">B</data>
</node>
<node id="n3">
<data key="key0">C</data>
</node>
<edge id="e0" source="n0" target="n1">
</edge>
<edge id="e1" source="n2" target="n3">
</edge>
</graph>
</graphml>
When I read graph
void ReadGraph() {
boost::dynamic_properties dp;
std::ifstream file(fileName);
boost::read_graphml(file, graph, dp);
}
This is crashing says property Name not found.
If I use ignore_other_properties for property,
boost::dynamic_properties dp(ignore_other_properties);
It works but I am not getting any graph item in graph vertices.
The graph is not empty, you get:
0 --> 1
1 -->
2 --> 3
3 -->
Or in XML: https://paste.ubuntu.com/p/c4tGmxGssJ/
Of course, you wanted to read the name property. For that you obviously need to register the property with the dynamic-properties map.
Note You can access members of property bundles much simpler:
dp.property("Name", boost::get(&GraphData::Name, graph));
Full Demo
#include <boost/graph/adjacency_list.hpp>
#include <boost/graph/graphml.hpp>
struct GraphData {
std::string Name;
};
using Graph = boost::adjacency_list<boost::setS, boost::vecS, boost::directedS, GraphData>;
Graph ReadGraph(std::string const& fileName) {
Graph graph;
boost::dynamic_properties dp;
dp.property("Name", boost::get(&GraphData::Name, graph));
std::ifstream file(fileName);
boost::read_graphml(file, graph, dp);
return graph;
}
void WriteGraph(std::ostream& os, Graph& graph) {
boost::dynamic_properties dp;
dp.property("Name", get(&GraphData::Name, graph));
boost::write_graphml(os, graph, dp, true);
}
#include <boost/graph/graph_utility.hpp>
int main() {
Graph g = ReadGraph("input.txt");
print_graph(g, get(&GraphData::Name, g));
// or as XML
WriteGraph(std::cout << "==== XML version: ====\n\n", g);
}
Prints
A --> D
D -->
B --> C
C -->
==== XML version: ====
<?xml version="1.0" encoding="UTF-8"?>
<graphml xmlns="http://graphml.graphdrawing.org/xmlns" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://graphml.graphdrawing.org/xmlns http://graphml.graphdrawing.org/xmlns/1.0/graphml.xsd">
<key id="key0" for="node" attr.name="Name" attr.type="string" />
<graph id="G" edgedefault="directed" parse.nodeids="canonical" parse.edgeids="canonical" parse.order="nodesfirst">
<node id="n0">
<data key="key0">A</data>
</node>
<node id="n1">
<data key="key0">D</data>
</node>
<node id="n2">
<data key="key0">B</data>
</node>
<node id="n3">
<data key="key0">C</data>
</node>
<edge id="e0" source="n0" target="n1">
</edge>
<edge id="e1" source="n2" target="n3">
</edge>
</graph>
</graphml>

QT DOMXml - Change the name of a node [duplicate]

This question already has answers here:
Edit Value of a QDomElement?
(6 answers)
Closed 6 years ago.
I am working on a QT Project and part of that is a reconstruction of an XML file. I was able to make most of the needed changes with QDom but I can't find how to rename a node.
So the old XML file looks like ..
<root>
<window name="" ..>
<element x="" y=""/>
<element1 a="" b=""/>
...
</window>
..
..
<window name="">
<element x="" y=""/>
<element1 a="" b=""/>
...
</window>
</root>
How can i change the XML so that the new one will have < group > instead of < window >?
So at the end it needs to look like..
<root>
<group name="" ..>
<element x="" y=""/>
<element1 a="" b=""/>
...
</group>
..
..
<group name="">
<element x="" y=""/>
<element1 a="" b=""/>
...
</group>
</root>
Adding some more info...
Here is the code I use to read the <window> nodes, delete some based on the visibility (comes from a list) and I need to change <window> to <group> for the remaining nodes.
QFile oldXml("file.xml");
oldXml.open(QIODevice::ReadOnly);
QDomDocument doc;
doc.setContent(&oldXml);
QDomNodeList nodes = doc.elementsByTagName("window");
// Remove Window nodes based on visibility
insize = nodes.length();
for ( int i = 0; i < insize; i++ ) {
QDomNode node = nodes.at(i-dels);
if ( (list2[i] == "0") | (list2[i]=="") ) {
node.parentNode().removeChild(node);
dels=dels+1;
} else {
// Here is where i need to change the node name from <window> to e.g. <group>
}
}
You could use setTagName and maybe setAttribute if you want to set a value for the name attribute.
With the following example, myxml.xml is converted to xmlout.xml
Note#1: this is just an example: we're replacing only the first node.
Note#2: in this example, we're using two different files. Depending on your design, you could use the same or not.
myxml.xml
<root>
<window name="">
<element x="" y=""/>
<element1 a="" b=""/>
</window>
<window name="">
<element x="" y=""/>
<element1 a="" b=""/>
</window>
</root>
xmlout.xml
<root>
<group name="value">
<element y="" x=""/>
<element1 a="" b=""/>
</group>
<window name="">
<element y="" x=""/>
<element1 a="" b=""/>
</window>
</root>
main.cpp
#include <iostream>
#include <QtXml>
#include <QFile>
int main(int argc, char *argv[])
{
QDomDocument doc;
// Load xml file as raw data
QFile inFile(":myxml.xml");
if (!inFile.open(QIODevice::ReadOnly ))
{
std::cerr << "Error - inFile: " << inFile.errorString().toStdString();
return 1;
}
// Set data into the QDomDocument before processing
doc.setContent(&inFile);
// Get element in question
QDomElement root = doc.documentElement();
QDomElement nodeTag = root.firstChildElement("window");
nodeTag.setTagName("group");
nodeTag.setAttribute("name","value");
inFile.close();
// Save the modified data
QFile outFile("xmlout.xml");
if (!outFile.open(QIODevice::WriteOnly ))
{
// Error while loading file
std::cerr << "Error - outFile: " << outFile.errorString().toStdString();
return 1;
}
QTextStream stream;
stream.setDevice(&outFile);
stream.setCodec("UTF-8");
doc.save(stream,4);
outFile.close();
return 0;
}
I did not see any straight API function to rename the element. API is allowing to change value but not name.
There is another round about way.
Create an element, for example:
QDomElement group = doc.createElement("group");
use "QDomNode's replacechild" function.
QDomNode QDomNode::replaceChild(const QDomNode &newChild, const QDomNode &oldChild)
ex:
QDomNode dNode = node.replaceChild(group,oldNode);

Is it possible to generate non-blocking calls with dbusxx-xml2cpp?

I would like to generate C++ headers using dbusxx-xml2cpp where some methods are non-blocking, e.g. using invoke_method_noreply instead of invoke_method. Is this possible?
For example the following XML:
<?xml version="1.0" encoding="UTF-8" ?>
<node name="/me/MyService">
<interface name="me.MyService">
<method name="MyMethod">
<arg direction="in" type="s" name="argument"/>
</method>
</interface>
</node>
Would generate (partly):
void MyMethod(const std::string& argument)
{
::DBus::CallMessage call;
::DBus::MessageIter wi = call.writer();
wi << argument;
call.member("MyMethod");
::DBus::Message ret = invoke_method (call);
}
But I would like to have something like:
void MyMethod(const std::string& argument)
{
::DBus::CallMessage call;
::DBus::MessageIter wi = call.writer();
wi << argument;
call.member("MyMethod");
bool ret = invoke_method_noreply (call);
}
Use the annotation org.freedesktop.DBus.Method.NoReply"
Example XML:
<node>
<interface name="org.test.example">
<method name="NoReplyMethod">
<arg name="data" direction="in" type="i"/>
<annotation name="org.freedesktop.DBus.Method.NoReply" value="true"/>
</method>
</interface>
</node>
Generated Code:
void NoReplyMethod(const int32_t& data)
{
::DBus::CallMessage call;
::DBus::MessageIter wi = call.writer();
wi << data;
call.member("NoReplyMethod");
assert (invoke_method_noreply (call));
}