ArrayGetValues.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_ArrayGetValues_h
#define viskores_cont_ArrayGetValues_h
 
#include <viskores/cont/viskores_cont_export.h>
 
#include <viskores/cont/ArrayHandle.h>
#include <viskores/cont/UnknownArrayHandle.h>
 
#include <initializer_list>
#include <vector>
 
namespace viskores
{
namespace cont
{
 
// Work around circular dependancy with UnknownArrayHandle.
class UnknownArrayHandle;
 
namespace internal
{
 
VISKORES_CONT_EXPORT void ArrayGetValuesImpl(const viskores::cont::UnknownArrayHandle& ids,
                                             const viskores::cont::UnknownArrayHandle& data,
                                             const viskores::cont::UnknownArrayHandle& output,
                                             std::false_type extractComponentInefficient);
 
template <typename IdsArrayHandle, typename DataArrayHandle, typename OutputArrayHandle>
void ArrayGetValuesImpl(const IdsArrayHandle& ids,
                        const DataArrayHandle& data,
                        const OutputArrayHandle& output,
                        std::true_type viskoresNotUsed(extractComponentInefficient))
{
  // Fallback implementation. Using UnknownArrayHandle to extract the data would be more
  // inefficient than simply getting the ReadPortal (which could potentially copy everything
  // form device to host), so we do that here. The only other alternative would be to write
  // a custom worklet, but that would require a device compiler, and we are avoiding that for
  // this header.
  viskores::Id outputSize = ids.GetNumberOfValues();
  output.Allocate(outputSize);
  auto idsPortal = ids.ReadPortal();
  auto dataPortal = data.ReadPortal();
  auto outputPortal = output.WritePortal();
  for (viskores::Id index = 0; index < outputSize; ++index)
  {
    outputPortal.Set(index, dataPortal.Get(idsPortal.Get(index)));
  }
}
 
} // namespace internal
 
template <typename SIds, typename T, typename SData, typename SOut>
VISKORES_CONT void ArrayGetValues(const viskores::cont::ArrayHandle<viskores::Id, SIds>& ids,
                                  const viskores::cont::ArrayHandle<T, SData>& data,
                                  viskores::cont::ArrayHandle<T, SOut>& output)
{
  using DataArrayHandle = viskores::cont::ArrayHandle<T, SData>;
  using InefficientExtract =
    viskores::cont::internal::ArrayExtractComponentIsInefficient<DataArrayHandle>;
  internal::ArrayGetValuesImpl(ids, data, output, InefficientExtract{});
}
 
template <typename SIds, typename TIn, typename SData, typename TOut, typename SOut>
VISKORES_CONT void ArrayGetValues(
  const viskores::cont::ArrayHandle<viskores::Id, SIds>& ids,
  const viskores::cont::ArrayHandle<TOut, viskores::cont::StorageTagCast<TIn, SData>>& data,
  viskores::cont::ArrayHandle<TOut, SOut>& output)
{
  // In this specialization, we extract the values from the cast array's source array and
  // then cast and copy to output.
  viskores::cont::ArrayHandleBasic<TIn> tempOutput;
  viskores::cont::ArrayHandleCast<TOut, viskores::cont::ArrayHandle<TIn, SData>> castArray = data;
  ArrayGetValues(ids, castArray.GetSourceArray(), tempOutput);
 
  viskores::Id numExtracted = tempOutput.GetNumberOfValues();
  output.Allocate(numExtracted);
  auto inp = tempOutput.ReadPortal();
  auto outp = output.WritePortal();
  for (viskores::Id i = 0; i < numExtracted; ++i)
  {
    outp.Set(i, static_cast<TOut>(inp.Get(i)));
  }
}
 
template <typename SIds, typename T, typename SData, typename Alloc>
VISKORES_CONT void ArrayGetValues(const viskores::cont::ArrayHandle<viskores::Id, SIds>& ids,
                                  const viskores::cont::ArrayHandle<T, SData>& data,
                                  std::vector<T, Alloc>& output)
{
  const std::size_t numVals = static_cast<std::size_t>(ids.GetNumberOfValues());
 
  // Allocate the vector and toss its data pointer into the array handle.
  output.resize(numVals);
  auto result = viskores::cont::make_ArrayHandle(output, viskores::CopyFlag::Off);
  viskores::cont::ArrayGetValues(ids, data, result);
  // Make sure to pull the data back to control before we dealloc the handle
  // that wraps the vec memory:
  result.SyncControlArray();
}
 
template <typename SIds, typename T, typename SData>
VISKORES_CONT std::vector<T> ArrayGetValues(
  const viskores::cont::ArrayHandle<viskores::Id, SIds>& ids,
  const viskores::cont::ArrayHandle<T, SData>& data)
{
  std::vector<T> result;
  viskores::cont::ArrayGetValues(ids, data, result);
  return result;
}
 
template <typename T, typename Alloc, typename SData, typename SOut>
VISKORES_CONT void ArrayGetValues(const std::vector<viskores::Id, Alloc>& ids,
                                  const viskores::cont::ArrayHandle<T, SData>& data,
                                  viskores::cont::ArrayHandle<T, SOut>& output)
{
  const auto idsAH = viskores::cont::make_ArrayHandle(ids, viskores::CopyFlag::Off);
  ArrayGetValues(idsAH, data, output);
}
 
template <typename T, typename AllocId, typename SData, typename AllocOut>
VISKORES_CONT void ArrayGetValues(const std::vector<viskores::Id, AllocId>& ids,
                                  const viskores::cont::ArrayHandle<T, SData>& data,
                                  std::vector<T, AllocOut>& output)
{
  const auto idsAH = viskores::cont::make_ArrayHandle(ids, viskores::CopyFlag::Off);
  ArrayGetValues(idsAH, data, output);
}
 
template <typename T, typename Alloc, typename SData>
VISKORES_CONT std::vector<T> ArrayGetValues(const std::vector<viskores::Id, Alloc>& ids,
                                            const viskores::cont::ArrayHandle<T, SData>& data)
{
  const auto idsAH = viskores::cont::make_ArrayHandle(ids, viskores::CopyFlag::Off);
  return ArrayGetValues(idsAH, data);
}
 
template <typename T, typename SData, typename SOut>
VISKORES_CONT void ArrayGetValues(const std::initializer_list<viskores::Id>& ids,
                                  const viskores::cont::ArrayHandle<T, SData>& data,
                                  viskores::cont::ArrayHandle<T, SOut>& output)
{
  const auto idsAH = viskores::cont::make_ArrayHandle(
    ids.begin(), static_cast<viskores::Id>(ids.size()), viskores::CopyFlag::Off);
  ArrayGetValues(idsAH, data, output);
}
 
template <typename T, typename SData, typename Alloc>
VISKORES_CONT void ArrayGetValues(const std::initializer_list<viskores::Id>& ids,
                                  const viskores::cont::ArrayHandle<T, SData>& data,
                                  std::vector<T, Alloc>& output)
{
  const auto idsAH = viskores::cont::make_ArrayHandle(
    ids.begin(), static_cast<viskores::Id>(ids.size()), viskores::CopyFlag::Off);
  ArrayGetValues(idsAH, data, output);
}
template <typename T, typename SData>
VISKORES_CONT std::vector<T> ArrayGetValues(const std::initializer_list<viskores::Id>& ids,
                                            const viskores::cont::ArrayHandle<T, SData>& data)
{
  const auto idsAH = viskores::cont::make_ArrayHandle(
    ids.begin(), static_cast<viskores::Id>(ids.size()), viskores::CopyFlag::Off);
  return ArrayGetValues(idsAH, data);
}
 
template <typename T, typename SData, typename SOut>
VISKORES_CONT void ArrayGetValues(const viskores::Id* ids,
                                  const viskores::Id numIds,
                                  const viskores::cont::ArrayHandle<T, SData>& data,
                                  viskores::cont::ArrayHandle<T, SOut>& output)
{
  const auto idsAH = viskores::cont::make_ArrayHandle(ids, numIds, viskores::CopyFlag::Off);
  ArrayGetValues(idsAH, data, output);
}
 
template <typename T, typename SData, typename Alloc>
VISKORES_CONT void ArrayGetValues(const viskores::Id* ids,
                                  const viskores::Id numIds,
                                  const viskores::cont::ArrayHandle<T, SData>& data,
                                  std::vector<T, Alloc>& output)
{
  const auto idsAH = viskores::cont::make_ArrayHandle(ids, numIds, viskores::CopyFlag::Off);
  ArrayGetValues(idsAH, data, output);
}
template <typename T, typename SData>
VISKORES_CONT std::vector<T> ArrayGetValues(const viskores::Id* ids,
                                            const viskores::Id numIds,
                                            const viskores::cont::ArrayHandle<T, SData>& data)
{
  const auto idsAH = viskores::cont::make_ArrayHandle(ids, numIds, viskores::CopyFlag::Off);
  return ArrayGetValues(idsAH, data);
}
 
template <typename T, typename S>
VISKORES_CONT T ArrayGetValue(viskores::Id id, const viskores::cont::ArrayHandle<T, S>& data)
{
  const auto idAH = viskores::cont::make_ArrayHandle(&id, 1, viskores::CopyFlag::Off);
  auto result = viskores::cont::ArrayGetValues(idAH, data);
  return result[0];
}
 
template <typename T, typename S>
VISKORES_CONT void ArrayGetValue(viskores::Id id,
                                 const viskores::cont::ArrayHandle<T, S>& data,
                                 T& val)
{
  val = ArrayGetValue(id, data);
}
}
} // namespace viskores::cont
 
#endif //viskores_cont_ArrayGetValues_h