vtkStringArray.h

Go to the documentation of this file.

/*=========================================================================
 
  Program:   Visualization Toolkit
  Module:    vtkStringArray.h
  Language:  C++
 
  Copyright 2004 Sandia Corporation.
  Under the terms of Contract DE-AC04-94AL85000, there is a non-exclusive
  license for use of this work by or on behalf of the
  U.S. Government. Redistribution and use in source and binary forms, with
  or without modification, are permitted provided that this Notice and any
  statement of authorship are reproduced on all copies.
 
=========================================================================*/
 
#ifndef vtkStringArray_h
#define vtkStringArray_h
 
#include "vtkAbstractArray.h"
#include "vtkCommonCoreModule.h" // For export macro
#include "vtkStdString.h"        // needed for vtkStdString definition
 
class vtkStringArrayLookup;
 
class VTKCOMMONCORE_EXPORT vtkStringArray : public vtkAbstractArray
{
public:
  enum DeleteMethod
  {
    VTK_DATA_ARRAY_FREE = vtkAbstractArray::VTK_DATA_ARRAY_FREE,
    VTK_DATA_ARRAY_DELETE = vtkAbstractArray::VTK_DATA_ARRAY_DELETE,
    VTK_DATA_ARRAY_ALIGNED_FREE = vtkAbstractArray::VTK_DATA_ARRAY_ALIGNED_FREE,
    VTK_DATA_ARRAY_USER_DEFINED = vtkAbstractArray::VTK_DATA_ARRAY_USER_DEFINED
  };
 
  static vtkStringArray* New();
  static vtkStringArray* ExtendedNew();
  vtkTypeMacro(vtkStringArray, vtkAbstractArray);
  void PrintSelf(ostream& os, vtkIndent indent) override;
 
  //
  //
  // Functions required by vtkAbstractArray
  //
  //
 
  int GetDataType() const override { return VTK_STRING; }
 
  int IsNumeric() const override { return 0; }
 
  void Initialize() override;
 
  int GetDataTypeSize() const override;
 
  void Squeeze() override { this->ResizeAndExtend(this->MaxId + 1); }
 
  vtkTypeBool Resize(vtkIdType numTuples) override;
 
  void SetTuple(vtkIdType i, vtkIdType j, vtkAbstractArray* source) override;
 
  void InsertTuple(vtkIdType i, vtkIdType j, vtkAbstractArray* source) override;
 
  void InsertTuples(vtkIdList* dstIds, vtkIdList* srcIds, vtkAbstractArray* source) override;
 
  void InsertTuplesStartingAt(
    vtkIdType dstStart, vtkIdList* srcIds, vtkAbstractArray* source) override;
 
  void InsertTuples(
    vtkIdType dstStart, vtkIdType n, vtkIdType srcStart, vtkAbstractArray* source) override;
 
  vtkIdType InsertNextTuple(vtkIdType j, vtkAbstractArray* source) override;
 
  void InterpolateTuple(
    vtkIdType i, vtkIdList* ptIndices, vtkAbstractArray* source, double* weights) override;
 
  void InterpolateTuple(vtkIdType i, vtkIdType id1, vtkAbstractArray* source1, vtkIdType id2,
    vtkAbstractArray* source2, double t) override;
 
  void GetTuples(vtkIdList* ptIds, vtkAbstractArray* output) override;
 
  void GetTuples(vtkIdType p1, vtkIdType p2, vtkAbstractArray* output) override;
 
  vtkTypeBool Allocate(vtkIdType sz, vtkIdType ext = 1000) override;
 
  const vtkStdString& GetValue(vtkIdType id) const
    VTK_EXPECTS(0 <= id && id < this->GetNumberOfValues());
 
  vtkStdString& GetValue(vtkIdType id) VTK_EXPECTS(0 <= id && id < this->GetNumberOfValues());
 
  void SetValue(vtkIdType id, vtkStdString value)
    VTK_EXPECTS(0 <= id && id < this->GetNumberOfValues())
  {
    this->Array[id] = value;
    this->DataChanged();
  }
 
  void SetValue(vtkIdType id, const char* value)
    VTK_EXPECTS(0 <= id && id < this->GetNumberOfValues()) VTK_EXPECTS(value != nullptr);
 
  void SetNumberOfTuples(vtkIdType number) override
  {
    this->SetNumberOfValues(this->NumberOfComponents * number);
  }
 
  vtkIdType GetNumberOfValues() const { return (this->MaxId + 1); }
 
  int GetNumberOfElementComponents() { return 0; }
  int GetElementComponentSize() const override
  {
    return static_cast<int>(sizeof(vtkStdString::value_type));
  }
 
  void InsertValue(vtkIdType id, vtkStdString f) VTK_EXPECTS(0 <= id);
  void InsertValue(vtkIdType id, const char* val) VTK_EXPECTS(0 <= id) VTK_EXPECTS(val != nullptr);
 
  void SetVariantValue(vtkIdType idx, vtkVariant value) override;
 
  void InsertVariantValue(vtkIdType idx, vtkVariant value) override;
 
  vtkIdType InsertNextValue(vtkStdString f);
  vtkIdType InsertNextValue(const char* f) VTK_EXPECTS(f != nullptr);
 
  vtkStdString* WritePointer(vtkIdType id, vtkIdType number);
 
  vtkStdString* GetPointer(vtkIdType id) { return this->Array + id; }
  void* GetVoidPointer(vtkIdType id) override { return this->GetPointer(id); }
 
  void DeepCopy(vtkAbstractArray* aa) override;
 
  void SetArray(
    vtkStdString* array, vtkIdType size, int save, int deleteMethod = VTK_DATA_ARRAY_DELETE);
  void SetVoidArray(void* array, vtkIdType size, int save) override
  {
    this->SetArray(static_cast<vtkStdString*>(array), size, save);
  }
  void SetVoidArray(void* array, vtkIdType size, int save, int deleteMethod) override
  {
    this->SetArray(static_cast<vtkStdString*>(array), size, save, deleteMethod);
  }
 
  void SetArrayFreeFunction(void (*callback)(void*)) override;
 
  unsigned long GetActualMemorySize() const override;
 
  VTK_NEWINSTANCE vtkArrayIterator* NewIterator() override;
 
  vtkIdType GetDataSize() const override;
 
 
  vtkIdType LookupValue(vtkVariant value) override;
  void LookupValue(vtkVariant value, vtkIdList* ids) override;
 
  vtkIdType LookupValue(const vtkStdString& value);
  void LookupValue(const vtkStdString& value, vtkIdList* ids);
 
  vtkIdType LookupValue(const char* value);
  void LookupValue(const char* value, vtkIdList* ids);
 
  void DataChanged() override;
 
  virtual void DataElementChanged(vtkIdType id);
 
  void ClearLookup() override;
 
protected:
  vtkStringArray();
  ~vtkStringArray() override;
 
  vtkStdString* Array;                         // pointer to data
  vtkStdString* ResizeAndExtend(vtkIdType sz); // function to resize data
 
  void (*DeleteFunction)(void*);
 
private:
  vtkStringArray(const vtkStringArray&) = delete;
  void operator=(const vtkStringArray&) = delete;
 
  vtkStringArrayLookup* Lookup;
  void UpdateLookup();
};
 
#endif