dbe::FileInfo Class Reference

#include <FileInfo.hpp>

Inheritance diagram for dbe::FileInfo:

Collaboration diagram for dbe::FileInfo:

Public Member Functions
	FileInfo (QString filename, QWidget *parent=0)
	~FileInfo ()=default
void	keyPressEvent (QKeyEvent *event) override

Static Public Member Functions
static void	show_file_info (const QString &filename)
static void	setup_paths ()
static QList< QUrl >	get_path_urls ()
static QStringList	get_path_list ()
static QString	prune_path (QString file)
static bool	match_path (const QString &file, const QString &top_file, const QStringList &includes)
static void	parse_all_objects ()
static QString	check_file_includes (const QString &file)
static QString	get_schema_path ()
static QString	get_data_path ()
static void	set_schema_path (const QString &path)
static void	set_data_path (const QString &path)

Private Slots
void	accept ()
void	reject ()
void	file_info_slot ()
void	file_info_slot (const QString &fn)
void	file_info_slot (QListWidgetItem *)
void	edit_object_slot ()
void	edit_object_slot (QListWidgetItem *)
void	delete_object_slot ()
void	rename_object_slot ()
void	activate_schema_context_menu (QPoint point)
void	activate_data_context_menu (QPoint point)
void	activate_object_context_menu (QPoint point)
void	add_datafile ()
void	add_schemafile ()
void	add_includefile (QFileDialog *fd)
void	add_missing_datafiles ()
void	add_missing_schemafiles ()
void	remove_datafile_slot ()
void	remove_schemafile_slot ()
void	remove_includefile (const QString &file)
void	filemodel_updated ()

Private Member Functions
void	parse_objects ()
void	parse_includes ()
bool	check_includes ()

Private Attributes
Ui::FileInfo *	m_ui
std::map< QString, const tref >	m_obj_map
QString	m_filename
bool	m_readonly { false }
QMenu *	m_schema_menu { nullptr }
QMenu *	m_data_menu { nullptr }
QMenu *	m_object_menu { nullptr }
QUuid const	m_uuid
bool	m_updating { false }

Static Private Attributes
static std::map< QString, std::map< QString, const tref > >	s_obj_map {}
static std::map< QString, std::set< QString > >	s_missing_schema_map {}
static std::map< QString, std::set< QString > >	s_missing_data_map {}
static QStringList	s_path_list {}
static QList< QUrl >	s_path_urls {}
static QString	s_schema_path { "." }
static QString	s_data_path { "." }

Detailed Description

Definition at line 22 of file FileInfo.hpp.

Constructor & Destructor Documentation

FileInfo()

dbe::FileInfo::FileInfo	(	QString	filename,
		QWidget *	parent = 0 )

Definition at line 196 of file FileInfo.cpp.

  : m_ui(new Ui::FileInfo)
  , m_filename(filename)
  , m_uuid(QUuid::createUuid())
{
 
  QWidget::setAttribute(Qt::WA_DeleteOnClose);
 
  m_ui->setupUi(this);
  m_ui->filename->setText(filename);
  if (confaccessor::check_file_rw(filename)) {
    m_ui->rstatus->setText(QString("RW"));
    m_readonly = false;
  } else {
    m_ui->rstatus->setText(QString("RO"));
    m_readonly = true;
  }
 
  setObjectName(filename);
  setWindowTitle("File:  " + filename.section('/', -1));
 
  setup_paths();
  parse_includes();
  parse_objects();
 
  m_ui->schema_list->setContextMenuPolicy(Qt::ContextMenuPolicy::CustomContextMenu);
  m_ui->data_list->setContextMenuPolicy(Qt::ContextMenuPolicy::CustomContextMenu);
  m_ui->object_list->setContextMenuPolicy(Qt::ContextMenuPolicy::CustomContextMenu);
 
  connect(m_ui->add_schema, SIGNAL(pressed()), this, SLOT(add_schemafile()));
  connect(m_ui->add_data, SIGNAL(pressed()), this, SLOT(add_datafile()));
 
  connect(m_ui->add_missing_schema, SIGNAL(pressed()), this, SLOT(add_missing_schemafiles()));
  connect(m_ui->add_missing, SIGNAL(pressed()), this, SLOT(add_missing_datafiles()));
 
  connect(
    m_ui->schema_list, SIGNAL(customContextMenuRequested(QPoint)), this, SLOT(activate_schema_context_menu(QPoint)));
 
  connect(m_ui->data_list, SIGNAL(customContextMenuRequested(QPoint)), this, SLOT(activate_data_context_menu(QPoint)));
  connect(m_ui->data_list, SIGNAL(itemActivated(QListWidgetItem*)), this, SLOT(file_info_slot(QListWidgetItem*)));
 
  connect(m_ui->object_list, SIGNAL(itemActivated(QListWidgetItem*)), this, SLOT(edit_object_slot(QListWidgetItem*)));
  connect(
    m_ui->object_list, SIGNAL(customContextMenuRequested(QPoint)), this, SLOT(activate_object_context_menu(QPoint)));
 
  connect(MainWindow::findthis(), SIGNAL(signal_new_file_model()), this, SLOT(filemodel_updated()));
}

