File indexing completed on 2024-12-15 04:56:11

 /*
  * 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 "dataset.h"
 
 #include <QDateTime>
 #include <QDebug>
 #include <QDataStream>
 
 #include <iostream>
 
 namespace HAWD
 {
 
 static const QString s_annotationKey("__annotation__");
 static const QString s_hashKey("__commithash__");
 static const QString s_timestampKey("__timestamp");
 static const int s_fieldWidth(20);
 
 Dataset::Row::Row(const Row &other)
     : m_key(other.m_key),
       m_columns(other.m_columns),
       m_data(other.m_data),
       m_annotation(other.m_annotation),
       m_commitHash(other.m_commitHash),
       m_dataset(other.m_dataset)
 {
 }
 
 Dataset::Row::Row(const Dataset &dataset, qint64 key)
     : m_key(key),
       m_columns(dataset.definition().columns()),
       m_dataset(&dataset)
 {
     // TODO: pre-populate m_data, or do that on buffer creation?
     for (const auto &colum : dataset.definition().columns()) {
         m_data.insert(colum.first, QVariant());
     }
 }
 
 Dataset::Row &Dataset::Row::operator=(const Row &rhs)
 {
     m_key = rhs.m_key;
     m_columns = rhs.m_columns;
     m_data = rhs.m_data;
     m_dataset = rhs.m_dataset;
     m_annotation = rhs.m_annotation;
     m_commitHash = rhs.m_commitHash;
     return *this;
 }
 
 void Dataset::Row::setValue(const QString &col, const QVariant &value)
 {
     for (const auto &column : m_columns) {
         if (column.first == col) {
             if (value.canConvert(column.second.type())) {
                 m_data[col] = value;
             }
             return;
         }
     }
 }
 
 QVariant Dataset::Row::value(const QString &col) const
 {
     return m_data.value(col);
 }
 
 void Dataset::Row::annotate(const QString &note)
 {
     m_annotation = note;
 }
 
 void Dataset::Row::setCommitHash(const QString &hash)
 {
     m_commitHash = hash;
 }
 
 qint64 Dataset::Row::key() const
 {
     if (m_key < 1) {
         const_cast<Dataset::Row *>(this)->m_key = QDateTime::currentMSecsSinceEpoch();
     }
 
     return m_key;
 }
 
 void Dataset::Row::fromBinary(QByteArray data)
 {
     QVariant value;
     QString key;
     QDataStream stream(&data, QIODevice::ReadOnly);
 
     while (!stream.atEnd()) {
         stream >> key;
         if (stream.atEnd()) {
             break;
         }
 
         stream >> value;
         if (key == s_annotationKey) {
             m_annotation = value.toString();
         } else if (key == s_hashKey) {
             m_commitHash = value.toString();
         } else if (key == s_timestampKey) {
             m_timeStamp = value.toDateTime();
         } else {
             setValue(key, value);
         }
     }
 }
 
 QByteArray Dataset::Row::toBinary() const
 {
     QByteArray data;
     QDataStream stream(&data, QIODevice::WriteOnly);
 
     QHashIterator<QString, QVariant> it(m_data);
     while (it.hasNext()) {
         it.next();
         if (it.value().isValid()) {
             stream << it.key() << it.value();
         }
     }
 
     if (!m_commitHash.isEmpty()) {
         stream << s_hashKey << QVariant(m_commitHash);
     }
 
     if (!m_timeStamp.isValid()) {
         stream << s_timestampKey << QVariant(m_timeStamp);
     }
 
     if (!m_annotation.isEmpty()) {
         stream << s_annotationKey << QVariant(m_annotation);
     }
 
     return data;
 }
 
 QString Dataset::tableHeaders(const QStringList &cols, int standardCols, const QString &seperator) const
 {
     if (!isValid()) {
         return QString();
     }
 
     QStringList strings;
 
     if (standardCols & Row::Timestamp) {
         strings << QObject::tr("Timestamp").leftJustified(s_fieldWidth, ' ');
     }
 
     if (standardCols & Row::CommitHash) {
         strings << QObject::tr("Commit").leftJustified(s_fieldWidth, ' ');
     }
 
     for (const auto &column : m_definition.columns()) {
         QString header = column.first;
         if (cols.isEmpty() || cols.contains(header)) {
             if (!column.second.unit().isEmpty()) {
                 header.append(" (").append(column.second.unit()).append(")");
             }
             strings << header.leftJustified(s_fieldWidth, ' ');
         }
     }
 
     if (standardCols & Row::Annotation) {
         strings << QObject::tr("Annotation").leftJustified(s_fieldWidth, ' ');
     }
 
     return strings.join(seperator);
 }
 
 
 QString Dataset::Row::commitHash() const
 {
     return m_commitHash;
 }
 
 QDateTime Dataset::Row::timestamp() const
 {
     if (m_timeStamp.isValid()) {
         return m_timeStamp;
     }
     QDateTime dt;
     dt.setMSecsSinceEpoch(m_key);
     return dt;
 }
 
 void Dataset::Row::setTimestamp(const QDateTime &dt)
 {
     m_timeStamp = dt;
 }
 
 QString Dataset::Row::toString(const QStringList &cols, int standardCols, const QString &seperator) const
 {
     if (m_data.isEmpty()) {
         return QString();
     }
 
     QStringList strings;
 
     if (standardCols & Timestamp) {
         strings << timestamp().toString("yyMMdd:hhmmss").leftJustified(s_fieldWidth, ' ');
     }
 
     if (standardCols & CommitHash) {
         strings << m_commitHash.leftJustified(s_fieldWidth, ' ');
     }
 
     for (const auto &column : m_columns) {
         const auto key = column.first;
         if (cols.isEmpty() || cols.contains(key)) {
             const auto value = m_data.value(key);
             if (value.canConvert<double>()) {
                 strings << QString("%1").arg(value.toDouble(), s_fieldWidth, 'f', 3);
             } else {
                 strings << value.toString().leftJustified(s_fieldWidth, ' ');
             }
         }
     }
 
     if (standardCols & Annotation) {
         strings << m_annotation.leftJustified(s_fieldWidth, ' ');
     }
 
     return strings.join(seperator);
 }
 
 Dataset::Dataset(const QString &name, const State &state)
     : m_definition(state.datasetDefinition(name)),
       m_storage(state.resultsPath(), name, Sink::Storage::DataStore::ReadWrite),
       m_transaction(m_storage.createTransaction()),
       m_commitHash(state.commitHash())
 {
 }
 
 Dataset::~Dataset()
 {
     m_transaction.commit();
 }
 
 bool Dataset::isValid() const
 {
     return m_definition.isValid();
 }
 
 const DatasetDefinition &Dataset::definition() const
 {
     return m_definition;
 }
 
 qint64 Dataset::insertRow(const Row &row)
 {
     if (row.m_dataset != this) {
         return 0;
     }
 
     qint64 key = row.key();
     m_transaction.openDatabase().write(QByteArray::fromRawData((const char *)&key, sizeof(qint64)), row.toBinary());
     return key;
 }
 
 void Dataset::removeRow(const Row &row)
 {
     //TODO
 }
 
 void Dataset::eachRow(const std::function<void(const Row &row)> &resultHandler)
 {
     if (!isValid()) {
         return;
     }
 
     Row row(*this);
     m_transaction.openDatabase().scan("",
                    [&](const QByteArray &key, const QByteArray &value) -> bool {
                        if (key.size() != sizeof(qint64)) {
                            return true;
                        }
 
                        row.fromBinary(value);
                        row.m_key = *(const qint64 *)key.data();
                        resultHandler(row);
                        return true;
                    },
                    Sink::Storage::DataStore::basicErrorHandler());
 }
 
 Dataset::Row Dataset::row(qint64 key)
 {
     if (key < 1) {
         Row row(*this, Sink::Storage::DataStore::maxRevision(m_transaction));
         row.setCommitHash(m_commitHash);
         return row;
     }
 
     Row row(*this, key);
     m_transaction.openDatabase().scan(QByteArray::fromRawData((const char *)&key, sizeof(qint64)),
             [&row](const QByteArray &key, const QByteArray &value) -> bool {
                 row.fromBinary(value);
                 return true;
             },
             Sink::Storage::DataStore::basicErrorHandler()
             );
     return row;
 }
 
 Dataset::Row Dataset::lastRow()
 {
     //TODO
     return Row(*this);
 }
 
 } // namespace HAWD