ArrayHandle.h

Go to the documentation of this file.

//============================================================================
//  The contents of this file are covered by the Viskores license. See
//  LICENSE.txt for details.
//
//  By contributing to this file, all contributors agree to the Developer
//  Certificate of Origin Version 1.1 (DCO 1.1) as stated in DCO.txt.
//============================================================================
 
//============================================================================
//  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 viskores_cont_ArrayHandle_h
#define viskores_cont_ArrayHandle_h
 
#include <viskores/cont/viskores_cont_export.h>
 
#include <viskores/Assert.h>
#include <viskores/Flags.h>
#include <viskores/Types.h>
 
#include <viskores/cont/DeviceAdapterList.h>
#include <viskores/cont/ErrorBadValue.h>
#include <viskores/cont/ErrorInternal.h>
#include <viskores/cont/Storage.h>
#include <viskores/cont/Token.h>
 
#include <viskores/internal/ArrayPortalHelpers.h>
 
#include <algorithm>
#include <deque>
#include <iterator>
#include <memory>
#include <mutex>
#include <vector>
 
#include <viskores/cont/internal/Buffer.h>
 
namespace viskores
{
namespace cont
{
 
// Normally this would be defined in ArrayHandleBasic.h, but we need this declared early for
// the default storage.
 
struct VISKORES_ALWAYS_EXPORT StorageTagBasic
{
};
}
} // namespace viskores::cont
 
#if VISKORES_STORAGE == VISKORES_STORAGE_BASIC
 
#define VISKORES_DEFAULT_STORAGE_TAG ::viskores::cont::StorageTagBasic
 
#elif VISKORES_STORAGE == VISKORES_STORAGE_ERROR
 
#include <viskores/cont/internal/StorageError.h>
#define VISKORES_DEFAULT_STORAGE_TAG ::viskores::cont::internal::StorageTagError
 
#elif (VISKORES_STORAGE == VISKORES_STORAGE_UNDEFINED) || !defined(VISKORES_STORAGE)
 
#ifndef VISKORES_DEFAULT_STORAGE_TAG
#warning If array storage is undefined, VISKORES_DEFAULT_STORAGE_TAG must be defined.
#endif
 
#endif
 
