vtkFieldData.h

Go to the documentation of this file.

/*=========================================================================
 
  Program:   Visualization Toolkit
  Module:    vtkFieldData.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 vtkFieldData_h
#define vtkFieldData_h
 
#include "vtkCommonDataModelModule.h" // For export macro
#include "vtkObject.h"
 
#include "vtkAbstractArray.h" // Needed for inline methods.
 
class vtkIdList;
 
class VTKCOMMONDATAMODEL_EXPORT vtkFieldData : public vtkObject
{
public:
  static vtkFieldData *New();
 
  vtkTypeMacro(vtkFieldData,vtkObject);
  void PrintSelf(ostream& os, vtkIndent indent);
 
  virtual void Initialize();
 
  int Allocate(const vtkIdType sz, const vtkIdType ext=1000);
 
  void CopyStructure(vtkFieldData*);
 
  void AllocateArrays(int num);
 
 
  int GetNumberOfArrays()
    {
      return this->NumberOfActiveArrays;
    }
 
  int AddArray(vtkAbstractArray *array);
 
 
  virtual void RemoveArray(const char *name)
    {
      int i;
      this->GetAbstractArray(name, i);
      this->RemoveArray(i);
    }
 
  vtkDataArray *GetArray(int i);
 
  vtkDataArray *GetArray(const char *arrayName, int &index);
 
 
  vtkDataArray *GetArray(const char *arrayName)
    {
      int i;
      return this->GetArray(arrayName, i);
    }
 
  vtkAbstractArray* GetAbstractArray(int i);
 
  vtkAbstractArray* GetAbstractArray(const char* arrayName, int &index);
 
 
  vtkAbstractArray* GetAbstractArray(const char* arrayName)
    {
    int i;
    return this->GetAbstractArray(arrayName, i);
    }
 
 
  int HasArray(const char *name)
    {
      int i;
      vtkAbstractArray *array = this->GetAbstractArray(name, i);
      // assert( i == -1);
      return array ? 1 : 0;
    }
 
 
  const char* GetArrayName(int i)
    {
    vtkAbstractArray* da = this->GetAbstractArray(i);
    return da ? da->GetName() : 0;
    }
 
  virtual void PassData(vtkFieldData* fd);
 
 
  void CopyFieldOn(const char* name) { this->CopyFieldOnOff(name, 1); }
  void CopyFieldOff(const char* name) { this->CopyFieldOnOff(name, 0); }
 
  virtual void CopyAllOn(int unused=0);
 
  virtual void CopyAllOff(int unused=0);
 
  virtual void DeepCopy(vtkFieldData *da);
 
  virtual void ShallowCopy(vtkFieldData *da);
 
  void Squeeze();
 
  void Reset();
 
  virtual unsigned long GetActualMemorySize();
 
  unsigned long int GetMTime();
 
  void GetField(vtkIdList *ptId, vtkFieldData *f);
 
  int GetArrayContainingComponent(int i, int& arrayComp);
 
  int GetNumberOfComponents();
 
  vtkIdType GetNumberOfTuples();
 
  void SetNumberOfTuples(const vtkIdType number);
 
  void SetTuple(const vtkIdType i, const vtkIdType j, vtkFieldData* source);
 
  void InsertTuple(const vtkIdType i, const vtkIdType j, vtkFieldData* source);
 
  vtkIdType InsertNextTuple(const vtkIdType j, vtkFieldData* source);
 
protected:
 
  vtkFieldData();
  ~vtkFieldData();
 
  int NumberOfArrays;
  int NumberOfActiveArrays;
  vtkAbstractArray **Data;
 
  void SetArray(int i, vtkAbstractArray *array);
 
  virtual void RemoveArray(int index);
 
  virtual void InitializeFields();
 
//BTX
 
  struct CopyFieldFlag
  {
    char* ArrayName;
    int IsCopied;
  };
 
  CopyFieldFlag* CopyFieldFlags; //the names of fields not to be copied
  int NumberOfFieldFlags; //the number of fields not to be copied
  void CopyFieldOnOff(const char* name, int onOff);
  void ClearFieldFlags();
  int FindFlag(const char* field);
  int GetFlag(const char* field);
  void CopyFlags(const vtkFieldData* source);
  int DoCopyAllOn;
  int DoCopyAllOff;
 
 
private:
  vtkFieldData(const vtkFieldData&);  // Not implemented.
  void operator=(const vtkFieldData&);  // Not implemented.
 
public:
 
  class VTKCOMMONDATAMODEL_EXPORT BasicIterator
  {
  public:
    BasicIterator();
    BasicIterator(const BasicIterator& source);
    BasicIterator(const int* list, unsigned int listSize);
    BasicIterator& operator=(const BasicIterator& source);
    virtual ~BasicIterator();
    void PrintSelf(ostream &os, vtkIndent indent);
 
    int GetListSize() const
      {
        return this->ListSize;
      }
    int GetCurrentIndex()
      {
        return this->List[this->Position];
      }
    int BeginIndex()
      {
        this->Position = -1;
        return this->NextIndex();
      }
    int End() const
      {
        return (this->Position >= this->ListSize);
      }
    int NextIndex()
      {
        this->Position++;
        return (this->End() ? -1 : this->List[this->Position]);
      }
 
  protected:
 
    int* List;
    int ListSize;
    int Position;
  };
 
  class VTKCOMMONDATAMODEL_EXPORT Iterator : public BasicIterator
  {
  public:
 
    Iterator(const Iterator& source);
    Iterator& operator=(const Iterator& source);
    virtual ~Iterator();
    Iterator(vtkFieldData* dsa, const int* list=0,
             unsigned int listSize=0);
 
    vtkDataArray* Begin()
      {
        this->Position = -1;
        return this->Next();
      }
 
    vtkDataArray* Next()
      {
        this->Position++;
        if (this->End())
          {
          return 0;
          }
 
        // vtkFieldData::GetArray() can return null, which implies that
        // a the array at the given index in not a vtkDataArray subclass.
        // This iterator skips such arrays.
        vtkDataArray* cur =  Fields->GetArray(this->List[this->Position]);
        return (cur? cur : this->Next());
      }
 
    void DetachFieldData();
 
  protected:
    vtkFieldData* Fields;
    int Detached;
  };
 
 
//ETX
 
};
 
 
#endif