Reformat code

author: Linus Jahn <lnj@kaidan.im> 2022-09-05 20:37:05 +0200
committer: Linus Jahn <lnj@kaidan.im> 2022-09-06 00:46:56 +0200
commit: 5f813f8a4bbe1e075daad7b3933829044befffb4 (patch)
tree: 20102aa665b03cfb6dfe0c6ece94938320b6430e /src/base
parent: 4c60b13e0b8011e4e0b093a690e939f3b23e2436 (diff)
download: qxmpp-5f813f8a4bbe1e075daad7b3933829044befffb4.tar.gz
36 files changed, 922 insertions, 505 deletions
diff --git a/src/base/QXmppArchiveIq.cpp b/src/base/QXmppArchiveIq.cpp
index 592f788c..0bbacf7f 100644
--- a/src/base/QXmppArchiveIq.cpp
+++ b/src/base/QXmppArchiveIq.cpp
@@ -96,12 +96,14 @@ void QXmppArchiveChat::toXml(QXmlStreamWriter *writer, const QXmppResultSetReply
     writer->writeStartElement(QStringLiteral("chat"));
     writer->writeDefaultNamespace(ns_archive);
     helperToXmlAddAttribute(writer, QStringLiteral("with"), m_with);
-    if (m_start.isValid())
+    if (m_start.isValid()) {
         helperToXmlAddAttribute(writer, QStringLiteral("start"), QXmppUtils::datetimeToString(m_start));
+    }
     helperToXmlAddAttribute(writer, QStringLiteral("subject"), m_subject);
     helperToXmlAddAttribute(writer, QStringLiteral("thread"), m_thread);
-    if (m_version)
+    if (m_version) {
         helperToXmlAddAttribute(writer, QStringLiteral("version"), QString::number(m_version));
+    }
 
     QDateTime prevTime = m_start;
 
@@ -112,8 +114,9 @@ void QXmppArchiveChat::toXml(QXmlStreamWriter *writer, const QXmppResultSetReply
         writer->writeEndElement();
         prevTime = message.date();
     }
-    if (!rsm.isNull())
+    if (!rsm.isNull()) {
         rsm.toXml(writer);
+    }
     writer->writeEndElement();
 }
 /// \endcond
@@ -395,18 +398,23 @@ void QXmppArchiveListIq::toXmlElementFromChild(QXmlStreamWriter *writer) const
 {
     writer->writeStartElement(QStringLiteral("list"));
     writer->writeDefaultNamespace(ns_archive);
-    if (!m_with.isEmpty())
+    if (!m_with.isEmpty()) {
         helperToXmlAddAttribute(writer, QStringLiteral("with"), m_with);
-    if (m_start.isValid())
+    }
+    if (m_start.isValid()) {
         helperToXmlAddAttribute(writer, QStringLiteral("start"), QXmppUtils::datetimeToString(m_start));
-    if (m_end.isValid())
+    }
+    if (m_end.isValid()) {
         helperToXmlAddAttribute(writer, QStringLiteral("end"), QXmppUtils::datetimeToString(m_end));
-    if (!m_rsmQuery.isNull())
+    }
+    if (!m_rsmQuery.isNull()) {
         m_rsmQuery.toXml(writer);
-    else if (!m_rsmReply.isNull())
+    } else if (!m_rsmReply.isNull()) {
         m_rsmReply.toXml(writer);
-    for (const auto &chat : m_chats)
+    }
+    for (const auto &chat : m_chats) {
         chat.toXml(writer);
+    }
     writer->writeEndElement();
 }
 
@@ -500,12 +508,15 @@ void QXmppArchiveRemoveIq::toXmlElementFromChild(QXmlStreamWriter *writer) const
 {
     writer->writeStartElement(QStringLiteral("remove"));
     writer->writeDefaultNamespace(ns_archive);
-    if (!m_with.isEmpty())
+    if (!m_with.isEmpty()) {
         helperToXmlAddAttribute(writer, QStringLiteral("with"), m_with);
-    if (m_start.isValid())
+    }
+    if (m_start.isValid()) {
         helperToXmlAddAttribute(writer, QStringLiteral("start"), QXmppUtils::datetimeToString(m_start));
-    if (m_end.isValid())
+    }
+    if (m_end.isValid()) {
         helperToXmlAddAttribute(writer, QStringLiteral("end"), QXmppUtils::datetimeToString(m_end));
+    }
     writer->writeEndElement();
 }
 /// \endcond
@@ -589,8 +600,9 @@ void QXmppArchiveRetrieveIq::toXmlElementFromChild(QXmlStreamWriter *writer) con
     writer->writeDefaultNamespace(ns_archive);
     helperToXmlAddAttribute(writer, QStringLiteral("with"), m_with);
     helperToXmlAddAttribute(writer, QStringLiteral("start"), QXmppUtils::datetimeToString(m_start));
-    if (!m_rsmQuery.isNull())
+    if (!m_rsmQuery.isNull()) {
         m_rsmQuery.toXml(writer);
+    }
     writer->writeEndElement();
 }
 /// \endcond
diff --git a/src/base/QXmppBindIq.cpp b/src/base/QXmppBindIq.cpp
index abc27781..f18c6268 100644
--- a/src/base/QXmppBindIq.cpp
+++ b/src/base/QXmppBindIq.cpp
@@ -64,10 +64,12 @@ void QXmppBindIq::toXmlElementFromChild(QXmlStreamWriter *writer) const
 {
     writer->writeStartElement(QStringLiteral("bind"));
     writer->writeDefaultNamespace(ns_bind);
-    if (!m_jid.isEmpty())
+    if (!m_jid.isEmpty()) {
         helperToXmlAddTextElement(writer, QStringLiteral("jid"), m_jid);
-    if (!m_resource.isEmpty())
+    }
+    if (!m_resource.isEmpty()) {
         helperToXmlAddTextElement(writer, QStringLiteral("resource"), m_resource);
+    }
     writer->writeEndElement();
 }
 /// \endcond
diff --git a/src/base/QXmppBitsOfBinaryContentId.cpp b/src/base/QXmppBitsOfBinaryContentId.cpp
index 877e08f7..a348b2f8 100644
--- a/src/base/QXmppBitsOfBinaryContentId.cpp
+++ b/src/base/QXmppBitsOfBinaryContentId.cpp
@@ -78,8 +78,9 @@ QXmppBitsOfBinaryContentIdPrivate::QXmppBitsOfBinaryContentIdPrivate()
 ///
 QXmppBitsOfBinaryContentId QXmppBitsOfBinaryContentId::fromCidUrl(const QString &input)
 {
-    if (input.startsWith(CONTENTID_URL))
+    if (input.startsWith(CONTENTID_URL)) {
         return fromContentId(input.mid(CONTENTID_URL_LENGTH));
+    }
 
     return {};
 }
