TSVSerialiser.h

Go to the documentation of this file.

// Mantid Repository : https://github.com/mantidproject/mantid
//
// Copyright © 2007 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 +
#pragma once
 
#include "DllOption.h"
#include "MantidKernel/CaseInsensitiveMap.h"
 
#include <map>
#include <sstream>
#include <string>
#include <vector>
 
#include <QColor>
#include <QPoint>
#include <QRect>
#include <QString>
 
namespace MantidQt {
namespace API {
 
class EXPORT_OPT_MANTIDQT_COMMON TSVSerialiser {
public:
  TSVSerialiser();
 
  explicit TSVSerialiser(const std::string &lines);
 
  void parseLines(const std::string &lines);
  std::string outputLines() const;
  void clear();
 
  bool hasLine(const std::string &name) const;
  bool hasSection(const std::string &name) const;
 
  std::vector<std::string> values(const std::string &name, const size_t i = 0) const;
 
  template <typename T> TSVSerialiser &operator>>(std::vector<T> &val) {
    val.reserve(m_curValues.size() - m_curIndex);
 
    for (size_t i = m_curIndex; i < m_curValues.size(); ++i) {
      auto valStr = m_curValues.at(i);
      std::stringstream valSS(valStr);
      T ret;
      valSS >> ret;
      val.emplace_back(ret);
    }
    return *this;
  }
 
  template <typename T> void parseLines(const std::string &name, std::vector<T> &container) {
 
    auto extractor = [](TSVSerialiser &tsv) {
      T value;
      tsv >> value;
      return value;
    };
 
    parseLines(name, container, extractor);
  }
 
  template <typename T, typename Extractor>
  void parseLines(const std::string &name, std::vector<T> &container, Extractor &&extractor) {
    size_t index = 0;
    while (selectLine(name, index)) {
      auto value = std::forward<Extractor>(extractor)(*this);
      container.emplace_back(value);
      ++index;
    }
  }
 
  std::vector<std::string> sections(const std::string &name) const;
 
  std::string lineAsString(const std::string &name, const size_t i = 0) const;
  QString lineAsQString(const std::string &name, const size_t i = 0) const;
 
  bool selectLine(const std::string &name, const size_t i = 0);
  bool selectSection(const std::string &name, const size_t i = 0);
 
  void storeDouble(const double val);
  void storeInt(const int val);
  void storeString(const std::string &val);
  void storeBool(const bool val);
 
  double readDouble();
  int readInt();
  std::string readString();
  bool readBool();
 
  int asInt(const size_t i) const;
  size_t asSize_t(const size_t i) const;
  double asDouble(const size_t i) const;
  float asFloat(const size_t i) const;
  std::string asString(const size_t i) const;
  QString asQString(const size_t i) const;
  bool asBool(const size_t i) const;
  QRect asQRect(const size_t i);
  QColor asQColor(const size_t i);
  QPoint asQPoint(const size_t i);
  QPointF asQPointF(const size_t i);
 
  TSVSerialiser &operator>>(int &val);
  TSVSerialiser &operator>>(size_t &val);
  TSVSerialiser &operator>>(double &val);
  TSVSerialiser &operator>>(float &val);
  TSVSerialiser &operator>>(std::string &val);
  TSVSerialiser &operator>>(QString &val);
  TSVSerialiser &operator>>(bool &val);
  TSVSerialiser &operator>>(QRect &val);
  TSVSerialiser &operator>>(QColor &val);
  TSVSerialiser &operator>>(QPoint &val);
  TSVSerialiser &operator>>(QPointF &val);
 
  TSVSerialiser &writeLine(const std::string &name);
 
  TSVSerialiser &operator<<(const std::string &val);
  TSVSerialiser &operator<<(const char *val);
  TSVSerialiser &operator<<(const QString &val);
  TSVSerialiser &operator<<(const double &val);
  TSVSerialiser &operator<<(const int &val);
  TSVSerialiser &operator<<(const size_t &val);
  TSVSerialiser &operator<<(const bool &val);
  TSVSerialiser &operator<<(const QRect &val);
  TSVSerialiser &operator<<(const QColor &val);
  TSVSerialiser &operator<<(const QPoint &val);
  TSVSerialiser &operator<<(const QPointF &val);
 
  void writeRaw(const std::string &raw);
  void writeSection(const std::string &name, const std::string &body);
  void writeInlineSection(const std::string &name, const std::string &body);
 
private:
  Mantid::Kernel::CaseInsensitiveMap<std::vector<std::string>> m_sections;
  Mantid::Kernel::CaseInsensitiveMap<std::vector<std::string>> m_lines;
 
  std::vector<std::string> m_curValues;
  int m_curIndex;
 
  std::stringstream m_output;
  bool m_midLine;
};
} // namespace API
} // namespace MantidQt