Utils.cpp

Go to the documentation of this file.

 
#include "opmonlib/Utils.hpp"
 
dunedaq::opmon::OpMonId
dunedaq::opmonlib::make_origin(const std::string& session, const std::string& app)
{
  opmon::OpMonId origin;
  origin.set_session(session);
  origin.set_application(app);
  return origin;
}
 
dunedaq::opmon::OpMonEntry
dunedaq::opmonlib::to_entry(const google::protobuf::Message& m, const CustomOrigin& co)
{
 
  dunedaq::opmon::OpMonEntry entry;
  entry.set_measurement(m.GetTypeName());
 
  *entry.mutable_data() = dunedaq::opmonlib::to_map(m);
 
  for (const auto& [tag, value] : co) {
    (*entry.mutable_custom_origin())[tag] = value;
  }
 
  return entry;
}
 
dunedaq::opmonlib::map_type
dunedaq::opmonlib::to_map(const google::protobuf::Message& m, std::string top_block)
{
 
  dunedaq::opmonlib::map_type ret;
 
  const auto* descriptor_p = m.GetDescriptor();
  const auto& des = *descriptor_p;
 
  const auto* reflection_p = m.GetReflection();
  const auto& ref = *reflection_p;
 
  using namespace google::protobuf;
 
  auto count = des.field_count();
  for (int i = 0; i < count; ++i) {
    const auto* field_p = des.field(i);
    if (field_p->is_repeated())
      continue;
 
    auto name = top_block.empty() ? field_p->name() : top_block + '.' + field_p->name();
 
    auto type = field_p->cpp_type();
    dunedaq::opmon::OpMonValue value;
    bool success = true;
    switch (type) {
      case FieldDescriptor::CppType::CPPTYPE_INT32:
        value.set_int4_value(ref.GetInt32(m, field_p));
        break;
      case FieldDescriptor::CppType::CPPTYPE_INT64:
        value.set_int8_value(ref.GetInt64(m, field_p));
        break;
      case FieldDescriptor::CppType::CPPTYPE_UINT32:
        value.set_uint4_value(ref.GetUInt32(m, field_p));
        break;
      case FieldDescriptor::CppType::CPPTYPE_UINT64:
        value.set_uint8_value(ref.GetUInt64(m, field_p));
        break;
      case FieldDescriptor::CppType::CPPTYPE_DOUBLE:
        value.set_double_value(ref.GetDouble(m, field_p));
        break;
      case FieldDescriptor::CppType::CPPTYPE_FLOAT:
        value.set_float_value(ref.GetFloat(m, field_p));
        break;
      case FieldDescriptor::CppType::CPPTYPE_BOOL:
        value.set_boolean_value(ref.GetBool(m, field_p));
        break;
      case FieldDescriptor::CppType::CPPTYPE_STRING:
        value.set_string_value(ref.GetString(m, field_p));
        break;
      case FieldDescriptor::CppType::CPPTYPE_MESSAGE: {
        auto data = dunedaq::opmonlib::to_map(ref.GetMessage(m, field_p), name);
        ret.insert(data.begin(), data.end());
        success = false;
        break;
      }
      default:
        success = false;
        break;
    } // switch on the cpp type
 
    if (success)
      ret[name] = value;
  }
 
  return ret;
}
 
void
dunedaq::opmonlib::from_entry(google::protobuf::Message& m, const dunedaq::opmon::OpMonEntry& e, std::string top_block)
{
 
  const auto* descriptor_p = m.GetDescriptor();
  const auto& des = *descriptor_p;
 
  const auto* reflection_p = m.GetReflection();
  const auto& ref = *reflection_p;
 
  using namespace google::protobuf;
 
  auto count = des.field_count();
  for (int i = 0; i < count; ++i) {
    const auto* field_p = des.field(i);
    if (field_p->is_repeated())
      continue;
 
    auto name = top_block.empty() ? field_p->name() : top_block + '.' + field_p->name();
 
    auto type = field_p->cpp_type();
 
    if (type == FieldDescriptor::CppType::CPPTYPE_MESSAGE) {
      auto message = ref.MutableMessage(&m, field_p);
      from_entry(*message, e, name);
    } else {
 
      auto value = e.data().find(name)->second;
 
      switch (type) {
        case FieldDescriptor::CppType::CPPTYPE_INT32:
          ref.SetInt32(&m, field_p, value.int4_value());
          break;
        case FieldDescriptor::CppType::CPPTYPE_INT64:
          ref.SetInt64(&m, field_p, value.int8_value());
          break;
        case FieldDescriptor::CppType::CPPTYPE_UINT32:
          ref.SetUInt32(&m, field_p, value.uint4_value());
          break;
        case FieldDescriptor::CppType::CPPTYPE_UINT64:
          ref.SetUInt64(&m, field_p, value.uint8_value());
          break;
        case FieldDescriptor::CppType::CPPTYPE_DOUBLE:
          ref.SetDouble(&m, field_p, value.double_value());
          break;
        case FieldDescriptor::CppType::CPPTYPE_FLOAT:
          ref.SetFloat(&m, field_p, value.float_value());
          break;
        case FieldDescriptor::CppType::CPPTYPE_BOOL:
          ref.SetBool(&m, field_p, value.boolean_value());
          break;
        case FieldDescriptor::CppType::CPPTYPE_STRING:
          ref.SetString(&m, field_p, value.string_value());
          break;
        default:
          break;
      } // switch on the cpp type
    } // else if it's a message
  } // loop over the fields
}
 