~FileInfo()

dbe::FileInfo::~FileInfo ( )

default

Member Function Documentation

accept

void dbe::FileInfo::accept ( )

privateslot

Definition at line 323 of file FileInfo.cpp.

{
  close();
}

activate_data_context_menu

void dbe::FileInfo::activate_data_context_menu ( QPoint point )

privateslot

Definition at line 547 of file FileInfo.cpp.

{
  if (m_data_menu == nullptr) {
    m_data_menu = new QMenu(this);
 
    auto info = new QAction(tr("Show file info"), this);
    connect(info, SIGNAL(triggered()), this, SLOT(file_info_slot()));
    m_data_menu->addAction(info);
 
    if (!m_readonly) {
      auto add = new QAction("Add include file", this);
      connect(add, SIGNAL(triggered()), this, SLOT(add_datafile()));
      m_data_menu->addAction(add);
 
      auto remove = new QAction("Remove include file", this);
      connect(remove, SIGNAL(triggered()), this, SLOT(remove_datafile_slot()));
      m_data_menu->addAction(remove);
    }
  }
 
  if (m_ui->data_list->currentIndex().isValid()) {
    m_data_menu->actions().at(0)->setVisible(true);
    m_data_menu->actions().at(2)->setVisible(true);
  } else {
    m_data_menu->actions().at(0)->setVisible(false);
    m_data_menu->actions().at(2)->setVisible(false);
  }
  m_data_menu->exec(m_ui->data_list->mapToGlobal(pos));
}

activate_object_context_menu

void dbe::FileInfo::activate_object_context_menu ( QPoint point )

privateslot

Definition at line 578 of file FileInfo.cpp.

{
  if (m_object_menu == nullptr) {
    m_object_menu = new QMenu(this);
 
    auto edit_action = new QAction(tr("&Edit object"), this);
    connect(edit_action, SIGNAL(triggered()), this, SLOT(edit_object_slot()));
    m_object_menu->addAction(edit_action);
 
    auto delete_action = new QAction(tr("&Delete Object"), this);
    connect(delete_action, SIGNAL(triggered()), this, SLOT(delete_object_slot()));
    m_object_menu->addAction(delete_action);
 
    auto rename_action = new QAction(tr("&Rename Object"), this);
    connect(rename_action, SIGNAL(triggered()), this, SLOT(rename_object_slot()));
    m_object_menu->addAction(rename_action);
  }
 
  if (m_ui->object_list->currentIndex().isValid()) {
    m_object_menu->exec(m_ui->object_list->mapToGlobal(pos));
  }
}

activate_schema_context_menu

void dbe::FileInfo::activate_schema_context_menu ( QPoint point )

privateslot

Definition at line 524 of file FileInfo.cpp.

