diff --git a/src/activeconnection.cpp b/src/activeconnection.cpp
index 0c81b16..3d7df4c 100644
--- a/src/activeconnection.cpp
+++ b/src/activeconnection.cpp
@@ -1,413 +1,414 @@
 /*
     SPDX-FileCopyrightText: 2011 Ilia Kats <ilia-kats@gmx.net>
     SPDX-FileCopyrightText: 2013 Daniel Nicoletti <dantti12@gmail.com>
     SPDX-FileCopyrightText: 2013 Jan Grulich <jgrulich@redhat.com>
 
     SPDX-License-Identifier: LGPL-2.1-only OR LGPL-3.0-only OR LicenseRef-KDE-Accepted-LGPL
 */
 
 #include "activeconnection.h"
 #include "activeconnection_p.h"
 #include "connection.h"
 #include "device.h"
 #include "nmdebug.h"
 #include "manager.h"
 #include "settings.h"
 
 #include <QDBusObjectPath>
 
 #include "manager_p.h"
 
 NetworkManager::ActiveConnectionPrivate::ActiveConnectionPrivate(const QString &dbusPath, ActiveConnection *q)
 #ifdef NMQT_STATIC
     : iface(NetworkManagerPrivate::DBUS_SERVICE, dbusPath, QDBusConnection::sessionBus())
 #else
     : iface(NetworkManagerPrivate::DBUS_SERVICE, dbusPath, QDBusConnection::systemBus())
 #endif
     , dhcp4Config(nullptr)
     , dhcp6Config(nullptr)
     , state(ActiveConnection::Unknown)
     , q_ptr(q)
 {
     path = dbusPath;
 }
 
 NetworkManager::ActiveConnectionPrivate::~ActiveConnectionPrivate()
 {
 }
 
 NetworkManager::ActiveConnection::State NetworkManager::ActiveConnectionPrivate::convertActiveConnectionState(uint state)
 {
     return (NetworkManager::ActiveConnection::State)state;
 }
 
 NetworkManager::ActiveConnection::Reason NetworkManager::ActiveConnectionPrivate::convertActiveConnectionReason(uint reason)
 {
     return (NetworkManager::ActiveConnection::Reason)reason;
 }
 
 NetworkManager::ActiveConnection::ActiveConnection(const QString &path, QObject *parent)
     : QObject(parent), d_ptr(new ActiveConnectionPrivate(path, this))
 {
     Q_D(ActiveConnection);
 
     // Get all ActiveConnection's at once
     QVariantMap initialProperties = NetworkManagerPrivate::retrieveInitialProperties(d->iface.staticInterfaceName(), path);
     if (!initialProperties.isEmpty()) {
         d->propertiesChanged(initialProperties);
     }
 
 #ifndef NMQT_STATIC
     QDBusConnection::systemBus().connect(NetworkManagerPrivate::DBUS_SERVICE, d->path, NetworkManagerPrivate::FDO_DBUS_PROPERTIES,
                                          QLatin1String("PropertiesChanged"), d, SLOT(dbusPropertiesChanged(QString,QVariantMap,QStringList)));
     QDBusConnection::systemBus().connect(NetworkManagerPrivate::DBUS_SERVICE, d->path, d->iface.staticInterfaceName(),
                                          QLatin1String("StateChanged"), d, SLOT(stateChanged(uint,uint)));
 #endif
 
 #ifdef NMQT_STATIC
     connect(&d->iface, &OrgFreedesktopNetworkManagerConnectionActiveInterface::PropertiesChanged, d, &ActiveConnectionPrivate::propertiesChanged);
     connect(&d->iface, &OrgFreedesktopNetworkManagerConnectionActiveInterface::StateChanged, d, &ActiveConnectionPrivate::stateChanged);
 #endif
 
 #ifndef NMQT_STATIC
     /*
      * Workaround: Re-check connection state before we watch changes in case it gets changed too quickly
      * BUG:352326
      */
     d->recheckProperties();
 #endif
 }
 
 NetworkManager::ActiveConnection::ActiveConnection(ActiveConnectionPrivate &dd, QObject *parent)
     : QObject(parent), d_ptr(&dd)
 {
     Q_D(ActiveConnection);
 
 #ifndef NMQT_STATIC
     QDBusConnection::systemBus().connect(NetworkManagerPrivate::DBUS_SERVICE, d->path, NetworkManagerPrivate::FDO_DBUS_PROPERTIES,
                                          QLatin1String("PropertiesChanged"), d, SLOT(dbusPropertiesChanged(QString,QVariantMap,QStringList)));
     QDBusConnection::systemBus().connect(NetworkManagerPrivate::DBUS_SERVICE, d->path, d->iface.staticInterfaceName(),
                                          QLatin1String("StateChanged"), d, SLOT(stateChanged(uint,uint)));
 #endif
 
 #ifdef NMQT_STATIC
     connect(&d->iface, &OrgFreedesktopNetworkManagerConnectionActiveInterface::PropertiesChanged, d, &ActiveConnectionPrivate::propertiesChanged);
     connect(&d->iface, &OrgFreedesktopNetworkManagerConnectionActiveInterface::StateChanged, d, &ActiveConnectionPrivate::stateChanged);
 #endif
 
 #ifndef NMQT_STATIC
     /*
      * Workaround: Re-check connection state before we watch changes in case it gets changed too quickly
      * BUG:352326
      */
     d->recheckProperties();
 #endif
 }
 
 NetworkManager::ActiveConnection::~ActiveConnection()
 {
     delete d_ptr;
 }
 
 bool NetworkManager::ActiveConnection::isValid() const
 {
     Q_D(const ActiveConnection);
     return !d->connection.isNull();
 }
 
 NetworkManager::Connection::Ptr NetworkManager::ActiveConnection::connection() const
 {
     Q_D(const ActiveConnection);
     return d->connection;
 }
 
 QString NetworkManager::ActiveConnection::path() const
 {
     Q_D(const ActiveConnection);
     return d->path;
 }
 
 bool NetworkManager::ActiveConnection::default4() const
 {
     Q_D(const ActiveConnection);
     return d->default4;
 }
 
 bool NetworkManager::ActiveConnection::default6() const
 {
     Q_D(const ActiveConnection);
     return d->default6;
 }
 
 NetworkManager::Dhcp4Config::Ptr NetworkManager::ActiveConnection::dhcp4Config() const
 {
     Q_D(const ActiveConnection);
     if (!d->dhcp4Config && !d->dhcp4ConfigPath.isNull()) {
         d->dhcp4Config = NetworkManager::Dhcp4Config::Ptr(new Dhcp4Config(d->dhcp4ConfigPath), &QObject::deleteLater);
     }
     return d->dhcp4Config;
 }
 
 NetworkManager::Dhcp6Config::Ptr NetworkManager::ActiveConnection::dhcp6Config() const
 {
     Q_D(const ActiveConnection);
     if (!d->dhcp6Config && !d->dhcp6ConfigPath.isNull()) {
         d->dhcp6Config = NetworkManager::Dhcp6Config::Ptr(new Dhcp6Config(d->dhcp6ConfigPath), &QObject::deleteLater);
     }
     return d->dhcp6Config;
 }
 
 NetworkManager::IpConfig NetworkManager::ActiveConnection::ipV4Config() const
 {
     Q_D(const ActiveConnection);
     if (!d->ipV4Config.isValid() && !d->ipV4ConfigPath.isNull()) {
         d->ipV4Config.setIPv4Path(d->ipV4ConfigPath);
     }
     return d->ipV4Config;
 }
 
 NetworkManager::IpConfig NetworkManager::ActiveConnection::ipV6Config() const
 {
     Q_D(const ActiveConnection);
     if (!d->ipV6Config.isValid() && !d->ipV6ConfigPath.isNull()) {
         d->ipV6Config.setIPv6Path(d->ipV6ConfigPath);
     }
     return d->ipV6Config;
 }
 
 QString NetworkManager::ActiveConnection::id() const
 {
     Q_D(const ActiveConnection);
     return d->id;
 }
 
 NetworkManager::ConnectionSettings::ConnectionType NetworkManager::ActiveConnection::type() const
 {
     Q_D(const ActiveConnection);
     return NetworkManager::ConnectionSettings::typeFromString(d->type);
 }
 
 QString NetworkManager::ActiveConnection::master() const
 {
     Q_D(const ActiveConnection);
     return d->master;
 }
 
 QString NetworkManager::ActiveConnection::specificObject() const
 {
     Q_D(const ActiveConnection);
     return d->specificObject;
 }
 
 NetworkManager::ActiveConnection::State NetworkManager::ActiveConnection::state() const
 {
     Q_D(const ActiveConnection);
     return d->state;
 }
 
 bool NetworkManager::ActiveConnection::vpn() const
 {
     Q_D(const ActiveConnection);
     return d->vpn;
 }
 
 QString NetworkManager::ActiveConnection::uuid() const
 {
     Q_D(const ActiveConnection);
     return d->uuid;
 }
 
 QStringList NetworkManager::ActiveConnection::devices() const
 {
     Q_D(const ActiveConnection);
     return d->devices;
 }
 
 void NetworkManager::ActiveConnectionPrivate::recheckProperties()
 {
     Q_Q(ActiveConnection);
 
     /*
      * Workaround: Re-check connection state before we watch changes in case it gets changed too quickly
      * BUG:352326
      */
     QStringList properties;
     const QDBusObjectPath ip4ConfigObjectPath = iface.ip4Config();
     const QDBusObjectPath ip6ConfigObjectPath = iface.ip6Config();
     const QDBusObjectPath dhcp4ConfigObjectPath = iface.dhcp4Config();
     const QDBusObjectPath dhcp6ConfigObjectPath = iface.dhcp6Config();
 
     if (state != NetworkManager::ActiveConnectionPrivate::convertActiveConnectionState(iface.state())) {
         properties << QLatin1String("State");
     }
 
     if (!ip4ConfigObjectPath.path().isNull() && ip4ConfigObjectPath.path() != ipV4ConfigPath) {
         properties << QLatin1String("Ip4Config");
     }
 
     if (!ip6ConfigObjectPath.path().isNull() && ip6ConfigObjectPath.path() != ipV6ConfigPath) {
         properties << QLatin1String("Ip6Config");
     }
 
     if (!dhcp4ConfigObjectPath.path().isNull() && dhcp4ConfigObjectPath.path() != dhcp4ConfigPath) {
         properties << QLatin1String("Dhcp4Config");
     }
 
     if (!dhcp6ConfigObjectPath.path().isNull() && dhcp6ConfigObjectPath.path() != dhcp6ConfigPath) {
         properties << QLatin1String("Dhcp6Config");
     }
 
-    Q_FOREACH (const QString &property, properties) {
+    for (const QString &property : qAsConst(properties)) {
         QDBusMessage message = QDBusMessage::createMethodCall(NetworkManager::NetworkManagerPrivate::DBUS_SERVICE,
                             NetworkManager::NetworkManagerPrivate::DBUS_DAEMON_PATH,
                             NetworkManager::NetworkManagerPrivate::FDO_DBUS_PROPERTIES,
                             QLatin1String("Get"));
         message << iface.staticInterfaceName() << property;
 
         QDBusPendingCall pendingCall = QDBusConnection::systemBus().asyncCall(message);
         QDBusPendingCallWatcher *watcher = new QDBusPendingCallWatcher(pendingCall, this);
 
         connect(watcher, &QDBusPendingCallWatcher::finished, [watcher, q, this, property] () {
             watcher->deleteLater();
             if (property == QLatin1String("State")) {
                 state = NetworkManager::ActiveConnectionPrivate::convertActiveConnectionState(iface.state());
                 Q_EMIT q->stateChanged(state);
             }
             if (property == QLatin1String("Ip4Config")) {
                 ipV4ConfigPath = iface.ip4Config().path();
                 Q_EMIT q->ipV4ConfigChanged();
             } else if (property == QLatin1String("Ip6Config")) {
                 ipV6ConfigPath = iface.ip6Config().path();
                 Q_EMIT q->ipV6ConfigChanged();
             } else if (property == QLatin1String("Dhcp4Config")) {
                 dhcp4ConfigPath = iface.dhcp4Config().path();
                 Q_EMIT q->dhcp4ConfigChanged();
             } else if (property == QLatin1String("Dhcp6Config")) {
                 dhcp6ConfigPath = iface.dhcp6Config().path();
                 Q_EMIT q->dhcp6ConfigChanged();
             }
         });
     }
 }
 
 void NetworkManager::ActiveConnectionPrivate::dbusPropertiesChanged(const QString &interfaceName, const QVariantMap &properties, const QStringList &invalidatedProperties)
 {
     Q_UNUSED(invalidatedProperties);
 
     if (interfaceName == QLatin1String("org.freedesktop.NetworkManager.Connection.Active")) {
         propertiesChanged(properties);
     }
 }
 
 void NetworkManager::ActiveConnectionPrivate::propertiesChanged(const QVariantMap &properties)
 {
     // qCDebug(NMQT) << Q_FUNC_INFO << properties;
 
     QVariantMap::const_iterator it = properties.constBegin();
     while (it != properties.constEnd()) {
         propertyChanged(it.key(), it.value());
         ++it;
     }
 }
 
 void NetworkManager::ActiveConnectionPrivate::stateChanged(uint state, uint reason)
 {
     Q_Q(ActiveConnection);
 
     Q_EMIT q->stateChangedReason(convertActiveConnectionState(state), convertActiveConnectionReason(reason));
 }
 
 void NetworkManager::ActiveConnectionPrivate::propertyChanged(const QString &property, const QVariant &value)
 {
     Q_Q(ActiveConnection);
 
     // qCDebug(NMQT) << property  << " - " << value;
 
     if (property == QLatin1String("Connection")) {
         connection = NetworkManager::findConnection(qdbus_cast<QDBusObjectPath>(value).path());
         Q_EMIT q->connectionChanged(connection);
         const QString tmpId = connection->settings()->id();
         const QString tmpType = connection->settings()->typeAsString(connection->settings()->connectionType());
         if (tmpId != id) {
             id = tmpId;
             Q_EMIT q->idChanged(id);
         }
 
         if (tmpType != type) {
             Q_EMIT q->typeChanged(NetworkManager::ConnectionSettings::typeFromString(type));
         }
     } else if (property == QLatin1String("Default")) {
         default4 = value.toBool();
         Q_EMIT q->default4Changed(default4);
     } else if (property == QLatin1String("Default6")) {
         default6 = value.toBool();
         Q_EMIT q->default6Changed(default6);
     } else if (property == QLatin1String("Dhcp4Config")) {
         QDBusObjectPath dhcp4ConfigPathTmp = (value).value<QDBusObjectPath>();
         if (dhcp4ConfigPathTmp.path().isNull()) {
             dhcp4Config.clear();
             dhcp4ConfigPath.clear();
         } else if (!dhcp4Config || dhcp4Config->path() != dhcp4ConfigPathTmp.path()) {
             dhcp4Config.clear();
             dhcp4ConfigPath = dhcp4ConfigPathTmp.path();
         }
         Q_EMIT q->dhcp4ConfigChanged();
     } else if (property == QLatin1String("Dhcp6Config")) {
         QDBusObjectPath dhcp6ConfigPathTmp = (value).value<QDBusObjectPath>();
         if (dhcp6ConfigPathTmp.path().isNull()) {
             dhcp6Config.clear();
             dhcp6ConfigPath.clear();
         } else if (!dhcp6Config || dhcp6Config->path() != dhcp6ConfigPathTmp.path()) {
             dhcp6Config.clear();
             dhcp6ConfigPath = dhcp6ConfigPathTmp.path();
         }
         Q_EMIT q->dhcp6ConfigChanged();
     } else if (property == QLatin1String("Ip4Config")) {
         QDBusObjectPath ip4ConfigObjectPathTmp = (value).value<QDBusObjectPath>();
         if (ip4ConfigObjectPathTmp.path().isNull() || ip4ConfigObjectPathTmp.path() == QLatin1String("/")) {
             ipV4ConfigPath.clear();
         } else {
             ipV4ConfigPath = ip4ConfigObjectPathTmp.path();
         }
         ipV4Config = IpConfig();
         Q_EMIT q->ipV4ConfigChanged();
     } else if (property == QLatin1String("Ip6Config")) {
         QDBusObjectPath ip6ConfigObjectPathTmp = (value).value<QDBusObjectPath>();
         if (ip6ConfigObjectPathTmp.path().isNull() || ip6ConfigObjectPathTmp.path() == QLatin1String("/")) {
             ipV6ConfigPath.clear();
         } else {
             ipV6ConfigPath = ip6ConfigObjectPathTmp.path();
         }
         ipV6Config = IpConfig();
         Q_EMIT q->ipV6ConfigChanged();
     } else if (property == QLatin1String("Id")) {
         id = value.toString();
         Q_EMIT q->idChanged(id);
     } else if (property == QLatin1String("Type")) {
         type = value.toString();
         Q_EMIT q->typeChanged(NetworkManager::ConnectionSettings::typeFromString(type));
     }  else if (property == QLatin1String("Master")) {
         master = qdbus_cast<QDBusObjectPath>(value).path();
         Q_EMIT q->masterChanged(master);
     } else if (property == QLatin1String("SpecificObject")) {
         specificObject = qdbus_cast<QDBusObjectPath>(value).path();
         Q_EMIT q->specificObjectChanged(specificObject);
     } else if (property == QLatin1String("State")) {
         state = NetworkManager::ActiveConnectionPrivate::convertActiveConnectionState(value.toUInt());
         Q_EMIT q->stateChanged(state);
     } else if (property == QLatin1String("Vpn")) {
         vpn = value.toBool();
         Q_EMIT q->vpnChanged(vpn);
     } else if (property == QLatin1String("Uuid")) {
         uuid = value.toString();
         Q_EMIT q->uuidChanged(uuid);
     } else if (property == QLatin1String("Devices")) {
         devices.clear();
-        Q_FOREACH (const QDBusObjectPath & path, qdbus_cast< QList<QDBusObjectPath> >(value)) {
+        const QList<QDBusObjectPath> opList = qdbus_cast< QList<QDBusObjectPath> >(value);
+        for (const QDBusObjectPath &path : opList) {
             devices.append(path.path());
         }
         Q_EMIT q->devicesChanged();
     } else {
         qCDebug(NMQT) << Q_FUNC_INFO << "Unhandled property" << property;
     }
 }
diff --git a/src/device.cpp b/src/device.cpp
index e289ccc..516d729 100644
--- a/src/device.cpp
+++ b/src/device.cpp
@@ -1,625 +1,629 @@
 /*
     SPDX-FileCopyrightText: 2008, 2010 Will Stephenson <wstephenson@kde.org>
     SPDX-FileCopyrightText: 2013 Daniel Nicoletti <dantti12@gmail.com>
     SPDX-FileCopyrightText: 2013 Jan Grulich <jgrulich@redhat.com>
 
     SPDX-License-Identifier: LGPL-2.1-only OR LGPL-3.0-only OR LicenseRef-KDE-Accepted-LGPL
 */
 
 #include "device_p.h"
 #include "manager.h"
 #include "manager_p.h"
 #include "connection.h"
 #include "settings.h"
 #include "nmdebug.h"
 
 #include <arpa/inet.h>
 
 #include <QDBusObjectPath>
 
 // logging category for this framework, default: log stuff >= warning
 Q_LOGGING_CATEGORY(NMQT, "networkmanager-qt", QtWarningMsg)
 
 namespace NetworkManager
 {
 class DeviceStateReasonPrivate
 {
 public:
     DeviceStateReasonPrivate(Device::State st, Device::StateChangeReason rsn)
         : state(st)
         , reason(rsn)
     {}
     DeviceStateReasonPrivate()
         : state(Device::UnknownState)
         , reason(Device::UnknownReason)
     {}
     Device::State state;
     Device::StateChangeReason reason;
 };
 }
 
 NetworkManager::DeviceStateReason::DeviceStateReason(Device::State state, Device::StateChangeReason reason)
     : d_ptr(new DeviceStateReasonPrivate(state, reason))
 {
 }
 
 NetworkManager::DeviceStateReason::DeviceStateReason(const NetworkManager::DeviceStateReason &other)
     : d_ptr(new DeviceStateReasonPrivate(*other.d_ptr))
 {
 }
 
 NetworkManager::DeviceStateReason::~DeviceStateReason()
 {
     delete d_ptr;
 }
 
 NetworkManager::Device::State NetworkManager::DeviceStateReason::state() const
 {
     Q_D(const DeviceStateReason);
     return d->state;
 }
 
 NetworkManager::Device::StateChangeReason NetworkManager::DeviceStateReason::reason() const
 {
     Q_D(const DeviceStateReason);
     return d->reason;
 }
 
 NetworkManager::DeviceStateReason &NetworkManager::DeviceStateReason::operator=(const NetworkManager::DeviceStateReason &other)
 {
     if (&other != this) {
         *d_ptr = *other.d_ptr;
     }
     return *this;
 }
 
 NetworkManager::DevicePrivate::DevicePrivate(const QString &path, NetworkManager::Device *q)
 #ifdef NMQT_STATIC
     : deviceIface(NetworkManagerPrivate::DBUS_SERVICE, path, QDBusConnection::sessionBus())
 #else
     : deviceIface(NetworkManagerPrivate::DBUS_SERVICE, path, QDBusConnection::systemBus())
 #endif
     , uni(path)
     , designSpeed(0)
     , dhcp4Config(nullptr)
     , dhcp6Config(nullptr)
     , mtu(0)
     , q_ptr(q)
 {
 }
 
 NetworkManager::DevicePrivate::~DevicePrivate()
 {
 }
 
 void NetworkManager::DevicePrivate::init()
 {
     qDBusRegisterMetaType<UIntList>();
     qDBusRegisterMetaType<UIntListList>();
     qDBusRegisterMetaType<IpV6DBusAddress>();
     qDBusRegisterMetaType<IpV6DBusAddressList>();
     qDBusRegisterMetaType<IpV6DBusNameservers>();
     qDBusRegisterMetaType<IpV6DBusRoute>();
     qDBusRegisterMetaType<IpV6DBusRouteList>();
     qDBusRegisterMetaType<DeviceDBusStateReason>();
 
     // This needs to be initialized as soon as possible, because based on this property
     // we initialize the device type
     deviceType = convertType(deviceIface.deviceType());
 
     deviceStatistics = DeviceStatistics::Ptr(new NetworkManager::DeviceStatistics(uni), &QObject::deleteLater);
 
     // Get all Device's properties at once
     QVariantMap initialProperties = NetworkManagerPrivate::retrieveInitialProperties(deviceIface.staticInterfaceName(), uni);
     if (!initialProperties.isEmpty()) {
         propertiesChanged(initialProperties);
     }
 
     QObject::connect(&deviceIface, &OrgFreedesktopNetworkManagerDeviceInterface::StateChanged, this, &DevicePrivate::deviceStateChanged);
 }
 
 NetworkManager::Device::MeteredStatus NetworkManager::DevicePrivate::convertMeteredStatus(uint metered)
 {
     NetworkManager::Device::MeteredStatus ourMeteredStatus = (NetworkManager::Device::MeteredStatus) metered;
     return ourMeteredStatus;
 }
 
 NetworkManager::Device::Capabilities NetworkManager::DevicePrivate::convertCapabilities(uint theirCaps)
 {
     NetworkManager::Device::Capabilities ourCaps
         = (NetworkManager::Device::Capabilities) theirCaps;
     return ourCaps;
 }
 
 NetworkManager::Device::State NetworkManager::DevicePrivate::convertState(uint theirState)
 {
     NetworkManager::Device::State ourState = static_cast<NetworkManager::Device::State>(theirState);
     return ourState;
 }
 
 NetworkManager::Device::StateChangeReason NetworkManager::DevicePrivate::convertReason(uint theirReason)
 {
     NetworkManager::Device::StateChangeReason ourReason = (NetworkManager::Device::StateChangeReason)theirReason;
     return ourReason;
 }
 
 NetworkManager::Device::Type NetworkManager::DevicePrivate::convertType(uint type)
 {
     // These are identical to NM enums
     if (type <= NM_DEVICE_TYPE_TEAM) {
         return (NetworkManager::Device::Type)type;
     }
 
     switch (type) {
     case 16:
         // NM_DEVICE_TYPE_TUN
         return NetworkManager::Device::Tun;
     case 17:
         // NM_DEVICE_TYPE_IP_TUNNEL
         return NetworkManager::Device::IpTunnel;
     case 18:
         // NM_DEVICE_TYPE_MACVLAN
         return NetworkManager::Device::MacVlan;
     case 19:
         // NM_DEVICE_TYPE_VXLAN
         return NetworkManager::Device::VxLan;
     case 20:
         // NM_DEVICE_TYPE_VETH
         return NetworkManager::Device::Veth;
     case 21:
         // NM_DEVICE_TYPE_MACSEC
         return NetworkManager::Device::MacSec;
     case 22:
         // NM_DEVICE_TYPE_DUMMY
         return NetworkManager::Device::Dummy;
     case 23:
         // NM_DEVICE_TYPE_PPP
         return NetworkManager::Device::Ppp;
     case 24:
         // NM_DEVICE_TYPE_OVS_INTERFACE
         return NetworkManager::Device::OvsInterface;
     case 25:
         // NM_DEVICE_TYPE_OVS_PORT
         return NetworkManager::Device::OvsPort;
     case 26:
         // NM_DEVICE_TYPE_OVS_BRIDGE
         return NetworkManager::Device::OvsBridge;
     case 27:
         // NM_DEVICE_TYPE_WPAN
         return NetworkManager::Device::Wpan;
     case 28:
         // NM_DEVICE_TYPE_6LOWPAN
         return NetworkManager::Device::Lowpan;
     case 29:
         // NM_DEVICE_TYPE_NM_DEVICE_TYPE_WIREGUARD
         return NetworkManager::Device::WireGuard;
     case 30:
         // NM_DEVICE_TYPE_WIFI_P2P
         return NetworkManager::Device::WifiP2P;
     }
 
     return NetworkManager::Device::UnknownType;
 }
 
 NetworkManager::Device::Device(const QString &path, QObject *parent)
     : QObject(parent)
     , d_ptr(new DevicePrivate(path, this))
 {
     Q_D(Device);
 
     d->init();
 }
 
 NetworkManager::Device::Device(DevicePrivate &dd,  QObject *parent)
     : QObject(parent)
     , d_ptr(&dd)
 {
     Q_D(Device);
 
     d->init();
 }
 
 void NetworkManager::DevicePrivate::propertyChanged(const QString &property, const QVariant &value)
 {
     Q_Q(Device);
 
     // qCDebug(NMQT) << property  << " - " << value;
     if (property == QLatin1String("ActiveConnection")) {
         // FIXME workaround, because NM doesn't Q_EMIT correct value
         // d->activeConnection = value.value<QDBusObjectPath>.path();
         activeConnection = deviceIface.activeConnection().path();
         Q_EMIT q->activeConnectionChanged();
     } else if (property == QLatin1String("Autoconnect")) {
         autoconnect = value.toBool();
         Q_EMIT q->autoconnectChanged();
     } else if (property == QLatin1String("AvailableConnections")) {
         QStringList newAvailableConnections;
-        QList<QDBusObjectPath> availableConnectionsTmp = qdbus_cast< QList<QDBusObjectPath> >(value);
-        Q_FOREACH (const QDBusObjectPath & availableConnection, availableConnectionsTmp) {
+        const QList<QDBusObjectPath> availableConnectionsTmp = qdbus_cast< QList<QDBusObjectPath> >(value);
+        for (const QDBusObjectPath &availableConnection : availableConnectionsTmp) {
             newAvailableConnections << availableConnection.path();
             if (!availableConnections.contains(availableConnection.path())) {
                 availableConnections << availableConnection.path();
                 Q_EMIT q->availableConnectionAppeared(availableConnection.path());
             }
         }
-        Q_FOREACH (const QString & availableConnection, availableConnections) {
+        auto it = availableConnections.begin();
+        while (it != availableConnections.end()) {
+            const QString availableConnection = *it;
             if (!newAvailableConnections.contains(availableConnection)) {
-                availableConnections.removeOne(availableConnection);
+                it = availableConnections.erase(it);
                 Q_EMIT q->availableConnectionDisappeared(availableConnection);
+            } else {
+                ++it;
             }
         }
         Q_EMIT q->availableConnectionChanged();
     } else if (property == QLatin1String("Capabilities")) {
         capabilities = NetworkManager::DevicePrivate::convertCapabilities(value.toUInt());
         Q_EMIT q->capabilitiesChanged();
     } else if (property == QLatin1String("DeviceType")) {
         deviceType = static_cast<Device::Type>(value.toUInt());
     } else if (property == QLatin1String("Dhcp4Config")) {
         QDBusObjectPath dhcp4ConfigPathTmp = value.value<QDBusObjectPath>();
         if (dhcp4ConfigPathTmp.path().isNull()) {
             dhcp4Config.clear();
             dhcp4ConfigPath.clear();
         } else if (!dhcp4Config || dhcp4Config->path() != dhcp4ConfigPathTmp.path()) {
             dhcp4Config.clear();
             dhcp4ConfigPath = dhcp4ConfigPathTmp.path();
         }
         Q_EMIT q->dhcp4ConfigChanged();
     } else if (property == QLatin1String("Dhcp6Config")) {
         QDBusObjectPath dhcp6ConfigPathTmp = value.value<QDBusObjectPath>();
         if (dhcp6ConfigPathTmp.path().isNull()) {
             dhcp6Config.clear();
             dhcp6ConfigPath.clear();
         } else if (!dhcp6Config || dhcp6Config->path() != dhcp6ConfigPathTmp.path()) {
             dhcp6Config.clear();
             dhcp6ConfigPath = dhcp6ConfigPathTmp.path();
         }
         Q_EMIT q->dhcp6ConfigChanged();
     } else if (property == QLatin1String("Driver")) {
         driver = value.toString();
         Q_EMIT q->driverChanged();
     } else if (property == QLatin1String("DriverVersion")) {
         driverVersion = value.toString();
         Q_EMIT q->driverVersionChanged();
     } else if (property == QLatin1String("FirmwareMissing")) {
         firmwareMissing = value.toBool();
         Q_EMIT q->firmwareMissingChanged();
     } else if (property == QLatin1String("FirmwareVersion")) {
         firmwareVersion = value.toString();
         Q_EMIT q->firmwareVersionChanged();
     } else if (property == QLatin1String("Interface")) {
         interfaceName = value.toString();
         Q_EMIT q->interfaceNameChanged();
     } else if (property == QLatin1String("Ip4Address")) {
         ipV4Address = QHostAddress(ntohl(value.toUInt()));
         Q_EMIT q->ipV4AddressChanged();
     } else if (property == QLatin1String("Ip4Config")) {
         QDBusObjectPath ip4ConfigObjectPathTmp = value.value<QDBusObjectPath>();
         if (ip4ConfigObjectPathTmp.path().isNull() || ip4ConfigObjectPathTmp.path() == QLatin1String("/")) {
             ipV4ConfigPath.clear();
         } else {
             ipV4ConfigPath = ip4ConfigObjectPathTmp.path();
         }
         ipV4Config = IpConfig();
         Q_EMIT q->ipV4ConfigChanged();
     } else if (property == QLatin1String("Ip6Config")) {
         QDBusObjectPath ip6ConfigObjectPathTmp = value.value<QDBusObjectPath>();
         if (ip6ConfigObjectPathTmp.path().isNull() || ip6ConfigObjectPathTmp.path() == QLatin1String("/")) {
             ipV6ConfigPath.clear();
         } else {
             ipV6ConfigPath = ip6ConfigObjectPathTmp.path();
         }
         ipV6Config = IpConfig();
         Q_EMIT q->ipV6ConfigChanged();
     } else if (property == QLatin1String("IpInterface")) {
         ipInterface = value.toString();
         Q_EMIT q->ipInterfaceChanged();
     } else if (property == QLatin1String("Managed")) {
         managed = value.toBool();
         Q_EMIT q->managedChanged();
     } else if (property == QLatin1String("State")) {
         connectionState = NetworkManager::DevicePrivate::convertState(value.toUInt());
         // FIXME NetworkManager 0.9.8 (maybe greater) doesn't
         // update ActiveConnection when disconnected
         // This is fixed in NM 73d128bbd17120225bb4986e3f05566f10fab581
         if (connectionState == NetworkManager::Device::Disconnected && activeConnection != QLatin1String("/")) {
             activeConnection = QLatin1Char('/');
             Q_EMIT q->activeConnectionChanged();
         }
         Q_EMIT q->connectionStateChanged();
     } else if (property == QLatin1String("StateReason")) { // just extracting the reason
         reason = NetworkManager::DevicePrivate::convertReason(qdbus_cast<DeviceDBusStateReason>(value).reason);
         Q_EMIT q->stateReasonChanged();
     } else if (property == QLatin1String("Udi")) {
         udi = value.toString();
         Q_EMIT q->udiChanged();
     } else if (property == QLatin1String("PhysicalPortId")) {
         physicalPortId = value.toString();
         Q_EMIT q->physicalPortIdChanged();
     } else if (property == QLatin1String("Mtu")) {
             mtu = value.toUInt();
             Q_EMIT q->mtuChanged();
     } else if (property == QLatin1String("NmPluginMissing")) {
         nmPluginMissing = value.toBool();
         Q_EMIT q->nmPluginMissingChanged(nmPluginMissing);
     } else if (property == QLatin1String("Metered")) {
         metered = NetworkManager::DevicePrivate::convertMeteredStatus(value.toUInt());
         Q_EMIT q->meteredChanged(metered);
     } else {
         qCDebug(NMQT) << Q_FUNC_INFO << "Unhandled property" << property;
     }
 }
 
 NetworkManager::Device::~Device()
 {
     Q_D(Device);
     delete d;
 }
 
 QString NetworkManager::Device::uni() const
 {
     Q_D(const Device);
     return d->uni;
 }
 
 QString NetworkManager::Device::interfaceName() const
 {
     Q_D(const Device);
     return d->interfaceName;
 }
 
 QString NetworkManager::Device::ipInterfaceName() const
 {
     Q_D(const Device);
     return d->ipInterface;
 }
 
 QString NetworkManager::Device::driver() const
 {
     Q_D(const Device);
     return d->driver;
 }
 
 QString NetworkManager::Device::driverVersion() const
 {
     Q_D(const Device);
     return d->driverVersion;
 }
 
 QString NetworkManager::Device::firmwareVersion() const
 {
     Q_D(const Device);
     return d->firmwareVersion;
 }
 
 NetworkManager::ActiveConnection::Ptr NetworkManager::Device::activeConnection() const
 {
     Q_D(const Device);
     return NetworkManager::findActiveConnection(d->activeConnection);
 }
 
 NetworkManager::Connection::List NetworkManager::Device::availableConnections()
 {
     Q_D(const Device);
 
     NetworkManager::Connection::List list;
-    Q_FOREACH (const QString & availableConnection, d->availableConnections) {
+    for (const QString &availableConnection : qAsConst(d->availableConnections)) {
         NetworkManager::Connection::Ptr connection = NetworkManager::findConnection(availableConnection);
         if (connection) {
             list << connection;
         }
     }
 
     return list;
 }
 
 bool NetworkManager::Device::firmwareMissing() const
 {
     Q_D(const Device);
     return d->firmwareMissing;
 }
 
 bool NetworkManager::Device::autoconnect() const
 {
     Q_D(const Device);
     return d->autoconnect;
 }
 
 void NetworkManager::Device::setAutoconnect(bool autoconnect)
 {
     Q_D(Device);
     d->deviceIface.setAutoconnect(autoconnect);
 }
 
 QString NetworkManager::Device::udi() const
 {
     Q_D(const Device);
     return d->udi;
 }
 
 QString NetworkManager::Device::physicalPortId() const
 {
     Q_D(const Device);
     return d->physicalPortId;
 }
 
 QHostAddress NetworkManager::Device::ipV4Address() const
 {
     Q_D(const Device);
     return d->ipV4Address;
 }
 
 NetworkManager::DeviceStateReason NetworkManager::Device::stateReason() const
 {
     Q_D(const Device);
     return DeviceStateReason(d->connectionState, d->reason);
 }
 
 NetworkManager::IpConfig NetworkManager::Device::ipV4Config() const
 {
     Q_D(const Device);
     if (!d->ipV4Config.isValid() && !d->ipV4ConfigPath.isNull()) {
         d->ipV4Config.setIPv4Path(d->ipV4ConfigPath);
     }
     return d->ipV4Config;
 }
 
 NetworkManager::IpConfig NetworkManager::Device::ipV6Config() const
 {
     Q_D(const Device);
     if (!d->ipV6Config.isValid() && !d->ipV6ConfigPath.isNull()) {
         d->ipV6Config.setIPv6Path(d->ipV6ConfigPath);
     }
     return d->ipV6Config;
 }
 
 NetworkManager::Dhcp4Config::Ptr NetworkManager::Device::dhcp4Config() const
 {
     Q_D(const Device);
     if (!d->dhcp4Config && !d->dhcp4ConfigPath.isNull()) {
         d->dhcp4Config = NetworkManager::Dhcp4Config::Ptr(new Dhcp4Config(d->dhcp4ConfigPath), &QObject::deleteLater);
     }
     return d->dhcp4Config;
 }
 
 NetworkManager::Dhcp6Config::Ptr NetworkManager::Device::dhcp6Config() const
 {
     Q_D(const Device);
     if (!d->dhcp6Config && !d->dhcp6ConfigPath.isNull()) {
         d->dhcp6Config = NetworkManager::Dhcp6Config::Ptr(new Dhcp6Config(d->dhcp6ConfigPath), &QObject::deleteLater);
     }
     return d->dhcp6Config;
 }
 
 bool NetworkManager::Device::isActive() const
 {
     Q_D(const Device);
     return !(d->connectionState == NetworkManager::Device::Unavailable
              || d->connectionState == NetworkManager::Device::Unmanaged
              || d->connectionState == NetworkManager::Device::Disconnected
              || d->connectionState == NetworkManager::Device::Failed);
 }
 
 bool NetworkManager::Device::isValid() const
 {
     Q_D(const Device);
     return d->deviceIface.isValid();
 }
 
 bool NetworkManager::Device::managed() const
 {
     Q_D(const Device);
     return d->managed;
 }
 
 uint NetworkManager::Device::mtu() const
 {
     Q_D(const Device);
     return d->mtu;
 }
 
 bool NetworkManager::Device::nmPluginMissing() const
 {
     Q_D(const Device);
     return d->nmPluginMissing;
 
 }
 
 NetworkManager::Device::MeteredStatus NetworkManager::Device::metered() const
 {
     Q_D(const Device);
     return d->metered;
 }
 
 QDBusPendingReply<> NetworkManager::Device::reapplyConnection(const NMVariantMapMap &connection, qulonglong version_id, uint flags)
 {
     Q_D(Device);
     return d->deviceIface.Reapply(connection, version_id, flags);
 }
 
 QDBusPendingReply<> NetworkManager::Device::disconnectInterface()
 {
     Q_D(Device);
     return d->deviceIface.Disconnect();
 }
 
 QDBusPendingReply<> NetworkManager::Device::deleteInterface()
 {
     if (NetworkManager::checkVersion(1, 0, 0)) {
         Q_D(Device);
         return d->deviceIface.Delete();
     } else {
         return QDBusPendingReply<>();
     }
 }
 
 NetworkManager::Device::State NetworkManager::Device::state() const
 {
     Q_D(const Device);
     return d->connectionState;
 }
 
 int NetworkManager::Device::designSpeed() const
 {
     Q_D(const Device);
     return d->designSpeed;
 }
 
 NetworkManager::Device::Capabilities NetworkManager::Device::capabilities() const
 {
     Q_D(const Device);
     return d->capabilities;
 }
 
 QVariant NetworkManager::Device::capabilitiesV() const
 {
     Q_D(const Device);
     return QVariant(d->capabilities);
 }
 
 NetworkManager::DeviceStatistics::Ptr NetworkManager::Device::deviceStatistics() const
 {
     Q_D(const Device);
     return d->deviceStatistics;
 }
 
 void NetworkManager::DevicePrivate::deviceStateChanged(uint newState, uint oldState, uint reason)
 {
     Q_Q(Device);
     connectionState = NetworkManager::DevicePrivate::convertState(newState);
     reason = NetworkManager::DevicePrivate::convertReason(reason);
 
     Q_EMIT q->stateChanged(connectionState, NetworkManager::DevicePrivate::convertState(oldState), NetworkManager::DevicePrivate::convertReason(reason));
 }
 
 void NetworkManager::DevicePrivate::dbusPropertiesChanged(const QString &interfaceName, const QVariantMap &properties, const QStringList &invalidatedProperties)
 {
     Q_UNUSED(invalidatedProperties);
     if (interfaceName.contains(QLatin1String("org.freedesktop.NetworkManager.Device")) && interfaceName != QLatin1String("org.freedesktop.NetworkManager.Device.Statistics")) {
         propertiesChanged(properties);
     }
 }
 
 void NetworkManager::DevicePrivate::propertiesChanged(const QVariantMap &properties)
 {
     // qCDebug(NMQT) << Q_FUNC_INFO << properties;
 
     QVariantMap::const_iterator it = properties.constBegin();
     while (it != properties.constEnd()) {
         propertyChanged(it.key(), it.value());
         ++it;
     }
 
     // FIXME workaround, we need to get a path to updated IPv[46]Config,
     // because NM doesn't Q_EMIT the updated value when the device is activated
     // BUG: https://bugzilla.gnome.org/show_bug.cgi?id=725657
     if (properties.contains(QLatin1String("State")) && connectionState == NetworkManager::Device::Activated) {
         propertyChanged(QLatin1String("Ip4Config"), QVariant::fromValue<QDBusObjectPath>(deviceIface.ip4Config()));
         propertyChanged(QLatin1String("Ip6Config"), QVariant::fromValue<QDBusObjectPath>(deviceIface.ip6Config()));
     }
 }
 
 NetworkManager::Device::Type NetworkManager::Device::type() const
 {
     Q_D(const Device);
     return d->deviceType;
 }
diff --git a/src/dnsconfiguration.cpp b/src/dnsconfiguration.cpp
index 6eff0d8..dcc6448 100644
--- a/src/dnsconfiguration.cpp
+++ b/src/dnsconfiguration.cpp
@@ -1,139 +1,143 @@
 /*
     SPDX-FileCopyrightText: 2018 Aleksander Morgado <aleksander@aleksander.es>
 
     SPDX-License-Identifier: LGPL-2.1-only OR LGPL-3.0-only OR LicenseRef-KDE-Accepted-LGPL
 */
 
 #include "ipconfig.h"
 
 #include <arpa/inet.h>
 
 #include "dnsconfiguration.h"
 
 namespace NetworkManager
 {
 
 class NetworkManager::DnsConfiguration::Private
 {
 public:
     Private(const QStringList &theSearches,
             const QStringList &theOptions,
             const QList<DnsDomain> theDomains)
         : searches(theSearches)
         , options(theOptions)
         , domains(theDomains)
     {}
     Private()
     {}
     QStringList searches;
     QStringList options;
     QList<DnsDomain> domains;
 };
 
 }
 
 NetworkManager::DnsConfiguration::DnsConfiguration(const QStringList &searches,
                                                    const QStringList &options,
                                                    const QList<DnsDomain> domains)
     : d(new Private(searches, options, domains))
 {
 }
 
 NetworkManager::DnsConfiguration::DnsConfiguration()
     : d(new Private())
 {
 }
 
 NetworkManager::DnsConfiguration::DnsConfiguration(const DnsConfiguration &other)
     : d(new Private)
 {
     *this = other;
 }
 
 NetworkManager::DnsConfiguration::~DnsConfiguration()
 {
     delete d;
 }
 
 QStringList NetworkManager::DnsConfiguration::searches() const
 {
     return d->searches;
 }
 
 void NetworkManager::DnsConfiguration::setSearches(const QStringList &searches)
 {
     d->searches = searches;
 }
 
 QStringList NetworkManager::DnsConfiguration::options() const
 {
     return d->options;
 }
 
 void NetworkManager::DnsConfiguration::setOptions(const QStringList &options)
 {
     d->options = options;
 }
 
 QList<NetworkManager::DnsDomain> NetworkManager::DnsConfiguration::domains() const
 {
     return d->domains;
 }
 
 void NetworkManager::DnsConfiguration::setDomains(const QList<NetworkManager::DnsDomain> &domains)
 {
     d->domains = domains;
 }
 
 QVariantMap NetworkManager::DnsConfiguration::toMap() const
 {
     QVariantMap map;
 
     map["searches"] = d->searches;
     map["options"] = d->options;
 
     QVariantMap domains;
-    Q_FOREACH (const NetworkManager::DnsDomain &domain, d->domains) {
+    for (const NetworkManager::DnsDomain &domain : qAsConst(d->domains)) {
         QVariantMap contents;
         QStringList serversList;
-        Q_FOREACH (const QHostAddress &address, domain.servers())
+        const QList<QHostAddress> servers = domain.servers();
+        for (const QHostAddress &address : servers) {
             serversList.append(address.toString());
+        }
         contents["servers"] = serversList;
         contents["options"] = domain.options();
         domains[domain.name()] = contents;
     }
     map["domains"] = domains;
 
     return map;
 }
 
 void NetworkManager::DnsConfiguration::fromMap (const QVariantMap &map)
 {
     d->searches = map["searches"].toStringList();
     d->options = map["options"].toStringList();
     d->domains = QList<NetworkManager::DnsDomain>();
 
     QVariantMap domains = map["domains"].toMap();
     QVariantMap::const_iterator i = domains.constBegin();
     while (i != domains.constEnd()) {
-        QVariantMap contents = i.value().toMap();
+        const QVariantMap contents = i.value().toMap();
         QList<QHostAddress> addressList;
-        Q_FOREACH (const QString &server, contents["servers"].toStringList())
+        const QStringList serversList = contents["servers"].toStringList();
+        for (const QString &server : serversList) {
             addressList.append(QHostAddress(server));
+        }
         NetworkManager::DnsDomain domain(i.key(),
                                          addressList,
                                          contents["options"].toStringList());
         d->domains.append(domain);
         ++i;
     }
 }
 
 NetworkManager::DnsConfiguration &NetworkManager::DnsConfiguration::operator=(const DnsConfiguration &other)
 {
     if (this == &other) {
         return *this;
     }
 
     *d = *other.d;
     return *this;
 }
diff --git a/src/fakenetwork/fakenetwork.cpp b/src/fakenetwork/fakenetwork.cpp
index 655140b..0582342 100644
--- a/src/fakenetwork/fakenetwork.cpp
+++ b/src/fakenetwork/fakenetwork.cpp
@@ -1,456 +1,458 @@
 /*
     SPDX-FileCopyrightText: 2014 Jan Grulich <jgrulich@redhat.com>
 
     SPDX-License-Identifier: LGPL-2.1-only OR LGPL-3.0-only OR LicenseRef-KDE-Accepted-LGPL
 */
 
 #include "connection.h"
 #include "fakenetwork.h"
 #include "wireddevice.h"
 #include "wirelessdevice.h"
 
 #include <QDBusConnection>
 #include <QTimer>
 
 #include "connectionsettings.h"
 #include "../manager.h"
 
 FakeNetwork::FakeNetwork(QObject *parent)
     : QObject(parent)
     , m_activatingConnection(QDBusObjectPath("/"))
     , m_connectivity(NetworkManager::Connectivity::NoConnectivity)
     , m_networkingEnabled(true)
     , m_primaryConnection(QDBusObjectPath("/"))
     , m_state(20)
     , m_version(QLatin1String("0.9.10.0"))
     , m_wimaxEnabled(true)
     , m_wimaxHardwareEnabled(true)
     , m_wirelessEnabled(true)
     , m_wirelessHardwareEnabled(true)
     , m_wwanEnabled(true)
     , m_wwanHardwareEnabled(true)
     , m_activeConnectionsCounter(0)
     , m_deviceCounter(0)
     , m_settings(new Settings(this))
 {
     registerService();
     connect(m_settings, &Settings::connectionAdded, this, &FakeNetwork::onConnectionAdded);
     connect(m_settings, &Settings::connectionRemoved, this, &FakeNetwork::onConnectionRemoved);
 }
 
 FakeNetwork::~FakeNetwork()
 {
     unregisterService();
     qDeleteAll(m_devices);
     delete m_settings;
 }
 
 QDBusObjectPath FakeNetwork::activatingConnection() const
 {
     return m_activatingConnection;
 }
 
 QList< QDBusObjectPath > FakeNetwork::activeConnections() const
 {
     return m_activeConnections.keys();
 }
 
 uint FakeNetwork::connectivity() const
 {
     return m_connectivity;
 }
 
 QList< QDBusObjectPath > FakeNetwork::devices() const
 {
     return m_devices.keys();
 }
 
 bool FakeNetwork::networkingEnabled() const
 {
     return m_networkingEnabled;
 }
 
 QDBusObjectPath FakeNetwork::primaryConnection() const
 {
     return m_primaryConnection;
 }
 
 uint FakeNetwork::state() const
 {
     return m_state;
 }
 
 QString FakeNetwork::version() const
 {
     return m_version;
 }
 
 bool FakeNetwork::wimaxEnabled() const
 {
     return m_wimaxEnabled;
 }
 
 void FakeNetwork::setWimaxEnabled(bool enabled)
 {
     m_wimaxEnabled = enabled;
 
     QVariantMap map;
     map.insert(QLatin1String("WimaxEnabled"), m_wimaxEnabled);
     Q_EMIT PropertiesChanged(map);
 }
 
 bool FakeNetwork::wimaxHardwareEnabled() const
 {
     return m_wimaxHardwareEnabled;
 }
 
 void FakeNetwork::setWimaxHardwareEnabled(bool enabled)
 {
     m_wimaxHardwareEnabled = enabled;
 
     QVariantMap map;
     map.insert(QLatin1String("WimaxHardwareEnabled"), m_wimaxHardwareEnabled);
     Q_EMIT PropertiesChanged(map);
 }
 
 bool FakeNetwork::wirelessEnabled() const
 {
     return m_wirelessEnabled;
 }
 
 void FakeNetwork::setWirelessEnabled(bool enabled)
 {
     m_wirelessEnabled = enabled;
 
     QVariantMap map;
     map.insert(QLatin1String("WirelessEnabled"), m_wirelessEnabled);
     Q_EMIT PropertiesChanged(map);
 }
 
 bool FakeNetwork::wirelessHardwareEnabled() const
 {
     return m_wirelessHardwareEnabled;
 }
 
 void FakeNetwork::setWirelessHardwareEnabled(bool enabled)
 {
     m_wirelessHardwareEnabled = enabled;
 
     QVariantMap map;
     map.insert(QLatin1String("WirelessHardwareEnabled"), m_wirelessHardwareEnabled);
     Q_EMIT PropertiesChanged(map);
 }
 
 bool FakeNetwork::wwanEnabled() const
 {
     return m_wwanEnabled;
 }
 
 void FakeNetwork::setWwanEnabled(bool enabled)
 {
     m_wwanEnabled = enabled;
 
     QVariantMap map;
     map.insert(QLatin1String("WwanEnabled"), m_wwanEnabled);
     Q_EMIT PropertiesChanged(map);
 }
 
 bool FakeNetwork::wwanHardwareEnabled() const
 {
     return m_wwanHardwareEnabled;
 }
 
 void FakeNetwork::addDevice(Device *device)
 {
     QString newDevicePath = QString("/org/kde/fakenetwork/Devices/") + QString::number(m_deviceCounter++);
     device->setDevicePath(newDevicePath);
     m_devices.insert(QDBusObjectPath(newDevicePath), device);
     QDBusConnection::sessionBus().registerObject(newDevicePath, device, QDBusConnection::ExportScriptableContents);
     Q_EMIT DeviceAdded(QDBusObjectPath(newDevicePath));
 }
 
 void FakeNetwork::removeDevice(Device *device)
 {
     m_devices.remove(QDBusObjectPath(device->devicePath()));
     QDBusConnection::sessionBus().unregisterObject(device->devicePath());
     Q_EMIT DeviceRemoved(QDBusObjectPath(device->devicePath()));
 }
 
 void FakeNetwork::registerService()
 {
     QDBusConnection::sessionBus().registerService(QLatin1String("org.kde.fakenetwork"));
     QDBusConnection::sessionBus().registerObject(QLatin1String("/org/kde/fakenetwork"), this, QDBusConnection::ExportScriptableContents);
     QDBusConnection::sessionBus().registerObject(QLatin1String("/org/kde/fakenetwork/Settings"), m_settings, QDBusConnection::ExportScriptableContents);
 
-    Q_FOREACH (const QDBusObjectPath & devicePath, m_devices.keys()) {
-        QDBusConnection::sessionBus().registerObject(devicePath.path(), m_devices.value(devicePath), QDBusConnection::ExportScriptableContents);
+    for (auto it = m_devices.cbegin(); it != m_devices.cend(); ++it) {
+        const QDBusObjectPath &devicePath = it.key();
+        QDBusConnection::sessionBus().registerObject(devicePath.path(), it.value(), QDBusConnection::ExportScriptableContents);
         Q_EMIT DeviceAdded(devicePath);
     }
 }
 
 void FakeNetwork::unregisterService()
 {
-    Q_FOREACH (const QDBusObjectPath & devicePath, m_devices.keys()) {
+    for (auto it = m_devices.cbegin(); it != m_devices.cend(); ++it) {
+        const QDBusObjectPath &devicePath = it.key();
         QDBusConnection::sessionBus().unregisterObject(devicePath.path());
         Q_EMIT DeviceRemoved(devicePath);
     }
 
     QDBusConnection::sessionBus().unregisterObject(QLatin1String("/org/kde/fakenetwork/Settings"));
     QDBusConnection::sessionBus().unregisterObject(QLatin1String("/org/kde/fakenetwork"));
     QDBusConnection::sessionBus().unregisterService(QLatin1String("org.kde.fakenetwork"));
 }
 
 QDBusObjectPath FakeNetwork::ActivateConnection(const QDBusObjectPath &connection, const QDBusObjectPath &device, const QDBusObjectPath &specific_object)
 {
     QString newActiveConnectionPath = QString("/org/kde/fakenetwork/ActiveConnection/") + QString::number(m_activeConnectionsCounter++);
     ActiveConnection *newActiveConnection = new ActiveConnection(this);
     newActiveConnection->addDevice(device);
     newActiveConnection->setActiveConnectionPath(newActiveConnectionPath);
     newActiveConnection->setConnection(connection);
     newActiveConnection->setSpecificObject(specific_object);
     newActiveConnection->setState(NetworkManager::ActiveConnection::Activating);
 
     m_activeConnections.insert(QDBusObjectPath(newActiveConnectionPath), newActiveConnection);
     QDBusConnection::sessionBus().registerObject(newActiveConnectionPath, newActiveConnection, QDBusConnection::ExportScriptableContents);
 
     m_activatingConnection = QDBusObjectPath(newActiveConnectionPath);
 
     QVariantMap map;
     map.insert(QLatin1String("ActiveConnections"), QVariant::fromValue<QList<QDBusObjectPath> >(m_activeConnections.keys()));
     map.insert(QLatin1String("ActivatingConnection"), QVariant::fromValue(QDBusObjectPath(newActiveConnectionPath)));
     Q_EMIT PropertiesChanged(map);
 
     Device *usedDevice = static_cast<Device *>(QDBusConnection::sessionBus().objectRegisteredAt(device.path()));
     if (usedDevice) {
         m_activatedDevice = usedDevice->devicePath();
         // Start simulation of activation
         usedDevice->setActiveConnection(newActiveConnectionPath);
         usedDevice->setState(NetworkManager::Device::Preparing);
         QTimer::singleShot(100, this, SLOT(updateConnectingState()));
     }
 
     return QDBusObjectPath(newActiveConnectionPath);
 }
 
 void FakeNetwork::updateConnectingState()
 {
     QVariantMap deviceMap;
     Device *device = m_devices.value(QDBusObjectPath(m_activatedDevice));
     if (device->state() == NetworkManager::Device::Preparing) {
         device->setState(NetworkManager::Device::ConfiguringHardware);
     } else if (device->state() == NetworkManager::Device::ConfiguringHardware) {
         device->setState(NetworkManager::Device::NeedAuth);
     } else if (device->state() == NetworkManager::Device::NeedAuth) {
         device->setState(NetworkManager::Device::ConfiguringIp);
     } else if (device->state() == NetworkManager::Device::ConfiguringIp) {
         device->setState(NetworkManager::Device::CheckingIp);
     } else if (device->state() == NetworkManager::Device::CheckingIp) {
         device->setState(NetworkManager::Device::Activated);
 
         ActiveConnection *activeConnection = static_cast<ActiveConnection *>(QDBusConnection::sessionBus().objectRegisteredAt(device->activeConnection().path()));
         if (activeConnection) {
             QVariantMap activeConnectionMap;
             activeConnectionMap.insert(QLatin1String("State"), NetworkManager::ActiveConnection::Activated);
 
             activeConnection->setState(NetworkManager::ActiveConnection::Activated);
             QDBusMessage message = QDBusMessage::createSignal(activeConnection->activeConnectionPath(), QLatin1String("org.kde.fakenetwork.Connection.Active"), QLatin1String("PropertiesChanged"));
             message << activeConnectionMap;
             QDBusConnection::sessionBus().send(message);
 
             QDBusMessage message2 = QDBusMessage::createSignal(activeConnection->activeConnectionPath(), QLatin1String("org.kde.fakenetwork.Connection.Active"), QLatin1String("StateChanged"));
             message2 << (uint)2 << (uint)1; // NM_ACTIVE_CONNECTION_STATE_ACTIVATED << NM_ACTIVE_CONNECTION_STATE_REASON_NONE
             QDBusConnection::sessionBus().send(message2);
         }
         // TODO: set dhcp4Config, dhcp6Config, ip4Config, ip6Config
         // IP Interface is usually same as interface
         device->setIpInterface(device->interface());
         // Set some IP address
         device->setIpv4Address(1763189258);
 
         deviceMap.insert(QLatin1String("IpInterface"), device->ipInterface());
         deviceMap.insert(QLatin1String("Ip4Address"), device->ip4Address());
         deviceMap.insert(QLatin1String("ActiveConnection"), m_activatingConnection.path());
 
         // Update FakeNetwork state, connectivity, primary connection
         m_connectivity = NetworkManager::Connectivity::Full;
         m_primaryConnection = m_activatingConnection;
         m_activatingConnection = QDBusObjectPath("/");
         m_state = 70;
         QVariantMap networkMap;
         networkMap.insert(QLatin1String("ActivatingConnection"), QVariant::fromValue(m_activatingConnection));
         networkMap.insert(QLatin1String("Connectivity"), NetworkManager::Connectivity::Full);
         networkMap.insert(QLatin1String("PrimaryConnection"), QVariant::fromValue(m_primaryConnection));
         networkMap.insert(QLatin1String("State"), m_state);
 
         QDBusMessage message = QDBusMessage::createSignal(QLatin1String("/org/kde/fakenetwork"), QLatin1String("org.kde.fakenetwork"), QLatin1String("PropertiesChanged"));
         message << networkMap;
         QDBusConnection::sessionBus().send(message);
 
         Q_EMIT StateChanged(m_state);
     }
 
     deviceMap.insert(QLatin1String("State"), device->state());
     QDBusMessage message = QDBusMessage::createSignal(device->devicePath(), device->deviceInterface(), QLatin1String("PropertiesChanged"));
     message << deviceMap;
     QDBusConnection::sessionBus().send(message);
 
     if (device->state() != NetworkManager::Device::Activated) {
         QTimer::singleShot(100, this, SLOT(updateConnectingState()));
     }
 }
 
 uint FakeNetwork::CheckConnectivity() const
 {
     return m_connectivity;
 }
 
 void FakeNetwork::DeactivateConnection(const QDBusObjectPath &active_connection)
 {
     ActiveConnection *activeConnection = m_activeConnections.value(active_connection);
     if (activeConnection) {
         activeConnection->setState(NetworkManager::ActiveConnection::Deactivating);
 
         QVariantMap activeConnectionMap;
         activeConnectionMap.insert(QLatin1String("State"), NetworkManager::ActiveConnection::Deactivating);
 
         activeConnection->setState(NetworkManager::ActiveConnection::Activated);
         QDBusMessage message = QDBusMessage::createSignal(activeConnection->activeConnectionPath(), QLatin1String("org.kde.fakenetwork.Connection.Active"), QLatin1String("PropertiesChanged"));
         message << activeConnectionMap;
         QDBusConnection::sessionBus().send(message);
 
         QDBusMessage message2 = QDBusMessage::createSignal(activeConnection->activeConnectionPath(), QLatin1String("org.kde.fakenetwork.Connection.Active"), QLatin1String("StateChanged"));
         message2 << (uint)4 << (uint)2; // NM_ACTIVE_CONNECTION_STATE_DEACTIVATED << NM_ACTIVE_CONNECTION_STATE_REASON_USER_DISCONNECTED
         QDBusConnection::sessionBus().send(message2);
 
         Device *device = m_devices.value(activeConnection->devices().first());
         if (device) {
             m_deactivatedDevice = device->devicePath();
             device->setState(NetworkManager::Device::Deactivating);
             QTimer::singleShot(100, this, SLOT(updateDeactivatingState()));
         }
 
         // Update FakeNetwork state, connectivity, primary connection
         m_connectivity = NetworkManager::Connectivity::NoConnectivity;
         m_primaryConnection = QDBusObjectPath("/");
         m_state = 20;
         QVariantMap networkMap;
         networkMap.insert(QLatin1String("Connectivity"), m_connectivity);
         networkMap.insert(QLatin1String("PrimaryConnection"), QVariant::fromValue(m_primaryConnection));
         networkMap.insert(QLatin1String("State"), m_state);
 
         message = QDBusMessage::createSignal(QLatin1String("/org/kde/fakenetwork"), QLatin1String("org.kde.fakenetwork"), QLatin1String("PropertiesChanged"));
         message << networkMap;
         QDBusConnection::sessionBus().send(message);
 
         Q_EMIT StateChanged(m_state);
     }
 }
 
 void FakeNetwork::updateDeactivatingState()
 {
     QVariantMap deviceMap;
     Device *device = m_devices.value(QDBusObjectPath(m_deactivatedDevice));
     ActiveConnection *activeConnection = static_cast<ActiveConnection *>(QDBusConnection::sessionBus().objectRegisteredAt(device->activeConnection().path()));
     if (activeConnection) {
         QVariantMap activeConnectionMap;
         activeConnectionMap.insert(QLatin1String("State"), NetworkManager::ActiveConnection::Deactivated);
 
         activeConnection->setState(NetworkManager::ActiveConnection::Activated);
         QDBusMessage message = QDBusMessage::createSignal(activeConnection->activeConnectionPath(), QLatin1String("org.kde.fakenetwork.Connection.Active"), QLatin1String("PropertiesChanged"));
         message << activeConnectionMap;
         QDBusConnection::sessionBus().send(message);
 
         QDBusMessage message2 = QDBusMessage::createSignal(activeConnection->activeConnectionPath(), QLatin1String("org.kde.fakenetwork.Connection.Active"), QLatin1String("StateChanged"));
         message2 << (uint)3 << (uint)2; // NM_ACTIVE_CONNECTION_STATE_DEACTIVATING << NM_ACTIVE_CONNECTION_STATE_REASON_USER_DISCONNECTED
         QDBusConnection::sessionBus().send(message2);
 
         removeActiveConnection(QDBusObjectPath(activeConnection->activeConnectionPath()));
     }
 
     device->setActiveConnection(QLatin1String("/"));
     device->setState(NetworkManager::Device::Disconnected);
     // TODO: set dhcp4Config, dhcp6Config, ip4Config, ip6Config
     // IP Interface is usually same as interface
     device->setIpInterface("");
     // Set some IP address
     device->setIpv4Address(0);
 
     deviceMap.insert(QLatin1String("ActiveConnection"), device->activeConnection().path());
     deviceMap.insert(QLatin1String("IpInterface"), device->ipInterface());
     deviceMap.insert(QLatin1String("Ip4Address"), device->ip4Address());
     deviceMap.insert(QLatin1String("State"), device->state());
 
     QDBusMessage message = QDBusMessage::createSignal(device->devicePath(), device->deviceInterface(), QLatin1String("PropertiesChanged"));
     message << deviceMap;
     QDBusConnection::sessionBus().send(message);
 }
 
 QDBusObjectPath FakeNetwork::GetDeviceByIpIface(const QString &iface)
 {
     // TODO
     return QDBusObjectPath();
 }
 
 QList< QDBusObjectPath > FakeNetwork::GetDevices() const
 {
     return m_devices.keys();
 }
 
 void FakeNetwork::onConnectionAdded(const QDBusObjectPath &connection)
 {
     Connection *newConnection = static_cast<Connection *>(QDBusConnection::sessionBus().objectRegisteredAt(connection.path()));
     if (newConnection) {
         NMVariantMapMap settings = newConnection->GetSettings();
         NetworkManager::ConnectionSettings::ConnectionType type = NetworkManager::ConnectionSettings::typeFromString(settings.value(QLatin1String("connection")).value(QLatin1String("type")).toString());
         if (!m_devices.isEmpty()) {
             Device *selectedDevice = nullptr;
-            Q_FOREACH (Device * device, m_devices.values()) {
+            for (Device *device : qAsConst(m_devices)) {
                 if (type == NetworkManager::ConnectionSettings::Wired && device->deviceType() == NetworkManager::Device::Ethernet) {
                     selectedDevice = device;
                     device->addAvailableConnection(connection);
                     break;
                 } else if (type == NetworkManager::ConnectionSettings::Wireless && device->deviceType() == NetworkManager::Device::Wifi) {
                     selectedDevice = device;
                     // TODO
                     break;
                 }
             }
 
             if (selectedDevice) {
                 QVariantMap map;
                 map.insert(QLatin1String("AvailableConnections"), QVariant::fromValue<QList<QDBusObjectPath> >(selectedDevice->availableConnections()));
 
                 QDBusMessage message = QDBusMessage::createSignal(selectedDevice->devicePath(), selectedDevice->deviceInterface(), QLatin1String("PropertiesChanged"));
                 message << map;
                 QDBusConnection::sessionBus().send(message);
             }
         }
     }
 }
 
 void FakeNetwork::onConnectionRemoved(const QDBusObjectPath &connection)
 {
-    Q_FOREACH (Device * device, m_devices.values()) {
+    for (Device *device : qAsConst(m_devices)) {
         if (device && device->availableConnections().contains(connection)) {
             device->removeAvailableConnection(connection);
 
             QVariantMap map;
             map.insert(QLatin1String("AvailableConnections"), QVariant::fromValue<QList<QDBusObjectPath> >(device->availableConnections()));
 
             QDBusMessage message = QDBusMessage::createSignal(device->devicePath(), device->deviceInterface(), QLatin1String("PropertiesChanged"));
             message << map;
             QDBusConnection::sessionBus().send(message);
         }
     }
 }
 
 void FakeNetwork::removeActiveConnection(const QDBusObjectPath &activeConnection)
 {
     delete m_activeConnections.value(activeConnection);
     m_activeConnections.remove(activeConnection);
     QDBusConnection::sessionBus().unregisterObject(activeConnection.path());
 
     QVariantMap map;
     map.insert(QLatin1String("ActiveConnections"), QVariant::fromValue<QList<QDBusObjectPath> >(m_activeConnections.keys()));
     Q_EMIT PropertiesChanged(map);
 }
diff --git a/src/fakenetwork/settings.cpp b/src/fakenetwork/settings.cpp
index 6c7b4e7..a37e13b 100644
--- a/src/fakenetwork/settings.cpp
+++ b/src/fakenetwork/settings.cpp
@@ -1,96 +1,97 @@
 /*
     SPDX-FileCopyrightText: 2014 Jan Grulich <jgrulich@redhat.com>
 
     SPDX-License-Identifier: LGPL-2.1-only OR LGPL-3.0-only OR LicenseRef-KDE-Accepted-LGPL
 */
 
 #include "settings.h"
 
 #include <QtDBus>
 
 Settings::Settings(QObject *parent)
     : QObject(parent)
     , m_canModify(true)
     , m_hostname(QLatin1String("fake-hostname"))
     , m_connectionCounter(0)
 {
     qDBusRegisterMetaType<NMVariantMapMap>();
 }
 
 Settings::~Settings()
 {
-    Q_FOREACH (const QDBusObjectPath & connection, m_connections.keys()) {
+    for (auto it =  m_connections.cbegin(); it != m_connections.cend(); ++it) {
+        const QDBusObjectPath &connection = it.key();
         QDBusConnection::sessionBus().unregisterObject(connection.path());
         Q_EMIT ConnectionRemoved(connection);
     }
 
     qDeleteAll(m_connections);
 }
 
 bool Settings::canModify() const
 {
     return m_canModify;
 }
 
 QList< QDBusObjectPath > Settings::connections() const
 {
     return m_connections.keys();
 }
 
 QString Settings::hostname() const
 {
     return m_hostname;
 }
 
 QDBusObjectPath Settings::AddConnection(const NMVariantMapMap &connection)
 {
     Connection *newConnection = new Connection(this, connection);
     QString newConnectionPath = QString("/org/kde/fakenetwork/Settings/") + QString::number(m_connectionCounter++);
     newConnection->setConnectionPath(newConnectionPath);
     m_connections.insert(QDBusObjectPath(newConnectionPath), newConnection);
     QDBusConnection::sessionBus().registerObject(newConnectionPath, newConnection, QDBusConnection::ExportScriptableContents);
 
     connect(newConnection, &Connection::connectionRemoved, this, &Settings::onConnectionRemoved);
 
     Q_EMIT NewConnection(QDBusObjectPath(newConnectionPath));
     // Send it for FakeNetwork separately to get AvailableConnections signal after NewConnection
     Q_EMIT connectionAdded(QDBusObjectPath(newConnectionPath));
 
     return QDBusObjectPath(newConnectionPath);
 }
 
 QDBusObjectPath Settings::AddConnectionUnsaved(const NMVariantMapMap &connection)
 {
     // TODO
     return QDBusObjectPath();
 }
 
 QDBusObjectPath Settings::GetConnectionByUuid(const QString &uuid)
 {
     // TODO
     return QDBusObjectPath();
 }
 
 QList< QDBusObjectPath > Settings::ListConnections()
 {
     return m_connections.keys();
 }
 
 void Settings::SaveHostname(const QString &hostname)
 {
     m_hostname = hostname;
 }
 
 void Settings::onConnectionRemoved(const QDBusObjectPath &connectionPath)
 {
     Connection *connection = m_connections.value(connectionPath);
 
     if (connection) {
         QDBusConnection::sessionBus().unregisterObject(connectionPath.path());
         Q_EMIT ConnectionRemoved(connectionPath);
         // Send it for FakeNetwork separately to get AvailableConnections signal after ConnectionRemoved
         Q_EMIT connectionRemoved(connectionPath);
         m_connections.remove(QDBusObjectPath(connectionPath));
         delete connection;
     }
 }
diff --git a/src/fakenetwork/wirelessdevice.cpp b/src/fakenetwork/wirelessdevice.cpp
index 9e93e57..7b744ee 100644
--- a/src/fakenetwork/wirelessdevice.cpp
+++ b/src/fakenetwork/wirelessdevice.cpp
@@ -1,137 +1,138 @@
 /*
     SPDX-FileCopyrightText: 2014 Jan Grulich <jgrulich@redhat.com>
 
     SPDX-License-Identifier: LGPL-2.1-only OR LGPL-3.0-only OR LicenseRef-KDE-Accepted-LGPL
 */
 
 #include "wirelessdevice.h"
 
 #include <QDBusConnection>
 
 WirelessDevice::WirelessDevice(QObject *parent)
     : Device(parent)
     , m_activeAccessPoint(QDBusObjectPath("/"))
     , m_bitrate(0)
     , m_mode(2)
     , m_wirelessCapabilities(0)
     , m_accessPointCounter(0)
 {
 }
 
 WirelessDevice::~WirelessDevice()
 {
-    Q_FOREACH (const QDBusObjectPath & ap, m_accessPoints.keys()) {
+    for (auto it = m_accessPoints.cbegin(); it != m_accessPoints.cend(); ++it) {
+         const QDBusObjectPath &ap = it.key();
         QDBusConnection::sessionBus().unregisterObject(ap.path());
         Q_EMIT AccessPointRemoved(ap);
     }
 
     qDeleteAll(m_accessPoints);
 
     QVariantMap map;
     map.insert(QLatin1String("AvailableConnections"), QVariant::fromValue<QList<QDBusObjectPath> >(QList<QDBusObjectPath>()));
     Q_EMIT PropertiesChanged(map);
 }
 
 QList< QDBusObjectPath > WirelessDevice::accessPoints() const
 {
     return m_accessPoints.keys();
 }
 
 QDBusObjectPath WirelessDevice::activeAccessPoint() const
 {
     return m_activeAccessPoint;
 }
 
 uint WirelessDevice::bitrate() const
 {
     return m_bitrate;
 }
 
 QString WirelessDevice::hwAddress() const
 {
     return m_hwAddress;
 }
 
 uint WirelessDevice::mode() const
 {
     return m_mode;
 }
 
 QString WirelessDevice::permHwAddress() const
 {
     return m_permHwAddress;
 }
 
 uint WirelessDevice::wirelessCapabilities() const
 {
     return m_wirelessCapabilities;
 }
 
 void WirelessDevice::addAccessPoint(AccessPoint *accessPoint)
 {
     QString newApPath = QString("/org/kde/fakenetwork/AccessPoints/") + QString::number(m_accessPointCounter++);
     accessPoint->setAccessPointPath(newApPath);
     m_accessPoints.insert(QDBusObjectPath(newApPath), accessPoint);
     QDBusConnection::sessionBus().registerObject(newApPath, accessPoint, QDBusConnection::ExportScriptableContents);
 
     Q_EMIT AccessPointAdded(QDBusObjectPath(newApPath));
 }
 
 void WirelessDevice::removeAccessPoint(AccessPoint *accessPoint)
 {
     m_accessPoints.remove(QDBusObjectPath(accessPoint->accessPointPath()));
 
     Q_EMIT AccessPointRemoved(QDBusObjectPath(accessPoint->accessPointPath()));
 }
 
 void WirelessDevice::setActiveAccessPoint(const QString &activeAccessPoint)
 {
     m_activeAccessPoint = QDBusObjectPath(activeAccessPoint);
 }
 
 void WirelessDevice::setBitrate(uint bitrate)
 {
     m_bitrate = bitrate;
 }
 
 void WirelessDevice::setHwAddress(const QString &hwAddress)
 {
     m_hwAddress = hwAddress;
 }
 
 void WirelessDevice::setMode(uint mode)
 {
     m_mode = mode;
 }
 
 void WirelessDevice::setPermHwAddress(const QString &permHwAddress)
 {
     m_permHwAddress = permHwAddress;
 }
 
 void WirelessDevice::setState(uint state)
 {
     Device::setState(state);
 
     // TODO: set speed, etc.
 }
 
 void WirelessDevice::setWirelessCapabilities(uint capabilities)
 {
     m_wirelessCapabilities = capabilities;
 }
 
 QList< QDBusObjectPath > WirelessDevice::GetAccessPoints()
 {
     return m_accessPoints.keys();
 }
 
 QList< QDBusObjectPath > WirelessDevice::GetAllAccessPoints()
 {
     return m_accessPoints.keys();
 }
 
 void WirelessDevice::RequestScan(const QVariantMap &options)
 {
     Q_UNUSED(options);
 }
diff --git a/src/settings.cpp b/src/settings.cpp
index cbbebdf..1993338 100644
--- a/src/settings.cpp
+++ b/src/settings.cpp
@@ -1,261 +1,261 @@
 /*
     SPDX-FileCopyrightText: 2011-2013 Lamarque Souza <lamarque@kde.org>
     SPDX-FileCopyrightText: 2013 Jan Grulich <jgrulich@redhat.com>
 
     SPDX-License-Identifier: LGPL-2.1-only OR LGPL-3.0-only OR LicenseRef-KDE-Accepted-LGPL
 */
 
 #include "settings.h"
 #include "settings_p.h"
 #include "macros.h"
 #include "connection.h"
 #include "manager_p.h"
 
 #include <QDBusObjectPath>
 
 #include <nm-setting-connection.h>
 
 #include "nmdebug.h"
 
 //NM_GLOBAL_STATIC(NetworkManager::SettingsPrivate, globalSettings)
 Q_GLOBAL_STATIC(NetworkManager::SettingsPrivate, globalSettings)
 
 NetworkManager::SettingsPrivate::SettingsPrivate()
 #ifdef NMQT_STATIC
     : iface(NetworkManagerPrivate::DBUS_SERVICE, NetworkManagerPrivate::DBUS_SETTINGS_PATH, QDBusConnection::sessionBus())
 #else
     : iface(NetworkManagerPrivate::DBUS_SERVICE, NetworkManagerPrivate::DBUS_SETTINGS_PATH, QDBusConnection::systemBus())
 #endif
     , m_canModify(true)
 {
     QDBusConnection::systemBus().connect(NetworkManagerPrivate::DBUS_SERVICE, NetworkManagerPrivate::DBUS_SETTINGS_PATH, NetworkManagerPrivate::FDO_DBUS_PROPERTIES,
                                          QLatin1String("PropertiesChanged"), this, SLOT(dbusPropertiesChanged(QString,QVariantMap,QStringList)));
     connect(&iface, &OrgFreedesktopNetworkManagerSettingsInterface::NewConnection,
             this, &SettingsPrivate::onConnectionAdded);
     connect(&iface, &OrgFreedesktopNetworkManagerSettingsInterface::ConnectionRemoved,
             this, static_cast<void (SettingsPrivate::*)(const QDBusObjectPath &)>(&SettingsPrivate::onConnectionRemoved));
     init();
     // This class is a friend of NetworkManagerPrivate thus initted there too
     // because of the init chain we must follow,
     // But if this class is used first we need to make sure the
     // NetworkManagerPrivate also get created so we have its signals for
     // when the daemon dies, we just can not call it directly here or
     // we will have a constructor infinite loop
     QTimer::singleShot(0, this, SLOT(initNotifier()));
 }
 
 void NetworkManager::SettingsPrivate::init()
 {
-    QList<QDBusObjectPath> connectionList = iface.connections();
+    const QList<QDBusObjectPath> connectionList = iface.connections();
     qCDebug(NMQT) << "Connections list";
-    Q_FOREACH (const QDBusObjectPath & connection, connectionList) {
+    for (const QDBusObjectPath &connection : connectionList) {
         if (!connections.contains(connection.path())) {
             connections.insert(connection.path(), Connection::Ptr());
             Q_EMIT connectionAdded(connection.path());
             qCDebug(NMQT) << " " << connection.path();
         }
     }
 
     // Get all Setting's properties at once
     QVariantMap initialProperties = NetworkManagerPrivate::retrieveInitialProperties(iface.staticInterfaceName(), NetworkManagerPrivate::DBUS_SETTINGS_PATH);
     if (!initialProperties.isEmpty()) {
         propertiesChanged(initialProperties);
     }
 }
 
 NetworkManager::Connection::List NetworkManager::SettingsPrivate::listConnections()
 {
     NetworkManager::Connection::List list;
     QMap<QString, Connection::Ptr>::const_iterator i = connections.constBegin();
     while (i != connections.constEnd()) {
         NetworkManager::Connection::Ptr connection = findRegisteredConnection(i.key());
         if (connection) {
             list << connection;
         }
         ++i;
     }
     return list;
 }
 
 NetworkManager::Connection::Ptr NetworkManager::SettingsPrivate::findConnectionByUuid(const QString &uuid)
 {
     QMap<QString, Connection::Ptr>::const_iterator i = connections.constBegin();
     while (i != connections.constEnd()) {
         NetworkManager::Connection::Ptr connection = findRegisteredConnection(i.key());
         if (connection && connection->uuid() == uuid) {
             return connection;
         }
         ++i;
     }
 
     return NetworkManager::Connection::Ptr();
 }
 
 QString NetworkManager::SettingsPrivate::hostname() const
 {
     return m_hostname;
 }
 
 bool NetworkManager::SettingsPrivate::canModify() const
 {
     return m_canModify;
 }
 
 QDBusPendingReply<QDBusObjectPath> NetworkManager::SettingsPrivate::addConnection(const NMVariantMapMap &connection)
 {
     return iface.AddConnection(connection);
 }
 
 QDBusPendingReply<QDBusObjectPath> NetworkManager::SettingsPrivate::addConnectionUnsaved(const NMVariantMapMap &connection)
 {
     return iface.AddConnectionUnsaved(connection);
 }
 
 QDBusPendingReply<bool, QStringList> NetworkManager::SettingsPrivate::loadConnections(const QStringList &filenames)
 {
     return iface.LoadConnections(filenames);
 }
 
 QDBusPendingReply<bool> NetworkManager::SettingsPrivate::reloadConnections()
 {
     return iface.ReloadConnections();
 }
 
 void NetworkManager::SettingsPrivate::initNotifier()
 {
     notifier();
 }
 
 void NetworkManager::SettingsPrivate::saveHostname(const QString &hostname)
 {
     iface.SaveHostname(hostname);
 }
 
 void NetworkManager::SettingsPrivate::dbusPropertiesChanged(const QString &interfaceName, const QVariantMap &properties, const QStringList &invalidatedProperties)
 {
     Q_UNUSED(invalidatedProperties);
     if (interfaceName == QLatin1String("org.freedesktop.NetworkManager.Settings")) {
         propertiesChanged(properties);
     }
 }
 
 void NetworkManager::SettingsPrivate::propertiesChanged(const QVariantMap &properties)
 {
     QVariantMap::const_iterator it = properties.constBegin();
     while (it != properties.constEnd()) {
         const QString property = it.key();
         if (property == QLatin1String("CanModify")) {
             m_canModify = it->toBool();
             Q_EMIT canModifyChanged(m_canModify);
         } else if (property == QLatin1String("Hostname")) {
             m_hostname = it->toString();
             Q_EMIT hostnameChanged(m_hostname);
         } else if (property == QLatin1String("Connections")) {
             //will never get here in runtime NM < 0.9.10
             // TODO some action??
         } else {
             qCWarning(NMQT) << Q_FUNC_INFO << "Unhandled property" << property;
         }
         ++it;
     }
 }
 
 void NetworkManager::SettingsPrivate::onConnectionAdded(const QDBusObjectPath &path)
 {
     const QString id = path.path();
     if (connections.contains(id)) {
         return;
     }
     connections.insert(id, Connection::Ptr());
     Q_EMIT connectionAdded(id);
 }
 
 NetworkManager::Connection::Ptr NetworkManager::SettingsPrivate::findRegisteredConnection(const QString &path)
 {
     Connection::Ptr ret;
     if (!path.isEmpty()) {
         bool contains = connections.contains(path);
         if (contains && connections.value(path)) {
             ret = connections.value(path);
         } else {
             ret = Connection::Ptr(new Connection(path), &QObject::deleteLater);
             connections[path] = ret;
             connect(ret.data(), SIGNAL(removed(QString)), this, SLOT(onConnectionRemoved(QString)));
             if (!contains) {
                 Q_EMIT connectionAdded(path);
             }
         }
     }
     return ret;
 }
 
 void NetworkManager::SettingsPrivate::onConnectionRemoved(const QDBusObjectPath &path)
 {
     onConnectionRemoved(path.path());
 }
 
 void NetworkManager::SettingsPrivate::onConnectionRemoved(const QString &path)
 {
     connections.remove(path);
     Q_EMIT connectionRemoved(path);
 }
 
 void NetworkManager::SettingsPrivate::daemonUnregistered()
 {
     connections.clear();
 }
 
 NetworkManager::Connection::List NetworkManager::listConnections()
 {
     return globalSettings->listConnections();
 }
 
 NetworkManager::Connection::Ptr NetworkManager::findConnectionByUuid(const QString &uuid)
 {
     return globalSettings->findConnectionByUuid(uuid);
 }
 
 NetworkManager::Connection::Ptr NetworkManager::findConnection(const QString &path)
 {
     return globalSettings->findRegisteredConnection(path);
 }
 
 QDBusPendingReply<QDBusObjectPath> NetworkManager::addConnection(const NMVariantMapMap &connection)
 {
     return globalSettings->addConnection(connection);
 }
 
 QDBusPendingReply<QDBusObjectPath> NetworkManager::addConnectionUnsaved(const NMVariantMapMap &connection)
 {
     return globalSettings->addConnectionUnsaved(connection);
 }
 
 QDBusPendingReply< bool, QStringList > NetworkManager::loadConnections(const QStringList &filenames)
 {
     return globalSettings->loadConnections(filenames);
 }
 
 QDBusPendingReply< bool > NetworkManager::reloadConnections()
 {
     return globalSettings->reloadConnections();
 }
 
 void NetworkManager::saveHostname(const QString &hostname)
 {
     globalSettings->saveHostname(hostname);
 }
 
 bool NetworkManager::canModify()
 {
     return globalSettings->canModify();
 }
 
 QString NetworkManager::hostname()
 {
     return globalSettings->hostname();
 }
 
 NetworkManager::SettingsNotifier *NetworkManager::settingsNotifier()
 {
     return globalSettings;
 }
diff --git a/src/wirelessnetwork.cpp b/src/wirelessnetwork.cpp
index 0efaad3..4edb75c 100644
--- a/src/wirelessnetwork.cpp
+++ b/src/wirelessnetwork.cpp
@@ -1,134 +1,134 @@
 /*
     SPDX-FileCopyrightText: 2009, 2011 Will Stephenson <wstephenson@kde.org>
     SPDX-FileCopyrightText: 2013 Jan Grulich <jgrulich@redhat.com>
 
     SPDX-License-Identifier: LGPL-2.1-only OR LGPL-3.0-only OR LicenseRef-KDE-Accepted-LGPL
 */
 
 #include "wirelessnetwork.h"
 #include "wirelessnetwork_p.h"
 
 #include "wirelessdevice.h"
 #include "manager.h"
 
 NetworkManager::WirelessNetworkPrivate::WirelessNetworkPrivate(WirelessNetwork *q, WirelessDevice *device)
     : q_ptr(q)
     , wirelessNetworkInterface(device)
 {
     QObject::connect(device, SIGNAL(accessPointAppeared(QString)),
                      q, SLOT(accessPointAppeared(QString)));
     QObject::connect(device, SIGNAL(accessPointDisappeared(QString)),
                      q, SLOT(accessPointDisappeared(QString)));
 }
 
 NetworkManager::WirelessNetworkPrivate::~WirelessNetworkPrivate()
 {
 }
 
 void NetworkManager::WirelessNetworkPrivate::addAccessPointInternal(const NetworkManager::AccessPoint::Ptr &accessPoint)
 {
     Q_Q(WirelessNetwork);
 
     QObject::connect(accessPoint.data(), SIGNAL(signalStrengthChanged(int)),
                      q, SLOT(updateStrength()));
     aps.insert(accessPoint->uni(), accessPoint);
     updateStrength();
 }
 
 void NetworkManager::WirelessNetworkPrivate::accessPointAppeared(const QString &uni)
 {
     if (!aps.contains(uni) && wirelessNetworkInterface) {
         NetworkManager::AccessPoint::Ptr accessPoint = wirelessNetworkInterface->findAccessPoint(uni);
         if (accessPoint && accessPoint->ssid() == ssid) {
             addAccessPointInternal(accessPoint);
         }
     }
 }
 
 void NetworkManager::WirelessNetworkPrivate::accessPointDisappeared(const QString &uni)
 {
     Q_Q(WirelessNetwork);
     aps.remove(uni);
     if (aps.isEmpty()) {
         Q_EMIT q->disappeared(ssid);
     } else {
         updateStrength();
     }
 }
 
 void NetworkManager::WirelessNetworkPrivate::updateStrength()
 {
     Q_Q(WirelessNetwork);
 
     int maximumStrength = -1;
     NetworkManager::AccessPoint::Ptr strongestAp;
-    Q_FOREACH (const NetworkManager::AccessPoint::Ptr & iface, aps) {
+    for (const NetworkManager::AccessPoint::Ptr &iface : qAsConst(aps)) {
         if (maximumStrength <= iface->signalStrength()) {
             maximumStrength = iface->signalStrength();
             strongestAp = iface;
         }
     }
     if (maximumStrength != strength) {
         strength = maximumStrength;
         Q_EMIT q->signalStrengthChanged(strength);
     }
 
     if (strongestAp && referenceAp != strongestAp) {
         referenceAp = strongestAp;
         Q_EMIT q->referenceAccessPointChanged(referenceAp->uni());
     }
     //TODO: update the networks delayed
     //kDebug() << "update strength" << ssid << strength;
 }
 
 NetworkManager::WirelessNetwork::WirelessNetwork(const AccessPoint::Ptr &accessPoint, WirelessDevice *device) :
     d_ptr(new WirelessNetworkPrivate(this, device))
 {
     Q_D(WirelessNetwork);
 
     d->strength = -1;
     d->ssid = accessPoint->ssid();
     d->addAccessPointInternal(accessPoint);
 }
 
 NetworkManager::WirelessNetwork::~WirelessNetwork()
 {
     delete d_ptr;
 }
 
 QString NetworkManager::WirelessNetwork::ssid() const
 {
     Q_D(const WirelessNetwork);
     return d->ssid;
 }
 
 int NetworkManager::WirelessNetwork::signalStrength() const
 {
     Q_D(const WirelessNetwork);
     return d->strength;
 }
 
 NetworkManager::AccessPoint::Ptr NetworkManager::WirelessNetwork::referenceAccessPoint() const
 {
     Q_D(const WirelessNetwork);
     return d->referenceAp;
 }
 
 NetworkManager::AccessPoint::List NetworkManager::WirelessNetwork::accessPoints() const
 {
     Q_D(const WirelessNetwork);
     return d->aps.values();
 }
 
 QString NetworkManager::WirelessNetwork::device() const
 {
     Q_D(const WirelessNetwork);
 
     if (d->wirelessNetworkInterface) {
         return d->wirelessNetworkInterface->uni();
     } else {
         return QString();
     }
 }
 
 #include "moc_wirelessnetwork.cpp"