dbe::BatchChangeWidget Class Reference

#include <BatchChangeWidget.hpp>

Inheritance diagram for dbe::BatchChangeWidget:

Collaboration diagram for dbe::BatchChangeWidget:

Signals
void	sig_batch_change_start ()
void	sig_batch_change_stop (const QList< QPair< QString, QString > > &)

Public Member Functions
	~BatchChangeWidget ()
	BatchChangeWidget (QWidget *parent=nullptr)
	BatchChangeWidget (bool ObjectsFromTable, QString ClassName, std::vector< dref > &Objects, QWidget *parent=nullptr)

Private Slots
void	FillInfo (const QString &Name)
void	MakeChanges ()
void	FindMatching ()
void	EnableCheckBox (QString RelationshipName)
void	UpdateRelationshipFilter (int)
void	UpdateRelationshipNewValues (int)

Private Member Functions
void	SetController ()
void	filter (std::vector< dref > &Objects, const QString &ClassName)

Private Attributes
std::unique_ptr< dbe::Ui::BatchChangeWidget >	ui
std::vector< dref >	TableObjects
bool	UseTable
bool	ClassChanged
QString	TableClass
std::unique_ptr< QTableWidget >	m_filter_table

Detailed Description

Definition at line 20 of file BatchChangeWidget.hpp.

Constructor & Destructor Documentation

~BatchChangeWidget()

dbe::BatchChangeWidget::~BatchChangeWidget ( )

default

BatchChangeWidget() [1/2]

dbe::BatchChangeWidget::BatchChangeWidget

(

QWidget *

parent = nullptr

)

Definition at line 19 of file BatchChangeWidget.cpp.

  :
  QWidget ( parent ),
  ui ( new Ui::BatchChangeWidget ),
  UseTable ( false ),
  ClassChanged ( true ),
  TableClass ( "" ),
  m_filter_table ( nullptr )
{
  ui->setupUi ( this );
  ui->TitleLabel->setStyleSheet (
    "QLabel { background-color:green; color:beige; font:bold14px; border-style:outset; border-width:2px;"
    "border-radius:10px; border-color:beige; font:bold14px; min-width:10em; padding:6px}" );
  ui->FirstStepLabel->setStyleSheet ( "QLabel { color:#DB5816; font: bold 14px;}" );
  ui->SecondStepLabel->setStyleSheet ( "QLabel { color:#DE8A14; font: bold 14px;}" );
  ui->ThirdStepLabel->setStyleSheet ( "QLabel { color:#8DAA2E; font: bold 14px;}" );
  setWindowTitle ( "Batch Change" );
 
  QStringList ListOfClasses ( dbe::config::api::info::onclass::allnames<QStringList>() );
  ui->ClassCombo->addItems ( ListOfClasses );
  ui->ClassCombo->setEditable ( true );
  ui->ClassCombo->setEditText ( "Type/Select Classes" );
 
  ui->AttributeBox->setEnabled ( false );
  ui->RelationshipBox->setEnabled ( false );
  ui->NewAttributeGroupBox->setEnabled ( false );
  ui->NewRelationshipGroupBox->setEnabled ( false );
  ui->MatchButton->setEnabled ( false );
  ui->FilterUid->setText ( "*" );
  ui->AttributeValueFilter->setText ( "*" );
 
  SetController();
}

BatchChangeWidget() [2/2]

dbe::BatchChangeWidget::BatchChangeWidget	(	bool	ObjectsFromTable,
		QString	ClassName,
		std::vector< dref > &	Objects,
		QWidget *	parent = nullptr )

Definition at line 53 of file BatchChangeWidget.cpp.

  :
  BatchChangeWidget ( parent )
{
  ClassChanged = false;
 
  TableObjects = Objects;
  UseTable = ObjectsFromTable;
  TableClass = ClassName;
 
  ui->ClassCombo->setCurrentIndex ( ui->ClassCombo->findText ( TableClass ) );
  ui->SubclassesCheckBox->setEnabled ( false );
  FillInfo ( TableClass );
 
  if ( UseTable )
  {
    setWindowTitle ( "Batch change - Table" );
    ui->FilterGroupBox->hide();
    ui->Label1->hide();
    ui->Label2->hide();
    ui->FirstStepLabel->hide();
    ui->SecondStepLabel->hide();
    ui->ThirdStepLabel->hide();
    ui->Line1->hide();
    ui->Line2->hide();
    ui->TitleLabel->setText ( "Batch Change of multiple objects - Table" );
    resize ( 540, 280 );
  }
}

