parser.cc

Go to the documentation of this file.

#include "parser.h"
#include <exception>
#include <sstream>
#include <boost/algorithm/string.hpp>
#include <iostream>
 
Parser::Parser(const std::string& d, char t)
{
  std::istringstream iss(d);
  std::string        token;
 
  while (std::getline(iss, token, t)) {
    boost::algorithm::trim(token);
    size_t      pos   = token.find('=');
    std::string key   = token.substr(0, pos);
    std::string value = token.substr(pos + 1);
    boost::algorithm::trim(key);
    boost::algorithm::trim(value);
    mmap.insert(std::pair<std::string, std::string>(key, value));
  }
}
 
std::vector<std::string> Parser::Find(const std::string& tag)
{
  std::vector<std::string> r;
  auto                     i = mmap.equal_range(tag);
  for (auto it = i.first; it != i.second; ++it) {
    r.push_back(it->second);
  }
 
  return r;
}
 
std::string Parser::Find(const std::string& tag, size_t index,
                         std::string value)
{
  std::vector<std::string> result = Find(tag);
 
  if (result.size() > index) {
    return result[index];
  }
  return value;
}
 
template<typename T>
std::optional<Waveform<T>> parseWaveformSamples(const std::string& adf_waveform_line)
{
  // remove multiple spaces, if any
  std::string str(adf_waveform_line);
 
  std::string::iterator new_end = std::unique(str.begin(), str.end(), [](char a, char b)
                                              { return a == b && a == ' '; });
 
  str.erase(new_end, str.end());
 
  // now decode the string
  std::istringstream ins(str);
  std::string        line;
 
  std::vector<T> waveform_samples;
  int            waveform_id{};
 
  std::getline(ins, line, ' ');
  try {
    waveform_id = std::stoi(line);
  }
  catch (std::exception const& ex) {
    std::cerr << "could not parse the waveform_id:" << ex.what() << "\n";
    return std::nullopt;
  }
 
  size_t nsamples{};
 
  std::getline(ins, line, ' ');
  try {
    nsamples = std::stoi(line);
  }
  catch (std::exception const& ex) {
    std::cerr << "could not parse the waveform_id:" << ex.what() << "\n";
    return std::nullopt;
  }
 
  waveform_samples.reserve(nsamples);
 
  while (std::getline(ins, line, ' ')) {
    T sample = atof(line.c_str());
    waveform_samples.push_back(sample);
  }
  if (waveform_samples.size() != nsamples) {
    std::cerr << "mismatched number of samples : expecting " << nsamples << " but got " << waveform_samples.size() << "\n";
    return std::nullopt;
  }
 
  return Waveform<T>{waveform_id, waveform_samples};
}
 
// instanciate the only two versions of parseWaveformSamples
// that we really support
template std::optional<Waveform<float>>  parseWaveformSamples(const std::string& adf_waveform_line);
template std::optional<Waveform<double>> parseWaveformSamples(const std::string& adf_waveform_line);
 
std::optional<DOMConfig> parseDOMConfiguration(const std::string& dom_configuration_line)
{
  if (dom_configuration_line.empty()) {
    return std::nullopt;
  }
  std::stringstream iss(dom_configuration_line);
  int               dom_id;
  iss >> dom_id;
  if (iss.eof()) {
    return std::nullopt;
  }
  int number_of_probes;
  iss >> number_of_probes;
  if (iss.eof() || number_of_probes <= 0) {
    return std::nullopt;
  }
  std::vector<ProbeConfig> probe_configs;
  while (probe_configs.size() < number_of_probes) {
    int id;
    iss >> id;
    if (iss.eof()) {
      return std::nullopt;
    }
    int threshold;
    iss >> threshold;
    if (iss.eof()) {
      return std::nullopt;
    }
    probe_configs.push_back(ProbeConfig{id, threshold});
  }
  if (iss.eof()) {
    return std::nullopt;
  }
  int debug_write;
  iss >> debug_write;
  if (!iss.eof()) {
    return std::nullopt;
  }
  return DOMConfig{dom_id, probe_configs, debug_write};
}