/usr/include/vtk-6.3/vtkDataArrayIteratorMacro.h is in libvtk6-dev 6.3.0+dfsg1-5.
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 | /*=========================================================================
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.
=========================================================================*/
// .NAME vtkDataArrayIteratorMacro - A macro for obtaining iterators to
// vtkDataArray data when the array implementation and type are unknown.
//
// .SECTION Description
// 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
// vtkDataArrayTemplate), 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 (but not
// vtkDataArrayTemplate), 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, ...));
// }
//
// .SECTION See Also
// vtkTemplateMacro vtkTypedDataArrayIterator
#ifndef vtkDataArrayIteratorMacro_h
#define vtkDataArrayIteratorMacro_h
#include "vtkDataArrayTemplate.h" // For all classes referred to in the macro
#include "vtkSetGet.h" // For vtkTemplateMacro
// 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 (vtkDataArrayTemplate<VTK_TT> *_dat = \
vtkDataArrayTemplate<VTK_TT>::FastDownCast(_aa)) \
{ \
typedef VTK_TT vtkDAValueType; \
typedef vtkDataArrayTemplate<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
|