Member Function Documentation

EnableCheckBox

void dbe::BatchChangeWidget::EnableCheckBox ( QString RelationshipName )

privateslot

Definition at line 521 of file BatchChangeWidget.cpp.

{
  QString ClassName = ui->ClassCombo->currentText();
  const dunedaq::conffwk::class_t & ClassInfo = dbe::config::api::info::onclass::definition (
                                             ClassName.toStdString(), false );
  std::vector<dunedaq::conffwk::relationship_t> RelationshipList = ClassInfo.p_relationships;
 
  for ( dunedaq::conffwk::relationship_t & i : RelationshipList )
  {
    if ( i.p_name == RelationshipName.toStdString() )
    {
      if ( ( i.p_cardinality == dunedaq::conffwk::zero_or_many ) || ( i.p_cardinality
                                                                 == dunedaq::conffwk::one_or_many ) )
      {
        ui->AddCheckBox->setEnabled ( true );
      }
      else
      {
        ui->AddCheckBox->setEnabled ( false );
      }
 
      break;
    }
  }
}

FillInfo

void dbe::BatchChangeWidget::FillInfo ( const QString & Name )

privateslot

Definition at line 223 of file BatchChangeWidget.cpp.

{
  ui->AttributeBox->setEnabled ( false );
  ui->RelationshipBox->setEnabled ( false );
  ui->NewAttributeGroupBox->setEnabled ( false );
  ui->NewRelationshipGroupBox->setEnabled ( false );
 
  const dunedaq::conffwk::class_t & ClassInfo = dbe::config::api::info::onclass::definition (
                                             Name.toStdString(),
                                             false );
  const std::vector<dunedaq::conffwk::attribute_t> AttributeList = ClassInfo.p_attributes;
  const std::vector<dunedaq::conffwk::relationship_t> RelationshipList = ClassInfo
                                                                    .p_relationships;
 
  QStringList ValueList;
 
  for ( dunedaq::conffwk::attribute_t Attribute : AttributeList )
  {
    ValueList.append ( QString ( Attribute.p_name.c_str() ) );
  }
 
  ui->AttributeComboBox->clear();
  ui->NewAttributeComboBox->clear();
  ui->AttributeComboBox->addItems ( ValueList );
  ui->NewAttributeComboBox->addItems ( ValueList );
 
  if ( !AttributeList.empty() && !UseTable )
  {
    ui->AttributeBox->setEnabled ( true );
    ui->NewAttributeGroupBox->setEnabled ( true );
    ui->MatchButton->setEnabled ( true );
  }
 
  if ( !AttributeList.empty() && UseTable )
  {
    ui->NewAttributeGroupBox->setEnabled ( true );
  }
 
  ValueList.clear();
 
  for ( dunedaq::conffwk::relationship_t Relationship : RelationshipList )
  {
    ValueList.append ( QString ( Relationship.p_name.c_str() ) );
  }
 
  ui->RelationshipComboBox->clear();
  ui->NewRelationshipComboBox->clear();
  ui->RelationshipComboBox->addItems ( ValueList );
  ui->NewRelationshipComboBox->addItems ( ValueList );
 
  if ( !RelationshipList.empty() && !UseTable )
  {
    ui->RelationshipBox->setEnabled ( true );
    ui->NewRelationshipGroupBox->setEnabled ( true );
    ui->MatchButton->setEnabled ( true );
  }
 
  if ( !RelationshipList.empty() && UseTable )
  {
    ui->NewRelationshipGroupBox->setEnabled ( true );
  }
 
  if ( !UseTable )
  {
    UpdateRelationshipFilter ( 0 );
    UpdateRelationshipNewValues ( 0 );
    ui->RelationshipValueFilter->setCurrentIndex ( 0 );
    ui->RelationshipEdit->setCurrentIndex ( -1 );
  }
  else
  {
    UpdateRelationshipNewValues ( 0 );
    ui->RelationshipEdit->setCurrentIndex ( -1 );
  }
 
  if ( ClassChanged )
  {
    UseTable = false;
  }
 
  ClassChanged = true;
}

