dbe::ui::config::info Class Reference

#include <config_ui_info.hpp>

Public Member Functions
	info (std::vector< std::string > const &file)
GraphicalClass	graphical (std::string const &) const
ViewConfiguration	view (std::string const &) const
Window	window (std::string const &) const
std::vector< Window >	windows () const
std::vector< ViewConfiguration >	views () const
std::vector< GraphicalClass >	graphicals () const

Private Member Functions
void	parse ()
void	parse_graphical (std::shared_ptr< dunedaq::conffwk::Configuration >, dunedaq::conffwk::ConfigObject &)
void	parse_window (std::shared_ptr< dunedaq::conffwk::Configuration >, dunedaq::conffwk::ConfigObject &)

Private Attributes
std::map< std::string, Window >	this_windows
std::map< std::string, GraphicalClass >	this_graphical
std::map< std::string, ViewConfiguration >	this_views
std::vector< std::string >	this_full_filenames

Detailed Description

Class used to read the current partition configuration in order to retrieve parameter for running the application and other necessary parameters

Definition at line 36 of file config_ui_info.hpp.

Constructor & Destructor Documentation

info()

dbe::ui::config::info::info

(

std::vector< std::string > const &

file

)

Definition at line 29 of file config_ui_info.cpp.

  : this_full_filenames ( full_file_name )
{
  parse();
}

Member Function Documentation

graphical()

dbe::GraphicalClass dbe::ui::config::info::graphical

(

std::string const &

name

)

const

Definition at line 35 of file config_ui_info.cpp.

{
  std::map<std::string, GraphicalClass>::const_iterator it = this_graphical.find ( name );
 
  if ( it != this_graphical.end() )
  {
    return it->second;
  }
  else
  {
    return
      {};
  }
}

graphicals()

std::vector< dbe::GraphicalClass > dbe::ui::config::info::graphicals

(

)

const

Definition at line 376 of file config_ui_info.cpp.

{
  std::vector<dbe::GraphicalClass> the_graphicals;
 
  for ( auto const & x : this_graphical )
  {
    the_graphicals.push_back ( x.second );
  }
 
  return the_graphicals;
}

parse()

void dbe::ui::config::info::parse ( )

private

Definition at line 80 of file config_ui_info.cpp.

{
  for ( std::string const & fname : this_full_filenames )
  {
    std::string Implementation = "oksconflibs:" + fname;
 
    try
    {
      std::shared_ptr<Configuration> ConfigFile ( new Configuration ( Implementation ) );
      std::vector<ConfigObject> objects;
 
      ConfigFile->get ( "Class", objects );
 
      for ( ConfigObject & aclass : objects )
      {
        parse_graphical ( ConfigFile, aclass );
      }
 
      objects.clear();
      ConfigFile->get ( "Window", objects );
 
      for ( ConfigObject & awindow : objects )
      {
        parse_window ( ConfigFile, awindow );
      }
    }
    catch ( dunedaq::conffwk::Exception const & ex )
    {
      ERROR ( "Configuration database load did not succeed",
              dbe::config::errors::parse ( ex ).c_str() );
    }
  }
}

parse_graphical()

void dbe::ui::config::info::parse_graphical ( std::shared_ptr< dunedaq::conffwk::Configuration > ConfigFile, dunedaq::conffwk::ConfigObject & Object )

private

Definition at line 114 of file config_ui_info.cpp.

