vtkGenericDataArray.h

Go to the documentation of this file.

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

  Program:   Visualization Toolkit
  Module:    vtkGenericDataArray.h

  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 vtkGenericDataArray_h
#define vtkGenericDataArray_h

#include "vtkDataArray.h"
#include "vtkSmartPointer.h"
#include "vtkTypeTraits.h"
#include "vtkGenericDataArrayLookupHelper.h"

#include <cassert>

template<class DerivedT, class ValueTypeT>
class vtkGenericDataArray : public vtkDataArray
{
  typedef vtkGenericDataArray<DerivedT, ValueTypeT> SelfType;
public:
  typedef ValueTypeT ValueType;
  vtkTemplateTypeMacro(SelfType, vtkDataArray)

  
  enum { VTK_DATA_TYPE = vtkTypeTraits<ValueType>::VTK_TYPE_ID };


  inline ValueType GetValue(vtkIdType valueIdx) const
  {
    return static_cast<const DerivedT*>(this)->GetValue(valueIdx);
  }

  inline void SetValue(vtkIdType valueIdx, ValueType value)
  {
    static_cast<DerivedT*>(this)->SetValue(valueIdx, value);
  }

  inline void GetTypedTuple(vtkIdType tupleIdx, ValueType* tuple) const
  {
    static_cast<const DerivedT*>(this)->GetTypedTuple(tupleIdx, tuple);
  }

  inline void SetTypedTuple(vtkIdType tupleIdx, const ValueType* tuple)
  {
    static_cast<DerivedT*>(this)->SetTypedTuple(tupleIdx, tuple);
  }

  inline ValueType GetTypedComponent(vtkIdType tupleIdx, int compIdx) const
  {
    return static_cast<const DerivedT*>(this)->GetTypedComponent(tupleIdx,
                                                                 compIdx);
  }

  inline void SetTypedComponent(vtkIdType tupleIdx, int compIdx,
                                ValueType value)
  {
    static_cast<DerivedT*>(this)->SetTypedComponent(tupleIdx, compIdx, value);
  }


  void *GetVoidPointer(vtkIdType valueIdx) VTK_OVERRIDE;
  ValueType* GetPointer(vtkIdType valueIdx);
  void SetVoidArray(void*, vtkIdType, int) VTK_OVERRIDE;
  void SetVoidArray(void*, vtkIdType, int, int) VTK_OVERRIDE;
  void* WriteVoidPointer(vtkIdType valueIdx, vtkIdType numValues) VTK_OVERRIDE;
  ValueType* WritePointer(vtkIdType valueIdx, vtkIdType numValues);

  void RemoveTuple(vtkIdType tupleIdx) VTK_OVERRIDE;

  vtkIdType InsertNextValue(ValueType value);

  void InsertValue(vtkIdType valueIdx, ValueType value);

  void InsertTypedTuple(vtkIdType tupleIdx, const ValueType *t);

  vtkIdType InsertNextTypedTuple(const ValueType *t);

  void InsertTypedComponent(vtkIdType tupleIdx, int compIdx, ValueType val);


  void GetValueRange(ValueType range[2], int comp);
  ValueType *GetValueRange(int comp);

  ValueType *GetValueRange() { return this->GetValueRange(0); }
  void GetValueRange(ValueType range[2]) { this->GetValueRange(range, 0); }

  vtkIdType Capacity() { return this->Size; }

  int GetDataType() VTK_OVERRIDE;
  int GetDataTypeSize() VTK_OVERRIDE;
  bool HasStandardMemoryLayout() VTK_OVERRIDE;
  int Allocate(vtkIdType size, vtkIdType ext = 1000) VTK_OVERRIDE;
  int Resize(vtkIdType numTuples) VTK_OVERRIDE;
  void SetNumberOfComponents(int num) VTK_OVERRIDE;
  void SetNumberOfTuples(vtkIdType number) VTK_OVERRIDE;
  void Initialize() VTK_OVERRIDE;
  void Squeeze() VTK_OVERRIDE;
  void SetTuple(vtkIdType dstTupleIdx, vtkIdType srcTupleIdx,
                vtkAbstractArray* source) VTK_OVERRIDE;
  // MSVC doesn't like 'using' here (error C2487). Just forward instead:
  // using Superclass::SetTuple;
  void SetTuple(vtkIdType tupleIdx, const float *tuple) VTK_OVERRIDE
  { this->Superclass::SetTuple(tupleIdx, tuple); }
  void SetTuple(vtkIdType tupleIdx, const double *tuple) VTK_OVERRIDE
  { this->Superclass::SetTuple(tupleIdx, tuple); }

  void InsertTuples(vtkIdList *dstIds, vtkIdList *srcIds,
                    vtkAbstractArray *source) VTK_OVERRIDE;
  // MSVC doesn't like 'using' here (error C2487). Just forward instead:
  // using Superclass::InsertTuples;
  void InsertTuples(vtkIdType dstStart, vtkIdType n, vtkIdType srcStart,
                    vtkAbstractArray* source) VTK_OVERRIDE
  { this->Superclass::InsertTuples(dstStart, n, srcStart, source); }