std::string
dunedaq::opmonlib::to_string(const dunedaq::opmon::OpMonId& id)
{
 
  std::string ret(id.session());
 
  if (!id.application().empty()) {
    ret += '.';
    ret += id.application();
  }
 
  for (int i = 0; i < id.substructure().size(); ++i) {
    ret += '.';
    ret += id.substructure()[i];
  }
 
  return ret;
}
 
const dunedaq::opmon::OpMonId&
dunedaq::opmonlib::operator+=(dunedaq::opmon::OpMonId& id, const std::string& element)
{
 
  if (element.empty())
    return id;
 
  if (id.session().empty()) {
    id.set_session(element);
    return id;
  }
 
  if (id.application().empty()) {
    id.set_application(element);
    return id;
  }
 
  id.add_substructure(element);
  return id;
}
 
dunedaq::opmon::OpMonId
dunedaq::opmonlib::operator+(const dunedaq::opmon::OpMonId& id, const std::string& element)
{
 
  auto ret = id;
  ret += element;
  return ret;
}
 
//---------------------------------------------------
// template specifications for setters by name
//---------------------------------------------------
template<>
void
dunedaq::opmonlib::set_value<int32_t>(const google::protobuf::Reflection& r,
                                      google::protobuf::Message& m,
                                      const google::protobuf::FieldDescriptor* f_p,
                                      int32_t value)
{
 
  r.SetInt32(&m, f_p, value);
}
 
template<>
void
dunedaq::opmonlib::set_value<int64_t>(const google::protobuf::Reflection& r,
                                      google::protobuf::Message& m,
                                      const google::protobuf::FieldDescriptor* f_p,
                                      int64_t value)
{
 
  r.SetInt64(&m, f_p, value);
}
 
template<>
void
dunedaq::opmonlib::set_value<uint32_t>(const google::protobuf::Reflection& r,
                                       google::protobuf::Message& m,
                                       const google::protobuf::FieldDescriptor* f_p,
                                       uint32_t value)
{
 
  r.SetUInt32(&m, f_p, value);
}
 
template<>
void
dunedaq::opmonlib::set_value<uint64_t>(const google::protobuf::Reflection& r,
                                       google::protobuf::Message& m,
                                       const google::protobuf::FieldDescriptor* f_p,
                                       uint64_t value)
{
 
  r.SetUInt64(&m, f_p, value);
}
 
template<>
void
dunedaq::opmonlib::set_value<double>(const google::protobuf::Reflection& r,
                                     google::protobuf::Message& m,
                                     const google::protobuf::FieldDescriptor* f_p,
                                     double value)
{
 
  r.SetDouble(&m, f_p, value);
}
 
template<>
void
dunedaq::opmonlib::set_value<float>(const google::protobuf::Reflection& r,
                                    google::protobuf::Message& m,
                                    const google::protobuf::FieldDescriptor* f_p,
                                    float value)
{
 
  r.SetFloat(&m, f_p, value);
}
 
template<>
void
dunedaq::opmonlib::set_value<bool>(const google::protobuf::Reflection& r,
                                   google::protobuf::Message& m,
                                   const google::protobuf::FieldDescriptor* f_p,
                                   bool value)
{
 
  r.SetBool(&m, f_p, value);
}
 
template<>
void
dunedaq::opmonlib::set_value<std::string>(const google::protobuf::Reflection& r,
                                          google::protobuf::Message& m,
                                          const google::protobuf::FieldDescriptor* f_p,
                                          std::string value)
{
 
  r.SetString(&m, f_p, value);
}