{
  GraphicalClass GraphicalClassObject;
 
  GraphicalClassObject.GraphicalUID = QString ( Object.UID().c_str() );
  dunedaq::conffwk::class_t cinfo = ConfigFile->get_class_info ( Object.class_name(), false );
 
  std::vector<dunedaq::conffwk::attribute_t> const & attributes = cinfo.p_attributes;
  std::vector<dunedaq::conffwk::relationship_t> const & relations = cinfo.p_relationships;
 
  for ( dunedaq::conffwk::attribute_t const & attr : attributes )
  {
    QStringList data = dbe::config::api::get::direct::attribute<QStringList> ( Object, attr );
 
    if ( attr.p_name == "Name" )
    {
      GraphicalClassObject.DatabaseClassName = data.at ( 0 );
    }
    else if ( attr.p_name == "Generic Pixmap File" )
    {
      GraphicalClassObject.GenericPixmapFile = data.at ( 0 );
    }
    else if ( attr.p_name == "Used Pixmap File" )
    {
      GraphicalClassObject.UsedPixmapFile = data.at ( 0 );
    }
    else if ( attr.p_name == "Icon Bitmap File" )
    {
      GraphicalClassObject.BitmapFile = data.at ( 0 );
    }
    else if ( attr.p_name == "Icon Mask Bitmap File" )
    {
      GraphicalClassObject.BitmapMaskFile = data.at ( 0 );
    }
    else if ( attr.p_name == "Show All Attributes" )
    {
      GraphicalClassObject.ShowAllAttributes = convert::to<bool> (
                                                 data, attr.p_int_format );
    }
    else if ( attr.p_name == "Attributes" )
    {
      GraphicalClassObject.Attributes = data;
    }
    else if ( attr.p_name == "Show All Relationships" )
    {
      GraphicalClassObject.ShowAllRelationships = convert::to<bool> (
                                                    data, attr.p_int_format );
    }
    else if ( attr.p_name == "Relationships" )
    {
      GraphicalClassObject.Relationships = data;
 
    }
    else if ( attr.p_name == "Icon Title" )
    {
      GraphicalClassObject.IconTitle = data.at ( 0 );
    }
  }
 
  for ( dunedaq::conffwk::relationship_t const & relation : relations )
  {
    QStringList data;
    std::vector<ConfigObject> neighboring
    { };
 
    if ( dbe::config::api::info::relation::is_simple ( relation ) )
    {
      neighboring.push_back (
        dbe::config::api::graph::direct::linked<ConfigObject> ( Object, relation ) );
    }
    else
    {
      std::vector<ConfigObject> objects = dbe::config::api::graph::direct::linked <
                                          std::vector<ConfigObject >> ( Object, relation );
      neighboring.insert ( std::end ( neighboring ), std::begin ( objects ),
                           std::end ( objects ) );
    }
 
    for ( ConfigObject & RelObject : neighboring )
    {
      dunedaq::conffwk::class_t RelClassInfo = ConfigFile->get_class_info ( RelObject.class_name(),
                                                                       false );
      std::vector<dunedaq::conffwk::attribute_t> AttributeRelList = RelClassInfo.p_attributes;
 
      if ( RelObject.class_name() == "Dual Relationship" )
      {
        DualRelationship DRel;
 
        for ( dunedaq::conffwk::attribute_t & Attribute : AttributeRelList )
        {
          data = dbe::config::api::get::direct::attribute<QStringList> ( RelObject,
                                                                         Attribute );
 
          if ( Attribute.p_name == "Direct" )
          {
            DRel.Direct = data.at ( 0 );
          }
          else if ( Attribute.p_name == "Reverse" )
          {
            DRel.Reverse = data.at ( 0 );
          }
        }
 
        GraphicalClassObject.DualRelationships.push_back ( DRel );
      }
      else if ( RelObject.class_name() == "Init Attribute Value" )
      {
        InitAttributeFromEnv IRel;
 
        for ( dunedaq::conffwk::attribute_t & Attribute : AttributeRelList )
        {
          data = dbe::config::api::get::direct::attribute<QStringList> ( RelObject,
                                                                         Attribute );
 
          if ( Attribute.p_name == "Attribute Name" )
          {
            IRel.AttributeName = data.at ( 0 );
          }
          else if ( Attribute.p_name == "Environment Variables" )
          {
            IRel.EnvNames = data;
          }
        }
 
        GraphicalClassObject.NeedToInitialize.push_back ( IRel );
      }
    }
  }
 
  this_graphical.emplace ( GraphicalClassObject.GraphicalUID.toStdString(),
                           GraphicalClassObject );
 
}

parse_window()

void dbe::ui::config::info::parse_window ( std::shared_ptr< dunedaq::conffwk::Configuration > database, dunedaq::conffwk::ConfigObject & object )

private

Definition at line 249 of file config_ui_info.cpp.

