confobject_desc.hpp

Go to the documentation of this file.

/*
 * confobject_desc.hpp
 *
 *  Created on: Jan 14, 2016
 *      Author: Leonidas Georgopoulos
 */
 
#ifndef DBE_CONFOBJECT_DESC_HPP_
#define DBE_CONFOBJECT_DESC_HPP_
 
#include "dbe/config_object_key.hpp"
#include "dbe/config_reference.hpp"
 
#include <QStringList>
#include <map>
#include <string>
#include <vector>
#include <iterator>
 
namespace dbe
{
//------------------------------------------------------------------------------------------
template<typename S = std::string>
class config_object_description: private config_object_key<S>
{
private:
  mutable inner::configobject::tref this_referenced_object;
  S this_file;
 
  friend void transfer ( config_object_description & one,
                         config_object_description & another ) noexcept
  {
    std::swap ( one.this_referenced_object, another.this_referenced_object );
    std::swap ( one.this_class, another.this_class );
    std::swap ( one.this_name, another.this_name );
    std::swap ( one.this_file, another.this_file );
  }
 
public:
  config_object_description ( dbe::inner::configobject::tref const & o ) noexcept ( false )
    : config_object_key<S>
  { o.UID(), o.class_name() },
  this_referenced_object ( o ),
  this_file ( o.contained_in() )
  {
  }
 
  config_object_description ( config_object_description const & other )
    : config_object_key<S>
  { other.this_name, other.this_class },
  this_referenced_object
  { other.this_referenced_object },
  this_file ( other.this_file )
  {
 
  }
 
  config_object_description operator= ( config_object_description other )
  {
    transfer ( *this, other );
    return *this;
  }
 
  S UID() const
  {
    return this->this_name;
  }
 
  S class_name() const
  {
    return this->this_class;
  }
 
  S contained_in() const
  {
    return this->this_file;
  }
 
  bool is_valid() const
  {
    return not this_referenced_object.is_null();
  }
 
  inner::configobject::tref ref() const;
 
};
typedef config_object_description<> dref;
//------------------------------------------------------------------------------------------
 
//------------------------------------------------------------------------------------------
template<typename S = std::string, typename I = std::string, typename A = std::string,
         template<typename ... > class V = std::vector, template <typename ...> class M = std::map >
struct config_object_image
{
  typedef S type_str;
  typedef I type_image;
  typedef A type_attribute_value;
 
  typedef V<type_image> type_images;
  typedef V<type_attribute_value> type_attributes;
 
  typedef M<type_str, type_attributes> type_attrmap;
  typedef M<type_str, type_images> type_relmap;
 
  typedef type_str type_file_name;
 
  type_attrmap attributes;
  type_relmap relations;
 
  type_image ref;
  type_file_name fn;
};
//------------------------------------------------------------------------------------------
 
//------------------------------------------------------------------------------------------
template<typename S> using config_object_preimage =
  config_object_image<S, config_object_key<S>, S>;
typedef config_object_preimage<std::string> t_config_object_preimage;
//------------------------------------------------------------------------------------------
 
//------------------------------------------------------------------------------------------
template<typename S = std::string>
struct config_object_representation
{
  typedef S t_str;
  typedef config_object_description<S> t_confobject;
  typedef std::vector<t_confobject> t_confobjects;
  typedef std::map<S, QStringList> t_attrmap;
  typedef std::map<S, t_confobjects> t_relmap;
 
  t_attrmap attributes;
  t_relmap relations;
 
  t_confobject ref;
 
  t_config_object_preimage toimage()
  {
    t_config_object_preimage::type_attrmap lattributes;
    t_config_object_preimage::type_relmap lrelations;
 
    std::for_each ( std::begin ( this->attributes ), std::end ( this->attributes ),
                    [&lattributes] ( typename std::pair<S, QStringList> const & e )
    {
      t_config_object_preimage::type_attrmap::value_type::second_type v;
 
      for ( auto const & x : e.second )
      {
        v.push_back ( x.toStdString() );
      }
 
      lattributes.insert ( std::make_pair ( e.first, v ) );
    } );
 
    std::for_each ( std::begin ( this->relations ), std::end ( this->relations ),
                    [&lrelations] ( typename t_relmap::value_type const & e )
    {
      t_config_object_preimage::type_relmap::value_type::second_type v;
 
      for ( t_confobject const & x : e.second )
      {
        v.push_back ( { x.UID(), x.class_name() } );
      }
 
      lrelations.insert ( std::make_pair ( e.first, v ) );
    } );
 
    return
    {
      lattributes, lrelations,
      { this->ref.UID(), this->ref.class_name() }, this->ref.contained_in() };
  }
};
typedef config_object_representation<> t_config_object_rep;
//------------------------------------------------------------------------------------------
 
}// end namespace dbe
 
#endif /* DBE_CONFOBJECT_DESC_HPP_ */