namespace viskores
{
namespace cont
{
 
namespace internal
{
 
class VISKORES_CONT_EXPORT ArrayHandleBase
{
};
 
template <typename T, typename StorageTag>
using IsValidArrayHandle = std::integral_constant<
  bool,
  !(std::is_base_of<viskores::cont::internal::UndefinedStorage,
                    viskores::cont::internal::Storage<T, StorageTag>>::value)>;
 
template <typename T, typename StorageTag>
using IsInvalidArrayHandle =
  std::integral_constant<bool, !IsValidArrayHandle<T, StorageTag>::value>;
 
template <typename ArrayHandle>
using IsWritableArrayHandle =
  viskores::internal::PortalSupportsSets<typename std::decay<ArrayHandle>::type::WritePortalType>;
 
template <typename T>
struct ArrayHandleCheck
  : std::is_base_of<viskores::cont::internal::ArrayHandleBase, std::decay_t<T>>::type
{
};
 
#define VISKORES_IS_ARRAY_HANDLE(T) \
  VISKORES_STATIC_ASSERT(::viskores::cont::internal::ArrayHandleCheck<T>{})
 
} // namespace internal
 
namespace detail
{
 
template <typename T>
struct GetTypeInParentheses;
template <typename T>
struct GetTypeInParentheses<void(T)>
{
  using type = T;
};
 
} // namespace detail
 
// Implementation for VISKORES_ARRAY_HANDLE_SUBCLASS macros
#define VISKORES_ARRAY_HANDLE_SUBCLASS_IMPL(classname, fullclasstype, superclass, typename__) \
  using Thisclass =                                                                           \
    typename__ viskores::cont::detail::GetTypeInParentheses<void fullclasstype>::type;        \
  using Superclass =                                                                          \
    typename__ viskores::cont::detail::GetTypeInParentheses<void superclass>::type;           \
                                                                                              \
  VISKORES_IS_ARRAY_HANDLE(Superclass);                                                       \
                                                                                              \
  VISKORES_CONT                                                                               \
  classname()                                                                                 \
  {                                                                                           \
  }                                                                                           \
                                                                                              \
  VISKORES_CONT                                                                               \
  classname(const Thisclass& src)                                                             \
    : Superclass(src)                                                                         \
  {                                                                                           \
  }                                                                                           \
                                                                                              \
  VISKORES_CONT                                                                               \
  classname(Thisclass&& src) noexcept                                                         \
    : Superclass(std::move(src))                                                              \
  {                                                                                           \
  }                                                                                           \
                                                                                              \
  VISKORES_CONT                                                                               \
  classname(const viskores::cont::ArrayHandle<typename__ Superclass::ValueType,               \
                                              typename__ Superclass::StorageTag>& src)        \
    : Superclass(src)                                                                         \
  {                                                                                           \
  }                                                                                           \
                                                                                              \
  VISKORES_CONT                                                                               \
  classname(viskores::cont::ArrayHandle<typename__ Superclass::ValueType,                     \
                                        typename__ Superclass::StorageTag>&& src) noexcept    \
    : Superclass(std::move(src))                                                              \
  {                                                                                           \
  }                                                                                           \
                                                                                              \
  VISKORES_CONT                                                                               \
  explicit classname(const std::vector<viskores::cont::internal::Buffer>& buffers)            \
    : Superclass(buffers)                                                                     \
  {                                                                                           \
  }                                                                                           \
                                                                                              \
  VISKORES_CONT                                                                               \
  explicit classname(std::vector<viskores::cont::internal::Buffer>&& buffers) noexcept        \
    : Superclass(std::move(buffers))                                                          \
  {                                                                                           \
  }                                                                                           \
                                                                                              \
  VISKORES_CONT                                                                               \
  Thisclass& operator=(const Thisclass& src)                                                  \
  {                                                                                           \
    this->Superclass::operator=(src);                                                         \
    return *this;                                                                             \
  }                                                                                           \
                                                                                              \
  VISKORES_CONT                                                                               \
  Thisclass& operator=(Thisclass&& src) noexcept                                              \
  {                                                                                           \
    this->Superclass::operator=(std::move(src));                                              \
    return *this;                                                                             \
  }                                                                                           \
                                                                                              \
  using ValueType = typename__ Superclass::ValueType;                                         \
  using StorageTag = typename__ Superclass::StorageTag;                                       \
  using StorageType = typename__ Superclass::StorageType;                                     \
  using ReadPortalType = typename__ Superclass::ReadPortalType;                               \
  using WritePortalType = typename__ Superclass::WritePortalType
 
#define VISKORES_ARRAY_HANDLE_SUBCLASS(classname, fullclasstype, superclass) \
  VISKORES_ARRAY_HANDLE_SUBCLASS_IMPL(classname, fullclasstype, superclass, typename)
 
#define VISKORES_ARRAY_HANDLE_SUBCLASS_NT(classname, superclass) \
  VISKORES_ARRAY_HANDLE_SUBCLASS_IMPL(classname, (classname), superclass, )
 
namespace detail
{
 
VISKORES_CONT_EXPORT VISKORES_CONT void ArrayHandleReleaseResourcesExecution(
  const std::vector<viskores::cont::internal::Buffer>& buffers);
 
VISKORES_CONT_EXPORT VISKORES_CONT bool ArrayHandleIsOnDevice(
  const std::vector<viskores::cont::internal::Buffer>& buffers,
  viskores::cont::DeviceAdapterId device);
 
} // namespace detail
 
template <typename T, typename StorageTag_ = VISKORES_DEFAULT_STORAGE_TAG>
class VISKORES_ALWAYS_EXPORT ArrayHandle : public internal::ArrayHandleBase
{
  VISKORES_STATIC_ASSERT_MSG(
    (internal::IsValidArrayHandle<T, StorageTag_>::value),
    "Attempted to create an ArrayHandle with an invalid type/storage combination.");
 
public:
  using ValueType = T;
  using StorageTag = StorageTag_;
  using StorageType = viskores::cont::internal::Storage<ValueType, StorageTag>;
 
  using ReadPortalType = typename StorageType::ReadPortalType;
  using WritePortalType = typename StorageType::WritePortalType;
 
  VISKORES_CONT ArrayHandle()
    : Buffers(StorageType::CreateBuffers())
  {
  }
 
  VISKORES_CONT ArrayHandle(const viskores::cont::ArrayHandle<ValueType, StorageTag>& src)
    : Buffers(src.Buffers)
  {
  }
 
