ITableWorkspace.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
 
//----------------------------------------------------------------------
// Includes
//----------------------------------------------------------------------
#include "MantidAPI/Column.h"
#include "MantidAPI/DllConfig.h"
#include "MantidAPI/ITableWorkspace_fwd.h"
#include "MantidAPI/LogManager.h"
#include "MantidAPI/Workspace.h"
#include "MantidKernel/V3D.h"
 
#ifndef Q_MOC_RUN
#include <boost/lexical_cast.hpp>
#include <memory>
#endif
 
#include <sstream>
#include <utility>
 
namespace Mantid {
 
//----------------------------------------------------------------------
// Forward declarations
//----------------------------------------------------------------------
 
namespace API {
 
class TableColumnHelper {
public:
  TableColumnHelper(ITableWorkspace *tw, const std::string &name) : m_workspace(tw), m_name(name) {}
  ITableWorkspace *m_workspace; 
  std::string m_name;           
};
 
class TableConstColumnHelper {
public:
  TableConstColumnHelper(const ITableWorkspace *tw, const std::string &name) : m_workspace(tw), m_name(name) {}
  const ITableWorkspace *m_workspace; 
  std::string m_name;                 
};
 
class TableRowHelper {
public:
  TableRowHelper(ITableWorkspace *tw, size_t row) : m_workspace(tw), m_row(row) {}
  ITableWorkspace *m_workspace; 
  size_t m_row;                 
};
 
// =====================================================================================
class MANTID_API_DLL ITableWorkspace : public API::Workspace {
public:
  ITableWorkspace() {}
 
  ITableWorkspace_uptr clone() const { return std::unique_ptr<ITableWorkspace>(doClone()); }
 
  ITableWorkspace_uptr cloneEmpty() const { return ITableWorkspace_uptr(doCloneEmpty()); }
 
  ITableWorkspace_uptr cloneColumns(const std::vector<std::string> &colNames) const;
 
  ITableWorkspace &operator=(const ITableWorkspace &) = delete;
  const std::string id() const override { return "ITableWorkspace"; }
  const std::string toString() const override;
  virtual Column_sptr addColumn(const std::string &type, const std::string &name) = 0;
  virtual bool addColumns(const std::string &type, const std::string &name, size_t n);
  virtual API::LogManager_sptr logs() = 0;
  virtual API::LogManager_const_sptr getLogs() const = 0;
 
  virtual void removeColumn(const std::string &name) = 0;
 
  virtual size_t columnCount() const = 0;
 
  virtual Column_sptr getColumn(const std::string &name) = 0;
 
  virtual Column_const_sptr getColumn(const std::string &name) const = 0;
 
  virtual Column_sptr getColumn(size_t index) = 0;
 
  virtual Column_const_sptr getColumn(size_t index) const = 0;
 
  virtual std::vector<std::string> getColumnNames() const = 0;
 
  virtual size_t rowCount() const = 0;
 
  virtual void setRowCount(size_t count) = 0;
 
  virtual size_t insertRow(size_t index) = 0;
 
  virtual void removeRow(size_t index) = 0;
 
  TableRowHelper appendRow();
 
  virtual bool customSort() const { return false; }
 
  virtual void sort(std::vector<std::pair<std::string, bool>> &criteria);
 
  TableColumnHelper getVector(const std::string &name);
 
  TableConstColumnHelper getVector(const std::string &name) const;
  template <class T>
  T &getRef(const std::string &name, size_t index) {
    std::shared_ptr<Column> c = getColumn(name);
    if (!c->isType<T>()) {
      std::string str =
          std::string("getRef: Type mismatch. ") + typeid(T).name() + " != " + c->get_type_info().name() + '\n';
      throw std::runtime_error(str);
    }
    return *(static_cast<T *>(c->void_pointer(index)));
  }
 
