TableRow.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 "MantidAPI/Column.h"
 
#ifndef Q_MOC_RUN
#include <boost/lexical_cast.hpp>
#endif
 
#include <ostream>
#include <stdexcept>
#include <vector>
 
namespace Mantid {
 
namespace API {
//----------------------------------------------------------------------
// Forward declarations
//----------------------------------------------------------------------
class TableRowHelper;
 
class MANTID_API_DLL TableRow {
public:
  TableRow(const TableRowHelper &trh);
  size_t row() const { return m_row; }
  size_t size() const { return m_nrows; }
  void row(size_t i);
  bool next();
  bool prev();
  void sep(const std::string &s) { m_sep = s; }
 
  template <class T> TableRow &operator<<(const T &t) {
    if (m_col >= m_columns.size()) {
      std::stringstream errss;
      errss << "Column index " << m_col << " is out of range " << m_columns.size() << " of operator << ";
      throw std::range_error(errss.str());
    }
    Column_sptr c = m_columns[m_col];
    if (!c->isType<T>()) {
      std::ostringstream err;
      err << "Type mismatch: " << typeid(T).name() << " (expected " << c->get_type_info().name() << ")";
      throw std::runtime_error(err.str());
    }
    c->cell<T>(m_row) = t;
    ++m_col;
    return *this;
  }
 
  TableRow &operator<<(const char *t) { return operator<<(std::string(t)); }
  TableRow &operator<<(bool t) { return operator<<(Boolean(t)); }
 
  template <class T> const TableRow &operator>>(T &t) const {
    if (m_col >= m_columns.size()) {
      std::stringstream errss;
      errss << "Column index " << m_col << " is out of range " << m_columns.size() << " of operator >> ";
      throw std::range_error(errss.str());
    }
    Column_sptr c = m_columns[m_col];
    if (!c->isType<T>()) {
      throw std::runtime_error("TableRow type mismatch.");
    }
    t = c->cell<T>(m_row);
    ++m_col;
    return *this;
  }
 
  const TableRow &operator>>(bool &t) const;
 
  template <class T> T &cell(size_t col) {
    if (col >= m_columns.size()) {
      std::stringstream errss;
      errss << "Column index " << m_col << " is out of range " << m_columns.size() << " of method cell(). ";
      throw std::range_error(errss.str());
    }
    m_col = col;
    Column_sptr c = m_columns[m_col];
    ++m_col; // Is it right?
    return c->cell<T>(m_row);
  }
 
  int &Int(size_t col) { return cell<int>(col); }
 
  double &Double(size_t col) { return cell<double>(col); }
 
  Boolean &Bool(size_t col) { return cell<Boolean>(col); }
 
  std::string &String(size_t col) { return cell<std::string>(col); }
 
private:
  friend MANTID_API_DLL std::ostream &operator<<(std::ostream &s, const TableRow &row);
  std::vector<Column_sptr> m_columns; 
  size_t m_row;                       
  mutable size_t m_col;               
  size_t m_nrows;                     
  std::string m_sep;                  
};
 
MANTID_API_DLL std::ostream &operator<<(std::ostream &s, const TableRow &row);
 
} // namespace API
} // namespace Mantid