  void InsertTuple(vtkIdType dstTupleIdx, vtkIdType srcTupleIdx,
                   vtkAbstractArray *source) VTK_OVERRIDE;
  void InsertTuple(vtkIdType tupleIdx, const float *source) VTK_OVERRIDE;
  void InsertTuple(vtkIdType tupleIdx, const double *source) VTK_OVERRIDE;
  void InsertComponent(vtkIdType tupleIdx, int compIdx,
                       double value) VTK_OVERRIDE;
  vtkIdType InsertNextTuple(vtkIdType srcTupleIdx,
                            vtkAbstractArray *source) VTK_OVERRIDE;
  vtkIdType InsertNextTuple(const float *tuple) VTK_OVERRIDE;
  vtkIdType InsertNextTuple(const double *tuple) VTK_OVERRIDE;
  void GetTuples(vtkIdList *tupleIds,
                 vtkAbstractArray *output) VTK_OVERRIDE;
  void GetTuples(vtkIdType p1, vtkIdType p2,
                 vtkAbstractArray *output) VTK_OVERRIDE;
  double *GetTuple(vtkIdType tupleIdx) VTK_OVERRIDE;
  void GetTuple(vtkIdType tupleIdx, double * tuple) VTK_OVERRIDE;
  void InterpolateTuple(vtkIdType dstTupleIdx, vtkIdList *ptIndices,
                        vtkAbstractArray* source,
                        double* weights) VTK_OVERRIDE;
  void InterpolateTuple(vtkIdType dstTupleIdx,
    vtkIdType srcTupleIdx1, vtkAbstractArray* source1,
    vtkIdType srcTupleIdx2, vtkAbstractArray* source2, double t) VTK_OVERRIDE;
  void SetComponent(vtkIdType tupleIdx, int compIdx, double value) VTK_OVERRIDE;
  double GetComponent(vtkIdType tupleIdx, int compIdx) VTK_OVERRIDE;
  void SetVariantValue(vtkIdType valueIdx, vtkVariant value) VTK_OVERRIDE;
  vtkVariant GetVariantValue(vtkIdType valueIdx) VTK_OVERRIDE;
  void InsertVariantValue(vtkIdType valueIdx, vtkVariant value) VTK_OVERRIDE;
  vtkIdType LookupValue(vtkVariant value) VTK_OVERRIDE;
  virtual vtkIdType LookupTypedValue(ValueType value);
  void LookupValue(vtkVariant value, vtkIdList* valueIds) VTK_OVERRIDE;
  virtual void LookupTypedValue(ValueType value, vtkIdList* valueIds);
  void ClearLookup() VTK_OVERRIDE;
  void DataChanged() VTK_OVERRIDE;
  VTK_NEWINSTANCE vtkArrayIterator* NewIterator() VTK_OVERRIDE;

protected:
  vtkGenericDataArray();
  ~vtkGenericDataArray() VTK_OVERRIDE;

  inline bool AllocateTuples(vtkIdType numTuples)
  {
    return static_cast<DerivedT*>(this)->AllocateTuples(numTuples);
  }

  inline bool ReallocateTuples(vtkIdType numTuples)
  {
    return static_cast<DerivedT*>(this)->ReallocateTuples(numTuples);
  }

  // This method resizes the array if needed so that the given tuple index is
  // valid/accessible.
  bool EnsureAccessToTuple(vtkIdType tupleIdx);

  vtkGenericDataArrayLookupHelper<SelfType> Lookup;
private:
  vtkGenericDataArray(const vtkGenericDataArray&) VTK_DELETE_FUNCTION;
  void operator=(const vtkGenericDataArray&) VTK_DELETE_FUNCTION;

  std::vector<double> LegacyTuple;
  std::vector<ValueType> LegacyValueRange;
};

#include "vtkGenericDataArray.txx"

// Adds an implementation of NewInstanceInternal() that returns an AoS
// (unmapped) VTK array, if possible. This allows the pipeline to copy and
// propagate the array when the array data is not modifiable. Use this in
// combination with vtkAbstractTypeMacro or vtkAbstractTemplateTypeMacro
// (instead of vtkTypeMacro) to avoid adding the default NewInstance
// implementation.
#define vtkAOSArrayNewInstanceMacro(thisClass) \
  protected: \
  vtkObjectBase *NewInstanceInternal() const VTK_OVERRIDE \
  { \
    if (vtkDataArray *da = \
        vtkDataArray::CreateDataArray(thisClass::VTK_DATA_TYPE)) \
    { \
      return da; \
    } \
    return thisClass::New(); \
  } \
  public:

#endif
// VTK-HeaderTest-Exclude: vtkGenericDataArray.h