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);
    std::cout << "line=" << line << " nsamples=" << nsamples << "\n";
  }
  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);