{
  if (m_schema_menu == nullptr) {
    m_schema_menu = new QMenu(this);
 
    if (!m_readonly) {
      auto add = new QAction("Add include file", this);
      connect(add, SIGNAL(triggered()), this, SLOT(add_schemafile()));
      m_schema_menu->addAction(add);
 
      auto remove = new QAction("Remove include file", this);
      connect(remove, SIGNAL(triggered()), this, SLOT(remove_schemafile_slot()));
      m_schema_menu->addAction(remove);
    }
  }
 
  if (m_ui->schema_list->currentIndex().isValid()) {
    m_schema_menu->actions().at(1)->setVisible(true);
  }
  m_schema_menu->exec(m_ui->schema_list->mapToGlobal(pos));
}

add_datafile

void dbe::FileInfo::add_datafile ( )

privateslot

Definition at line 392 of file FileInfo.cpp.

{
  if (s_data_path == ".") {
    s_data_path = s_schema_path;
  }
  auto fd = new QFileDialog(this, tr("Open Data File"), s_data_path, tr("XML data files (*.data.xml)"));
  add_includefile(fd);
  if (fd->result() == QDialog::Accepted) {
    s_data_path = fd->directory().path();
  }
}

add_includefile

void dbe::FileInfo::add_includefile ( QFileDialog * fd )

privateslot

Definition at line 416 of file FileInfo.cpp.

{
  fd->setFileMode(QFileDialog::ExistingFiles);
  fd->setViewMode(QFileDialog::Detail);
  fd->setAcceptMode(QFileDialog::AcceptOpen);
  fd->setSidebarUrls(s_path_urls);
  if (fd->exec() == QDialog::Accepted) {
    auto files = fd->selectedFiles();
    QScopedValueRollback<bool> rb(m_updating, true);
    for (auto file : files) {
      file = prune_path(file);
      config::api::commands::file::add(m_filename, file);
    }
    parse_includes();
    parse_objects();
  }
}

add_missing_datafiles

void dbe::FileInfo::add_missing_datafiles ( )

privateslot

Definition at line 452 of file FileInfo.cpp.

{
  QScopedValueRollback<bool> rb(m_updating, true);
  auto short_filename = prune_path(m_filename);
  if (!s_missing_data_map.contains(short_filename)) {
    QMessageBox::warning(
      this, "Warning", QString("Missing data map is corrupt and does not contain %1").arg(short_filename));
    return;
  }
  for (const auto& file : s_missing_data_map.at(prune_path(m_filename))) {
    config::api::commands::file::add(m_filename, file);
  }
  parse_includes();
  parse_objects();
}

add_missing_schemafiles

void dbe::FileInfo::add_missing_schemafiles ( )

privateslot

Definition at line 435 of file FileInfo.cpp.

{
  QScopedValueRollback<bool> rb(m_updating, true);
  auto short_filename = prune_path(m_filename);
  if (!s_missing_schema_map.contains(short_filename)) {
    QMessageBox::warning(
      this, "Warning", QString("Missing schema map is corrupt and does not contain %1").arg(short_filename));
    return;
  }
  for (const auto& file : s_missing_schema_map.at(short_filename)) {
    config::api::commands::file::add(m_filename, file);
  }
  parse_includes();
  parse_objects();
}

add_schemafile

void dbe::FileInfo::add_schemafile ( )

privateslot

Definition at line 404 of file FileInfo.cpp.

{
  if (s_schema_path == ".") {
    s_schema_path = s_data_path;
  }
  auto fd = new QFileDialog(this, tr("Open Schema File"), s_schema_path, tr("XML schema files (*.schema.xml)"));
  add_includefile(fd);
  if (fd->result() == QDialog::Accepted) {
    s_schema_path = fd->directory().path();
  }
}

check_file_includes()

QString dbe::FileInfo::check_file_includes ( const QString & file )

static

Definition at line 143 of file FileInfo.cpp.