@@ -98,19 +99,22 @@ QXmppBitsOfBinaryContentId QXmppBitsOfBinaryContentId::fromCidUrl(const QString
 ///
 QXmppBitsOfBinaryContentId QXmppBitsOfBinaryContentId::fromContentId(const QString &input)
 {
-    if (input.startsWith(CONTENTID_URL) || !input.endsWith(CONTENTID_POSTFIX))
+    if (input.startsWith(CONTENTID_URL) || !input.endsWith(CONTENTID_POSTFIX)) {
         return {};
+    }
 
     // remove '@bob.xmpp.org'
     QString hashAndAlgoStr = input.left(input.size() - CONTENTID_POSTFIX_LENGTH);
     // get size of hash algo id
     QStringList algoAndHash = hashAndAlgoStr.split(CONTENTID_HASH_SEPARATOR);
-    if (algoAndHash.size() != 2)
+    if (algoAndHash.size() != 2) {
         return {};
+    }
 
     QCryptographicHash::Algorithm algo = HASH_ALGORITHMS.key(algoAndHash.first(), QCryptographicHash::Algorithm(-1));
-    if (int(algo) == -1)
+    if (int(algo) == -1) {
         return {};
+    }
 
     QXmppBitsOfBinaryContentId cid;
     cid.setAlgorithm(algo);
@@ -151,8 +155,9 @@ QXmppBitsOfBinaryContentId &QXmppBitsOfBinaryContentId::operator=(QXmppBitsOfBin
 ///
 QString QXmppBitsOfBinaryContentId::toContentId() const
 {
-    if (!isValid())
+    if (!isValid()) {
         return {};
+    }
 
     return HASH_ALGORITHMS.value(d->algorithm) +
         CONTENTID_HASH_SEPARATOR +
@@ -165,8 +170,9 @@ QString QXmppBitsOfBinaryContentId::toContentId() const
 ///
 QString QXmppBitsOfBinaryContentId::toCidUrl() const
 {
-    if (!isValid())
+    if (!isValid()) {
         return {};
+    }
 
     return toContentId().prepend(CONTENTID_URL);
 }
diff --git a/src/base/QXmppBitsOfBinaryData.cpp b/src/base/QXmppBitsOfBinaryData.cpp
index 51f20bc4..1592a2e5 100644
--- a/src/base/QXmppBitsOfBinaryData.cpp
+++ b/src/base/QXmppBitsOfBinaryData.cpp
@@ -158,8 +158,9 @@ void QXmppBitsOfBinaryData::toXmlElementFromChild(QXmlStreamWriter *writer) cons
     writer->writeStartElement(QStringLiteral("data"));
     writer->writeDefaultNamespace(ns_bob);
     helperToXmlAddAttribute(writer, QStringLiteral("cid"), d->cid.toContentId());
-    if (d->maxAge > -1)
+    if (d->maxAge > -1) {
         helperToXmlAddAttribute(writer, QStringLiteral("max-age"), QString::number(d->maxAge));
+    }
     helperToXmlAddAttribute(writer, QStringLiteral("type"), d->contentType.name());
     writer->writeCharacters(d->data.toBase64());
     writer->writeEndElement();
diff --git a/src/base/QXmppBitsOfBinaryIq.cpp b/src/base/QXmppBitsOfBinaryIq.cpp
index e7256997..b55b7aa2 100644
--- a/src/base/QXmppBitsOfBinaryIq.cpp
+++ b/src/base/QXmppBitsOfBinaryIq.cpp
@@ -32,8 +32,9 @@ bool QXmppBitsOfBinaryIq::isBitsOfBinaryIq(const QDomElement &element)
 {
     QDomElement child = element.firstChildElement();
     while (!child.isNull()) {
-        if (QXmppBitsOfBinaryData::isBitsOfBinaryData(child))
+        if (QXmppBitsOfBinaryData::isBitsOfBinaryData(child)) {
             return true;
+        }
         child = child.nextSiblingElement();
     }
     return false;
diff --git a/src/base/QXmppBookmarkSet.cpp b/src/base/QXmppBookmarkSet.cpp
index bf6388db..35808e1d 100644
--- a/src/base/QXmppBookmarkSet.cpp
+++ b/src/base/QXmppBookmarkSet.cpp
@@ -190,12 +190,14 @@ void QXmppBookmarkSet::toXml(QXmlStreamWriter *writer) const
     writer->writeDefaultNamespace(ns_bookmarks);
     for (const auto &conference : m_conferences) {
         writer->writeStartElement(QStringLiteral("conference"));
-        if (conference.autoJoin())
+        if (conference.autoJoin()) {
             helperToXmlAddAttribute(writer, QStringLiteral("autojoin"), QStringLiteral("true"));
+        }
         helperToXmlAddAttribute(writer, QStringLiteral("jid"), conference.jid());
         helperToXmlAddAttribute(writer, QStringLiteral("name"), conference.name());
-        if (!conference.nickName().isEmpty())
+        if (!conference.nickName().isEmpty()) {
             helperToXmlAddTextElement(writer, QStringLiteral("nick"), conference.nickName());
+        }
         writer->writeEndElement();
     }
     for (const auto &url : m_urls) {
diff --git a/src/base/QXmppByteStreamIq.cpp b/src/base/QXmppByteStreamIq.cpp
index 0bd921b6..84fad3ec 100644
--- a/src/base/QXmppByteStreamIq.cpp
+++ b/src/base/QXmppByteStreamIq.cpp
@@ -159,12 +159,13 @@ void QXmppByteStreamIq::parseElementFromChild(const QDomElement &element)
     auto queryElement = element.firstChildElement(QStringLiteral("query"));
     m_sid = queryElement.attribute(QStringLiteral("sid"));
     const auto modeStr = queryElement.attribute(QStringLiteral("mode"));
-    if (modeStr == QStringLiteral("tcp"))
+    if (modeStr == QStringLiteral("tcp")) {
         m_mode = Tcp;
-    else if (modeStr == QStringLiteral("udp"))
+    } else if (modeStr == QStringLiteral("udp")) {
         m_mode = Udp;
-    else
+    } else {
         m_mode = None;
+    }
 
     QDomElement hostElement = queryElement.firstChildElement(QStringLiteral("streamhost"));
     while (!hostElement.isNull()) {
@@ -187,10 +188,11 @@ void QXmppByteStreamIq::toXmlElementFromChild(QXmlStreamWriter *writer) const
     writer->writeDefaultNamespace(ns_bytestreams);
     helperToXmlAddAttribute(writer, QStringLiteral("sid"), m_sid);
     QString modeStr;
-    if (m_mode == Tcp)
+    if (m_mode == Tcp) {
         modeStr = QStringLiteral("tcp");
-    else if (m_mode == Udp)
+    } else if (m_mode == Udp) {
         modeStr = QStringLiteral("udp");
+    }
     helperToXmlAddAttribute(writer, QStringLiteral("mode"), modeStr);
     for (const auto &streamHost : m_streamHosts) {
         writer->writeStartElement(QStringLiteral("streamhost"));
@@ -200,8 +202,9 @@ void QXmppByteStreamIq::toXmlElementFromChild(QXmlStreamWriter *writer) const
         helperToXmlAddAttribute(writer, QStringLiteral("zeroconf"), streamHost.zeroconf());
         writer->writeEndElement();
     }
-    if (!m_activate.isEmpty())
+    if (!m_activate.isEmpty()) {
         helperToXmlAddTextElement(writer, QStringLiteral("activate"), m_activate);
+    }
     if (!m_streamHostUsed.isEmpty()) {
         writer->writeStartElement(QStringLiteral("streamhost-used"));
         helperToXmlAddAttribute(writer, QStringLiteral("jid"), m_streamHostUsed);
diff --git a/src/base/QXmppDataForm.cpp b/src/base/QXmppDataForm.cpp
index 9f68046c..ced40875 100644
--- a/src/base/QXmppDataForm.cpp
+++ b/src/base/QXmppDataForm.cpp
@@ -63,14 +63,18 @@ QString fieldTypeToString(QXmppDataForm::Field::Type type)
 
 std::optional<QXmppDataForm::Type> formTypeFromString(const QString &type)
 {
-    if (type == "form")
+    if (type == "form") {
         return QXmppDataForm::Form;
-    if (type == "submit")
+    }
+    if (type == "submit") {
         return QXmppDataForm::Submit;
-    if (type == "cancel")
+    }
+    if (type == "cancel") {
         return QXmppDataForm::Cancel;
-    if (type == "result")
+    }
+    if (type == "result") {
         return QXmppDataForm::Result;
+    }
     return {};
 }
 
@@ -786,8 +790,9 @@ bool QXmppDataForm::isNull() const
 /// \cond
 void QXmppDataForm::parse(const QDomElement &element)
 {
-    if (element.isNull())
+    if (element.isNull()) {
         return;
+    }
 
     /* form type */
     if (const auto type = formTypeFromString(element.attribute("type"))) {
@@ -879,8 +884,9 @@ void QXmppDataForm::parse(const QDomElement &element)
 
 void QXmppDataForm::toXml(QXmlStreamWriter *writer) const
 {
-    if (isNull())
+    if (isNull()) {
         return;
+    }
 
     writer->writeStartElement("x");
     writer->writeDefaultNamespace(ns_data);
@@ -889,10 +895,12 @@ void QXmppDataForm::toXml(QXmlStreamWriter *writer) const
     writer->writeAttribute("type", formTypeToString(d->type));
 
     /* form properties */
-    if (!d->title.isEmpty())
+    if (!d->title.isEmpty()) {
         writer->writeTextElement("title", d->title);
-    if (!d->instructions.isEmpty())
+    }
+    if (!d->instructions.isEmpty()) {
         writer->writeTextElement("instructions", d->instructions);
+    }
 
     for (const auto &field : d->fields) {
         writer->writeStartElement("field");
@@ -930,16 +938,18 @@ void QXmppDataForm::toXml(QXmlStreamWriter *writer) const
             writer->writeDefaultNamespace(ns_media_element);
 
             // media width and height
-            if (field.mediaSize().width() > 0)
+            if (field.mediaSize().width() > 0) {
                 helperToXmlAddAttribute(
                     writer,
                     QStringLiteral("width"),
                     QString::number(field.mediaSize().width()));
-            if (field.mediaSize().height() > 0)
+            }
+            if (field.mediaSize().height() > 0) {
                 helperToXmlAddAttribute(
                     writer,
                     QStringLiteral("height"),
                     QString::number(field.mediaSize().height()));
+            }
 
             const auto sources = field.mediaSources();
             for (const auto &source : sources) {
@@ -969,10 +979,12 @@ void QXmppDataForm::toXml(QXmlStreamWriter *writer) const
         }
 
         /* other properties */
-        if (!field.description().isEmpty())
+        if (!field.description().isEmpty()) {
             helperToXmlAddTextElement(writer, "description", field.description());
-        if (field.isRequired())
+        }
+        if (field.isRequired()) {
             helperToXmlAddTextElement(writer, "required", "");
+        }
 
         writer->writeEndElement();
     }
diff --git a/src/base/QXmppDiscoveryIq.cpp b/src/base/QXmppDiscoveryIq.cpp
index 93e1c444..99860c9b 100644
--- a/src/base/QXmppDiscoveryIq.cpp
+++ b/src/base/QXmppDiscoveryIq.cpp
@@ -13,25 +13,29 @@
 
 static bool identityLessThan(const QXmppDiscoveryIq::Identity &i1, const QXmppDiscoveryIq::Identity &i2)
 {
-    if (i1.category() < i2.category())
+    if (i1.category() < i2.category()) {
         return true;
-    else if (i1.category() > i2.category())
+    } else if (i1.category() > i2.category()) {
         return false;
+    }
 
-    if (i1.type() < i2.type())
+    if (i1.type() < i2.type()) {
         return true;
-    else if (i1.type() > i2.type())
+    } else if (i1.type() > i2.type()) {
         return false;
+    }
 
-    if (i1.language() < i2.language())
+    if (i1.language() < i2.language()) {
         return true;
-    else if (i1.language() > i2.language())
+    } else if (i1.language() > i2.language()) {
         return false;
+    }
 
-    if (i1.name() < i2.name())
+    if (i1.name() < i2.name()) {
         return true;
-    else if (i1.name() > i2.name())
+    } else if (i1.name() > i2.name()) {
         return false;
+    }
 
     return false;
 }
@@ -381,10 +385,12 @@ QByteArray QXmppDiscoveryIq::verificationString() const
     QStringList sortedFeatures = d->features;
     std::sort(sortedFeatures.begin(), sortedFeatures.end());
     sortedFeatures.removeDuplicates();
-    for (const auto &identity : sortedIdentities)
+    for (const auto &identity : sortedIdentities) {
         S += QString("%1/%2/%3/%4<").arg(identity.category(), identity.type(), identity.language(), identity.name());
-    for (const auto &feature : sortedFeatures)
+    }
+    for (const auto &feature : sortedFeatures) {
         S += feature + QLatin1String("<");
+    }
 
     if (!d->form.isNull()) {
         QMap<QString, QXmppDataForm::Field> fieldMap;
@@ -437,10 +443,11 @@ void QXmppDiscoveryIq::parseElementFromChild(const QDomElement &element)
 {
     QDomElement queryElement = element.firstChildElement("query");
     d->queryNode = queryElement.attribute("node");
-    if (queryElement.namespaceURI() == ns_disco_items)
+    if (queryElement.namespaceURI() == ns_disco_items) {
         d->queryType = ItemsQuery;
-    else
+    } else {
         d->queryType = InfoQuery;
+    }
 
     QDomElement itemElement = queryElement.firstChildElement();
     while (!itemElement.isNull()) {
diff --git a/src/base/QXmppElement.cpp b/src/base/QXmppElement.cpp
index 5399b6cf..cbc5920b 100644
--- a/src/base/QXmppElement.cpp
+++ b/src/base/QXmppElement.cpp
@@ -29,14 +29,16 @@ public:
 
 QXmppElementPrivate::QXmppElementPrivate(const QDomElement &element)
 {
-    if (element.isNull())
+    if (element.isNull()) {
         return;
+    }
 
     name = element.tagName();
     QString xmlns = element.namespaceURI();
     QString parentns = element.parentNode().namespaceURI();
-    if (!xmlns.isEmpty() && xmlns != parentns)
+    if (!xmlns.isEmpty() && xmlns != parentns) {
         attributes.insert("xmlns", xmlns);
+    }
     QDomNamedNodeMap attrs = element.attributes();
     for (int i = 0; i < attrs.size(); i++) {
         QDomAttr attr = attrs.item(i).toAttr();
@@ -107,8 +109,9 @@ QXmppElement::QXmppElement(const QDomElement &element)
 
 QXmppElement::~QXmppElement()
 {
-    if (!d->counter.deref())
+    if (!d->counter.deref()) {
         delete d;
+    }
 }
 
 ///
@@ -119,8 +122,9 @@ QXmppElement &QXmppElement::operator=(const QXmppElement &other)
     // self-assignment check
     if (this != &other) {
         other.d->counter.ref();
-        if (!d->counter.deref())
+        if (!d->counter.deref()) {
             delete d;
+        }
         d = other.d;
     }
     return *this;
@@ -134,8 +138,9 @@ QXmppElement &QXmppElement::operator=(const QXmppElement &other)
 ///
 QDomElement QXmppElement::sourceDomElement() const
 {
-    if (d->serializedSource.isEmpty())
+    if (d->serializedSource.isEmpty()) {
         return QDomElement();
+    }
 
     QDomDocument doc;
     if (!doc.setContent(d->serializedSource, true)) {
@@ -175,13 +180,15 @@ void QXmppElement::setAttribute(const QString &name, const QString &value)
 ///
 void QXmppElement::appendChild(const QXmppElement &child)
 {
-    if (child.d->parent == d)
+    if (child.d->parent == d) {
         return;
+    }
 
-    if (child.d->parent)
+    if (child.d->parent) {
         child.d->parent->children.removeAll(child.d);
-    else
+    } else {
         child.d->counter.ref();
+    }
     child.d->parent = d;
     d->children.append(child.d);
 }
@@ -206,12 +213,15 @@ QXmppElement QXmppElement::firstChildElement(const QString &name) const
 ///
 QXmppElement QXmppElement::nextSiblingElement(const QString &name) const
 {
-    if (!d->parent)
+    if (!d->parent) {
         return QXmppElement();
+    }
     const QList<QXmppElementPrivate *> &siblings_d = d->parent->children;
-    for (int i = siblings_d.indexOf(d) + 1; i < siblings_d.size(); i++)
-        if (name.isEmpty() || siblings_d[i]->name == name)
+    for (int i = siblings_d.indexOf(d) + 1; i < siblings_d.size(); i++) {
+        if (name.isEmpty() || siblings_d[i]->name == name) {
             return QXmppElement(siblings_d[i]);
+        }
+    }
     return QXmppElement();
 }
 
@@ -228,8 +238,9 @@ bool QXmppElement::isNull() const
 ///
 void QXmppElement::removeChild(const QXmppElement &child)
 {
-    if (child.d->parent != d)
+    if (child.d->parent != d) {
         return;
+    }
 
     d->children.removeAll(child.d);
     child.d->counter.deref();
@@ -273,19 +284,22 @@ void QXmppElement::setValue(const QString &value)
 ///
 void QXmppElement::toXml(QXmlStreamWriter *writer) const
 {
-    if (isNull())
+    if (isNull()) {
         return;
+    }
 
     writer->writeStartElement(d->name);
-    if (d->attributes.contains("xmlns"))
+    if (d->attributes.contains("xmlns")) {
         writer->writeDefaultNamespace(d->attributes.value("xmlns"));
+    }
     std::for_each(d->attributes.keyBegin(), d->attributes.keyEnd(), [this, writer](const QString &key) {
         if (key != "xmlns") {
             helperToXmlAddAttribute(writer, key, d->attributes.value(key));
         }
     });
-    if (!d->value.isEmpty())
+    if (!d->value.isEmpty()) {
         writer->writeCharacters(d->value);
+    }
     for (auto *childPrivate : std::as_const(d->children)) {
         QXmppElement(childPrivate).toXml(writer);
     }
diff --git a/src/base/QXmppHttpUploadIq.cpp b/src/base/QXmppHttpUploadIq.cpp
index 9553d403..e9969bfa 100644
--- a/src/base/QXmppHttpUploadIq.cpp
+++ b/src/base/QXmppHttpUploadIq.cpp
@@ -106,8 +106,9 @@ void QXmppHttpUploadRequestIq::parseElementFromChild(const QDomElement &element)
     if (request.hasAttribute("content-type")) {
         QMimeDatabase mimeDb;
         QMimeType type = mimeDb.mimeTypeForName(request.attribute("content-type"));
-        if (!type.isDefault() && type.isValid())
+        if (!type.isDefault() && type.isValid()) {
             d->contentType = type;
+        }
     }
 }
 
@@ -119,8 +120,9 @@ void QXmppHttpUploadRequestIq::toXmlElementFromChild(QXmlStreamWriter *writer) c
     writer->writeAttribute("filename", d->fileName);
     writer->writeAttribute("size", QString::number(d->size));
     // content-type is optional
-    if (!d->contentType.isDefault() && d->contentType.isValid())
+    if (!d->contentType.isDefault() && d->contentType.isValid()) {
         writer->writeAttribute("content-type", d->contentType.name());
+    }
     writer->writeEndElement();
 }
 /// \endcond
diff --git a/src/base/QXmppJingleIq.cpp b/src/base/QXmppJingleIq.cpp
index 7b7def33..1c244d7b 100644
--- a/src/base/QXmppJingleIq.cpp
+++ b/src/base/QXmppJingleIq.cpp
@@ -61,8 +61,9 @@ static QString formatFingerprint(const QByteArray &digest)
     QString fingerprint;
     const QString hx = digest.toHex().toUpper();
     for (int i = 0; i < hx.size(); i += 2) {
-        if (!fingerprint.isEmpty())
+        if (!fingerprint.isEmpty()) {
             fingerprint += ':';
+        }
         fingerprint += hx.mid(i, 2);
     }
     return fingerprint;
@@ -82,12 +83,14 @@ static QString addressToSdp(const QHostAddress &host)
 
 static bool candidateParseSdp(QXmppJingleCandidate *candidate, const QString &sdp)
 {
-    if (!sdp.startsWith(QStringLiteral("candidate:")))
+    if (!sdp.startsWith(QStringLiteral("candidate:"))) {
         return false;
+    }
 
     const QStringList bits = sdp.mid(10).split(" ");
-    if (bits.size() < 6)
+    if (bits.size() < 6) {
         return false;
+    }
 
     candidate->setFoundation(bits[0]);
     candidate->setComponent(bits[1].toInt());
@@ -99,8 +102,9 @@ static bool candidateParseSdp(QXmppJingleCandidate *candidate, const QString &sd
         if (bits[i] == QStringLiteral("typ")) {
             bool ok;
             candidate->setType(QXmppJingleCandidate::typeFromString(bits[i + 1], &ok));
-            if (!ok)
+            if (!ok) {
                 return false;
+            }
         } else if (bits[i] == QStringLiteral("generation")) {
             candidate->setGeneration(bits[i + 1].toInt());
         } else {
@@ -401,8 +405,9 @@ void QXmppJingleIq::Content::parse(const QDomElement &element)
 
 void QXmppJingleIq::Content::toXml(QXmlStreamWriter *writer) const
 {
-    if (d->creator.isEmpty() || d->name.isEmpty())
+    if (d->creator.isEmpty() || d->name.isEmpty()) {
         return;
+    }
 
     writer->writeStartElement(QStringLiteral("content"));
     helperToXmlAddAttribute(writer, QStringLiteral("creator"), d->creator);
@@ -415,10 +420,12 @@ void QXmppJingleIq::Content::toXml(QXmlStreamWriter *writer) const
         writer->writeStartElement(QStringLiteral("description"));
         writer->writeDefaultNamespace(d->descriptionType);
         helperToXmlAddAttribute(writer, QStringLiteral("media"), d->descriptionMedia);
-        if (d->descriptionSsrc)
+        if (d->descriptionSsrc) {
             writer->writeAttribute(QStringLiteral("ssrc"), QString::number(d->descriptionSsrc));
-        for (const auto &payload : d->payloadTypes)
+        }
+        for (const auto &payload : d->payloadTypes) {
             payload.toXml(writer);
+        }
         writer->writeEndElement();
     }
 
@@ -428,8 +435,9 @@ void QXmppJingleIq::Content::toXml(QXmlStreamWriter *writer) const
         writer->writeDefaultNamespace(d->transportType);
         helperToXmlAddAttribute(writer, QStringLiteral("ufrag"), d->transportUser);
         helperToXmlAddAttribute(writer, QStringLiteral("pwd"), d->transportPassword);
-        for (const auto &candidate : d->transportCandidates)
+        for (const auto &candidate : d->transportCandidates) {
             candidate.toXml(writer);
+        }
 
         // XEP-0320
         if (!d->transportFingerprint.isEmpty() && !d->transportFingerprintHash.isEmpty()) {
@@ -449,8 +457,9 @@ bool QXmppJingleIq::Content::parseSdp(const QString &sdp)
 {
     QList<QXmppJinglePayloadType> payloads;
     for (auto &line : sdp.split(QChar(u'\n'))) {
-        if (line.endsWith('\r'))
+        if (line.endsWith('\r')) {
             line.resize(line.size() - 1);
+        }
         if (line.startsWith(QStringLiteral("a="))) {
             int idx = line.indexOf(':');
             const QString attrName = idx != -1 ? line.mid(2, idx - 2) : line.mid(2);
@@ -487,8 +496,9 @@ bool QXmppJingleIq::Content::parseSdp(const QString &sdp)
                             const auto paramParts = paramStr.split(regex);
                             for (const auto &p : paramParts) {
                                 const QStringList bits = p.split('=');
-                                if (bits.size() == 2)
+                                if (bits.size() == 2) {
                                     params.insert(bits.at(0), bits.at(1));
+                                }
                             }
                         }
                         payload.setParameters(params);
@@ -497,21 +507,25 @@ bool QXmppJingleIq::Content::parseSdp(const QString &sdp)
             } else if (attrName == QStringLiteral("rtpmap")) {
                 // payload type map
                 const QStringList bits = attrValue.split(' ');
-                if (bits.size() != 2)
+                if (bits.size() != 2) {
                     continue;
+                }
                 bool ok = false;
                 const int id = bits[0].toInt(&ok);
-                if (!ok)
+                if (!ok) {
                     continue;
+                }
 
                 const QStringList args = bits[1].split('/');
                 for (auto &payload : payloads) {
                     if (payload.id() == id) {
                         payload.setName(args[0]);
-                        if (args.size() > 1)
+                        if (args.size() > 1) {
                             payload.setClockrate(args[1].toInt());
-                        if (args.size() > 2)
+                        }
+                        if (args.size() > 2) {
                             payload.setChannels(args[2].toInt());
+                        }
                     }
                 }
             } else if (attrName == QStringLiteral("ice-ufrag")) {
@@ -541,8 +555,9 @@ bool QXmppJingleIq::Content::parseSdp(const QString &sdp)
             for (int i = 3; i < bits.size(); ++i) {
                 bool ok = false;
                 int id = bits[i].toInt(&ok);
-                if (!ok)
+                if (!ok) {
                     continue;
+                }
                 QXmppJinglePayloadType payload;
                 payload.setId(id);
                 payloads << payload;
@@ -555,10 +570,11 @@ bool QXmppJingleIq::Content::parseSdp(const QString &sdp)
 
 static bool candidateLessThan(const QXmppJingleCandidate &c1, const QXmppJingleCandidate &c2)
 {
-    if (c1.type() == c2.type())
+    if (c1.type() == c2.type()) {
         return c1.priority() > c2.priority();
-    else
+    } else {
         return c1.type() == QXmppJingleCandidate::ServerReflexiveType;
+    }
 }
 
 QString QXmppJingleIq::Content::toSdp() const
@@ -584,39 +600,48 @@ QString QXmppJingleIq::Content::toSdp() const
     for (const QXmppJinglePayloadType &payload : d->payloadTypes) {
         payloads += " " + QString::number(payload.id());
         QString rtpmap = QString::number(payload.id()) + " " + payload.name() + "/" + QString::number(payload.clockrate());
-        if (payload.channels() > 1)
+        if (payload.channels() > 1) {
             rtpmap += "/" + QString::number(payload.channels());
+        }
         attrs << "a=rtpmap:" + rtpmap;
 
         // payload parameters
         QStringList paramList;
         const QMap<QString, QString> params = payload.parameters();
         if (payload.name() == QStringLiteral("telephone-event")) {
-            if (params.contains(QStringLiteral("events")))
+            if (params.contains(QStringLiteral("events"))) {
                 paramList << params.value(QStringLiteral("events"));
+            }
         } else {
             QMap<QString, QString>::const_iterator i;
-            for (i = params.begin(); i != params.end(); ++i)
+            for (i = params.begin(); i != params.end(); ++i) {
                 paramList << i.key() + QStringLiteral("=") + i.value();
+            }
         }
-        if (!paramList.isEmpty())
+        if (!paramList.isEmpty()) {
             attrs << QStringLiteral("a=fmtp:") + QByteArray::number(payload.id()) + QStringLiteral(" ") + paramList.join("; ");
+        }
     }
     sdp << QStringLiteral("m=%1 %2 RTP/AVP%3").arg(d->descriptionMedia, QString::number(localRtpPort), payloads);
     sdp << QStringLiteral("c=%1").arg(addressToSdp(localRtpAddress));
     sdp += attrs;
 
     // transport
-    for (const auto &candidate : d->transportCandidates)
+    for (const auto &candidate : d->transportCandidates) {
         sdp << QStringLiteral("a=%1").arg(candidateToSdp(candidate));
-    if (!d->transportUser.isEmpty())
+    }
+    if (!d->transportUser.isEmpty()) {
         sdp << QStringLiteral("a=ice-ufrag:%1").arg(d->transportUser);
-    if (!d->transportPassword.isEmpty())
+    }
+    if (!d->transportPassword.isEmpty()) {
         sdp << QStringLiteral("a=ice-pwd:%1").arg(d->transportPassword);
-    if (!d->transportFingerprint.isEmpty() && !d->transportFingerprintHash.isEmpty())
+    }
+    if (!d->transportFingerprint.isEmpty() && !d->transportFingerprintHash.isEmpty()) {
         sdp << QStringLiteral("a=fingerprint:%1 %2").arg(d->transportFingerprintHash, formatFingerprint(d->transportFingerprint));
-    if (!d->transportFingerprintSetup.isEmpty())
+    }
+    if (!d->transportFingerprintSetup.isEmpty()) {
         sdp << QStringLiteral("a=setup:%1").arg(d->transportFingerprintSetup);
+    }
 
     return sdp.join("\r\n") + "\r\n";
 }
@@ -670,12 +695,14 @@ void QXmppJingleIq::Reason::parse(const QDomElement &element)
 
 void QXmppJingleIq::Reason::toXml(QXmlStreamWriter *writer) const
 {
-    if (m_type < AlternativeSession || m_type > UnsupportedTransports)
+    if (m_type < AlternativeSession || m_type > UnsupportedTransports) {
         return;
+    }
 
     writer->writeStartElement(QStringLiteral("reason"));
-    if (!m_text.isEmpty())
+    if (!m_text.isEmpty()) {
         helperToXmlAddTextElement(writer, QStringLiteral("text"), m_text);
+    }
     writer->writeEmptyElement(jingle_reasons[m_type]);
     writer->writeEndElement();
 }
@@ -890,8 +917,9 @@ void QXmppJingleIq::toXmlElementFromChild(QXmlStreamWriter *writer) const
     helperToXmlAddAttribute(writer, QStringLiteral("initiator"), d->initiator);
     helperToXmlAddAttribute(writer, QStringLiteral("responder"), d->responder);
     helperToXmlAddAttribute(writer, QStringLiteral("sid"), d->sid);
-    for (const auto &content : d->contents)
+    for (const auto &content : d->contents) {
         content.toXml(writer);
+    }
     d->reason.toXml(writer);
 
     // ringing
@@ -1166,22 +1194,24 @@ void QXmppJingleCandidate::toXml(QXmlStreamWriter *writer) const
 QXmppJingleCandidate::Type QXmppJingleCandidate::typeFromString(const QString &typeStr, bool *ok)
 {
     QXmppJingleCandidate::Type type;
-    if (typeStr == QStringLiteral("host"))
+    if (typeStr == QStringLiteral("host")) {
         type = HostType;
-    else if (typeStr == QStringLiteral("prflx"))
+    } else if (typeStr == QStringLiteral("prflx")) {
         type = PeerReflexiveType;
-    else if (typeStr == QStringLiteral("srflx"))
+    } else if (typeStr == QStringLiteral("srflx")) {
         type = ServerReflexiveType;
-    else if (typeStr == QStringLiteral("relay"))
+    } else if (typeStr == QStringLiteral("relay")) {
         type = RelayedType;
-    else {
+    } else {
         qWarning() << "Unknown candidate type" << typeStr;
-        if (ok)
+        if (ok) {
             *ok = false;
+        }
         return HostType;
     }
-    if (ok)
+    if (ok) {
         *ok = true;
+    }
     return type;
 }
 
@@ -1365,8 +1395,9 @@ void QXmppJinglePayloadType::parse(const QDomElement &element)
     d->id = element.attribute(QStringLiteral("id")).toInt();
     d->name = element.attribute(QStringLiteral("name"));
     d->channels = element.attribute(QStringLiteral("channels")).toInt();
-    if (!d->channels)
+    if (!d->channels) {
         d->channels = 1;
+    }
     d->clockrate = element.attribute(QStringLiteral("clockrate")).toInt();
     d->maxptime = element.attribute(QStringLiteral("maxptime")).toInt();
     d->ptime = element.attribute(QStringLiteral("ptime")).toInt();
@@ -1383,14 +1414,18 @@ void QXmppJinglePayloadType::toXml(QXmlStreamWriter *writer) const
     writer->writeStartElement(QStringLiteral("payload-type"));
     helperToXmlAddAttribute(writer, QStringLiteral("id"), QString::number(d->id));
     helperToXmlAddAttribute(writer, QStringLiteral("name"), d->name);
-    if (d->channels > 1)
+    if (d->channels > 1) {
         helperToXmlAddAttribute(writer, QStringLiteral("channels"), QString::number(d->channels));
-    if (d->clockrate > 0)
+    }
+    if (d->clockrate > 0) {
         helperToXmlAddAttribute(writer, QStringLiteral("clockrate"), QString::number(d->clockrate));
-    if (d->maxptime > 0)
+    }
+    if (d->maxptime > 0) {
         helperToXmlAddAttribute(writer, QStringLiteral("maxptime"), QString::number(d->maxptime));
-    if (d->ptime > 0)
+    }
+    if (d->ptime > 0) {
         helperToXmlAddAttribute(writer, QStringLiteral("ptime"), QString::number(d->ptime));
+    }
 
     for (auto itr = d->parameters.begin(); itr != d->parameters.end(); itr++) {
         writer->writeStartElement(QStringLiteral("parameter"));
@@ -1419,10 +1454,11 @@ QXmppJinglePayloadType &QXmppJinglePayloadType::operator=(const QXmppJinglePaylo
 bool QXmppJinglePayloadType::operator==(const QXmppJinglePayloadType &other) const
 {
     // FIXME : what to do with m_ptime and m_maxptime?
-    if (d->id <= 95)
+    if (d->id <= 95) {
         return other.d->id == d->id && other.d->clockrate == d->clockrate;
-    else
+    } else {
         return other.d->channels == d->channels &&
             other.d->clockrate == d->clockrate &&
             other.d->name.toLower() == d->name.toLower();
+    }
 }
diff --git a/src/base/QXmppLogger.cpp b/src/base/QXmppLogger.cpp
index 2f0b445a..a9c7bcef 100644
--- a/src/base/QXmppLogger.cpp
+++ b/src/base/QXmppLogger.cpp
@@ -67,8 +67,9 @@ QXmppLoggable::QXmppLoggable(QObject *parent)
 void QXmppLoggable::childEvent(QChildEvent *event)
 {
     auto *child = qobject_cast<QXmppLoggable *>(event->child());
-    if (!child)
+    if (!child) {
         return;
+    }
 
     if (event->added()) {
         relaySignals(child, this);
@@ -120,8 +121,9 @@ QXmppLogger::~QXmppLogger()
 
 QXmppLogger *QXmppLogger::getLogger()
 {
-    if (!m_logger)
+    if (!m_logger) {
         m_logger = new QXmppLogger();
+    }
 
     return m_logger;
 }
@@ -165,8 +167,9 @@ void QXmppLogger::setMessageTypes(QXmppLogger::MessageTypes types)
 void QXmppLogger::log(QXmppLogger::MessageType type, const QString &text)
 {
     // filter messages
-    if (!d->messageTypes.testFlag(type))
+    if (!d->messageTypes.testFlag(type)) {
         return;
+    }
 
     switch (d->loggingType) {
     case QXmppLogger::FileLogging:
diff --git a/src/base/QXmppMessage.cpp b/src/base/QXmppMessage.cpp
index 3062b227..74e18149 100644
--- a/src/base/QXmppMessage.cpp
+++ b/src/base/QXmppMessage.cpp
@@ -429,8 +429,9 @@ bool QXmppMessage::isReceiptRequested() const
 void QXmppMessage::setReceiptRequested(bool requested)
 {
     d->receiptRequested = requested;
-    if (requested && id().isEmpty())
+    if (requested && id().isEmpty()) {
         generateAndSetNextId();
+    }
 }
 
 ///
@@ -551,8 +552,9 @@ bool QXmppMessage::isSlashMeCommand() const
 ///
 QString QXmppMessage::slashMeCommandText(const QString &body)
 {
-    if (isSlashMeCommand(body))
+    if (isSlashMeCommand(body)) {
         return body.mid(4);
+    }
     return {};
 }
 
@@ -1027,8 +1029,9 @@ void QXmppMessage::setEncryptionMethodNs(const QString &encryptionMethod)
 ///
 QString QXmppMessage::encryptionName() const
 {
-    if (!d->encryptionName.isEmpty())
+    if (!d->encryptionName.isEmpty()) {
         return d->encryptionName;
+    }
     return QXmpp::Private::encryptionToName(encryptionMethod());
 }
 
@@ -1100,8 +1103,9 @@ QString QXmppMessage::spoilerHint() const
 void QXmppMessage::setSpoilerHint(const QString &spoilerHint)
 {
     d->spoilerHint = spoilerHint;
-    if (!spoilerHint.isEmpty())
+    if (!spoilerHint.isEmpty()) {
         d->isSpoiler = true;
+    }
 }
 
 #ifdef BUILD_OMEMO
@@ -1213,10 +1217,11 @@ void QXmppMessage::parse(const QDomElement &element, QXmpp::SceMode sceMode)
 
     // message type
     int messageType = MESSAGE_TYPES.indexOf(element.attribute(QStringLiteral("type")));
-    if (messageType != -1)
+    if (messageType != -1) {
         d->type = static_cast<Type>(messageType);
-    else
+    } else {
         d->type = QXmppMessage::Normal;
+    }
 
     parseExtensions(element, sceMode);
 }
@@ -1402,8 +1407,9 @@ bool QXmppMessage::parseExtension(const QDomElement &element, QXmpp::SceMode sce
         // XEP-0085: Chat State Notifications
         if (element.namespaceURI() == ns_chat_states) {
             int i = CHAT_STATES.indexOf(element.tagName());
-            if (i > 0)
+            if (i > 0) {
                 d->state = static_cast<QXmppMessage::State>(i);
+            }
             return true;
         }
         // XEP-0184: Message Delivery Receipts
@@ -1411,8 +1417,9 @@ bool QXmppMessage::parseExtension(const QDomElement &element, QXmpp::SceMode sce
             d->receiptId = element.attribute(QStringLiteral("id"));
 
             // compatibility with old-style XEP
-            if (d->receiptId.isEmpty())
+            if (d->receiptId.isEmpty()) {
                 d->receiptId = id();
+            }
             return true;
         }
         if (checkElement(element, QStringLiteral("request"), ns_message_receipts)) {
@@ -1525,8 +1532,9 @@ void QXmppMessage::serializeExtensions(QXmlStreamWriter *writer, QXmpp::SceMode
             writer->writeStartElement(QStringLiteral("stanza-id"));
             writer->writeDefaultNamespace(ns_sid);
             writer->writeAttribute(QStringLiteral("id"), d->stanzaId);
-            if (!d->stanzaIdBy.isNull())
+            if (!d->stanzaIdBy.isNull()) {
                 writer->writeAttribute(QStringLiteral("by"), d->stanzaIdBy);
+            }
             writer->writeEndElement();
         }
 
@@ -1668,16 +1676,19 @@ void QXmppMessage::serializeExtensions(QXmlStreamWriter *writer, QXmpp::SceMode
             writer->writeStartElement(QStringLiteral("x"));
             writer->writeDefaultNamespace(ns_conference);
             writer->writeAttribute(QStringLiteral("jid"), d->mucInvitationJid);
-            if (!d->mucInvitationPassword.isEmpty())
+            if (!d->mucInvitationPassword.isEmpty()) {
                 writer->writeAttribute(QStringLiteral("password"), d->mucInvitationPassword);
-            if (!d->mucInvitationReason.isEmpty())
+            }
+            if (!d->mucInvitationReason.isEmpty()) {
                 writer->writeAttribute(QStringLiteral("reason"), d->mucInvitationReason);
+            }
             writer->writeEndElement();
         }
 
         // XEP-0231: Bits of Binary
-        for (const auto &data : std::as_const(d->bitsOfBinaryData))
+        for (const auto &data : std::as_const(d->bitsOfBinaryData)) {
             data.toXmlElementFromChild(writer);
+        }
 
         // XEP-0308: Last Message Correction
         if (!d->replaceId.isEmpty()) {
diff --git a/src/base/QXmppMixIq.cpp b/src/base/QXmppMixIq.cpp
index 8d28bc39..33d394f9 100644
--- a/src/base/QXmppMixIq.cpp
+++ b/src/base/QXmppMixIq.cpp
@@ -140,24 +140,28 @@ void QXmppMixIq::parseElementFromChild(const QDomElement &element)
     }
 
     if (child.namespaceURI() == ns_mix_pam) {
-        if (child.hasAttribute(QStringLiteral("channel")))
+        if (child.hasAttribute(QStringLiteral("channel"))) {
             d->jid = child.attribute(QStringLiteral("channel"));
+        }
 
         child = child.firstChildElement();
     }
 
     if (!child.isNull() && child.namespaceURI() == ns_mix) {
-        if (child.hasAttribute(QStringLiteral("jid")))
+        if (child.hasAttribute(QStringLiteral("jid"))) {
             d->jid = child.attribute(QStringLiteral("jid"));
-        if (child.hasAttribute(QStringLiteral("channel")))
+        }
+        if (child.hasAttribute(QStringLiteral("channel"))) {
             d->channelName = child.attribute(QStringLiteral("channel"));
+        }
 
         QDomElement subChild = child.firstChildElement();
         while (!subChild.isNull()) {
-            if (subChild.tagName() == QStringLiteral("subscribe"))
+            if (subChild.tagName() == QStringLiteral("subscribe")) {
                 d->nodes << subChild.attribute(QStringLiteral("node"));
-            else if (subChild.tagName() == QStringLiteral("nick"))
+            } else if (subChild.tagName() == QStringLiteral("nick")) {
                 d->nick = subChild.text();
+            }
 
             subChild = subChild.nextSiblingElement();
         }
@@ -166,36 +170,42 @@ void QXmppMixIq::parseElementFromChild(const QDomElement &element)
 
 void QXmppMixIq::toXmlElementFromChild(QXmlStreamWriter *writer) const
 {
-    if (d->actionType == None)
+    if (d->actionType == None) {
         return;
+    }
 
     writer->writeStartElement(MIX_ACTION_TYPES.at(d->actionType));
     if (d->actionType == ClientJoin || d->actionType == ClientLeave) {
         writer->writeDefaultNamespace(ns_mix_pam);
-        if (type() == Set)
+        if (type() == Set) {
             helperToXmlAddAttribute(writer, QStringLiteral("channel"), d->jid);
+        }
 
-        if (d->actionType == ClientJoin)
+        if (d->actionType == ClientJoin) {
             writer->writeStartElement(QStringLiteral("join"));
-        else if (d->actionType == ClientLeave)
+        } else if (d->actionType == ClientLeave) {
             writer->writeStartElement(QStringLiteral("leave"));
+        }
     }
 
     writer->writeDefaultNamespace(ns_mix);
     helperToXmlAddAttribute(writer, QStringLiteral("channel"), d->channelName);
-    if (type() == Result)
+    if (type() == Result) {
         helperToXmlAddAttribute(writer, QStringLiteral("jid"), d->jid);
+    }
 
     for (const auto &node : d->nodes) {
         writer->writeStartElement(QStringLiteral("subscribe"));
         writer->writeAttribute(QStringLiteral("node"), node);
         writer->writeEndElement();
     }
-    if (!d->nick.isEmpty())
+    if (!d->nick.isEmpty()) {
         writer->writeTextElement(QStringLiteral("nick"), d->nick);
+    }
 
     writer->writeEndElement();
-    if (d->actionType == ClientJoin || d->actionType == ClientLeave)
+    if (d->actionType == ClientJoin || d->actionType == ClientLeave) {
         writer->writeEndElement();
+    }
 }
 /// \endcond
diff --git a/src/base/QXmppMucIq.cpp b/src/base/QXmppMucIq.cpp
index a0f92179..2ac82145 100644
--- a/src/base/QXmppMucIq.cpp
+++ b/src/base/QXmppMucIq.cpp
@@ -53,18 +53,19 @@ QXmppMucItem::Affiliation QXmppMucItem::affiliation() const
 /// \cond
 QXmppMucItem::Affiliation QXmppMucItem::affiliationFromString(const QString &affiliationStr)
 {
-    if (affiliationStr == QStringLiteral("owner"))
+    if (affiliationStr == QStringLiteral("owner")) {
         return QXmppMucItem::OwnerAffiliation;
-    else if (affiliationStr == QStringLiteral("admin"))
+    } else if (affiliationStr == QStringLiteral("admin")) {
         return QXmppMucItem::AdminAffiliation;
-    else if (affiliationStr == QStringLiteral("member"))
+    } else if (affiliationStr == QStringLiteral("member")) {
         return QXmppMucItem::MemberAffiliation;
-    else if (affiliationStr == QStringLiteral("outcast"))
+    } else if (affiliationStr == QStringLiteral("outcast")) {
         return QXmppMucItem::OutcastAffiliation;
-    else if (affiliationStr == QStringLiteral("none"))
+    } else if (affiliationStr == QStringLiteral("none")) {
         return QXmppMucItem::NoAffiliation;
-    else
+    } else {
         return QXmppMucItem::UnspecifiedAffiliation;
+    }
 }
 
 QString QXmppMucItem::affiliationToString(Affiliation affiliation)
@@ -153,16 +154,17 @@ QXmppMucItem::Role QXmppMucItem::role() const
 /// \cond
 QXmppMucItem::Role QXmppMucItem::roleFromString(const QString &roleStr)
 {
-    if (roleStr == QStringLiteral("moderator"))
+    if (roleStr == QStringLiteral("moderator")) {
         return QXmppMucItem::ModeratorRole;
-    else if (roleStr == QStringLiteral("participant"))
+    } else if (roleStr == QStringLiteral("participant")) {
         return QXmppMucItem::ParticipantRole;
-    else if (roleStr == QStringLiteral("visitor"))
+    } else if (roleStr == QStringLiteral("visitor")) {
         return QXmppMucItem::VisitorRole;
-    else if (roleStr == QStringLiteral("none"))
+    } else if (roleStr == QStringLiteral("none")) {
         return QXmppMucItem::NoRole;
-    else
+    } else {
         return QXmppMucItem::UnspecifiedRole;
+    }
 }
 
 QString QXmppMucItem::roleToString(Role role)
@@ -214,8 +216,9 @@ void QXmppMucItem::toXml(QXmlStreamWriter *writer) const
         helperToXmlAddAttribute(writer, QStringLiteral("jid"), m_actor);
         writer->writeEndElement();
     }
-    if (!m_reason.isEmpty())
+    if (!m_reason.isEmpty()) {
         helperToXmlAddTextElement(writer, QStringLiteral("reason"), m_reason);
+    }
     writer->writeEndElement();
 }
 /// \endcond
@@ -259,8 +262,9 @@ void QXmppMucAdminIq::toXmlElementFromChild(QXmlStreamWriter *writer) const
 {
     writer->writeStartElement(QStringLiteral("query"));
     writer->writeDefaultNamespace(ns_muc_admin);
-    for (const QXmppMucItem &item : m_items)
+    for (const QXmppMucItem &item : m_items) {
         item.toXml(writer);
+    }
     writer->writeEndElement();
 }
 /// \endcond
diff --git a/src/base/QXmppNonSASLAuth.cpp b/src/base/QXmppNonSASLAuth.cpp
index dfffccef..6e4efd5c 100644
--- a/src/base/QXmppNonSASLAuth.cpp
+++ b/src/base/QXmppNonSASLAuth.cpp
@@ -110,14 +110,18 @@ void QXmppNonSASLAuthIq::toXmlElementFromChild(QXmlStreamWriter *writer) const
 {
     writer->writeStartElement(QStringLiteral("query"));
     writer->writeDefaultNamespace(ns_auth);
-    if (!m_username.isEmpty())
+    if (!m_username.isEmpty()) {
         writer->writeTextElement(QStringLiteral("username"), m_username);
-    if (!m_digest.isEmpty())
+    }
+    if (!m_digest.isEmpty()) {
         writer->writeTextElement(QStringLiteral("digest"), m_digest.toHex());
-    if (!m_password.isEmpty())
+    }
+    if (!m_password.isEmpty()) {
         writer->writeTextElement(QStringLiteral("password"), m_password);
-    if (!m_resource.isEmpty())
+    }
+    if (!m_resource.isEmpty()) {
         writer->writeTextElement(QStringLiteral("resource"), m_resource);
+    }
     writer->writeEndElement();
 }
 /// \endcond
diff --git a/src/base/QXmppPresence.cpp b/src/base/QXmppPresence.cpp
index 202dd2a3..54e44fb4 100644
--- a/src/base/QXmppPresence.cpp
+++ b/src/base/QXmppPresence.cpp
@@ -378,8 +378,9 @@ void QXmppPresence::parse(const QDomElement &element)
 
     // attributes
     int type = PRESENCE_TYPES.indexOf(element.attribute(QStringLiteral("type")));
-    if (type > -1)
+    if (type > -1) {
         d->type = Type(type);
+    }
 
     QXmppElementList unknownElements;
     QDomElement childElement = element.firstChildElement();
@@ -387,8 +388,9 @@ void QXmppPresence::parse(const QDomElement &element)
     while (!childElement.isNull()) {
         if (childElement.tagName() == QStringLiteral("show")) {
             int availableStatusType = AVAILABLE_STATUS_TYPES.indexOf(childElement.text());
-            if (availableStatusType > -1)
+            if (availableStatusType > -1) {
                 d->availableStatusType = AvailableStatusType(availableStatusType);
+            }
         } else if (childElement.tagName() == QStringLiteral("status")) {
             d->statusText = childElement.text();
         } else if (childElement.tagName() == QStringLiteral("priority")) {
@@ -439,10 +441,11 @@ void QXmppPresence::parseExtension(const QDomElement &element, QXmppElementList
             d->vCardUpdateType = VCardUpdateNotReady;
         } else {
             d->photoHash = QByteArray::fromHex(photoElement.text().toLatin1());
-            if (d->photoHash.isEmpty())
+            if (d->photoHash.isEmpty()) {
                 d->vCardUpdateType = VCardUpdateNoPhoto;
-            else
+            } else {
                 d->vCardUpdateType = VCardUpdateValidPhoto;
+            }
         }
         // XEP-0319: Last User Interaction in Presence
     } else if (element.tagName() == QStringLiteral("idle") && element.namespaceURI() == ns_idle) {
@@ -469,12 +472,15 @@ void QXmppPresence::toXml(QXmlStreamWriter *xmlWriter) const
     helperToXmlAddAttribute(xmlWriter, QStringLiteral("type"), PRESENCE_TYPES.at(d->type));
 
     const QString show = AVAILABLE_STATUS_TYPES.at(d->availableStatusType);
-    if (!show.isEmpty())
+    if (!show.isEmpty()) {
         helperToXmlAddTextElement(xmlWriter, QStringLiteral("show"), show);
-    if (!d->statusText.isEmpty())
+    }
+    if (!d->statusText.isEmpty()) {
         helperToXmlAddTextElement(xmlWriter, QStringLiteral("status"), d->statusText);
-    if (d->priority != 0)
+    }
+    if (d->priority != 0) {
         helperToXmlAddTextElement(xmlWriter, QStringLiteral("priority"), QString::number(d->priority));
+    }
 
     error().toXml(xmlWriter);
 
@@ -482,16 +488,18 @@ void QXmppPresence::toXml(QXmlStreamWriter *xmlWriter) const
     if (d->mucSupported) {
         xmlWriter->writeStartElement(QStringLiteral("x"));
         xmlWriter->writeDefaultNamespace(ns_muc);
-        if (!d->mucPassword.isEmpty())
+        if (!d->mucPassword.isEmpty()) {
             xmlWriter->writeTextElement(QStringLiteral("password"), d->mucPassword);
+        }
         xmlWriter->writeEndElement();
     }
 
     if (!d->mucItem.isNull() || !d->mucStatusCodes.isEmpty()) {
         xmlWriter->writeStartElement(QStringLiteral("x"));
         xmlWriter->writeDefaultNamespace(ns_muc_user);
-        if (!d->mucItem.isNull())
+        if (!d->mucItem.isNull()) {
             d->mucItem.toXml(xmlWriter);
+        }
         for (const auto code : d->mucStatusCodes) {
             xmlWriter->writeStartElement(QStringLiteral("status"));
             xmlWriter->writeAttribute(QStringLiteral("code"), QString::number(code));
@@ -541,10 +549,12 @@ void QXmppPresence::toXml(QXmlStreamWriter *xmlWriter) const
     if (!d->mixUserJid.isEmpty() || !d->mixUserNick.isEmpty()) {
         xmlWriter->writeStartElement(QStringLiteral("mix"));
         xmlWriter->writeDefaultNamespace(ns_mix_presence);
-        if (!d->mixUserJid.isEmpty())
+        if (!d->mixUserJid.isEmpty()) {
             helperToXmlAddTextElement(xmlWriter, QStringLiteral("jid"), d->mixUserJid);
-        if (!d->mixUserNick.isEmpty())
+        }
+        if (!d->mixUserNick.isEmpty()) {
             helperToXmlAddTextElement(xmlWriter, QStringLiteral("nick"), d->mixUserNick);
+        }
         xmlWriter->writeEndElement();
     }
 
diff --git a/src/base/QXmppPubSubNodeConfig.cpp b/src/base/QXmppPubSubNodeConfig.cpp
index 2f9408a6..2703b398 100644
--- a/src/base/QXmppPubSubNodeConfig.cpp
+++ b/src/base/QXmppPubSubNodeConfig.cpp
@@ -91,16 +91,21 @@ public:
 
 std::optional<QXmppPubSubNodeConfig::AccessModel> QXmppPubSubNodeConfig::accessModelFromString(const QString &string)
 {
-    if (string == QStringLiteral("open"))
+    if (string == QStringLiteral("open")) {
         return Open;
-    if (string == QStringLiteral("presence"))
+    }
+    if (string == QStringLiteral("presence")) {
         return Presence;
-    if (string == QStringLiteral("roster"))
+    }
+    if (string == QStringLiteral("roster")) {
         return Roster;
-    if (string == QStringLiteral("authorize"))
+    }
+    if (string == QStringLiteral("authorize")) {
         return Authorize;
-    if (string == QStringLiteral("whitelist"))
+    }
+    if (string == QStringLiteral("whitelist")) {
         return Allowlist;
+    }
     return std::nullopt;
 }
 
@@ -123,12 +128,15 @@ QString QXmppPubSubNodeConfig::accessModelToString(AccessModel model)
 
 std::optional<QXmppPubSubNodeConfig::PublishModel> QXmppPubSubNodeConfig::publishModelFromString(const QString &string)
 {
-    if (string == QStringLiteral("publishers"))
+    if (string == QStringLiteral("publishers")) {
         return Publishers;
-    if (string == QStringLiteral("subscribers"))
+    }
+    if (string == QStringLiteral("subscribers")) {
         return Subscribers;
-    if (string == QStringLiteral("open"))
+    }
+    if (string == QStringLiteral("open")) {
         return Anyone;
+    }
     return std::nullopt;
 }
 
@@ -147,12 +155,15 @@ QString QXmppPubSubNodeConfig::publishModelToString(QXmppPubSubNodeConfig::Publi
 
 std::optional<QXmppPubSubNodeConfig::ChildAssociationPolicy> QXmppPubSubNodeConfig::childAssociatationPolicyFromString(const QString &string)
 {
-    if (string == QStringLiteral("all"))
+    if (string == QStringLiteral("all")) {
         return ChildAssociationPolicy::All;
-    if (string == QStringLiteral("owners"))
+    }
+    if (string == QStringLiteral("owners")) {
         return ChildAssociationPolicy::Owners;
-    if (string == QStringLiteral("whitelist"))
+    }
+    if (string == QStringLiteral("whitelist")) {
         return ChildAssociationPolicy::Whitelist;
+    }
     return std::nullopt;
 }
 
@@ -171,10 +182,12 @@ QString QXmppPubSubNodeConfig::childAssociationPolicyToString(QXmppPubSubNodeCon
 
 std::optional<QXmppPubSubNodeConfig::ItemPublisher> QXmppPubSubNodeConfig::itemPublisherFromString(const QString &string)
 {
-    if (string == QStringLiteral("owner"))
+    if (string == QStringLiteral("owner")) {
         return NodeOwner;
-    if (string == QStringLiteral("publisher"))
+    }
+    if (string == QStringLiteral("publisher")) {
         return Publisher;
+    }
     return std::nullopt;
 }
 
@@ -191,10 +204,12 @@ QString QXmppPubSubNodeConfig::itemPublisherToString(ItemPublisher publisher)
 
 std::optional<QXmppPubSubNodeConfig::NodeType> QXmppPubSubNodeConfig::nodeTypeFromString(const QString &string)
 {
-    if (string == QStringLiteral("leaf"))
+    if (string == QStringLiteral("leaf")) {
         return Leaf;
-    if (string == QStringLiteral("collection"))
+    }
+    if (string == QStringLiteral("collection")) {
         return Collection;
+    }
     return std::nullopt;
 }
 
@@ -211,10 +226,12 @@ QString QXmppPubSubNodeConfig::nodeTypeToString(NodeType type)
 
 std::optional<QXmppPubSubNodeConfig::NotificationType> QXmppPubSubNodeConfig::notificationTypeFromString(const QString &string)
 {
-    if (string == QStringLiteral("normal"))
+    if (string == QStringLiteral("normal")) {
         return Normal;
-    if (string == QStringLiteral("headline"))
+    }
+    if (string == QStringLiteral("headline")) {
         return Headline;
+    }
     return std::nullopt;
 }
 
@@ -231,12 +248,15 @@ QString QXmppPubSubNodeConfig::notificationTypeToString(NotificationType type)
 
 std::optional<QXmppPubSubNodeConfig::SendLastItemType> QXmppPubSubNodeConfig::sendLastItemTypeFromString(const QString &string)
 {
-    if (string == QStringLiteral("never"))
+    if (string == QStringLiteral("never")) {
         return Never;
-    if (string == QStringLiteral("on_sub"))
+    }
+    if (string == QStringLiteral("on_sub")) {
         return OnSubscription;
-    if (string == QStringLiteral("on_sub_and_presence"))
+    }
+    if (string == QStringLiteral("on_sub_and_presence")) {
         return OnSubscriptionAndPresence;
+    }
     return std::nullopt;
 }
 
diff --git a/src/base/QXmppPubSubSubscribeOptions.cpp b/src/base/QXmppPubSubSubscribeOptions.cpp
index 439c9a59..08cef054 100644
--- a/src/base/QXmppPubSubSubscribeOptions.cpp
+++ b/src/base/QXmppPubSubSubscribeOptions.cpp
@@ -33,32 +33,42 @@ public:
 QXmppPubSubSubscribeOptions::PresenceStates QXmppPubSubSubscribeOptions::presenceStatesFromStringList(const QStringList &values)
 {
     PresenceStates states;
-    if (values.contains(QStringLiteral("away")))
+    if (values.contains(QStringLiteral("away"))) {
         states |= Away;
-    if (values.contains(QStringLiteral("chat")))
+    }
+    if (values.contains(QStringLiteral("chat"))) {
         states |= Chat;
-    if (values.contains(QStringLiteral("dnd")))
+    }
+    if (values.contains(QStringLiteral("dnd"))) {
         states |= DoNotDisturb;
-    if (values.contains(QStringLiteral("online")))
+    }
+    if (values.contains(QStringLiteral("online"))) {
         states |= Online;
-    if (values.contains(QStringLiteral("xa")))
+    }
+    if (values.contains(QStringLiteral("xa"))) {
         states |= ExtendedAway;
+    }
     return states;
 }
 
 QStringList QXmppPubSubSubscribeOptions::presenceStatesToStringList(PresenceStates states)
 {
     QStringList output;
-    if (states & Away)
+    if (states & Away) {
         output << QStringLiteral("away");
-    if (states & Chat)
+    }
+    if (states & Chat) {
         output << QStringLiteral("chat");
-    if (states & DoNotDisturb)
+    }
+    if (states & DoNotDisturb) {
         output << QStringLiteral("dnd");
-    if (states & Online)
+    }
+    if (states & Online) {
         output << QStringLiteral("online");
-    if (states & ExtendedAway)
+    }
+    if (states & ExtendedAway) {
         output << QStringLiteral("xa");
+    }
     return output;
 }
 
diff --git a/src/base/QXmppRegisterIq.cpp b/src/base/QXmppRegisterIq.cpp
index b5cdee77..82ab6043 100644
--- a/src/base/QXmppRegisterIq.cpp
+++ b/src/base/QXmppRegisterIq.cpp
@@ -297,28 +297,34 @@ void QXmppRegisterIq::toXmlElementFromChild(QXmlStreamWriter *writer) const
     writer->writeStartElement(QStringLiteral("query"));
     writer->writeDefaultNamespace(ns_register);
 
-    if (!d->instructions.isEmpty())
+    if (!d->instructions.isEmpty()) {
         writer->writeTextElement(QStringLiteral("instructions"), d->instructions);
+    }
 
-    if (d->isRegistered)
+    if (d->isRegistered) {
         writer->writeEmptyElement(ELEMENT_REGISTERED);
-    if (d->isRemove)
+    }
+    if (d->isRemove) {
         writer->writeEmptyElement(ELEMENT_REMOVE);
+    }
 
-    if (!d->username.isEmpty())
+    if (!d->username.isEmpty()) {
         writer->writeTextElement(QStringLiteral("username"), d->username);
-    else if (!d->username.isNull())
+    } else if (!d->username.isNull()) {
         writer->writeEmptyElement(QStringLiteral("username"));
+    }
 
-    if (!d->password.isEmpty())
+    if (!d->password.isEmpty()) {
         writer->writeTextElement(QStringLiteral("password"), d->password);
-    else if (!d->password.isNull())
+    } else if (!d->password.isNull()) {
         writer->writeEmptyElement(QStringLiteral("password"));
+    }
 
-    if (!d->email.isEmpty())
+    if (!d->email.isEmpty()) {
         writer->writeTextElement(QStringLiteral("email"), d->email);
-    else if (!d->email.isNull())
+    } else if (!d->email.isNull()) {
         writer->writeEmptyElement(QStringLiteral("email"));
+    }
 
     d->form.toXml(writer);
     d->bitsOfBinaryData.toXml(writer);
diff --git a/src/base/QXmppResultSet.cpp b/src/base/QXmppResultSet.cpp
index d0e0fa2a..99b91c8c 100644
--- a/src/base/QXmppResultSet.cpp
+++ b/src/base/QXmppResultSet.cpp
@@ -102,30 +102,37 @@ void QXmppResultSetQuery::parse(const QDomElement &element)
     if (setElement.namespaceURI() == ns_rsm) {
         bool ok = false;
         m_max = setElement.firstChildElement(QStringLiteral("max")).text().toInt(&ok);
-        if (!ok)
+        if (!ok) {
             m_max = -1;
+        }
         m_after = setElement.firstChildElement(QStringLiteral("after")).text();
         m_before = setElement.firstChildElement(QStringLiteral("before")).text();
         m_index = setElement.firstChildElement(QStringLiteral("index")).text().toInt(&ok);
-        if (!ok)
+        if (!ok) {
             m_index = -1;
+        }
     }
 }
 
 void QXmppResultSetQuery::toXml(QXmlStreamWriter *writer) const
 {
-    if (isNull())
+    if (isNull()) {
         return;
+    }
     writer->writeStartElement(QStringLiteral("set"));
     writer->writeDefaultNamespace(ns_rsm);
-    if (m_max >= 0)
+    if (m_max >= 0) {
         helperToXmlAddTextElement(writer, QStringLiteral("max"), QString::number(m_max));
-    if (!m_after.isNull())
+    }
+    if (!m_after.isNull()) {
         helperToXmlAddTextElement(writer, QStringLiteral("after"), m_after);
-    if (!m_before.isNull())
+    }
+    if (!m_before.isNull()) {
         helperToXmlAddTextElement(writer, QStringLiteral("before"), m_before);
-    if (m_index >= 0)
+    }
+    if (m_index >= 0) {
         helperToXmlAddTextElement(writer, QStringLiteral("index"), QString::number(m_index));
+    }
     writer->writeEndElement();
 }
 /// \endcond
@@ -220,30 +227,35 @@ void QXmppResultSetReply::parse(const QDomElement &element)
         m_first = firstElem.text();
         bool ok = false;
         m_index = firstElem.attribute("index").toInt(&ok);
-        if (!ok)
+        if (!ok) {
             m_index = -1;
+        }
         m_last = setElement.firstChildElement("last").text();
     }
 }
 
 void QXmppResultSetReply::toXml(QXmlStreamWriter *writer) const
 {
-    if (isNull())
+    if (isNull()) {
         return;
+    }
     writer->writeStartElement("set");
     writer->writeDefaultNamespace(ns_rsm);
     if (!m_first.isNull() || m_index >= 0) {
         writer->writeStartElement("first");
-        if (m_index >= 0)
+        if (m_index >= 0) {
             writer->writeAttribute("index", QString::number(m_index));
+        }
         writer->writeCharacters(m_first);
         writer->writeEndElement();
     }
-    if (!m_last.isNull())
+    if (!m_last.isNull()) {
         helperToXmlAddTextElement(writer, "last", m_last);
+    }
 
-    if (m_count >= 0)
+    if (m_count >= 0) {
         helperToXmlAddTextElement(writer, "count", QString::number(m_count));
+    }
     writer->writeEndElement();
 }
 /// \endcond
diff --git a/src/base/QXmppRosterIq.cpp b/src/base/QXmppRosterIq.cpp
index 28f7572d..59f20f0b 100644
--- a/src/base/QXmppRosterIq.cpp
+++ b/src/base/QXmppRosterIq.cpp
@@ -129,8 +129,9 @@ void QXmppRosterIq::toXmlElementFromChild(QXmlStreamWriter *writer) const
     writer->writeDefaultNamespace(ns_roster);
 
     // XEP-0237 roster versioning - If the server does not advertise support for roster versioning, the client MUST NOT include the 'ver' attribute.
-    if (!version().isEmpty())
+    if (!version().isEmpty()) {
         writer->writeAttribute(QStringLiteral("ver"), version());
+    }
 
     // XEP-0405: Mediated Information eXchange (MIX): Participant Server Requirements
     if (d->mixAnnotate) {
@@ -139,8 +140,9 @@ void QXmppRosterIq::toXmlElementFromChild(QXmlStreamWriter *writer) const
         writer->writeEndElement();
     }
 
-    for (int i = 0; i < d->items.count(); ++i)
+    for (int i = 0; i < d->items.count(); ++i) {
         d->items.at(i).toXml(writer);
+    }
     writer->writeEndElement();
 }
 /// \endcond
@@ -336,20 +338,21 @@ QString QXmppRosterIq::Item::getSubscriptionTypeStr() const
 
 void QXmppRosterIq::Item::setSubscriptionTypeFromStr(const QString &type)
 {
-    if (type.isEmpty())
+    if (type.isEmpty()) {
         setSubscriptionType(NotSet);
-    else if (type == QStringLiteral("none"))
+    } else if (type == QStringLiteral("none")) {
         setSubscriptionType(None);
-    else if (type == QStringLiteral("both"))
+    } else if (type == QStringLiteral("both")) {
         setSubscriptionType(Both);
-    else if (type == QStringLiteral("from"))
+    } else if (type == QStringLiteral("from")) {
         setSubscriptionType(From);
-    else if (type == QStringLiteral("to"))
+    } else if (type == QStringLiteral("to")) {
         setSubscriptionType(To);
-    else if (type == QStringLiteral("remove"))
+    } else if (type == QStringLiteral("remove")) {
         setSubscriptionType(Remove);
-    else
+    } else {
         qWarning("QXmppRosterIq::Item::setTypeFromStr(): invalid type");
+    }
 }
 
 ///
@@ -426,8 +429,9 @@ void QXmppRosterIq::Item::toXml(QXmlStreamWriter *writer) const
     helperToXmlAddAttribute(writer, QStringLiteral("name"), d->name);
     helperToXmlAddAttribute(writer, QStringLiteral("subscription"), getSubscriptionTypeStr());
     helperToXmlAddAttribute(writer, QStringLiteral("ask"), subscriptionStatus());
-    if (d->approved)
+    if (d->approved) {
         writer->writeAttribute(QStringLiteral("approved"), QStringLiteral("true"));
+    }
 
     QSet<QString>::const_iterator i = d->groups.constBegin();
     while (i != d->groups.constEnd()) {
diff --git a/src/base/QXmppRpcIq.cpp b/src/base/QXmppRpcIq.cpp
index bfee0f16..b7a45db5 100644
--- a/src/base/QXmppRpcIq.cpp
+++ b/src/base/QXmppRpcIq.cpp
@@ -70,9 +70,9 @@ void QXmppRpcMarshaller::marshall(QXmlStreamWriter *writer, const QVariant &valu
         break;
     }
     default: {
-        if (value.isNull())
+        if (value.isNull()) {
             writer->writeEmptyElement(QStringLiteral("nil"));
-        else if (value.canConvert(QVariant::String)) {
+        } else if (value.canConvert(QVariant::String)) {
             writer->writeTextElement(QStringLiteral("string"), value.toString());
         }
         break;
@@ -103,21 +103,23 @@ QVariant QXmppRpcMarshaller::demarshall(const QDomElement &elem, QStringList &er
     } else if (typeName == QStringLiteral("int") || typeName == QStringLiteral("i4")) {
         bool ok = false;
         QVariant val(typeData.text().toInt(&ok));
-        if (ok)
+        if (ok) {
             return val;
+        }
         errors << "I was looking for an integer but data was courupt";
         return QVariant();
     } else if (typeName == QStringLiteral("double")) {
         bool ok = false;
         QVariant val(typeData.text().toDouble(&ok));
-        if (ok)
+        if (ok) {
             return val;
+        }
         errors << "I was looking for an double but data was corrupt";
-    } else if (typeName == QStringLiteral("boolean"))
+    } else if (typeName == QStringLiteral("boolean")) {
         return QVariant(typeData.text() == QStringLiteral("1") || typeData.text().toLower() == QStringLiteral("true"));
-    else if (typeName == QStringLiteral("datetime") || typeName == QStringLiteral("datetime.iso8601"))
+    } else if (typeName == QStringLiteral("datetime") || typeName == QStringLiteral("datetime.iso8601")) {
         return QVariant(QDateTime::fromString(typeData.text(), Qt::ISODate));
-    else if (typeName == QStringLiteral("array")) {
+    } else if (typeName == QStringLiteral("array")) {
         QVariantList arr;
         QDomElement valueNode = typeData.firstChildElement(QStringLiteral("data")).firstChildElement();
         while (!valueNode.isNull() && errors.isEmpty()) {
@@ -257,8 +259,9 @@ void QXmppRpcResponseIq::parseElementFromChild(const QDomElement &element)
         while (!param.isNull()) {
             QStringList errors;
             const QVariant value = QXmppRpcMarshaller::demarshall(param.firstChildElement(QStringLiteral("value")), errors);
-            if (!errors.isEmpty())
+            if (!errors.isEmpty()) {
                 break;
+            }
             m_values << value;
             param = param.nextSiblingElement(QStringLiteral("param"));
         }
@@ -266,8 +269,9 @@ void QXmppRpcResponseIq::parseElementFromChild(const QDomElement &element)
         QStringList errors;
         const QDomElement errElement = contents.firstChildElement(QStringLiteral("value"));
         const QVariant error = QXmppRpcMarshaller::demarshall(errElement, errors);
-        if (!errors.isEmpty())
+        if (!errors.isEmpty()) {
             return;
+        }
         m_faultCode = error.toMap()[QStringLiteral("faultCode")].toInt();
         m_faultString = error.toMap()[QStringLiteral("faultString")].toString();
     }
@@ -363,8 +367,9 @@ void QXmppRpcInvokeIq::parseElementFromChild(const QDomElement &element)
         while (!param.isNull()) {
             QStringList errors;
             QVariant arg = QXmppRpcMarshaller::demarshall(param.firstChildElement(QStringLiteral("value")), errors);
-            if (!errors.isEmpty())
+            if (!errors.isEmpty()) {
                 break;
+            }
             m_arguments << arg;
             param = param.nextSiblingElement(QStringLiteral("param"));
         }
diff --git a/src/base/QXmppSasl.cpp b/src/base/QXmppSasl.cpp
index be4dc76e..d8a86bb0 100644
--- a/src/base/QXmppSasl.cpp
+++ b/src/base/QXmppSasl.cpp
@@ -92,8 +92,9 @@ static QByteArray deriveKeyPbkdf2(QCryptographicHash::Algorithm algorithm,
 
 static QByteArray generateNonce()
 {
-    if (!forcedNonce.isEmpty())
+    if (!forcedNonce.isEmpty()) {
         return forcedNonce;
+    }
 
     QByteArray nonce = QXmppUtils::generateRandomBytes(32);
 
@@ -150,8 +151,9 @@ void QXmppSaslAuth::toXml(QXmlStreamWriter *writer) const
     writer->writeStartElement(QStringLiteral("auth"));
     writer->writeDefaultNamespace(ns_xmpp_sasl);
     writer->writeAttribute(QStringLiteral("mechanism"), m_mechanism);
-    if (!m_value.isEmpty())
+    if (!m_value.isEmpty()) {
         writer->writeCharacters(m_value.toBase64());
+    }
     writer->writeEndElement();
 }
 
@@ -179,8 +181,9 @@ void QXmppSaslChallenge::toXml(QXmlStreamWriter *writer) const
 {
     writer->writeStartElement(QStringLiteral("challenge"));
     writer->writeDefaultNamespace(ns_xmpp_sasl);
-    if (!m_value.isEmpty())
+    if (!m_value.isEmpty()) {
         writer->writeCharacters(m_value.toBase64());
+    }
     writer->writeEndElement();
 }
 
@@ -208,8 +211,9 @@ void QXmppSaslFailure::toXml(QXmlStreamWriter *writer) const
 {
     writer->writeStartElement(QStringLiteral("failure"));
     writer->writeDefaultNamespace(ns_xmpp_sasl);
-    if (!m_condition.isEmpty())
+    if (!m_condition.isEmpty()) {
         writer->writeEmptyElement(m_condition);
+    }
     writer->writeEndElement();
 }
 
@@ -237,8 +241,9 @@ void QXmppSaslResponse::toXml(QXmlStreamWriter *writer) const
 {
     writer->writeStartElement(QStringLiteral("response"));
     writer->writeDefaultNamespace(ns_xmpp_sasl);
-    if (!m_value.isEmpty())
+    if (!m_value.isEmpty()) {
         writer->writeCharacters(m_value.toBase64());
+    }
     writer->writeEndElement();
 }
 
@@ -445,8 +450,9 @@ bool QXmppSaslClientDigestMd5::respond(const QByteArray &challenge, QByteArray &
         // Build response
         QMap<QByteArray, QByteArray> output;
         output[QByteArrayLiteral("username")] = username().toUtf8();
-        if (!realm.isEmpty())
+        if (!realm.isEmpty()) {
             output[QByteArrayLiteral("realm")] = realm;
+        }
         output[QByteArrayLiteral("nonce")] = m_nonce;
         output[QByteArrayLiteral("qop")] = QByteArrayLiteral("auth");
         output[QByteArrayLiteral("cnonce")] = m_cnonce;
@@ -785,8 +791,9 @@ QXmppSaslServer::Response QXmppSaslServerDigestMd5::respond(const QByteArray &re
     if (m_step == 0) {
         QMap<QByteArray, QByteArray> output;
         output[QByteArrayLiteral("nonce")] = m_nonce;
-        if (!realm().isEmpty())
+        if (!realm().isEmpty()) {
             output[QByteArrayLiteral("realm")] = realm().toUtf8();
+        }
         output[QByteArrayLiteral("qop")] = QByteArrayLiteral("auth");
         output[QByteArrayLiteral("charset")] = QByteArrayLiteral("utf-8");
         output[QByteArrayLiteral("algorithm")] = QByteArrayLiteral("md5-sess");
@@ -805,8 +812,9 @@ QXmppSaslServer::Response QXmppSaslServerDigestMd5::respond(const QByteArray &re
         }
 
         setUsername(QString::fromUtf8(input.value(QByteArrayLiteral("username"))));
-        if (password().isEmpty() && passwordDigest().isEmpty())
+        if (password().isEmpty() && passwordDigest().isEmpty()) {
             return InputNeeded;
+        }
 
         m_nc = input.value(QByteArrayLiteral("nc"));
         m_cnonce = input.value(QByteArrayLiteral("cnonce"));
@@ -818,8 +826,9 @@ QXmppSaslServer::Response QXmppSaslServerDigestMd5::respond(const QByteArray &re
             m_secret = passwordDigest();
         }
 
-        if (input.value(QByteArrayLiteral("response")) != calculateDigest(QByteArrayLiteral("AUTHENTICATE"), digestUri, m_secret, m_nonce, m_cnonce, m_nc))
+        if (input.value(QByteArrayLiteral("response")) != calculateDigest(QByteArrayLiteral("AUTHENTICATE"), digestUri, m_secret, m_nonce, m_cnonce, m_nc)) {
             return Failed;
+        }
 
         QMap<QByteArray, QByteArray> output;
         output[QByteArrayLiteral("rspauth")] = calculateDigest(QByteArray(), digestUri, m_secret, m_nonce, m_cnonce, m_nc);
@@ -893,8 +902,9 @@ QMap<QByteArray, QByteArray> QXmppSaslDigestMd5::parseMessage(const QByteArray &
             pos++;
             int endPos = ba.indexOf('"', pos);
             // skip quoted quotes
-            while (endPos >= 0 && ba.at(endPos - 1) == '\\')
+            while (endPos >= 0 && ba.at(endPos - 1) == '\\') {
                 endPos = ba.indexOf('"', endPos + 1);
+            }
             if (endPos < 0) {
                 qWarning("Unfinished quoted string");
                 return map;
@@ -909,8 +919,9 @@ QMap<QByteArray, QByteArray> QXmppSaslDigestMd5::parseMessage(const QByteArray &
         } else {
             // non-quoted string
             int endPos = ba.indexOf(',', pos);
-            if (endPos < 0)
+            if (endPos < 0) {
                 endPos = ba.size();
+            }
             map[key] = ba.mid(pos, endPos - pos);
             // skip comma
             startIndex = endPos + 1;
@@ -923,8 +934,9 @@ QByteArray QXmppSaslDigestMd5::serializeMessage(const QMap<QByteArray, QByteArra
 {
     QByteArray ba;
     for (auto itr = map.begin(); itr != map.end(); itr++) {
-        if (!ba.isEmpty())
+        if (!ba.isEmpty()) {
             ba.append(',');
+        }
         ba.append(itr.key() + QByteArrayLiteral("="));
         auto value = itr.value();
         const char *separators = "()<>@,;:\\\"/[]?={} \t";
diff --git a/src/base/QXmppSocks.cpp b/src/base/QXmppSocks.cpp
index c09431a3..5420f6b4 100644
--- a/src/base/QXmppSocks.cpp
+++ b/src/base/QXmppSocks.cpp
@@ -66,8 +66,9 @@ static bool parseHostAndPort(QDataStream &stream, quint8 &type, QByteArray &host
     quint8 hostLength;
     stream >> type;
     stream >> hostLength;
-    if (stream.status() != QDataStream::Ok)
+    if (stream.status() != QDataStream::Ok) {
         return false;
+    }
     host.resize(hostLength);
     if (stream.readRawData(host.data(), hostLength) != hostLength) {
         qWarning("Invalid host length");
@@ -188,8 +189,9 @@ void QXmppSocksServer::close()
 
 bool QXmppSocksServer::listen(quint16 port)
 {
-    if (!m_server->listen(QHostAddress::Any, port))
+    if (!m_server->listen(QHostAddress::Any, port)) {
         return false;
+    }
 
     // FIXME: this fails on Linux if /proc/sys/net/ipv6/bindv6only is 0
     m_server_v6->listen(QHostAddress::AnyIPv6, m_server->serverPort());
@@ -204,12 +206,14 @@ quint16 QXmppSocksServer::serverPort() const
 void QXmppSocksServer::slotNewConnection()
 {
     auto *server = qobject_cast<QTcpServer *>(sender());
-    if (!server)
+    if (!server) {
         return;
+    }
 
     QTcpSocket *socket = server->nextPendingConnection();
-    if (!socket)
+    if (!socket) {
         return;
+    }
 
     // register socket
     m_states.insert(socket, ConnectState);
@@ -219,8 +223,9 @@ void QXmppSocksServer::slotNewConnection()
 void QXmppSocksServer::slotReadyRead()
 {
     auto *socket = qobject_cast<QTcpSocket *>(sender());
-    if (!socket || !m_states.contains(socket))
+    if (!socket || !m_states.contains(socket)) {
         return;
+    }
 
     if (m_states.value(socket) == ConnectState) {
         // receive connect to server request
diff --git a/src/base/QXmppStanza.cpp b/src/base/QXmppStanza.cpp
index 56ad5e4c..db969327 100644
--- a/src/base/QXmppStanza.cpp
+++ b/src/base/QXmppStanza.cpp
@@ -81,55 +81,56 @@ QString conditionToString(QXmppStanza::Error::Condition condition)
 
 std::optional<QXmppStanza::Error::Condition> conditionFromString(const QString &string)
 {
-    if (string == "bad-request")
+    if (string == "bad-request") {
         return QXmppStanza::Error::BadRequest;
-    else if (string == "conflict")
+    } else if (string == "conflict") {
         return QXmppStanza::Error::Conflict;
-    else if (string == "feature-not-implemented")
+    } else if (string == "feature-not-implemented") {
         return QXmppStanza::Error::FeatureNotImplemented;
-    else if (string == "forbidden")
+    } else if (string == "forbidden") {
         return QXmppStanza::Error::Forbidden;
-    else if (string == "gone")
+    } else if (string == "gone") {
         return QXmppStanza::Error::Gone;
-    else if (string == "internal-server-error")
+    } else if (string == "internal-server-error") {
         return QXmppStanza::Error::InternalServerError;
-    else if (string == "item-not-found")
+    } else if (string == "item-not-found") {
         return QXmppStanza::Error::ItemNotFound;
-    else if (string == "jid-malformed")
+    } else if (string == "jid-malformed") {
         return QXmppStanza::Error::JidMalformed;
-    else if (string == "not-acceptable")
+    } else if (string == "not-acceptable") {
         return QXmppStanza::Error::NotAcceptable;
-    else if (string == "not-allowed")
+    } else if (string == "not-allowed") {
         return QXmppStanza::Error::NotAllowed;
-    else if (string == "not-authorized")
+    } else if (string == "not-authorized") {
         return QXmppStanza::Error::NotAuthorized;
-    else if (string == "payment-required") {
+    } else if (string == "payment-required") {
         QT_WARNING_PUSH
         QT_WARNING_DISABLE_DEPRECATED
         return QXmppStanza::Error::PaymentRequired;
         QT_WARNING_POP
-    } else if (string == "policy-violation")
+    } else if (string == "policy-violation") {
         return QXmppStanza::Error::PolicyViolation;
-    else if (string == "recipient-unavailable")
+    } else if (string == "recipient-unavailable") {
         return QXmppStanza::Error::RecipientUnavailable;
-    else if (string == "redirect")
+    } else if (string == "redirect") {
         return QXmppStanza::Error::Redirect;
-    else if (string == "registration-required")
+    } else if (string == "registration-required") {
         return QXmppStanza::Error::RegistrationRequired;
-    else if (string == "remote-server-not-found")
+    } else if (string == "remote-server-not-found") {
         return QXmppStanza::Error::RemoteServerNotFound;
-    else if (string == "remote-server-timeout")
+    } else if (string == "remote-server-timeout") {
         return QXmppStanza::Error::RemoteServerTimeout;
-    else if (string == "resource-constraint")
+    } else if (string == "resource-constraint") {
         return QXmppStanza::Error::ResourceConstraint;
-    else if (string == "service-unavailable")
+    } else if (string == "service-unavailable") {
         return QXmppStanza::Error::ServiceUnavailable;
-    else if (string == "subscription-required")
+    } else if (string == "subscription-required") {
         return QXmppStanza::Error::SubscriptionRequired;
-    else if (string == "undefined-condition")
+    } else if (string == "undefined-condition") {
         return QXmppStanza::Error::UndefinedCondition;
-    else if (string == "unexpected-request")
+    } else if (string == "unexpected-request") {
         return QXmppStanza::Error::UnexpectedRequest;
+    }
     return std::nullopt;
 }
 
@@ -152,16 +153,17 @@ QString typeToString(QXmppStanza::Error::Type type)
 
 std::optional<QXmppStanza::Error::Type> typeFromString(const QString &string)
 {
-    if (string == QStringLiteral("cancel"))
+    if (string == QStringLiteral("cancel")) {
         return QXmppStanza::Error::Cancel;
-    else if (string == QStringLiteral("continue"))
+    } else if (string == QStringLiteral("continue")) {
         return QXmppStanza::Error::Continue;
-    else if (string == QStringLiteral("modify"))
+    } else if (string == QStringLiteral("modify")) {
         return QXmppStanza::Error::Modify;
-    else if (string == QStringLiteral("auth"))
+    } else if (string == QStringLiteral("auth")) {
         return QXmppStanza::Error::Auth;
-    else if (string == QStringLiteral("wait"))
+    } else if (string == QStringLiteral("wait")) {
         return QXmppStanza::Error::Wait;
+    }
     return std::nullopt;
 }
 
@@ -280,10 +282,12 @@ void QXmppExtendedAddress::parse(const QDomElement &element)
 void QXmppExtendedAddress::toXml(QXmlStreamWriter *xmlWriter) const
 {
     xmlWriter->writeStartElement(QStringLiteral("address"));
-    if (d->delivered)
+    if (d->delivered) {
         xmlWriter->writeAttribute(QStringLiteral("delivered"), QStringLiteral("true"));
-    if (!d->description.isEmpty())
+    }
+    if (!d->description.isEmpty()) {
         xmlWriter->writeAttribute(QStringLiteral("desc"), d->description);
+    }
     xmlWriter->writeAttribute(QStringLiteral("jid"), d->jid);
     xmlWriter->writeAttribute(QStringLiteral("type"), d->type);
     xmlWriter->writeEndElement();
@@ -623,8 +627,9 @@ void QXmppStanza::Error::parse(const QDomElement &errorElement)
                     d->redirectionUri = element.text();
 
                     // .text() returns empty string if nothing was set
-                    if (d->redirectionUri.isEmpty())
+                    if (d->redirectionUri.isEmpty()) {
                         d->redirectionUri.clear();
+                    }
                 }
             }
         } else if (element.namespaceURI() == ns_http_upload) {
@@ -647,8 +652,9 @@ void QXmppStanza::Error::parse(const QDomElement &errorElement)
 
 void QXmppStanza::Error::toXml(QXmlStreamWriter *writer) const
 {
-    if (!d->condition && !d->type)
+    if (!d->condition && !d->type) {
         return;
+    }
 
     writer->writeStartElement(QStringLiteral("error"));
     helperToXmlAddAttribute(writer, QStringLiteral("by"), d->by);
@@ -656,8 +662,9 @@ void QXmppStanza::Error::toXml(QXmlStreamWriter *writer) const
         writer->writeAttribute(QStringLiteral("type"), typeToString(*d->type));
     }
 
-    if (d->code > 0)
+    if (d->code > 0) {
         helperToXmlAddAttribute(writer, QStringLiteral("code"), QString::number(d->code));
+    }
 
     if (d->condition) {
         writer->writeStartElement(conditionToString(*d->condition));
@@ -1045,16 +1052,18 @@ void QXmppStanza::parse(const QDomElement &element)
     d->lang = element.attribute("lang");
 
     QDomElement errorElement = element.firstChildElement("error");
-    if (!errorElement.isNull())
+    if (!errorElement.isNull()) {
         d->error.parse(errorElement);
+    }
 
     // XEP-0033: Extended Stanza Addressing
     QDomElement addressElement = element.firstChildElement("addresses").firstChildElement("address");
     while (!addressElement.isNull()) {
         QXmppExtendedAddress address;
         address.parse(addressElement);
-        if (address.isValid())
+        if (address.isValid()) {
             d->extendedAddresses << address;
+        }
         addressElement = addressElement.nextSiblingElement("address");
     }
 }
@@ -1065,14 +1074,16 @@ void QXmppStanza::extensionsToXml(QXmlStreamWriter *xmlWriter, QXmpp::SceMode sc
     if (sceMode & QXmpp::ScePublic && !d->extendedAddresses.isEmpty()) {
         xmlWriter->writeStartElement("addresses");
         xmlWriter->writeDefaultNamespace(ns_extended_addressing);
-        for (const auto &address : d->extendedAddresses)
+        for (const auto &address : d->extendedAddresses) {
             address.toXml(xmlWriter);
+        }
         xmlWriter->writeEndElement();
     }
 
     // other extensions
-    for (const auto &extension : d->extensions)
+    for (const auto &extension : d->extensions) {
         extension.toXml(xmlWriter);
+    }
 }
 
 /// \endcond
diff --git a/src/base/QXmppStartTlsPacket.cpp b/src/base/QXmppStartTlsPacket.cpp
index 60b2cf5b..3fab0ea0 100644
--- a/src/base/QXmppStartTlsPacket.cpp
+++ b/src/base/QXmppStartTlsPacket.cpp
@@ -43,8 +43,9 @@ void QXmppStartTlsPacket::setType(QXmppStartTlsPacket::Type type)
 /// \cond
 void QXmppStartTlsPacket::parse(const QDomElement &element)
 {
-    if (!QXmppStartTlsPacket::isStartTlsPacket(element))
+    if (!QXmppStartTlsPacket::isStartTlsPacket(element)) {
         return;
+    }
 
     if (auto index = STARTTLS_TYPES.indexOf(element.tagName()); index >= 0) {
         m_type = Type(index);
diff --git a/src/base/QXmppStream.cpp b/src/base/QXmppStream.cpp
index 25dea1b7..6b5d9589 100644
--- a/src/base/QXmppStream.cpp
+++ b/src/base/QXmppStream.cpp
@@ -145,8 +145,9 @@ bool QXmppStream::isConnected() const
 bool QXmppStream::sendData(const QByteArray &data)
 {
     logSent(QString::fromUtf8(data));
-    if (!d->socket || d->socket->state() != QAbstractSocket::ConnectedState)
+    if (!d->socket || d->socket->state() != QAbstractSocket::ConnectedState) {
         return false;
+    }
     return d->socket->write(data) == data.size();
 }
 
@@ -315,8 +316,9 @@ QSslSocket *QXmppStream::socket() const
 void QXmppStream::setSocket(QSslSocket *socket)
 {
     d->socket = socket;
-    if (!d->socket)
+    if (!d->socket) {
         return;
+    }
 
     // socket events
     connect(socket, &QAbstractSocket::connected, this, &QXmppStream::_q_socketConnected);
@@ -425,8 +427,9 @@ void QXmppStream::processData(const QString &data)
     // Try to parse the wrapped XML
     //
     QDomDocument doc;
-    if (!doc.setContent(wrappedStanzas, true))
+    if (!doc.setContent(wrappedStanzas, true)) {
         return;
+    }
 
     //
     // Success: We can clear the buffer and send a 'received' log message
@@ -444,8 +447,9 @@ void QXmppStream::processData(const QString &data)
     auto stanza = doc.documentElement().firstChildElement();
     for (; !stanza.isNull(); stanza = stanza.nextSiblingElement()) {
         // handle possible stream management packets first
-        if (d->streamManager.handleStanza(stanza) || handleIqResponse(stanza))
+        if (d->streamManager.handleStanza(stanza) || handleIqResponse(stanza)) {
             continue;
+        }
 
         // process all other kinds of packets
         handleStanza(stanza);
diff --git a/src/base/QXmppStreamFeatures.cpp b/src/base/QXmppStreamFeatures.cpp
index a6cc4443..e9a74440 100644
--- a/src/base/QXmppStreamFeatures.cpp
+++ b/src/base/QXmppStreamFeatures.cpp
@@ -270,10 +270,11 @@ static QXmppStreamFeatures::Mode readFeature(const QDomElement &element, const c
     QXmppStreamFeatures::Mode mode = QXmppStreamFeatures::Disabled;
     while (!subElement.isNull()) {
         if (subElement.namespaceURI() == tagNs) {
-            if (!subElement.firstChildElement(QStringLiteral("required")).isNull())
+            if (!subElement.firstChildElement(QStringLiteral("required")).isNull()) {
                 mode = QXmppStreamFeatures::Required;
-            else if (mode != QXmppStreamFeatures::Required)
+            } else if (mode != QXmppStreamFeatures::Required) {
                 mode = QXmppStreamFeatures::Enabled;
+            }
         }
         subElement = subElement.nextSiblingElement(tagName);
     }
@@ -330,8 +331,9 @@ static void writeFeature(QXmlStreamWriter *writer, const char *tagName, const ch
     if (mode != QXmppStreamFeatures::Disabled) {
         writer->writeStartElement(tagName);
         writer->writeDefaultNamespace(tagNs);
-        if (mode == QXmppStreamFeatures::Required)
+        if (mode == QXmppStreamFeatures::Required) {
             writer->writeEmptyElement(QStringLiteral("required"));
+        }
         writer->writeEndElement();
     }
 }
@@ -361,15 +363,17 @@ void QXmppStreamFeatures::toXml(QXmlStreamWriter *writer) const
     if (!d->compressionMethods.isEmpty()) {
         writer->writeStartElement(QStringLiteral("compression"));
         writer->writeDefaultNamespace(ns_compressFeature);
-        for (const auto &method : std::as_const(d->compressionMethods))
+        for (const auto &method : std::as_const(d->compressionMethods)) {
             writer->writeTextElement(QStringLiteral("method"), method);
+        }
         writer->writeEndElement();
     }
     if (!d->authMechanisms.isEmpty()) {
         writer->writeStartElement(QStringLiteral("mechanisms"));
         writer->writeDefaultNamespace(ns_sasl);
-        for (const auto &mechanism : std::as_const(d->authMechanisms))
+        for (const auto &mechanism : std::as_const(d->authMechanisms)) {
             writer->writeTextElement(QStringLiteral("mechanism"), mechanism);
+        }
         writer->writeEndElement();
     }
     writer->writeEndElement();
diff --git a/src/base/QXmppStreamInitiationIq.cpp b/src/base/QXmppStreamInitiationIq.cpp
index 56c31024..b3c93c8c 100644
--- a/src/base/QXmppStreamInitiationIq.cpp
+++ b/src/base/QXmppStreamInitiationIq.cpp
@@ -70,10 +70,11 @@ void QXmppStreamInitiationIq::parseElementFromChild(const QDomElement &element)
     QDomElement siElement = element.firstChildElement(QStringLiteral("si"));
     m_siId = siElement.attribute(QStringLiteral("id"));
     m_mimeType = siElement.attribute(QStringLiteral("mime-type"));
-    if (siElement.attribute(QStringLiteral("profile")) == ns_stream_initiation_file_transfer)
+    if (siElement.attribute(QStringLiteral("profile")) == ns_stream_initiation_file_transfer) {
         m_profile = FileTransfer;
-    else
+    } else {
         m_profile = None;
+    }
 
     QDomElement itemElement = siElement.firstChildElement();
     while (!itemElement.isNull()) {
@@ -92,10 +93,12 @@ void QXmppStreamInitiationIq::toXmlElementFromChild(QXmlStreamWriter *writer) co
     writer->writeDefaultNamespace(ns_stream_initiation);
     helperToXmlAddAttribute(writer, QStringLiteral("id"), m_siId);
     helperToXmlAddAttribute(writer, QStringLiteral("mime-type"), m_mimeType);
-    if (m_profile == FileTransfer)
+    if (m_profile == FileTransfer) {
         helperToXmlAddAttribute(writer, QStringLiteral("profile"), ns_stream_initiation_file_transfer);
-    if (!m_fileInfo.isNull())
+    }
+    if (!m_fileInfo.isNull()) {
         m_fileInfo.toXml(writer);
+    }
     if (!m_featureForm.isNull()) {
         writer->writeStartElement(QStringLiteral("feature"));
         writer->writeDefaultNamespace(ns_feature_negotiation);
diff --git a/src/base/QXmppStreamManagement.cpp b/src/base/QXmppStreamManagement.cpp
index af08dc71..67a28ef8 100644
--- a/src/base/QXmppStreamManagement.cpp
+++ b/src/base/QXmppStreamManagement.cpp
@@ -54,10 +54,12 @@ void QXmppStreamManagementEnable::toXml(QXmlStreamWriter *writer) const
 {
     writer->writeStartElement(QStringLiteral("enable"));
     writer->writeDefaultNamespace(ns_stream_management);
-    if (m_resume)
+    if (m_resume) {
         writer->writeAttribute(QStringLiteral("resume"), QStringLiteral("true"));
-    if (m_max > 0)
+    }
+    if (m_max > 0) {
         writer->writeAttribute(QStringLiteral("max"), QString::number(m_max));
+    }
     writer->writeEndElement();
 }
 
@@ -124,12 +126,15 @@ void QXmppStreamManagementEnabled::toXml(QXmlStreamWriter *writer) const
 {
     writer->writeStartElement(QStringLiteral("enable"));
     writer->writeDefaultNamespace(ns_stream_management);
-    if (m_resume)
+    if (m_resume) {
         writer->writeAttribute(QStringLiteral("resume"), QStringLiteral("true"));
-    if (m_max > 0)
+    }
+    if (m_max > 0) {
         writer->writeAttribute(QStringLiteral("max"), QString::number(m_max));
-    if (!m_location.isEmpty())
+    }
+    if (!m_location.isEmpty()) {
         writer->writeAttribute(QStringLiteral("location"), m_location);
+    }
     writer->writeEndElement();
 }
 
@@ -424,8 +429,9 @@ void QXmppStreamManager::setAcknowledgedSequenceNumber(unsigned int sequenceNumb
 
 void QXmppStreamManager::handleAcknowledgement(const QDomElement &element)
 {
-    if (!m_enabled)
+    if (!m_enabled) {
         return;
+    }
 
     QXmppStreamManagementAck ack;
     ack.parse(element);
@@ -434,8 +440,9 @@ void QXmppStreamManager::handleAcknowledgement(const QDomElement &element)
 
 void QXmppStreamManager::sendAcknowledgement()
 {
-    if (!m_enabled)
+    if (!m_enabled) {
         return;
+    }
 
     // prepare packet
     QByteArray data;
@@ -449,8 +456,9 @@ void QXmppStreamManager::sendAcknowledgement()
 
 void QXmppStreamManager::sendAcknowledgementRequest()
 {
-    if (!m_enabled)
+    if (!m_enabled) {
         return;
+    }
 
     // prepare packet
     QByteArray data;
diff --git a/src/base/QXmppStun.cpp b/src/base/QXmppStun.cpp
index eb3ce0e1..360135a4 100644
--- a/src/base/QXmppStun.cpp
+++ b/src/base/QXmppStun.cpp
@@ -99,8 +99,9 @@ static QString computeFoundation(QXmppJingleCandidate::Type type, const QString
 
 static bool isIPv6LinkLocalAddress(const QHostAddress &addr)
 {
-    if (addr.protocol() != QAbstractSocket::IPv6Protocol)
+    if (addr.protocol() != QAbstractSocket::IPv6Protocol) {
         return false;
+    }
     Q_IPV6ADDR ipv6addr = addr.toIPv6Address();
     return (((ipv6addr[0] << 8) + ipv6addr[1]) & 0xffc0) == 0xfe80;
 }
@@ -119,37 +120,43 @@ static bool isCompatibleAddress(const QHostAddress &a1, const QHostAddress &a2)
 
 static bool decodeAddress(QDataStream &stream, quint16 a_length, QHostAddress &address, quint16 &port, const QByteArray &xorId = QByteArray())
 {
-    if (a_length < 4)
+    if (a_length < 4) {
         return false;
+    }
     quint8 reserved, protocol;
     quint16 rawPort;
     stream >> reserved;
     stream >> protocol;
     stream >> rawPort;
-    if (xorId.isEmpty())
+    if (xorId.isEmpty()) {
         port = rawPort;
-    else
+    } else {
         port = rawPort ^ (STUN_MAGIC >> 16);
+    }
     if (protocol == STUN_IPV4) {
-        if (a_length != 8)
+        if (a_length != 8) {
             return false;
+        }
         quint32 addr;
         stream >> addr;
-        if (xorId.isEmpty())
+        if (xorId.isEmpty()) {
             address = QHostAddress(addr);
-        else
+        } else {
             address = QHostAddress(addr ^ STUN_MAGIC);
+        }
     } else if (protocol == STUN_IPV6) {
-        if (a_length != 20)
+        if (a_length != 20) {
             return false;
+        }
         Q_IPV6ADDR addr;
         stream.readRawData((char *)&addr, sizeof(addr));
         if (!xorId.isEmpty()) {
             QByteArray xpad;
             QDataStream(&xpad, QIODevice::WriteOnly) << STUN_MAGIC;
             xpad += xorId;
-            for (int i = 0; i < 16; i++)
+            for (int i = 0; i < 16; i++) {
                 addr[i] ^= xpad[i];
+            }
         }
         address = QHostAddress(addr);
     } else {
@@ -184,8 +191,9 @@ static void encodeAddress(QDataStream &stream, quint16 type, const QHostAddress
             QByteArray xpad;
             QDataStream(&xpad, QIODevice::WriteOnly) << STUN_MAGIC;
             xpad += xorId;
-            for (int i = 0; i < 16; i++)
+            for (int i = 0; i < 16; i++) {
                 addr[i] ^= xpad[i];
+            }
         }
         stream << port;
         stream.writeRawData((char *)&addr, sizeof(addr));
@@ -513,8 +521,9 @@ void QXmppStunMessage::setUsername(const QString &username)
 bool QXmppStunMessage::decode(const QByteArray &buffer, const QByteArray &key, QStringList *errors)
 {
     QStringList silent;
-    if (!errors)
+    if (!errors) {
         errors = &silent;
+    }
 
     if (buffer.size() < STUN_HEADER) {
         *errors << QLatin1String("Received a truncated STUN packet");
@@ -553,16 +562,18 @@ bool QXmppStunMessage::decode(const QByteArray &buffer, const QByteArray &key, Q
 
         if (a_type == Priority) {
             // PRIORITY
-            if (a_length != sizeof(m_priority))
+            if (a_length != sizeof(m_priority)) {
                 return false;
+            }
             stream >> m_priority;
             m_attributes << Priority;
 
         } else if (a_type == ErrorCode) {
 
             // ERROR-CODE
-            if (a_length < 4)
+            if (a_length < 4) {
                 return false;
+            }
             quint16 reserved;
             quint8 errorCodeHigh, errorCodeLow;
             stream >> reserved;
@@ -576,15 +587,17 @@ bool QXmppStunMessage::decode(const QByteArray &buffer, const QByteArray &key, Q
         } else if (a_type == UseCandidate) {
 
             // USE-CANDIDATE
-            if (a_length != 0)
+            if (a_length != 0) {
                 return false;
+            }
             useCandidate = true;
 
         } else if (a_type == ChannelNumber) {
 
             // CHANNEL-NUMBER
-            if (a_length != 4)
+            if (a_length != 4) {
                 return false;
+            }
             stream >> m_channelNumber;
             stream.skipRawData(2);
             m_attributes << ChannelNumber;
@@ -599,8 +612,9 @@ bool QXmppStunMessage::decode(const QByteArray &buffer, const QByteArray &key, Q
         } else if (a_type == Lifetime) {
 
             // LIFETIME
-            if (a_length != sizeof(m_lifetime))
+            if (a_length != sizeof(m_lifetime)) {
                 return false;
+            }
             stream >> m_lifetime;
             m_attributes << Lifetime;
 
@@ -622,8 +636,9 @@ bool QXmppStunMessage::decode(const QByteArray &buffer, const QByteArray &key, Q
         } else if (a_type == RequestedTransport) {
 
             // REQUESTED-TRANSPORT
-            if (a_length != 4)
+            if (a_length != 4) {
                 return false;
+            }
             stream >> m_requestedTransport;
             stream.skipRawData(3);
             m_attributes << RequestedTransport;
@@ -631,8 +646,9 @@ bool QXmppStunMessage::decode(const QByteArray &buffer, const QByteArray &key, Q
         } else if (a_type == ReservationToken) {
 
             // RESERVATION-TOKEN
-            if (a_length != 8)
+            if (a_length != 8) {
                 return false;
+            }
             m_reservationToken.resize(a_length);
             stream.readRawData(m_reservationToken.data(), m_reservationToken.size());
             m_attributes << ReservationToken;
@@ -664,8 +680,9 @@ bool QXmppStunMessage::decode(const QByteArray &buffer, const QByteArray &key, Q
         } else if (a_type == ChangeRequest) {
 
             // CHANGE-REQUEST
-            if (a_length != sizeof(m_changeRequest))
+            if (a_length != sizeof(m_changeRequest)) {
                 return false;
+            }
             stream >> m_changeRequest;
             m_attributes << ChangeRequest;
 
@@ -720,8 +737,9 @@ bool QXmppStunMessage::decode(const QByteArray &buffer, const QByteArray &key, Q
         } else if (a_type == MessageIntegrity) {
 
             // MESSAGE-INTEGRITY
-            if (a_length != 20)
+            if (a_length != 20) {
                 return false;
+            }
             QByteArray integrity(20, 0);
             stream.readRawData(integrity.data(), integrity.size());
 
@@ -741,8 +759,9 @@ bool QXmppStunMessage::decode(const QByteArray &buffer, const QByteArray &key, Q
         } else if (a_type == Fingerprint) {
 
             // FINGERPRINT
-            if (a_length != 4)
+            if (a_length != 4) {
                 return false;
+            }
             quint32 fingerprint;
             stream >> fingerprint;
 
@@ -761,16 +780,18 @@ bool QXmppStunMessage::decode(const QByteArray &buffer, const QByteArray &key, Q
         } else if (a_type == IceControlling) {
 
             /// ICE-CONTROLLING
-            if (a_length != 8)
+            if (a_length != 8) {
                 return false;
+            }
             iceControlling.resize(a_length);
             stream.readRawData(iceControlling.data(), iceControlling.size());
 
         } else if (a_type == IceControlled) {
 
             /// ICE-CONTROLLED
-            if (a_length != 8)
+            if (a_length != 8) {
                 return false;
+            }
             iceControlled.resize(a_length);
             stream.readRawData(iceControlled.data(), iceControlled.size());
 
@@ -898,8 +919,9 @@ QByteArray QXmppStunMessage::encode(const QByteArray &key, bool addFingerprint)
     }
 
     // REALM
-    if (m_attributes.contains(Realm))
+    if (m_attributes.contains(Realm)) {
         encodeString(stream, Realm, m_realm);
+    }
 
     // REQUESTED-TRANSPORT
     if (m_attributes.contains(RequestedTransport)) {
@@ -918,12 +940,14 @@ QByteArray QXmppStunMessage::encode(const QByteArray &key, bool addFingerprint)
     }
 
     // SOFTWARE
-    if (m_attributes.contains(Software))
+    if (m_attributes.contains(Software)) {
         encodeString(stream, Software, m_software);
+    }
 
     // USERNAME
-    if (m_attributes.contains(Username))
+    if (m_attributes.contains(Username)) {
         encodeString(stream, Username, m_username);
+    }
 
     // ICE-CONTROLLING or ICE-CONTROLLED
     if (!iceControlling.isEmpty()) {
@@ -970,8 +994,9 @@ QByteArray QXmppStunMessage::encode(const QByteArray &key, bool addFingerprint)
 ///
 quint16 QXmppStunMessage::peekType(const QByteArray &buffer, quint32 &cookie, QByteArray &id)
 {
-    if (buffer.size() < STUN_HEADER)
+    if (buffer.size() < STUN_HEADER) {
         return 0;
+    }
 
     // parse STUN header
     QDataStream stream(buffer);
@@ -981,8 +1006,9 @@ quint16 QXmppStunMessage::peekType(const QByteArray &buffer, quint32 &cookie, QB
     stream >> length;
     stream >> cookie;
 
-    if (length != buffer.size() - STUN_HEADER)
+    if (length != buffer.size() - STUN_HEADER) {
         return 0;
+    }
 
     id.resize(STUN_ID_SIZE);
     stream.readRawData(id.data(), id.size());
@@ -1043,59 +1069,80 @@ QString QXmppStunMessage::toString() const
     dumpLines << QStringLiteral(" id %1").arg(QString::fromLatin1(m_id.toHex()));
 
     // attributes
-    if (m_attributes.contains(ChannelNumber))
+    if (m_attributes.contains(ChannelNumber)) {
         dumpLines << QStringLiteral(" * CHANNEL-NUMBER %1").arg(QString::number(m_channelNumber));
-    if (errorCode)
+    }
+    if (errorCode) {
         dumpLines << QStringLiteral(" * ERROR-CODE %1 %2")
                          .arg(QString::number(errorCode), errorPhrase);
-    if (m_attributes.contains(Lifetime))
+    }
+    if (m_attributes.contains(Lifetime)) {
         dumpLines << QStringLiteral(" * LIFETIME %1").arg(QString::number(m_lifetime));
-    if (m_attributes.contains(Nonce))
+    }
+    if (m_attributes.contains(Nonce)) {
         dumpLines << QStringLiteral(" * NONCE %1").arg(QString::fromLatin1(m_nonce));
-    if (m_attributes.contains(Realm))
+    }
+    if (m_attributes.contains(Realm)) {
         dumpLines << QStringLiteral(" * REALM %1").arg(m_realm);
-    if (m_attributes.contains(RequestedTransport))
+    }
+    if (m_attributes.contains(RequestedTransport)) {
         dumpLines << QStringLiteral(" * REQUESTED-TRANSPORT 0x%1").arg(QString::number(m_requestedTransport, 16));
-    if (m_attributes.contains(ReservationToken))
+    }
+    if (m_attributes.contains(ReservationToken)) {
         dumpLines << QStringLiteral(" * RESERVATION-TOKEN %1").arg(QString::fromLatin1(m_reservationToken.toHex()));
-    if (m_attributes.contains(Software))
+    }
+    if (m_attributes.contains(Software)) {
         dumpLines << QStringLiteral(" * SOFTWARE %1").arg(m_software);
-    if (m_attributes.contains(Username))
+    }
+    if (m_attributes.contains(Username)) {
         dumpLines << QStringLiteral(" * USERNAME %1").arg(m_username);
-    if (mappedPort)
+    }
+    if (mappedPort) {
         dumpLines << QStringLiteral(" * MAPPED-ADDRESS %1 %2")
                          .arg(mappedHost.toString(), QString::number(mappedPort));
-    if (m_attributes.contains(ChangeRequest))
+    }
+    if (m_attributes.contains(ChangeRequest)) {
         dumpLines << QStringLiteral(" * CHANGE-REQUEST %1")
                          .arg(QString::number(m_changeRequest));
-    if (sourcePort)
+    }
+    if (sourcePort) {
         dumpLines << QStringLiteral(" * SOURCE-ADDRESS %1 %2")
                          .arg(sourceHost.toString(), QString::number(sourcePort));
-    if (changedPort)
+    }
+    if (changedPort) {
         dumpLines << QStringLiteral(" * CHANGED-ADDRESS %1 %2")
                          .arg(changedHost.toString(), QString::number(changedPort));
-    if (otherPort)
+    }
+    if (otherPort) {
         dumpLines << QStringLiteral(" * OTHER-ADDRESS %1 %2")
                          .arg(otherHost.toString(), QString::number(otherPort));
-    if (xorMappedPort)
+    }
+    if (xorMappedPort) {
         dumpLines << QStringLiteral(" * XOR-MAPPED-ADDRESS %1 %2")
                          .arg(xorMappedHost.toString(), QString::number(xorMappedPort));
-    if (xorPeerPort)
+    }
+    if (xorPeerPort) {
         dumpLines << QStringLiteral(" * XOR-PEER-ADDRESS %1 %2")
                          .arg(xorPeerHost.toString(), QString::number(xorPeerPort));
-    if (xorRelayedPort)
+    }
+    if (xorRelayedPort) {
         dumpLines << QStringLiteral(" * XOR-RELAYED-ADDRESS %1 %2")
                          .arg(xorRelayedHost.toString(), QString::number(xorRelayedPort));
-    if (m_attributes.contains(Priority))
+    }
+    if (m_attributes.contains(Priority)) {
         dumpLines << QStringLiteral(" * PRIORITY %1").arg(QString::number(m_priority));
-    if (!iceControlling.isEmpty())
+    }
+    if (!iceControlling.isEmpty()) {
         dumpLines << QStringLiteral(" * ICE-CONTROLLING %1")
                          .arg(QString::fromLatin1(iceControlling.toHex()));
-    if (!iceControlled.isEmpty())
+    }
+    if (!iceControlled.isEmpty()) {
         dumpLines << QStringLiteral(" * ICE-CONTROLLED %1")
                          .arg(QString::fromLatin1(iceControlled.toHex()));
-    if (useCandidate)
+    }
+    if (useCandidate) {
         dumpLines << QStringLiteral(" * USE-CANDIDATE");
+    }
 
     return dumpLines.join("\n");
 }
@@ -1210,8 +1257,9 @@ QXmppTurnAllocation::QXmppTurnAllocation(QObject *parent)
 ///
 QXmppTurnAllocation::~QXmppTurnAllocation()
 {
-    if (m_state == ConnectedState)
+    if (m_state == ConnectedState) {
         disconnectFromHost();
+    }
 }
 
 ///
@@ -1219,8 +1267,9 @@ QXmppTurnAllocation::~QXmppTurnAllocation()
 ///
 void QXmppTurnAllocation::connectToHost()
 {
-    if (m_state != UnconnectedState)
+    if (m_state != UnconnectedState) {
         return;
+    }
 
     // start listening for UDP
     if (socket->state() == QAbstractSocket::UnconnectedState) {
@@ -1434,8 +1483,9 @@ QXmppTurnAllocation::AllocationState QXmppTurnAllocation::state() const
 
 void QXmppTurnAllocation::setState(AllocationState state)
 {
-    if (state == m_state)
+    if (state == m_state) {
         return;
+    }
     m_state = state;
     if (m_state == ConnectedState) {
         emit connected();
@@ -1448,8 +1498,9 @@ void QXmppTurnAllocation::setState(AllocationState state)
 void QXmppTurnAllocation::transactionFinished()
 {
     auto *transaction = qobject_cast<QXmppStunTransaction *>(sender());
-    if (!transaction || !m_transactions.removeAll(transaction))
+    if (!transaction || !m_transactions.removeAll(transaction)) {
         return;
+    }
     transaction->deleteLater();
 
     // handle authentication
@@ -1507,8 +1558,9 @@ void QXmppTurnAllocation::transactionFinished()
 
             // remove channel
             m_channels.remove(transaction->request().channelNumber());
-            if (m_channels.isEmpty())
+            if (m_channels.isEmpty()) {
                 m_channelTimer->stop();
+            }
             return;
         }
 
@@ -1533,8 +1585,9 @@ void QXmppTurnAllocation::transactionFinished()
 
 qint64 QXmppTurnAllocation::writeDatagram(const QByteArray &data, const QHostAddress &host, quint16 port)
 {
-    if (m_state != ConnectedState)
+    if (m_state != ConnectedState) {
         return -1;
+    }
 
     const Address addr = qMakePair(host, port);
     quint16 channel = m_channels.key(addr);
@@ -1556,8 +1609,9 @@ qint64 QXmppTurnAllocation::writeDatagram(const QByteArray &data, const QHostAdd
         m_transactions << new QXmppStunTransaction(request, this);
 
         // schedule refresh
-        if (!m_channelTimer->isActive())
+        if (!m_channelTimer->isActive()) {
             m_channelTimer->start();
+        }
     }
 
     // send data
@@ -1567,10 +1621,11 @@ qint64 QXmppTurnAllocation::writeDatagram(const QByteArray &data, const QHostAdd
     stream << channel;
     stream << quint16(data.size());
     stream.writeRawData(data.data(), data.size());
-    if (socket->writeDatagram(channelData, m_turnHost, m_turnPort) == channelData.size())
+    if (socket->writeDatagram(channelData, m_turnHost, m_turnPort) == channelData.size()) {
         return data.size();
-    else
+    } else {
         return -1;
+    }
 }
 
 void QXmppTurnAllocation::writeStun(const QXmppStunMessage &message)
@@ -1636,8 +1691,9 @@ void QXmppUdpTransport::readyRead()
 qint64 QXmppUdpTransport::writeDatagram(const QByteArray &data, const QHostAddress &host, quint16 port)
 {
     QHostAddress remoteHost = host;
-    if (isIPv6LinkLocalAddress(host))
+    if (isIPv6LinkLocalAddress(host)) {
         remoteHost.setScopeId(m_socket->localAddress().scopeId());
+    }
     return m_socket->writeDatagram(data, remoteHost, port);
 }
 /// \endcond
@@ -1706,12 +1762,14 @@ QString CandidatePair::toString() const
 {
     const QXmppJingleCandidate candidate = transport->localCandidate(m_component);
     QString str = QStringLiteral("%1 port %2").arg(remote.host().toString(), QString::number(remote.port()));
-    if (candidate.type() == QXmppJingleCandidate::HostType)
+    if (candidate.type() == QXmppJingleCandidate::HostType) {
         str += QStringLiteral(" (local %1 port %2)").arg(candidate.host().toString(), QString::number(candidate.port()));
-    else
+    } else {
         str += QStringLiteral(" (relayed)");
-    if (!reflexive.host().isNull() && reflexive.port())
+    }
+    if (!reflexive.host().isNull() && reflexive.port()) {
         str += QStringLiteral(" (reflexive %1 port %2)").arg(reflexive.host().toString(), QString::number(reflexive.port()));
+    }
     return str;
 }
 
@@ -1797,28 +1855,32 @@ bool QXmppIceComponentPrivate::addRemoteCandidate(const QXmppJingleCandidate &ca
          candidate.type() != QXmppJingleCandidate::ServerReflexiveType) ||
         candidate.protocol() != QStringLiteral("udp") ||
         (candidate.host().protocol() != QAbstractSocket::IPv4Protocol &&
-         candidate.host().protocol() != QAbstractSocket::IPv6Protocol))
+         candidate.host().protocol() != QAbstractSocket::IPv6Protocol)) {
         return false;
+    }
 
     for (const auto &c : std::as_const(remoteCandidates)) {
-        if (c.host() == candidate.host() && c.port() == candidate.port())
+        if (c.host() == candidate.host() && c.port() == candidate.port()) {
             return false;
+        }
     }
     remoteCandidates << candidate;
 
     for (auto *transport : std::as_const(transports)) {
         // only pair compatible addresses
         const QXmppJingleCandidate local = transport->localCandidate(component);
-        if (!isCompatibleAddress(local.host(), candidate.host()))
+        if (!isCompatibleAddress(local.host(), candidate.host())) {
             continue;
+        }
 
         auto *pair = new CandidatePair(component, config->iceControlling, q);
         pair->remote = candidate;
         pair->transport = transport;
         pairs << pair;
 
-        if (!fallbackPair && local.type() == QXmppJingleCandidate::HostType)
+        if (!fallbackPair && local.type() == QXmppJingleCandidate::HostType) {
             fallbackPair = pair;
+        }
     }
 
     std::sort(pairs.begin(), pairs.end(), candidatePairPtrLessThan);
@@ -1829,8 +1891,9 @@ bool QXmppIceComponentPrivate::addRemoteCandidate(const QXmppJingleCandidate &ca
 CandidatePair *QXmppIceComponentPrivate::findPair(QXmppStunTransaction *transaction)
 {
     for (auto *pair : std::as_const(pairs)) {
-        if (pair->transaction == transaction)
+        if (pair->transaction == transaction) {
             return pair;
+        }
     }
     return nullptr;
 }
@@ -1860,8 +1923,9 @@ void QXmppIceComponentPrivate::setSockets(QList<QUdpSocket *> sockets)
     localCandidates.clear();
     qDeleteAll(pairs);
     for (auto *transport : std::as_const(transports)) {
-        if (transport != turnAllocation)
+        if (transport != turnAllocation) {
             delete transport;
+        }
     }
     transports.clear();
 
@@ -1983,8 +2047,9 @@ int QXmppIceComponent::component() const
 
 void QXmppIceComponent::checkCandidates()
 {
-    if (d->config->remoteUser.isEmpty())
+    if (d->config->remoteUser.isEmpty()) {
         return;
+    }
     debug(QStringLiteral("Checking remote candidates"));
 
     for (auto *pair : std::as_const(d->pairs)) {
@@ -2013,8 +2078,9 @@ void QXmppIceComponent::close()
 ///
 void QXmppIceComponent::connectToHost()
 {
-    if (d->activePair)
+    if (d->activePair) {
         return;
+    }
 
     checkCandidates();
     d->timer->start();
@@ -2039,8 +2105,9 @@ QList<QXmppJingleCandidate> QXmppIceComponent::localCandidates() const
 void QXmppIceComponent::handleDatagram(const QByteArray &buffer, const QHostAddress &remoteHost, quint16 remotePort)
 {
     auto *transport = qobject_cast<QXmppIceTransport *>(sender());
-    if (!transport)
+    if (!transport) {
         return;
+    }
 
     // if this is not a STUN message, emit it
     quint32 messageCookie;
@@ -2073,8 +2140,9 @@ void QXmppIceComponent::handleDatagram(const QByteArray &buffer, const QHostAddr
     QString messagePassword;
     if (!stunTransaction) {
         messagePassword = (messageType & 0xFF00) ? d->config->remotePassword : d->config->localPassword;
-        if (messagePassword.isEmpty())
+        if (messagePassword.isEmpty()) {
             return;
+        }
     }
 
     // parse STUN message
@@ -2091,8 +2159,9 @@ void QXmppIceComponent::handleDatagram(const QByteArray &buffer, const QHostAddr
 #endif
 
     // we only want binding requests and responses
-    if (message.messageMethod() != QXmppStunMessage::Binding)
+    if (message.messageMethod() != QXmppStunMessage::Binding) {
         return;
+    }
 
     // STUN checks
     if (stunTransaction) {
@@ -2165,16 +2234,18 @@ void QXmppIceComponent::handleDatagram(const QByteArray &buffer, const QHostAddr
         case CandidatePair::WaitingState:
         case CandidatePair::FailedState:
             // send a triggered connectivity test
-            if (!d->config->remoteUser.isEmpty())
+            if (!d->config->remoteUser.isEmpty()) {
                 d->performCheck(pair, pair->nominating || d->config->iceControlling || message.useCandidate);
+            }
             break;
         case CandidatePair::InProgressState:
             // FIXME: force retransmit now
             pair->nominating = pair->nominating || message.useCandidate;
             break;
         case CandidatePair::SucceededState:
-            if (message.useCandidate)
+            if (message.useCandidate) {
                 pair->nominated = true;
+            }
             break;
         }
 
@@ -2187,8 +2258,9 @@ void QXmppIceComponent::handleDatagram(const QByteArray &buffer, const QHostAddr
                 break;
             }
         }
-        if (!pair)
+        if (!pair) {
             return;
+        }
 
         // check remote host and port
         if (remoteHost != pair->remote.host() || remotePort != pair->remote.port()) {
@@ -2209,8 +2281,9 @@ void QXmppIceComponent::handleDatagram(const QByteArray &buffer, const QHostAddr
             info(QStringLiteral("ICE pair selected %1 (priority: %2)").arg(pair->toString(), QString::number(pair->priority())));
             const bool wasConnected = (d->activePair != nullptr);
             d->activePair = pair;
-            if (!wasConnected)
+            if (!wasConnected) {
                 emit connected();
+            }
         }
     }
 }
@@ -2267,8 +2340,9 @@ void QXmppIceComponent::transactionFinished()
             for (const auto &candidate : std::as_const(d->localCandidates)) {
                 if (candidate.host() == reflexiveHost &&
                     candidate.port() == reflexivePort &&
-                    candidate.type() == QXmppJingleCandidate::ServerReflexiveType)
+                    candidate.type() == QXmppJingleCandidate::ServerReflexiveType) {
                     return;
+                }
             }
 
             // add the new local candidate
@@ -2335,21 +2409,24 @@ QList<QHostAddress> QXmppIceComponent::discoverAddresses()
     const auto interfaces = QNetworkInterface::allInterfaces();
     for (const auto &interface : interfaces) {
         if (!(interface.flags() & QNetworkInterface::IsRunning) ||
-            interface.flags() & QNetworkInterface::IsLoopBack)
+            interface.flags() & QNetworkInterface::IsLoopBack) {
             continue;
+        }
 
         const auto addressEntries = interface.addressEntries();
         for (const auto &entry : addressEntries) {
             QHostAddress ip = entry.ip();
             if ((ip.protocol() != QAbstractSocket::IPv4Protocol &&
                  ip.protocol() != QAbstractSocket::IPv6Protocol) ||
-                entry.netmask().isNull())
+                entry.netmask().isNull()) {
                 continue;
+            }
 
             // FIXME: for some reason we can have loopback addresses
             // even if the interface does not have the loopback flag
-            if (isLoopbackAddress(ip))
+            if (isLoopbackAddress(ip)) {
                 continue;
+            }
 
             // FIXME: for now skip IPv6 link-local addresses, seems to upset
             // clients such as empathy
@@ -2376,30 +2453,35 @@ QList<QHostAddress> QXmppIceComponent::discoverAddresses()
 QList<QUdpSocket *> QXmppIceComponent::reservePorts(const QList<QHostAddress> &addresses, int count, QObject *parent)
 {
     QList<QUdpSocket *> sockets;
-    if (addresses.isEmpty() || !count)
+    if (addresses.isEmpty() || !count) {
         return sockets;
+    }
 
     const int expectedSize = addresses.size() * count;
     quint16 port = 49152;
     while (sockets.size() != expectedSize) {
         // reserve first port (even number)
-        if (port % 2)
+        if (port % 2) {
             port++;
+        }
         QList<QUdpSocket *> socketChunk;
         while (socketChunk.isEmpty() && port <= 65536 - count) {
             socketChunk = reservePort(addresses, port, parent);
-            if (socketChunk.isEmpty())
+            if (socketChunk.isEmpty()) {
                 port += 2;
+            }
         }
-        if (socketChunk.isEmpty())
+        if (socketChunk.isEmpty()) {
             return sockets;
+        }
 
         // reserve other ports
         sockets << socketChunk;
         for (int i = 1; i < count; ++i) {
             socketChunk = reservePort(addresses, ++port, parent);
-            if (socketChunk.isEmpty())
+            if (socketChunk.isEmpty()) {
                 break;
+            }
             sockets << socketChunk;
         }
 
@@ -2420,20 +2502,22 @@ QList<QUdpSocket *> QXmppIceComponent::reservePorts(const QList<QHostAddress> &a
 qint64 QXmppIceComponent::sendDatagram(const QByteArray &datagram)
 {
     CandidatePair *pair = d->activePair ? d->activePair : d->fallbackPair;
-    if (!pair)
+    if (!pair) {
         return -1;
+    }
     return pair->transport->writeDatagram(datagram, pair->remote.host(), pair->remote.port());
 }
 
 void QXmppIceComponent::updateGatheringState()
 {
     QXmppIceConnection::GatheringState newGatheringState;
-    if (d->transports.isEmpty())
+    if (d->transports.isEmpty()) {
         newGatheringState = QXmppIceConnection::NewGatheringState;
-    else if (!d->stunTransactions.isEmpty() || d->turnAllocation->state() == QXmppTurnAllocation::ConnectingState)
+    } else if (!d->stunTransactions.isEmpty() || d->turnAllocation->state() == QXmppTurnAllocation::ConnectingState) {
         newGatheringState = QXmppIceConnection::BusyGatheringState;
-    else
+    } else {
         newGatheringState = QXmppIceConnection::CompleteGatheringState;
+    }
 
     if (newGatheringState != d->gatheringState) {
         d->gatheringState = newGatheringState;
@@ -2572,8 +2656,9 @@ bool QXmppIceConnection::bind(const QList<QHostAddress> &addresses)
 {
     // reserve ports
     QList<QUdpSocket *> sockets = QXmppIceComponent::reservePorts(addresses, d->components.size());
-    if (sockets.isEmpty() && !addresses.isEmpty())
+    if (sockets.isEmpty() && !addresses.isEmpty()) {
         return false;
+    }
 
     // assign sockets
     QList<int> keys = d->components.keys();
@@ -2603,8 +2688,9 @@ void QXmppIceConnection::close()
 ///
 void QXmppIceConnection::connectToHost()
 {
-    if (isConnected() || d->connectTimer->isActive())
+    if (isConnected() || d->connectTimer->isActive()) {
         return;
+    }
 
     for (auto *socket : std::as_const(d->components)) {
         socket->connectToHost();
@@ -2618,8 +2704,9 @@ void QXmppIceConnection::connectToHost()
 bool QXmppIceConnection::isConnected() const
 {
     for (auto *socket : std::as_const(d->components)) {
-        if (!socket->isConnected())
+        if (!socket->isConnected()) {
             return false;
+        }
     }
     return true;
 }
@@ -2769,8 +2856,9 @@ void QXmppIceConnection::setTurnPassword(const QString &password)
 void QXmppIceConnection::slotConnected()
 {
     for (auto *socket : std::as_const(d->components)) {
-        if (!socket->isConnected())
+        if (!socket->isConnected()) {
             return;
+        }
     }
     info(QStringLiteral("ICE negotiation completed"));
     d->connectTimer->stop();
@@ -2783,17 +2871,20 @@ void QXmppIceConnection::slotGatheringStateChanged()
     bool allComplete = true;
     bool allNew = true;
     for (auto *socket : std::as_const(d->components)) {
-        if (socket->d->gatheringState != CompleteGatheringState)
+        if (socket->d->gatheringState != CompleteGatheringState) {
             allComplete = false;
-        if (socket->d->gatheringState != NewGatheringState)
+        }
+        if (socket->d->gatheringState != NewGatheringState) {
             allNew = false;
+        }
     }
-    if (allNew)
+    if (allNew) {
         newGatheringState = NewGatheringState;
-    else if (allComplete)
+    } else if (allComplete) {
         newGatheringState = CompleteGatheringState;
-    else
+    } else {
         newGatheringState = BusyGatheringState;
+    }
 
     if (newGatheringState != d->gatheringState) {
         info(QStringLiteral("ICE gathering state changed from '%1' to '%2'").arg(gathering_states[d->gatheringState], gathering_states[newGatheringState]));
diff --git a/src/base/QXmppUtils.cpp b/src/base/QXmppUtils.cpp
index 462d19fb..7ae74ba3 100644
--- a/src/base/QXmppUtils.cpp
+++ b/src/base/QXmppUtils.cpp
@@ -123,19 +123,22 @@ int QXmppUtils::timezoneOffsetFromString(const QString &str)
     static const QRegularExpression timezoneRegex(QStringLiteral("(Z|([+-])([0-9]{2}):([0-9]{2}))"));
 
     const auto match = timezoneRegex.match(str);
-    if (!match.hasMatch())
+    if (!match.hasMatch()) {
         return 0;
+    }
 
     // No offset from UTC
-    if (match.captured(1) == QChar(u'Z'))
+    if (match.captured(1) == QChar(u'Z')) {
         return 0;
+    }
 
     // Calculate offset
     const int offset = match.captured(3).toInt() * 3600 +
         match.captured(4).toInt() * 60;
 
-    if (match.captured(2) == QChar(u'-'))
+    if (match.captured(2) == QChar(u'-')) {
         return -offset;
+    }
     return offset;
 }
 
@@ -145,8 +148,9 @@ int QXmppUtils::timezoneOffsetFromString(const QString &str)
 ///
 QString QXmppUtils::timezoneOffsetToString(int secs)
 {
-    if (!secs)
+    if (!secs) {
         return QStringLiteral("Z");
+    }
 
     const QTime tzoTime = QTime(0, 0, 0).addSecs(qAbs(secs));
     return (secs < 0 ? QStringLiteral("-") : QStringLiteral("+")) + tzoTime.toString(QStringLiteral("hh:mm"));
@@ -164,8 +168,9 @@ QString QXmppUtils::jidToDomain(const QString &jid)
 QString QXmppUtils::jidToResource(const QString &jid)
 {
     const int pos = jid.indexOf(QChar('/'));
-    if (pos < 0)
+    if (pos < 0) {
         return QString();
+    }
     return jid.mid(pos + 1);
 }
 
@@ -174,8 +179,9 @@ QString QXmppUtils::jidToResource(const QString &jid)
 QString QXmppUtils::jidToUser(const QString &jid)
 {
     const int pos = jid.indexOf(QChar('@'));
-    if (pos < 0)
+    if (pos < 0) {
         return QString();
+    }
     return jid.left(pos);
 }
 
@@ -184,8 +190,9 @@ QString QXmppUtils::jidToUser(const QString &jid)
 QString QXmppUtils::jidToBareJid(const QString &jid)
 {
     const int pos = jid.indexOf(QChar('/'));
-    if (pos < 0)
+    if (pos < 0) {
         return jid;
+    }
     return jid.left(pos);
 }
 
@@ -194,8 +201,9 @@ QString QXmppUtils::jidToBareJid(const QString &jid)
 quint32 QXmppUtils::generateCrc32(const QByteArray &in)
 {
     quint32 result = 0xffffffff;
-    for (char n : in)
+    for (char n : in) {
         result = (result >> 8) ^ (crctable[(result & 0xff) ^ (quint8)n]);
+    }
     return result ^= 0xffffffff;
 }
 
@@ -207,12 +215,14 @@ static QByteArray generateHmac(QCryptographicHash::Algorithm algorithm, const QB
     QByteArray kpad = key + QByteArray(B - key.size(), 0);
 
     QByteArray ba;
-    for (int i = 0; i < B; ++i)
+    for (int i = 0; i < B; ++i) {
         ba += kpad[i] ^ 0x5c;
+    }
 
     QByteArray tmp;
-    for (int i = 0; i < B; ++i)
+    for (int i = 0; i < B; ++i) {
         tmp += kpad[i] ^ 0x36;
+    }
     hasher.addData(tmp);
     hasher.addData(text);
     ba += hasher.result();
@@ -261,8 +271,9 @@ int QXmppUtils::generateRandomInteger(int N)
 QByteArray QXmppUtils::generateRandomBytes(int length)
 {
     QByteArray bytes(length, 'm');
-    for (int i = 0; i < length; ++i)
+    for (int i = 0; i < length; ++i) {
         bytes[i] = (char)generateRandomInteger(256);
+    }
     return bytes;
 }
 
@@ -297,31 +308,35 @@ QString QXmppUtils::generateStanzaUuid()
 ///
 QString QXmppUtils::generateStanzaHash(int length)
 {
-    if (length == 36)
+    if (length == 36) {
         return QXmppUtils::generateStanzaUuid();
+    }
 
     const QString somechars = QStringLiteral("1234567890abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ");
     const int N = somechars.size();
     QString hashResult;
-    for (int idx = 0; idx < length; ++idx)
+    for (int idx = 0; idx < length; ++idx) {
         hashResult += somechars[generateRandomInteger(N)];
+    }
     return hashResult;
 }
 
 void helperToXmlAddAttribute(QXmlStreamWriter *stream, const QString &name,
                              const QString &value)
 {
-    if (!value.isEmpty())
+    if (!value.isEmpty()) {
         stream->writeAttribute(name, value);
+    }
 }
 
 void helperToXmlAddTextElement(QXmlStreamWriter *stream, const QString &name,
                                const QString &value)
 {
-    if (!value.isEmpty())
+    if (!value.isEmpty()) {
         stream->writeTextElement(name, value);
-    else
+    } else {
         stream->writeEmptyElement(name);
+    }
 }
 
 /// \cond
diff --git a/src/base/QXmppVCardIq.cpp b/src/base/QXmppVCardIq.cpp
index 4abec8ba..fa8e7444 100644
--- a/src/base/QXmppVCardIq.cpp
+++ b/src/base/QXmppVCardIq.cpp
@@ -12,20 +12,21 @@
 
 static QString getImageType(const QByteArray &contents)
 {
-    if (contents.startsWith("\x89PNG\x0d\x0a\x1a\x0a"))
+    if (contents.startsWith("\x89PNG\x0d\x0a\x1a\x0a")) {
         return QStringLiteral("image/png");
-    else if (contents.startsWith("\x8aMNG"))
+    } else if (contents.startsWith("\x8aMNG")) {
         return QStringLiteral("video/x-mng");
-    else if (contents.startsWith("GIF8"))
+    } else if (contents.startsWith("GIF8")) {
         return QStringLiteral("image/gif");
-    else if (contents.startsWith("BM"))
+    } else if (contents.startsWith("BM")) {
         return QStringLiteral("image/bmp");
-    else if (contents.contains("/* XPM */"))
+    } else if (contents.contains("/* XPM */")) {
         return QStringLiteral("image/x-xpm");
-    else if (contents.contains("<?xml") && contents.contains("<svg"))
+    } else if (contents.contains("<?xml") && contents.contains("<svg")) {
         return QStringLiteral("image/svg+xml");
-    else if (contents.startsWith("\xFF\xD8\xFF\xE0"))
+    } else if (contents.startsWith("\xFF\xD8\xFF\xE0")) {
         return QStringLiteral("image/jpeg");
+    }
     return QStringLiteral("image/unknown");
 }
 
@@ -163,14 +164,18 @@ void QXmppVCardAddress::setType(QXmppVCardAddress::Type type)
 /// \cond
 void QXmppVCardAddress::parse(const QDomElement &element)
 {
-    if (!element.firstChildElement(QStringLiteral("HOME")).isNull())
+    if (!element.firstChildElement(QStringLiteral("HOME")).isNull()) {
         d->type |= Home;
-    if (!element.firstChildElement(QStringLiteral("WORK")).isNull())
+    }
+    if (!element.firstChildElement(QStringLiteral("WORK")).isNull()) {
         d->type |= Work;
-    if (!element.firstChildElement(QStringLiteral("POSTAL")).isNull())
+    }
+    if (!element.firstChildElement(QStringLiteral("POSTAL")).isNull()) {
         d->type |= Postal;
-    if (!element.firstChildElement(QStringLiteral("PREF")).isNull())
+    }
+    if (!element.firstChildElement(QStringLiteral("PREF")).isNull()) {
         d->type |= Preferred;
+    }
 
     d->country = element.firstChildElement(QStringLiteral("CTRY")).text();
     d->locality = element.firstChildElement(QStringLiteral("LOCALITY")).text();
@@ -182,25 +187,34 @@ void QXmppVCardAddress::parse(const QDomElement &element)
 void QXmppVCardAddress::toXml(QXmlStreamWriter *writer) const
 {
     writer->writeStartElement(QStringLiteral("ADR"));
-    if (d->type & Home)
+    if (d->type & Home) {
         writer->writeEmptyElement(QStringLiteral("HOME"));
-    if (d->type & Work)
+    }
+    if (d->type & Work) {
         writer->writeEmptyElement(QStringLiteral("WORK"));
-    if (d->type & Postal)
+    }
+    if (d->type & Postal) {
         writer->writeEmptyElement(QStringLiteral("POSTAL"));
-    if (d->type & Preferred)
+    }
+    if (d->type & Preferred) {
         writer->writeEmptyElement(QStringLiteral("PREF"));
+    }
 
-    if (!d->country.isEmpty())
+    if (!d->country.isEmpty()) {
         writer->writeTextElement(QStringLiteral("CTRY"), d->country);
-    if (!d->locality.isEmpty())
+    }
+    if (!d->locality.isEmpty()) {
         writer->writeTextElement(QStringLiteral("LOCALITY"), d->locality);
-    if (!d->postcode.isEmpty())
+    }
+    if (!d->postcode.isEmpty()) {
         writer->writeTextElement(QStringLiteral("PCODE"), d->postcode);
-    if (!d->region.isEmpty())
+    }
+    if (!d->region.isEmpty()) {
         writer->writeTextElement(QStringLiteral("REGION"), d->region);
-    if (!d->street.isEmpty())
+    }
+    if (!d->street.isEmpty()) {
         writer->writeTextElement(QStringLiteral("STREET"), d->street);
+    }
 
     writer->writeEndElement();
 }
@@ -286,32 +300,42 @@ void QXmppVCardEmail::setType(QXmppVCardEmail::Type type)
 /// \cond
 void QXmppVCardEmail::parse(const QDomElement &element)
 {
-    if (!element.firstChildElement(QStringLiteral("HOME")).isNull())
+    if (!element.firstChildElement(QStringLiteral("HOME")).isNull()) {
         d->type |= Home;
-    if (!element.firstChildElement(QStringLiteral("WORK")).isNull())
+    }
+    if (!element.firstChildElement(QStringLiteral("WORK")).isNull()) {
         d->type |= Work;
-    if (!element.firstChildElement(QStringLiteral("INTERNET")).isNull())
+    }
+    if (!element.firstChildElement(QStringLiteral("INTERNET")).isNull()) {
         d->type |= Internet;
-    if (!element.firstChildElement(QStringLiteral("PREF")).isNull())
+    }
+    if (!element.firstChildElement(QStringLiteral("PREF")).isNull()) {
         d->type |= Preferred;
-    if (!element.firstChildElement(QStringLiteral("X400")).isNull())
+    }
+    if (!element.firstChildElement(QStringLiteral("X400")).isNull()) {
         d->type |= X400;
+    }
     d->address = element.firstChildElement(QStringLiteral("USERID")).text();
 }
 
 void QXmppVCardEmail::toXml(QXmlStreamWriter *writer) const
 {
     writer->writeStartElement(QStringLiteral("EMAIL"));
-    if (d->type & Home)
+    if (d->type & Home) {
         writer->writeEmptyElement(QStringLiteral("HOME"));
-    if (d->type & Work)
+    }
+    if (d->type & Work) {
         writer->writeEmptyElement(QStringLiteral("WORK"));
-    if (d->type & Internet)
+    }
+    if (d->type & Internet) {
         writer->writeEmptyElement(QStringLiteral("INTERNET"));
-    if (d->type & Preferred)
+    }
+    if (d->type & Preferred) {
         writer->writeEmptyElement(QStringLiteral("PREF"));
-    if (d->type & X400)
+    }
+    if (d->type & X400) {
         writer->writeEmptyElement(QStringLiteral("X400"));
+    }
     writer->writeTextElement(QStringLiteral("USERID"), d->address);
     writer->writeEndElement();
 }
@@ -397,64 +421,90 @@ void QXmppVCardPhone::setType(QXmppVCardPhone::Type type)
 /// \cond
 void QXmppVCardPhone::parse(const QDomElement &element)
 {
-    if (!element.firstChildElement(QStringLiteral("HOME")).isNull())
+    if (!element.firstChildElement(QStringLiteral("HOME")).isNull()) {
         d->type |= Home;
-    if (!element.firstChildElement(QStringLiteral("WORK")).isNull())
+    }
+    if (!element.firstChildElement(QStringLiteral("WORK")).isNull()) {
         d->type |= Work;
-    if (!element.firstChildElement(QStringLiteral("VOICE")).isNull())
+    }
+    if (!element.firstChildElement(QStringLiteral("VOICE")).isNull()) {
         d->type |= Voice;
-    if (!element.firstChildElement(QStringLiteral("FAX")).isNull())
+    }
+    if (!element.firstChildElement(QStringLiteral("FAX")).isNull()) {
         d->type |= Fax;
-    if (!element.firstChildElement(QStringLiteral("PAGER")).isNull())
+    }
+    if (!element.firstChildElement(QStringLiteral("PAGER")).isNull()) {
         d->type |= Pager;
-    if (!element.firstChildElement(QStringLiteral("MSG")).isNull())
+    }
+    if (!element.firstChildElement(QStringLiteral("MSG")).isNull()) {
         d->type |= Messaging;
-    if (!element.firstChildElement(QStringLiteral("CELL")).isNull())
+    }
+    if (!element.firstChildElement(QStringLiteral("CELL")).isNull()) {
         d->type |= Cell;
-    if (!element.firstChildElement(QStringLiteral("VIDEO")).isNull())
+    }
+    if (!element.firstChildElement(QStringLiteral("VIDEO")).isNull()) {
         d->type |= Video;
-    if (!element.firstChildElement(QStringLiteral("BBS")).isNull())
+    }
+    if (!element.firstChildElement(QStringLiteral("BBS")).isNull()) {
         d->type |= BBS;
-    if (!element.firstChildElement(QStringLiteral("MODEM")).isNull())
+    }
+    if (!element.firstChildElement(QStringLiteral("MODEM")).isNull()) {
         d->type |= Modem;
-    if (!element.firstChildElement(QStringLiteral("ISDN")).isNull())
+    }
+    if (!element.firstChildElement(QStringLiteral("ISDN")).isNull()) {
         d->type |= ISDN;
-    if (!element.firstChildElement(QStringLiteral("PCS")).isNull())
+    }
+    if (!element.firstChildElement(QStringLiteral("PCS")).isNull()) {
         d->type |= PCS;
-    if (!element.firstChildElement(QStringLiteral("PREF")).isNull())
+    }
+    if (!element.firstChildElement(QStringLiteral("PREF")).isNull()) {
         d->type |= Preferred;
+    }
     d->number = element.firstChildElement(QStringLiteral("NUMBER")).text();
 }
 
 void QXmppVCardPhone::toXml(QXmlStreamWriter *writer) const
 {
     writer->writeStartElement(QStringLiteral("TEL"));
-    if (d->type & Home)
+    if (d->type & Home) {
         writer->writeEmptyElement(QStringLiteral("HOME"));
-    if (d->type & Work)
+    }
+    if (d->type & Work) {
         writer->writeEmptyElement(QStringLiteral("WORK"));
-    if (d->type & Voice)
+    }
+    if (d->type & Voice) {
         writer->writeEmptyElement(QStringLiteral("VOICE"));
-    if (d->type & Fax)
+    }
+    if (d->type & Fax) {
         writer->writeEmptyElement(QStringLiteral("FAX"));
-    if (d->type & Pager)
+    }
+    if (d->type & Pager) {
         writer->writeEmptyElement(QStringLiteral("PAGER"));
-    if (d->type & Messaging)
+    }
+    if (d->type & Messaging) {
         writer->writeEmptyElement(QStringLiteral("MSG"));
-    if (d->type & Cell)
+    }
+    if (d->type & Cell) {
         writer->writeEmptyElement(QStringLiteral("CELL"));
-    if (d->type & Video)
+    }
+    if (d->type & Video) {
         writer->writeEmptyElement(QStringLiteral("VIDEO"));
-    if (d->type & BBS)
+    }
+    if (d->type & BBS) {
         writer->writeEmptyElement(QStringLiteral("BBS"));
-    if (d->type & Modem)
+    }
+    if (d->type & Modem) {
         writer->writeEmptyElement(QStringLiteral("MODEM"));
-    if (d->type & ISDN)
+    }
+    if (d->type & ISDN) {
         writer->writeEmptyElement(QStringLiteral("ISDN"));
-    if (d->type & PCS)
+    }
+    if (d->type & PCS) {
         writer->writeEmptyElement(QStringLiteral("PCS"));
-    if (d->type & Preferred)
+    }
+    if (d->type & Preferred) {
         writer->writeEmptyElement(QStringLiteral("PREF"));
+    }
     writer->writeTextElement(QStringLiteral("NUMBER"), d->number);
     writer->writeEndElement();
 }
@@ -710,10 +760,11 @@ void QXmppVCardIq::setDescription(const QString &description)
 
 QString QXmppVCardIq::email() const
 {
-    if (d->emails.isEmpty())
+    if (d->emails.isEmpty()) {
         return QString();
-    else
+    } else {
         return d->emails.first().address();
+    }
 }
 
 /// Sets the email address.
@@ -976,44 +1027,56 @@ void QXmppVCardIq::toXmlElementFromChild(QXmlStreamWriter *writer) const
 {
     writer->writeStartElement(QStringLiteral("vCard"));
     writer->writeDefaultNamespace(ns_vcard);
-    for (const QXmppVCardAddress &address : d->addresses)
+    for (const QXmppVCardAddress &address : d->addresses) {
         address.toXml(writer);
-    if (d->birthday.isValid())
+    }
+    if (d->birthday.isValid()) {
         helperToXmlAddTextElement(writer, QStringLiteral("BDAY"), d->birthday.toString(QStringLiteral("yyyy-MM-dd")));
-    if (!d->description.isEmpty())
+    }
+    if (!d->description.isEmpty()) {
         helperToXmlAddTextElement(writer, QStringLiteral("DESC"), d->description);
-    for (const QXmppVCardEmail &email : d->emails)
+    }
+    for (const QXmppVCardEmail &email : d->emails) {
         email.toXml(writer);
-    if (!d->fullName.isEmpty())
+    }
+    if (!d->fullName.isEmpty()) {
         helperToXmlAddTextElement(writer, QStringLiteral("FN"), d->fullName);
-    if (!d->nickName.isEmpty())
+    }
+    if (!d->nickName.isEmpty()) {
         helperToXmlAddTextElement(writer, QStringLiteral("NICKNAME"), d->nickName);
+    }
     if (!d->firstName.isEmpty() ||
         !d->lastName.isEmpty() ||
         !d->middleName.isEmpty()) {
         writer->writeStartElement("N");
-        if (!d->firstName.isEmpty())
+        if (!d->firstName.isEmpty()) {
             helperToXmlAddTextElement(writer, QStringLiteral("GIVEN"), d->firstName);
-        if (!d->lastName.isEmpty())
+        }
+        if (!d->lastName.isEmpty()) {
             helperToXmlAddTextElement(writer, QStringLiteral("FAMILY"), d->lastName);
-        if (!d->middleName.isEmpty())
+        }
+        if (!d->middleName.isEmpty()) {
             helperToXmlAddTextElement(writer, QStringLiteral("MIDDLE"), d->middleName);
+        }
         writer->writeEndElement();
     }
 
-    for (const QXmppVCardPhone &phone : d->phones)
+    for (const QXmppVCardPhone &phone : d->phones) {
         phone.toXml(writer);
+    }
     if (!photo().isEmpty()) {
         writer->writeStartElement(QStringLiteral("PHOTO"));
         QString photoType = d->photoType;
-        if (photoType.isEmpty())
+        if (photoType.isEmpty()) {
             photoType = getImageType(d->photo);
+        }
         helperToXmlAddTextElement(writer, QStringLiteral("TYPE"), photoType);
         helperToXmlAddTextElement(writer, QStringLiteral("BINVAL"), d->photo.toBase64());
         writer->writeEndElement();
     }
-    if (!d->url.isEmpty())
+    if (!d->url.isEmpty()) {
         helperToXmlAddTextElement(writer, QStringLiteral("URL"), d->url);
+    }
 
     d->organization.toXml(writer);
 
diff --git a/src/base/QXmppVersionIq.cpp b/src/base/QXmppVersionIq.cpp
index 80cae9e0..039ba48a 100644
--- a/src/base/QXmppVersionIq.cpp
+++ b/src/base/QXmppVersionIq.cpp
@@ -80,14 +80,17 @@ void QXmppVersionIq::toXmlElementFromChild(QXmlStreamWriter *writer) const
     writer->writeStartElement(QStringLiteral("query"));
     writer->writeDefaultNamespace(ns_version);
 
-    if (!m_name.isEmpty())
+    if (!m_name.isEmpty()) {
         helperToXmlAddTextElement(writer, QStringLiteral("name"), m_name);
+    }
 
-    if (!m_os.isEmpty())
+    if (!m_os.isEmpty()) {
         helperToXmlAddTextElement(writer, QStringLiteral("os"), m_os);
+    }
 
-    if (!m_version.isEmpty())
+    if (!m_version.isEmpty()) {
         helperToXmlAddTextElement(writer, QStringLiteral("version"), m_version);
+    }
 
     writer->writeEndElement();
 }
author	Linus Jahn <lnj@kaidan.im>	2022-09-05 20:37:05 +0200
committer	Linus Jahn <lnj@kaidan.im>	2022-09-06 00:46:56 +0200
commit	5f813f8a4bbe1e075daad7b3933829044befffb4 (patch)
tree	20102aa665b03cfb6dfe0c6ece94938320b6430e /src/base
parent	4c60b13e0b8011e4e0b093a690e939f3b23e2436 (diff)
download	qxmpp-5f813f8a4bbe1e075daad7b3933829044befffb4.tar.gz