vtkXMLReader.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
// SPDX-License-Identifier: BSD-3-Clause
 
#ifndef vtkXMLReader_h
#define vtkXMLReader_h
 
#include "vtkAlgorithm.h"
#include "vtkIOXMLModule.h"   // For export macro
#include "vtkSmartPointer.h"  // for vtkSmartPointer.
#include "vtkWrappingHints.h" // For VTK_MARSHALAUTO
 
#include <istream>   // for IStream
#include <memory>    // for std::unique_ptr
#include <streambuf> // for Streambuf
#include <string>    // for std::string
 
VTK_ABI_NAMESPACE_BEGIN
class vtkAbstractArray;
class vtkCallbackCommand;
class vtkCharArray;
class vtkCommand;
class vtkDataArray;
class vtkDataArraySelection;
class vtkDataSet;
class vtkDataSetAttributes;
class vtkInformation;
class vtkInformationVector;
class vtkResourceStream;
class vtkStringArray;
class vtkXMLDataElement;
class vtkXMLDataParser;
 
class VTKIOXML_EXPORT VTK_MARSHALAUTO vtkXMLReader : public vtkAlgorithm
{
public:
  vtkTypeMacro(vtkXMLReader, vtkAlgorithm);
  void PrintSelf(ostream& os, vtkIndent indent) override;
 
  enum FieldType
  {
    POINT_DATA,
    CELL_DATA,
    OTHER
  };


  vtkSetFilePathMacro(FileName);
  vtkGetFilePathMacro(FileName);


  vtkSetMacro(ReadFromInputString, vtkTypeBool);
  vtkGetMacro(ReadFromInputString, vtkTypeBool);
  vtkBooleanMacro(ReadFromInputString, vtkTypeBool);

  void SetInputString(const char* in);
  void SetInputString(const char* in, int len);
  void SetBinaryInputString(const char*, int len);
  void SetInputString(const std::string& input)
  {
    this->SetBinaryInputString(input.c_str(), static_cast<int>(input.length()));
  }



  virtual void SetInputArray(vtkCharArray*);


  vtkSetMacro(ReadFromInputStream, bool);
  vtkGetMacro(ReadFromInputStream, bool);
  vtkBooleanMacro(ReadFromInputStream, bool);


  void SetStream(vtkResourceStream* stream);
  vtkResourceStream* GetStream();


  virtual int CanReadFile(VTK_FILEPATH const char* name);
  bool CanReadFile(vtkResourceStream* stream);


  vtkDataSet* GetOutputAsDataSet();
  vtkDataSet* GetOutputAsDataSet(int index);


  vtkGetObjectMacro(PointDataArraySelection, vtkDataArraySelection);
  vtkGetObjectMacro(CellDataArraySelection, vtkDataArraySelection);
  vtkGetObjectMacro(ColumnArraySelection, vtkDataArraySelection);


  int GetNumberOfPointArrays();
  int GetNumberOfCellArrays();
  int GetNumberOfColumnArrays();


  int GetNumberOfTimeDataArrays() const;
  const char* GetTimeDataArray(int idx) const;
  vtkGetObjectMacro(TimeDataStringArray, vtkStringArray);


  vtkGetStringMacro(ActiveTimeDataArrayName);
  vtkSetStringMacro(ActiveTimeDataArrayName);


  const char* GetPointArrayName(int index);
  const char* GetCellArrayName(int index);
  const char* GetColumnArrayName(int index);


  int GetPointArrayStatus(const char* name);
  int GetCellArrayStatus(const char* name);
  void SetPointArrayStatus(const char* name, int status);
  void SetCellArrayStatus(const char* name, int status);
  int GetColumnArrayStatus(const char* name);
  void SetColumnArrayStatus(const char* name, int status);
 
  // For the specified port, copy the information this reader sets up in
  // SetupOutputInformation to outInfo
  virtual void CopyOutputInformation(vtkInformation* vtkNotUsed(outInfo), int vtkNotUsed(port)) {}


  vtkSetMacro(TimeStep, int);
  vtkGetMacro(TimeStep, int);
 
  vtkGetMacro(NumberOfTimeSteps, int);

  vtkGetVector2Macro(TimeStepRange, int);
  vtkSetVector2Macro(TimeStepRange, int);

  vtkXMLDataParser* GetXMLParser() { return this->XMLParser; }
 
