dbe::model_common_async_operations< T > Class Template Reference

#include <model_common_interface.hpp>

Public Member Functions
MODEL_COMMON_TYPES_TOPLEVEL_DEFINITIONS	model_common_async_operations ()
void	model_common_connections ()

Protected Member Functions
void	remove_object (type_object_info const &)
void	create_object (type_object_info const &)
void	rename_object (type_object_info const &)
void	update_object (type_object_info const &)
void	update_multiple_objects (std::vector< type_object_info > const &)

Detailed Description

template<typename T>
class dbe::model_common_async_operations< T >

Provides a unified manner to handle implemented methods in derived classes of model_common_slots::slot_... methods (e.g. defined with MODEL_COMMON_INTERFACE_SLOTS... macros ) by first looking up for the object at hand.

Each of the methods in this class are called from the derived class causing a call chain Derived::slot -> model_common_async_operations method -> implemented method in Derived class

e.g. for object deletion

T::slot_remove_object -> remove_object -> T::remove_deleted_object

Definition at line 254 of file model_common_interface.hpp.

Constructor & Destructor Documentation

model_common_async_operations()

template<typename T>

dbe::model_common_async_operations< T >::model_common_async_operations ( )

inline

Definition at line 125 of file model_common_operations.hpp.

  : MODEL_COMMON_INTERFACE_UUID_DECL
{
}
//------------------------------------------------------------------------------------------
 
//------------------------------------------------------------------------------------------
// FOR FUTURE USE
// template<typename T> inline std::vector<dbe::dref> dbe::model_common_impl<T>::filter_indices(
//    type_indices::iterator b, type_indices::iterator e)
//{
//  typedef std::set<decltype(b->row())> t_qrows;
//  typedef std::vector<dref> t_objects;
//
//  t_objects objects_to_act_upon;
//  t_indices indices_to_check;
//
//  for(t_indices::iterator iter = b ; iter != e ; ++iter)
//  {
//    if(iter->isValid() and iter->column() == 0)
//    {
//      dref o = static_cast<T *>(this)->getobject(*iter);
//      if(o.is_valid())
//      {
//        indices_to_check.push_back(*iter);
//        objects_to_act_upon.push_back(o);
//      }
//    }
//  }
//
//}
//------------------------------------------------------------------------------------------
 
//------------------------------------------------------------------------------------------
template<typename T>
inline bool
dbe::model_common_impl<T>::delete_objects(type_indices::iterator b, type_indices::iterator e)
{
  typedef std::set<decltype(b->row())> t_qrows;
  typedef std::vector<type_object_info> t_objects;
  t_objects to_remove_objects;
 
  for (type_indices::iterator iter = b; iter != e; ++iter) {
    if (iter->isValid() and iter->column() == 0) {
      dref o = static_cast<T*>(this)->getobject(*iter);
 
      if (o.is_valid()) {
        to_remove_objects.push_back(o);
      }
    }
  }
 
  t_objects removed_objects;
 
  for (auto const& o : to_remove_objects) {
    if (dbe::config::api::commands::delobj(o.ref(), static_cast<T*>(this)->uuid)) {
      removed_objects.push_back(o);
    }
  }
 
  t_qrows to_remove_rows;
 
  for (auto const& o : removed_objects) {
    QModelIndex newloc = static_cast<T*>(this)->lookup(o);
 
    if (newloc.isValid()) {
      to_remove_rows.insert(newloc.row());
    }
  }
 
  t_qrows::reverse_iterator uend = to_remove_rows.rbegin();
 
  if (uend != to_remove_rows.rend()) {
    for (int count = 0, bottom = *uend, last = bottom; uend != to_remove_rows.rend(); count = 0, bottom = *uend) {
      for (; uend != to_remove_rows.rend() and count == bottom - *uend; last = *uend, ++uend, ++count)
        ;
 
      static_cast<T*>(this)->removeRows(last, count, b->parent());
    }
 
    return true;
  }
 
  return false;
}

Member Function Documentation

create_object()

template<typename T>

void dbe::model_common_async_operations< T >::create_object ( type_object_info const & obj )

