dox/Common/vtkDataArrayTemplate.h

Go to the documentation of this file.

/*=========================================================================

  Program:   Visualization Toolkit
  Module:    $RCSfile: vtkDataArrayTemplate.h,v $

  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
  All rights reserved.
  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.

     This software is distributed WITHOUT ANY WARRANTY; without even
     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
     PURPOSE.  See the above copyright notice for more information.

=========================================================================*/
#ifndef __vtkDataArrayTemplate_h
#define __vtkDataArrayTemplate_h

#include "vtkDataArray.h"

template <class T>
class vtkDataArrayTemplateLookup;

template <class T>
class vtkDataArrayTemplate: public vtkDataArray
{
public:
  typedef vtkDataArray Superclass;
  void PrintSelf(ostream& os, vtkIndent indent);

  int Allocate(vtkIdType sz, vtkIdType ext=1000);

  void Initialize();

  int GetDataTypeSize() { return static_cast<int>(sizeof(T)); }

  void SetNumberOfTuples(vtkIdType number);

  virtual void SetTuple(vtkIdType i, vtkIdType j, vtkAbstractArray* source);

  virtual void InsertTuple(vtkIdType i, vtkIdType j, vtkAbstractArray* source);

  virtual vtkIdType InsertNextTuple(vtkIdType j, vtkAbstractArray* source);
  
  double* GetTuple(vtkIdType i);


  void GetTuple(vtkIdType i, double* tuple);
  void GetTupleValue(vtkIdType i, T* tuple);


  void SetTuple(vtkIdType i, const float* tuple);
  void SetTuple(vtkIdType i, const double* tuple);
  void SetTupleValue(vtkIdType i, const T* tuple);


  void InsertTuple(vtkIdType i, const float* tuple);
  void InsertTuple(vtkIdType i, const double* tuple);
  void InsertTupleValue(vtkIdType i, const T* tuple);


  vtkIdType InsertNextTuple(const float* tuple);
  vtkIdType InsertNextTuple(const double* tuple);
  vtkIdType InsertNextTupleValue(const T* tuple);

  void Squeeze() { this->ResizeAndExtend (this->MaxId+1); }

  virtual int Resize(vtkIdType numTuples);

  T GetValue(vtkIdType id) { return this->Array[id]; }


  void SetValue(vtkIdType id, T value)
    { this->Array[id] = value;};

  void SetNumberOfValues(vtkIdType number);

  void InsertValue(vtkIdType id, T f);

  vtkIdType InsertNextValue(T f);


  virtual void RemoveTuple(vtkIdType id);
  virtual void RemoveFirstTuple();
  virtual void RemoveLastTuple();

  double GetComponent(vtkIdType i, int j);

  void SetComponent(vtkIdType i, int j, double c);

  virtual void InsertComponent(vtkIdType i, int j, double c);


  T* WritePointer(vtkIdType id, vtkIdType number);
  virtual void* WriteVoidPointer(vtkIdType id, vtkIdType number)
    { return this->WritePointer(id, number); }


  T* GetPointer(vtkIdType id) { return this->Array + id; }
  virtual void* GetVoidPointer(vtkIdType id) { return this->GetPointer(id); }


  void DeepCopy(vtkDataArray* da);
  void DeepCopy(vtkAbstractArray* aa)
    { this->Superclass::DeepCopy(aa); }

//BTX
  enum DeleteMethod
  {
    VTK_DATA_ARRAY_FREE,
    VTK_DATA_ARRAY_DELETE
  };
//ETX


  void SetArray(T* array, vtkIdType size, int save, int deleteMethod);
  void SetArray(T* array, vtkIdType size, int save)
    { this->SetArray(array, size, save, VTK_DATA_ARRAY_FREE); }
  virtual void SetVoidArray(void* array, vtkIdType size, int save)
    { this->SetArray(static_cast<T*>(array), size, save); }
  virtual void SetVoidArray(void* array, 
                            vtkIdType size, 
                            int save, 
                            int deleteMethod)
    { 
      this->SetArray(static_cast<T*>(array), size, save, deleteMethod); 
    }

  virtual void ExportToVoidPointer(void *out_ptr);

  virtual void ComputeRange(int comp);

  virtual vtkArrayIterator* NewIterator();
  
  //BTX

  virtual vtkIdType LookupValue(vtkVariant value);
  virtual void LookupValue(vtkVariant value, vtkIdList* ids);
  //ETX
  vtkIdType LookupValue(T value);
  void LookupValue(T value, vtkIdList* ids);
  
  virtual void DataChanged();
  
  virtual void ClearLookup();
  
protected:
  vtkDataArrayTemplate(vtkIdType numComp);
  ~vtkDataArrayTemplate();

  T* Array;   // pointer to data
  T* ResizeAndExtend(vtkIdType sz);  // function to resize data
  T* Realloc(vtkIdType sz);
  
  int TupleSize; //used for data conversion
  double* Tuple;

  int SaveUserArray;
  int DeleteMethod;

  void ComputeScalarRange(int comp);
  void ComputeVectorRange();
private:
  vtkDataArrayTemplate(const vtkDataArrayTemplate&);  // Not implemented.
  void operator=(const vtkDataArrayTemplate&);  // Not implemented.

  vtkDataArrayTemplateLookup<T>* Lookup;
  void UpdateLookup();

  void DeleteArray();
};

#if !defined(VTK_NO_EXPLICIT_TEMPLATE_INSTANTIATION)
# define VTK_DATA_ARRAY_TEMPLATE_INSTANTIATE(T) \
   template class VTK_COMMON_EXPORT vtkDataArrayTemplate< T >
#else
# include "vtkDataArrayTemplateImplicit.txx"
# define VTK_DATA_ARRAY_TEMPLATE_INSTANTIATE(T)
#endif

#endif // !defined(__vtkDataArrayTemplate_h)

// This portion must be OUTSIDE the include blockers.  Each
// vtkDataArray subclass uses this to give its instantiation of this
// template a DLL interface.
#if defined(VTK_DATA_ARRAY_TEMPLATE_TYPE)
# if defined(VTK_BUILD_SHARED_LIBS) && defined(_MSC_VER)
#  pragma warning (push)
#  pragma warning (disable: 4091) // warning C4091: 'extern ' : 
   // ignored on left of 'int' when no variable is declared
#  pragma warning (disable: 4231) // Compiler-specific extension warning.

   // We need to disable warning 4910 and do an extern dllexport
   // anyway.  When deriving vtkCharArray and other types from an
   // instantiation of this template the compiler does an explicit
   // instantiation of the base class.  From outside the vtkCommon
   // library we block this using an extern dllimport instantiation.
   // For classes inside vtkCommon we should be able to just do an
   // extern instantiation, but VS 2008 complains about missing
   // definitions.  We cannot do an extern dllimport inside vtkCommon
   // since the symbols are local to the dll.  An extern dllexport
   // seems to be the only way to convince VS 2008 to do the right
   // thing, so we just disable the warning.
#  pragma warning (disable: 4910) // extern and dllexport incompatible

   // Use an "extern explicit instantiation" to give the class a DLL
   // interface.  This is a compiler-specific extension.
   extern VTK_DATA_ARRAY_TEMPLATE_INSTANTIATE(VTK_DATA_ARRAY_TEMPLATE_TYPE);
#  pragma warning (pop)
# endif
# undef VTK_DATA_ARRAY_TEMPLATE_TYPE
#endif

---