{
  Window WindowObject;
  dunedaq::conffwk::class_t ClassInfo = database->get_class_info ( object.class_name(), false );
  std::vector<dunedaq::conffwk::attribute_t> const & attributes = ClassInfo.p_attributes;
  std::vector<dunedaq::conffwk::relationship_t> const & relations = ClassInfo.p_relationships;
 
  for ( dunedaq::conffwk::attribute_t const & attribute : attributes )
  {
    if ( attribute.p_name == "Title" )
    {
      WindowObject.Title = dbe::config::api::get::direct::attribute<QStringList> ( object,
                                                                                   attribute ).at (
                             0 );
    }
  }
 
  for ( dunedaq::conffwk::relationship_t const & relation : relations )
  {
    std::vector<ConfigObject> linkedobjects;
 
    if ( dbe::config::api::info::relation::is_simple ( relation ) )
    {
      linkedobjects.push_back (
        dbe::config::api::graph::direct::linked<ConfigObject> ( object, relation ) );
    }
    else
    {
      std::vector<ConfigObject> voisins = dbe::config::api::graph::direct::linked <
                                          std::vector<ConfigObject >> ( object, relation );
 
      if ( not voisins.empty() )
      {
        linkedobjects.insert ( std::end ( linkedobjects ), std::begin ( voisins ),
                               std::end ( voisins ) );
      }
    }
 
    for ( ConfigObject & neighbor : linkedobjects )
    {
      dunedaq::conffwk::class_t classinfo = database->get_class_info ( neighbor.class_name(),
                                                                  false );
      std::vector<dunedaq::conffwk::attribute_t> const & AttributeRelList = classinfo
                                                                       .p_attributes;
      std::vector<dunedaq::conffwk::relationship_t> const & RelationshipRelList = classinfo
                                                                             .p_relationships;
 
      if ( neighbor.class_name() != "Window Separator" )
      {
        for ( dunedaq::conffwk::attribute_t const & Attribute : AttributeRelList )
        {
          if ( Attribute.p_name == "Shown with children" )
          {
            QStringList neighbor_names
            { dbe::config::api::get::direct::attribute<QStringList> ( neighbor, Attribute ) };
 
            if ( neighbor_names.at ( 0 ) != "none" )
            {
              WindowObject.ShowChildren = true;
            }
            else
            {
              WindowObject.ShowChildren = false;
            }
          }
        }
 
        for ( dunedaq::conffwk::relationship_t const & RelationshipRel : RelationshipRelList )
        {
          QStringList RelDataList;
          std::vector<ConfigObject> neighboring_nodes;
 
          if ( dbe::config::api::info::relation::is_simple ( RelationshipRel ) )
          {
            neighboring_nodes.push_back (
              dbe::config::api::graph::direct::linked<ConfigObject> ( neighbor,
                                                                      RelationshipRel ) );
          }
          else
          {
 
            std::vector<ConfigObject> neighbors = dbe::config::api::graph::direct::linked <
                                                  std::vector<ConfigObject >> ( neighbor, RelationshipRel );
 
            neighboring_nodes.insert ( std::end ( neighboring_nodes ), std::begin ( neighbors ),
                                       std::end ( neighbors ) );
          }
 
          for ( ConfigObject & RelDataObject : neighboring_nodes )
          {
            RelDataList.push_back ( QString ( RelDataObject.UID().c_str() ) );
          }
 
          WindowObject.GraphicalClassesList.push_back ( RelDataList.at ( 0 ) );
        }
      }
    }
  }
 
  this_windows.emplace ( WindowObject.Title.toStdString(), WindowObject );
}

view()

dbe::ViewConfiguration dbe::ui::config::info::view

(

std::string const &

name

)

const

Definition at line 50 of file config_ui_info.cpp.

{
  std::map<std::string, ViewConfiguration>::const_iterator it = this_views.find ( name );
 
  if ( it != this_views.end() )
  {
    return it->second;
  }
  else
  {
    return
      {};
  }
}

views()

std::vector< dbe::ViewConfiguration > dbe::ui::config::info::views

(

)

const

Definition at line 364 of file config_ui_info.cpp.

{
  std::vector<dbe::ViewConfiguration> views;
 
  for ( auto const & x : this_views )
  {
    views.push_back ( x.second );
  }
 
  return views;
}

window()

dbe::Window dbe::ui::config::info::window

(

std::string const &

name

)

const

Definition at line 65 of file config_ui_info.cpp.

{
  std::map<std::string, Window>::const_iterator it = this_windows.find ( name );
 
  if ( it != this_windows.end() )
  {
    return it->second;
  }
  else
  {
    return
      {};
  }
}

windows()

std::vector< dbe::Window > dbe::ui::config::info::windows

(

)

const

Definition at line 352 of file config_ui_info.cpp.

{
  std::vector<dbe::Window> windows;
 
  for ( auto const & x : this_windows )
  {
    windows.push_back ( x.second );
  }
 
  return windows;
}

Member Data Documentation

this_full_filenames

std::vector<std::string> dbe::ui::config::info::this_full_filenames

private

Definition at line 58 of file config_ui_info.hpp.

this_graphical

std::map<std::string, GraphicalClass> dbe::ui::config::info::this_graphical

private

Definition at line 55 of file config_ui_info.hpp.

this_views

std::map<std::string, ViewConfiguration> dbe::ui::config::info::this_views

private

Definition at line 56 of file config_ui_info.hpp.

this_windows

std::map<std::string, Window> dbe::ui::config::info::this_windows

private

Definition at line 54 of file config_ui_info.hpp.

---

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

• /github/workspace/dunedaq/sourcecode/dbe/include/dbe/config_ui_info.hpp
• /github/workspace/dunedaq/sourcecode/dbe/src/internal/config_ui_info.cpp