filter()

void dbe::BatchChangeWidget::filter ( std::vector< dref > & Objects, const QString & ClassName )

private

Filtering Attributes

Definition at line 115 of file BatchChangeWidget.cpp.

{
 
  dunedaq::conffwk::class_t const & cinfo = dbe::config::api::info::onclass::definition (
                                         cname.toStdString(), false );
  std::vector<dunedaq::conffwk::attribute_t> const & attributes = cinfo.p_attributes;
  std::vector<dunedaq::conffwk::relationship_t> const & relations = cinfo.p_relationships;
 
  // Filtering UID
  std::vector<dref> filtered;
 
  if ( !ui->FilterUid->text().isEmpty() )
  {
    QRegExp uidfilter ( ui->FilterUid->text() );
    uidfilter.setPatternSyntax ( QRegExp::Wildcard );
 
    for ( dbe::dref const & it : objs )
    {
 
      if ( uidfilter.exactMatch ( QString::fromStdString ( it.ref().UID() ) ) )
      {
        filtered.push_back ( it );
      }
    }
 
    objs = filtered;
    filtered.clear();
  }
 
  QRegExp attribute_filter ( ui->AttributeValueFilter->text() );
  attribute_filter.setPatternSyntax ( QRegExp::Wildcard );
 
  std::string selected_attribute_name = ui->AttributeComboBox->currentText().toStdString();
 
  std::vector<dunedaq::conffwk::attribute_t>::const_iterator attrdef = std::find_if (
                                                                    std::begin ( attributes ), std::end ( attributes ),
                                                                    [&selected_attribute_name] ( dunedaq::conffwk::attribute_t const & attr )
  {
    return attr.p_name == selected_attribute_name;
  } );
 
  if ( attrdef != std::end ( attributes ) )
  {
    for ( dbe::dref const & it : objs )
    {
      QStringList values
      { dbe::config::api::get::attribute::list<QStringList> ( it.ref(), *attrdef ) };
 
      for ( QString & v : values )
        if ( attribute_filter.exactMatch ( v ) )
        {
          filtered.push_back ( it );
          break;
        }
    }
 
  }
 
  objs = filtered;
  filtered.clear();
 
  // Filter on Relationship
 
  std::string selected_relation_name =
    ui->RelationshipComboBox->currentText().toStdString();
 
  std::vector<dunedaq::conffwk::relationship_t>::const_iterator relationdef = std::find_if (
                                                                           std::begin ( relations ), std::end ( relations ),
                                                                           [&selected_relation_name] ( dunedaq::conffwk::relationship_t const & rel )
  {
    return rel.p_name == selected_relation_name;
  } );
 
  if ( relationdef != std::end ( relations ) )
  {
    QRegExp relation_filter ( ui->RelationshipValueFilter->currentText() );
    relation_filter.setPatternSyntax ( QRegExp::Wildcard );
 
    for ( dbe::dref const & it : objs )
    {
      QStringList ValueList
      {
        dbegraph::linked::through::relation<QStringList> (
          it.ref(), *relationdef ) };
 
      if ( ValueList.isEmpty() and ( ui->RelationshipValueFilter->currentText() == "*"
                                     or ui->RelationshipValueFilter->currentText() == "" ) )
      {
        filtered.push_back ( it );
      }
      else
      {
        for ( QString const & v : ValueList )
          if ( relation_filter.exactMatch ( v ) )
          {
            filtered.push_back ( it );
            break;
          }
      }
    }
 
  }
 
  objs = filtered;
  filtered.clear();
}

FindMatching

void dbe::BatchChangeWidget::FindMatching ( )

privateslot

Definition at line 417 of file BatchChangeWidget.cpp.

