UnknownArrayHandle.h

Go to the documentation of this file.

//============================================================================
//  Copyright (c) Kitware, Inc.
//  All rights reserved.
//  See LICENSE.txt 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.
//============================================================================
#ifndef vtk_m_cont_UnknownArrayHandle_h
#define vtk_m_cont_UnknownArrayHandle_h
 
#include <vtkm/cont/vtkm_cont_export.h>
 
#include <vtkm/cont/ArrayExtractComponent.h>
#include <vtkm/cont/ArrayHandle.h>
#include <vtkm/cont/ArrayHandleCast.h>
#include <vtkm/cont/ArrayHandleMultiplexer.h>
#include <vtkm/cont/ArrayHandleRecombineVec.h>
#include <vtkm/cont/ArrayHandleRuntimeVec.h>
#include <vtkm/cont/ArrayHandleStride.h>
#include <vtkm/cont/StorageList.h>
 
#include <vtkm/Deprecated.h>
#include <vtkm/TypeList.h>
#include <vtkm/VecTraits.h>
 
#include <memory>
#include <typeindex>
 
namespace vtkm
{
namespace cont
{
 
namespace detail
{
 
template <typename T, typename S>
void UnknownAHDelete(void* mem)
{
  using AH = vtkm::cont::ArrayHandle<T, S>;
  AH* arrayHandle = reinterpret_cast<AH*>(mem);
  delete arrayHandle;
}
 
template <typename T, typename S>
const std::vector<vtkm::cont::internal::Buffer>& UnknownAHBuffers(void* mem)
{
  using AH = vtkm::cont::ArrayHandle<T, S>;
  AH* arrayHandle = reinterpret_cast<AH*>(mem);
  return arrayHandle->GetBuffers();
}
 
template <typename T, typename S>
void* UnknownAHNewInstance()
{
  return new vtkm::cont::ArrayHandle<T, S>;
}
 
template <typename T, typename S>
vtkm::Id UnknownAHNumberOfValues(void* mem)
{
  using AH = vtkm::cont::ArrayHandle<T, S>;
  AH* arrayHandle = reinterpret_cast<AH*>(mem);
  return arrayHandle->GetNumberOfValues();
}
 
template <typename T, typename S>
vtkm::IdComponent UnknownAHNumberOfComponentsFlat(void* mem)
{
  using AH = vtkm::cont::ArrayHandle<T, S>;
  AH* arrayHandle = reinterpret_cast<AH*>(mem);
  return arrayHandle->GetNumberOfComponentsFlat();
}
 
// Uses SFINAE to use Storage<>::GetNumberOfComponents if it exists, or the VecTraits otherwise
template <typename T, typename S>
inline auto UnknownAHNumberOfComponentsImpl(void* mem)
  -> decltype(vtkm::cont::internal::Storage<T, S>::GetNumberOfComponents(
    std::vector<vtkm::cont::internal::Buffer>()))
{
  using AH = vtkm::cont::ArrayHandle<T, S>;
  AH* arrayHandle = reinterpret_cast<AH*>(mem);
  return vtkm::cont::internal::Storage<T, S>::GetNumberOfComponents(arrayHandle->GetBuffers());
}
 
// Uses static vec size.
template <typename T, typename S>
inline vtkm::IdComponent UnknownAHNumberOfComponentsImpl(void*, vtkm::VecTraitsTagSizeStatic)
{
  return vtkm::VecTraits<T>::NUM_COMPONENTS;
}
 
// The size of the vecs are not defined at compile time. Assume that the components are not
// nested and use the flat components query.
template <typename T, typename S>
inline vtkm::IdComponent UnknownAHNumberOfComponentsImpl(void* mem, vtkm::VecTraitsTagSizeVariable)
{
  return UnknownAHNumberOfComponentsFlat<T, S>(mem);
}
 
template <typename T, typename S>
vtkm::IdComponent UnknownAHNumberOfComponents(void* mem)
{
  return UnknownAHNumberOfComponentsImpl<T, S>(mem, typename vtkm::VecTraits<T>::IsSizeStatic{});
}
 
template <typename T, typename S>
void UnknownAHAllocate(void* mem,
                       vtkm::Id numValues,
                       vtkm::CopyFlag preserve,
                       vtkm::cont::Token& token)
{
  using AH = vtkm::cont::ArrayHandle<T, S>;
  AH* arrayHandle = reinterpret_cast<AH*>(mem);
  arrayHandle->Allocate(numValues, preserve, token);
}
 
template <typename T, typename S>
void UnknownAHShallowCopy(const void* sourceMem, void* destinationMem)
{
  using AH = vtkm::cont::ArrayHandle<T, S>;
  const AH* source = reinterpret_cast<const AH*>(sourceMem);
  AH* destination = reinterpret_cast<AH*>(destinationMem);
  *destination = *source;
}
 
template <typename T, typename S>
void UnknownAHDeepCopy(const void* sourceMem, void* destinationMem)
{
  using AH = vtkm::cont::ArrayHandle<T, S>;
  const AH* source = reinterpret_cast<const AH*>(sourceMem);
  AH* destination = reinterpret_cast<AH*>(destinationMem);
  destination->DeepCopyFrom(*source);
}
 
template <typename T, typename S>
std::vector<vtkm::cont::internal::Buffer>
UnknownAHExtractComponent(void* mem, vtkm::IdComponent componentIndex, vtkm::CopyFlag allowCopy)
{
  using AH = vtkm::cont::ArrayHandle<T, S>;
  AH* arrayHandle = reinterpret_cast<AH*>(mem);
  auto componentArray = vtkm::cont::ArrayExtractComponent(*arrayHandle, componentIndex, allowCopy);
  return componentArray.GetBuffers();
}
 
template <typename T, typename S>
void UnknownAHReleaseResources(void* mem)
{
  using AH = vtkm::cont::ArrayHandle<T, S>;
  AH* arrayHandle = reinterpret_cast<AH*>(mem);
  arrayHandle->ReleaseResources();
}
 
template <typename T, typename S>
void UnknownAHReleaseResourcesExecution(void* mem)
{
  using AH = vtkm::cont::ArrayHandle<T, S>;
  AH* arrayHandle = reinterpret_cast<AH*>(mem);
  arrayHandle->ReleaseResourcesExecution();
}
 
template <typename T, typename S>
void UnknownAHPrintSummary(void* mem, std::ostream& out, bool full)
{
  using AH = vtkm::cont::ArrayHandle<T, S>;
  AH* arrayHandle = reinterpret_cast<AH*>(mem);
  vtkm::cont::printSummary_ArrayHandle(*arrayHandle, out, full);
}
 
struct VTKM_CONT_EXPORT UnknownAHContainer;
 
struct MakeUnknownAHContainerFunctor
{
  template <typename T, typename S>
  std::shared_ptr<UnknownAHContainer> operator()(const vtkm::cont::ArrayHandle<T, S>& array) const;
};
 
struct VTKM_CONT_EXPORT UnknownAHComponentInfo
{
  std::type_index Type;
  bool IsIntegral;
  bool IsFloat;
  bool IsSigned;
  std::size_t Size;
 
