File indexing completed on 2024-09-15 04:47:08

 /*
  * Copyright (C) 2014 Aaron Seigo <aseigo@kde.org>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation; either
  * version 2.1 of the License, or (at your option) version 3, or any
  * later version accepted by the membership of KDE e.V. (or its
  * successor approved by the membership of KDE e.V.), which shall
  * act as a proxy defined in Section 6 of version 3 of the license.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this library.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 #include "datasetdefinition.h"
 
 #include <QDateTime>
 #include <QDebug>
 #include <QFile>
 #include <QJsonDocument>
 #include <QJsonObject>
 #include <QJsonArray>
 
 #include <iostream>
 
 namespace HAWD
 {
 
 static QHash<QString, QMetaType::Type> s_types;
 
 DataDefinition::DataDefinition(const QString &name, QMetaType::Type type, const QString &unit, int min, int max)
     : m_name(name),
       m_type(type),
       m_unit(unit),
       m_min(min),
       m_max(max)
 {
 }
 
 DataDefinition::DataDefinition(const QJsonObject &json)
     : m_name(json.value("name").toString()),
       m_type(QMetaType::Int),
       m_unit(json.value("unit").toString()),
       m_min(json.value("min").toInt()),
       m_max(json.value("max").toInt())
 {
     if (s_types.isEmpty()) {
         s_types.insert("date", QMetaType::QDate);
         s_types.insert("time", QMetaType::QTime);
         s_types.insert("int", QMetaType::Int);
         s_types.insert("uint", QMetaType::UInt);
         s_types.insert("bool", QMetaType::Bool);
         s_types.insert("float", QMetaType::Float);
         s_types.insert("double", QMetaType::Double);
         s_types.insert("char", QMetaType::QChar);
         s_types.insert("string", QMetaType::QString);
         s_types.insert("datetime", QMetaType::QDateTime);
     }
 
     const QString typeString = json.value("type").toString().toLower();
     if (s_types.contains(typeString)) {
         m_type = s_types.value(typeString);
     }
 }
 
 QString DataDefinition::name() const
 {
     return m_name;
 }
 
 QString DataDefinition::typeString() const
 {
     return QMetaType::typeName(m_type);
 }
 
 QMetaType::Type DataDefinition::type() const
 {
     return m_type;
 }
 
 QString DataDefinition::unit() const
 {
     return m_unit;
 }
 
 int DataDefinition::min() const
 {
     return m_min;
 }
 
 int DataDefinition::max() const
 {
     return m_max;
 }
 
 DatasetDefinition::DatasetDefinition(const QString &path)
     : m_valid(false)
 {
     QFile file(path);
     m_name = file.fileName();
 
     if (file.open(QIODevice::ReadOnly)) {
         QJsonParseError error;
         QJsonDocument jsonDoc = QJsonDocument::fromJson(file.readAll(), &error);
 
         if (jsonDoc.isNull()) {
             m_lastError = QObject::tr("Dataset definition file malformed at character %1: %2").arg(error.offset).arg(error.errorString());
         } else {
             m_valid = true;
             QJsonObject json = jsonDoc.object();
             const QString name = json.value("name").toString();
             if (!name.isEmpty()) {
                 m_name = name;
             }
 
             m_description = json.value("description").toString();
             auto cols = json.value("columns").toArray();
             for (QJsonValueRef entry: cols) {
                 QJsonObject def = entry.toObject();
                 if (!def.isEmpty()) {
                     m_columns << qMakePair(def.value("name").toString(), DataDefinition(def));
                 }
             }
         }
     } else {
         m_lastError = QObject::tr("Could not open file for parsing: ").arg(path);
     }
 }
 
 bool DatasetDefinition::isValid() const
 {
     return m_valid;
 }
 
 QString DatasetDefinition::lastError() const
 {
     return m_lastError;
 }
 
 QString DatasetDefinition::name() const
 {
     return m_name;
 }
 
 QString DatasetDefinition::description() const
 {
     return m_description;
 }
 
 QList<QPair<QString, DataDefinition> > DatasetDefinition::columns() const
 {
     return m_columns;
 }
 
 } // namespace HAWD