{
  QString ClassName = ui->ClassCombo->currentText();
  bool SubClasses = ui->SubclassesCheckBox->isChecked();
 
  std::vector<tref> const & tmprefs = dbe::config::api::info::onclass::objects (
                                        ClassName.toStdString(), SubClasses );
 
  std::vector<dref> candidates;
  std::copy ( tmprefs.begin(), tmprefs.end(), std::back_inserter ( candidates ) );
 
  if ( !candidates.empty() )
  {
    filter ( candidates, ClassName );
  }
 
  if ( candidates.empty() )
  {
    QMessageBox::information ( this, tr ( "Message" ), tr ( "No objects match filter!" ) );
  }
  else
  {
    int NumberOfColumns = 1;
    bool AttributeEnabled = false;
    bool RelationshipEnabled = false;
 
    if ( ui->AttributeComboBox->isEnabled() )
    {
      AttributeEnabled = true;
      NumberOfColumns++;
    }
 
    if ( ui->RelationshipComboBox->isEnabled() )
    {
      RelationshipEnabled = true;
      NumberOfColumns++;
    }
 
    m_filter_table = std::unique_ptr<QTableWidget> ( new QTableWidget() );
    m_filter_table->setWindowTitle ( tr ( "Objects matching filter" ) );
    m_filter_table->setColumnCount ( NumberOfColumns );
    m_filter_table->setRowCount ( candidates.size() );
 
    for ( size_t i = 0; i < candidates.size(); i++ )
    {
      QTableWidgetItem * AttributeValue;
      QTableWidgetItem * RelationshipValue;
 
      QTableWidgetItem * ObjectUid = new QTableWidgetItem (
        tr ( "%1@%2" ).arg ( candidates.at ( i ).UID().c_str() ).arg (
          candidates.at ( i ).class_name().c_str() ) );
      m_filter_table->setItem ( i, 0, ObjectUid );
 
      if ( AttributeEnabled )
      {
        dunedaq::conffwk::attribute_t Attribute = dbe::config::api::info::attributematch (
                                               ui->AttributeComboBox->currentText(), ClassName );
 
        QStringList AttributeValueList
        {
          dbe::config::api::get::attribute::list<QStringList> ( candidates.at ( i ).ref(),
          Attribute ) };
 
        AttributeValue = new QTableWidgetItem ( AttributeValueList.join ( " " ) );
        m_filter_table->setItem ( i, 1, AttributeValue );
      }
 
      if ( RelationshipEnabled )
      {
        dunedaq::conffwk::relationship_t Relationship = config::api::info::relation::match (
                                                     ui->RelationshipComboBox->currentText(), ClassName );
 
        QStringList RelationshipList
        {
          dbegraph::linked::through::relation<QStringList> (
            candidates.at ( i ).ref(), Relationship ) };
 
        RelationshipValue = new QTableWidgetItem ( RelationshipList.join ( " " ) );
        m_filter_table->setItem ( i, 2, RelationshipValue );
      }
    }
 
    QStringList Headers;
    Headers << "Object Id";
 
    if ( AttributeEnabled )
    {
      Headers << ui->AttributeComboBox->currentText();
    }
 
    if ( RelationshipEnabled )
    {
      Headers << ui->RelationshipComboBox->currentText();
    }
 
    m_filter_table->setHorizontalHeaderLabels ( Headers );
 
    QHeaderView * HeaderView = m_filter_table->horizontalHeader();
    HeaderView->setStretchLastSection ( true );
    m_filter_table->resize ( 500, 300 );
    m_filter_table->show();
  }
}

MakeChanges

void dbe::BatchChangeWidget::MakeChanges ( )

privateslot

Definition at line 306 of file BatchChangeWidget.cpp.