  UnknownAHComponentInfo() = delete;
 
  bool operator==(const UnknownAHComponentInfo& rhs);
 
  template <typename T>
  static UnknownAHComponentInfo Make()
  {
    return UnknownAHComponentInfo{ typeid(T),
                                   std::is_integral<T>::value,
                                   std::is_floating_point<T>::value,
                                   std::is_signed<T>::value,
                                   sizeof(T) };
  }
 
private:
  UnknownAHComponentInfo(std::type_index&& type,
                         bool isIntegral,
                         bool isFloat,
                         bool isSigned,
                         std::size_t size)
    : Type(std::move(type))
    , IsIntegral(isIntegral)
    , IsFloat(isFloat)
    , IsSigned(isSigned)
    , Size(size)
  {
  }
};
 
struct VTKM_CONT_EXPORT UnknownAHContainer
{
  void* ArrayHandlePointer;
 
  std::type_index ValueType;
  std::type_index StorageType;
  UnknownAHComponentInfo BaseComponentType;
 
  using DeleteType = void(void*);
  DeleteType* DeleteFunction;
 
  using BuffersType = const std::vector<vtkm::cont::internal::Buffer>&(void*);
  BuffersType* Buffers;
 
  using NewInstanceType = void*();
  NewInstanceType* NewInstance;
 
  using NewInstanceBasicType = std::shared_ptr<UnknownAHContainer>(void*);
  NewInstanceBasicType* NewInstanceBasic;
  NewInstanceBasicType* NewInstanceFloatBasic;
 
  using NumberOfValuesType = vtkm::Id(void*);
  NumberOfValuesType* NumberOfValues;
 
  using NumberOfComponentsType = vtkm::IdComponent(void*);
  NumberOfComponentsType* NumberOfComponents;
  NumberOfComponentsType* NumberOfComponentsFlat;
 
  using AllocateType = void(void*, vtkm::Id, vtkm::CopyFlag, vtkm::cont::Token&);
  AllocateType* Allocate;
 
  using ShallowCopyType = void(const void*, void*);
  ShallowCopyType* ShallowCopy;
 
  using DeepCopyType = void(const void*, void*);
  DeepCopyType* DeepCopy;
 
  using ExtractComponentType = std::vector<vtkm::cont::internal::Buffer>(void*,
                                                                         vtkm::IdComponent,
                                                                         vtkm::CopyFlag);
  ExtractComponentType* ExtractComponent;
 
  using ReleaseResourcesType = void(void*);
  ReleaseResourcesType* ReleaseResources;
  ReleaseResourcesType* ReleaseResourcesExecution;
 
  using PrintSummaryType = void(void*, std::ostream&, bool);
  PrintSummaryType* PrintSummary;
 
  void operator=(const UnknownAHContainer&) = delete;
 
  ~UnknownAHContainer() { this->DeleteFunction(this->ArrayHandlePointer); }
 
  std::shared_ptr<UnknownAHContainer> MakeNewInstance() const;
 