  template <class T> T &cell(size_t row, size_t col) {
    Column_sptr c = getColumn(col);
    if (!c->isType<T>()) {
      std::ostringstream ostr;
      ostr << "cell: Type mismatch:\n" << typeid(T).name() << " != \n" << c->get_type_info().name() << '\n';
      throw std::runtime_error(ostr.str());
    }
    if (row >= this->rowCount()) {
      throw std::range_error("Table does not have row " + std::to_string(row));
    }
    return *(static_cast<T *>(c->void_pointer(row)));
  }
 
  int &Int(size_t row, size_t col) { return cell<int>(row, col); }
  double &Double(size_t row, size_t col) { return cell<double>(row, col); }
  Boolean &Bool(size_t row, size_t col) { return cell<Boolean>(row, col); }
  std::string &String(size_t row, size_t col) { return cell<std::string>(row, col); }
 
  TableRowHelper getRow(size_t row) { return TableRowHelper(this, row); }
  TableRowHelper getFirstRow() { return TableRowHelper(this, 0); }
 
  virtual void find(size_t value, size_t &row, size_t col) = 0;
  virtual void find(double value, size_t &row, size_t col) = 0;
  virtual void find(float value, size_t &row, size_t col) = 0;
  virtual void find(API::Boolean value, size_t &row, size_t col) = 0;
  virtual void find(const std::string &value, size_t &row, size_t col) = 0;
  virtual void find(const Mantid::Kernel::V3D &value, size_t &row, size_t col) = 0;
 
  void modified();
 
protected:
  ITableWorkspace(const ITableWorkspace &) = default;
 
  void resizeColumn(Column *c, size_t size) { c->resize(size); }
 
  void insertInColumn(Column *c, size_t index) { c->insert(index); }
 
  void removeFromColumn(Column *c, size_t index) { c->remove(index); }
 
private:
  ITableWorkspace *doClone() const override { return doCloneColumns(std::vector<std::string>()); }
  ITableWorkspace *doCloneEmpty() const override = 0;
  virtual ITableWorkspace *doCloneColumns(const std::vector<std::string> &colNames) const = 0;
};
 
// =====================================================================================
template <class T> class ColumnVector {
public:
  ColumnVector(const TableColumnHelper &th) : m_column(th.m_workspace->getColumn(th.m_name)) {
    if (!m_column->isType<T>()) {
      std::stringstream mess;
      mess << "Type mismatch when creating a ColumnVector<" << typeid(T).name() << ">.";
      throw std::runtime_error(mess.str());
    }
  }
  ColumnVector(Column_sptr column) : m_column(std::move(column)) {
    if (!m_column->isType<T>()) {
      std::stringstream mess;
      mess << "Type mismatch when creating a ColumnVector<" << typeid(T).name() << ">.";
      throw std::runtime_error(mess.str());
    }
  }
  T &operator[](size_t i) { return m_column->cell<T>(i); }
  size_t size() { return (m_column->size()); }
 
private:
  Column_sptr m_column; 
};
 
template <class T> class ConstColumnVector {
public:
  ConstColumnVector(const TableConstColumnHelper &th) : m_column(th.m_workspace->getColumn(th.m_name)) {
    if (!m_column->isType<T>()) {
      std::stringstream mess;
      mess << "Type mismatch when creating a ColumnVector<" << typeid(T).name() << ">.";
      throw std::runtime_error(mess.str());
    }
  }
  ConstColumnVector(Column_const_sptr column) : m_column(std::move(column)) {
    if (!m_column->isType<T>()) {
      std::stringstream mess;
      mess << "Type mismatch when creating a ColumnVector<" << typeid(T).name() << ">.";
      throw std::runtime_error(mess.str());
    }
  }
  const T &operator[](size_t i) { return m_column->cell<T>(i); }
  size_t size() { return m_column->size(); }
 
private:
  Column_const_sptr m_column; 
};
 
} // namespace API
} // Namespace Mantid