{
  QString message{};
 
  auto fname = prune_path(filename);
  if (!s_missing_schema_map.contains(fname)) {
    s_missing_schema_map.insert({ fname, {} });
  } else {
    s_missing_schema_map.at(fname).clear();
  }
  if (!s_missing_data_map.contains(fname)) {
    s_missing_data_map.insert({ fname, {} });
  } else {
    s_missing_data_map.at(fname).clear();
  }
  QStringList includes(config::api::get::file::inclusions_singlefile(filename));
  if (s_obj_map.contains(prune_path(filename))) {
    for (auto [id, obj] : s_obj_map.at(prune_path(filename))) {
      dunedaq::conffwk::class_t const& classdef = dbe::config::api::info::onclass::definition(obj.class_name(), false);
 
      auto schema_file = QString::fromStdString(classdef.p_schema_path);
      if (!match_path(schema_file, filename, includes)) {
        message += QString("Object <i>" + id + "</i> is of class <i>" + QString::fromStdString(obj.class_name()) +
                           "</i> defined in file <b>" + schema_file + "</b> which is not included<br>");
        s_missing_schema_map.at(fname).insert(prune_path(schema_file));
      }
      std::vector<tref> relobjs;
      for (auto rel : classdef.p_relationships) {
        if (config::api::info::relation::is_simple(rel)) {
          try {
            relobjs.push_back(dbegraph::linked::through::relation<tref>(obj, rel));
          } catch (daq::dbe::config_object_retrieval_result_is_null const& e) {
            // nothing needs be done to handle cases that a relation has not been set
          }
        } else {
          relobjs = dbegraph::linked::through::relation<std::vector<tref>>(obj, rel);
        }
 
        for (auto relobj : relobjs) {
          auto file = QString::fromStdString(relobj.contained_in());
          if (!(match_path(file, filename, includes))) {
            message +=
              QString("Object <i>" + id + "</i> has relationship to <i>" + QString::fromStdString(relobj.full_name()) +
                      "</i> in file <b>" + file + "</b> which is not included<br>");
            s_missing_data_map.at(fname).insert(prune_path(file));
          }
        }
      }
    }
  }
  return message;
}

check_includes()

bool dbe::FileInfo::check_includes ( )

private

Definition at line 283 of file FileInfo.cpp.

{
  QString message = check_file_includes(m_filename);
  m_ui->message->setText(message);
  return message.isEmpty();
}

delete_object_slot

void dbe::FileInfo::delete_object_slot ( )

privateslot

Definition at line 364 of file FileInfo.cpp.

{
  auto name = m_ui->object_list->currentItem()->text();
  auto file = prune_path(m_filename);
  if (s_obj_map.at(file).contains(name)) {
    config::api::commands::delobj(s_obj_map.at(file).at(name), m_uuid);
  }
  parse_objects();
}

edit_object_slot [1/2]

void dbe::FileInfo::edit_object_slot ( )

privateslot

Definition at line 334 of file FileInfo.cpp.

{
  auto item = m_ui->object_list->currentItem();
  edit_object_slot(item);
}

edit_object_slot [2/2]

void dbe::FileInfo::edit_object_slot ( QListWidgetItem * item )

privateslot

Definition at line 341 of file FileInfo.cpp.

{
  auto name = item->text();
  if (s_obj_map.at(prune_path(m_filename)).contains(name)) {
    for (QWidget* widget : QApplication::allWidgets()) {
      auto oe = dynamic_cast<ObjectEditor*>(widget);
      if (oe != nullptr) {
        if (oe->objectName() == name) {
          oe->raise();
          oe->setVisible(true);
          oe->activateWindow();
          return;
        }
      }
    }
 
    auto obj = s_obj_map.at(prune_path(m_filename)).at(name);
    auto oe = new ObjectEditor(obj);
    oe->show();
  }
}

file_info_slot [1/3]

void dbe::FileInfo::file_info_slot ( )

privateslot

Definition at line 487 of file FileInfo.cpp.