  template <typename T, typename S>
  static std::shared_ptr<UnknownAHContainer> Make(const vtkm::cont::ArrayHandle<T, S>& array)
  {
    return std::shared_ptr<UnknownAHContainer>(new UnknownAHContainer(array));
  }
 
  template <typename TargetT, typename SourceT, typename SourceS>
  static std::shared_ptr<UnknownAHContainer> Make(
    const vtkm::cont::ArrayHandle<TargetT, vtkm::cont::StorageTagCast<SourceT, SourceS>>& array)
  {
    vtkm::cont::ArrayHandleCast<TargetT, vtkm::cont::ArrayHandle<SourceT, SourceS>> castArray =
      array;
    return Make(castArray.GetSourceArray());
  }
 
  template <typename T, typename... Ss>
  static std::shared_ptr<UnknownAHContainer> Make(
    const vtkm::cont::ArrayHandle<T, vtkm::cont::StorageTagMultiplexer<Ss...>>& array)
  {
    auto&& variant = vtkm::cont::ArrayHandleMultiplexer<vtkm::cont::ArrayHandle<T, Ss>...>(array)
                       .GetArrayHandleVariant();
    if (variant.IsValid())
    {
      return variant.CastAndCall(MakeUnknownAHContainerFunctor{});
    }
    else
    {
      return std::shared_ptr<UnknownAHContainer>{};
    }
  }
 
private:
  UnknownAHContainer(const UnknownAHContainer&) = default;
 
  template <typename T, typename S>
  explicit UnknownAHContainer(const vtkm::cont::ArrayHandle<T, S>& array);
};
 
template <typename T, typename S>
std::shared_ptr<UnknownAHContainer> UnknownAHNewInstanceBasic(void*, vtkm::VecTraitsTagSizeStatic)
{
  return UnknownAHContainer::Make(vtkm::cont::ArrayHandleBasic<T>{});
}
template <typename T, typename S>
std::shared_ptr<UnknownAHContainer> UnknownAHNewInstanceBasic(void* mem,
                                                              vtkm::VecTraitsTagSizeVariable)
{
  vtkm::IdComponent numComponents = UnknownAHNumberOfComponentsFlat<T, S>(mem);
  if (numComponents < 1)
  {
    // Array can have an inconsistent number of components. Cannot be represented by basic array.
    throw vtkm::cont::ErrorBadType("Cannot create a basic array from array with ValueType of " +
                                   vtkm::cont::TypeToString<T>());
  }
  using ComponentType = typename vtkm::VecTraits<T>::BaseComponentType;
  return UnknownAHContainer::Make(vtkm::cont::ArrayHandleRuntimeVec<ComponentType>(numComponents));
}
template <typename T, typename S>
std::shared_ptr<UnknownAHContainer> UnknownAHNewInstanceBasic(void* mem)
{
  return UnknownAHNewInstanceBasic<T, S>(mem, typename vtkm::VecTraits<T>::IsSizeStatic{});
}
 
template <typename T, typename S>
std::shared_ptr<UnknownAHContainer> UnknownAHNewInstanceFloatBasic(void*,
                                                                   vtkm::VecTraitsTagSizeStatic)
{
  using FloatT = typename vtkm::VecTraits<T>::template ReplaceBaseComponentType<vtkm::FloatDefault>;
  return UnknownAHContainer::Make(vtkm::cont::ArrayHandleBasic<FloatT>{});
}
template <typename T, typename S>
std::shared_ptr<UnknownAHContainer> UnknownAHNewInstanceFloatBasic(void* mem,
                                                                   vtkm::VecTraitsTagSizeVariable)
{
  vtkm::IdComponent numComponents = UnknownAHNumberOfComponentsFlat<T, S>(mem);
  if (numComponents < 1)
  {
    // Array can have an inconsistent number of components. Cannot be represented by basic array.
    throw vtkm::cont::ErrorBadType("Cannot create a basic array from array with ValueType of " +
                                   vtkm::cont::TypeToString<T>());
  }
  return UnknownAHContainer::Make(
    vtkm::cont::ArrayHandleRuntimeVec<vtkm::FloatDefault>(numComponents));
}
template <typename T, typename S>
std::shared_ptr<UnknownAHContainer> UnknownAHNewInstanceFloatBasic(void* mem)
{
  return UnknownAHNewInstanceFloatBasic<T, S>(mem, typename vtkm::VecTraits<T>::IsSizeStatic{});
}
 
template <typename T, typename S>
inline UnknownAHContainer::UnknownAHContainer(const vtkm::cont::ArrayHandle<T, S>& array)
  : ArrayHandlePointer(new vtkm::cont::ArrayHandle<T, S>(array))
  , ValueType(typeid(T))
  , StorageType(typeid(S))
  , BaseComponentType(
      UnknownAHComponentInfo::Make<typename vtkm::VecTraits<T>::BaseComponentType>())
  , DeleteFunction(detail::UnknownAHDelete<T, S>)
  , Buffers(detail::UnknownAHBuffers<T, S>)
  , NewInstance(detail::UnknownAHNewInstance<T, S>)
  , NewInstanceBasic(detail::UnknownAHNewInstanceBasic<T, S>)
  , NewInstanceFloatBasic(detail::UnknownAHNewInstanceFloatBasic<T, S>)
  , NumberOfValues(detail::UnknownAHNumberOfValues<T, S>)
  , NumberOfComponents(detail::UnknownAHNumberOfComponents<T, S>)
  , NumberOfComponentsFlat(detail::UnknownAHNumberOfComponentsFlat<T, S>)
  , Allocate(detail::UnknownAHAllocate<T, S>)
  , ShallowCopy(detail::UnknownAHShallowCopy<T, S>)
  , DeepCopy(detail::UnknownAHDeepCopy<T, S>)
  , ExtractComponent(detail::UnknownAHExtractComponent<T, S>)
  , ReleaseResources(detail::UnknownAHReleaseResources<T, S>)
  , ReleaseResourcesExecution(detail::UnknownAHReleaseResourcesExecution<T, S>)
  , PrintSummary(detail::UnknownAHPrintSummary<T, S>)
{
}
 
template <typename T, typename S>
inline std::shared_ptr<UnknownAHContainer> MakeUnknownAHContainerFunctor::operator()(
  const vtkm::cont::ArrayHandle<T, S>& array) const
{
  return UnknownAHContainer::Make(array);
};
 
} // namespace detail
 
// Forward declaration. Include UncertainArrayHandle.h if using this.
template <typename ValueTypeList, typename StorageTypeList>
class UncertainArrayHandle;
 
class VTKM_CONT_EXPORT UnknownArrayHandle
{
  std::shared_ptr<detail::UnknownAHContainer> Container;
 
