Storage.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_Storage_h
#define vtk_m_cont_Storage_h
 
#define VTKM_STORAGE_ERROR -2
#define VTKM_STORAGE_UNDEFINED -1
#define VTKM_STORAGE_BASIC 1
 
#ifndef VTKM_STORAGE
#define VTKM_STORAGE VTKM_STORAGE_BASIC
#endif
 
#include <vtkm/Flags.h>
#include <vtkm/StaticAssert.h>
 
#include <vtkm/internal/ArrayPortalDummy.h>
 
#include <vtkm/cont/ErrorBadAllocation.h>
#include <vtkm/cont/Logging.h>
#include <vtkm/cont/Token.h>
 
#include <vtkm/cont/internal/Buffer.h>
 
namespace vtkm
{
namespace cont
{
 
#ifdef VTKM_DOXYGEN_ONLY
struct VTKM_ALWAYS_EXPORT StorageTag___
{
};
#endif // VTKM_DOXYGEN_ONLY
 
namespace internal
{
 
struct UndefinedStorage
{
};
 
namespace detail
{
 
// This class should never be used. It is used as a placeholder for undefined
// Storage objects. If you get a compiler error involving this object, then it
// probably comes from trying to use an ArrayHandle with bad template
// arguments.
template <typename T>
struct UndefinedArrayPortal
{
  VTKM_STATIC_ASSERT(sizeof(T) == static_cast<size_t>(-1));
};
 
} // namespace detail
 
template <typename T, class StorageTag>
class Storage
#ifndef VTKM_DOXYGEN_ONLY
  : public vtkm::cont::internal::UndefinedStorage
{
public:
  using ReadPortalType = vtkm::cont::internal::detail::UndefinedArrayPortal<T>;
  using WritePortalType = vtkm::cont::internal::detail::UndefinedArrayPortal<T>;
};
#else  //VTKM_DOXYGEN_ONLY
{
public:
  using ValueType = T;
 
  using ReadPortalType = vtkm::internal::ArrayPortalBasicRead<T>;
 
  using WritePortalType = vtkm::internal::ArrayPortalBasicWrite<T>;
 
  VTKM_CONT static std::vector<vtkm::cont::internal::Buffer> CreateBuffers();
 
  VTKM_CONT static void ResizeBuffers(vtkm::Id numValues,
                                      const std::vector<vtkm::cont::internal::Buffer>& buffers,
                                      vtkm::CopyFlag preserve,
                                      vtkm::cont::Token& token);
 
  VTKM_CONT static vtkm::Id GetNumberOfValues(
    const std::vector<vtkm::cont::internal::Buffer>& buffers);
 
  VTKM_CONT static void Fill(const std::vector<vtkm::cont::internal::Buffer>& buffers,
                             const ValueType& fillValue,
                             vtkm::Id startIndex,
                             vtkm::Id endIndex,
                             vtkm::cont::Token& token);
 
  VTKM_CONT static ReadPortalType CreateReadPortal(
    const std::vector<vtkm::cont::internal::Buffer>& buffers,
    vtkm::cont::DeviceAdapterId device,
    vtkm::cont::Token& token);
 
  VTKM_CONT static WritePortalType CreateWritePortal(
    const std::vector<vtkm::cont::internal::Buffer>& buffers,
    vtkm::cont::DeviceAdapterId device,
    vtkm::cont::Token& token)
};
#endif // VTKM_DOXYGEN_ONLY
 
namespace detail
{
 
VTKM_CONT_EXPORT void StorageNoResizeImpl(vtkm::Id currentNumValues,
                                          vtkm::Id requestedNumValues,
                                          std::string storageTagName);
 
} // namespace detail
 
template <typename StorageType>
struct StorageTraits;
 
template <typename T, typename S>
struct StorageTraits<vtkm::cont::internal::Storage<T, S>>
{
  using ValueType = T;
  using Tag = S;
};
 
#define VTKM_STORAGE_NO_RESIZE                                                                  \
  VTKM_CONT static void ResizeBuffers(vtkm::Id numValues,                                       \
                                      const std::vector<vtkm::cont::internal::Buffer>& buffers, \
                                      vtkm::CopyFlag,                                           \
                                      vtkm::cont::Token&)                                       \
  {                                                                                             \
    vtkm::cont::internal::detail::StorageNoResizeImpl(                                          \
      GetNumberOfValues(buffers),                                                               \
      numValues,                                                                                \
      vtkm::cont::TypeToString<typename vtkm::cont::internal::StorageTraits<Storage>::Tag>());  \
  }                                                                                             \
  using ResizeBuffersEatComma = void
 
#define VTKM_STORAGE_NO_WRITE_PORTAL                                                           \
  using WritePortalType = vtkm::internal::ArrayPortalDummy<                                    \
    typename vtkm::cont::internal::StorageTraits<Storage>::ValueType>;                         \
  VTKM_CONT static void Fill(                                                                  \
    const std::vector<vtkm::cont::internal::Buffer>&,                                          \
    const typename vtkm::cont::internal::StorageTraits<Storage>::ValueType&,                   \
    vtkm::Id,                                                                                  \
    vtkm::Id,                                                                                  \
    vtkm::cont::Token&)                                                                        \
  {                                                                                            \
    throw vtkm::cont::ErrorBadAllocation(                                                      \
      "Cannot write to arrays with storage type of " +                                         \
      vtkm::cont::TypeToString<typename vtkm::cont::internal::StorageTraits<Storage>::Tag>()); \
  }                                                                                            \
  VTKM_CONT static WritePortalType CreateWritePortal(                                          \
    const std::vector<vtkm::cont::internal::Buffer>&,                                          \
    vtkm::cont::DeviceAdapterId,                                                               \
    vtkm::cont::Token&)                                                                        \
  {                                                                                            \
    throw vtkm::cont::ErrorBadAllocation(                                                      \
      "Cannot write to arrays with storage type of " +                                         \
      vtkm::cont::TypeToString<typename vtkm::cont::internal::StorageTraits<Storage>::Tag>()); \
  }                                                                                            \
  using CreateWritePortalEatComma = void
 
} // namespace internal
}
} // namespace vtkm::cont
 
#endif //vtk_m_cont_Storage_h