{
  show_file_info(m_ui->data_list->currentItem()->text());
}

file_info_slot [2/3]

void dbe::FileInfo::file_info_slot ( const QString & fn )

privateslot

Definition at line 499 of file FileInfo.cpp.

{
  show_file_info(filename);
}

file_info_slot [3/3]

void dbe::FileInfo::file_info_slot ( QListWidgetItem * item )

privateslot

Definition at line 493 of file FileInfo.cpp.

{
  show_file_info(item->text());
}

filemodel_updated

void dbe::FileInfo::filemodel_updated ( )

privateslot

Definition at line 245 of file FileInfo.cpp.

{
  if (m_updating) {
    return;
  }
  parse_includes();
  parse_objects();
}

get_data_path()

QString dbe::FileInfo::get_data_path ( )

inlinestatic

Definition at line 40 of file FileInfo.hpp.

{ return s_data_path; }

get_path_list()

QStringList dbe::FileInfo::get_path_list ( )

static

Definition at line 116 of file FileInfo.cpp.

{
  if (s_path_list.isEmpty()) {
    setup_paths();
  }
  return s_path_list;
}

get_path_urls()

QList< QUrl > dbe::FileInfo::get_path_urls ( )

static

Definition at line 108 of file FileInfo.cpp.

{
  if (s_path_urls.isEmpty()) {
    setup_paths();
  }
  return s_path_urls;
}

get_schema_path()

QString dbe::FileInfo::get_schema_path ( )

inlinestatic

Definition at line 39 of file FileInfo.hpp.

{ return s_schema_path; }

keyPressEvent()

void dbe::FileInfo::keyPressEvent ( QKeyEvent * event )

override

Definition at line 314 of file FileInfo.cpp.

{
  if (event->key() == Qt::Key_Escape) {
    close();
  }
  QWidget::keyPressEvent(event);
}

match_path()

bool dbe::FileInfo::match_path ( const QString & file, const QString & top_file, const QStringList & includes )

static

Definition at line 81 of file FileInfo.cpp.

{
  if (top_file.endsWith(file)) {
    return true;
  }
 
  if (s_path_list.isEmpty()) {
    setup_paths();
  }
 
  QStringList candidates{ file };
  for (const auto& element : s_path_list) {
    if (file.startsWith(element)) {
      auto short_name = file;
      candidates.append(short_name.remove(element));
    }
  }
 
  for (auto cand : candidates) {
    if (includes.contains(cand)) {
      return true;
    }
  }
  return false;
}

parse_all_objects()

void dbe::FileInfo::parse_all_objects ( )

static

Definition at line 125 of file FileInfo.cpp.

{
  s_obj_map.clear();
  for (auto const& class_name : config::api::info::onclass::allnames<std::vector<std::string>>()) {
    for (auto obj : config::api::info::onclass::objects(class_name, false)) {
      auto file = prune_path(QString::fromStdString(obj.contained_in()));
      auto name = QString::fromStdString(obj.full_name());
      if (!s_obj_map.contains(file)) {
        s_obj_map.insert({ file, {} });
        s_missing_schema_map.insert({ file, {} });
        s_missing_data_map.insert({ file, {} });
      }
      s_obj_map.at(file).insert({ name, obj });
    }
  }
}

parse_includes()

void dbe::FileInfo::parse_includes ( )

private

Definition at line 291 of file FileInfo.cpp.

{
  QStringList includes(config::api::get::file::inclusions_singlefile(m_filename));
  m_ui->schema_list->clear();
  m_ui->data_list->clear();
  for (auto inc : includes) {
    auto item = new QListWidgetItem(inc);
    if (!confaccessor::check_file_rw(inc)) {
      item->setForeground(QBrush(StyleUtility::FileReadOnlyForeground));
      item->setBackground(QBrush(StyleUtility::FileReadOnlyBackground));
    }
    if (inc.endsWith(".schema.xml")) {
      m_ui->schema_list->addItem(item);
    }
    if (inc.endsWith(".data.xml")) {
      m_ui->data_list->addItem(item);
    }
  }
  m_ui->schema_list->update();
  m_ui->data_list->update();
}

