vtkMRMLTableNode.h

Go to the documentation of this file.

/*==============================================================================
 
  Program: 3D Slicer
 
  Portions (c) Copyright 2015 Brigham and Women's Hospital (BWH) All Rights Reserved.
 
  See COPYRIGHT.txt
  or http://www.slicer.org/copyright/copyright.txt for details.
 
  Unless required by applicable law or agreed to in writing, software
  distributed under the License is distributed on an "AS IS" BASIS,
  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  See the License for the specific language governing permissions and
  limitations under the License.
 
  This file was originally developed by Andras Lasso (PerkLab, Queen's
  University) and Kevin Wang (Princess Margaret Hospital, Toronto) and was
  supported through OCAIRO and the Applied Cancer Research Unit program of
  Cancer Care Ontario.
 
==============================================================================*/
 
#ifndef __vtkMRMLTableNode_h
#define __vtkMRMLTableNode_h
 
#include <string>
#include <vector>
 
#include "vtkMRMLStorableNode.h"
 
// MRML Includes
class vtkMRMLStorageNode;
 
// VTK Includes
class vtkTable;
 
class VTK_MRML_EXPORT vtkMRMLTableNode : public vtkMRMLStorableNode
{
public:
 
public:
  static vtkMRMLTableNode *New();
  vtkTypeMacro(vtkMRMLTableNode,vtkMRMLStorableNode);
 
  void PrintSelf(ostream& os, vtkIndent indent) override;
 
  //----------------------------------------------------------------
  //----------------------------------------------------------------
 
  vtkMRMLNode* CreateNodeInstance() override;
 
  void ReadXMLAttributes( const char** atts) override;
 
  void WriteXML(ostream& of, int indent) override;
 
  vtkMRMLCopyContentMacro(vtkMRMLTableNode);
 
  const char* GetNodeTagName() override { return "Table"; }
 
  void ProcessMRMLEvents(vtkObject *caller, unsigned long event, void *callData) override;
 
  //----------------------------------------------------------------
  //----------------------------------------------------------------
  virtual void SetAndObserveTable(vtkTable* table);
  vtkGetObjectMacro(Table, vtkTable);
 
  virtual void SetAndObserveSchema(vtkTable* schema);
  vtkGetObjectMacro(Schema, vtkTable);
 
  vtkGetMacro(Locked, bool);
  vtkSetMacro(Locked, bool);
 
  vtkGetMacro(UseFirstColumnAsRowHeader, bool);
  vtkSetMacro(UseFirstColumnAsRowHeader, bool);
 
  vtkGetMacro(UseColumnNameAsColumnHeader, bool);
  vtkSetMacro(UseColumnNameAsColumnHeader, bool);
 
  vtkMRMLStorageNode* CreateDefaultStorageNode() override;
 
  vtkAbstractArray* AddColumn(vtkAbstractArray* column = nullptr);
 
  bool RenameColumn(int columnIndex, const char* newName);
 
  bool RemoveColumn(int columnIndex);
 
  bool RemoveAllColumns();
 
  int AddEmptyRow();
 
  bool RemoveRow(int rowIndex);
 
  std::string GetCellText(int rowIndex, int columnIndex);
 
  bool SetCellText(int rowIndex, int columnIndex, const char* text);
 
  int GetColumnIndex(const char* columnName);
  int GetColumnIndex(const std::string &columnName);
 
  int GetColumnIndex(vtkAbstractArray* column);
 
  std::string GetColumnName(int columnIndex);
 
  int GetNumberOfRows();
 
  int GetNumberOfColumns();
 
  void SetColumnNullValue(const std::string& columnName, const std::string& nullValue);
  std::string GetColumnNullValue(const std::string& columnName);
 
  void SetColumnLongName(const std::string& columnName, const std::string& description);
  std::string GetColumnLongName(const std::string& columnName);
 
  void SetColumnDescription(const std::string& columnName, const std::string& description);
  std::string GetColumnDescription(const std::string& columnName);
 
  void SetColumnUnitLabel(const std::string& columnName, const std::string& unitLabel);
  std::string GetColumnUnitLabel(const std::string& columnName);
 
  std::string GetColumnProperty(const std::string& columnName, const std::string& propertyName);
  std::string GetColumnProperty(int columnIndex, const std::string& propertyName);
 
  void GetAllColumnPropertyNames(vtkStringArray* propertyNames);
 
  void SetColumnProperty(const std::string& columnName, const std::string& propertyName, const std::string& propertyValue);
  void SetColumnProperty(int columnIndex, const std::string& propertyName, const std::string& propertyValue);
 
  void RemoveColumnProperty(const std::string& propertyName);
 
  void CopyAllColumnProperties(const std::string& sourceColumnName, const std::string& targetColumnName);
 
  void RemoveAllColumnProperties(const std::string& columnName);
  void RemoveAllColumnProperties(int columnIndex);
 
  int GetColumnValueTypeFromSchema(const std::string& columnName);
 
  vtkIdType InsertNextBlankRowWithNullValues(vtkTable* table);
 
  int GetColumnType(const std::string& columnName);
 
  bool SetColumnType(const std::string& columnName, int typeId);
 
  bool SetDefaultColumnType(const std::string& type, const std::string& nullValue="");
 
  static const char* GetDefaultColumnName();
 
  static int GetValueTypeFromString(std::string valueTypeStr);
 
  static std::string GetValueTypeAsString(int valueType);
 
  bool SetComponentNames(const std::string& columnName, const std::vector<std::string>& componentNames);
 
  std::vector<std::string> GetComponentNames(const std::string& columnName);
 
  std::vector<std::string> GetComponentNamesFromSchema(const std::string& columnName);
 
  static std::vector<std::string> GetComponentNamesFromArray(vtkAbstractArray* array);
 
  static const std::vector<std::string> GetComponentNamesFromString(const std::string& componentNameString);
 
  static std::string GetComponentNamesAsString(const std::vector<std::string>& componentNames);
 
  //----------------------------------------------------------------
  //----------------------------------------------------------------
 protected:
  vtkMRMLTableNode();
  ~vtkMRMLTableNode() override;
  vtkMRMLTableNode(const vtkMRMLTableNode&);
  void operator=(const vtkMRMLTableNode&);
 
 protected:
 
  std::string GetColumnPropertyInternal(const std::string& columnName, const std::string& propertyName);
 
  void SetColumnPropertyInternal(const std::string& columnName, const std::string& propertyName, const std::string& propertyValue);
 
  vtkIdType GetPropertyRowIndex(const std::string& columnName);
 
  //----------------------------------------------------------------
  //----------------------------------------------------------------
 
  vtkTable* Table;
  bool Locked;
  bool UseColumnNameAsColumnHeader;
  bool UseFirstColumnAsRowHeader;
 
  vtkTable* Schema;
 
};
 
#endif