Continues migration with DDS, Common

Lts/Common/LtsUtils/LtsUtilsSettings/settings.cpp

@@ -0,0 +1,264 @@
+
+
+#include "settings.h"
+
+#include <QByteArray>
+#include <QCoreApplication>
+#include <QDataStream>
+#include <QFile>
+#include <QJsonArray>
+#include <QJsonDocument>
+#include <QJsonObject>
+#include <QRegularExpression>
+#include <QVector>
+
+#include <QDebug>
+
+
+namespace LtsUtils
+{
+
+enum class SettingType
+{
+  String = 1,
+  StringList = 2,
+  Json = 3,
+  FunctionKeys = 4,
+  Boolean = 5,
+};
+
+QString typeToString(SettingType t)
+{
+  switch (t)
+  {
+  case SettingType::String:
+    return QStringLiteral("String");
+  case SettingType::StringList:
+    return QStringLiteral("StringList");
+  case SettingType::Json:
+    return QStringLiteral("Json");
+  case SettingType::FunctionKeys:
+    return QStringLiteral("FunctionKeys");
+  case SettingType::Boolean:
+    return QStringLiteral("Boolean");
+  }
+  Q_ASSERT(false);
+  return QStringLiteral("Unknown SettingType (%1)").arg(int(t));
+}
+
+SettingType stringToType(const QString &s)
+{
+  if (s == typeToString(SettingType::String))
+    return SettingType::String;
+  if (s == typeToString(SettingType::StringList))
+    return SettingType::StringList;
+  if (s == typeToString(SettingType::Json))
+    return SettingType::Json;
+  if (s == typeToString(SettingType::FunctionKeys))
+    return SettingType::FunctionKeys;
+  if (s == typeToString(SettingType::Boolean))
+    return SettingType::Boolean;
+  Q_ASSERT(false);
+  return SettingType::String;
+}
+
+
+static QString craftKey(const QString &group, const QString &identifier)
+{
+  return group + QLatin1Char('.') + identifier;
+}
+
+
+
+
+static OperatorSettings *s_operatorSettings = nullptr;
+static void cleanupOperatorSettings()
+{
+  delete s_operatorSettings;
+  s_operatorSettings = nullptr;
+}
+
+OperatorSettings *OperatorSettings::getInstance()
+{
+  if (!s_operatorSettings)
+  {
+    s_operatorSettings = new OperatorSettings;
+    qAddPostRoutine(&cleanupOperatorSettings);
+  }
+  return s_operatorSettings;
+}
+
+
+
+
+
+static ProjectSettings *s_projectSettings = nullptr;
+static void cleanupProjectSettings()
+{
+  delete s_projectSettings;
+  s_projectSettings = nullptr;
+}
+
+ProjectSettings *ProjectSettings::getInstance()
+{
+  if (!s_projectSettings)
+  {
+    s_projectSettings = new ProjectSettings;
+    qAddPostRoutine(&cleanupProjectSettings);
+  }
+  return s_projectSettings;
+}
+
+bool ProjectSettings::initFromFile(const QString &filename)
+{
+  QFile f(filename);
+  if (!f.open(QIODevice::ReadOnly))
+    return false;
+
+  QJsonParseError jErr;
+  const QJsonObject settings = QJsonDocument::fromJson(f.readAll(), &jErr).object();
+  if (jErr.error != QJsonParseError::NoError)
+    return false;
+
+  const QJsonObject psObj = settings[QStringLiteral("ProjectSettings")].toObject();
+  if (psObj.isEmpty())
+    return false;
+
+  QHash<QString, QVariant> newData;
+  const QStringList &groupKeys(psObj.keys());
+  for (const auto &gKey : groupKeys)
+  {
+    const QJsonObject objGroup(psObj[gKey].toObject());
+    const QStringList &itemKeys(objGroup.keys());
+    for (const auto &key : itemKeys)
+    {
+      const QJsonObject obj(objGroup[key].toObject());
+      const auto strType(obj[QStringLiteral("Type")].toString());
+      const auto type = stringToType(strType);
+      const QJsonValue jVal(obj[QStringLiteral("Default")]);
+      QVariant val;
+      switch (type)
+      {
+      case SettingType::Json:
+        val = QJsonDocument(jVal.toObject()).toJson();
+        break;
+      case SettingType::StringList:
+      {
+        const QJsonArray arr(jVal.toArray());
+        QStringList sl;
+        sl.reserve(arr.size());
+        for (const auto &ele : arr)
+          sl.push_back(ele.toString());
+        val = sl;
+        break;
+      }
+      case SettingType::FunctionKeys:
+        val = jVal.toVariant();
+        break;
+      case SettingType::String:
+        val = jVal.toString();
+        break;
+      case SettingType::Boolean:
+        val = jVal.toBool();
+        break;
+      }
+      newData[craftKey(gKey, key)] = val;
+    }
+  }
+  getInstance()->m_data = newData;
+  return true;
+}
+
+bool ProjectSettings::isFunctionEnabled(const QString &group, const QString &function)
+{
+  const QStringList functionNames = getInstance()->value(QStringLiteral("Functionalities"),
+                                                         QStringLiteral("IdentifierList")).toStringList();
+
+  return functionNames.contains(group + QLatin1Char(':') + function);
+}
+
+
+
+
+void Settings::init(const QByteArray &settings)
+{
+  QByteArray uncompressed;
+  try
+  {
+    uncompressed = qUncompress(settings);
+  }
+  catch (...)
+  {}
+
+  if (uncompressed.isEmpty())
+    uncompressed = settings;
+
+  QDataStream stream(uncompressed);
+  stream >> m_data;
+}
+
+
+QByteArray Settings::exportSettings() const
+{
+  if (m_data.isEmpty())
+    return QByteArray();
+
+  QByteArray ba;
+  QDataStream stream(&ba, QIODevice::WriteOnly);
+  stream << m_data;
+  return qCompress(ba);
+}
+
+
+void Settings::clear()
+{
+  m_data.clear();
+}
+
+void Settings::dump()
+{
+  qWarning() << "Settings::m_data: keys=" << m_data.keys();
+  QHashIterator<QString, QVariant> it(m_data);
+  int i=0;
+  while (it.hasNext())
+  {
+    it.next();
+    qWarning() << i++ << ":" << " - key='" << it.key() << "' value -> '" << it.value() << "'";
+  }
+  qWarning() << "Settings::m_data: ------------------";
+}
+
+void Settings::setValue(const QString &group, const QString &identifier, const QVariant &value)
+{
+  
+  m_data.insert(craftKey(group, identifier), value);
+  emit valueChanged(group, identifier, value);
+}
+
+
+void Settings::removeValue(const QString &group, const QString &identifier)
+{
+  if (m_data.remove(craftKey(group, identifier)))
+    emit valueRemoved(group, identifier);
+}
+
+
+QStringList Settings::identifiers(const QString &group) const
+{
+  QStringList result;
+  for (auto it = m_data.begin(); it != m_data.end(); ++it)
+  {
+    QVector<QStringRef> decrafted = it.key().splitRef(QLatin1Char('.'));
+    if (decrafted.size() > 1 && group.compare(decrafted.at(0)) == 0)
+      result.append(decrafted.at(1).toString());
+  }
+  return result;
+}
+
+
+QVariant Settings::value(const QString &group, const QString &identifier, const QVariant &defaultValue) const
+{
+  return m_data.value(craftKey(group, identifier), defaultValue);
+}
+
+}