paraview-dev 5.0.1+dfsg1-4 / usr / include / paraview / vtkSpyPlotBlockIterator.h

This file is indexed.

/usr/include/paraview/vtkSpyPlotBlockIterator.h is in paraview-dev 5.0.1+dfsg1-4.

This file is owned by root:root, with mode 0o644.

The actual contents of the file can be viewed below. 

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
#ifndef vtkSpyPlotBlockIterator_h
#define vtkSpyPlotBlockIterator_h

#include "vtkPVVTKExtensionsDefaultModule.h" //needed for exports
#include "vtkSpyPlotUniReader.h"
#include "vtkSpyPlotReaderMap.h"
#include "assert.h"

class vtkSpyBlock;
class vtkSpyPlotReaderMap;
class vtkSpyPlotReader;

//-----------------------------------------------------------------------------
class VTKPVVTKEXTENSIONSDEFAULT_EXPORT vtkSpyPlotBlockIterator
{
public:
  // Description:
  // Initialize the iterator with informations 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() {}

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 VTKPVVTKEXTENSIONSDEFAULT_EXPORT vtkSpyPlotBlockDistributionBlockIterator
  : public vtkSpyPlotBlockIterator
{
public:
  vtkSpyPlotBlockDistributionBlockIterator() {}
  virtual ~vtkSpyPlotBlockDistributionBlockIterator() {}
  virtual void Start();
  virtual int GetNumberOfBlocksToProcess();
protected:
  virtual void FindFirstBlockOfCurrentOrNextFile();
};


class VTKPVVTKEXTENSIONSDEFAULT_EXPORT vtkSpyPlotFileDistributionBlockIterator
  : public vtkSpyPlotBlockIterator
{
public:
    vtkSpyPlotFileDistributionBlockIterator();
  virtual ~vtkSpyPlotFileDistributionBlockIterator() {}
  virtual void Init(int numberOfProcessors,
                    int processorId,
                    vtkSpyPlotReader *parent,
                    vtkSpyPlotReaderMap *fileMap,
                    int currentTimeStep);
  virtual void Start();
  virtual int GetNumberOfBlocksToProcess();

protected:
  virtual void FindFirstBlockOfCurrentOrNextFile();
  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

APT Browse - Built by Thomas Orozco.