one more optimization

The previous versions stored values as string, so any (even if they are
not used) values being converted into string, and then (if required)
being converted back to float/int/etc. I've changed the mechanism, so
they are stored as QVariant (native value).

Please note that it is possible that this rewrite may cause crash in
some cases (if I've missed smth).

sources/awesome-widget/plugin/awdataaggregator.cpp

@@ -36,11 +36,11 @@ AWDataAggregator::AWDataAggregator(QObject *parent)
 {
     qCDebug(LOG_AW) << __PRETTY_FUNCTION__;
     // required by signals
-    qRegisterMetaType<QHash<QString, QString>>("QHash<QString, QString>");
+    //    qRegisterMetaType<QHash<QString, QString>>("QHash<QString, QString>");
 
     initScene();
-    connect(this, SIGNAL(updateData(const QHash<QString, QString> &)), this,
+    connect(this, SIGNAL(updateData(const QVariantHash &)), this,
-            SLOT(dataUpdate(const QHash<QString, QString> &)));
+            SLOT(dataUpdate(const QVariantHash &)));
 }
 
 
@@ -168,7 +168,7 @@ QPixmap AWDataAggregator::tooltipImage()
 }
 
 
-void AWDataAggregator::dataUpdate(const QHash<QString, QString> &values)
+void AWDataAggregator::dataUpdate(const QVariantHash &values)
 {
     // do not log these arguments
     setData(values);
@@ -254,11 +254,12 @@ QString AWDataAggregator::notificationText(const QString source,
 }
 
 
-void AWDataAggregator::setData(const QHash<QString, QString> &values)
+void AWDataAggregator::setData(const QVariantHash &values)
 {
     // do not log these arguments
     // battery update requires info is AC online or not
-    setData(values[QString("ac")] == configuration[QString("acOnline")],
+    setData(values[QString("ac")].toString()
+                == configuration[QString("acOnline")],
             QString("batTooltip"), values[QString("bat")].toFloat());
     // usual case
     setData(QString("cpuTooltip"), values[QString("cpu")].toFloat(), 90.0);
@@ -271,7 +272,7 @@ void AWDataAggregator::setData(const QHash<QString, QString> &values)
     [this](const QString value) {
         checkValue(QString("netdev"), currentNetworkDevice, value);
         currentNetworkDevice = value;
-    }(values[QString("netdev")]);
+    }(values[QString("netdev")].toString());
     // additional check for GPU load
     [this](const float value) {
         checkValue(QString("gpu"), value, 90.0);
@@ -302,7 +303,7 @@ void AWDataAggregator::setData(const QString &source, float value,
         QList<float> netValues
             = data[QString("downkbTooltip")] + data[QString("upkbTooltip")];
         boundaries[QString("downkbTooltip")]
-            = 1.2 * *std::max_element(netValues.cbegin(), netValues.cend());
+            = 1.2f * *std::max_element(netValues.cbegin(), netValues.cend());
         boundaries[QString("upkbTooltip")]
             = boundaries[QString("downkbTooltip")];
     }

sources/awesome-widget/plugin/awdataaggregator.h

@@ -41,11 +41,11 @@ public:
     QPixmap tooltipImage();
 
 signals:
-    void updateData(const QHash<QString, QString> &values);
+    void updateData(const QVariantHash &values);
     void toolTipPainted(const QString image) const;
 
 public slots:
-    void dataUpdate(const QHash<QString, QString> &values);
+    void dataUpdate(const QVariantHash &values);
 
 private:
     // ui
@@ -59,9 +59,9 @@ private:
     QString notificationText(const QString source, const float value) const;
     QString notificationText(const QString source, const QString value) const;
     // main method
-    void setData(const QHash<QString, QString> &values);
+    void setData(const QVariantHash &values);
     void setData(const QString &source, float value,
-                 const float extremum = -1.0);
+                 const float extremum = -1.0f);
     // different signature for battery device
     void setData(const bool dontInvert, const QString &source, float value);
     // variables

sources/awesome-widget/plugin/awkeys.cpp

@@ -167,8 +167,8 @@ QString AWKeys::valueByKey(QString key) const
 {
     qCDebug(LOG_AW) << "Requested value for key" << key;
 
-    return values.value(key.remove(QRegExp(QString("^bar[0-9]{1,}"))),
+    key.remove(QRegExp(QString("^bar[0-9]{1,}")));
-                        QString(""));
+    return aggregator->formater(values[key], key);
 }
 
 
@@ -236,34 +236,26 @@ void AWKeys::calculateValues()
     QStringList mountDevices = keyOperator->devices(QString("mount"));
     for (auto device : mountDevices) {
         int index = mountDevices.indexOf(device);
-        values[QString("hddtotmb%1").arg(index)] = QString("%1").arg(
+        values[QString("hddtotmb%1").arg(index)]
-            values[QString("hddfreemb%1").arg(index)].toFloat()
+            = values[QString("hddfreemb%1").arg(index)].toFloat()
-                + values[QString("hddmb%1").arg(index)].toFloat(),
+              + values[QString("hddmb%1").arg(index)].toFloat();
-            5, 'f', 0);
+        values[QString("hddtotgb%1").arg(index)]
-        values[QString("hddtotgb%1").arg(index)] = QString("%1").arg(
+            = values[QString("hddfreegb%1").arg(index)].toFloat()
-            values[QString("hddfreegb%1").arg(index)].toFloat()
+              + values[QString("hddgb%1").arg(index)].toFloat();
-                + values[QString("hddgb%1").arg(index)].toFloat(),
-            5, 'f', 1);
     }
 
     // memtot*
-    values[QString("memtotmb")]
+    values[QString("memtotmb")] = values[QString("memusedmb")].toInt()
-        = QString("%1").arg(values[QString("memusedmb")].toInt()
+                                  + values[QString("memfreemb")].toInt();
-                                + values[QString("memfreemb")].toInt(),
+    values[QString("memtotgb")] = values[QString("memusedgb")].toFloat()
-                            5);
+                                  + values[QString("memfreegb")].toFloat();
-    values[QString("memtotgb")]
-        = QString("%1").arg(values[QString("memusedgb")].toFloat()
-                                + values[QString("memfreegb")].toFloat(),
-                            5, 'f', 1);
     // mem
-    values[QString("mem")]
+    values[QString("mem")] = 100.0f * values[QString("memmb")].toFloat()
-        = QString("%1").arg(100.0 * values[QString("memmb")].toFloat()
+                             / values[QString("memtotmb")].toFloat();
-                                / values[QString("memtotmb")].toFloat(),
-                            5, 'f', 1);
 
     // up, down, upkb, downkb, upunits, downunits
     int netIndex = keyOperator->devices(QString("net"))
-                       .indexOf(values[QString("netdev")]);
+                       .indexOf(values[QString("netdev")].toString());
     values[QString("down")] = values[QString("down%1").arg(netIndex)];
     values[QString("downkb")] = values[QString("downkb%1").arg(netIndex)];
     values[QString("downunits")] = values[QString("downunits%1").arg(netIndex)];
@@ -272,28 +264,23 @@ void AWKeys::calculateValues()
     values[QString("upunits")] = values[QString("upunits%1").arg(netIndex)];
 
     // swaptot*
-    values[QString("swaptotmb")]
+    values[QString("swaptotmb")] = values[QString("swapmb")].toInt()
-        = QString("%1").arg(values[QString("swapmb")].toInt()
+                                   + values[QString("swapfreemb")].toInt();
-                                + values[QString("swapfreemb")].toInt(),
+    values[QString("swaptotgb")] = values[QString("swapgb")].toFloat()
-                            5);
+                                   + values[QString("swapfreegb")].toFloat();
-    values[QString("swaptotgb")]
-        = QString("%1").arg(values[QString("swapgb")].toFloat()
-                                + values[QString("swapfreegb")].toFloat(),
-                            5, 'f', 1);
     // swap
-    values[QString("swap")]
+    values[QString("swap")] = 100.0f * values[QString("swapmb")].toFloat()
-        = QString("%1").arg(100.0 * values[QString("swapmb")].toFloat()
+                              / values[QString("swaptotmb")].toFloat();
-                                / values[QString("swaptotmb")].toFloat(),
-                            5, 'f', 1);
 
     // lambdas
     for (auto key : m_foundLambdas)
         values[key] = [this](QString key) {
             QJSEngine engine;
             // apply $this values
-            key.replace(QString("$this"), values[key]);
+            key.replace(QString("$this"), values[key].toString());
             for (auto lambdaKey : m_foundKeys)
-                key.replace(QString("$%1").arg(lambdaKey), values[lambdaKey]);
+                key.replace(QString("$%1").arg(lambdaKey),
+                            aggregator->formater(values[lambdaKey], lambdaKey));
             qCInfo(LOG_AW) << "Expression" << key;
             QJSValue result = engine.evaluate(key);
             if (result.isError()) {
@@ -315,16 +302,17 @@ QString AWKeys::parsePattern(QString pattern) const
 
     // lambdas
     for (auto key : m_foundLambdas)
-        pattern.replace(QString("${{%1}}").arg(key), values[key]);
+        pattern.replace(QString("${{%1}}").arg(key), values[key].toString());
 
     // main keys
     for (auto key : m_foundKeys)
-        pattern.replace(QString("$%1").arg(key),
+        pattern.replace(QString("$%1").arg(key), [this](const QString &tag,
-                        [](QString key, QString value) {
+                                                        const QVariant &value) {
-                            if ((!key.startsWith(QString("custom")))
+            QString strValue = aggregator->formater(value, tag);
-                                && (!key.startsWith(QString("weather"))))
+            if ((!tag.startsWith(QString("custom")))
-                                value.replace(QString(" "), QString("&nbsp;"));
+                && (!tag.startsWith(QString("weather"))))
-                            return value;
+                strValue.replace(QString(" "), QString("&nbsp;"));
+            return strValue;
         }(key, values[key]));
 
     // bars
@@ -338,7 +326,8 @@ QString AWKeys::parsePattern(QString pattern) const
                                 return QVariant::fromValue<QList<float>>(data);
                             }(dataAggregator->getData(key))));
         else
-            pattern.replace(QString("$%1").arg(bar), item->image(values[key]));
+            pattern.replace(QString("$%1").arg(bar),
+                            item->image(values[key].toFloat()));
     }
 
     // prepare strings
@@ -368,10 +357,11 @@ void AWKeys::setDataBySource(const QString &sourceName, const QVariantMap &data)
 
     m_mutex.lock();
     // HACK workaround for time values which are stored in the different path
-    QVariant value = sourceName == QString("Local") ? data[QString("DateTime")]
+    std::for_each(tags.cbegin(), tags.cend(),
+                  [this, &data, &sourceName](const QString &tag) {
+                      values[tag] = sourceName == QString("Local")
+                                        ? data[QString("DateTime")]
                                         : data[QString("value")];
-    std::for_each(tags.cbegin(), tags.cend(), [this, value](const QString tag) {
-        values[tag] = aggregator->formater(value, tag);
                   });
     m_mutex.unlock();
 }

sources/awesome-widget/plugin/awkeys.h

@@ -86,7 +86,7 @@ private:
     // variables
     QVariantMap m_tooltipParams;
     QStringList m_foundBars, m_foundKeys, m_foundLambdas, m_requiredKeys;
-    QHash<QString, QString> values;
+    QVariantHash values;
     bool m_optimize = false;
     bool m_wrapNewLines = false;
     // multithread features

sources/awesome-widget/plugin/awkeysaggregator.cpp

@@ -30,6 +30,23 @@ AWKeysAggregator::AWKeysAggregator(QObject *parent)
     : QObject(parent)
 {
     qCDebug(LOG_AW) << __PRETTY_FUNCTION__;
+
+    // default formaters
+    // memory
+    m_formater[QString("mem")] = Float;
+    m_formater[QString("memtotmb")] = IntegerFive;
+    m_formater[QString("memtotgb")] = Float;
+    // network
+    m_formater[QString("down")] = NetSmartFormat;
+    m_formater[QString("downkb")] = Integer;
+    m_formater[QString("downunits")] = NetSmartUnits;
+    m_formater[QString("up")] = NetSmartFormat;
+    m_formater[QString("upkb")] = Integer;
+    m_formater[QString("upunits")] = NetSmartUnits;
+    // swap
+    m_formater[QString("swap")] = Float;
+    m_formater[QString("swaptotmb")] = IntegerFive;
+    m_formater[QString("swaptotgb")] = Float;
 }
 
 
@@ -57,6 +74,9 @@ QString AWKeysAggregator::formater(const QVariant &data,
     case Integer:
         output = QString("%1").arg(data.toFloat(), 4, 'f', 0);
         break;
+    case IntegerFive:
+        output = QString("%1").arg(data.toFloat(), 5, 'f', 0);
+        break;
     case IntegerThree:
         output = QString("%1").arg(data.toFloat(), 3, 'f', 0);
         break;
@@ -137,9 +157,11 @@ QString AWKeysAggregator::formater(const QVariant &data,
               static_cast<int>(data.toFloat()));
         break;
     case NoFormat:
-    default:
         output = data.toString();
         break;
+    default:
+        output = QString();
+        break;
     }
 
     return output;
@@ -315,6 +337,9 @@ QStringList AWKeysAggregator::registerSource(const QString &source,
             QString key = QString("hdd%1").arg(index);
             m_map[source] = key;
             m_formater[key] = Float;
+            // additional keys
+            m_formater[QString("hddtotmb%1").arg(index)] = IntegerFive;
+            m_formater[QString("hddtotgb%1").arg(index)] = Float;
         }
     } else if (source.contains(mountFreeRegExp)) {
         // free space

sources/awesome-widget/plugin/awkeysaggregator.h

@@ -42,6 +42,7 @@ class AWKeysAggregator : public QObject
         Float,
         FloatTwoSymbols,
         Integer,
+        IntegerFive,
         IntegerThree,
         List,
         // unit specific formaters
@@ -78,7 +79,7 @@ public:
 
 public slots:
     QStringList registerSource(const QString &source, const QString &units,
-                               const QStringList &keys = QStringList());
+                               const QStringList &keys);
 
 private:
     float temperature(const float temp) const;