parse_objects()

void dbe::FileInfo::parse_objects ( )

private

Definition at line 255 of file FileInfo.cpp.

{
  parse_all_objects();
  m_ui->object_list->clear();
  auto fname = prune_path(m_filename);
  if (s_obj_map.contains(fname)) {
    auto& omap = s_obj_map.at(fname);
    for (auto const& [obj_name, obj_ref] : omap) {
      auto item = new QListWidgetItem(obj_name);
      m_ui->object_list->addItem(item);
    }
  }
  m_ui->object_list->update();
 
  auto status = check_includes();
  if (!s_missing_schema_map.contains(fname)) {
    s_missing_schema_map.insert({ fname, {} });
  }
  if (!s_missing_data_map.contains(fname)) {
    s_missing_data_map.insert({ fname, {} });
  }
  m_ui->add_missing_schema->setVisible(!s_missing_schema_map.at(fname).empty());
  m_ui->add_missing->setVisible(!s_missing_data_map.at(fname).empty());
 
  m_ui->warningBox->setVisible(!status);
}

prune_path()

QString dbe::FileInfo::prune_path ( QString file )

static

Definition at line 66 of file FileInfo.cpp.

{
  if (s_path_list.isEmpty()) {
    setup_paths();
  }
  for (const QString& element : s_path_list) {
    if (file.startsWith(element)) {
      file.remove(element);
      break;
    }
  }
  return file;
}

reject

void dbe::FileInfo::reject ( )

privateslot

Definition at line 328 of file FileInfo.cpp.

{
  close();
}

remove_datafile_slot

void dbe::FileInfo::remove_datafile_slot ( )

privateslot

Definition at line 474 of file FileInfo.cpp.

{
  remove_includefile(m_ui->data_list->currentItem()->text());
}

remove_includefile

void dbe::FileInfo::remove_includefile ( const QString & file )

privateslot

Definition at line 479 of file FileInfo.cpp.

{
  config::api::commands::file::remove(m_filename, file);
  parse_includes();
  parse_objects();
}

remove_schemafile_slot

void dbe::FileInfo::remove_schemafile_slot ( )

privateslot

Definition at line 469 of file FileInfo.cpp.

{
  remove_includefile(m_ui->schema_list->currentItem()->text());
}

rename_object_slot

void dbe::FileInfo::rename_object_slot ( )

privateslot

Definition at line 375 of file FileInfo.cpp.

{
  auto name = m_ui->object_list->currentItem()->text();
  auto file = prune_path(m_filename);
  if (s_obj_map.at(file).contains(name)) {
    QInputDialog dia(this);
    dia.setLabelText("Enter new name for " + name);
    auto code = dia.exec();
    if (code == QDialog::Accepted) {
      std::string new_name = dia.textValue().toStdString();
      config::api::commands::renobj(s_obj_map.at(file).at(name), new_name, m_uuid);
    }
  }
  parse_objects();
}

set_data_path()

void dbe::FileInfo::set_data_path ( const QString & path )

inlinestatic

Definition at line 42 of file FileInfo.hpp.

{ s_data_path = path; }

set_schema_path()

void dbe::FileInfo::set_schema_path ( const QString & path )

inlinestatic

Definition at line 41 of file FileInfo.hpp.

{ s_schema_path = path; }

setup_paths()

void dbe::FileInfo::setup_paths ( )

static

Definition at line 32 of file FileInfo.cpp.