  VISKORES_CONT ArrayHandle(viskores::cont::ArrayHandle<ValueType, StorageTag>&& src) noexcept
    : Buffers(std::move(src.Buffers))
  {
  }
 
  VISKORES_CONT explicit ArrayHandle(const std::vector<viskores::cont::internal::Buffer>& buffers)
    : Buffers(buffers)
  {
  }
 
  VISKORES_CONT explicit ArrayHandle(
    std::vector<viskores::cont::internal::Buffer>&& buffers) noexcept
    : Buffers(std::move(buffers))
  {
  }
 
  VISKORES_CONT ~ArrayHandle() {}
 
  VISKORES_CONT
  viskores::cont::ArrayHandle<ValueType, StorageTag>& operator=(
    const viskores::cont::ArrayHandle<ValueType, StorageTag>& src)
  {
    this->Buffers = src.Buffers;
    return *this;
  }
 
  VISKORES_CONT
  viskores::cont::ArrayHandle<ValueType, StorageTag>& operator=(
    viskores::cont::ArrayHandle<ValueType, StorageTag>&& src) noexcept
  {
    this->Buffers = std::move(src.Buffers);
    return *this;
  }
 
  VISKORES_CONT
  bool operator==(const ArrayHandle<ValueType, StorageTag>& rhs) const
  {
    return this->Buffers == rhs.Buffers;
  }
 
  VISKORES_CONT
  bool operator!=(const ArrayHandle<ValueType, StorageTag>& rhs) const
  {
    return this->Buffers != rhs.Buffers;
  }
 
  template <typename VT, typename ST>
  VISKORES_CONT bool operator==(const ArrayHandle<VT, ST>&) const
  {
    return false; // different valuetype and/or storage
  }
 
  template <typename VT, typename ST>
  VISKORES_CONT bool operator!=(const ArrayHandle<VT, ST>&) const
  {
    return true; // different valuetype and/or storage
  }
 
  VISKORES_CONT StorageType GetStorage() const { return StorageType{}; }
 
  VISKORES_CONT ReadPortalType ReadPortal() const
  {
    viskores::cont::Token token;
    return this->ReadPortal(token);
  }
  VISKORES_CONT ReadPortalType ReadPortal(viskores::cont::Token& token) const
  {
    return StorageType::CreateReadPortal(
      this->GetBuffers(), viskores::cont::DeviceAdapterTagUndefined{}, token);
  }
 
  VISKORES_CONT WritePortalType WritePortal() const
  {
    viskores::cont::Token token;
    return this->WritePortal(token);
  }
  VISKORES_CONT WritePortalType WritePortal(viskores::cont::Token& token) const
  {
    return StorageType::CreateWritePortal(
      this->GetBuffers(), viskores::cont::DeviceAdapterTagUndefined{}, token);
  }
 
  VISKORES_CONT viskores::Id GetNumberOfValues() const
  {
    return StorageType::GetNumberOfValues(this->GetBuffers());
  }
 
  VISKORES_CONT viskores::IdComponent GetNumberOfComponentsFlat() const
  {
    return StorageType::GetNumberOfComponentsFlat(this->GetBuffers());
  }
 
  VISKORES_CONT void Allocate(viskores::Id numberOfValues,
                              viskores::CopyFlag preserve,
                              viskores::cont::Token& token) const
  {
    StorageType::ResizeBuffers(numberOfValues, this->GetBuffers(), preserve, token);
  }
 
  VISKORES_CONT void Allocate(viskores::Id numberOfValues,
                              viskores::CopyFlag preserve = viskores::CopyFlag::Off) const
  {
    viskores::cont::Token token;
    this->Allocate(numberOfValues, preserve, token);
  }
 
  VISKORES_CONT void AllocateAndFill(viskores::Id numberOfValues,
                                     const ValueType& fillValue,
                                     viskores::CopyFlag preserve,
                                     viskores::cont::Token& token) const
  {
    // Note that there is a slight potential for a race condition here. It is possible for someone
    // else to resize the array in between getting the startIndex and locking the array in the
    // Allocate call. If there really are 2 threads trying to allocate this array at the same time,
    // you probably have bigger problems than filling at the wrong index.
    viskores::Id startIndex = (preserve == viskores::CopyFlag::On) ? this->GetNumberOfValues() : 0;
 
    this->Allocate(numberOfValues, preserve, token);
 
    if (startIndex < numberOfValues)
    {
      this->Fill(fillValue, startIndex, numberOfValues, token);
    }
  }
 
