VTK-m  2.1
ArrayHandleBasic.h
Go to the documentation of this file.
1 //============================================================================
2 // Copyright (c) Kitware, Inc.
3 // All rights reserved.
4 // See LICENSE.txt for details.
5 //
6 // This software is distributed WITHOUT ANY WARRANTY; without even
7 // the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
8 // PURPOSE. See the above copyright notice for more information.
9 //============================================================================
10 #ifndef vtk_m_cont_ArrayHandleBasic_h
11 #define vtk_m_cont_ArrayHandleBasic_h
12 
13 #include <vtkm/cont/ArrayHandle.h>
14 #include <vtkm/cont/ArrayPortalToIterators.h>
15 #include <vtkm/cont/SerializableTypeString.h>
16 #include <vtkm/cont/Serialization.h>
17 #include <vtkm/cont/Storage.h>
18 
19 #include <vtkm/internal/ArrayPortalBasic.h>
20 
21 #include <vtkm/VecFlat.h>
22 
23 #include <limits>
24 
25 namespace vtkm
26 {
27 namespace cont
28 {
29 
30 namespace internal
31 {
32 
33 template <typename T>
34 class VTKM_ALWAYS_EXPORT Storage<T, vtkm::cont::StorageTagBasic>
35 {
36 public:
37  using ReadPortalType = vtkm::internal::ArrayPortalBasicRead<T>;
38  using WritePortalType = vtkm::internal::ArrayPortalBasicWrite<T>;
39 
40  VTKM_CONT static std::vector<vtkm::cont::internal::Buffer> CreateBuffers()
41  {
42  return std::vector<vtkm::cont::internal::Buffer>(1);
43  }
44 
45  VTKM_CONT static void ResizeBuffers(vtkm::Id numValues,
46  const std::vector<vtkm::cont::internal::Buffer>& buffers,
47  vtkm::CopyFlag preserve,
48  vtkm::cont::Token& token)
49  {
50  buffers[0].SetNumberOfBytes(
51  vtkm::internal::NumberOfValuesToNumberOfBytes<T>(numValues), preserve, token);
52  }
53 
54  VTKM_CONT static vtkm::IdComponent GetNumberOfComponentsFlat(
55  const std::vector<vtkm::cont::internal::Buffer>&)
56  {
57  return vtkm::VecFlat<T>::NUM_COMPONENTS;
58  }
59 
60  VTKM_CONT static vtkm::Id GetNumberOfValues(
61  const std::vector<vtkm::cont::internal::Buffer>& buffers)
62  {
63  VTKM_ASSERT(buffers.size() == 1);
64  return static_cast<vtkm::Id>(buffers[0].GetNumberOfBytes() /
65  static_cast<vtkm::BufferSizeType>(sizeof(T)));
66  }
67 
68  VTKM_CONT static void Fill(const std::vector<vtkm::cont::internal::Buffer>& buffers,
69  const T& fillValue,
70  vtkm::Id startIndex,
71  vtkm::Id endIndex,
72  vtkm::cont::Token& token)
73  {
74  VTKM_ASSERT(buffers.size() == 1);
75  constexpr vtkm::BufferSizeType fillValueSize =
76  static_cast<vtkm::BufferSizeType>(sizeof(fillValue));
77  buffers[0].Fill(
78  &fillValue, fillValueSize, startIndex * fillValueSize, endIndex * fillValueSize, token);
79  }
80 
81  VTKM_CONT static ReadPortalType CreateReadPortal(
82  const std::vector<vtkm::cont::internal::Buffer>& buffers,
83  vtkm::cont::DeviceAdapterId device,
84  vtkm::cont::Token& token)
85  {
86  VTKM_ASSERT(buffers.size() == 1);
87  return ReadPortalType(reinterpret_cast<const T*>(buffers[0].ReadPointerDevice(device, token)),
88  GetNumberOfValues(buffers));
89  }
90 
91  VTKM_CONT static WritePortalType CreateWritePortal(
92  const std::vector<vtkm::cont::internal::Buffer>& buffers,
93  vtkm::cont::DeviceAdapterId device,
94  vtkm::cont::Token& token)
95  {
96  VTKM_ASSERT(buffers.size() == 1);
97  return WritePortalType(reinterpret_cast<T*>(buffers[0].WritePointerDevice(device, token)),
98  GetNumberOfValues(buffers));
99  }
100 };
101 
102 } // namespace internal
103 
104 template <typename T>
105 class VTKM_ALWAYS_EXPORT ArrayHandleBasic : public ArrayHandle<T, vtkm::cont::StorageTagBasic>
106 {
107 public:
108  VTKM_ARRAY_HANDLE_SUBCLASS(ArrayHandleBasic,
109  (ArrayHandleBasic<T>),
110  (ArrayHandle<T, vtkm::cont::StorageTagBasic>));
111 
112  ArrayHandleBasic(
113  T* array,
114  vtkm::Id numberOfValues,
115  vtkm::cont::internal::BufferInfo::Deleter deleter,
116  vtkm::cont::internal::BufferInfo::Reallocater reallocater = internal::InvalidRealloc)
117  : Superclass(std::vector<vtkm::cont::internal::Buffer>{ vtkm::cont::internal::MakeBuffer(
118  vtkm::cont::DeviceAdapterTagUndefined{},
119  array,
120  array,
121  vtkm::internal::NumberOfValuesToNumberOfBytes<T>(numberOfValues),
122  deleter,
123  reallocater) })
124  {
125  }
126 
127  ArrayHandleBasic(
128  T* array,
129  vtkm::Id numberOfValues,
130  vtkm::cont::DeviceAdapterId device,
131  vtkm::cont::internal::BufferInfo::Deleter deleter,
132  vtkm::cont::internal::BufferInfo::Reallocater reallocater = internal::InvalidRealloc)
133  : Superclass(std::vector<vtkm::cont::internal::Buffer>{ vtkm::cont::internal::MakeBuffer(
134  device,
135  array,
136  array,
137  vtkm::internal::NumberOfValuesToNumberOfBytes<T>(numberOfValues),
138  deleter,
139  reallocater) })
140  {
141  }
142 
143  ArrayHandleBasic(
144  T* array,
145  void* container,
146  vtkm::Id numberOfValues,
147  vtkm::cont::internal::BufferInfo::Deleter deleter,
148  vtkm::cont::internal::BufferInfo::Reallocater reallocater = internal::InvalidRealloc)
149  : Superclass(std::vector<vtkm::cont::internal::Buffer>{ vtkm::cont::internal::MakeBuffer(
150  vtkm::cont::DeviceAdapterTagUndefined{},
151  array,
152  container,
153  vtkm::internal::NumberOfValuesToNumberOfBytes<T>(numberOfValues),
154  deleter,
155  reallocater) })
156  {
157  }
158 
159  ArrayHandleBasic(
160  T* array,
161  void* container,
162  vtkm::Id numberOfValues,
163  vtkm::cont::DeviceAdapterId device,
164  vtkm::cont::internal::BufferInfo::Deleter deleter,
165  vtkm::cont::internal::BufferInfo::Reallocater reallocater = internal::InvalidRealloc)
166  : Superclass(std::vector<vtkm::cont::internal::Buffer>{ vtkm::cont::internal::MakeBuffer(
167  device,
168  array,
169  container,
170  vtkm::internal::NumberOfValuesToNumberOfBytes<T>(numberOfValues),
171  deleter,
172  reallocater) })
173  {
174  }
175 
182  const T* GetReadPointer(vtkm::cont::Token& token) const
183  {
184  return reinterpret_cast<const T*>(this->GetBuffers()[0].ReadPointerHost(token));
185  }
186  const T* GetReadPointer() const
187  {
188  vtkm::cont::Token token;
189  return this->GetReadPointer(token);
190  }
191  T* GetWritePointer(vtkm::cont::Token& token) const
192  {
193  return reinterpret_cast<T*>(this->GetBuffers()[0].WritePointerHost(token));
194  }
195  T* GetWritePointer() const
196  {
197  vtkm::cont::Token token;
198  return this->GetWritePointer(token);
199  }
200 
201  const T* GetReadPointer(vtkm::cont::DeviceAdapterId device, vtkm::cont::Token& token) const
202  {
203  return reinterpret_cast<const T*>(this->GetBuffers()[0].ReadPointerDevice(device, token));
204  }
205  const T* GetReadPointer(vtkm::cont::DeviceAdapterId device) const
206  {
207  vtkm::cont::Token token;
208  return this->GetReadPointer(device, token);
209  }
210  T* GetWritePointer(vtkm::cont::DeviceAdapterId device, vtkm::cont::Token& token) const
211  {
212  return reinterpret_cast<T*>(this->GetBuffers()[0].WritePointerDevice(device, token));
213  }
214  T* GetWritePointer(vtkm::cont::DeviceAdapterId device) const
215  {
216  vtkm::cont::Token token;
217  return this->GetWritePointer(device, token);
218  }
220 };
221 
224 template <typename T>
225 VTKM_CONT vtkm::cont::ArrayHandleBasic<T> make_ArrayHandle(const T* array,
226  vtkm::Id numberOfValues,
227  vtkm::CopyFlag copy)
228 {
229  if (copy == vtkm::CopyFlag::On)
230  {
231  vtkm::cont::ArrayHandleBasic<T> handle;
232  handle.Allocate(numberOfValues);
233  std::copy(
234  array, array + numberOfValues, vtkm::cont::ArrayPortalToIteratorBegin(handle.WritePortal()));
235  return handle;
236  }
237  else
238  {
239  return vtkm::cont::ArrayHandleBasic<T>(const_cast<T*>(array), numberOfValues, [](void*) {});
240  }
241 }
242 
248 template <typename T>
249 VTKM_CONT vtkm::cont::ArrayHandleBasic<T> make_ArrayHandleMove(
250  T*& array,
251  vtkm::Id numberOfValues,
252  vtkm::cont::internal::BufferInfo::Deleter deleter = internal::SimpleArrayDeleter<T>,
253  vtkm::cont::internal::BufferInfo::Reallocater reallocater = internal::SimpleArrayReallocater<T>)
254 {
255  vtkm::cont::ArrayHandleBasic<T> arrayHandle(array, numberOfValues, deleter, reallocater);
256  array = nullptr;
257  return arrayHandle;
258 }
259 
262 template <typename T, typename Allocator>
263 VTKM_CONT vtkm::cont::ArrayHandleBasic<T> make_ArrayHandle(const std::vector<T, Allocator>& array,
264  vtkm::CopyFlag copy)
265 {
266  if (!array.empty())
267  {
268  return make_ArrayHandle(array.data(), static_cast<vtkm::Id>(array.size()), copy);
269  }
270  else
271  {
272  // Vector empty. Just return an empty array handle.
273  return vtkm::cont::ArrayHandle<T, vtkm::cont::StorageTagBasic>();
274  }
275 }
276 
279 template <typename T, typename Allocator>
280 VTKM_CONT vtkm::cont::ArrayHandleBasic<T> make_ArrayHandleMove(std::vector<T, Allocator>&& array)
281 {
282  using vector_type = std::vector<T, Allocator>;
283  vector_type* container = new vector_type(std::move(array));
284  return vtkm::cont::ArrayHandleBasic<T>(container->data(),
285  container,
286  static_cast<vtkm::Id>(container->size()),
287  internal::StdVectorDeleter<T, Allocator>,
288  internal::StdVectorReallocater<T, Allocator>);
289 }
290 
293 template <typename T, typename Allocator>
294 VTKM_CONT vtkm::cont::ArrayHandleBasic<T> make_ArrayHandle(std::vector<T, Allocator>&& array,
295  vtkm::CopyFlag vtkmNotUsed(copy))
296 {
297  return make_ArrayHandleMove(array);
298 }
299 
302 template <typename T>
303 VTKM_CONT vtkm::cont::ArrayHandleBasic<T> make_ArrayHandle(std::initializer_list<T>&& values)
304 {
305  return make_ArrayHandle(values.begin(), static_cast<vtkm::Id>(values.size()), vtkm::CopyFlag::On);
306 }
307 }
308 } // namespace vtkm::cont
309 
310 //=============================================================================
311 // Specializations of serialization related classes
313 namespace vtkm
314 {
315 namespace cont
316 {
317 
318 template <typename T>
319 struct SerializableTypeString<vtkm::cont::ArrayHandleBasic<T>>
320 {
321  static VTKM_CONT const std::string& Get()
322  {
323  static std::string name = "AH<" + SerializableTypeString<T>::Get() + ">";
324  return name;
325  }
326 };
327 
328 template <typename T>
329 struct SerializableTypeString<ArrayHandle<T, vtkm::cont::StorageTagBasic>>
330  : SerializableTypeString<vtkm::cont::ArrayHandleBasic<T>>
331 {
332 };
333 }
334 } // vtkm::cont
335 
336 namespace mangled_diy_namespace
337 {
338 
339 template <typename T>
340 struct Serialization<vtkm::cont::ArrayHandleBasic<T>>
341 {
342  static VTKM_CONT void save(BinaryBuffer& bb,
343  const vtkm::cont::ArrayHandle<T, vtkm::cont::StorageTagBasic>& obj)
344  {
345  vtkmdiy::save(bb, obj.GetBuffers()[0]);
346  }
347 
348  static VTKM_CONT void load(BinaryBuffer& bb,
349  vtkm::cont::ArrayHandle<T, vtkm::cont::StorageTagBasic>& obj)
350  {
351  vtkm::cont::internal::Buffer buffer;
352  vtkmdiy::load(bb, buffer);
353 
354  obj = vtkm::cont::ArrayHandle<T, vtkm::cont::StorageTagBasic>(
355  vtkm::cont::internal::CreateBuffers(buffer));
356  }
357 };
358 
359 template <typename T>
360 struct Serialization<vtkm::cont::ArrayHandle<T, vtkm::cont::StorageTagBasic>>
361  : Serialization<vtkm::cont::ArrayHandleBasic<T>>
362 {
363 };
364 
365 } // diy
367 
368 #ifndef vtk_m_cont_ArrayHandleBasic_cxx
369 
372 
373 namespace vtkm
374 {
375 namespace cont
376 {
377 
378 namespace internal
379 {
380 
381 #define VTKM_STORAGE_EXPORT(Type) \
382  extern template class VTKM_CONT_TEMPLATE_EXPORT Storage<Type, StorageTagBasic>; \
383  extern template class VTKM_CONT_TEMPLATE_EXPORT Storage<vtkm::Vec<Type, 2>, StorageTagBasic>; \
384  extern template class VTKM_CONT_TEMPLATE_EXPORT Storage<vtkm::Vec<Type, 3>, StorageTagBasic>; \
385  extern template class VTKM_CONT_TEMPLATE_EXPORT Storage<vtkm::Vec<Type, 4>, StorageTagBasic>;
386 
387 VTKM_STORAGE_EXPORT(char)
388 VTKM_STORAGE_EXPORT(vtkm::Int8)
389 VTKM_STORAGE_EXPORT(vtkm::UInt8)
390 VTKM_STORAGE_EXPORT(vtkm::Int16)
391 VTKM_STORAGE_EXPORT(vtkm::UInt16)
392 VTKM_STORAGE_EXPORT(vtkm::Int32)
393 VTKM_STORAGE_EXPORT(vtkm::UInt32)
394 VTKM_STORAGE_EXPORT(vtkm::Int64)
395 VTKM_STORAGE_EXPORT(vtkm::UInt64)
396 VTKM_STORAGE_EXPORT(vtkm::Float32)
397 VTKM_STORAGE_EXPORT(vtkm::Float64)
398 
399 #undef VTKM_STORAGE_EXPORT
400 
401 } // namespace internal
402 
403 #define VTKM_ARRAYHANDLE_EXPORT(Type) \
404  extern template class VTKM_CONT_TEMPLATE_EXPORT ArrayHandle<Type, StorageTagBasic>; \
405  extern template class VTKM_CONT_TEMPLATE_EXPORT \
406  ArrayHandle<vtkm::Vec<Type, 2>, StorageTagBasic>; \
407  extern template class VTKM_CONT_TEMPLATE_EXPORT \
408  ArrayHandle<vtkm::Vec<Type, 3>, StorageTagBasic>; \
409  extern template class VTKM_CONT_TEMPLATE_EXPORT ArrayHandle<vtkm::Vec<Type, 4>, StorageTagBasic>;
410 
411 VTKM_ARRAYHANDLE_EXPORT(char)
412 VTKM_ARRAYHANDLE_EXPORT(vtkm::Int8)
413 VTKM_ARRAYHANDLE_EXPORT(vtkm::UInt8)
414 VTKM_ARRAYHANDLE_EXPORT(vtkm::Int16)
415 VTKM_ARRAYHANDLE_EXPORT(vtkm::UInt16)
416 VTKM_ARRAYHANDLE_EXPORT(vtkm::Int32)
417 VTKM_ARRAYHANDLE_EXPORT(vtkm::UInt32)
418 VTKM_ARRAYHANDLE_EXPORT(vtkm::Int64)
419 VTKM_ARRAYHANDLE_EXPORT(vtkm::UInt64)
420 VTKM_ARRAYHANDLE_EXPORT(vtkm::Float32)
421 VTKM_ARRAYHANDLE_EXPORT(vtkm::Float64)
422 
423 #undef VTKM_ARRAYHANDLE_EXPORT
424 }
425 } // end vtkm::cont
426 
428 
429 #endif // !vtk_m_cont_ArrayHandleBasic_cxx
430 
431 #endif //vtk_m_cont_ArrayHandleBasic_h
VecFlat.h
vtkm::cont::ArrayHandleBasic::Superclass
typename vtkm::cont::detail::GetTypeInParentheses< void(ArrayHandle< T, vtkm::cont::StorageTagBasic >) >::type Superclass
Definition: ArrayHandleBasic.h:110
vtkm::cont::ArrayHandle
Manages an array-worth of data.
Definition: ArrayHandle.h:300
ArrayHandle.h
vtkm::cont::ArrayHandleBasic::GetReadPointer
const T * GetReadPointer() const
Gets raw access to the ArrayHandle's data.
Definition: ArrayHandleBasic.h:186
vtkm::cont::ArrayHandle::GetBuffers
const std::vector< vtkm::cont::internal::Buffer > & GetBuffers() const
Returns the internal Buffer structures that hold the data.
Definition: ArrayHandle.h:719
vtkm::exec::arg::load
T load(const U &u, vtkm::Id v)
Definition: FetchTagArrayDirectIn.h:36
vtkm
Groups connected points that have the same field value.
Definition: Atomic.h:19
vtkm::Get
auto Get(const vtkm::Tuple< Ts... > &tuple)
Retrieve the object from a vtkm::Tuple at the given index.
Definition: Tuple.h:81
VTKM_ARRAY_HANDLE_SUBCLASS
#define VTKM_ARRAY_HANDLE_SUBCLASS(classname, fullclasstype, superclass)
Macro to make default methods in ArrayHandle subclasses.
Definition: ArrayHandle.h:243
VTKM_ASSERT
#define VTKM_ASSERT(condition)
Definition: Assert.h:43
vtkm::IdComponent
vtkm::Int32 IdComponent
Base type to use to index small lists.
Definition: Types.h:194
ArrayPortalToIterators.h
vtkm::cont::ArrayHandleBasic::GetWritePointer
T * GetWritePointer(vtkm::cont::DeviceAdapterId device) const
Gets raw access to the ArrayHandle's data.
Definition: ArrayHandleBasic.h:214
vtkm::cont::ArrayHandleBasic::GetReadPointer
const T * GetReadPointer(vtkm::cont::DeviceAdapterId device) const
Gets raw access to the ArrayHandle's data.
Definition: ArrayHandleBasic.h:205
Storage.h
vtkm::Int16
int16_t Int16
Base type to use for 16-bit signed integer numbers.
Definition: Types.h:173
vtkm::cont::ArrayHandleBasic::ArrayHandleBasic
ArrayHandleBasic(T *array, void *container, vtkm::Id numberOfValues, vtkm::cont::DeviceAdapterId device, vtkm::cont::internal::BufferInfo::Deleter deleter, vtkm::cont::internal::BufferInfo::Reallocater reallocater=internal::InvalidRealloc)
Definition: ArrayHandleBasic.h:159
vtkm::cont::ArrayHandleBasic::GetReadPointer
const T * GetReadPointer(vtkm::cont::Token &token) const
Gets raw access to the ArrayHandle's data.
Definition: ArrayHandleBasic.h:182
vtkm::cont::make_ArrayHandleMove
vtkm::cont::ArrayHandleBasic< T > make_ArrayHandleMove(T *&array, vtkm::Id numberOfValues, vtkm::cont::internal::BufferInfo::Deleter deleter=internal::SimpleArrayDeleter< T >, vtkm::cont::internal::BufferInfo::Reallocater reallocater=internal::SimpleArrayReallocater< T >)
A convenience function to move a user-allocated array into an ArrayHandle.
Definition: ArrayHandleBasic.h:249
SerializableTypeString.h
vtkm::BufferSizeType
vtkm::Int64 BufferSizeType
Definition: DeviceAdapterMemoryManager.h:27
vtkm::cont::ArrayHandleBasic::GetWritePointer
T * GetWritePointer(vtkm::cont::Token &token) const
Gets raw access to the ArrayHandle's data.
Definition: ArrayHandleBasic.h:191
mangled_diy_namespace
Definition: Particle.h:351
vtkm::cont::ArrayHandleBasic::ArrayHandleBasic
ArrayHandleBasic(T *array, vtkm::Id numberOfValues, vtkm::cont::DeviceAdapterId device, vtkm::cont::internal::BufferInfo::Deleter deleter, vtkm::cont::internal::BufferInfo::Reallocater reallocater=internal::InvalidRealloc)
Definition: ArrayHandleBasic.h:127
vtkm::cont::Token
A token to hold the scope of an ArrayHandle or other object.
Definition: Token.h:35
ArrayPortalBasic.h
vtkm::cont::ArrayHandleBasic::ArrayHandleBasic
ArrayHandleBasic(T *array, void *container, vtkm::Id numberOfValues, vtkm::cont::internal::BufferInfo::Deleter deleter, vtkm::cont::internal::BufferInfo::Reallocater reallocater=internal::InvalidRealloc)
Definition: ArrayHandleBasic.h:143
vtkm::cont::ArrayHandleBasic::GetReadPointer
const T * GetReadPointer(vtkm::cont::DeviceAdapterId device, vtkm::cont::Token &token) const
Gets raw access to the ArrayHandle's data.
Definition: ArrayHandleBasic.h:201
vtkm::Int8
int8_t Int8
Base type to use for 8-bit signed integer numbers.
Definition: Types.h:165
vtkm::cont::ArrayHandleBasic::GetWritePointer
T * GetWritePointer(vtkm::cont::DeviceAdapterId device, vtkm::cont::Token &token) const
Gets raw access to the ArrayHandle's data.
Definition: ArrayHandleBasic.h:210
Serialization.h
VTKM_CONT
#define VTKM_CONT
Definition: ExportMacros.h:57
vtkm::Id
vtkm::Int64 Id
Base type to use to index arrays.
Definition: Types.h:227
vtkm::Int64
signed long long Int64
Base type to use for 64-bit signed integer numbers.
Definition: Types.h:204
vtkm::VecFlat
Treat a Vec or Vec-like object as a flat Vec.
Definition: VecFlat.h:224
vtkm::UInt8
uint8_t UInt8
Base type to use for 8-bit unsigned integer numbers.
Definition: Types.h:169
vtkm::CopyFlag::On
@ On
vtkmNotUsed
#define vtkmNotUsed(parameter_name)
Simple macro to identify a parameter as unused.
Definition: ExportMacros.h:128
vtkm::cont::ArrayHandleBasic::ArrayHandleBasic
ArrayHandleBasic(T *array, vtkm::Id numberOfValues, vtkm::cont::internal::BufferInfo::Deleter deleter, vtkm::cont::internal::BufferInfo::Reallocater reallocater=internal::InvalidRealloc)
Definition: ArrayHandleBasic.h:112
vtkm::cont::DeviceAdapterId
An object used to specify a device.
Definition: DeviceAdapterTag.h:58
vtkm::cont::ArrayHandleBasic::GetWritePointer
T * GetWritePointer() const
Gets raw access to the ArrayHandle's data.
Definition: ArrayHandleBasic.h:195
vtkm::UInt32
uint32_t UInt32
Base type to use for 32-bit unsigned integer numbers.
Definition: Types.h:185
vtkm::cont::DeviceAdapterTagUndefined
Tag for a device adapter used to avoid specifying a device.
Definition: DeviceAdapterTag.h:187
vtkm::Float32
float Float32
Base type to use for 32-bit floating-point numbers.
Definition: Types.h:157
vtkm::UInt64
unsigned long long UInt64
Base type to use for 64-bit signed integer numbers.
Definition: Types.h:207
vtkm::cont::ArrayPortalToIteratorBegin
vtkm::cont::ArrayPortalToIterators< PortalType >::IteratorType ArrayPortalToIteratorBegin(const PortalType &portal)
Convenience function for converting an ArrayPortal to a begin iterator.
Definition: ArrayPortalToIterators.h:178
vtkm::Int32
int32_t Int32
Base type to use for 32-bit signed integer numbers.
Definition: Types.h:181
vtkm::Float64
double Float64
Base type to use for 64-bit floating-point numbers.
Definition: Types.h:161
vtkm::CopyFlag
CopyFlag
Identifier used to specify whether a function should deep copy data.
Definition: Flags.h:17
vtkm::cont::ArrayHandle< T, vtkm::cont::StorageTagBasic >::Allocate
void Allocate(vtkm::Id numberOfValues, vtkm::CopyFlag preserve, vtkm::cont::Token &token) const
Allocates an array large enough to hold the given number of values.
Definition: ArrayHandle.h:488
vtkm::cont::ArrayHandleBasic
Definition: ArrayHandleBasic.h:105
VTKM_ALWAYS_EXPORT
#define VTKM_ALWAYS_EXPORT
Definition: ExportMacros.h:89
vtkm::cont::make_ArrayHandle
vtkm::cont::ArrayHandleBasic< T > make_ArrayHandle(const T *array, vtkm::Id numberOfValues, vtkm::CopyFlag copy)
A convenience function for creating an ArrayHandle from a standard C array.
Definition: ArrayHandleBasic.h:225
vtkm::UInt16
uint16_t UInt16
Base type to use for 16-bit unsigned integer numbers.
Definition: Types.h:177
vtkm::cont::ArrayHandle< T, vtkm::cont::StorageTagBasic >::WritePortal
WritePortalType WritePortal() const
Get an array portal that can be used in the control environment.
Definition: ArrayHandle.h:452
Generated by   doxygen 1.8.17