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 "vtkCommonCoreModule.h" // For export macro
#include "vtkAbstractArray.h"
#include "vtkStdString.h" // needed for vtkStdString definition
 
class vtkStringArrayLookup;
 
class VTKCOMMONCORE_EXPORT vtkStringArray : public vtkAbstractArray
{
public:
  static vtkStringArray* New();
  vtkTypeMacro(vtkStringArray,vtkAbstractArray);
  void PrintSelf(ostream& os, vtkIndent indent);
 
  //
  //
  // Functions required by vtkAbstractArray
  //
  //
 
 
  int GetDataType()
    { return VTK_STRING; }
 
  int IsNumeric() { return 0; }
 
  void Initialize();
 
  int GetDataTypeSize();
 
  void Squeeze() { this->ResizeAndExtend (this->MaxId+1); }
 
  int Resize(vtkIdType numTuples);
 
  virtual void SetTuple(vtkIdType i, vtkIdType j, vtkAbstractArray* source);
 
  virtual void InsertTuple(vtkIdType i, vtkIdType j, vtkAbstractArray* source);
 
 
  virtual void InsertTuples(vtkIdList *dstIds, vtkIdList *srcIds,
                            vtkAbstractArray *source);
 
 
  virtual void InsertTuples(vtkIdType dstStart, vtkIdType n, vtkIdType srcStart,
                            vtkAbstractArray* source);
 
  virtual vtkIdType InsertNextTuple(vtkIdType j, vtkAbstractArray* source);
 
 
  virtual void InterpolateTuple(vtkIdType i, vtkIdList *ptIndices,
    vtkAbstractArray* source,  double* weights);
 
 
  virtual void InterpolateTuple(vtkIdType i,
    vtkIdType id1, vtkAbstractArray* source1,
    vtkIdType id2, vtkAbstractArray* source2, double t);
 
  virtual void GetTuples(vtkIdList *ptIds, vtkAbstractArray *output);
 
  virtual void GetTuples(vtkIdType p1, vtkIdType p2, vtkAbstractArray *output);
 
  int Allocate( vtkIdType sz, vtkIdType ext=1000 );
 
  vtkStdString &GetValue(vtkIdType id);
 
//BTX
 
  void SetValue(vtkIdType id, vtkStdString value)
    { this->Array[id] = value; this->DataChanged(); }
//ETX
  void SetValue(vtkIdType id, const char *value);
 
 
  virtual void SetNumberOfTuples(vtkIdType number)
    { this->SetNumberOfValues(this->NumberOfComponents* number); }
 
  void SetNumberOfValues(vtkIdType number);
 
  vtkIdType GetNumberOfValues() { return this->MaxId + 1; }
 
  int GetNumberOfElementComponents() { return 0; }
  int GetElementComponentSize() { return static_cast<int>(sizeof(vtkStdString::value_type)); }
 
//BTX
 
  void InsertValue(vtkIdType id, vtkStdString f);
//ETX
  void InsertValue(vtkIdType id, const char *val);
 
  void SetVariantValue(vtkIdType idx, vtkVariant value);
 
//BTX
 
  vtkIdType InsertNextValue(vtkStdString f);
//ETX
  vtkIdType InsertNextValue(const char *f);
 
//BTX
 
  vtkStdString* WritePointer(vtkIdType id, vtkIdType number);
//ETX
 
//BTX
 
  vtkStdString* GetPointer(vtkIdType id) { return this->Array + id; }
  void* GetVoidPointer(vtkIdType id) { return this->GetPointer(id); }
//ETX
 
  void DeepCopy( vtkAbstractArray* aa );
 
 
//BTX
 
  void SetArray(vtkStdString* array, vtkIdType size, int save);
  virtual void SetVoidArray(void* array, vtkIdType size, int save)
    { this->SetArray(static_cast<vtkStdString*>(array), size, save); }
//ETX
 
  unsigned long GetActualMemorySize();
 
  virtual vtkArrayIterator* NewIterator();
 
  virtual vtkIdType GetDataSize();
 
 
  virtual vtkIdType LookupValue(vtkVariant value);
  virtual void LookupValue(vtkVariant value, vtkIdList* ids);
//BTX
  vtkIdType LookupValue(vtkStdString value);
  void LookupValue(vtkStdString value, vtkIdList* ids);
//ETX
  vtkIdType LookupValue(const char* value);
  void LookupValue(const char* value, vtkIdList* ids);
 
  virtual void DataChanged();
 
  virtual void DataElementChanged(vtkIdType id);
 
  virtual void ClearLookup();
 
protected:
  vtkStringArray();
  ~vtkStringArray();
 
  vtkStdString* Array;   // pointer to data
  vtkStdString* ResizeAndExtend(vtkIdType sz);  // function to resize data
 
  int SaveUserArray;
 
private:
  vtkStringArray(const vtkStringArray&);  // Not implemented.
  void operator=(const vtkStringArray&);  // Not implemented.
 
  //BTX
  vtkStringArrayLookup* Lookup;
  void UpdateLookup();
  //ETX
};
 
 
 
#endif