  VISKORES_CONT void AllocateAndFill(viskores::Id numberOfValues,
                                     const ValueType& fillValue,
                                     viskores::CopyFlag preserve = viskores::CopyFlag::Off) const
  {
    viskores::cont::Token token;
    this->AllocateAndFill(numberOfValues, fillValue, preserve, token);
  }
 
  VISKORES_CONT void Fill(const ValueType& fillValue,
                          viskores::Id startIndex,
                          viskores::Id endIndex,
                          viskores::cont::Token& token) const
  {
    StorageType::Fill(this->GetBuffers(), fillValue, startIndex, endIndex, token);
  }
  VISKORES_CONT void Fill(const ValueType& fillValue,
                          viskores::Id startIndex,
                          viskores::Id endIndex) const
  {
    viskores::cont::Token token;
    this->Fill(fillValue, startIndex, endIndex, token);
  }
  VISKORES_CONT void Fill(const ValueType& fillValue, viskores::Id startIndex = 0) const
  {
    viskores::cont::Token token;
    this->Fill(fillValue, startIndex, this->GetNumberOfValues(), token);
  }
 
  VISKORES_CONT void ReleaseResourcesExecution() const
  {
    detail::ArrayHandleReleaseResourcesExecution(this->Buffers);
  }
 
  VISKORES_CONT void ReleaseResources() const { this->Allocate(0); }
 
  VISKORES_CONT ReadPortalType PrepareForInput(viskores::cont::DeviceAdapterId device,
                                               viskores::cont::Token& token) const
  {
    return StorageType::CreateReadPortal(this->GetBuffers(), device, token);
  }
 
  VISKORES_CONT WritePortalType PrepareForInPlace(viskores::cont::DeviceAdapterId device,
                                                  viskores::cont::Token& token) const
  {
    return StorageType::CreateWritePortal(this->GetBuffers(), device, token);
  }
 
  VISKORES_CONT WritePortalType PrepareForOutput(viskores::Id numberOfValues,
                                                 viskores::cont::DeviceAdapterId device,
                                                 viskores::cont::Token& token) const
  {
    this->Allocate(numberOfValues, viskores::CopyFlag::Off, token);
    return StorageType::CreateWritePortal(this->GetBuffers(), device, token);
  }
 
  VISKORES_CONT bool IsOnDevice(viskores::cont::DeviceAdapterId device) const
  {
    return detail::ArrayHandleIsOnDevice(this->Buffers, device);
  }
 
  VISKORES_CONT bool IsOnHost() const
  {
    return this->IsOnDevice(viskores::cont::DeviceAdapterTagUndefined{});
  }
 
  VISKORES_CONT void SyncControlArray() const
  {
    // Creating a host read portal will force the data to be synced to the host.
    this->ReadPortal();
  }
 
  VISKORES_CONT void Enqueue(const viskores::cont::Token& token) const
  {
    for (auto&& buffer : this->Buffers)
    {
      buffer.Enqueue(token);
    }
  }
 
  VISKORES_CONT void DeepCopyFrom(
    const viskores::cont::ArrayHandle<ValueType, StorageTag>& source) const
  {
    VISKORES_ASSERT(this->Buffers.size() == source.Buffers.size());
 
    for (std::size_t bufferIndex = 0; bufferIndex < this->Buffers.size(); ++bufferIndex)
    {
      this->Buffers[bufferIndex].DeepCopyFrom(source.Buffers[bufferIndex]);
    }
  }
 
  VISKORES_CONT const std::vector<viskores::cont::internal::Buffer>& GetBuffers() const
  {
    return this->Buffers;
  }
  VISKORES_CONT std::vector<viskores::cont::internal::Buffer>& GetBuffers()
  {
    return this->Buffers;
  }
 
private:
  mutable std::vector<viskores::cont::internal::Buffer> Buffers;
 
protected:
  VISKORES_CONT void SetBuffer(viskores::IdComponent index,
                               const viskores::cont::internal::Buffer& buffer)
  {
    this->Buffers[static_cast<std::size_t>(index)] = buffer;
  }
 