{
  std::vector<dref> Objects;
 
  BOOST_SCOPE_EXIT(&Objects, this_)
  {
      QList<QPair<QString, QString>> objs;
      for(const auto& o : Objects) {
          objs.append(QPair<QString, QString>(QString::fromStdString(o.class_name()),
                                              QString::fromStdString(o.UID())));
      }
 
      this_->emit sig_batch_change_stop(objs);
 
 
      QApplication::restoreOverrideCursor();
      this_->ui->ChangeButton->setEnabled(true);
      confaccessor::ref().blockSignals(false);
  }
  BOOST_SCOPE_EXIT_END
 
  ui->ChangeButton->setEnabled(false);
  QApplication::setOverrideCursor(Qt::WaitCursor);
  confaccessor::ref().blockSignals(true);
 
  bool SubClasses = ui->SubclassesCheckBox->isChecked();
  QString ClassName = ui->ClassCombo->currentText();
 
  std::unique_ptr<dbe::interface::messenger::batch_guard> batchmode (
    interface::messenger::qt::batchmode() );
 
  emit sig_batch_change_start();
 
  if ( not UseTable )
  {
    std::vector<tref> const & tmprefs = dbe::config::api::info::onclass::objects (
                                          ClassName.toStdString(), SubClasses );
 
    std::copy ( tmprefs.begin(), tmprefs.end(), std::back_inserter ( Objects ) );
 
    if ( not Objects.empty() )
    {
      filter ( Objects, ClassName );
    }
  }
  else
  {
    Objects = TableObjects;
  }
 
  if ( Objects.empty() ) QMessageBox::information ( this, tr ( "Message" ),
                                                      tr ( "No objects match filter!" ) );
  else
  {
    const dunedaq::conffwk::class_t & ClassInfo = dbe::config::api::info::onclass::definition (
                                               ClassName.toStdString(), false );
    const std::vector<dunedaq::conffwk::attribute_t> AttributeList = ClassInfo.p_attributes;
    const std::vector<dunedaq::conffwk::relationship_t> RelationshipList = ClassInfo
                                                                      .p_relationships;
    dunedaq::conffwk::attribute_t AttributeChange;
    dunedaq::conffwk::relationship_t RelationshipChange;
 
    for ( dunedaq::conffwk::attribute_t i : AttributeList )
      if ( i.p_name == ui->NewAttributeComboBox->currentText().toStdString() )
      {
        AttributeChange = i;
        break;
      }
 
    for ( dunedaq::conffwk::relationship_t i : RelationshipList )
      if ( i.p_name == ui->NewRelationshipComboBox->currentText().toStdString() )
      {
        RelationshipChange = i;
        break;
      }
 
    QStringList AttributeChangeList;
 
    if ( !ui->AttributeEdit->text().isEmpty() ) AttributeChangeList
          << ui->AttributeEdit->text();
 
    for ( auto objects_iter = Objects.begin(); objects_iter != Objects.end(); ++objects_iter )
    {
      tref Object = objects_iter->ref();
 
      QStringList RelationshipChangeList;
 
      if ( ui->ChangeAtrributeCheckBox->isChecked() )
      {
        if ( !AttributeChangeList.isEmpty() )
        {
          dbe::config::api::set::attribute ( Object, AttributeChange, AttributeChangeList );
        }
      }
 
      if ( ui->ChangeRelationshipCheckBox->isChecked() )
      {
        if ( ui->AddCheckBox->isChecked() )
        {
          RelationshipChangeList =
            dbegraph::linked::through::relation<QStringList> (
              Object, RelationshipChange );
        }
 
        RelationshipChangeList << ui->RelationshipEdit->currentText();
        dbe::config::api::set::relation ( Object, RelationshipChange, RelationshipChangeList );
      }
    }
  }
}

SetController()

void dbe::BatchChangeWidget::SetController ( )

private

Definition at line 84 of file BatchChangeWidget.cpp.

{
  connect ( ui->ClassCombo, SIGNAL ( activated ( QString ) ), this,
            SLOT ( FillInfo ( const QString & ) ) );
 
  connect ( ui->ChangeButton, SIGNAL ( clicked() ), this, SLOT ( MakeChanges() ) );
 
  connect ( ui->MatchButton, SIGNAL ( clicked() ), this, SLOT ( FindMatching() ) );
 
  connect ( ui->NewRelationshipComboBox, SIGNAL ( activated ( QString ) ), this,
            SLOT ( EnableCheckBox ( QString ) ) );
  connect ( ui->CancelButton, SIGNAL ( clicked() ), this, SLOT ( close() ) );
 
  connect ( ui->RelationshipComboBox, SIGNAL ( activated ( int ) ), this,
            SLOT ( UpdateRelationshipFilter ( int ) ) );
 
  connect ( ui->NewRelationshipComboBox, SIGNAL ( activated ( int ) ), this,
            SLOT ( UpdateRelationshipNewValues ( int ) ) );
 
  MainWindow * mainwin = MainWindow::findthis();
 
  if ( mainwin != nullptr )
  {
    connect ( this, SIGNAL ( sig_batch_change_start() ), mainwin,
              SLOT ( slot_batch_change_start() ), Qt::UniqueConnection );
    connect ( this, SIGNAL ( sig_batch_change_stop(const QList<QPair<QString, QString>>&) ), mainwin,
              SLOT ( slot_batch_change_stop(const QList<QPair<QString, QString>>&) ),
              Qt::UniqueConnection );
  }
}

