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 31 of file config_ui_info.hpp.

Constructor & Destructor Documentation

info()

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

(

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

file

)

Definition at line 24 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 30 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 371 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 75 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 109 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 244 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 45 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 359 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 60 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 347 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 53 of file config_ui_info.hpp.

this_graphical

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

private

Definition at line 50 of file config_ui_info.hpp.

this_views

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

private

Definition at line 51 of file config_ui_info.hpp.

this_windows

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

private

Definition at line 49 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