diff --git a/src/solid/devices/backends/upower/upowermanager.cpp b/src/solid/devices/backends/upower/upowermanager.cpp
index 4ca7149..8565dd5 100644
--- a/src/solid/devices/backends/upower/upowermanager.cpp
+++ b/src/solid/devices/backends/upower/upowermanager.cpp
@@ -1,164 +1,165 @@
 /*
     SPDX-FileCopyrightText: 2010 Michael Zanetti <mzanetti@kde.org>
     SPDX-FileCopyrightText: 2010 Lukas Tinkl <ltinkl@redhat.com>
 
     SPDX-License-Identifier: LGPL-2.1-only OR LGPL-3.0-only OR LicenseRef-KDE-Accepted-LGPL
 */
 
 #include "upowermanager.h"
 #include "upowerdevice.h"
 #include "upower.h"
 
 #include <QDBusReply>
 #include <QDebug>
 #include <QDBusMetaType>
 #include <QDBusConnectionInterface>
 
 #include "../shared/rootdevice.h"
 
 using namespace Solid::Backends::UPower;
 using namespace Solid::Backends::Shared;
 
 UPowerManager::UPowerManager(QObject *parent)
     : Solid::Ifaces::DeviceManager(parent),
       m_manager(UP_DBUS_SERVICE,
                 UP_DBUS_PATH,
                 UP_DBUS_INTERFACE,
                 QDBusConnection::systemBus())
 {
     m_supportedInterfaces
             << Solid::DeviceInterface::GenericInterface
             << Solid::DeviceInterface::Battery;
 
     qDBusRegisterMetaType<QList<QDBusObjectPath> >();
     qDBusRegisterMetaType<QVariantMap>();
 
     bool serviceFound = m_manager.isValid();
     if (!serviceFound) {
         // find out whether it will be activated automatically
         QDBusMessage message = QDBusMessage::createMethodCall("org.freedesktop.DBus",
                                "/org/freedesktop/DBus",
                                "org.freedesktop.DBus",
                                "ListActivatableNames");
 
         QDBusReply<QStringList> reply = QDBusConnection::systemBus().call(message);
         if (reply.isValid() && reply.value().contains(UP_DBUS_SERVICE)) {
             QDBusConnection::systemBus().interface()->startService(UP_DBUS_SERVICE);
             serviceFound = true;
         }
     }
 
     if (serviceFound) {
         if (m_manager.metaObject()->indexOfSignal("DeviceAdded(QDBusObjectPath)") != -1) {
             // for UPower >= 0.99.0, changed signature :o/
             connect(&m_manager, SIGNAL(DeviceAdded(QDBusObjectPath)),
                     this, SLOT(onDeviceAdded(QDBusObjectPath)));
             connect(&m_manager, SIGNAL(DeviceRemoved(QDBusObjectPath)),
                     this, SLOT(onDeviceRemoved(QDBusObjectPath)));
         } else {
             connect(&m_manager, SIGNAL(DeviceAdded(QString)),
                     this, SIGNAL(deviceAdded(QString)));
             connect(&m_manager, SIGNAL(DeviceRemoved(QString)),
                     this, SIGNAL(deviceRemoved(QString)));
         }
     }
 }
 
 UPowerManager::~UPowerManager()
 {
 }
 
 QObject *UPowerManager::createDevice(const QString &udi)
 {
     if (udi == udiPrefix()) {
         RootDevice *root = new RootDevice(udiPrefix());
 
         root->setProduct(tr("Power Management"));
         root->setDescription(tr("Batteries and other sources of power"));
         root->setIcon("preferences-system-power-management");
 
         return root;
 
     } else if (allDevices().contains(udi)) {
         return new UPowerDevice(udi);
 
     } else {
         return nullptr;
     }
 }
 
 QStringList UPowerManager::devicesFromQuery(const QString &parentUdi, Solid::DeviceInterface::Type type)
 {
-    QStringList allDev = allDevices();
+    const QStringList allDev = allDevices();
     QStringList result;
 
     if (!parentUdi.isEmpty()) {
-        Q_FOREACH (const QString &udi, allDev) {
+        for (const QString &udi : allDev) {
             if (udi == udiPrefix()) {
                 continue;
             }
 
             UPowerDevice device(udi);
             if (device.queryDeviceInterface(type) && device.parentUdi() == parentUdi) {
                 result << udi;
             }
         }
 
         return result;
     } else if (type != Solid::DeviceInterface::Unknown) {
-        Q_FOREACH (const QString &udi, allDev) {
+        for (const QString &udi : allDev) {
             if (udi == udiPrefix()) {
                 continue;
             }
 
             UPowerDevice device(udi);
             if (device.queryDeviceInterface(type)) {
                 result << udi;
             }
         }
 
         return result;
     } else {
         return allDev;
     }
 }
 
 QStringList UPowerManager::allDevices()
 {
     QDBusReply<QList<QDBusObjectPath> > reply = m_manager.call("EnumerateDevices");
 
     if (!reply.isValid()) {
         qWarning() << Q_FUNC_INFO << " error: " << reply.error().name();
         return QStringList();
     }
 
     QStringList retList;
     retList << udiPrefix();
 
-    Q_FOREACH (const QDBusObjectPath &path, reply.value()) {
+    const auto pathList = reply.value();
+    for (const QDBusObjectPath &path : pathList) {
         retList << path.path();
     }
 
     return retList;
 }
 
 QSet< Solid::DeviceInterface::Type > UPowerManager::supportedInterfaces() const
 {
     return m_supportedInterfaces;
 }
 
 QString UPowerManager::udiPrefix() const
 {
     return UP_UDI_PREFIX;
 }
 
 void UPowerManager::onDeviceAdded(const QDBusObjectPath &path)
 {
     emit deviceAdded(path.path());
 }
 
 void UPowerManager::onDeviceRemoved(const QDBusObjectPath &path)
 {
     emit deviceRemoved(path.path());
 }
 
diff --git a/src/solid/devices/backends/win/winblock.cpp b/src/solid/devices/backends/win/winblock.cpp
index b7bf497..3bf18e8 100644
--- a/src/solid/devices/backends/win/winblock.cpp
+++ b/src/solid/devices/backends/win/winblock.cpp
@@ -1,177 +1,177 @@
 /*
     SPDX-FileCopyrightText: 2013 Patrick von Reth <vonreth@kde.org>
 
     SPDX-License-Identifier: LGPL-2.1-only OR LGPL-3.0-only OR LicenseRef-KDE-Accepted-LGPL
 */
 
 #include "winblock.h"
 
 #include <QSettings>
 #include <QDebug>
 
 using namespace Solid::Backends::Win;
 
 #include <ntddcdrm.h>
 #include <ntddmmc.h>
 
 QMap<QString, QString> WinBlock::m_driveLetters = QMap<QString, QString>();
 QMap<QString, QSet<QString> > WinBlock::m_driveUDIS = QMap<QString, QSet<QString> >();
 QMap<QString, QString> WinBlock::m_virtualDrives = QMap<QString, QString>();
 
 WinBlock::WinBlock(WinDevice *device):
     WinInterface(device),
     m_major(-1),
     m_minor(-1)
 {
     if (m_device->type() == Solid::DeviceInterface::StorageVolume) {
         STORAGE_DEVICE_NUMBER info = WinDeviceManager::getDeviceInfo<STORAGE_DEVICE_NUMBER>(driveLetterFromUdi(m_device->udi()), IOCTL_STORAGE_GET_DEVICE_NUMBER);
         m_major = info.DeviceNumber;
         m_minor = info.PartitionNumber;
     } else if (m_device->type() == Solid::DeviceInterface::StorageDrive ||
                m_device->type() == Solid::DeviceInterface::OpticalDrive ||
                m_device->type() == Solid::DeviceInterface::OpticalDisc) {
         m_major = m_device->udi().mid(m_device->udi().length() - 1).toInt();
     } else {
         qFatal("Not implemented device type %i", m_device->type());
     }
 
 }
 
 WinBlock::~WinBlock()
 {
 }
 
 int WinBlock::deviceMajor() const
 {
     Q_ASSERT(m_major != -1);
     return m_major;
 }
 
 int WinBlock::deviceMinor() const
 {
     return m_minor;
 }
 
 QString WinBlock::device() const
 {
     return driveLetterFromUdi(m_device->udi());
 }
 
 QStringList WinBlock::drivesFromMask(const DWORD unitmask)
 {
     QStringList result;
     DWORD localUnitmask(unitmask);
     for (int i = 0; i <= 25; ++i) {
         if (0x01 == (localUnitmask & 0x1)) {
             result << QString("%1:").arg((char)(i + 'A'));
         }
         localUnitmask >>= 1;
     }
     return result;
 }
 
 QSet<QString> WinBlock::getUdis()
 {
     return updateUdiFromBitMask(GetLogicalDrives());
 }
 
 QString WinBlock::driveLetterFromUdi(const QString &udi)
 {
     if (!m_driveLetters.contains(udi)) {
         qWarning() << udi << "is not connected to a drive";
     }
     return m_driveLetters[udi];
 }
 
 QString WinBlock::udiFromDriveLetter(const QString &drive)
 {
     QString out;
     for (QMap<QString, QString>::const_iterator it = m_driveLetters.cbegin(); it != m_driveLetters.cend(); ++it) {
         if (it.value() == drive) {
             out = it.key();
             break;
         }
     }
     return out;
 }
 
 QString WinBlock::resolveVirtualDrive(const QString &drive)
 {
     return m_virtualDrives[drive];
 }
 
 QSet<QString> WinBlock::updateUdiFromBitMask(const DWORD unitmask)
 {
-    QStringList drives = drivesFromMask(unitmask);
+    const QStringList drives = drivesFromMask(unitmask);
     QSet<QString> list;
     wchar_t driveWCHAR[MAX_PATH];
     wchar_t bufferOut[MAX_PATH];
     QString dosPath;
-    foreach (const QString &drive, drives) {
+    for (const QString &drive : drives) {
         QSet<QString> udis;
         driveWCHAR[drive.toWCharArray(driveWCHAR)] = 0;
         if (GetDriveType(driveWCHAR) == DRIVE_REMOTE) { //network drive
             QSettings settings(QLatin1String("HKEY_CURRENT_USER\\Network\\") + drive.at(0), QSettings::NativeFormat);
             QString path = settings.value("RemotePath").toString();
             if (!path.isEmpty()) {
                 QString key = QLatin1String("/org/kde/solid/win/volume.virtual/") + drive.at(0);
                 m_virtualDrives[key] = path;
                 udis << key;
             }
 
         } else {
             QueryDosDeviceW(driveWCHAR, bufferOut, MAX_PATH);
             dosPath = QString::fromWCharArray(bufferOut);
             if (dosPath.startsWith("\\??\\")) { //subst junction
                 dosPath = dosPath.mid(4);
                 QString key = QLatin1String("/org/kde/solid/win/volume.virtual/") + drive.at(0);
                 m_virtualDrives[key] = dosPath;
                 udis << key;
             } else {
                 STORAGE_DEVICE_NUMBER info = WinDeviceManager::getDeviceInfo<STORAGE_DEVICE_NUMBER>(drive, IOCTL_STORAGE_GET_DEVICE_NUMBER);
 
                 switch (info.DeviceType) {
                 case FILE_DEVICE_DISK: {
                     udis << QString("/org/kde/solid/win/volume/disk#%1,partition#%2").arg(info.DeviceNumber).arg(info.PartitionNumber);
                     udis << QString("/org/kde/solid/win/storage/disk#%1").arg(info.DeviceNumber);
 
                 }
                 break;
                 case FILE_DEVICE_CD_ROM:
                 case FILE_DEVICE_DVD: {
                     udis << QString("/org/kde/solid/win/storage.cdrom/disk#%1").arg(info.DeviceNumber);
                     DISK_GEOMETRY_EX out = WinDeviceManager::getDeviceInfo<DISK_GEOMETRY_EX>(drive, IOCTL_DISK_GET_DRIVE_GEOMETRY_EX);
                     if (out.DiskSize.QuadPart != 0) {
                         udis << QString("/org/kde/solid/win/volume.cdrom/disk#%1").arg(info.DeviceNumber);
                     }
                 }
                 break;
                 default:
                     qDebug() << "unknown device" << drive << info.DeviceType << info.DeviceNumber << info.PartitionNumber;
                 }
             }
         }
         m_driveUDIS[drive] = udis;
-        foreach (const QString &s, udis) {
-            m_driveLetters[s] = drive;
+        for (const QString &str : qAsConst(udis)) {
+            m_driveLetters[str] = drive;
         }
         list += udis;
     }
     return list;
 }
 
 QSet<QString> WinBlock::getFromBitMask(const DWORD unitmask)
 {
     QSet<QString> list;
-    QStringList drives = drivesFromMask(unitmask);
-    foreach (const QString &drive, drives) {
+    const QStringList drives = drivesFromMask(unitmask);
+    for (const QString &drive : drives) {
         if (m_driveUDIS.contains(drive)) {
             list += m_driveUDIS[drive];
         } else {
             //we have to update the cache
             return updateUdiFromBitMask(unitmask);
         }
 
     }
     return list;
 }
diff --git a/src/solid/devices/backends/win/windevicemanager.cpp b/src/solid/devices/backends/win/windevicemanager.cpp
index d73c723..b33c415 100644
--- a/src/solid/devices/backends/win/windevicemanager.cpp
+++ b/src/solid/devices/backends/win/windevicemanager.cpp
@@ -1,227 +1,228 @@
 /*
     SPDX-FileCopyrightText: 2013 Patrick von Reth <vonreth@kde.org>
 
     SPDX-License-Identifier: LGPL-2.1-only OR LGPL-3.0-only OR LicenseRef-KDE-Accepted-LGPL
 */
 
 #include "windevicemanager.h"
 #include "windevicemanager_p.h"
 #include <solid/deviceinterface.h>
 #include "windevice.h"
 #include "winprocessor.h"
 #include "winblock.h"
 #include "winbattery.h"
 
 #include <dbt.h>
 
 #include <QDebug>
 
 using namespace Solid::Backends::Win;
 
 Q_GLOBAL_STATIC(SolidWinEventFilter,solidWineventFilter)
 
 SolidWinEventFilter *SolidWinEventFilter::instance()
 {
     return solidWineventFilter;
 }
 
 
 SolidWinEventFilter::SolidWinEventFilter():
     QObject()
     {
         wchar_t title[] = L"KDEWinDeviceManager";
 
         WNDCLASSEX wcex;
         ZeroMemory(&wcex, sizeof(wcex));
         wcex.cbSize = sizeof(WNDCLASSEX);
         wcex.lpfnWndProc    = SolidWinEventFilter::WndProc;
         wcex.hInstance      = (HINSTANCE)::GetModuleHandle(NULL);
         wcex.hbrBackground  = (HBRUSH)(COLOR_WINDOW);
         wcex.lpszClassName  = title;
         if (RegisterClassEx(&wcex) == 0) {
             qWarning() << "Failed to initialize KDEWinDeviceManager we will be unable to detect device changes";
             return;
         }
 
         m_windowID = CreateWindow(title, title, WS_ICONIC, 0, 0,
                                   CW_USEDEFAULT, 0, NULL, NULL, wcex.hInstance, NULL);
         if (m_windowID == NULL) {
             qWarning() << "Failed to initialize KDEWinDeviceManager we will be unable to detect device changes";
             return;
         }
         ShowWindow(m_windowID, SW_HIDE);
     }
 
     SolidWinEventFilter::~SolidWinEventFilter()
     {
         PostMessage(m_windowID, WM_CLOSE, 0, 0);
     }
 
     void SolidWinEventFilter::promoteAddedDevice(const QSet<QString> &udi)
     {
         emit deviceAdded(udi);
     }
 
     void SolidWinEventFilter::promoteRemovedDevice(const QSet<QString> &udi)
     {
         emit deviceRemoved(udi);
     }
 
     void SolidWinEventFilter::promotePowerChange()
     {
         emit powerChanged();
     }
 
     LRESULT CALLBACK SolidWinEventFilter::WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
     {
         //some parts of the code are based on http://www.codeproject.com/Articles/119168/Hardware-Change-Detection
         switch (message) {
         case WM_DEVICECHANGE: {
 
             if ((wParam == DBT_DEVICEARRIVAL) || (wParam == DBT_DEVICEREMOVECOMPLETE)) {
                 DEV_BROADCAST_HDR *header = reinterpret_cast<DEV_BROADCAST_HDR *>(lParam);
                 if (header->dbch_devicetype == DBT_DEVTYP_VOLUME) {
 
                     DEV_BROADCAST_VOLUME *devNot = reinterpret_cast<DEV_BROADCAST_VOLUME *>(lParam);
                     switch (wParam) {
 
                     case DBT_DEVICEREMOVECOMPLETE: {
                         QSet<QString> udis = WinBlock::getFromBitMask(devNot->dbcv_unitmask);
                         solidWineventFilter->promoteRemovedDevice(udis);
                     }
                         break;
                     case DBT_DEVICEARRIVAL: {
                         QSet<QString> udis = WinBlock::updateUdiFromBitMask(devNot->dbcv_unitmask);
                         solidWineventFilter->promoteAddedDevice(udis);
                     }
                         break;
                     }
                     break;
                 }
             }
         }
             break;
         case WM_POWERBROADCAST: {
             solidWineventFilter->promotePowerChange();
         }
             break;
         case WM_DESTROY: {
             PostQuitMessage(0);
         }
             break;
         default:
             return DefWindowProc(hWnd, message, wParam, lParam);
         }
         return 0;
     }
 
 
 
 
 WinDeviceManager::WinDeviceManager(QObject *parent)
     : DeviceManager(parent)
 {
 
     connect(solidWineventFilter, SIGNAL(deviceAdded(QSet<QString>)),this, SLOT(slotDeviceAdded(QSet<QString>)));
     connect(solidWineventFilter, SIGNAL(deviceRemoved(QSet<QString>)),this, SLOT(slotDeviceRemoved(QSet<QString>)));
 
     m_supportedInterfaces << Solid::DeviceInterface::GenericInterface
                              //                          << Solid::DeviceInterface::Block
                           << Solid::DeviceInterface::StorageAccess
                           << Solid::DeviceInterface::StorageDrive
                           << Solid::DeviceInterface::OpticalDrive
                           << Solid::DeviceInterface::StorageVolume
                           << Solid::DeviceInterface::OpticalDisc
                           << Solid::DeviceInterface::Processor
                           << Solid::DeviceInterface::Battery;
 
     updateDeviceList();
 }
 
 WinDeviceManager::~WinDeviceManager()
 {
 
 }
 
 QString WinDeviceManager::udiPrefix() const
 {
     return QString();
 }
 
 QSet<Solid::DeviceInterface::Type> Solid::Backends::Win::WinDeviceManager::supportedInterfaces() const
 {
     return m_supportedInterfaces;
 }
 
 QStringList WinDeviceManager::allDevices()
 {
     return m_devicesList;
 }
 
 QStringList WinDeviceManager::devicesFromQuery(const QString &parentUdi, Solid::DeviceInterface::Type type)
 {
 
     QStringList list;
+    const QStringList deviceList = allDevices();
     if (!parentUdi.isEmpty()) {
-        foreach (const QString &udi, allDevices()) {
+        for (const QString &udi : deviceList) {
             WinDevice device(udi);
             if (device.type() == type && device.parentUdi() == parentUdi) {
                 list << udi;
             }
         }
     } else if (type != Solid::DeviceInterface::Unknown) {
-        foreach (const QString &udi, allDevices()) {
+        for (const QString &udi : deviceList) {
             WinDevice device(udi);
             if (device.queryDeviceInterface(type)) {
                 list << udi;
             }
         }
     } else {
-        list << allDevices();
+        list << deviceList;
     }
     return list;
 
 }
 
 QObject *Solid::Backends::Win::WinDeviceManager::createDevice(const QString &udi)
 {
     if (allDevices().contains(udi)) {
         return new WinDevice(udi);
     } else {
         return 0;
     }
 }
 
 void WinDeviceManager::slotDeviceAdded(const QSet<QString> &udi)
 {
-    QSet<QString> tmp = udi - m_devices;//don't report devices that are already known(cd drive)
+    const QSet<QString> tmp = udi - m_devices; //don't report devices that are already known(cd drive)
     m_devices += tmp;
     m_devicesList = m_devices.toList();
     std::sort(m_devicesList.begin(), m_devicesList.end());
-    foreach (const QString &s, tmp) {
-        emit deviceAdded(s);
+    for (const QString &str : tmp) {
+        emit deviceAdded(str);
     }
 }
 
 void WinDeviceManager::slotDeviceRemoved(const QSet<QString> &udi)
 {
     m_devices -= udi;
     m_devicesList = m_devices.toList();
     std::sort(m_devicesList.begin(), m_devicesList.end());
-    foreach (const QString &s, udi) {
-        emit deviceRemoved(s);
+    for (const QString &str : udi) {
+        emit deviceRemoved(str);
     }
 }
 
 void WinDeviceManager::updateDeviceList()
 {
     QSet<QString> devices = WinProcessor::getUdis();
     devices += WinBlock::getUdis();
     devices += WinBattery::getUdis();
 
     m_devices = devices;
     m_devicesList = m_devices.toList();
     std::sort(m_devicesList.begin(), m_devicesList.end());
 }
 
 
diff --git a/src/solid/devices/backends/win/winopticaldrive.cpp b/src/solid/devices/backends/win/winopticaldrive.cpp
index a31db24..016565c 100644
--- a/src/solid/devices/backends/win/winopticaldrive.cpp
+++ b/src/solid/devices/backends/win/winopticaldrive.cpp
@@ -1,141 +1,141 @@
 /*
     SPDX-FileCopyrightText: 2013 Patrick von Reth <vonreth@kde.org>
 
     SPDX-License-Identifier: LGPL-2.1-only OR LGPL-3.0-only OR LicenseRef-KDE-Accepted-LGPL
 */
 
 #include "winopticaldrive.h"
 
 #include <ntddcdrm.h>
 #include <ntddmmc.h>
 
 using namespace Solid::Backends::Win;
 
 WinOpticalDrive::WinOpticalDrive(WinDevice *device) :
     WinStorageDrive(device)
 {
-    QMap<ulong, MediaProfiles> profiles = MediaProfiles::profiles(WinBlock::driveLetterFromUdi(m_device->udi()));
-    foreach (const MediaProfiles p, profiles.values()) {
+    const QMap<ulong, MediaProfiles> profiles = MediaProfiles::profiles(WinBlock::driveLetterFromUdi(m_device->udi()));
+    for (const MediaProfiles &p : profiles) {
         m_supportedTypes |= p.type;
     }
 }
 
 WinOpticalDrive::~WinOpticalDrive()
 {
 }
 
 Solid::OpticalDrive::MediumTypes WinOpticalDrive::supportedMedia() const
 {
     return m_supportedTypes;
 }
 
 bool WinOpticalDrive::eject()
 {
     WinDeviceManager::deviceAction(WinBlock::driveLetterFromUdi(m_device->udi()), IOCTL_STORAGE_EJECT_MEDIA);
     return true;
 }
 
 QList<int> WinOpticalDrive::writeSpeeds() const
 {
     return QList<int>();
 }
 
 int WinOpticalDrive::writeSpeed() const
 {
     return 0;
 }
 
 int WinOpticalDrive::readSpeed() const
 {
     return 0;
 }
 
 MediaProfiles::MediaProfiles() :
     profile(0),
     type(0),
     active(false)
 {
 }
 
 MediaProfiles::MediaProfiles(ulong profile, Solid::OpticalDrive::MediumTypes type, QString name):
     profile(profile),
     type(type),
     name(name),
     active(false)
 {
 }
 
 MediaProfiles::MediaProfiles(FEATURE_DATA_PROFILE_LIST_EX *feature) :
     profile(0),
     type(0),
     active(false)
 {
     ulong val = (feature->ProfileNumber[0] << 8 | feature->ProfileNumber[1] << 0);
     MediaProfiles p =  MediaProfiles::getProfile(val);
     if (!p.isNull()) {
         profile = p.profile;
         type = p.type;
         name = p.name;
         active =  feature->Current;
     }
 }
 
 bool MediaProfiles::isNull()
 {
     return name.isNull();
 }
 
 QMap<ulong, MediaProfiles> MediaProfiles::profiles(const QString &drive)
 {
 
     //thx to http://www.adras.com/Determine-optical-drive-type-and-capabilities.t6826-144-1.html
 
     QMap<ulong, MediaProfiles> out;
     DWORD buffSize = 1024;
     char buffer[1024];
     GET_CONFIGURATION_IOCTL_INPUT input;
     ZeroMemory(&input, sizeof(GET_CONFIGURATION_IOCTL_INPUT));
     input.Feature = FeatureProfileList;
     input.RequestType = SCSI_GET_CONFIGURATION_REQUEST_TYPE_ALL;
 
     WinDeviceManager::getDeviceInfo<char, GET_CONFIGURATION_IOCTL_INPUT>(drive, IOCTL_CDROM_GET_CONFIGURATION, buffer, buffSize, &input);
 
     GET_CONFIGURATION_HEADER *info = (GET_CONFIGURATION_HEADER *)buffer;
     FEATURE_DATA_PROFILE_LIST *profile = (FEATURE_DATA_PROFILE_LIST *)info->Data;
     FEATURE_DATA_PROFILE_LIST_EX *feature = profile->Profiles;
     for (int i = 0; i < profile->Header.AdditionalLength / 4; ++feature, ++i) {
         MediaProfiles p = MediaProfiles(feature);
         if (!p.isNull()) {
             out.insert(p.profile, p);
         }
     }
 
     return out;
 }
 
 const MediaProfiles MediaProfiles::getProfile(ulong val)
 {
 #define AddProfile(profile,type) profiles.insert(profile,MediaProfiles(profile,type,#profile))
     static QMap<ulong, MediaProfiles> profiles;
     if (profiles.isEmpty()) {
         AddProfile(ProfileCdrom, 0);
         AddProfile(ProfileCdRecordable, Solid::OpticalDrive::Cdr);
         AddProfile(ProfileCdRewritable, Solid::OpticalDrive::Cdrw);
         AddProfile(ProfileDvdRom, Solid::OpticalDrive::Dvd);
         AddProfile(ProfileDvdRecordable, Solid::OpticalDrive::Dvdr);
         AddProfile(ProfileDvdRewritable, Solid::OpticalDrive::Dvdrw);
         AddProfile(ProfileDvdRam, Solid::OpticalDrive::Dvdram);
         AddProfile(ProfileDvdPlusR, Solid::OpticalDrive::Dvdplusr);
         AddProfile(ProfileDvdPlusRW, Solid::OpticalDrive::Dvdplusrw);
         AddProfile(ProfileDvdPlusRDualLayer, Solid::OpticalDrive::Dvdplusdl);
         AddProfile(ProfileDvdPlusRWDualLayer, Solid::OpticalDrive::Dvdplusdlrw);
         AddProfile(ProfileBDRom, Solid::OpticalDrive::Bd);
         AddProfile(ProfileBDRRandomWritable, Solid::OpticalDrive::Bdr);
         AddProfile(ProfileBDRSequentialWritable, Solid::OpticalDrive::Bdr);
         AddProfile(ProfileBDRewritable, Solid::OpticalDrive::Bdre);
         AddProfile(ProfileHDDVDRom, Solid::OpticalDrive::HdDvd);
         AddProfile(ProfileHDDVDRecordable, Solid::OpticalDrive::HdDvdr);
         AddProfile(ProfileHDDVDRewritable, Solid::OpticalDrive::HdDvdrw);
     }
     return profiles[val];
 }
diff --git a/src/solid/devices/backends/win/winprocessor.cpp b/src/solid/devices/backends/win/winprocessor.cpp
index 36a314b..f1ef6ec 100644
--- a/src/solid/devices/backends/win/winprocessor.cpp
+++ b/src/solid/devices/backends/win/winprocessor.cpp
@@ -1,116 +1,117 @@
 /*
     SPDX-FileCopyrightText: 2013 Patrick von Reth <vonreth@kde.org>
 
     SPDX-License-Identifier: LGPL-2.1-only OR LGPL-3.0-only OR LicenseRef-KDE-Accepted-LGPL
 */
 
 #include "winprocessor.h"
 
 #include <solid/devices/backends/shared/cpufeatures.h>
 
 #include <QSettings>
 
 using namespace Solid::Backends::Win;
 
 typedef BOOL (WINAPI *GLPI_fn)(SYSTEM_LOGICAL_PROCESSOR_INFORMATION *Buffer, DWORD *ReturnLength);
 GLPI_fn pGetLogicalProcessorInformation = (GLPI_fn)GetProcAddress(LoadLibraryA("kernel32.dll"), "GetLogicalProcessorInformation");
 
 WinProcessor::WinProcessor(WinDevice *device):
     WinInterface(device)
 {
     m_number = m_device->udi().mid(m_device->udi().length() - 1).toInt();
 }
 
 WinProcessor::~WinProcessor()
 {
 }
 
 int WinProcessor::number() const
 {
     return m_number;
 }
 
 int WinProcessor::maxSpeed() const
 {
     return updateCache()[m_number].speed;
 }
 
 bool WinProcessor::canChangeFrequency() const
 {
     //TODO:implement
     return false;
 }
 
 Solid::Processor::InstructionSets WinProcessor::instructionSets() const
 {
     static Solid::Processor::InstructionSets set = Solid::Backends::Shared::cpuFeatures();
     return set;
 }
 
 QSet<QString> WinProcessor::getUdis()
 {
     static QSet<QString> out;
     if (out.isEmpty()) {
-        foreach (const ProcessorInfo &info, updateCache()) {
+        const QMap<int, ProcessorInfo> map = updateCache();
+        for (const ProcessorInfo &info : map) {
             out << QString("/org/kde/solid/win/cpu/device#%1,cpu#%2").arg(info.id).arg(info.lgicalId);
         }
     }
     return out;
 }
 
 DWORD WinProcessor::countSetBits(ULONG_PTR bitMask)
 {
     DWORD LSHIFT = sizeof(ULONG_PTR) * 8 - 1;
     DWORD bitSetCount = 0;
     ULONG_PTR bitTest = (ULONG_PTR)1 << LSHIFT;
     DWORD i;
 
     for (i = 0; i <= LSHIFT; ++i) {
         bitSetCount += ((bitMask & bitTest) ? 1 : 0);
         bitTest /= 2;
     }
 
     return bitSetCount;
 }
 
 const QMap<int, WinProcessor::ProcessorInfo> &WinProcessor::updateCache()
 {
     static QMap<int, ProcessorInfo> p;
 
     if (p.isEmpty()) {
         DWORD size = 0;
         pGetLogicalProcessorInformation(NULL, &size);
         char *buff = new char[size];
         SYSTEM_LOGICAL_PROCESSOR_INFORMATION *info = (SYSTEM_LOGICAL_PROCESSOR_INFORMATION *)buff;
         pGetLogicalProcessorInformation(info, &size);
         size /= sizeof(SYSTEM_LOGICAL_PROCESSOR_INFORMATION);
 
         uint processorCoreCount = 0;
         uint logicalProcessorCount = 0;
 
         for (uint i = 0; i < size; ++i) {
             if (info[i].Relationship == RelationProcessorCore) {
                 // A hyperthreaded core supplies more than one logical processor.
                 uint old = logicalProcessorCount;
                 logicalProcessorCount += countSetBits(info[i].ProcessorMask);
                 for (; old < logicalProcessorCount; ++old) {
                     QSettings settings(QLatin1String("HKEY_LOCAL_MACHINE\\HARDWARE\\DESCRIPTION\\System\\CentralProcessor\\") + QString::number(old),  QSettings::NativeFormat);
                     ProcessorInfo proc;
                     proc.id = processorCoreCount;
                     proc.lgicalId = old;
                     proc.speed = settings.value("~MHz").toInt();
                     proc.vendor = settings.value("VendorIdentifier").toString().trimmed();
                     proc.name = settings.value("ProcessorNameString").toString().trimmed();
                     proc.produuct = settings.value("Identifier").toString().trimmed();
 
                     p[old] = proc;
                 }
                 processorCoreCount++;
             }
 
         }
         delete [] buff;
     }
     return p;
 
 }
diff --git a/src/tools/solid-hardware/solid-hardware.cpp b/src/tools/solid-hardware/solid-hardware.cpp
index e81c4d8..3c4b766 100644
--- a/src/tools/solid-hardware/solid-hardware.cpp
+++ b/src/tools/solid-hardware/solid-hardware.cpp
@@ -1,449 +1,448 @@
 /*  This file is part of the KDE project
     SPDX-FileCopyrightText: 2006 Kevin Ottens <ervin@kde.org>
     SPDX-FileCopyrightText: 2014 Alejandro Fiestas Olivares <afiestas@kde.org>
 
     SPDX-License-Identifier: LGPL-2.0-only
 */
 
 #include "solid-hardware.h"
 
 
 #include <QString>
 #include <QStringList>
 #include <QMetaProperty>
 #include <QMetaEnum>
 #include <QTextStream>
 
 #include <QCoreApplication>
 #include <QCommandLineParser>
 
 #include <solid/device.h>
 #include <solid/genericinterface.h>
 #include <solid/storageaccess.h>
 #include <solid/opticaldrive.h>
 
 #include <iostream>
 #include <solid/devicenotifier.h>
 using namespace std;
 
 static const char appName[] = "solid-hardware";
 
 static const char version[] = "0.1a";
 
 std::ostream &operator<<(std::ostream &out, const QString &msg)
 {
     return (out << msg.toLocal8Bit().constData());
 }
 
 std::ostream &operator<<(std::ostream &out, const QVariant &value)
 {
     switch (value.type())
     {
     case QVariant::StringList:
     {
         out << "{";
 
         const QStringList list = value.toStringList();
 
         QStringList::ConstIterator it = list.constBegin();
         QStringList::ConstIterator end = list.constEnd();
 
         for (; it!=end; ++it)
         {
             out << "'" << *it << "'";
 
             if (it+1!=end)
             {
                 out << ", ";
             }
         }
 
         out << "}  (string list)";
         break;
     }
     case QVariant::Bool:
         out << (value.toBool()?"true":"false") << "  (bool)";
         break;
     case QVariant::Int:
     case QVariant::LongLong:
         out << value.toString()
             << "  (0x" << QString::number(value.toLongLong(), 16) << ")  (" << QVariant::typeToName(value.type()) << ")";
         break;
     case QVariant::UInt:
     case QVariant::ULongLong:
         out << value.toString()
             << "  (0x" << QString::number(value.toULongLong(), 16) << ")  (" << QVariant::typeToName(value.type()) << ")";
         break;
     case QVariant::Double:
         out << value.toString() << " (double)";
         break;
     case QVariant::UserType:
     {
         //qDebug() << "got variant type:" << value.typeName();
         if (value.canConvert<QList<int> >())
         {
-            QList<int> intlist = value.value<QList<int> >();
+            const QList<int> intlist = value.value<QList<int>>();
             QStringList tmp;
-            foreach (int val, intlist)
+            for (const int val : intlist) {
                 tmp.append(QString::number(val));
+            }
             out << "{" << tmp.join(",") << "} (int list)";
         }
         break;
     }
     default:
         out << "'" << value.toString() << "'  (string)";
         break;
     }
 
     return out;
 }
 
 std::ostream &operator<<(std::ostream &out, const Solid::Device &device)
 {
     out << "  parent = " << QVariant(device.parentUdi()) << endl;
     out << "  vendor = " << QVariant(device.vendor()) << endl;
     out << "  product = " << QVariant(device.product()) << endl;
     out << "  description = " << QVariant(device.description()) << endl;
     out << "  icon = " << QVariant(device.icon()) << endl;
 
     int index = Solid::DeviceInterface::staticMetaObject.indexOfEnumerator("Type");
     QMetaEnum typeEnum = Solid::DeviceInterface::staticMetaObject.enumerator(index);
 
     for (int i=0; i<typeEnum.keyCount(); i++)
     {
         Solid::DeviceInterface::Type type = (Solid::DeviceInterface::Type)typeEnum.value(i);
         const Solid::DeviceInterface *interface = device.asDeviceInterface(type);
 
         if (interface)
         {
             const QMetaObject *meta = interface->metaObject();
 
             for (int i=meta->propertyOffset(); i<meta->propertyCount(); i++)
             {
                 QMetaProperty property = meta->property(i);
                 out << "  " << QString(meta->className()).mid(7) << "." << property.name()
                     << " = ";
 
                 QVariant value = property.read(interface);
 
                 if (property.isEnumType()) {
                     QMetaEnum metaEnum = property.enumerator();
                     if (metaEnum.isFlag()) {
                         out << "'" << metaEnum.valueToKeys(value.toInt()).constData() << "'"
                             << "  (0x" << QString::number(value.toInt(), 16) << ")  (flag)";
                     } else {
                         out << "'" << metaEnum.valueToKey(value.toInt()) << "'"
                             << "  (0x" << QString::number(value.toInt(), 16) << ")  (enum)";
                     }
                     out << endl;
                 } else {
                     out << value << endl;
                 }
             }
         }
     }
 
     return out;
 }
 
 std::ostream &operator<<(std::ostream &out, const QMap<QString,QVariant> &properties)
 {
-    Q_FOREACH (const QString &key, properties.keys())
-    {
-        out << "  " << key << " = " << properties[key] << endl;
+    for (auto it = properties.cbegin(); it != properties.cend(); ++it) {
+        out << "  " << it.key() << " = " << it.value() << endl;
     }
 
     return out;
 }
 
 QString getUdiFromArguments(QCoreApplication &app, QCommandLineParser &parser)
 {
     parser.addPositionalArgument("udi", QCoreApplication::translate("solid-hardware", "Device udi"));
     parser.process(app);
     if (parser.positionalArguments().count() < 2) {
         parser.showHelp(1);
     }
     return parser.positionalArguments().at(1);
 }
 
 static QString commandsHelp()
 {
     QString data;
     QTextStream cout(&data);
     cout << endl << QCoreApplication::translate("solid-hardware", "Syntax:") << endl << endl;
 
     cout << "  solid-hardware list [details|nonportableinfo]" << endl;
     cout << QCoreApplication::translate("solid-hardware",
             "             # List the hardware available in the system.\n"
             "             # - If the 'nonportableinfo' option is specified, the device\n"
             "             # properties are listed (be careful, in this case property names\n"
             "             # are backend dependent),\n"
             "             # - If the 'details' option is specified, the device interfaces\n"
             "             # and the corresponding properties are listed in a platform\n"
             "             # neutral fashion,\n"
             "             # - Otherwise only device UDIs are listed.\n") << endl;
 
     cout << "  solid-hardware details 'udi'" << endl;
     cout << QCoreApplication::translate("solid-hardware",
             "             # Display all the interfaces and properties of the device\n"
             "             # corresponding to 'udi' in a platform neutral fashion.\n") << endl;
 
     cout << "  solid-hardware nonportableinfo 'udi'" << endl;
     cout << QCoreApplication::translate("solid-hardware",
             "             # Display all the properties of the device corresponding to 'udi'\n"
             "             # (be careful, in this case property names are backend dependent).\n") << endl;
 
     cout << "  solid-hardware query 'predicate' ['parentUdi']" << endl;
     cout << QCoreApplication::translate("solid-hardware",
             "             # List the UDI of devices corresponding to 'predicate'.\n"
             "             # - If 'parentUdi' is specified, the search is restricted to the\n"
             "             # branch of the corresponding device,\n"
             "             # - Otherwise the search is done on all the devices.\n") << endl;
 
     cout << "  solid-hardware mount 'udi'" << endl;
     cout << QCoreApplication::translate("solid-hardware",
             "             # If applicable, mount the device corresponding to 'udi'.\n") << endl;
 
     cout << "  solid-hardware unmount 'udi'" << endl;
     cout << QCoreApplication::translate("solid-hardware",
             "             # If applicable, unmount the device corresponding to 'udi'.\n") << endl;
 
     cout << "  solid-hardware eject 'udi'" << endl;
     cout << QCoreApplication::translate("solid-hardware",
             "             # If applicable, eject the device corresponding to 'udi'.\n") << endl;
 
     cout << "  solid-hardware listen" << endl;
     cout << QCoreApplication::translate("solid-hardware",
             "             # Listen to all add/remove events on supported hardware.") << endl;
 
     return data;
 }
 
 int main(int argc, char **argv)
 {
     SolidHardware app(argc, argv);
     app.setApplicationName(appName);
     app.setApplicationVersion(version);
 
     QCommandLineParser parser;
     parser.setApplicationDescription(QCoreApplication::translate("solid-hardware", "KDE tool for querying your hardware from the command line"));
     parser.addHelpOption();
     parser.addVersionOption();
     parser.addPositionalArgument("command", QCoreApplication::translate("solid-hardware", "Command to execute"), commandsHelp());
 
     QCommandLineOption commands("commands", QCoreApplication::translate("solid-hardware", "Show available commands"));
     // --commands only for backwards compat, it's now in the "syntax help"
     // of the positional argument.
     commands.setFlags(QCommandLineOption::HiddenFromHelp);
     parser.addOption(commands);
 
     parser.process(app);
     if (parser.isSet(commands))
     {
         cout << commandsHelp() << endl;
         return 0;
     }
 
     QStringList args = parser.positionalArguments();
     if (args.count() < 1) {
         parser.showHelp(1);
     }
 
     parser.clearPositionalArguments();
 
     QString command(args.at(0));
 
     if (command == "list")
     {
         parser.addPositionalArgument("details", QCoreApplication::translate("solid-hardware", "Show device details"));
         parser.addPositionalArgument("nonportableinfo", QCoreApplication::translate("solid-hardware", "Show non portable information"));
         parser.process(app);
         args = parser.positionalArguments();
         QByteArray extra(args.count() == 2 ? args.at(1).toLocal8Bit() : "");
         return app.hwList(extra == "details", extra == "nonportableinfo");
     } else if (command == "details") {
         const QString udi = getUdiFromArguments(app, parser);
         return app.hwCapabilities(udi);
     } else if (command == "nonportableinfo") {
         const QString udi = getUdiFromArguments(app, parser);
         return app.hwProperties(udi);
     } else if (command == "query") {
         parser.addPositionalArgument("udi", QCoreApplication::translate("solid-hardware", "Device udi"));
         parser.addPositionalArgument("parent", QCoreApplication::translate("solid-hardware", "Parent device udi"));
         parser.process(app);
         if (parser.positionalArguments().count() < 2 || parser.positionalArguments().count() > 3) {
             parser.showHelp(1);
         }
 
         QString query = args.at(1);
         QString parent;
 
         if (args.count() == 3)
         {
             parent = args.at(2);
         }
 
         return app.hwQuery(parent, query);
     } else if (command == "mount") {
         const QString udi = getUdiFromArguments(app, parser);
         return app.hwVolumeCall(SolidHardware::Mount, udi);
     } else if (command == "unmount") {
         const QString udi = getUdiFromArguments(app, parser);
         return app.hwVolumeCall(SolidHardware::Unmount, udi);
     } else if (command == "eject") {
         const QString udi = getUdiFromArguments(app, parser);
         return app.hwVolumeCall(SolidHardware::Eject, udi);
     } else if (command == "listen") {
         return app.listen();
     }
 
     cerr << QCoreApplication::translate("solid-hardware", "Syntax Error: Unknown command '%1'").arg(command) << endl;
 
     return 1;
 }
 
 bool SolidHardware::hwList(bool interfaces, bool system)
 {
     const QList<Solid::Device> all = Solid::Device::allDevices();
 
-    Q_FOREACH (const Solid::Device &device, all)
+    for (const Solid::Device &device : all)
     {
         cout << "udi = '" << device.udi() << "'" << endl;
 
         if (interfaces)
         {
             cout << device << endl;
         }
         else if (system && device.is<Solid::GenericInterface>())
         {
             QMap<QString,QVariant> properties = device.as<Solid::GenericInterface>()->allProperties();
             cout << properties << endl;
         }
     }
 
     return true;
 }
 
 bool SolidHardware::hwCapabilities(const QString &udi)
 {
     const Solid::Device device(udi);
 
     cout << "udi = '" << device.udi() << "'" << endl;
     cout << device << endl;
 
     return true;
 }
 
 bool SolidHardware::hwProperties(const QString &udi)
 {
     const Solid::Device device(udi);
 
     cout << "udi = '" << device.udi() << "'" << endl;
     if (device.is<Solid::GenericInterface>()) {
         QMap<QString,QVariant> properties = device.as<Solid::GenericInterface>()->allProperties();
         cout << properties << endl;
     }
 
     return true;
 }
 
 bool SolidHardware::hwQuery(const QString &parentUdi, const QString &query)
 {
     const QList<Solid::Device> devices
         = Solid::Device::listFromQuery(query, parentUdi);
 
-    Q_FOREACH (const Solid::Device &device, devices)
-    {
+    for (const Solid::Device &device : devices) {
         cout << "udi = '" << device.udi() << "'" << endl;
     }
 
     return true;
 }
 
 bool SolidHardware::hwVolumeCall(SolidHardware::VolumeCallType type, const QString &udi)
 {
     Solid::Device device(udi);
 
     if (!device.is<Solid::StorageAccess>() && type!=Eject)
     {
         cerr << tr("Error: %1 does not have the interface StorageAccess.").arg(udi) << endl;
         return false;
     }
     else if (!device.is<Solid::OpticalDrive>() && type==Eject)
     {
         cerr << tr("Error: %1 does not have the interface OpticalDrive.").arg(udi) << endl;
         return false;
     }
 
     switch(type)
     {
     case Mount:
         connect(device.as<Solid::StorageAccess>(),
                 SIGNAL(setupDone(Solid::ErrorType,QVariant,QString)),
                 this,
                 SLOT(slotStorageResult(Solid::ErrorType,QVariant)));
         device.as<Solid::StorageAccess>()->setup();
         break;
     case Unmount:
         connect(device.as<Solid::StorageAccess>(),
                 SIGNAL(teardownDone(Solid::ErrorType,QVariant,QString)),
                 this,
                 SLOT(slotStorageResult(Solid::ErrorType,QVariant)));
         device.as<Solid::StorageAccess>()->teardown();
         break;
     case Eject:
         connect(device.as<Solid::OpticalDrive>(),
                 SIGNAL(ejectDone(Solid::ErrorType,QVariant,QString)),
                 this,
                 SLOT(slotStorageResult(Solid::ErrorType,QVariant)));
         device.as<Solid::OpticalDrive>()->eject();
         break;
     }
 
     m_loop.exec();
 
     if (m_error)
     {
         cerr << tr("Error: %1").arg(m_errorString) << endl;
         return false;
     }
 
     return true;
 }
 
 bool SolidHardware::listen()
 {
     Solid::DeviceNotifier *notifier = Solid::DeviceNotifier::instance();
     bool a = connect(notifier, SIGNAL(deviceAdded(QString)), this, SLOT(deviceAdded(QString)));
     bool d = connect(notifier, SIGNAL(deviceRemoved(QString)), this, SLOT(deviceRemoved(QString)));
 
     if (!a || !d) {
         return false;
     }
 
     cout << "Listening to add/remove events: " << endl;
     m_loop.exec();
     return true;
 }
 
 void SolidHardware::deviceAdded(const QString &udi)
 {
     cout << "Device Added:" << endl;
     cout << "udi = '" << udi << "'" << endl;
 }
 
 void SolidHardware::deviceRemoved(const QString &udi)
 {
     cout << "Device Removed:" << endl;
     cout << "udi = '" << udi << "'" << endl;
 }
 
 void SolidHardware::slotStorageResult(Solid::ErrorType error, const QVariant &errorData)
 {
     if (error) {
         m_error = 1;
         m_errorString = errorData.toString();
     }
     m_loop.exit();
 }