sig_batch_change_start

void dbe::BatchChangeWidget::sig_batch_change_start ( )

signal

sig_batch_change_stop

void dbe::BatchChangeWidget::sig_batch_change_stop ( const QList< QPair< QString, QString > > & )

signal

UpdateRelationshipFilter

void dbe::BatchChangeWidget::UpdateRelationshipFilter ( int )

privateslot

Definition at line 547 of file BatchChangeWidget.cpp.

{
  ui->RelationshipValueFilter->clear();
  ui->RelationshipValueFilter->addItem ( "*" );
 
  QString ClassName = ui->ClassCombo->currentText();
  QString RelationshipName = ui->RelationshipComboBox->currentText();
 
  const dunedaq::conffwk::class_t & ClassInfo = dbe::config::api::info::onclass::definition (
                                             ClassName.toStdString(), false );
  std::vector<dunedaq::conffwk::relationship_t> RelationshipList = ClassInfo.p_relationships;
 
  if ( RelationshipList.size() != 0 )
  {
    dunedaq::conffwk::relationship_t ChosenRelationship;
 
    for ( dunedaq::conffwk::relationship_t & i : RelationshipList )
    {
      if ( i.p_name == RelationshipName.toStdString() )
      {
        ChosenRelationship = i;
        break;
      }
    }
 
    std::vector<tref> const & Objects = dbe::config::api::info::onclass::objects (
                                          ChosenRelationship.p_type );
 
    QStringList ObjectsUid;
 
    for ( tref const & Object : Objects )
    {
      ObjectsUid.append ( Object.UID().c_str() );
    }
 
    ui->RelationshipValueFilter->addItems ( ObjectsUid );
  }
}

UpdateRelationshipNewValues

void dbe::BatchChangeWidget::UpdateRelationshipNewValues ( int )

privateslot

Definition at line 586 of file BatchChangeWidget.cpp.

{
  ui->RelationshipEdit->clear();
 
  QString ClassName = ui->ClassCombo->currentText();
  QString RelationshipName = ui->NewRelationshipComboBox->currentText();
 
  const dunedaq::conffwk::class_t & ClassInfo = dbe::config::api::info::onclass::definition (
                                             ClassName.toStdString(), false );
  std::vector<dunedaq::conffwk::relationship_t> RelationshipList = ClassInfo.p_relationships;
 
  if ( RelationshipList.size() != 0 )
  {
    dunedaq::conffwk::relationship_t ChosenRelationship;
 
    for ( dunedaq::conffwk::relationship_t & i : RelationshipList )
    {
      if ( i.p_name == RelationshipName.toStdString() )
      {
        ChosenRelationship = i;
        break;
      }
    }
 
    std::vector<tref> const & Objects = dbe::config::api::info::onclass::objects (
                                          ChosenRelationship.p_type );
 
    QStringList ObjectsUid;
 
    for ( tref const & Object : Objects )
    {
      ObjectsUid.append ( Object.UID().c_str() );
    }
 
    ui->RelationshipEdit->addItems ( ObjectsUid );
  }
}

Member Data Documentation

ClassChanged

bool dbe::BatchChangeWidget::ClassChanged

private

Definition at line 36 of file BatchChangeWidget.hpp.

m_filter_table

std::unique_ptr<QTableWidget> dbe::BatchChangeWidget::m_filter_table

private

Definition at line 39 of file BatchChangeWidget.hpp.

TableClass

QString dbe::BatchChangeWidget::TableClass

private

Definition at line 38 of file BatchChangeWidget.hpp.

TableObjects

std::vector<dref> dbe::BatchChangeWidget::TableObjects

private

Definition at line 34 of file BatchChangeWidget.hpp.

ui

std::unique_ptr<dbe::Ui::BatchChangeWidget> dbe::BatchChangeWidget::ui

private

Definition at line 33 of file BatchChangeWidget.hpp.

UseTable

bool dbe::BatchChangeWidget::UseTable

private

Definition at line 36 of file BatchChangeWidget.hpp.

---

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

• /github/workspace/dunedaq/sourcecode/dbe/include/dbe/BatchChangeWidget.hpp
• /github/workspace/dunedaq/sourcecode/dbe/src/widgets/BatchChangeWidget.cpp