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
|
/*=========================================================================
Program: Visualization Toolkit
Module: vtkDataArrayIteratorMacro.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.
=========================================================================*/
/**
* @class vtkDataArrayIteratorMacro
* @brief A macro for obtaining iterators to
* vtkDataArray data when the array implementation and type are unknown.
*
*
*
* NOTE: This macro is deprecated and should not be used any longer. Use
* vtkArrayDispatch and the vtkGenericDataArray API instead of
* vtkDataArrayIteratorMacro and vtkTypedDataArrayIterator.
*
* See vtkTemplateMacro.
* This macro is similar, but defines several additional typedefs and variables
* for safely iterating through data in a vtkAbstractArray container:
* - vtkDAValueType is typedef'd to the array's element value type.
* - vtkDAContainerType is typedef'd to the most derived class of
* vtkAbstractArray for which a suitable iterator has been found.
* - vtkDAIteratorType is typedef'd to the most suitable iterator type found.
* - vtkDABegin is an object of vtkDAIteratorType that points to the first
* component of the first tuple in the array.
* - vtkDAEnd is an object of vtkDAIteratorType that points to the element
* *after* the last component of the last tuple in the array.
* The primary advantage to using this macro is that arrays with non-standard
* memory layouts will be safely handled, and dangerous calls to GetVoidPointer
* are avoided.
* For arrays with > 1 component, the iterator will proceed through all
* components of a tuple before moving on to the next tuple.
* This matches the memory layout of the standard vtkDataArray subclasses such
* as vtkFloatArray.
*
* For the standard vtkDataArray implementations (which are subclasses of
* vtkAOSDataArrayTemplate), the iterators will simply be pointers to the raw
* memory of the array.
* This allows very fast iteration when possible, and permits compiler
* optimizations in the standard template library to occur (such as reducing
* std::copy to memmove).
*
* For arrays that are subclasses of vtkTypedDataArray, a
* vtkTypedDataArrayIterator is used.
* Such iterators safely traverse the array using API calls and have
* pointer-like semantics, but add about a 35% performance overhead compared
* with iterating over the raw memory (measured by summing a vtkFloatArray
* containing 10M values on GCC 4.8.1 with -O3 optimization using both iterator
* types -- see TestDataArrayIterators).
*
* For arrays that are not subclasses of vtkTypedDataArray, there is no reliably
* safe way to iterate over the array elements.
* In such cases, this macro performs the legacy behavior of casting
* vtkAbstractArray::GetVoidPointer(...) to vtkDAValueType* to create the
* iterators.
*
* To use this macro, create a templated worker function:
*
* template <class Iterator>
* void myFunc(Iterator begin, Iterator end, ...) {...}
*
* and then call the vtkDataArrayIteratorMacro inside of a switch statement
* using the above objects and typedefs as needed:
*
* vtkAbstractArray *someArray = ...;
* switch (someArray->GetDataType())
* {
* vtkDataArrayIteratorMacro(someArray, myFunc(vtkDABegin, vtkDAEnd, ...));
* }
*
* @sa
* vtkArrayDispatch vtkGenericDataArray
* vtkTemplateMacro vtkTypedDataArrayIterator
*/
#ifndef vtkDataArrayIteratorMacro_h
#define vtkDataArrayIteratorMacro_h
#include "vtkAOSDataArrayTemplate.h" // For classes referred to in the macro
#include "vtkSetGet.h" // For vtkTemplateMacro
#include "vtkTypedDataArray.h" // For classes referred to in the macro
// Silence 'unused typedef' warnings on GCC.
// use of the typedef in question depends on the macro
// argument _call and thus should not be removed.
#if defined(__GNUC__)
#define _vtkDAIMUnused __attribute__ ((unused))
#else
#define _vtkDAIMUnused
#endif
#define vtkDataArrayIteratorMacro(_array, _call) \
vtkTemplateMacro( \
vtkAbstractArray *_aa(_array); \
if (vtkAOSDataArrayTemplate<VTK_TT> *_dat = \
vtkAOSDataArrayTemplate<VTK_TT>::FastDownCast(_aa)) \
{ \
typedef VTK_TT vtkDAValueType; \
typedef vtkAOSDataArrayTemplate<vtkDAValueType> vtkDAContainerType; \
typedef vtkDAContainerType::Iterator vtkDAIteratorType; \
vtkDAIteratorType vtkDABegin(_dat->Begin()); \
vtkDAIteratorType vtkDAEnd(_dat->End()); \
(void)vtkDABegin; /* Prevent warnings when unused */ \
(void)vtkDAEnd; \
_call; \
} \
else if (vtkTypedDataArray<VTK_TT> *_tda = \
vtkTypedDataArray<VTK_TT>::FastDownCast(_aa)) \
{ \
typedef VTK_TT vtkDAValueType; \
typedef vtkTypedDataArray<vtkDAValueType> vtkDAContainerType; \
typedef vtkDAContainerType::Iterator vtkDAIteratorType; \
vtkDAIteratorType vtkDABegin(_tda->Begin()); \
vtkDAIteratorType vtkDAEnd(_tda->End()); \
(void)vtkDABegin; \
(void)vtkDAEnd; \
_call; \
} \
else \
{ \
/* This is not ideal, as no explicit iterator has been declared. \
* Cast the void pointer and hope for the best! */ \
typedef VTK_TT vtkDAValueType; \
typedef vtkAbstractArray vtkDAContainerType _vtkDAIMUnused; \
typedef vtkDAValueType* vtkDAIteratorType; \
vtkDAIteratorType vtkDABegin = \
static_cast<vtkDAIteratorType>(_aa->GetVoidPointer(0)); \
vtkDAIteratorType vtkDAEnd = vtkDABegin + _aa->GetMaxId() + 1; \
(void)vtkDABegin; \
(void)vtkDAEnd; \
_call; \
} \
)
#endif //vtkDataArrayIteratorMacro_h
// VTK-HeaderTest-Exclude: vtkDataArrayIteratorMacro.h
|
