TableWorkspace.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/ITableWorkspace.h"
#include "MantidDataObjects/DllConfig.h"
#include "MantidDataObjects/TableColumn.h"
#include "MantidDataObjects/TableWorkspace_fwd.h"
#include "MantidKernel/PropertyManager.h"
#include "MantidKernel/V3D.h"
#include <boost/tuple/tuple.hpp>
 
#include <memory>
#include <utility>
 
namespace Mantid {
 
namespace DataObjects {
class MANTID_DATAOBJECTS_DLL TableWorkspace : public API::ITableWorkspace {
public:
  TableWorkspace(size_t nrows = 0);
 
  TableWorkspace &operator=(const TableWorkspace &other) = delete;
 
  std::unique_ptr<TableWorkspace> clone() const { return std::unique_ptr<TableWorkspace>(doClone()); }
 
  std::unique_ptr<TableWorkspace> cloneEmpty() const { return std::unique_ptr<TableWorkspace>(doCloneEmpty()); }
 
  const std::string id() const override { return "TableWorkspace"; }
  size_t getMemorySize() const override;
  API::Column_sptr addColumn(const std::string &type, const std::string &name) override;
  void removeColumn(const std::string &name) override;
  size_t columnCount() const override { return static_cast<int>(m_columns.size()); }
  API::Column_sptr getColumn(const std::string &name) override;
  API::Column_const_sptr getColumn(const std::string &name) const override;
  API::Column_sptr getColumn(size_t index) override;
  API::Column_const_sptr getColumn(size_t index) const override;
  std::vector<std::string> getColumnNames() const override;
  size_t rowCount() const override { return m_rowCount; }
  API::LogManager_sptr logs() override { return m_LogManager; }
  API::LogManager_const_sptr getLogs() const override { return m_LogManager; }
 
  template <class T> std::vector<T> &getColVector(size_t index) {
    auto pTableCol = dynamic_cast<TableColumn<T> *>(m_columns[index].get());
    if (pTableCol)
      return pTableCol->data();
    else {
      throw std::runtime_error("TableWorkspace::getColVector(): Can not cast "
                               "to proper TableCol type");
    }
  }
  template <class T> const std::vector<T> &getColVector(size_t index) const {
    auto pTableCol = dynamic_cast<TableColumn<T> *>(m_columns[index].get());
    if (pTableCol)
      return pTableCol->data();
    else {
      throw std::runtime_error("TableWorkspace::getColVector()const: Can not "
                               "cast to proper TableCol type");
    }
  }
  template <class T> std::vector<T> &getColVector(const std::string &name) {
    auto ci = std::find_if(m_columns.begin(), m_columns.end(), FindName(name));
    if (ci == m_columns.end())
      throw(std::runtime_error("column with name: " + name + " does not exist"));
    auto pTableCol = dynamic_cast<TableColumn<T> *>(ci->get());
    if (pTableCol)
      return pTableCol->data();
    else {
      throw std::runtime_error("TableWorkspace::getColVector(): Can not cast "
                               "to proper TableCol type");
    }
  }
  template <class T> const std::vector<T> &getColVector(const std::string &name) const {
    auto ci = std::find_if(m_columns.begin(), m_columns.end(), FindName(name));
    if (ci == m_columns.end())
      throw(std::runtime_error("column with name: " + name + " does not exist"));
    auto pTableCol = dynamic_cast<TableColumn<T> *>(ci->get());
    if (pTableCol)
      return pTableCol->data();
    else {
      throw std::runtime_error("TableWorkspace::getColVector()const: Can not "
                               "cast to proper TableCol type");
    }
  }
  template <class T> T *getColDataArray(const std::string &name) {
    auto ci = std::find_if(m_columns.begin(), m_columns.end(), FindName(name));
    if (ci == m_columns.end())
      return nullptr;
    auto pTableCol = dynamic_cast<TableColumn<T> *>(ci->get());
    if (pTableCol)
      return pTableCol->dataArray();
    else
      return nullptr;
  }
  template <class T> T *getColDataArray(const std::string &name) const {
    auto ci = std::find_if(m_columns.begin(), m_columns.end(), FindName(name));
    if (ci == m_columns.end())
      return nullptr;
    auto pTableCol = dynamic_cast<TableColumn<T> *>(ci->get());
    if (pTableCol)
      return pTableCol->dataArray();
    else
      return nullptr;
  }
 
  void setRowCount(size_t count) override;
  size_t insertRow(size_t index) override;
  void removeRow(size_t index) override;
 
  void find(size_t value, size_t &row, size_t col) override { findValue(value, row, col); }
  void find(const std::string &value, size_t &row, size_t col) override { findValue(value, row, col); }
  void find(float value, size_t &row, size_t col) override { findValue(value, row, col); }
  void find(API::Boolean value, size_t &row, size_t col) override { findValue(value, row, col); }
  void find(double value, size_t &row, size_t col) override { findValue(value, row, col); }
  void find(const Mantid::Kernel::V3D &value, size_t &row, size_t col) override { findValue(value, row, col); }
  template <class U> U cell_cast(size_t nRow, size_t nCol) const {
    API::Column_sptr spCol = this->m_columns[nCol];
    return static_cast<U>(spCol->operator[](nRow));
  }
  template <class U> U cell_cast(size_t nRow, const std::string &col_name) const {
    API::Column_const_sptr spCol = this->getColumn(col_name);
    return static_cast<U>(spCol->operator[](nRow));
  }
 
  void sort(std::vector<std::pair<std::string, bool>> &criteria) override;
 
protected:
  TableWorkspace(const TableWorkspace &other);
 
private:
  TableWorkspace *doClone() const override { return doCloneColumns(std::vector<std::string>()); }
 
  TableWorkspace *doCloneEmpty() const override { return new TableWorkspace(); }
 
  TableWorkspace *doCloneColumns(const std::vector<std::string> &colNames) const override;
 
  template <typename Type> void findValue(const Type value, size_t &row, size_t colIndex) {
 
    try {
      TableColumn_ptr<Type> tc_sptr = getColumn(colIndex);
      std::vector<Type> dataVec = tc_sptr->data();
      typename std::vector<Type>::iterator itr;
      itr = std::find(dataVec.begin(), dataVec.end(), value);
      if (itr != dataVec.end()) {
        std::vector<int>::difference_type pos;
        pos = std::distance(dataVec.begin(), itr);
        // size_t pos=static_cast<int>itr-dataVec.begin();
        row = static_cast<int>(pos);
 
      } else {
        throw std::out_of_range("Search object not found in table workspace");
      }
    } catch (std::range_error &) {
      throw;
    } catch (std::runtime_error &) {
      throw;
    }
  }
 
  void addColumn(const std::shared_ptr<API::Column> &column);
 
private:
  class FindName {
    std::string m_name; 
  public:
    FindName(const std::string &name) : m_name(name) {}
    bool operator()(std::shared_ptr<API::Column> &cp) const { return cp->name() == m_name; }
    bool operator()(const std::shared_ptr<const API::Column> &cp) const { return cp->name() == m_name; }
  };
 
  using column_it = std::vector<std::shared_ptr<API::Column>>::iterator; 
 
  using column_const_it = std::vector<std::shared_ptr<API::Column>>::const_iterator;
 
  std::vector<std::shared_ptr<API::Column>> m_columns;
  size_t m_rowCount;
 
  API::LogManager_sptr m_LogManager;
};
} // namespace DataObjects
} // namespace Mantid