  vtkTypeBool ProcessRequest(vtkInformation* request, vtkInformationVector** inputVector,
    vtkInformationVector* outputVector) override;


  void SetReaderErrorObserver(vtkCommand*);
  vtkGetObjectMacro(ReaderErrorObserver, vtkCommand);


  void SetParserErrorObserver(vtkCommand*);
  vtkGetObjectMacro(ParserErrorObserver, vtkCommand);

  vtkMTimeType GetMTime() override;
 
protected:
  vtkXMLReader();
  ~vtkXMLReader() override;


  virtual int ReadXMLInformation();
  virtual void ReadXMLData();

  virtual const char* GetDataSetName() = 0;

  virtual int CanReadFileVersion(int major, int minor);

  virtual void SetupEmptyOutput() = 0;

  virtual void SetupOutputInformation(vtkInformation* vtkNotUsed(outInfo)) {}

  virtual void SetupOutputData();

  virtual int ReadPrimaryElement(vtkXMLDataElement* ePrimary);

  virtual int ReadVTKFile(vtkXMLDataElement* eVTKFile);

  int GetLocalDataType(vtkXMLDataElement* da, int datatype);

  vtkAbstractArray* CreateArray(vtkXMLDataElement* da);

  int CreateInformationKey(vtkXMLDataElement* eInfoKey, vtkInformation* info);

  bool ReadInformation(vtkXMLDataElement* infoRoot, vtkInformation* info);


  virtual int OpenStream();
  virtual void CloseStream();
  virtual int OpenVTKFile();
  virtual void CloseVTKFile();
  virtual int OpenVTKString();
  virtual void CloseVTKString();
  virtual void CreateXMLParser();
  virtual void DestroyXMLParser();
  void SetupCompressor(const char* type);
  int CanReadFileVersionString(const char* version);

  virtual int CanReadFileWithDataType(const char* dsname);

  vtkGetMacro(FileMajorVersion, int);

  vtkGetMacro(FileMinorVersion, int);


  int IntersectExtents(
    VTK_FUTURE_CONST int extent1[6], VTK_FUTURE_CONST int extent2[6], int result[6]);
  void ComputePointDimensions(VTK_FUTURE_CONST int extent[6], int* dimensions);
  void ComputePointIncrements(VTK_FUTURE_CONST int extent[6], vtkIdType* increments);
  void ComputeCellDimensions(VTK_FUTURE_CONST int extent[6], int* dimensions);
  void ComputeCellIncrements(VTK_FUTURE_CONST int extent[6], vtkIdType* increments);
  vtkIdType GetStartTuple(
    VTK_FUTURE_CONST int extent[6], vtkIdType* increments, int i, int j, int k);
  void ReadAttributeIndices(vtkXMLDataElement* eDSA, vtkDataSetAttributes* dsa);
  char** CreateStringArray(int numStrings);
  void DestroyStringArray(int numStrings, char** strings);

  virtual int ReadArrayValues(vtkXMLDataElement* da, vtkIdType arrayIndex, vtkAbstractArray* array,
    vtkIdType startIndex, vtkIdType numValues, FieldType type = OTHER);

  virtual int ReadArrayTuples(vtkXMLDataElement* da, vtkIdType arrayTupleIndex,
    vtkAbstractArray* array, vtkIdType startTupleIndex, vtkIdType numTuples,
    FieldType type = OTHER);

  void SetDataArraySelections(vtkXMLDataElement* eDSA, vtkDataArraySelection* sel);
 
  int SetFieldDataInfo(vtkXMLDataElement* eDSA, int association, vtkIdType numTuples,
    vtkInformationVector*(&infoVector));


  int PointDataArrayIsEnabled(vtkXMLDataElement* ePDA);
  int CellDataArrayIsEnabled(vtkXMLDataElement* eCDA);

  static void SelectionModifiedCallback(
    vtkObject* caller, unsigned long eid, void* clientdata, void* calldata);

  virtual void SqueezeOutputArrays(vtkDataObject*) {}

  void MarkIdTypeArrays(vtkXMLDataElement* da);
 
  // The vtkXMLDataParser instance used to hide XML reading details.
  vtkXMLDataParser* XMLParser;
 
  // The FieldData element representation.
  vtkXMLDataElement* FieldDataElement;
 
  // The input file's name.
  char* FileName;
 
  // The stream used to read the input.
  std::istream* Stream;
 
