vtkSpyPlotBlockIterator.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (c) Kitware Inc.
// SPDX-License-Identifier: BSD-3-Clause
#ifndef vtkSpyPlotBlockIterator_h
#define vtkSpyPlotBlockIterator_h

#include "vtkPVVTKExtensionsIOSPCTHModule.h" //needed for exports
#include "vtkSpyPlotReaderMap.h"             // for vtkSpyPlotReaderMap iterator
#include "vtkSpyPlotUniReader.h"             // for vtkSpyPlotUniReader

#include <cassert> // for assert

class vtkSpyPlotReader;

//-----------------------------------------------------------------------------
class VTKPVVTKEXTENSIONSIOSPCTH_EXPORT vtkSpyPlotBlockIterator
{
public:
  // Description:
  // Initialize the iterator with information about processors,
  // files and timestep.
  virtual void Init(int numberOfProcessors, int processorId, vtkSpyPlotReader* parent,
    vtkSpyPlotReaderMap* fileMap, int currentTimeStep);

  // Description:
  // Go to first block if any.
  virtual void Start() = 0;

  // Description:
  // Returns the total number of blocks to be processed by this Processor.
  // Can be called only after Init().
  virtual int GetNumberOfBlocksToProcess() = 0;

  // Description:
  // Are there still blocks to iterate over?
  int IsActive() const;

  // Description:
  // Go to the next block if any
  // \pre is_active: IsActive()
  void Next();

  // Description:
  // Return the block at current position.
  // \pre is_active: IsActive()
  vtkSpyPlotBlock* GetBlock() const;

  // Description:
  // Return the blockID at current position.
  // \pre is_active: IsActive()
  int GetBlockID() const;

  // Description:
  // Return the number of fields at current position.
  // \pre is_active: IsActive()
  int GetNumberOfFields() const;

  // Description:
  // Return the SPCTH API handle at current position.
  // \pre is_active: IsActive()
  vtkSpyPlotUniReader* GetUniReader() const;

  // Description:
  // Return the number of processors being used
  int GetNumberOfProcessors() const;

  // Description:
  // Return the id of this processor
  int GetProcessorId() const;

  virtual ~vtkSpyPlotBlockIterator() = default;

protected:
  vtkSpyPlotBlockIterator();

  virtual void FindFirstBlockOfCurrentOrNextFile() = 0;

  int NumberOfProcessors;
  int ProcessorId;
  vtkSpyPlotReaderMap* FileMap;
  int CurrentTimeStep;

  int NumberOfFiles;

  int Active;
  int Block;
  int NumberOfFields;
  vtkSpyPlotUniReader* UniReader;

  vtkSpyPlotReaderMap::MapOfStringToSPCTH::iterator FileIterator;
  int FileIndex;

  int BlockEnd;
  vtkSpyPlotReader* Parent;
};

class VTKPVVTKEXTENSIONSIOSPCTH_EXPORT vtkSpyPlotBlockDistributionBlockIterator
  : public vtkSpyPlotBlockIterator
{
public:
  vtkSpyPlotBlockDistributionBlockIterator() = default;
  ~vtkSpyPlotBlockDistributionBlockIterator() override = default;
  void Start() override;
  int GetNumberOfBlocksToProcess() override;

protected:
  void FindFirstBlockOfCurrentOrNextFile() override;
};

class VTKPVVTKEXTENSIONSIOSPCTH_EXPORT vtkSpyPlotFileDistributionBlockIterator
  : public vtkSpyPlotBlockIterator
{
public:
  vtkSpyPlotFileDistributionBlockIterator();
  ~vtkSpyPlotFileDistributionBlockIterator() override = default;
  void Init(int numberOfProcessors, int processorId, vtkSpyPlotReader* parent,
    vtkSpyPlotReaderMap* fileMap, int currentTimeStep) override;
  void Start() override;
  int GetNumberOfBlocksToProcess() override;

protected:
  void FindFirstBlockOfCurrentOrNextFile() override;
  int FileStart;
  int FileEnd;
};

inline void vtkSpyPlotBlockIterator::Next()
{
  assert("pre: is_active" && IsActive());

  ++this->Block;
  if (this->Block > this->BlockEnd)
  {
    ++this->FileIterator;
    ++this->FileIndex;
    this->FindFirstBlockOfCurrentOrNextFile();
  }
}

inline int vtkSpyPlotBlockIterator::GetProcessorId() const
{
  return this->ProcessorId;
}

inline int vtkSpyPlotBlockIterator::GetNumberOfProcessors() const
{
  return this->NumberOfProcessors;
}

inline vtkSpyPlotUniReader* vtkSpyPlotBlockIterator::GetUniReader() const
{
  assert("pre: is_active" && IsActive());
  return this->UniReader;
}

inline int vtkSpyPlotBlockIterator::IsActive() const
{
  return this->Active;
}

inline vtkSpyPlotBlock* vtkSpyPlotBlockIterator::GetBlock() const
{
  assert("pre: is_active" && IsActive());
  return this->UniReader->GetBlock(Block);
}

inline int vtkSpyPlotBlockIterator::GetBlockID() const
{
  assert("pre: is_active" && IsActive());
  return Block;
}

inline int vtkSpyPlotBlockIterator::GetNumberOfFields() const
{
  assert("pre: is_active" && IsActive());
  return this->NumberOfFields;
}

#endif

// VTK-HeaderTest-Exclude: vtkSpyPlotBlockIterator.h