  VTKM_CONT bool IsValueTypeImpl(std::type_index type) const;
  VTKM_CONT bool IsStorageTypeImpl(std::type_index type) const;
  VTKM_CONT bool IsBaseComponentTypeImpl(const detail::UnknownAHComponentInfo& type) const;
 
public:
  VTKM_CONT UnknownArrayHandle() = default;
 
  template <typename T, typename S>
  VTKM_CONT UnknownArrayHandle(const vtkm::cont::ArrayHandle<T, S>& array)
    : Container(detail::UnknownAHContainer::Make(array))
  {
  }
 
  VTKM_CONT bool IsValid() const;
 
  VTKM_CONT UnknownArrayHandle NewInstance() const;
 
  VTKM_CONT UnknownArrayHandle NewInstanceBasic() const;
 
  VTKM_CONT UnknownArrayHandle NewInstanceFloatBasic() const;
 
  VTKM_CONT std::string GetValueTypeName() const;
 
  VTKM_CONT std::string GetBaseComponentTypeName() const;
 
  VTKM_CONT std::string GetStorageTypeName() const;
 
  VTKM_CONT std::string GetArrayTypeName() const;
 
  template <typename ValueType>
  VTKM_CONT bool IsValueType() const
  {
    return this->IsValueTypeImpl(typeid(ValueType));
  }
 
  template <typename StorageType>
  VTKM_CONT bool IsStorageType() const
  {
    return this->IsStorageTypeImpl(typeid(StorageType));
  }
 
  template <typename BaseComponentType>
  VTKM_CONT bool IsBaseComponentType() const
  {
    return this->IsBaseComponentTypeImpl(detail::UnknownAHComponentInfo::Make<BaseComponentType>());
  }
 
  template <typename ArrayHandleType>
  VTKM_CONT bool IsType() const
  {
    VTKM_IS_ARRAY_HANDLE(ArrayHandleType);
    return (this->IsValueType<typename ArrayHandleType::ValueType>() &&
            this->IsStorageType<typename ArrayHandleType::StorageTag>());
  }
 
  // Defined in UncertainArrayHandle.h
  template <typename NewValueTypeList, typename NewStorageTypeList>
  VTKM_CONT vtkm::cont::UncertainArrayHandle<NewValueTypeList, NewStorageTypeList> ResetTypes(
    NewValueTypeList = NewValueTypeList{},
    NewStorageTypeList = NewStorageTypeList{}) const;
 
  VTKM_CONT vtkm::Id GetNumberOfValues() const;
 
  VTKM_CONT vtkm::IdComponent GetNumberOfComponents() const;
 
  VTKM_CONT vtkm::IdComponent GetNumberOfComponentsFlat() const;
 
  VTKM_CONT void Allocate(vtkm::Id numValues,
                          vtkm::CopyFlag preserve,
                          vtkm::cont::Token& token) const;
  VTKM_CONT void Allocate(vtkm::Id numValues, vtkm::CopyFlag preserve = vtkm::CopyFlag::Off) const;
 
  template <typename ArrayHandleType>
  VTKM_CONT bool CanConvert() const;
 