  // Whether this object is reading from a string or a file.
  // Default is 0: read from file.
  vtkTypeBool ReadFromInputString;
 
  // The input string.
  std::string InputString;
 
  // The input array. Keeps a low memory footprint by sourcing StringStream from contents of this
  // array
  vtkCharArray* InputArray;
 
  // The array selections.
  vtkDataArraySelection* PointDataArraySelection;
  vtkDataArraySelection* CellDataArraySelection;
  vtkDataArraySelection* ColumnArraySelection;
  vtkStringArray* TimeDataStringArray;

  char* ActiveTimeDataArrayName;

  vtkSmartPointer<vtkDataArray> TimeDataArray;
 
  // The observer to modify this object when the array selections are
  // modified.
  vtkCallbackCommand* SelectionObserver;
 
  // Whether there was an error reading the file in RequestInformation.
  int InformationError;
 
  // Whether there was an error reading the file in RequestData.
  int DataError;
 
  // incrementally fine-tuned progress updates.
  virtual void GetProgressRange(float* range);
  virtual void SetProgressRange(const float range[2], int curStep, int numSteps);
  virtual void SetProgressRange(const float range[2], int curStep, const float* fractions);
  virtual void UpdateProgressDiscrete(float progress);
  float ProgressRange[2];
 
  virtual int RequestData(vtkInformation* request, vtkInformationVector** inputVector,
    vtkInformationVector* outputVector);
  virtual int RequestDataObject(vtkInformation* vtkNotUsed(request),
    vtkInformationVector** vtkNotUsed(inputVector), vtkInformationVector* vtkNotUsed(outputVector))
  {
    return 1;
  }
  virtual int RequestInformation(vtkInformation* request, vtkInformationVector** inputVector,
    vtkInformationVector* outputVector);
  vtkTimeStamp ReadMTime;
 
  // Whether there was an error reading the XML.
  int ReadError;
 
  // For structured data keep track of dimensions empty of cells.  For
  // unstructured data these are always zero.  This is used to support
  // 1-D and 2-D cell data.
  int AxesEmpty[3];
 
  // The timestep currently being read.
  int TimeStep;
  int CurrentTimeStep;
  int NumberOfTimeSteps;
  void SetNumberOfTimeSteps(int num);
  // buffer for reading timestep from the XML file the length is of
  // NumberOfTimeSteps and therefore is always long enough
  int* TimeSteps;
  // Store the range of time steps
  int TimeStepRange[2];
 
  // Now we need to save what was the last time read for each kind of
  // data to avoid rereading it that is to say we need a var for
  // e.g. PointData/CellData/Points/Cells...
  // See SubClass for details with member vars like PointsTimeStep/PointsOffset
 
  // Helper function useful to know if a timestep is found in an array of timestep
  static int IsTimeStepInArray(int timestep, int* timesteps, int length);
 
  vtkDataObject* GetCurrentOutput();
  vtkInformation* GetCurrentOutputInformation();
 
  // Flag for whether DataProgressCallback should actually update
  // progress.
  int InReadData;
 
  virtual void ConvertGhostLevelsToGhostType(FieldType, vtkAbstractArray*, vtkIdType, vtkIdType) {}
 
  /*
   * Populate the output's FieldData with the file's FieldData tags content
   */
  void ReadFieldData();
 
private:
  int OpenVTKStream();
 
  // The stream used to read the input if it is in a resource stream
  vtkSmartPointer<vtkResourceStream> ResourceStream;
 
  bool ReadFromInputStream = false;
 
  // The stream used to read the input if it is in a file.
  istream* FileStream;
  // The stream used to read the input if it is in a string.
  std::istringstream* StringStream;
 
  // Used when converting vtkResourceStream into istream
  std::unique_ptr<std::streambuf> Streambuf;
  std::unique_ptr<std::istream> StreamBuffer;
 
  int TimeStepWasReadOnce;
 
  int FileMajorVersion;
  int FileMinorVersion;
 
  vtkDataObject* CurrentOutput;
  vtkInformation* CurrentOutputInformation;
 
  vtkXMLReader(const vtkXMLReader&) = delete;
  void operator=(const vtkXMLReader&) = delete;
 
  vtkCommand* ReaderErrorObserver;
  vtkCommand* ParserErrorObserver;
};
 
VTK_ABI_NAMESPACE_END
#endif