protobuf_factory.cpp

Go to the documentation of this file.

#include "protobuf_factory.h"
 
#include <QSettings>
#include <QMessageBox>
 
#include "PlotJuggler/contrib/fmt/format.h"
#include "PlotJuggler/svg_util.h"
 
namespace gp = google::protobuf;
 
ParserFactoryProtobuf::ParserFactoryProtobuf()
{
  _widget = new QWidget(nullptr);
  ui = new Ui::ProtobufLoader;
  ui->setupUi(_widget);
 
  _source_tree.MapPath("", "");
  _source_tree.MapPath("/", "/");
 
  loadSettings();
 
  QSettings settings;
  QString theme = settings.value("Preferences::theme", "light").toString();
  ui->pushButtonRemove->setIcon(LoadSvg(":/resources/svg/trash.svg", theme));
 
  connect(ui->pushButtonInclude, &QPushButton::clicked, this,
          &ParserFactoryProtobuf::onIncludeDirectory);
  connect(ui->pushButtonLoad, &QPushButton::clicked, this,
          &ParserFactoryProtobuf::onLoadFile);
  connect(ui->pushButtonRemove, &QPushButton::clicked, this,
          &ParserFactoryProtobuf::onRemoveInclude);
 
  QString last_type = settings.value("ProtobufParserCreator.lastType").toString();
  int combo_index = ui->comboBox->findText(last_type, Qt::MatchExactly);
  if (!last_type.isEmpty() && combo_index != -1)
  {
    ui->comboBox->setCurrentIndex(combo_index);
    onComboChanged(last_type);
  }
 
  connect(ui->comboBox, qOverload<const QString&>(&QComboBox::currentIndexChanged), this,
          &ParserFactoryProtobuf::onComboChanged);
}
 
void ParserFactoryProtobuf::importFile(QString filename)
{
  QFile file(filename);
  if (!file.exists())
  {
    QMessageBox::warning(nullptr, tr("Error loading file"),
                         tr("File %1 does not exist").arg(filename), QMessageBox::Cancel);
    return;
  }
  file.open(QIODevice::ReadOnly);
  FileInfo info;
  QFileInfo fileinfo(filename);
  QString file_basename = fileinfo.fileName();
  info.file_path = filename;
  info.proto_text = file.readAll();
 
  _source_tree.MapPath("", filename.toStdString());
  _source_tree.MapPath("", file_basename.toStdString());
  _source_tree.MapPath("", fileinfo.absolutePath().toStdString());
 
  FileErrorCollector error_collector;
 
  _importer.reset(new gp::compiler::Importer(&_source_tree, &error_collector));
  info.file_descriptor = _importer->Import(file_basename.toStdString());
 
  if (!info.file_descriptor)
  {
    if (error_collector.errors().size() > 0)
    {
      QMessageBox::warning(nullptr, "Error parsing Proto file",
                           error_collector.errors().front(), QMessageBox::Cancel);
    }
    return;
  }
 
  ui->loadedProto->setText(file_basename);
  ui->protoPreview->setText(info.proto_text);
  ui->comboBox->clear();
 
  for (int i = 0; i < info.file_descriptor->message_type_count(); i++)
  {
    const std::string& type_name = info.file_descriptor->message_type(i)->name();
    auto descriptor = info.file_descriptor->FindMessageTypeByName(type_name);
    QString type_qname = QString::fromStdString(type_name);
    info.descriptors.insert({ type_qname, descriptor });
    ui->comboBox->addItem(type_qname);
  }
  _loaded_file = std::move(info);
}
 