{
  QString DUNEDAQ_DB_PATH = getenv("DUNEDAQ_DB_PATH");
  s_path_list.clear();
  s_path_urls.clear();
  auto path_list = DUNEDAQ_DB_PATH.split(QLatin1Char(':'), Qt::SkipEmptyParts);
  for (QString& path : path_list) {
    char* rpath = realpath(path.toStdString().c_str(), NULL);
    path = QString(rpath);
    free(rpath);
 
    if (!path.isEmpty()) {
      if (!path.endsWith("/")) {
        path.append("/");
      }
      s_path_urls.append(QUrl::fromLocalFile(path));
      s_path_list.append(path);
    }
  }
  auto dbpath = confaccessor::dbfullname();
  dbpath.truncate(dbpath.lastIndexOf("/") + 1);
  if (!s_path_list.contains(dbpath)) {
    s_path_urls.append(QUrl::fromLocalFile(dbpath));
    s_path_list.append(dbpath);
  }
  char* rpath_cd = realpath(".", NULL);
  auto path_cd = QString(rpath_cd);
  free(rpath_cd);
  if (!s_path_list.contains(path_cd)) {
    s_path_urls.append(QUrl::fromLocalFile(path_cd));
  }
}

show_file_info()

void dbe::FileInfo::show_file_info ( const QString & filename )

static

Definition at line 505 of file FileInfo.cpp.

{
  for (QWidget* widget : QApplication::allWidgets()) {
    auto fi = dynamic_cast<FileInfo*>(widget);
    if (fi != nullptr) {
      if (fi->objectName() == filename) {
        fi->raise();
        fi->setVisible(true);
        fi->activateWindow();
        return;
      }
    }
  }
 
  auto fi = new FileInfo(filename);
  fi->show();
}

Member Data Documentation

m_data_menu

QMenu* dbe::FileInfo::m_data_menu { nullptr }

private

Definition at line 79 of file FileInfo.hpp.

m_filename

QString dbe::FileInfo::m_filename

private

Definition at line 76 of file FileInfo.hpp.

m_obj_map

std::map<QString, const tref> dbe::FileInfo::m_obj_map

private

Definition at line 75 of file FileInfo.hpp.

m_object_menu

QMenu* dbe::FileInfo::m_object_menu { nullptr }

private

Definition at line 80 of file FileInfo.hpp.

m_readonly

bool dbe::FileInfo::m_readonly { false }

private

Definition at line 77 of file FileInfo.hpp.

m_schema_menu

QMenu* dbe::FileInfo::m_schema_menu { nullptr }

private

Definition at line 78 of file FileInfo.hpp.

m_ui

Ui::FileInfo* dbe::FileInfo::m_ui

private

Definition at line 74 of file FileInfo.hpp.

m_updating

bool dbe::FileInfo::m_updating { false }

private

Definition at line 83 of file FileInfo.hpp.

m_uuid

QUuid const dbe::FileInfo::m_uuid

private

Definition at line 81 of file FileInfo.hpp.

s_data_path

QString dbe::FileInfo::s_data_path { "." }

staticprivate

Definition at line 92 of file FileInfo.hpp.

s_missing_data_map

std::map< QString, std::set< QString > > dbe::FileInfo::s_missing_data_map {}

staticprivate

Definition at line 87 of file FileInfo.hpp.

s_missing_schema_map

std::map< QString, std::set< QString > > dbe::FileInfo::s_missing_schema_map {}

staticprivate

Definition at line 86 of file FileInfo.hpp.

s_obj_map

std::map< QString, std::map< QString, const tref > > dbe::FileInfo::s_obj_map {}

staticprivate

Definition at line 85 of file FileInfo.hpp.

s_path_list

QStringList dbe::FileInfo::s_path_list {}

staticprivate

Definition at line 89 of file FileInfo.hpp.

s_path_urls

QList< QUrl > dbe::FileInfo::s_path_urls {}

staticprivate

Definition at line 90 of file FileInfo.hpp.

s_schema_path

QString dbe::FileInfo::s_schema_path { "." }

staticprivate

Definition at line 91 of file FileInfo.hpp.

---

The documentation for this class was generated from the following files:

• /github/workspace/dunedaq/sourcecode/dbe/include/dbe/FileInfo.hpp
• /github/workspace/dunedaq/sourcecode/dbe/src/structure/FileInfo.cpp