inlineprotected

Definition at line 115 of file model_common_operations.hpp.

{
  type_index oid(static_cast<T*>(this)->lookup(obj));
 
  if (not oid.isValid()) {
    static_cast<T*>(this)->create_contained_object(oid, obj);
  }
}

model_common_connections()

template<typename T>

void dbe::model_common_async_operations< T >::model_common_connections ( )

inline

Setup the necessary connections to signals from confaccessor to the derived object

THIS HAS TO BE CALLED FROM THE DERIVED CLASS otherwise it will have no effect

Needs be to called from the derived class constructor to setup the connection to slots defined in the derived class, since they cannot be know before.

Definition at line 31 of file model_common_operations.hpp.

{
  static_cast<T*>(this)->connect(&confaccessor::ref(),
                                 SIGNAL(object_deleted(QString const&, dref const&)),
                                 static_cast<T*>(this),
                                 SLOT(slot_remove_object(QString const&, dref const&)));
  static_cast<T*>(this)->connect(&confaccessor::ref(),
                                 SIGNAL(object_renamed(QString const&, dref const&)),
                                 static_cast<T*>(this),
                                 SLOT(slot_rename_object(QString const&, dref const&)));
  static_cast<T*>(this)->connect(&confaccessor::ref(),
                                 SIGNAL(object_changed(QString const&, dref const&)),
                                 static_cast<T*>(this),
                                 SLOT(slot_update_object(QString const&, dref const&)));
  static_cast<T*>(this)->connect(&confaccessor::ref(),
                                 SIGNAL(object_created(QString const&, dref const&)),
                                 static_cast<T*>(this),
                                 SLOT(slot_create_object(QString const&, dref const&)));
}

remove_object()

template<typename T>

void dbe::model_common_async_operations< T >::remove_object ( type_object_info const & obj )

inlineprotected

Actually calls the derived class implementation of the prototype remove_deleted_object

Parameters

the	object to be matched and removed from the index

Definition at line 55 of file model_common_operations.hpp.

{
  type_index oid(static_cast<T*>(this)->lookup(obj));
 
  if (oid.isValid()) {
    static_cast<T*>(this)->remove_deleted_object(oid);
  }
}

rename_object()

template<typename T>

void dbe::model_common_async_operations< T >::rename_object ( type_object_info const & obj )

inlineprotected

Definition at line 66 of file model_common_operations.hpp.

{
  type_index oid(static_cast<T*>(this)->lookup(obj));
 
  if (oid.isValid()) {
    static_cast<T*>(this)->rename_contained_object(oid, obj);
  }
}

update_multiple_objects()

template<typename T>

void dbe::model_common_async_operations< T >::update_multiple_objects ( std::vector< type_object_info > const & objects )

inlineprotected

Definition at line 88 of file model_common_operations.hpp.

{
  BOOST_SCOPE_EXIT_TPL(this_)
  {
    emit static_cast<T*>(this_)->layoutChanged();
  }
  BOOST_SCOPE_EXIT_END
 
  static_cast<T*>(this)->layoutAboutToBeChanged();
 
  {
    BOOST_SCOPE_EXIT_TPL(this_)
    {
      static_cast<T*>(this_)->blockSignals(false);
    }
    BOOST_SCOPE_EXIT_END
 
    static_cast<T*>(this)->blockSignals(true);
 
    for (const auto& obj : objects) {
      static_cast<T*>(this)->update_object(obj);
    }
  }
}

update_object()

template<typename T>

void dbe::model_common_async_operations< T >::update_object ( type_object_info const & obj )

inlineprotected

Definition at line 77 of file model_common_operations.hpp.

{
  type_index oid(static_cast<T*>(this)->lookup(obj));
 
  if (oid.isValid()) {
    static_cast<T*>(this)->update_contained_object(oid, obj);
  }
}

---

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

• /github/workspace/dunedaq/sourcecode/dbe/include/dbe/model_common_interface.hpp
• /github/workspace/dunedaq/sourcecode/dbe/include/dbe/model_common_operations.hpp