void ParserFactoryProtobuf::loadSettings()
{
  ui->listWidget->clear();
  ui->protoPreview->clear();
 
  QSettings settings;
 
  auto include_list = settings.value("ProtobufParserCreator.include_dirs").toStringList();
  for (const auto& include_dir : include_list)
  {
    QDir path_dir(include_dir);
    if (path_dir.exists())
    {
      ui->listWidget->addItem(include_dir);
      _source_tree.MapPath("", include_dir.toStdString());
    }
  }
  ui->listWidget->sortItems();
 
  auto filename = settings.value("ProtobufParserCreator.protofile").toString();
  if (!filename.isEmpty())
  {
    importFile(filename);
  }
}
 
void ParserFactoryProtobuf::saveSettings()
{
  QSettings settings;
  QStringList include_list;
  for (int row = 0; row < ui->listWidget->count(); row++)
  {
    include_list += ui->listWidget->item(row)->text();
  }
  settings.setValue("ProtobufParserCreator.include_dirs", include_list);
  settings.setValue("ProtobufParserCreator.protofile", _loaded_file.file_path);
}
 
ParserFactoryProtobuf::~ParserFactoryProtobuf()
{
  delete ui;
}
 
MessageParserPtr ParserFactoryProtobuf::createParser(const std::string& topic_name,
                                                     const std::string& type_name,
                                                     const std::string& schema,
                                                     PlotDataMapRef& data)
{
  QString descriptor_name =
      type_name.empty() ? ui->comboBox->currentText() : QString::fromStdString(type_name);
  if (schema.empty())
  {
    auto descr_it = _loaded_file.descriptors.find(descriptor_name);
    if (descr_it == _loaded_file.descriptors.end())
    {
      throw std::runtime_error("ParserFactoryProtobuf: can't find the descriptor");
    }
    auto selected_descriptor = descr_it->second;
    return std::make_shared<ProtobufParser>(topic_name, selected_descriptor, data);
  }
  else
  {
    gp::FileDescriptorSet field_set;
    if (!field_set.ParseFromArray(schema.data(), schema.size()))
    {
      throw std::runtime_error("failed to parse schema data");
    }
 
    return std::make_shared<ProtobufParser>(topic_name, type_name, field_set, data);
  }
}
 
void ParserFactoryProtobuf::onIncludeDirectory()
{
  QSettings settings;
  QString directory_path =
      settings.value("ProtobufParserCreator.loadDirectory", QDir::currentPath())
          .toString();
 
  QString dirname =
      QFileDialog::getExistingDirectory(_widget, tr("Load StyleSheet"), directory_path);
  if (dirname.isEmpty())
  {
    return;
  }
  settings.setValue("ProtobufParserCreator.loadDirectory", dirname);
  if (ui->listWidget->findItems(dirname, Qt::MatchExactly).empty())
  {
    ui->listWidget->addItem(dirname);
    ui->listWidget->sortItems();
  }
}
 
void ParserFactoryProtobuf::onLoadFile()
{
  QSettings settings;
 
  QString directory_path =
      settings.value("ProtobufParserCreator.loadDirectory", QDir::currentPath())
          .toString();
 
  QString filename = QFileDialog::getOpenFileName(_widget, tr("Load StyleSheet"),
                                                  directory_path, tr("(*.proto)"));
  if (filename.isEmpty())
  {
    return;
  }
 
  importFile(filename);
 
  directory_path = QFileInfo(filename).absolutePath();
  settings.setValue("ProtobufParserCreator.loadDirectory", directory_path);
 
  saveSettings();
}
 
void ParserFactoryProtobuf::onRemoveInclude()
{
  auto selected = ui->listWidget->selectedItems();
 
  while (!selected.isEmpty())
  {
    auto item = selected.front();
    delete ui->listWidget->takeItem(ui->listWidget->row(item));
    selected.pop_front();
  }
  saveSettings();
  loadSettings();
}
 
void ParserFactoryProtobuf::onComboChanged(const QString& text)
{
  auto descr_it = _loaded_file.descriptors.find(text);
  if (descr_it != _loaded_file.descriptors.end())
  {
    QSettings settings;
    settings.setValue("ProtobufParserCreator.lastType", text);
  }
}