  // MSVC will issue deprecation warnings here if this template is instantiated with
  // a deprecated class even if the template is used from a section of code where
  // deprecation warnings are suppressed. This is annoying behavior since this template
  // has no control over what class it is used with. To get around it, we have to
  // suppress all deprecation warnings here.
#ifdef VTKM_MSVC
  VTKM_DEPRECATED_SUPPRESS_BEGIN
#endif
 
private:
  template <typename T, typename S>
  VTKM_CONT void BaseAsArrayHandle(vtkm::cont::ArrayHandle<T, S>& array) const
  {
    using ArrayType = vtkm::cont::ArrayHandle<T, S>;
    if (!this->IsType<ArrayType>())
    {
      VTKM_LOG_CAST_FAIL(*this, decltype(array));
      throwFailedDynamicCast(this->GetArrayTypeName(), vtkm::cont::TypeToString(array));
    }
 
    array = *reinterpret_cast<ArrayType*>(this->Container->ArrayHandlePointer);
  }
 
public:
  template <typename T, typename S>
  VTKM_CONT void AsArrayHandle(vtkm::cont::ArrayHandle<T, S>& array) const
  {
    this->BaseAsArrayHandle(array);
  }
 
  template <typename T>
  VTKM_CONT void AsArrayHandle(vtkm::cont::ArrayHandle<T>& array) const;
 
  template <typename T, typename... Ss>
  VTKM_CONT void AsArrayHandle(
    vtkm::cont::ArrayHandle<T, vtkm::cont::StorageTagMultiplexer<Ss...>>& array) const;
 
  template <typename TargetT, typename SourceT, typename SourceS>
  VTKM_CONT void AsArrayHandle(
    vtkm::cont::ArrayHandle<TargetT, vtkm::cont::StorageTagCast<SourceT, SourceS>>& array) const
  {
    using ContainedArrayType = vtkm::cont::ArrayHandle<SourceT, SourceS>;
    array = vtkm::cont::ArrayHandleCast<TargetT, ContainedArrayType>(
      this->AsArrayHandle<ContainedArrayType>());
  }
 
  template <typename T>
  VTKM_CONT void AsArrayHandle(
    vtkm::cont::ArrayHandle<T, vtkm::cont::StorageTagRuntimeVec>& array) const
  {
    using BaseT = typename T::ComponentType;
    if (this->IsStorageType<vtkm::cont::StorageTagBasic>() && this->IsBaseComponentType<BaseT>())
    {
      // Reinterpret the basic array as components, and then wrap that in a runtime vec
      // with the correct amount of components.
      vtkm::cont::ArrayHandle<BaseT, vtkm::cont::StorageTagBasic> basicArray(
        this->Container->Buffers(this->Container->ArrayHandlePointer));
      array =
        vtkm::cont::ArrayHandleRuntimeVec<BaseT>(this->GetNumberOfComponentsFlat(), basicArray);
    }
    else
    {
      this->BaseAsArrayHandle(array);
    }
  }
 
  template <typename ArrayType>
  VTKM_CONT ArrayType AsArrayHandle() const
  {
    VTKM_IS_ARRAY_HANDLE(ArrayType);
    ArrayType array;
    this->AsArrayHandle(array);
    return array;
  }
#ifdef VTKM_MSVC
  VTKM_DEPRECATED_SUPPRESS_END
#endif
 
  void DeepCopyFrom(const vtkm::cont::UnknownArrayHandle& source);
 
  void DeepCopyFrom(const vtkm::cont::UnknownArrayHandle& source) const;
 
  void CopyShallowIfPossible(const vtkm::cont::UnknownArrayHandle& source);
 
  void CopyShallowIfPossible(const vtkm::cont::UnknownArrayHandle& source) const;
 
  template <typename BaseComponentType>
  VTKM_CONT vtkm::cont::ArrayHandleStride<BaseComponentType> ExtractComponent(
    vtkm::IdComponent componentIndex,
    vtkm::CopyFlag allowCopy = vtkm::CopyFlag::On) const
  {
    using ComponentArrayType = vtkm::cont::ArrayHandleStride<BaseComponentType>;
    if (!this->IsBaseComponentType<BaseComponentType>())
    {
      VTKM_LOG_CAST_FAIL(*this, ComponentArrayType);
      throwFailedDynamicCast("UnknownArrayHandle with " + this->GetArrayTypeName(),
                             "component array of " + vtkm::cont::TypeToString<BaseComponentType>());
    }
 
    auto buffers = this->Container->ExtractComponent(
      this->Container->ArrayHandlePointer, componentIndex, allowCopy);
    return ComponentArrayType(buffers);
  }
 
  template <typename BaseComponentType>
  VTKM_CONT vtkm::cont::ArrayHandleRecombineVec<BaseComponentType> ExtractArrayFromComponents(
    vtkm::CopyFlag allowCopy = vtkm::CopyFlag::On) const
  {
    vtkm::cont::ArrayHandleRecombineVec<BaseComponentType> result;
    vtkm::IdComponent numComponents = this->GetNumberOfComponentsFlat();
    for (vtkm::IdComponent cIndex = 0; cIndex < numComponents; ++cIndex)
    {
      result.AppendComponentArray(this->ExtractComponent<BaseComponentType>(cIndex, allowCopy));
    }
    return result;
  }
 
  template <typename TypeList, typename StorageList, typename Functor, typename... Args>
  VTKM_CONT void CastAndCallForTypes(Functor&& functor, Args&&... args) const;
 
  template <typename TypeList, typename StorageList, typename Functor, typename... Args>
  VTKM_CONT void CastAndCallForTypesWithFloatFallback(Functor&& functor, Args&&... args) const;
 
