<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE html>
<html lang="en">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<!-- qdbusargument.cpp -->
<title>QDBusArgument Class | Qt D-Bus</title>
<link rel="stylesheet" type="text/css" href="style/offline-simple.css" />
<script type="text/javascript">
document.getElementsByTagName("link").item(0).setAttribute("href", "style/offline.css");
// loading style sheet breaks anchors that were jumped to before
// so force jumping to anchor again
setTimeout(function() {
var anchor = location.hash;
// need to jump to different anchor first (e.g. none)
location.hash = "#";
setTimeout(function() {
location.hash = anchor;
}, 0);
}, 0);
</script>
</head>
<body>
<div class="header" id="qtdocheader">
<div class="main">
<div class="main-rounded">
<div class="navigationbar">
<table><tr>
<td >Qt 5.9</td><td ><a href="qtdbus-index.html">Qt D-Bus</a></td><td ><a href="qtdbus-module.html">C++ Classes</a></td><td >QDBusArgument</td></tr></table><table class="buildversion"><tr>
<td id="buildversion" width="100%" align="right">Qt 5.9.4 Reference Documentation</td>
</tr></table>
</div>
</div>
<div class="content">
<div class="line">
<div class="content mainContent">
<div class="sidebar">
<div class="toc">
<h3><a name="toc">Contents</a></h3>
<ul>
<li class="level1"><a href="#public-types">Public Types</a></li>
<li class="level1"><a href="#public-functions">Public Functions</a></li>
<li class="level1"><a href="#related-non-members">Related Non-Members</a></li>
<li class="level1"><a href="#details">Detailed Description</a></li>
</ul>
</div>
<div class="sidebar-content" id="sidebar-content"></div></div>
<h1 class="title">QDBusArgument Class</h1>
<!-- $$$QDBusArgument-brief -->
<p>The <a href="qdbusargument.html">QDBusArgument</a> class is used to marshall and demarshall D-Bus arguments. <a href="#details">More...</a></p>
<!-- @@@QDBusArgument -->
<div class="table"><table class="alignedsummary">
<tr><td class="memItemLeft rightAlign topAlign"> Header:</td><td class="memItemRight bottomAlign"> <span class="preprocessor">#include <QDBusArgument></span>
</td></tr><tr><td class="memItemLeft rightAlign topAlign"> qmake:</td><td class="memItemRight bottomAlign"> QT += dbus</td></tr><tr><td class="memItemLeft rightAlign topAlign"> Since:</td><td class="memItemRight bottomAlign"> Qt 4.2</td></tr></table></div><ul>
<li><a href="qdbusargument-members.html">List of all members, including inherited members</a></li>
</ul>
<a name="public-types"></a>
<h2 id="public-types">Public Types</h2>
<div class="table"><table class="alignedsummary">
<tr><td class="memItemLeft rightAlign topAlign"> enum </td><td class="memItemRight bottomAlign"><b><a href="qdbusargument.html#ElementType-enum">ElementType</a></b> { BasicType, VariantType, ArrayType, StructureType, ..., UnknownType }</td></tr>
</table></div>
<a name="public-functions"></a>
<h2 id="public-functions">Public Functions</h2>
<div class="table"><table class="alignedsummary">
<tr><td class="memItemLeft rightAlign topAlign"> </td><td class="memItemRight bottomAlign"><b><a href="qdbusargument.html#QDBusArgument">QDBusArgument</a></b>()</td></tr>
<tr><td class="memItemLeft rightAlign topAlign"> </td><td class="memItemRight bottomAlign"><b><a href="qdbusargument.html#QDBusArgument-1">QDBusArgument</a></b>(const QDBusArgument &<i>other</i>)</td></tr>
<tr><td class="memItemLeft rightAlign topAlign"> </td><td class="memItemRight bottomAlign"><b><a href="qdbusargument.html#QDBusArgument-2">QDBusArgument</a></b>(QDBusArgument &&<i>other</i>)</td></tr>
<tr><td class="memItemLeft rightAlign topAlign"> </td><td class="memItemRight bottomAlign"><b><a href="qdbusargument.html#dtor.QDBusArgument">~QDBusArgument</a></b>()</td></tr>
<tr><td class="memItemLeft rightAlign topAlign"> QVariant </td><td class="memItemRight bottomAlign"><b><a href="qdbusargument.html#asVariant">asVariant</a></b>() const</td></tr>
<tr><td class="memItemLeft rightAlign topAlign"> bool </td><td class="memItemRight bottomAlign"><b><a href="qdbusargument.html#atEnd">atEnd</a></b>() const</td></tr>
<tr><td class="memItemLeft rightAlign topAlign"> void </td><td class="memItemRight bottomAlign"><b><a href="qdbusargument.html#beginArray">beginArray</a></b>(int <i>id</i>)</td></tr>
<tr><td class="memItemLeft rightAlign topAlign"> void </td><td class="memItemRight bottomAlign"><b><a href="qdbusargument.html#beginArray-1">beginArray</a></b>() const</td></tr>
<tr><td class="memItemLeft rightAlign topAlign"> void </td><td class="memItemRight bottomAlign"><b><a href="qdbusargument.html#beginMap">beginMap</a></b>(int <i>kid</i>, int <i>vid</i>)</td></tr>
<tr><td class="memItemLeft rightAlign topAlign"> void </td><td class="memItemRight bottomAlign"><b><a href="qdbusargument.html#beginMap-1">beginMap</a></b>() const</td></tr>
<tr><td class="memItemLeft rightAlign topAlign"> void </td><td class="memItemRight bottomAlign"><b><a href="qdbusargument.html#beginMapEntry">beginMapEntry</a></b>()</td></tr>
<tr><td class="memItemLeft rightAlign topAlign"> void </td><td class="memItemRight bottomAlign"><b><a href="qdbusargument.html#beginMapEntry-1">beginMapEntry</a></b>() const</td></tr>
<tr><td class="memItemLeft rightAlign topAlign"> void </td><td class="memItemRight bottomAlign"><b><a href="qdbusargument.html#beginStructure">beginStructure</a></b>()</td></tr>
<tr><td class="memItemLeft rightAlign topAlign"> void </td><td class="memItemRight bottomAlign"><b><a href="qdbusargument.html#beginStructure-1">beginStructure</a></b>() const</td></tr>
<tr><td class="memItemLeft rightAlign topAlign"> ElementType </td><td class="memItemRight bottomAlign"><b><a href="qdbusargument.html#currentType">currentType</a></b>() const</td></tr>
<tr><td class="memItemLeft rightAlign topAlign"> void </td><td class="memItemRight bottomAlign"><b><a href="qdbusargument.html#endArray">endArray</a></b>()</td></tr>
<tr><td class="memItemLeft rightAlign topAlign"> void </td><td class="memItemRight bottomAlign"><b><a href="qdbusargument.html#endArray-1">endArray</a></b>() const</td></tr>
<tr><td class="memItemLeft rightAlign topAlign"> void </td><td class="memItemRight bottomAlign"><b><a href="qdbusargument.html#endMap">endMap</a></b>()</td></tr>
<tr><td class="memItemLeft rightAlign topAlign"> void </td><td class="memItemRight bottomAlign"><b><a href="qdbusargument.html#endMap-1">endMap</a></b>() const</td></tr>
<tr><td class="memItemLeft rightAlign topAlign"> void </td><td class="memItemRight bottomAlign"><b><a href="qdbusargument.html#endMapEntry">endMapEntry</a></b>()</td></tr>
<tr><td class="memItemLeft rightAlign topAlign"> void </td><td class="memItemRight bottomAlign"><b><a href="qdbusargument.html#endMapEntry-1">endMapEntry</a></b>() const</td></tr>
<tr><td class="memItemLeft rightAlign topAlign"> void </td><td class="memItemRight bottomAlign"><b><a href="qdbusargument.html#endStructure">endStructure</a></b>()</td></tr>
<tr><td class="memItemLeft rightAlign topAlign"> void </td><td class="memItemRight bottomAlign"><b><a href="qdbusargument.html#endStructure-1">endStructure</a></b>() const</td></tr>
<tr><td class="memItemLeft rightAlign topAlign"> void </td><td class="memItemRight bottomAlign"><b><a href="qdbusargument.html#swap">swap</a></b>(QDBusArgument &<i>other</i>)</td></tr>
<tr><td class="memItemLeft rightAlign topAlign"> QDBusArgument &</td><td class="memItemRight bottomAlign"><b><a href="qdbusargument.html#operator-lt-lt">operator<<</a></b>(uchar <i>arg</i>)</td></tr>
<tr><td class="memItemLeft rightAlign topAlign"> QDBusArgument &</td><td class="memItemRight bottomAlign"><b><a href="qdbusargument.html#operator-lt-lt-1">operator<<</a></b>(bool <i>arg</i>)</td></tr>
<tr><td class="memItemLeft rightAlign topAlign"> QDBusArgument &</td><td class="memItemRight bottomAlign"><b><a href="qdbusargument.html#operator-lt-lt-2">operator<<</a></b>(short <i>arg</i>)</td></tr>
<tr><td class="memItemLeft rightAlign topAlign"> QDBusArgument &</td><td class="memItemRight bottomAlign"><b><a href="qdbusargument.html#operator-lt-lt-3">operator<<</a></b>(ushort <i>arg</i>)</td></tr>
<tr><td class="memItemLeft rightAlign topAlign"> QDBusArgument &</td><td class="memItemRight bottomAlign"><b><a href="qdbusargument.html#operator-lt-lt-4">operator<<</a></b>(int <i>arg</i>)</td></tr>
<tr><td class="memItemLeft rightAlign topAlign"> QDBusArgument &</td><td class="memItemRight bottomAlign"><b><a href="qdbusargument.html#operator-lt-lt-5">operator<<</a></b>(uint <i>arg</i>)</td></tr>
<tr><td class="memItemLeft rightAlign topAlign"> QDBusArgument &</td><td class="memItemRight bottomAlign"><b><a href="qdbusargument.html#operator-lt-lt-6">operator<<</a></b>(qlonglong <i>arg</i>)</td></tr>
<tr><td class="memItemLeft rightAlign topAlign"> QDBusArgument &</td><td class="memItemRight bottomAlign"><b><a href="qdbusargument.html#operator-lt-lt-7">operator<<</a></b>(qulonglong <i>arg</i>)</td></tr>
<tr><td class="memItemLeft rightAlign topAlign"> QDBusArgument &</td><td class="memItemRight bottomAlign"><b><a href="qdbusargument.html#operator-lt-lt-8">operator<<</a></b>(double <i>arg</i>)</td></tr>
<tr><td class="memItemLeft rightAlign topAlign"> QDBusArgument &</td><td class="memItemRight bottomAlign"><b><a href="qdbusargument.html#operator-lt-lt-9">operator<<</a></b>(const QString &<i>arg</i>)</td></tr>
<tr><td class="memItemLeft rightAlign topAlign"> QDBusArgument &</td><td class="memItemRight bottomAlign"><b><a href="qdbusargument.html#operator-lt-lt-10">operator<<</a></b>(const QDBusVariant &<i>arg</i>)</td></tr>
<tr><td class="memItemLeft rightAlign topAlign"> QDBusArgument &</td><td class="memItemRight bottomAlign"><b><a href="qdbusargument.html#operator-lt-lt-14">operator<<</a></b>(const QStringList &<i>arg</i>)</td></tr>
<tr><td class="memItemLeft rightAlign topAlign"> QDBusArgument &</td><td class="memItemRight bottomAlign"><b><a href="qdbusargument.html#operator-lt-lt-15">operator<<</a></b>(const QByteArray &<i>arg</i>)</td></tr>
<tr><td class="memItemLeft rightAlign topAlign"> QDBusArgument &</td><td class="memItemRight bottomAlign"><b><a href="qdbusargument.html#operator-eq">operator=</a></b>(QDBusArgument &&<i>other</i>)</td></tr>
<tr><td class="memItemLeft rightAlign topAlign"> QDBusArgument &</td><td class="memItemRight bottomAlign"><b><a href="qdbusargument.html#operator-eq-1">operator=</a></b>(const QDBusArgument &<i>other</i>)</td></tr>
<tr><td class="memItemLeft rightAlign topAlign"> const QDBusArgument &</td><td class="memItemRight bottomAlign"><b><a href="qdbusargument.html#operator-gt-gt">operator>></a></b>(uchar &<i>arg</i>) const</td></tr>
<tr><td class="memItemLeft rightAlign topAlign"> const QDBusArgument &</td><td class="memItemRight bottomAlign"><b><a href="qdbusargument.html#operator-gt-gt-1">operator>></a></b>(bool &<i>arg</i>) const</td></tr>
<tr><td class="memItemLeft rightAlign topAlign"> const QDBusArgument &</td><td class="memItemRight bottomAlign"><b><a href="qdbusargument.html#operator-gt-gt-2">operator>></a></b>(short &<i>arg</i>) const</td></tr>
<tr><td class="memItemLeft rightAlign topAlign"> const QDBusArgument &</td><td class="memItemRight bottomAlign"><b><a href="qdbusargument.html#operator-gt-gt-3">operator>></a></b>(ushort &<i>arg</i>) const</td></tr>
<tr><td class="memItemLeft rightAlign topAlign"> const QDBusArgument &</td><td class="memItemRight bottomAlign"><b><a href="qdbusargument.html#operator-gt-gt-4">operator>></a></b>(int &<i>arg</i>) const</td></tr>
<tr><td class="memItemLeft rightAlign topAlign"> const QDBusArgument &</td><td class="memItemRight bottomAlign"><b><a href="qdbusargument.html#operator-gt-gt-5">operator>></a></b>(uint &<i>arg</i>) const</td></tr>
<tr><td class="memItemLeft rightAlign topAlign"> const QDBusArgument &</td><td class="memItemRight bottomAlign"><b><a href="qdbusargument.html#operator-gt-gt-6">operator>></a></b>(qlonglong &<i>arg</i>) const</td></tr>
<tr><td class="memItemLeft rightAlign topAlign"> const QDBusArgument &</td><td class="memItemRight bottomAlign"><b><a href="qdbusargument.html#operator-gt-gt-7">operator>></a></b>(qulonglong &<i>arg</i>) const</td></tr>
<tr><td class="memItemLeft rightAlign topAlign"> const QDBusArgument &</td><td class="memItemRight bottomAlign"><b><a href="qdbusargument.html#operator-gt-gt-8">operator>></a></b>(double &<i>arg</i>) const</td></tr>
<tr><td class="memItemLeft rightAlign topAlign"> const QDBusArgument &</td><td class="memItemRight bottomAlign"><b><a href="qdbusargument.html#operator-gt-gt-9">operator>></a></b>(QString &<i>arg</i>) const</td></tr>
<tr><td class="memItemLeft rightAlign topAlign"> const QDBusArgument &</td><td class="memItemRight bottomAlign"><b><a href="qdbusargument.html#operator-gt-gt-10">operator>></a></b>(QDBusVariant &<i>arg</i>) const</td></tr>
<tr><td class="memItemLeft rightAlign topAlign"> const QDBusArgument &</td><td class="memItemRight bottomAlign"><b><a href="qdbusargument.html#operator-gt-gt-14">operator>></a></b>(QStringList &<i>arg</i>) const</td></tr>
<tr><td class="memItemLeft rightAlign topAlign"> const QDBusArgument &</td><td class="memItemRight bottomAlign"><b><a href="qdbusargument.html#operator-gt-gt-15">operator>></a></b>(QByteArray &<i>arg</i>) const</td></tr>
</table></div>
<a name="related-non-members"></a>
<h2 id="related-non-members">Related Non-Members</h2>
<div class="table"><table class="alignedsummary">
<tr><td class="memItemLeft rightAlign topAlign"> int </td><td class="memItemRight bottomAlign"><b><a href="qdbusargument.html#qDBusRegisterMetaType">qDBusRegisterMetaType</a></b>()</td></tr>
<tr><td class="memItemLeft rightAlign topAlign"> T </td><td class="memItemRight bottomAlign"><b><a href="qdbusargument.html#qdbus_cast">qdbus_cast</a></b>(const QDBusArgument &<i>argument</i>)</td></tr>
</table></div>
<a name="details"></a>
<!-- $$$QDBusArgument-description -->
<div class="descr">
<h2 id="details">Detailed Description</h2>
<p>The <a href="qdbusargument.html">QDBusArgument</a> class is used to marshall and demarshall D-Bus arguments.</p>
<p>The class is used to send arguments over D-Bus to remote applications and to receive them back. D-Bus offers an extensible type system, based on a few primitive types and associations of them. See the <a href="qdbustypesystem.html">Qt D-Bus Type System</a> page for more information on the type system.</p>
<p><a href="qdbusargument.html">QDBusArgument</a> is the central class in the Qt D-Bus type system, providing functions to marshall and demarshall the primitive types. The compound types are then created by association of one or more of the primitive types in arrays, dictionaries or structures.</p>
<p>The following example illustrates how a structure containing an integer and a string can be constructed using the <a href="qdbustypesystem.html">Qt D-Bus type system</a>:</p>
<pre class="cpp">
<span class="keyword">struct</span> MyStructure
{
<span class="type">int</span> count;
<span class="type"><a href="../qtcore/qstring.html">QString</a></span> name;
};
Q_DECLARE_METATYPE(MyStructure)
<span class="comment">// Marshall the MyStructure data into a D-Bus argument</span>
<span class="type"><a href="qdbusargument.html#QDBusArgument">QDBusArgument</a></span> <span class="operator">&</span><span class="keyword">operator</span><span class="operator"><</span><span class="operator"><</span>(<span class="type"><a href="qdbusargument.html#QDBusArgument">QDBusArgument</a></span> <span class="operator">&</span>argument<span class="operator">,</span> <span class="keyword">const</span> MyStructure <span class="operator">&</span>mystruct)
{
argument<span class="operator">.</span>beginStructure();
argument <span class="operator"><</span><span class="operator"><</span> mystruct<span class="operator">.</span>count <span class="operator"><</span><span class="operator"><</span> mystruct<span class="operator">.</span>name;
argument<span class="operator">.</span>endStructure();
<span class="keyword">return</span> argument;
}
<span class="comment">// Retrieve the MyStructure data from the D-Bus argument</span>
<span class="keyword">const</span> <span class="type"><a href="qdbusargument.html#QDBusArgument">QDBusArgument</a></span> <span class="operator">&</span><span class="keyword">operator</span><span class="operator">></span><span class="operator">></span>(<span class="keyword">const</span> <span class="type"><a href="qdbusargument.html#QDBusArgument">QDBusArgument</a></span> <span class="operator">&</span>argument<span class="operator">,</span> MyStructure <span class="operator">&</span>mystruct)
{
argument<span class="operator">.</span>beginStructure();
argument <span class="operator">></span><span class="operator">></span> mystruct<span class="operator">.</span>count <span class="operator">></span><span class="operator">></span> mystruct<span class="operator">.</span>name;
argument<span class="operator">.</span>endStructure();
<span class="keyword">return</span> argument;
}
</pre>
<p>The type has to be registered with <a href="qdbusargument.html#qDBusRegisterMetaType">qDBusRegisterMetaType</a>() before it can be used with <a href="qdbusargument.html">QDBusArgument</a>. Therefore, somewhere in your program, you should add the following code:</p>
<pre class="cpp">
qDBusRegisterMetaType<span class="operator"><</span>MyStructure<span class="operator">></span>();
</pre>
<p>Once registered, a type can be used in outgoing method calls (placed with <a href="qdbusabstractinterface.html#call">QDBusAbstractInterface::call</a>()), signal emissions from registered objects or in incoming calls from remote applications.</p>
<p>It is important to note that the <code>operator<<</code> and <code>operator>></code> streaming functions must always produce the same number of entries in case of structures, both in reading and in writing (marshalling and demarshalling), otherwise calls and signals may start to silently fail.</p>
<p>The following example illustrates this wrong usage in context of a class that may contain invalid data:</p>
<pre class="cpp">
<span class="comment">//bad code</span>
<span class="comment">// Wrongly marshall the MyTime data into a D-Bus argument</span>
<span class="type"><a href="qdbusargument.html#QDBusArgument">QDBusArgument</a></span> <span class="operator">&</span><span class="keyword">operator</span><span class="operator"><</span><span class="operator"><</span>(<span class="type"><a href="qdbusargument.html#QDBusArgument">QDBusArgument</a></span> <span class="operator">&</span>argument<span class="operator">,</span> <span class="keyword">const</span> MyTime <span class="operator">&</span>mytime)
{
argument<span class="operator">.</span>beginStructure();
<span class="keyword">if</span> (mytime<span class="operator">.</span>isValid)
argument <span class="operator"><</span><span class="operator"><</span> <span class="keyword">true</span> <span class="operator"><</span><span class="operator"><</span> mytime<span class="operator">.</span>hour
<span class="operator"><</span><span class="operator"><</span> mytime<span class="operator">.</span>minute <span class="operator"><</span><span class="operator"><</span> mytime<span class="operator">.</span>second;
<span class="keyword">else</span>
argument <span class="operator"><</span><span class="operator"><</span> <span class="keyword">false</span>;
argument<span class="operator">.</span>endStructure();
<span class="keyword">return</span> argument;
}
</pre>
<p>In this example, both the <code>operator<<</code> and the <code>operator>></code> functions may produce a different number of reads/writes. This can confuse the Qt D-Bus type system and should be avoided.</p>
</div>
<p><b>See also </b><a href="qdbusabstractinterface.html">QDBusAbstractInterface</a>, <a href="qdbustypesystem.html">The Qt D-Bus type system</a>, <a href="usingadaptors.html">Using Adaptors</a>, and <a href="qdbusargument.html#qdbus_cast">qdbus_cast</a>().</p>
<!-- @@@QDBusArgument -->
<div class="types">
<h2>Member Type Documentation</h2>
<!-- $$$ElementType$$$BasicType$$$VariantType$$$ArrayType$$$StructureType$$$MapType$$$MapEntryType$$$UnknownType -->
<h3 class="fn" id="ElementType-enum"><a name="ElementType-enum"></a>enum QDBusArgument::<span class="name">ElementType</span></h3>
<p>This enum describes the type of element held by the argument.</p>
<div class="table"><table class="valuelist"><tr valign="top" class="odd"><th class="tblConst">Constant</th><th class="tblval">Value</th><th class="tbldscr">Description</th></tr>
<tr><td class="topAlign"><code>QDBusArgument::BasicType</code></td><td class="topAlign tblval"><code>0</code></td><td class="topAlign">A basic element, which is understood by <a href="../qtcore/qvariant.html">QVariant</a>. The following types are considered basic: bool, byte, short, ushort, int, uint, qint64, quint64, double, <a href="../qtcore/qstring.html">QString</a>, <a href="../qtcore/qbytearray.html">QByteArray</a>, <a href="qdbusobjectpath.html">QDBusObjectPath</a>, <a href="qdbussignature.html">QDBusSignature</a></td></tr>
<tr><td class="topAlign"><code>QDBusArgument::VariantType</code></td><td class="topAlign tblval"><code>1</code></td><td class="topAlign">The variant element (<a href="qdbusvariant.html">QDBusVariant</a>)</td></tr>
<tr><td class="topAlign"><code>QDBusArgument::ArrayType</code></td><td class="topAlign tblval"><code>2</code></td><td class="topAlign">An array element, usually represented by <a href="../qtcore/qlist.html">QList</a><T> or <a href="../qtcore/qvector.html">QVector</a><T>. Note: <a href="../qtcore/qbytearray.html">QByteArray</a> and associative maps are not considered arrays, even if the D-Bus protocol transports them as such.</td></tr>
<tr><td class="topAlign"><code>QDBusArgument::StructureType</code></td><td class="topAlign tblval"><code>3</code></td><td class="topAlign">A custom type represented by a structure, like <a href="../qtcore/qdatetime.html">QDateTime</a>, <a href="../qtcore/qpoint.html">QPoint</a>, etc.</td></tr>
<tr><td class="topAlign"><code>QDBusArgument::MapType</code></td><td class="topAlign tblval"><code>4</code></td><td class="topAlign">An associative container, like <a href="../qtcore/qmap.html">QMap</a><Key, Value> or <a href="../qtcore/qhash.html#qhash">QHash</a><Key, Value></td></tr>
<tr><td class="topAlign"><code>QDBusArgument::MapEntryType</code></td><td class="topAlign tblval"><code>5</code></td><td class="topAlign">One entry in an associative container: both the key and the value form one map-entry type.</td></tr>
<tr><td class="topAlign"><code>QDBusArgument::UnknownType</code></td><td class="topAlign tblval"><code>-1</code></td><td class="topAlign">The type is unknown or we have reached the end of the list.</td></tr>
</table></div>
<p>This enum was introduced or modified in Qt 4.5.</p>
<p><b>See also </b><a href="qdbusargument.html#currentType">currentType</a>().</p>
<!-- @@@ElementType -->
</div>
<div class="func">
<h2>Member Function Documentation</h2>
<!-- $$$QDBusArgument[overload1]$$$QDBusArgument -->
<h3 class="fn" id="QDBusArgument"><a name="QDBusArgument"></a>QDBusArgument::<span class="name">QDBusArgument</span>()</h3>
<p>Constructs an empty <a href="qdbusargument.html">QDBusArgument</a> argument.</p>
<p>An empty <a href="qdbusargument.html">QDBusArgument</a> object does not allow either reading or writing to be performed.</p>
<!-- @@@QDBusArgument -->
<!-- $$$QDBusArgument$$$QDBusArgumentconstQDBusArgument& -->
<h3 class="fn" id="QDBusArgument-1"><a name="QDBusArgument-1"></a>QDBusArgument::<span class="name">QDBusArgument</span>(const <span class="type"><a href="qdbusargument.html#QDBusArgument">QDBusArgument</a></span> &<i>other</i>)</h3>
<p>Constructs a copy of the <i>other</i> <a href="qdbusargument.html">QDBusArgument</a> object.</p>
<p>Both objects will therefore contain the same state from this point forward. QDBusArguments are explicitly shared and, therefore, any modification to either copy will affect the other one too.</p>
<!-- @@@QDBusArgument -->
<!-- $$$QDBusArgument$$$QDBusArgumentQDBusArgument&& -->
<h3 class="fn" id="QDBusArgument-2"><a name="QDBusArgument-2"></a>QDBusArgument::<span class="name">QDBusArgument</span>(<span class="type"><a href="qdbusargument.html#QDBusArgument">QDBusArgument</a></span> &&<i>other</i>)</h3>
<p>Move-copy constructor.</p><!-- @@@QDBusArgument -->
<!-- $$$~QDBusArgument[overload1]$$$~QDBusArgument -->
<h3 class="fn" id="dtor.QDBusArgument"><a name="dtor.QDBusArgument"></a>QDBusArgument::<span class="name">~QDBusArgument</span>()</h3>
<p>Disposes of the resources associated with this <a href="qdbusargument.html">QDBusArgument</a> object.</p>
<!-- @@@~QDBusArgument -->
<!-- $$$asVariant[overload1]$$$asVariant -->
<h3 class="fn" id="asVariant"><a name="asVariant"></a><span class="type"><a href="../qtcore/qvariant.html">QVariant</a></span> QDBusArgument::<span class="name">asVariant</span>() const</h3>
<p>Returns the current argument in the form of a <a href="../qtcore/qvariant.html">QVariant</a>. Basic types will be decoded and returned in the <a href="../qtcore/qvariant.html">QVariant</a>, but for complex types, this function will return a <a href="qdbusargument.html">QDBusArgument</a> object in the <a href="../qtcore/qvariant.html">QVariant</a>. It is the caller's responsibility to decode the argument (for example, by calling asVariant() in it).</p>
<p>For example, if the current argument is an INT32, this function will return a <a href="../qtcore/qvariant.html">QVariant</a> with an argument of type QVariant::Int. For an array of INT32, it will return a <a href="../qtcore/qvariant.html">QVariant</a> containing a <a href="qdbusargument.html">QDBusArgument</a>.</p>
<p>If an error occurs or if there are no more arguments to decode (i.e., we are at the end of the argument list), this function will return an invalid <a href="../qtcore/qvariant.html">QVariant</a>.</p>
<p>This function was introduced in Qt 4.5.</p>
<p><b>See also </b><a href="qdbusargument.html#atEnd">atEnd</a>().</p>
<!-- @@@asVariant -->
<!-- $$$atEnd[overload1]$$$atEnd -->
<h3 class="fn" id="atEnd"><a name="atEnd"></a><span class="type">bool</span> QDBusArgument::<span class="name">atEnd</span>() const</h3>
<p>Returns <code>true</code> if there are no more elements to be extracted from this <a href="qdbusargument.html">QDBusArgument</a>. This function is usually used in <a href="qdbusargument.html">QDBusArgument</a> objects returned from <a href="qdbusargument.html#beginMap-1">beginMap</a>() and <a href="qdbusargument.html#beginArray-1">beginArray</a>().</p>
<!-- @@@atEnd -->
<!-- $$$beginArray[overload1]$$$beginArrayint -->
<h3 class="fn" id="beginArray"><a name="beginArray"></a><span class="type">void</span> QDBusArgument::<span class="name">beginArray</span>(<span class="type">int</span> <i>id</i>)</h3>
<p>Opens a new D-Bus array suitable for appending elements of meta-type <i>id</i>.</p>
<p>This function is used usually in <code>operator<<</code> streaming operators, as in the following example:</p>
<pre class="cpp">
<span class="comment">// append an array of MyElement types</span>
<span class="type"><a href="qdbusargument.html#QDBusArgument">QDBusArgument</a></span> <span class="operator">&</span><span class="keyword">operator</span><span class="operator"><</span><span class="operator"><</span>(<span class="type"><a href="qdbusargument.html#QDBusArgument">QDBusArgument</a></span> <span class="operator">&</span>argument<span class="operator">,</span> <span class="keyword">const</span> MyArray <span class="operator">&</span>myarray)
{
argument<span class="operator">.</span>beginArray( <a href="../qtcore/qmetatype.html#qMetaTypeId">qMetaTypeId</a><span class="operator"><</span>MyElement<span class="operator">></span>() );
<span class="keyword">for</span> ( <span class="type">int</span> i <span class="operator">=</span> <span class="number">0</span>; i <span class="operator"><</span> myarray<span class="operator">.</span>length; <span class="operator">+</span><span class="operator">+</span>i )
argument <span class="operator"><</span><span class="operator"><</span> myarray<span class="operator">.</span>elements<span class="operator">[</span>i<span class="operator">]</span>;
argument<span class="operator">.</span>endArray();
<span class="keyword">return</span> argument;
}
</pre>
<p>If the type you want to marshall is a <a href="../qtcore/qlist.html">QList</a>, <a href="../qtcore/qvector.html">QVector</a> or any of the Qt's <a href="../qtcore/containers.html">Container Classes</a> that take one template parameter, you need not declare an <code>operator<<</code> function for it, since Qt D-Bus provides generic templates to do the job of marshalling the data. The same applies for STL's sequence containers, such as <code>std::list</code>, <code>std::vector</code>, etc.</p>
<p><b>See also </b><a href="qdbusargument.html#endArray">endArray</a>(), <a href="qdbusargument.html#beginStructure">beginStructure</a>(), and <a href="qdbusargument.html#beginMap-1">beginMap</a>().</p>
<!-- @@@beginArray -->
<!-- $$$beginArray$$$beginArray -->
<h3 class="fn" id="beginArray-1"><a name="beginArray-1"></a><span class="type">void</span> QDBusArgument::<span class="name">beginArray</span>() const</h3>
<p>Recurses into the D-Bus array to allow extraction of the array elements.</p>
<p>This function is used usually in <code>operator>></code> streaming operators, as in the following example:</p>
<pre class="cpp">
<span class="comment">// extract a MyArray array of MyElement elements</span>
<span class="keyword">const</span> <span class="type"><a href="qdbusargument.html#QDBusArgument">QDBusArgument</a></span> <span class="operator">&</span><span class="keyword">operator</span><span class="operator">></span><span class="operator">></span>(<span class="keyword">const</span> <span class="type"><a href="qdbusargument.html#QDBusArgument">QDBusArgument</a></span> <span class="operator">&</span>argument<span class="operator">,</span> MyArray <span class="operator">&</span>myarray)
{
argument<span class="operator">.</span>beginArray();
myarray<span class="operator">.</span>clear();
<span class="keyword">while</span> ( <span class="operator">!</span>argument<span class="operator">.</span>atEnd() ) {
MyElement element;
argument <span class="operator">></span><span class="operator">></span> element;
myarray<span class="operator">.</span>append( element );
}
argument<span class="operator">.</span>endArray();
<span class="keyword">return</span> argument;
}
</pre>
<p>If the type you want to demarshall is a <a href="../qtcore/qlist.html">QList</a>, <a href="../qtcore/qvector.html">QVector</a> or any of the Qt's <a href="../qtcore/containers.html">Container Classes</a> that take one template parameter, you need not declare an <code>operator>></code> function for it, since Qt D-Bus provides generic templates to do the job of demarshalling the data. The same applies for STL's sequence containers, such as <code>std::list</code>, <code>std::vector</code>, etc.</p>
<p><b>See also </b><a href="qdbusargument.html#atEnd">atEnd</a>(), <a href="qdbusargument.html#beginStructure">beginStructure</a>(), and <a href="qdbusargument.html#beginMap-1">beginMap</a>().</p>
<!-- @@@beginArray -->
<!-- $$$beginMap[overload1]$$$beginMapintint -->
<h3 class="fn" id="beginMap"><a name="beginMap"></a><span class="type">void</span> QDBusArgument::<span class="name">beginMap</span>(<span class="type">int</span> <i>kid</i>, <span class="type">int</span> <i>vid</i>)</h3>
<p>Opens a new D-Bus map suitable for appending elements. Maps are containers that associate one entry (the key) to another (the value), such as Qt's <a href="../qtcore/qmap.html">QMap</a> or <a href="../qtcore/qhash.html#qhash">QHash</a>. The ids of the map's key and value meta types must be passed in <i>kid</i> and <i>vid</i> respectively.</p>
<p>This function is used usually in <code>operator<<</code> streaming operators, as in the following example:</p>
<pre class="cpp">
<span class="comment">// append a dictionary that associates ints to MyValue types</span>
<span class="type"><a href="qdbusargument.html#QDBusArgument">QDBusArgument</a></span> <span class="operator">&</span><span class="keyword">operator</span><span class="operator"><</span><span class="operator"><</span>(<span class="type"><a href="qdbusargument.html#QDBusArgument">QDBusArgument</a></span> <span class="operator">&</span>argument<span class="operator">,</span> <span class="keyword">const</span> MyDictionary <span class="operator">&</span>mydict)
{
argument<span class="operator">.</span>beginMap( <span class="type"><a href="../qtcore/qvariant.html">QVariant</a></span><span class="operator">::</span>Int<span class="operator">,</span> <a href="../qtcore/qmetatype.html#qMetaTypeId">qMetaTypeId</a><span class="operator"><</span>MyValue<span class="operator">></span>() );
<span class="keyword">for</span> ( <span class="type">int</span> i <span class="operator">=</span> <span class="number">0</span>; i <span class="operator"><</span> mydict<span class="operator">.</span>length; <span class="operator">+</span><span class="operator">+</span>i ) {
argument<span class="operator">.</span>beginMapEntry();
argument <span class="operator"><</span><span class="operator"><</span> mydict<span class="operator">.</span>data<span class="operator">[</span>i<span class="operator">]</span><span class="operator">.</span>key <span class="operator"><</span><span class="operator"><</span> mydict<span class="operator">.</span>data<span class="operator">[</span>i<span class="operator">]</span><span class="operator">.</span>value;
argument<span class="operator">.</span>endMapEntry();
}
argument<span class="operator">.</span>endMap();
<span class="keyword">return</span> argument;
}
</pre>
<p>If the type you want to marshall is a <a href="../qtcore/qmap.html">QMap</a> or <a href="../qtcore/qhash.html#qhash">QHash</a>, you need not declare an <code>operator<<</code> function for it, since Qt D-Bus provides generic templates to do the job of marshalling the data.</p>
<p><b>See also </b><a href="qdbusargument.html#endMap">endMap</a>(), <a href="qdbusargument.html#beginStructure">beginStructure</a>(), <a href="qdbusargument.html#beginArray-1">beginArray</a>(), and <a href="qdbusargument.html#beginMapEntry">beginMapEntry</a>().</p>
<!-- @@@beginMap -->
<!-- $$$beginMap$$$beginMap -->
<h3 class="fn" id="beginMap-1"><a name="beginMap-1"></a><span class="type">void</span> QDBusArgument::<span class="name">beginMap</span>() const</h3>
<p>Recurses into the D-Bus map to allow extraction of the map's elements.</p>
<p>This function is used usually in <code>operator>></code> streaming operators, as in the following example:</p>
<pre class="cpp">
<span class="comment">// extract a MyDictionary map that associates ints to MyValue elements</span>
<span class="keyword">const</span> <span class="type"><a href="qdbusargument.html#QDBusArgument">QDBusArgument</a></span> <span class="operator">&</span><span class="keyword">operator</span><span class="operator">></span><span class="operator">></span>(<span class="keyword">const</span> <span class="type"><a href="qdbusargument.html#QDBusArgument">QDBusArgument</a></span> <span class="operator">&</span>argument<span class="operator">,</span> MyDictionary <span class="operator">&</span>mydict)
{
argument<span class="operator">.</span>beginMap();
mydict<span class="operator">.</span>clear();
<span class="keyword">while</span> ( <span class="operator">!</span>argMap<span class="operator">.</span>atEnd() ) {
<span class="type">int</span> key;
MyValue value;
argument<span class="operator">.</span>beginMapEntry();
argument <span class="operator">></span><span class="operator">></span> key <span class="operator">></span><span class="operator">></span> value;
argument<span class="operator">.</span>endMapEntry();
mydict<span class="operator">.</span>append( key<span class="operator">,</span> value );
}
argument<span class="operator">.</span>endMap();
<span class="keyword">return</span> argument;
}
</pre>
<p>If the type you want to demarshall is a <a href="../qtcore/qmap.html">QMap</a> or <a href="../qtcore/qhash.html#qhash">QHash</a>, you need not declare an <code>operator>></code> function for it, since Qt D-Bus provides generic templates to do the job of demarshalling the data.</p>
<p><b>See also </b><a href="qdbusargument.html#endMap">endMap</a>(), <a href="qdbusargument.html#beginStructure">beginStructure</a>(), <a href="qdbusargument.html#beginArray-1">beginArray</a>(), and <a href="qdbusargument.html#beginMapEntry">beginMapEntry</a>().</p>
<!-- @@@beginMap -->
<!-- $$$beginMapEntry[overload1]$$$beginMapEntry -->
<h3 class="fn" id="beginMapEntry"><a name="beginMapEntry"></a><span class="type">void</span> QDBusArgument::<span class="name">beginMapEntry</span>()</h3>
<p>Opens a D-Bus map entry suitable for appending the key and value entries. This function is only valid when a map has been opened with <a href="qdbusargument.html#beginMap-1">beginMap</a>().</p>
<p>See <a href="qdbusargument.html#beginMap-1">beginMap</a>() for an example of usage of this function.</p>
<p><b>See also </b><a href="qdbusargument.html#endMapEntry">endMapEntry</a>() and <a href="qdbusargument.html#beginMap-1">beginMap</a>().</p>
<!-- @@@beginMapEntry -->
<!-- $$$beginMapEntry$$$beginMapEntry -->
<h3 class="fn" id="beginMapEntry-1"><a name="beginMapEntry-1"></a><span class="type">void</span> QDBusArgument::<span class="name">beginMapEntry</span>() const</h3>
<p>Recurses into the D-Bus map entry to allow extraction of the key and value pair.</p>
<p>See <a href="qdbusargument.html#beginMap-1">beginMap</a>() for an example of how this function is usually used.</p>
<p><b>See also </b><a href="qdbusargument.html#endMapEntry">endMapEntry</a>() and <a href="qdbusargument.html#beginMap-1">beginMap</a>().</p>
<!-- @@@beginMapEntry -->
<!-- $$$beginStructure[overload1]$$$beginStructure -->
<h3 class="fn" id="beginStructure"><a name="beginStructure"></a><span class="type">void</span> QDBusArgument::<span class="name">beginStructure</span>()</h3>
<p>Opens a new D-Bus structure suitable for appending new arguments.</p>
<p>This function is used usually in <code>operator<<</code> streaming operators, as in the following example:</p>
<pre class="cpp">
<span class="type"><a href="qdbusargument.html#QDBusArgument">QDBusArgument</a></span> <span class="operator">&</span><span class="keyword">operator</span><span class="operator"><</span><span class="operator"><</span>(<span class="type"><a href="qdbusargument.html#QDBusArgument">QDBusArgument</a></span> <span class="operator">&</span>argument<span class="operator">,</span> <span class="keyword">const</span> MyStructure <span class="operator">&</span>mystruct)
{
argument<span class="operator">.</span>beginStructure();
argument <span class="operator"><</span><span class="operator"><</span> mystruct<span class="operator">.</span>member1 <span class="operator"><</span><span class="operator"><</span> mystruct<span class="operator">.</span>member2 <span class="operator"><</span><span class="operator"><</span> <span class="operator">.</span><span class="operator">.</span><span class="operator">.</span> ;
argument<span class="operator">.</span>endStructure();
<span class="keyword">return</span> argument;
}
</pre>
<p>Structures can contain other structures, so the following code is also valid:</p>
<pre class="cpp">
<span class="type"><a href="qdbusargument.html#QDBusArgument">QDBusArgument</a></span> <span class="operator">&</span><span class="keyword">operator</span><span class="operator"><</span><span class="operator"><</span>(<span class="type"><a href="qdbusargument.html#QDBusArgument">QDBusArgument</a></span> <span class="operator">&</span>argument<span class="operator">,</span> <span class="keyword">const</span> MyStructure <span class="operator">&</span>mystruct)
{
argument<span class="operator">.</span>beginStructure();
argument <span class="operator"><</span><span class="operator"><</span> mystruct<span class="operator">.</span>member1 <span class="operator"><</span><span class="operator"><</span> mystruct<span class="operator">.</span>member2;
argument<span class="operator">.</span>beginStructure();
argument <span class="operator"><</span><span class="operator"><</span> mystruct<span class="operator">.</span>member3<span class="operator">.</span>subMember1 <span class="operator"><</span><span class="operator"><</span> mystruct<span class="operator">.</span>member3<span class="operator">.</span>subMember2;
argument<span class="operator">.</span>endStructure();
argument <span class="operator"><</span><span class="operator"><</span> mystruct<span class="operator">.</span>member4;
argument<span class="operator">.</span>endStructure();
<span class="keyword">return</span> argument;
}
</pre>
<p><b>See also </b><a href="qdbusargument.html#endStructure">endStructure</a>(), <a href="qdbusargument.html#beginArray-1">beginArray</a>(), and <a href="qdbusargument.html#beginMap-1">beginMap</a>().</p>
<!-- @@@beginStructure -->
<!-- $$$beginStructure$$$beginStructure -->
<h3 class="fn" id="beginStructure-1"><a name="beginStructure-1"></a><span class="type">void</span> QDBusArgument::<span class="name">beginStructure</span>() const</h3>
<p>Opens a D-Bus structure suitable for extracting elements.</p>
<p>This function is used usually in <code>operator>></code> streaming operators, as in the following example:</p>
<pre class="cpp">
<span class="keyword">const</span> <span class="type"><a href="qdbusargument.html#QDBusArgument">QDBusArgument</a></span> <span class="operator">&</span><span class="keyword">operator</span><span class="operator">></span><span class="operator">></span>(<span class="keyword">const</span> <span class="type"><a href="qdbusargument.html#QDBusArgument">QDBusArgument</a></span> <span class="operator">&</span>argument<span class="operator">,</span> MyStructure <span class="operator">&</span>mystruct)
{
argument<span class="operator">.</span>beginStructure()
argument <span class="operator">></span><span class="operator">></span> mystruct<span class="operator">.</span>member1 <span class="operator">></span><span class="operator">></span> mystruct<span class="operator">.</span>member2 <span class="operator">></span><span class="operator">></span> mystruct<span class="operator">.</span>member3 <span class="operator">></span><span class="operator">></span> <span class="operator">.</span><span class="operator">.</span><span class="operator">.</span>;
argument<span class="operator">.</span>endStructure();
<span class="keyword">return</span> argument;
}
</pre>
<p><b>See also </b><a href="qdbusargument.html#endStructure">endStructure</a>(), <a href="qdbusargument.html#beginArray-1">beginArray</a>(), and <a href="qdbusargument.html#beginMap-1">beginMap</a>().</p>
<!-- @@@beginStructure -->
<!-- $$$currentType[overload1]$$$currentType -->
<h3 class="fn" id="currentType"><a name="currentType"></a><span class="type"><a href="qdbusargument.html#ElementType-enum">ElementType</a></span> QDBusArgument::<span class="name">currentType</span>() const</h3>
<p>Returns the classification of the current element type. If an error decoding the type occurs or if we're at the end of the argument, this function returns <a href="qdbusargument.html#ElementType-enum">QDBusArgument::UnknownType</a>.</p>
<p>This function only makes sense when demarshalling arguments. If it is used while marshalling, it will always return <a href="qdbusargument.html#ElementType-enum">UnknownType</a>.</p>
<p>This function was introduced in Qt 4.5.</p>
<!-- @@@currentType -->
<!-- $$$endArray[overload1]$$$endArray -->
<h3 class="fn" id="endArray"><a name="endArray"></a><span class="type">void</span> QDBusArgument::<span class="name">endArray</span>()</h3>
<p>Closes a D-Bus array opened with <a href="qdbusargument.html#beginArray-1">beginArray</a>(). This function must be called same number of times that <a href="qdbusargument.html#beginArray-1">beginArray</a>() is called.</p>
<p><b>See also </b><a href="qdbusargument.html#beginArray-1">beginArray</a>(), <a href="qdbusargument.html#endStructure">endStructure</a>(), and <a href="qdbusargument.html#endMap">endMap</a>().</p>
<!-- @@@endArray -->
<!-- $$$endArray$$$endArray -->
<h3 class="fn" id="endArray-1"><a name="endArray-1"></a><span class="type">void</span> QDBusArgument::<span class="name">endArray</span>() const</h3>
<p>Closes the D-Bus array and allow extracting of the next element after the array.</p>
<p><b>See also </b><a href="qdbusargument.html#beginArray-1">beginArray</a>().</p>
<!-- @@@endArray -->
<!-- $$$endMap[overload1]$$$endMap -->
<h3 class="fn" id="endMap"><a name="endMap"></a><span class="type">void</span> QDBusArgument::<span class="name">endMap</span>()</h3>
<p>Closes a D-Bus map opened with <a href="qdbusargument.html#beginMap-1">beginMap</a>(). This function must be called same number of times that <a href="qdbusargument.html#beginMap-1">beginMap</a>() is called.</p>
<p><b>See also </b><a href="qdbusargument.html#beginMap-1">beginMap</a>(), <a href="qdbusargument.html#endStructure">endStructure</a>(), and <a href="qdbusargument.html#endArray">endArray</a>().</p>
<!-- @@@endMap -->
<!-- $$$endMap$$$endMap -->
<h3 class="fn" id="endMap-1"><a name="endMap-1"></a><span class="type">void</span> QDBusArgument::<span class="name">endMap</span>() const</h3>
<p>Closes the D-Bus map and allow extracting of the next element after the map.</p>
<p><b>See also </b><a href="qdbusargument.html#beginMap-1">beginMap</a>().</p>
<!-- @@@endMap -->
<!-- $$$endMapEntry[overload1]$$$endMapEntry -->
<h3 class="fn" id="endMapEntry"><a name="endMapEntry"></a><span class="type">void</span> QDBusArgument::<span class="name">endMapEntry</span>()</h3>
<p>Closes a D-Bus map entry opened with <a href="qdbusargument.html#beginMapEntry">beginMapEntry</a>(). This function must be called same number of times that <a href="qdbusargument.html#beginMapEntry">beginMapEntry</a>() is called.</p>
<p><b>See also </b><a href="qdbusargument.html#beginMapEntry">beginMapEntry</a>().</p>
<!-- @@@endMapEntry -->
<!-- $$$endMapEntry$$$endMapEntry -->
<h3 class="fn" id="endMapEntry-1"><a name="endMapEntry-1"></a><span class="type">void</span> QDBusArgument::<span class="name">endMapEntry</span>() const</h3>
<p>Closes the D-Bus map entry and allow extracting of the next element on the map.</p>
<p><b>See also </b><a href="qdbusargument.html#beginMapEntry">beginMapEntry</a>().</p>
<!-- @@@endMapEntry -->
<!-- $$$endStructure[overload1]$$$endStructure -->
<h3 class="fn" id="endStructure"><a name="endStructure"></a><span class="type">void</span> QDBusArgument::<span class="name">endStructure</span>()</h3>
<p>Closes a D-Bus structure opened with <a href="qdbusargument.html#beginStructure">beginStructure</a>(). This function must be called same number of times that <a href="qdbusargument.html#beginStructure">beginStructure</a>() is called.</p>
<p><b>See also </b><a href="qdbusargument.html#beginStructure">beginStructure</a>(), <a href="qdbusargument.html#endArray">endArray</a>(), and <a href="qdbusargument.html#endMap">endMap</a>().</p>
<!-- @@@endStructure -->
<!-- $$$endStructure$$$endStructure -->
<h3 class="fn" id="endStructure-1"><a name="endStructure-1"></a><span class="type">void</span> QDBusArgument::<span class="name">endStructure</span>() const</h3>
<p>Closes the D-Bus structure and allow extracting of the next element after the structure.</p>
<p><b>See also </b><a href="qdbusargument.html#beginStructure">beginStructure</a>().</p>
<!-- @@@endStructure -->
<!-- $$$swap[overload1]$$$swapQDBusArgument& -->
<h3 class="fn" id="swap"><a name="swap"></a><span class="type">void</span> QDBusArgument::<span class="name">swap</span>(<span class="type"><a href="qdbusargument.html#QDBusArgument">QDBusArgument</a></span> &<i>other</i>)</h3>
<!-- @@@swap -->
<!-- $$$operator<<[overload1]$$$operator<<uchar -->
<h3 class="fn" id="operator-lt-lt"><a name="operator-lt-lt"></a><span class="type"><a href="qdbusargument.html#QDBusArgument">QDBusArgument</a></span> &QDBusArgument::<span class="name">operator<<</span>(<span class="type"><a href="../qtcore/qtglobal.html#uchar-typedef">uchar</a></span> <i>arg</i>)</h3>
<p>Appends the primitive value <i>arg</i> of type <code>BYTE</code> to the D-Bus stream.</p>
<!-- @@@operator<< -->
<!-- $$$operator<<$$$operator<<bool -->
<h3 class="fn" id="operator-lt-lt-1"><a name="operator-lt-lt-1"></a><span class="type"><a href="qdbusargument.html#QDBusArgument">QDBusArgument</a></span> &QDBusArgument::<span class="name">operator<<</span>(<span class="type">bool</span> <i>arg</i>)</h3>
<p>This is an overloaded function.</p>
<p>Appends the primitive value <i>arg</i> of type <code>BOOLEAN</code> to the D-Bus stream.</p>
<!-- @@@operator<< -->
<!-- $$$operator<<$$$operator<<short -->
<h3 class="fn" id="operator-lt-lt-2"><a name="operator-lt-lt-2"></a><span class="type"><a href="qdbusargument.html#QDBusArgument">QDBusArgument</a></span> &QDBusArgument::<span class="name">operator<<</span>(<span class="type">short</span> <i>arg</i>)</h3>
<p>This is an overloaded function.</p>
<p>Appends the primitive value <i>arg</i> of type <code>INT16</code> to the D-Bus stream.</p>
<!-- @@@operator<< -->
<!-- $$$operator<<$$$operator<<ushort -->
<h3 class="fn" id="operator-lt-lt-3"><a name="operator-lt-lt-3"></a><span class="type"><a href="qdbusargument.html#QDBusArgument">QDBusArgument</a></span> &QDBusArgument::<span class="name">operator<<</span>(<span class="type"><a href="../qtcore/qtglobal.html#ushort-typedef">ushort</a></span> <i>arg</i>)</h3>
<p>This is an overloaded function.</p>
<p>Appends the primitive value <i>arg</i> of type <code>UINT16</code> to the D-Bus stream.</p>
<!-- @@@operator<< -->
<!-- $$$operator<<$$$operator<<int -->
<h3 class="fn" id="operator-lt-lt-4"><a name="operator-lt-lt-4"></a><span class="type"><a href="qdbusargument.html#QDBusArgument">QDBusArgument</a></span> &QDBusArgument::<span class="name">operator<<</span>(<span class="type">int</span> <i>arg</i>)</h3>
<p>This is an overloaded function.</p>
<p>Appends the primitive value <i>arg</i> of type <code>INT32</code> to the D-Bus stream.</p>
<!-- @@@operator<< -->
<!-- $$$operator<<$$$operator<<uint -->
<h3 class="fn" id="operator-lt-lt-5"><a name="operator-lt-lt-5"></a><span class="type"><a href="qdbusargument.html#QDBusArgument">QDBusArgument</a></span> &QDBusArgument::<span class="name">operator<<</span>(<span class="type"><a href="../qtcore/qtglobal.html#uint-typedef">uint</a></span> <i>arg</i>)</h3>
<p>This is an overloaded function.</p>
<p>Appends the primitive value <i>arg</i> of type <code>UINT32</code> to the D-Bus stream.</p>
<!-- @@@operator<< -->
<!-- $$$operator<<$$$operator<<qlonglong -->
<h3 class="fn" id="operator-lt-lt-6"><a name="operator-lt-lt-6"></a><span class="type"><a href="qdbusargument.html#QDBusArgument">QDBusArgument</a></span> &QDBusArgument::<span class="name">operator<<</span>(<span class="type"><a href="../qtcore/qtglobal.html#qlonglong-typedef">qlonglong</a></span> <i>arg</i>)</h3>
<p>This is an overloaded function.</p>
<p>Appends the primitive value <i>arg</i> of type <code>INT64</code> to the D-Bus stream.</p>
<!-- @@@operator<< -->
<!-- $$$operator<<$$$operator<<qulonglong -->
<h3 class="fn" id="operator-lt-lt-7"><a name="operator-lt-lt-7"></a><span class="type"><a href="qdbusargument.html#QDBusArgument">QDBusArgument</a></span> &QDBusArgument::<span class="name">operator<<</span>(<span class="type"><a href="../qtcore/qtglobal.html#qulonglong-typedef">qulonglong</a></span> <i>arg</i>)</h3>
<p>This is an overloaded function.</p>
<p>Appends the primitive value <i>arg</i> of type <code>UINT64</code> to the D-Bus stream.</p>
<!-- @@@operator<< -->
<!-- $$$operator<<$$$operator<<double -->
<h3 class="fn" id="operator-lt-lt-8"><a name="operator-lt-lt-8"></a><span class="type"><a href="qdbusargument.html#QDBusArgument">QDBusArgument</a></span> &QDBusArgument::<span class="name">operator<<</span>(<span class="type">double</span> <i>arg</i>)</h3>
<p>This is an overloaded function.</p>
<p>Appends the primitive value <i>arg</i> of type <code>DOUBLE</code> (double-precision floating-point) to the D-Bus stream.</p>
<!-- @@@operator<< -->
<!-- $$$operator<<$$$operator<<constQString& -->
<h3 class="fn" id="operator-lt-lt-9"><a name="operator-lt-lt-9"></a><span class="type"><a href="qdbusargument.html#QDBusArgument">QDBusArgument</a></span> &QDBusArgument::<span class="name">operator<<</span>(const <span class="type"><a href="../qtcore/qstring.html">QString</a></span> &<i>arg</i>)</h3>
<p>This is an overloaded function.</p>
<p>Appends the primitive value <i>arg</i> of type <code>STRING</code> (Unicode character string) to the D-Bus stream.</p>
<!-- @@@operator<< -->
<!-- $$$operator<<$$$operator<<constQDBusVariant& -->
<h3 class="fn" id="operator-lt-lt-10"><a name="operator-lt-lt-10"></a><span class="type"><a href="qdbusargument.html#QDBusArgument">QDBusArgument</a></span> &QDBusArgument::<span class="name">operator<<</span>(const <span class="type"><a href="qdbusvariant.html">QDBusVariant</a></span> &<i>arg</i>)</h3>
<p>This is an overloaded function.</p>
<p>Appends the primitive value <i>arg</i> of type <code>VARIANT</code> to the D-Bus stream.</p>
<p>A D-Bus variant type can contain any type, including other variants. It is similar to the Qt <a href="../qtcore/qvariant.html">QVariant</a> type.</p>
<!-- @@@operator<< -->
<!-- $$$operator<<$$$operator<<constQStringList& -->
<h3 class="fn" id="operator-lt-lt-14"><a name="operator-lt-lt-14"></a><span class="type"><a href="qdbusargument.html#QDBusArgument">QDBusArgument</a></span> &QDBusArgument::<span class="name">operator<<</span>(const <span class="type"><a href="../qtcore/qstringlist.html">QStringList</a></span> &<i>arg</i>)</h3>
<p>This is an overloaded function.</p>
<p>Appends the <a href="../qtcore/qstringlist.html">QStringList</a> given by <i>arg</i> as <code>ARRAY of STRING</code> to the D-Bus stream.</p>
<p><a href="../qtcore/qstringlist.html">QStringList</a> and <a href="../qtcore/qbytearray.html">QByteArray</a> are the only two non-primitive types that are supported directly by <a href="qdbusargument.html">QDBusArgument</a> because of their widespread usage in Qt applications.</p>
<p>Other arrays are supported through compound types in Qt D-Bus.</p>
<!-- @@@operator<< -->
<!-- $$$operator<<$$$operator<<constQByteArray& -->
<h3 class="fn" id="operator-lt-lt-15"><a name="operator-lt-lt-15"></a><span class="type"><a href="qdbusargument.html#QDBusArgument">QDBusArgument</a></span> &QDBusArgument::<span class="name">operator<<</span>(const <span class="type"><a href="../qtcore/qbytearray.html">QByteArray</a></span> &<i>arg</i>)</h3>
<p>This is an overloaded function.</p>
<p>Appends the <a href="../qtcore/qbytearray.html">QByteArray</a> given by <i>arg</i> as <code>ARRAY of BYTE</code> to the D-Bus stream.</p>
<p><a href="../qtcore/qstringlist.html">QStringList</a> and <a href="../qtcore/qbytearray.html">QByteArray</a> are the only two non-primitive types that are supported directly by <a href="qdbusargument.html">QDBusArgument</a> because of their widespread usage in Qt applications.</p>
<p>Other arrays are supported through compound types in Qt D-Bus.</p>
<!-- @@@operator<< -->
<!-- $$$operator=[overload1]$$$operator=QDBusArgument&& -->
<h3 class="fn" id="operator-eq"><a name="operator-eq"></a><span class="type"><a href="qdbusargument.html#QDBusArgument">QDBusArgument</a></span> &QDBusArgument::<span class="name">operator=</span>(<span class="type"><a href="qdbusargument.html#QDBusArgument">QDBusArgument</a></span> &&<i>other</i>)</h3>
<p>Move-assignment operator.</p><!-- @@@operator= -->
<!-- $$$operator=$$$operator=constQDBusArgument& -->
<h3 class="fn" id="operator-eq-1"><a name="operator-eq-1"></a><span class="type"><a href="qdbusargument.html#QDBusArgument">QDBusArgument</a></span> &QDBusArgument::<span class="name">operator=</span>(const <span class="type"><a href="qdbusargument.html#QDBusArgument">QDBusArgument</a></span> &<i>other</i>)</h3>
<p>Copies the <i>other</i> <a href="qdbusargument.html">QDBusArgument</a> object into this one.</p>
<p>Both objects will therefore contain the same state from this point forward. QDBusArguments are explicitly shared and, therefore, any modification to either copy will affect the other one too.</p>
<!-- @@@operator= -->
<!-- $$$operator>>[overload1]$$$operator>>uchar& -->
<h3 class="fn" id="operator-gt-gt"><a name="operator-gt-gt"></a>const <span class="type"><a href="qdbusargument.html#QDBusArgument">QDBusArgument</a></span> &QDBusArgument::<span class="name">operator>></span>(<span class="type"><a href="../qtcore/qtglobal.html#uchar-typedef">uchar</a></span> &<i>arg</i>) const</h3>
<p>Extracts one D-BUS primitive argument of type <code>BYTE</code> from the D-BUS stream and puts it into <i>arg</i>.</p>
<!-- @@@operator>> -->
<!-- $$$operator>>$$$operator>>bool& -->
<h3 class="fn" id="operator-gt-gt-1"><a name="operator-gt-gt-1"></a>const <span class="type"><a href="qdbusargument.html#QDBusArgument">QDBusArgument</a></span> &QDBusArgument::<span class="name">operator>></span>(<span class="type">bool</span> &<i>arg</i>) const</h3>
<p>This is an overloaded function.</p>
<p>Extracts one D-Bus primitive argument of type <code>BOOLEAN</code> from the D-Bus stream.</p>
<!-- @@@operator>> -->
<!-- $$$operator>>$$$operator>>short& -->
<h3 class="fn" id="operator-gt-gt-2"><a name="operator-gt-gt-2"></a>const <span class="type"><a href="qdbusargument.html#QDBusArgument">QDBusArgument</a></span> &QDBusArgument::<span class="name">operator>></span>(<span class="type">short</span> &<i>arg</i>) const</h3>
<p>This is an overloaded function.</p>
<p>Extracts one D-Bus primitive argument of type <code>INT16</code> from the D-Bus stream.</p>
<!-- @@@operator>> -->
<!-- $$$operator>>$$$operator>>ushort& -->
<h3 class="fn" id="operator-gt-gt-3"><a name="operator-gt-gt-3"></a>const <span class="type"><a href="qdbusargument.html#QDBusArgument">QDBusArgument</a></span> &QDBusArgument::<span class="name">operator>></span>(<span class="type"><a href="../qtcore/qtglobal.html#ushort-typedef">ushort</a></span> &<i>arg</i>) const</h3>
<p>This is an overloaded function.</p>
<p>Extracts one D-Bus primitive argument of type <code>UINT16</code> from the D-Bus stream.</p>
<!-- @@@operator>> -->
<!-- $$$operator>>$$$operator>>int& -->
<h3 class="fn" id="operator-gt-gt-4"><a name="operator-gt-gt-4"></a>const <span class="type"><a href="qdbusargument.html#QDBusArgument">QDBusArgument</a></span> &QDBusArgument::<span class="name">operator>></span>(<span class="type">int</span> &<i>arg</i>) const</h3>
<p>This is an overloaded function.</p>
<p>Extracts one D-Bus primitive argument of type <code>INT32</code> from the D-Bus stream.</p>
<!-- @@@operator>> -->
<!-- $$$operator>>$$$operator>>uint& -->
<h3 class="fn" id="operator-gt-gt-5"><a name="operator-gt-gt-5"></a>const <span class="type"><a href="qdbusargument.html#QDBusArgument">QDBusArgument</a></span> &QDBusArgument::<span class="name">operator>></span>(<span class="type"><a href="../qtcore/qtglobal.html#uint-typedef">uint</a></span> &<i>arg</i>) const</h3>
<p>This is an overloaded function.</p>
<p>Extracts one D-Bus primitive argument of type <code>UINT32</code> from the D-Bus stream.</p>
<!-- @@@operator>> -->
<!-- $$$operator>>$$$operator>>qlonglong& -->
<h3 class="fn" id="operator-gt-gt-6"><a name="operator-gt-gt-6"></a>const <span class="type"><a href="qdbusargument.html#QDBusArgument">QDBusArgument</a></span> &QDBusArgument::<span class="name">operator>></span>(<span class="type"><a href="../qtcore/qtglobal.html#qlonglong-typedef">qlonglong</a></span> &<i>arg</i>) const</h3>
<p>This is an overloaded function.</p>
<p>Extracts one D-Bus primitive argument of type <code>INT64</code> from the D-Bus stream.</p>
<!-- @@@operator>> -->
<!-- $$$operator>>$$$operator>>qulonglong& -->
<h3 class="fn" id="operator-gt-gt-7"><a name="operator-gt-gt-7"></a>const <span class="type"><a href="qdbusargument.html#QDBusArgument">QDBusArgument</a></span> &QDBusArgument::<span class="name">operator>></span>(<span class="type"><a href="../qtcore/qtglobal.html#qulonglong-typedef">qulonglong</a></span> &<i>arg</i>) const</h3>
<p>This is an overloaded function.</p>
<p>Extracts one D-Bus primitive argument of type <code>UINT64</code> from the D-Bus stream.</p>
<!-- @@@operator>> -->
<!-- $$$operator>>$$$operator>>double& -->
<h3 class="fn" id="operator-gt-gt-8"><a name="operator-gt-gt-8"></a>const <span class="type"><a href="qdbusargument.html#QDBusArgument">QDBusArgument</a></span> &QDBusArgument::<span class="name">operator>></span>(<span class="type">double</span> &<i>arg</i>) const</h3>
<p>This is an overloaded function.</p>
<p>Extracts one D-Bus primitive argument of type <code>DOUBLE</code> (double-precision floating pount) from the D-Bus stream.</p>
<!-- @@@operator>> -->
<!-- $$$operator>>$$$operator>>QString& -->
<h3 class="fn" id="operator-gt-gt-9"><a name="operator-gt-gt-9"></a>const <span class="type"><a href="qdbusargument.html#QDBusArgument">QDBusArgument</a></span> &QDBusArgument::<span class="name">operator>></span>(<span class="type"><a href="../qtcore/qstring.html">QString</a></span> &<i>arg</i>) const</h3>
<p>This is an overloaded function.</p>
<p>Extracts one D-Bus primitive argument of type <code>STRING</code> (Unicode character string) from the D-Bus stream.</p>
<!-- @@@operator>> -->
<!-- $$$operator>>$$$operator>>QDBusVariant& -->
<h3 class="fn" id="operator-gt-gt-10"><a name="operator-gt-gt-10"></a>const <span class="type"><a href="qdbusargument.html#QDBusArgument">QDBusArgument</a></span> &QDBusArgument::<span class="name">operator>></span>(<span class="type"><a href="qdbusvariant.html">QDBusVariant</a></span> &<i>arg</i>) const</h3>
<p>This is an overloaded function.</p>
<p>Extracts one D-Bus primitive argument of type <code>VARIANT</code> from the D-Bus stream.</p>
<p>A D-Bus variant type can contain any type, including other variants. It is similar to the Qt <a href="../qtcore/qvariant.html">QVariant</a> type.</p>
<p>In case the variant contains a type not directly supported by <a href="qdbusargument.html">QDBusArgument</a>, the value of the returned <a href="qdbusvariant.html">QDBusVariant</a> will contain another <a href="qdbusargument.html">QDBusArgument</a>. It is your responsibility to further demarshall it into another type.</p>
<!-- @@@operator>> -->
<!-- $$$operator>>$$$operator>>QStringList& -->
<h3 class="fn" id="operator-gt-gt-14"><a name="operator-gt-gt-14"></a>const <span class="type"><a href="qdbusargument.html#QDBusArgument">QDBusArgument</a></span> &QDBusArgument::<span class="name">operator>></span>(<span class="type"><a href="../qtcore/qstringlist.html">QStringList</a></span> &<i>arg</i>) const</h3>
<p>This is an overloaded function.</p>
<p>Extracts an array of strings from the D-Bus stream and return it as a <a href="../qtcore/qstringlist.html">QStringList</a>.</p>
<p><a href="../qtcore/qstringlist.html">QStringList</a> and <a href="../qtcore/qbytearray.html">QByteArray</a> are the only two non-primitive types that are supported directly by <a href="qdbusargument.html">QDBusArgument</a> because of their widespread usage in Qt applications.</p>
<p>Other arrays are supported through compound types in Qt D-Bus.</p>
<!-- @@@operator>> -->
<!-- $$$operator>>$$$operator>>QByteArray& -->
<h3 class="fn" id="operator-gt-gt-15"><a name="operator-gt-gt-15"></a>const <span class="type"><a href="qdbusargument.html#QDBusArgument">QDBusArgument</a></span> &QDBusArgument::<span class="name">operator>></span>(<span class="type"><a href="../qtcore/qbytearray.html">QByteArray</a></span> &<i>arg</i>) const</h3>
<p>This is an overloaded function.</p>
<p>Extracts an array of bytes from the D-Bus stream and return it as a <a href="../qtcore/qbytearray.html">QByteArray</a>.</p>
<p><a href="../qtcore/qstringlist.html">QStringList</a> and <a href="../qtcore/qbytearray.html">QByteArray</a> are the only two non-primitive types that are supported directly by <a href="qdbusargument.html">QDBusArgument</a> because of their widespread usage in Qt applications.</p>
<p>Other arrays are supported through compound types in Qt D-Bus.</p>
<!-- @@@operator>> -->
</div>
<div class="relnonmem">
<h2>Related Non-Members</h2>
<!-- $$$qDBusRegisterMetaType[overload1]$$$qDBusRegisterMetaType -->
<h3 class="fn" id="qDBusRegisterMetaType"><a name="qDBusRegisterMetaType"></a><span class="type">int</span> <span class="name">qDBusRegisterMetaType</span>()</h3>
<p>Registers <code>T</code> with the <a href="qdbustypesystem.html">Qt D-Bus Type System</a> and the Qt <a href="../qtcore/qmetatype.html">meta-type system</a>, if it's not already registered.</p>
<p>To register a type, it must be declared as a meta-type with the <a href="../qtcore/qmetatype.html#Q_DECLARE_METATYPE">Q_DECLARE_METATYPE</a>() macro, and then registered as in the following example:</p>
<pre class="cpp">
<span class="preprocessor">#include <QDBusMetaType></span>
qDBusRegisterMetaType<span class="operator"><</span>MyClass<span class="operator">></span>();
</pre>
<p>If <code>T</code> isn't one of Qt's <a href="../qtcore/containers.html">container classes</a>, the <code>operator<<</code> and <code>operator>></code> streaming operators between <code>T</code> and <a href="qdbusargument.html">QDBusArgument</a> must be already declared. See the <a href="qdbustypesystem.html">Qt D-Bus Type System</a> page for more information on how to declare such types.</p>
<p>This function returns the Qt meta type id for the type (the same value that is returned from <a href="../qtcore/qmetatype.html#qRegisterMetaType-1">qRegisterMetaType</a>()).</p>
<p><b>Note: </b>The feature that a <code>T</code> inheriting a streamable type (including the containers <a href="../qtcore/qlist.html">QList</a>, <a href="../qtcore/qhash.html#qhash">QHash</a> or <a href="../qtcore/qmap.html">QMap</a>) can be streamed without providing custom <code>operator<<</code> and <code>operator>></code> is deprecated as of Qt 5.7, because it ignores everything in <code>T</code> except the base class. There is no diagnostic. You should always provide these operators for all types you wish to stream and not rely on Qt-provided stream operators for base classes.</p><p><b>Note:</b> This function is thread-safe.</p>
<p>This function was introduced in Qt 4.2.</p>
<p><b>See also </b><a href="qdbustypesystem.html">Qt D-Bus Type System</a>, <a href="../qtcore/qmetatype.html#qRegisterMetaType-1">qRegisterMetaType</a>(), and <a href="../qtcore/qmetatype.html">QMetaType</a>.</p>
<!-- @@@qDBusRegisterMetaType -->
<!-- $$$qdbus_cast[overload1]$$$qdbus_castconstQDBusArgument& -->
<h3 class="fn" id="qdbus_cast"><a name="qdbus_cast"></a><span class="type">T</span> <span class="name">qdbus_cast</span>(const <span class="type"><a href="qdbusargument.html#QDBusArgument">QDBusArgument</a></span> &<i>argument</i>)</h3>
<p>Attempts to demarshall the contents of <i>argument</i> into the type <code>T</code>. For example:</p>
<pre class="cpp">
MyType item <span class="operator">=</span> qdbus_cast<span class="operator"><</span>Type<span class="operator">></span>(argument);
</pre>
<p>Note that it is equivalent to the following:</p>
<pre class="cpp">
MyType item;
argument <span class="operator">></span><span class="operator">></span> item;
</pre>
<p>This function was introduced in Qt 4.2.</p>
<!-- @@@qdbus_cast -->
</div>
</div>
</div>
</div>
</div>
</div>
<div class="footer">
<p>
<acronym title="Copyright">©</acronym> 2017 The Qt Company Ltd.
Documentation contributions included herein are the copyrights of
their respective owners.<br> The documentation provided herein is licensed under the terms of the <a href="http://www.gnu.org/licenses/fdl.html">GNU Free Documentation License version 1.3</a> as published by the Free Software Foundation.<br> Qt and respective logos are trademarks of The Qt Company Ltd. in Finland and/or other countries worldwide. All other trademarks are property
of their respective owners. </p>
</div>
</body>
</html>
distrib
>
Mageia
>
6
>
armv5tl
>
media
>
core-updates
>
by-pkgid
>
768f7d9f703884aa2562bf0a651086df
>
files
>
920
