values_model.cpp - master - waterstone/json_inspector

values_model.cpp
121 строка3 KB
Peter Sakhno
Udjust data presentation
14 ноя 2025, 10:09
14 ноя 2025, 10:09a35c7cd
#include "values_model.h"

#include <iomanip>
#include <type_traits>

namespace {
  constexpr int kColumns{ 2 };
}

void ValuesModel::SetData(JSONNodeWPC values_source) {
  beginResetModel();

  m_count = 0;
  m_values_source = values_source;

  endResetModel();
}

int ValuesModel::rowCount(const QModelIndex&) const {
  return m_count;
}

int ValuesModel::columnCount(const QModelIndex&) const {
  return kColumns;
}

QVariant ValuesModel::data(const QModelIndex& index, int role) const {
  if (role != Qt::DisplayRole)
    return {};

  if (!index.isValid() || index.column() >= kColumns)
    return {};

  auto values_source = m_values_source.lock();
  if (!values_source)
    return {};

  const auto& values = values_source->GetValues();
  if (index.row() < 0 || values.size() <= index.row())
    return {};

  auto cit = std::next(values.cbegin(), index.row());
  if (cit == values.cend())
    return {};

  const auto& var = *cit;

  if (index.column() == 0) {
    switch (var.index()) {
      case 0: return QStringLiteral("null");
      case 1: return QStringLiteral("bool");
      case 2: return QStringLiteral("int");
      case 3: return QStringLiteral("long int");
      case 4: return QStringLiteral("unsigned int");
      case 5: return QStringLiteral("unsigned long int");
      case 6: return QStringLiteral("double");
      case 7: return QStringLiteral("string");
      default: return QStringLiteral("...");
    }
  }
  
  return std::visit([](auto&& arg) -> QVariant
    {
      QVariant out;
      using T = std::decay_t<decltype(arg)>;
      if constexpr (std::is_same_v<T, std::string>)
        out = QString::fromStdString(arg);
      else if constexpr (!std::is_same_v<T, std::monostate>)
        out = arg;
      return out;
    }, var);
}

QVariant ValuesModel::headerData(int section, Qt::Orientation orientation, int role) const {
  if (Qt::Horizontal == orientation) {
    switch (role) {
      case Qt::DisplayRole:
      {
        switch (section) {
          case 0:
            return tr("Type");
          case 1:
          {
            auto values_source = m_values_source.lock();
            if (values_source)
              return QString(tr("Values [%1]").arg(values_source->GetValues().size()));
            else
              return tr("Values");
          }
        }
      }

      case Qt::TextAlignmentRole:
        return static_cast<Qt::Alignment::Int>(Qt::AlignLeft | Qt::AlignVCenter);
    }
  }
  return QAbstractTableModel::headerData(section, orientation, role);
}

bool ValuesModel::canFetchMore(const QModelIndex&) const {
  auto values_source = m_values_source.lock();
  if (!values_source)
    return false;

  return (m_count < values_source->GetValues().size());
}

void ValuesModel::fetchMore(const QModelIndex&) {
  auto values_source = m_values_source.lock();
  if (!values_source)
    return;

  const int remainder = static_cast<int>(values_source->GetValues().size()) - m_count;
  const int items_2_fetch = qMin(100, remainder);
  if (items_2_fetch <= 0)
    return;

  beginInsertRows(QModelIndex(), m_count, m_count + items_2_fetch - 1);
  m_count += items_2_fetch;
  endInsertRows();
}