Column.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/DllConfig.h"
 
#ifndef Q_MOC_RUN
#include <memory>
#endif
#include <cstring>
#include <limits>
#include <stdexcept>
#include <string>
#include <typeinfo>
#include <vector>
 
namespace Mantid {
 
namespace API {
class MANTID_API_DLL Column {
public:
  Column() : m_type("int"), m_plotType(-1000), m_isReadOnly(false){};
 
  virtual ~Column() = default;
 
  const std::string &name() const { return m_name; }
 
  const std::string &type() const { return m_type; }
  virtual double operator[](size_t i) const {
    UNUSED_ARG(i);
    return std::numeric_limits<double>::quiet_NaN();
  }
  void setName(const std::string &str) { m_name = str; }
 
  virtual size_t size() const = 0;
 
  virtual const std::type_info &get_type_info() const = 0;
 
  virtual const std::type_info &get_pointer_type_info() const = 0;
 
  virtual bool getReadOnly() const { return m_isReadOnly; }
 
  void setReadOnly(bool isReadOnly) { m_isReadOnly = isReadOnly; }
 
  virtual void print(size_t index, std::ostream &s) const = 0;
 
  virtual void read(size_t index, const std::string &text) {
    UNUSED_ARG(text);
    UNUSED_ARG(index);
  }
 
  virtual void read(const size_t index, std::istringstream &in) {
    UNUSED_ARG(index)
    UNUSED_ARG(in)
  }
 
  virtual bool isBool() const = 0;
 
  virtual bool isNumber() const = 0;
 
  virtual long int sizeOfData() const = 0;
 
  virtual Column *clone() const = 0;
 
  virtual double toDouble(size_t index) const = 0;
 
  virtual void fromDouble(size_t index, double value) = 0;
 
  virtual void sortIndex(bool ascending, size_t start, size_t end, std::vector<size_t> &indexVec,
                         std::vector<std::pair<size_t, size_t>> &equalRanges) const;
 
  virtual void sortValues(const std::vector<size_t> &indexVec);
 
  template <class T> T &cell(size_t index) { return *static_cast<T *>(void_pointer(index)); }
 
  template <class T> const T &cell(size_t index) const { return *static_cast<const T *>(void_pointer(index)); }
 
  template <class T> bool isType() const { return !std::strcmp(get_type_info().name(), typeid(T).name()); }
 
  int getPlotType() const { return m_plotType; }
 
  void setPlotType(int t);
 
  int getLinkedYCol() const { return m_linkedYCol; }
 
  void setLinkedYCol(const int yCol);
 
  template <class T = double> std::vector<T> numeric_fill(size_t maxSize = std::numeric_limits<size_t>::max()) const {
    std::vector<T> vec(std::min(size(), maxSize));
    for (size_t i = 0; i < vec.size(); ++i) {
      vec[i] = static_cast<T>(toDouble(i));
    }
    return vec;
  }
 
  virtual bool equals(const Column &, double) const { throw std::runtime_error("equals not implemented"); };
 
  virtual bool equalsRelErr(const Column &, double) const { throw std::runtime_error("equals not implemented"); };
 
protected:
  virtual void resize(size_t count) = 0;
  virtual void insert(size_t index) = 0;
  virtual void remove(size_t index) = 0;
  virtual void *void_pointer(size_t index) = 0;
  virtual const void *void_pointer(size_t index) const = 0;
 
  bool possibleToCompare(const Column &otherColumn) const {
    if (otherColumn.get_type_info() != this->get_type_info())
      return false;
    if (otherColumn.size() != this->size()) {
      return false;
    }
    return true;
  }
 
  std::string m_name; 
  std::string m_type; 
 
  int m_plotType;
 
  int m_linkedYCol = -1;
 
  bool m_isReadOnly;
 
  friend class ColumnFactoryImpl;
  friend class ITableWorkspace;
  template <class T> friend class ColumnVector;
};
 
struct MANTID_API_DLL Boolean {
  Boolean() : value(false) {}
  Boolean(bool b) : value(b) {}
  operator bool() { return value; }
  bool operator==(const Boolean &b) const { return (this->value == b.value); }
  //
  operator bool() const { return this->value; }
  bool value; 
};
 
MANTID_API_DLL std::ostream &operator<<(std::ostream &, const API::Boolean &);
MANTID_API_DLL std::istream &operator>>(std::istream &istr, API::Boolean &);
 
using Column_sptr = std::shared_ptr<Column>;
using Column_const_sptr = std::shared_ptr<const Column>;
 
} // namespace API
} // Namespace Mantid