vtkPVArrayInformation.h

Go to the documentation of this file.

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

  Program:   ParaView
  Module:    vtkPVArrayInformation.h

  Copyright (c) Kitware, Inc.
  All rights reserved.
  See Copyright.txt or http://www.paraview.org/HTML/Copyright.html 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 vtkPVArrayInformation_h
#define vtkPVArrayInformation_h

#include "vtkPVInformation.h"
#include "vtkRemotingCoreModule.h" //needed for exports

#include <string> // for std::string
#include <vector> // for std::vector

class vtkAbstractArray;
class vtkClientServerStream;
class vtkStringArray;

class VTKREMOTINGCORE_EXPORT vtkPVArrayInformation : public vtkPVInformation
{
public:
  static vtkPVArrayInformation* New();
  vtkTypeMacro(vtkPVArrayInformation, vtkPVInformation);
  void PrintSelf(ostream& os, vtkIndent indent) override;


  vtkSetMacro(DataType, int);
  vtkGetMacro(DataType, int);


  vtkSetStringMacro(Name);
  vtkGetStringMacro(Name);


  void SetNumberOfComponents(int numComps);
  vtkGetMacro(NumberOfComponents, int);

  void SetComponentName(vtkIdType component, const char* name);

  const char* GetComponentName(vtkIdType component);


  vtkSetMacro(NumberOfTuples, vtkTypeInt64);
  vtkGetMacro(NumberOfTuples, vtkTypeInt64);


  void SetComponentRange(int comp, double min, double max);
  void SetComponentRange(int comp, double* range)
  {
    this->SetComponentRange(comp, range[0], range[1]);
  }
  double* GetComponentRange(int component) VTK_SIZEHINT(2);
  void GetComponentRange(int comp, double range[2]);


  void SetComponentFiniteRange(int comp, double min, double max);
  void SetComponentFiniteRange(int comp, double* range)
  {
    this->SetComponentFiniteRange(comp, range[0], range[1]);
  }
  double* GetComponentFiniteRange(int component);
  void GetComponentFiniteRange(int comp, double range[2]);

  void GetDataTypeRange(double range[2]);

  int Compare(vtkPVArrayInformation* info);

  void DeepCopy(vtkPVArrayInformation* info);

  void CopyFromObject(vtkObject*) override;

  void AddInformation(vtkPVInformation*) override;


  void CopyToStream(vtkClientServerStream*) override;
  void CopyFromStream(const vtkClientServerStream*) override;


  vtkSetMacro(IsPartial, int);
  vtkGetMacro(IsPartial, int);

  void Initialize();


  void AddInformationKeys(vtkPVArrayInformation* info);
  void AddInformationKey(const char* location, const char* name);
  void AddUniqueInformationKey(const char* location, const char* name);


  int GetNumberOfInformationKeys();
  const char* GetInformationKeyLocation(int);
  const char* GetInformationKeyName(int);
  int HasInformationKey(const char* location, const char* name);


  int GetNumberOfStringValues();
  const char* GetStringValue(int);

protected:
  vtkPVArrayInformation();
  ~vtkPVArrayInformation() override;

  void AddRanges(vtkPVArrayInformation* info);
  void AddFiniteRanges(vtkPVArrayInformation* info);
  void AddValues(vtkPVArrayInformation* info);

  int IsPartial;
  int DataType;
  int NumberOfComponents;
  vtkTypeInt64 NumberOfTuples;
  char* Name;
  double* Ranges;
  double* FiniteRanges;
  std::vector<std::string> StringValues;

  // this array is used to store existing information keys (location/name pairs)

  class vtkInternalInformationKeys;
  vtkInternalInformationKeys* InformationKeys;

  // this is used by GetComponentName, so that it always return a valid component name

  std::string* DefaultComponentName;

  void DetermineDefaultComponentName(const int& component_no, const int& numComps);

  class vtkInternalComponentNames;
  vtkInternalComponentNames* ComponentNames;

  vtkPVArrayInformation(const vtkPVArrayInformation&) = delete;
  void operator=(const vtkPVArrayInformation&) = delete;
};

#endif