Shuenhoy/vtk-m
1
0
Fork 0
mirror of https://gitlab.kitware.com/vtk/vtk-m synced 2024-09-16 17:22:55 +00:00
Code Issues 2 Actions Packages Projects Releases Wiki Activity

Shorten storage tags for ArrayHandleConcatenate

Browse Source
This commit is contained in:
Kenneth Moreland 2019-12-19 18:01:10 -07:00
parent 2688fc7d50
commit b2f07511fb
2 changed files with 106 additions and 23 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

39
docs/changelog/shorter-fancy-array-handle-classnames.md
View File

@ -12,6 +12,8 @@ The fix was for these classes to declare their own `Storage` tag and then
implement their `Storage` and `ArrayTransport` classes as trivial
subclasses of the generic `ArrayHandleImplicit` or `ArrayHandleTransport`.
As an added bonus, a lot of this shortening also means that storage that relies on other array handles now are just typed by to storage of the decorated type, not the array itself. This should make the types a little more robust.
Here is a list of classes that were updated.
#### `ArrayHandleCast<TargetT, vtkm::cont::ArrayHandle<SourceT, SourceStorage>>`
@ -31,7 +33,7 @@ vtkm::cont::StorageTagCast<SourceT, SourceStorage>
(Developer's note: Implementing this change to `ArrayHandleCast` was a much bigger PITA than expected.)
#### `ArrayHandleCartesianProduct<AH1, AH2, AH3>
#### `ArrayHandleCartesianProduct<AH1, AH2, AH3>`
Old storage:
``` cpp
@ -64,7 +66,40 @@ New storage:
vtkm::cont::StorageTagCompositeVec<StorageType1, StorageType2>
```
#### `ArrayHandleUniformPointCoordinates
#### `ArrayHandleConcatinate`
First an example with two simple types.
Old storage:
``` cpp
vtkm::cont::StorageTagConcatenate<
vtkm::cont::ArrayHandle<ValueType, StorageTag1>,
vtkm::cont::ArrayHandle<ValueType, StorageTag2> >
```
New storage:
``` cpp
vtkm::cont::StorageTagConcatenate<StorageTag1, StorageTag2>
```
Now a more specific example taken from the unit test of a concatination of a concatination.
Old storage:
``` cpp
vtkm::cont::StorageTagConcatenate<
vtkm::cont::ArrayHandleConcatenate<
vtkm::cont::ArrayHandle<ValueType, StorageTag1>,
vtkm::cont::ArrayHandle<ValueType, StorageTag2>>,
vtkm::cont::ArrayHandle<ValueType, StorageTag3>>
```
New storage:
``` cpp
vtkm::cont::StorageTagConcatenate<
vtkm::cont::StorageTagConcatenate<StorageTag1, StorageTag2>, StorageTag3>
```
#### `ArrayHandleUniformPointCoordinates`
Old storage:
``` cpp

90
vtkm/cont/ArrayHandleConcatenate.h
View File

@ -10,6 +10,9 @@
#ifndef vtk_m_cont_ArrayHandleConcatenate_h
#define vtk_m_cont_ArrayHandleConcatenate_h
#include <vtkm/Deprecated.h>
#include <vtkm/StaticAssert.h>
#include <vtkm/cont/ArrayHandle.h>
namespace vtkm
@ -98,7 +101,7 @@ private:
} // namespace internal
template <typename ArrayHandleType1, typename ArrayHandleType2>
template <typename StorageTag1, typename StorageTag2>
class StorageTagConcatenate
{
};
@ -106,12 +109,47 @@ class StorageTagConcatenate
namespace internal
{
template <typename ArrayHandleType1, typename ArrayHandleType2>
class Storage<typename ArrayHandleType1::ValueType,
StorageTagConcatenate<ArrayHandleType1, ArrayHandleType2>>
namespace detail
{
template <typename T, typename ArrayOrStorage, bool IsArrayType>
struct ConcatinateTypeArgImpl;
template <typename T, typename Storage>
struct ConcatinateTypeArgImpl<T, Storage, false>
{
using StorageTag = Storage;
using ArrayHandle = vtkm::cont::ArrayHandle<T, StorageTag>;
};
template <typename T, typename Array>
struct VTKM_DEPRECATED(1.6, "Use storage tags instead of array handles in StorageTagConcatenate")
ConcatinateTypeArgImpl<T, Array, true>
{
VTKM_STATIC_ASSERT_MSG((std::is_same<T, typename Array::ValueType>::value),
"Used array with wrong type in ArrayHandleConcatinate.");
using StorageTag = typename Array::StorageTag;
using ArrayHandle = vtkm::cont::ArrayHandle<T, StorageTag>;
};
template <typename T, typename ArrayOrStorage>
struct ConcatinateTypeArg
: ConcatinateTypeArgImpl<T,
ArrayOrStorage,
vtkm::cont::internal::ArrayHandleCheck<ArrayOrStorage>::type::value>
{
};
} // namespace detail
template <typename T, typename ST1, typename ST2>
class Storage<T, StorageTagConcatenate<ST1, ST2>>
{
using ArrayHandleType1 = typename detail::ConcatinateTypeArg<T, ST1>::ArrayHandle;
using ArrayHandleType2 = typename detail::ConcatinateTypeArg<T, ST2>::ArrayHandle;
public:
using ValueType = typename ArrayHandleType1::ValueType;
using ValueType = T;
using PortalType = ArrayPortalConcatenate<typename ArrayHandleType1::PortalControl,
typename ArrayHandleType2::PortalControl>;
using PortalConstType = ArrayPortalConcatenate<typename ArrayHandleType1::PortalConstControl,
@ -127,7 +165,9 @@ public:
Storage(const ArrayHandleType1& a1, const ArrayHandleType2& a2)
: array1(a1)
, array2(a2)
, valid(true){};
, valid(true)
{
}
VTKM_CONT
PortalConstType GetPortalConst() const
@ -198,16 +238,19 @@ private:
bool valid;
}; // class Storage
template <typename ArrayHandleType1, typename ArrayHandleType2, typename Device>
class ArrayTransfer<typename ArrayHandleType1::ValueType,
StorageTagConcatenate<ArrayHandleType1, ArrayHandleType2>,
Device>
template <typename T, typename ST1, typename ST2, typename Device>
class ArrayTransfer<T, StorageTagConcatenate<ST1, ST2>, Device>
{
using ArrayHandleType1 = typename detail::ConcatinateTypeArg<T, ST1>::ArrayHandle;
using ArrayHandleType2 = typename detail::ConcatinateTypeArg<T, ST2>::ArrayHandle;
using StorageTag1 = typename detail::ConcatinateTypeArg<T, ST1>::StorageTag;
using StorageTag2 = typename detail::ConcatinateTypeArg<T, ST2>::StorageTag;
public:
using ValueType = typename ArrayHandleType1::ValueType;
using ValueType = T;
private:
using StorageTag = StorageTagConcatenate<ArrayHandleType1, ArrayHandleType2>;
using StorageTag = StorageTagConcatenate<StorageTag1, StorageTag2>;
using StorageType = vtkm::cont::internal::Storage<ValueType, StorageTag>;
public:
@ -295,14 +338,16 @@ namespace cont
template <typename ArrayHandleType1, typename ArrayHandleType2>
class ArrayHandleConcatenate
: public vtkm::cont::ArrayHandle<typename ArrayHandleType1::ValueType,
StorageTagConcatenate<ArrayHandleType1, ArrayHandleType2>>
StorageTagConcatenate<typename ArrayHandleType1::StorageTag,
typename ArrayHandleType2::StorageTag>>
{
public:
VTKM_ARRAY_HANDLE_SUBCLASS(
ArrayHandleConcatenate,
(ArrayHandleConcatenate<ArrayHandleType1, ArrayHandleType2>),
(vtkm::cont::ArrayHandle<typename ArrayHandleType1::ValueType,
StorageTagConcatenate<ArrayHandleType1, ArrayHandleType2>>));
StorageTagConcatenate<typename ArrayHandleType1::StorageTag,
typename ArrayHandleType2::StorageTag>>));
protected:
using StorageType = vtkm::cont::internal::Storage<ValueType, StorageTag>;
@ -344,10 +389,12 @@ struct SerializableTypeString<vtkm::cont::ArrayHandleConcatenate<AH1, AH2>>
}
};
template <typename AH1, typename AH2>
template <typename T, typename ST1, typename ST2>
struct SerializableTypeString<
vtkm::cont::ArrayHandle<typename AH1::ValueType, vtkm::cont::StorageTagConcatenate<AH1, AH2>>>
: SerializableTypeString<vtkm::cont::ArrayHandleConcatenate<AH1, AH2>>
vtkm::cont::ArrayHandle<T, vtkm::cont::StorageTagConcatenate<ST1, ST2>>>
: SerializableTypeString<vtkm::cont::ArrayHandleConcatenate<
typename internal::detail::ConcatinateTypeArg<T, ST1>::ArrayHandle,
typename internal::detail::ConcatinateTypeArg<T, ST2>::ArrayHandle>>
{
};
}
@ -383,10 +430,11 @@ public:
}
};
template <typename AH1, typename AH2>
struct Serialization<
vtkm::cont::ArrayHandle<typename AH1::ValueType, vtkm::cont::StorageTagConcatenate<AH1, AH2>>>
: Serialization<vtkm::cont::ArrayHandleConcatenate<AH1, AH2>>
template <typename T, typename ST1, typename ST2>
struct Serialization<vtkm::cont::ArrayHandle<T, vtkm::cont::StorageTagConcatenate<ST1, ST2>>>
: Serialization<vtkm::cont::ArrayHandleConcatenate<
typename vtkm::cont::internal::detail::ConcatinateTypeArg<T, ST1>::ArrayHandle,
typename vtkm::cont::internal::detail::ConcatinateTypeArg<T, ST2>::ArrayHandle>>
{
};
} // diy