RegexStrings.cpp

Go to the documentation of this file.

// Mantid Repository : https://github.com/mantidproject/mantid
//
// Copyright © 2018 ISIS Rutherford Appleton Laboratory UKRI,
//   NScD Oak Ridge National Laboratory, European Spallation Source,
//   Institut Laue - Langevin & CSNS, Institute of High Energy Physics, CAS
// SPDX - License - Identifier: GPL - 3.0 +
#include "MantidKernel/RegexStrings.h"
#include "MantidKernel/Logger.h"
#include "MantidKernel/Strings.h"
 
#include <algorithm>
#include <vector>
 
namespace Mantid::Kernel::Strings {
 
namespace {
Logger logger("Regex");
}
 
template <typename T> int StrComp(const std::string &Text, const boost::regex &Re, T &Aout, const int compNum) {
  boost::sregex_iterator m1(Text.begin(), Text.end(), Re);
  boost::sregex_iterator empty;
  // Failed search
  if (m1 == empty || static_cast<int>((*m1).size()) < compNum)
    return 0;
  int count = compNum;
  for (; count != 0; count--)
    m1++;
  return convert((*m1)[0].str(), Aout);
}
 
template <typename T> int StrComp(const char *Text, const boost::regex &Re, T &Aout, const int compNum) {
  return StrComp(std::string(Text), Re, Aout, compNum);
}
 
int StrLook(const std::string &Text, const boost::regex &Re) {
  boost::sregex_iterator m1(Text.begin(), Text.end(), Re);
  boost::sregex_iterator empty;
  // Failed search
  if (m1 == empty)
    return 0;
  return 1;
}
 
std::vector<std::string> StrParts(std::string Sdx, const boost::regex &Re) {
  std::vector<std::string> Aout;
  boost::regex_split(std::back_inserter(Aout), Sdx,
                     Re); // Destroys string in process
  return Aout;
}
 
template <typename T> int StrFullCut(std::string &Text, const boost::regex &Re, T &Aout, const int compNum) {
  boost::sregex_iterator m1(Text.begin(), Text.end(), Re);
  boost::sregex_iterator empty;
  if (m1 == empty)
    return 0;
 
  if (compNum + 1 >= static_cast<int>(m1->size()))
    return 0;
  // Mantid::Kernel::Strings::Convert to required output form
  if (!Mantid::Kernel::Strings::convert((*m1)[compNum + 1].str(), Aout))
    return 0;
  // Found object
  unsigned int zero = 0; // Needed for boost 1.40 (can't just put 0 in next line)
  Text.erase(m1->position(zero), (*m1)[0].str().length());
  return 1;
}
 
template <typename T> int StrFullCut(std::string &Text, const boost::regex &Re, std::vector<T> &Aout) {
  boost::sregex_iterator m1(Text.begin(), Text.end(), Re);
  boost::sregex_iterator empty;
  if (m1 == empty)
    return 0;
 
  logger.information() << "SFC :: \n";
  Aout.clear();
  unsigned int zero = 0; // Needed for boost 1.40
  const size_t M0 = m1->position(zero);
  size_t ML = M0;
  for (; m1 != empty; m1++) {
    for (unsigned int index = 1; index < m1->size(); index++) {
      T tmp;
      if (!Mantid::Kernel::Strings::convert((*m1)[index].str(), tmp))
        return 0;
      Aout.emplace_back(tmp);
    }
    ML = m1->position(zero) + (*m1)[0].str().length();
  }
  logger.information() << "SFC :: " << M0 << " " << ML << '\n';
  // Found object
  Text.erase(M0, ML);
  return 1;
}
 
template <> int StrFullCut(std::string &Text, const boost::regex &Re, std::vector<std::string> &Aout) {
  boost::sregex_iterator m1(Text.begin(), Text.end(), Re);
  boost::sregex_iterator empty;
  if (m1 == empty)
    return 0;
 
  unsigned int zero = 0; // Needed for boost 1.40
  const auto M0 = static_cast<int>(m1->position(zero));
  int ML = M0;
  for (; m1 != empty; m1++) {
    ML = static_cast<int>(m1->position(zero) + (*m1)[0].str().length());
    for (unsigned int index = 1; index < m1->size(); index++)
      Aout.emplace_back((*m1)[index].str());
  }
  logger.information() << "SFC :: " << M0 << " " << ML << '\n';
  // Found object
  Text.erase(M0, ML);
  return 1;
}
 
template <typename T> int StrFullSplit(const std::string &text, const boost::regex &Re, std::vector<T> &Aout) {
  boost::sregex_iterator m1(text.begin(), text.end(), Re);
  boost::sregex_iterator empty;
  for (; m1 != empty; m1++)
    for (unsigned int index = 1; index < m1->size(); index++) {
      T tmp;
      if (!Mantid::Kernel::Strings::convert((*m1)[index].str(), tmp))
        return static_cast<int>(Aout.size());
      Aout.emplace_back(tmp);
    }
  return static_cast<int>(Aout.size());
}
 
template <typename T> int StrSingleSplit(const std::string &text, const boost::regex &Re, std::vector<T> &Aout) {
  boost::sregex_iterator m1(text.begin(), text.end(), Re);
  boost::sregex_iterator empty;
  if (m1 != empty)
    for (unsigned int index = 1; index < m1->size(); index++) {
      T tmp;
      if (!Mantid::Kernel::Strings::convert((*m1)[index].str(), tmp))
        return static_cast<int>(Aout.size());
      Aout.emplace_back(tmp);
    }
 
  return static_cast<int>(Aout.size());
}
 
template <> int StrSingleSplit(const std::string &text, const boost::regex &Re, std::vector<std::string> &Aout) {
  boost::sregex_iterator m1(text.begin(), text.end(), Re);
  boost::sregex_iterator empty;
  if (m1 != empty) {
    for (unsigned int index = 1; index < m1->size(); index++)
      Aout.emplace_back((*m1)[index].str());
    return 1;
  }
  return 0;
}
 
DLLExport int findPattern(std::istream &fh, const boost::regex &Re, std::string &Out) {
  char ss[512]; // max of 512
  boost::cmatch ans;
 
  int cnt = 1;
  fh.getline(ss, 512, '\n');
  while (!fh.fail() && !boost::regex_search(ss, ans, Re, boost::match_default)) {
    fh.getline(ss, 512, '\n');
    cnt++;
  }
  if (fh.fail())
    return 0;
  Out = ss;
  return cnt;
}
 
template <typename T> int findComp(std::istream &fh, const boost::regex &Re, T &Out) {
  char ss[512]; // max of 512
  boost::cmatch ans;
 
  int cnt(1);
  fh.getline(ss, 512, '\n');
  while (!fh.fail() && !boost::regex_search(ss, ans, Re, boost::match_default)) {
    cnt++;
    fh.getline(ss, 512, '\n');
  }
  if (ans[0].matched) {
    std::string xout(ans[1].first, ans[1].second);
    if (Mantid::Kernel::Strings::convert(xout, Out))
      return cnt;
  }
  return 0;
}
 
template <> DLLExport int findComp(std::istream &fh, const boost::regex &Re, std::string &Out) {
  char ss[512]; // max of 512
  boost::cmatch ans;
 
  int cnt(1);
  fh.getline(ss, 512, '\n');
  while (!fh.fail() && !boost::regex_search(ss, ans, Re, boost::match_default)) {
    cnt++;
    fh.getline(ss, 512, '\n');
  }
  if (ans[0].matched) {
    Out = std::string(ans[1].first, ans[1].second);
    return cnt;
  }
  return 0;
}
 
 
template DLLExport int StrFullCut(std::string &, const boost::regex &, std::string &, const int);
template DLLExport int StrFullCut(std::string &, const boost::regex &, int &, const int);
template DLLExport int StrFullCut(std::string &, const boost::regex &, double &, const int);
 
template DLLExport int StrFullSplit(const std::string &, const boost::regex &, std::vector<int> &);
template DLLExport int StrFullSplit(const std::string &, const boost::regex &, std::vector<double> &);
template DLLExport int StrFullSplit(const std::string &, const boost::regex &, std::vector<std::string> &);
 
template DLLExport int StrSingleSplit(const std::string &, const boost::regex &, std::vector<int> &);
template DLLExport int StrSingleSplit(const std::string &, const boost::regex &, std::vector<double> &);
 
template DLLExport int StrComp(const char *, const boost::regex &, double &, const int);
template DLLExport int StrComp(const char *, const boost::regex &, int &, const int);
template DLLExport int StrComp(const std::string &, const boost::regex &, double &, const int);
template DLLExport int StrComp(const std::string &, const boost::regex &, int &, const int);
 
template DLLExport int findComp(std::istream &, const boost::regex &, int &);
 
 
} // namespace Mantid::Kernel::Strings