  template <typename Functor, typename... Args>
  VTKM_CONT void CastAndCallWithExtractedArray(Functor&& functor, Args&&... args) const;
 
  VTKM_CONT void ReleaseResourcesExecution() const;
 
  VTKM_CONT void ReleaseResources() const;
 
  VTKM_CONT void PrintSummary(std::ostream& out, bool full = false) const;
};
 
//=============================================================================
// Out of class implementations
 
namespace detail
{
 
template <typename T, typename S>
struct UnknownArrayHandleCanConvert
{
  VTKM_CONT bool operator()(const vtkm::cont::UnknownArrayHandle& array) const
  {
    return array.IsType<vtkm::cont::ArrayHandle<T, S>>();
  }
};
 
template <typename T>
struct UnknownArrayHandleCanConvert<T, vtkm::cont::StorageTagBasic>
{
  VTKM_CONT bool operator()(const vtkm::cont::UnknownArrayHandle& array) const
  {
    using UnrolledVec = vtkm::internal::UnrollVec<T>;
    return (array.IsType<vtkm::cont::ArrayHandleBasic<T>>() ||
            (array.IsStorageType<vtkm::cont::StorageTagRuntimeVec>() &&
             array.IsBaseComponentType<typename UnrolledVec::ComponentType>() &&
             UnrolledVec::NUM_COMPONENTS == array.GetNumberOfComponentsFlat()));
  }
};
 
template <typename TargetT, typename SourceT, typename SourceS>
struct UnknownArrayHandleCanConvert<TargetT, vtkm::cont::StorageTagCast<SourceT, SourceS>>
{
  VTKM_CONT bool operator()(const vtkm::cont::UnknownArrayHandle& array) const
  {
    return UnknownArrayHandleCanConvert<SourceT, SourceS>{}(array);
  }
};
 
template <typename T>
struct UnknownArrayHandleCanConvertTry
{
  template <typename S>
  VTKM_CONT void operator()(S, const vtkm::cont::UnknownArrayHandle& array, bool& canConvert) const
  {
    canConvert |= UnknownArrayHandleCanConvert<T, S>{}(array);
  }
};
 
template <typename T, typename... Ss>
struct UnknownArrayHandleCanConvert<T, vtkm::cont::StorageTagMultiplexer<Ss...>>
{
  VTKM_CONT bool operator()(const vtkm::cont::UnknownArrayHandle& array) const
  {
    bool canConvert = false;
    vtkm::ListForEach(UnknownArrayHandleCanConvertTry<T>{}, vtkm::List<Ss...>{}, array, canConvert);
    return canConvert;
  }
};
 
template <typename T>
struct UnknownArrayHandleCanConvert<T, vtkm::cont::StorageTagRuntimeVec>
{
  VTKM_CONT bool operator()(const vtkm::cont::UnknownArrayHandle& array) const
  {
    using BaseComponentType = typename T::ComponentType;
    return (array.IsType<vtkm::cont::ArrayHandle<T, vtkm::cont::StorageTagRuntimeVec>>() ||
            (array.IsStorageType<vtkm::cont::StorageTagBasic>() &&
             array.IsBaseComponentType<BaseComponentType>()));
  }
};
 
} // namespace detail
 
template <typename ArrayHandleType>
VTKM_CONT inline bool UnknownArrayHandle::CanConvert() const
{
  VTKM_IS_ARRAY_HANDLE(ArrayHandleType);
 
  return detail::UnknownArrayHandleCanConvert<typename ArrayHandleType::ValueType,
                                              typename ArrayHandleType::StorageTag>{}(*this);
}
 
namespace detail
{
 
template <typename T,
          vtkm::IdComponent =
            vtkm::VecTraits<typename vtkm::internal::UnrollVec<T>::ComponentType>::NUM_COMPONENTS>
struct UnknownArrayHandleRuntimeVecAsBasic
{
  VTKM_CONT bool operator()(const vtkm::cont::UnknownArrayHandle*,
                            const detail::UnknownAHContainer*,
                            vtkm::cont::ArrayHandle<T>&) const
  {
    // This version only gets called if T contains a `Vec`-like object that is not a strict `Vec`.
    // This is rare but could happen. In this case, the type cannot be stored in an
    // `ArrayHandleRuntimeVec` and therefore the load can never happen, so just ignore.
    return false;
  }
};
 
template <typename T>
struct UnknownArrayHandleRuntimeVecAsBasic<T, 1>
{
  VTKM_CONT bool operator()(const vtkm::cont::UnknownArrayHandle* self,
                            const detail::UnknownAHContainer* container,
                            vtkm::cont::ArrayHandle<T>& array) const
  {
    using UnrolledVec = vtkm::internal::UnrollVec<T>;
    using ComponentType = typename UnrolledVec::ComponentType;
    if (self->IsStorageType<vtkm::cont::StorageTagRuntimeVec>() &&
        self->IsBaseComponentType<ComponentType>() &&
        UnrolledVec::NUM_COMPONENTS == self->GetNumberOfComponentsFlat())
    {
      // Pull out the components array out of the buffers. The array might not match exactly
      // the array put in, but the buffer should still be consistent with the array (which works
      // because the size of a basic array is based on the number of bytes in the buffer).
      using RuntimeVecType = typename vtkm::cont::ArrayHandleRuntimeVec<ComponentType>::ValueType;
      using StorageRuntimeVec =
        vtkm::cont::internal::Storage<RuntimeVecType, vtkm::cont::StorageTagRuntimeVec>;
      StorageRuntimeVec::AsArrayHandleBasic(container->Buffers(container->ArrayHandlePointer),
                                            array);
      return true;
    }
    else
    {
      return false;
    }
  }
};
 
} // namespace detail
 
template <typename T>
VTKM_CONT inline void UnknownArrayHandle::AsArrayHandle(vtkm::cont::ArrayHandle<T>& array) const
{
  if (!detail::UnknownArrayHandleRuntimeVecAsBasic<T>{}(this, this->Container.get(), array))
  {
    this->BaseAsArrayHandle(array);
  }
}
 
namespace detail
{
 
struct UnknownArrayHandleMultiplexerCastTry
{
  template <typename T, typename S, typename... Ss>
  VTKM_CONT void operator()(
    S,
    const vtkm::cont::UnknownArrayHandle& unknownArray,
    vtkm::cont::ArrayHandle<T, vtkm::cont::StorageTagMultiplexer<Ss...>>& outputArray,
    bool& converted) const
  {
    using ArrayType = vtkm::cont::ArrayHandle<T, S>;
    if (unknownArray.CanConvert<ArrayType>())
    {
      if (converted && !unknownArray.IsType<ArrayType>())
      {
        // The array has already been converted and pushed in the multiplexer. It is
        // possible that multiple array types can be put in the ArrayHandleMultiplexer
        // (for example, and ArrayHandle or an ArrayHandle that has been cast). Exact
        // matches will override other matches (hence, the second part of the condition),
        // but at this point we have already found a better array to put inside.
        return;
      }
      outputArray = vtkm::cont::ArrayHandleMultiplexer<vtkm::cont::ArrayHandle<T, Ss>...>(
        unknownArray.AsArrayHandle<ArrayType>());
      converted = true;
    }
  }
};
 
} // namespace detail
 
template <typename T, typename... Ss>
void UnknownArrayHandle::AsArrayHandle(
  vtkm::cont::ArrayHandle<T, vtkm::cont::StorageTagMultiplexer<Ss...>>& array) const
{
  bool converted = false;
  vtkm::ListForEach(
    detail::UnknownArrayHandleMultiplexerCastTry{}, vtkm::List<Ss...>{}, *this, array, converted);
 
  if (!converted)
  {
    VTKM_LOG_CAST_FAIL(*this, decltype(array));
    throwFailedDynamicCast(vtkm::cont::TypeToString(*this), vtkm::cont::TypeToString(array));
  }
}
 
namespace detail
{
 
struct UnknownArrayHandleTry
{
  template <typename T, typename S, typename Functor, typename... Args>
  void operator()(vtkm::List<T, S>,
                  Functor&& f,
                  bool& called,
                  const vtkm::cont::UnknownArrayHandle& unknownArray,
                  Args&&... args) const
  {
    using DerivedArrayType = vtkm::cont::ArrayHandle<T, S>;
    if (!called && unknownArray.CanConvert<DerivedArrayType>())
    {
      called = true;
      DerivedArrayType derivedArray;
      unknownArray.AsArrayHandle(derivedArray);
      VTKM_LOG_CAST_SUCC(unknownArray, derivedArray);
 
      // If you get a compile error here, it means that you have called CastAndCall for a
      // vtkm::cont::UnknownArrayHandle and the arguments of the functor do not match those
      // being passed. This is often because it is calling the functor with an ArrayHandle
      // type that was not expected. Either add overloads to the functor to accept all
      // possible array types or constrain the types tried for the CastAndCall. Note that
      // the functor will be called with an array of type vtkm::cont::ArrayHandle<T, S>.
      // Directly using a subclass of ArrayHandle (e.g. vtkm::cont::ArrayHandleConstant<T>)
      // might not work.
      f(derivedArray, std::forward<Args>(args)...);
    }
  }
};
 
} // namespace detail
 
namespace internal
{
 
namespace detail
{
 
template <typename T>
struct IsUndefinedArrayType
{
};
template <typename T, typename S>
struct IsUndefinedArrayType<vtkm::List<T, S>> : vtkm::cont::internal::IsInvalidArrayHandle<T, S>
{
};
 
} // namespace detail
 
template <typename ValueTypeList, typename StorageTypeList>
using ListAllArrayTypes =
  vtkm::ListRemoveIf<vtkm::ListCross<ValueTypeList, StorageTypeList>, detail::IsUndefinedArrayType>;
 
VTKM_CONT_EXPORT void ThrowCastAndCallException(const vtkm::cont::UnknownArrayHandle&,
                                                const std::type_info&);
 
} // namespace internal
 
template <typename TypeList, typename StorageTagList, typename Functor, typename... Args>
inline void UnknownArrayHandle::CastAndCallForTypes(Functor&& f, Args&&... args) const
{
  using crossProduct = internal::ListAllArrayTypes<TypeList, StorageTagList>;
 
  bool called = false;
  vtkm::ListForEach(detail::UnknownArrayHandleTry{},
                    crossProduct{},
                    std::forward<Functor>(f),
                    called,
                    *this,
                    std::forward<Args>(args)...);
  if (!called)
  {
    // throw an exception
    VTKM_LOG_CAST_FAIL(*this, TypeList);
    internal::ThrowCastAndCallException(*this, typeid(TypeList));
  }
}
 
template <typename TypeList, typename StorageTagList, typename Functor, typename... Args>
VTKM_CONT void UnknownArrayHandle::CastAndCallForTypesWithFloatFallback(Functor&& functor,
                                                                        Args&&... args) const
{
  using crossProduct = internal::ListAllArrayTypes<TypeList, StorageTagList>;
 
  bool called = false;
  vtkm::ListForEach(detail::UnknownArrayHandleTry{},
                    crossProduct{},
                    std::forward<Functor>(functor),
                    called,
                    *this,
                    std::forward<Args>(args)...);
  if (!called)
  {
    // Copy to a float array and try again
    vtkm::cont::UnknownArrayHandle floatArray = this->NewInstanceFloatBasic();
    floatArray.DeepCopyFrom(*this);
    vtkm::ListForEach(detail::UnknownArrayHandleTry{},
                      crossProduct{},
                      std::forward<Functor>(functor),
                      called,
                      floatArray,
                      std::forward<Args>(args)...);
  }
  if (!called)
  {
    // throw an exception
    VTKM_LOG_CAST_FAIL(*this, TypeList);
    internal::ThrowCastAndCallException(*this, typeid(TypeList));
  }
}
 
//=============================================================================
// Free function casting helpers
 
template <typename ArrayHandleType>
VTKM_CONT inline bool IsType(const vtkm::cont::UnknownArrayHandle& array)
{
  return array.template IsType<ArrayHandleType>();
}
 
template <typename ArrayHandleType>
VTKM_CONT inline ArrayHandleType Cast(const vtkm::cont::UnknownArrayHandle& array)
{
  return array.template AsArrayHandle<ArrayHandleType>();
}
 
namespace detail
{
 
struct UnknownArrayHandleTryExtract
{
  template <typename T, typename Functor, typename... Args>
  void operator()(T,
                  Functor&& f,
                  bool& called,
                  const vtkm::cont::UnknownArrayHandle& unknownArray,
                  Args&&... args) const
  {
    if (!called && unknownArray.IsBaseComponentType<T>())
    {
      called = true;
      auto extractedArray = unknownArray.ExtractArrayFromComponents<T>();
      VTKM_LOG_CAST_SUCC(unknownArray, extractedArray);
 
      // If you get a compile error here, it means that you have called
      // CastAndCallWithExtractedArray for a vtkm::cont::UnknownArrayHandle and the arguments of
      // the functor do not match those being passed. This is often because it is calling the
      // functor with an ArrayHandle type that was not expected. Add overloads to the functor to
      // accept all possible array types or constrain the types tried for the CastAndCall. Note
      // that the functor will be called with an array of type that is different than the actual
      // type of the `ArrayHandle` stored in the `UnknownArrayHandle`.
      f(extractedArray, std::forward<Args>(args)...);
    }
  }
};
 
} // namespace detail
 
template <typename Functor, typename... Args>
inline void UnknownArrayHandle::CastAndCallWithExtractedArray(Functor&& functor,
                                                              Args&&... args) const
{
  bool called = false;
  vtkm::ListForEach(detail::UnknownArrayHandleTryExtract{},
                    vtkm::TypeListScalarAll{},
                    std::forward<Functor>(functor),
                    called,
                    *this,
                    std::forward<Args>(args)...);
  if (!called)
  {
    // Throw an exception.
    // The message will be a little wonky because the types are just the value types, not the
    // full type to cast to.
    VTKM_LOG_CAST_FAIL(*this, vtkm::TypeListScalarAll);
    internal::ThrowCastAndCallException(*this, typeid(vtkm::TypeListScalarAll));
  }
}
 
}
} // namespace vtkm::cont
 
//=============================================================================
// Specializations of serialization related classes
 
namespace vtkm
{
namespace cont
{
 
template <>
struct VTKM_CONT_EXPORT SerializableTypeString<vtkm::cont::UnknownArrayHandle>
{
  static VTKM_CONT std::string Get();
};
}
} // namespace vtkm::cont
 
namespace mangled_diy_namespace
{
 
template <>
struct VTKM_CONT_EXPORT Serialization<vtkm::cont::UnknownArrayHandle>
{
public:
  static VTKM_CONT void save(BinaryBuffer& bb, const vtkm::cont::UnknownArrayHandle& obj);
  static VTKM_CONT void load(BinaryBuffer& bb, vtkm::cont::UnknownArrayHandle& obj);
};
 
} // namespace mangled_diy_namespace
 
 
#endif //vtk_m_cont_UnknownArrayHandle_h