  VISKORES_CONT void SetBuffers(const std::vector<viskores::cont::internal::Buffer>& buffers)
  {
    this->Buffers = buffers;
  }
  VISKORES_CONT void SetBuffers(std::vector<viskores::cont::internal::Buffer>&& buffers)
  {
    this->Buffers = std::move(buffers);
  }
};
 
namespace detail
{
 
template <typename T>
VISKORES_NEVER_EXPORT VISKORES_CONT inline void printSummary_ArrayHandle_Value(
  const T& value,
  std::ostream& out,
  viskores::VecTraitsTagSingleComponent)
{
  out << value;
}
 
VISKORES_NEVER_EXPORT
VISKORES_CONT
inline void printSummary_ArrayHandle_Value(viskores::UInt8 value,
                                           std::ostream& out,
                                           viskores::VecTraitsTagSingleComponent)
{
  out << static_cast<int>(value);
}
 
VISKORES_NEVER_EXPORT
VISKORES_CONT
inline void printSummary_ArrayHandle_Value(viskores::Int8 value,
                                           std::ostream& out,
                                           viskores::VecTraitsTagSingleComponent)
{
  out << static_cast<int>(value);
}
 
template <typename T>
VISKORES_NEVER_EXPORT VISKORES_CONT inline void printSummary_ArrayHandle_Value(
  const T& value,
  std::ostream& out,
  viskores::VecTraitsTagMultipleComponents)
{
  using Traits = viskores::VecTraits<T>;
  using ComponentType = typename Traits::ComponentType;
  using IsVecOfVec = typename viskores::VecTraits<ComponentType>::HasMultipleComponents;
  viskores::IdComponent numComponents = Traits::GetNumberOfComponents(value);
  out << "(";
  printSummary_ArrayHandle_Value(Traits::GetComponent(value, 0), out, IsVecOfVec());
  for (viskores::IdComponent index = 1; index < numComponents; ++index)
  {
    out << ",";
    printSummary_ArrayHandle_Value(Traits::GetComponent(value, index), out, IsVecOfVec());
  }
  out << ")";
}
 
template <typename T1, typename T2>
VISKORES_NEVER_EXPORT VISKORES_CONT inline void printSummary_ArrayHandle_Value(
  const viskores::Pair<T1, T2>& value,
  std::ostream& out,
  viskores::VecTraitsTagSingleComponent)
{
  out << "{";
  printSummary_ArrayHandle_Value(
    value.first, out, typename viskores::VecTraits<T1>::HasMultipleComponents());
  out << ",";
  printSummary_ArrayHandle_Value(
    value.second, out, typename viskores::VecTraits<T2>::HasMultipleComponents());
  out << "}";
}
 
 
 
} // namespace detail
 
template <typename T, typename StorageT>
VISKORES_NEVER_EXPORT VISKORES_CONT inline void printSummary_ArrayHandle(
  const viskores::cont::ArrayHandle<T, StorageT>& array,
  std::ostream& out,
  bool full = false)
{
  using ArrayType = viskores::cont::ArrayHandle<T, StorageT>;
  using PortalType = typename ArrayType::ReadPortalType;
  using IsVec = typename viskores::VecTraits<T>::HasMultipleComponents;
 
  viskores::Id sz = array.GetNumberOfValues();
 
  out << "valueType=" << viskores::cont::TypeToString<T>()
      << " storageType=" << viskores::cont::TypeToString<StorageT>() << " " << sz
      << " values occupying " << (static_cast<size_t>(sz) * sizeof(T)) << " bytes [";
 
  PortalType portal = array.ReadPortal();
  if (full || sz <= 7)
  {
    for (viskores::Id i = 0; i < sz; i++)
    {
      detail::printSummary_ArrayHandle_Value(portal.Get(i), out, IsVec());
      if (i != (sz - 1))
      {
        out << " ";
      }
    }
  }
  else
  {
    detail::printSummary_ArrayHandle_Value(portal.Get(0), out, IsVec());
    out << " ";
    detail::printSummary_ArrayHandle_Value(portal.Get(1), out, IsVec());
    out << " ";
    detail::printSummary_ArrayHandle_Value(portal.Get(2), out, IsVec());
    out << " ... ";
    detail::printSummary_ArrayHandle_Value(portal.Get(sz - 3), out, IsVec());
    out << " ";
    detail::printSummary_ArrayHandle_Value(portal.Get(sz - 2), out, IsVec());
    out << " ";
    detail::printSummary_ArrayHandle_Value(portal.Get(sz - 1), out, IsVec());
  }
  out << "]\n";
}
 
namespace internal
{
 
namespace detail
{
 
VISKORES_CONT inline void CreateBuffersImpl(std::vector<viskores::cont::internal::Buffer>&);
template <typename T, typename S, typename... Args>
VISKORES_CONT inline void CreateBuffersImpl(std::vector<viskores::cont::internal::Buffer>& buffers,
                                            const viskores::cont::ArrayHandle<T, S>& array,
                                            const Args&... args);
template <typename... Args>
VISKORES_CONT inline void CreateBuffersImpl(std::vector<viskores::cont::internal::Buffer>& buffers,
                                            const viskores::cont::internal::Buffer& buffer,
                                            const Args&... args);
 
template <typename... Args>
VISKORES_CONT inline void CreateBuffersImpl(
  std::vector<viskores::cont::internal::Buffer>& buffers,
  const std::vector<viskores::cont::internal::Buffer>& addbuffs,
  const Args&... args);
template <typename Arg0, typename... Args>
VISKORES_CONT inline void CreateBuffersImpl(std::vector<viskores::cont::internal::Buffer>& buffers,
                                            const Arg0& arg0,
                                            const Args&... args);
 
VISKORES_CONT inline void CreateBuffersImpl(std::vector<viskores::cont::internal::Buffer>&)
{
  // Nothing left to add.
}
 
template <typename T, typename S, typename... Args>
VISKORES_CONT inline void CreateBuffersImpl(std::vector<viskores::cont::internal::Buffer>& buffers,
                                            const viskores::cont::ArrayHandle<T, S>& array,
                                            const Args&... args)
{
  CreateBuffersImpl(buffers, array.GetBuffers(), args...);
}
 
template <typename... Args>
VISKORES_CONT inline void CreateBuffersImpl(std::vector<viskores::cont::internal::Buffer>& buffers,
                                            const viskores::cont::internal::Buffer& buffer,
                                            const Args&... args)
{
  buffers.push_back(buffer);
  CreateBuffersImpl(buffers, args...);
}
 
template <typename... Args>
VISKORES_CONT inline void CreateBuffersImpl(
  std::vector<viskores::cont::internal::Buffer>& buffers,
  const std::vector<viskores::cont::internal::Buffer>& addbuffs,
  const Args&... args)
{
  buffers.insert(buffers.end(), addbuffs.begin(), addbuffs.end());
  CreateBuffersImpl(buffers, args...);
}
 
template <typename T, typename S, typename... Args>
VISKORES_CONT inline void CreateBuffersResolveArrays(
  std::vector<viskores::cont::internal::Buffer>& buffers,
  std::true_type,
  const viskores::cont::ArrayHandle<T, S>& array,
  const Args&... args)
{
  CreateBuffersImpl(buffers, array, args...);
}
 
template <typename MetaData, typename... Args>
VISKORES_CONT inline void CreateBuffersResolveArrays(
  std::vector<viskores::cont::internal::Buffer>& buffers,
  std::false_type,
  const MetaData& metadata,
  const Args&... args)
{
  viskores::cont::internal::Buffer buffer;
  buffer.SetMetaData(metadata);
  buffers.push_back(std::move(buffer));
  CreateBuffersImpl(buffers, args...);
}
 
template <typename Arg0, typename... Args>
VISKORES_CONT inline void CreateBuffersImpl(std::vector<viskores::cont::internal::Buffer>& buffers,
                                            const Arg0& arg0,
                                            const Args&... args)
{
  // If the argument is a subclass of ArrayHandle, the template resolution will pick this
  // overload instead of the correct ArrayHandle overload. To resolve that, check to see
  // if the type is an `ArrayHandle` and use `CreateBuffersResolveArrays` to choose the
  // right path.
  using IsArray = typename viskores::cont::internal::ArrayHandleCheck<Arg0>::type::type;
  CreateBuffersResolveArrays(buffers, IsArray{}, arg0, args...);
}
 
} // namespace detail
 
template <typename... Args>
VISKORES_CONT inline std::vector<viskores::cont::internal::Buffer> CreateBuffers(
  const Args&... args)
{
  std::vector<viskores::cont::internal::Buffer> buffers;
  buffers.reserve(sizeof...(args));
  detail::CreateBuffersImpl(buffers, args...);
  return buffers;
}
 
} // namespace internal
 
}
} //namespace viskores::cont
 
#ifndef viskores_cont_ArrayHandleBasic_h
#include <viskores/cont/ArrayHandleBasic.h>
#endif
 
#endif //viskores_cont_ArrayHandle_h