CastAndCall.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_CastAndCall_h
#define vtk_m_cont_CastAndCall_h
 
#include <vtkm/internal/IndexTag.h>
 
#include <vtkm/cont/DefaultTypes.h>
#include <vtkm/cont/UnknownArrayHandle.h>
 
#include <utility>
 
namespace vtkm
{
namespace cont
{
 
class CoordinateSystem;
class Field;
 
template <typename T, typename S>
class ArrayHandle;
 
template <vtkm::IdComponent>
class CellSetStructured;
template <typename T>
class CellSetSingleType;
template <typename T, typename S, typename U>
class CellSetExplicit;
template <typename T, typename S>
class CellSetPermutation;
class CellSetExtrude;
 
class UnknownCellSet;
 
template <typename DynamicObject, typename Functor, typename... Args>
void CastAndCall(const DynamicObject& dynamicObject, Functor&& f, Args&&... args)
{
  dynamicObject.CastAndCall(std::forward<Functor>(f), std::forward<Args>(args)...);
}
 
// actually implemented in vtkm/cont/CoordinateSystem.h
template <typename Functor, typename... Args>
void CastAndCall(const CoordinateSystem& coords, Functor&& f, Args&&... args);
 
// actually implemented in vtkm/cont/Field.h
template <typename Functor, typename... Args>
void CastAndCall(const vtkm::cont::Field& field, Functor&& f, Args&&... args);
 
// actually implemented in vtkm/cont/UnknownCellSet.h
template <typename Functor, typename... Args>
void CastAndCall(const vtkm::cont::UnknownCellSet& cellSet, Functor&& f, Args&&... args);
 
template <typename T, typename U, typename Functor, typename... Args>
void CastAndCall(const vtkm::cont::ArrayHandle<T, U>& handle, Functor&& f, Args&&... args)
{
  f(handle, std::forward<Args>(args)...);
}
 
// Implemented here to avoid circular dependencies.
template <typename Functor, typename... Args>
void CastAndCall(const UnknownArrayHandle& handle, Functor&& f, Args&&... args)
{
  handle.CastAndCallForTypes<VTKM_DEFAULT_TYPE_LIST, VTKM_DEFAULT_STORAGE_LIST>(
    std::forward<Functor>(f), std::forward<Args>(args)...);
}
 
template <vtkm::IdComponent Dim, typename Functor, typename... Args>
void CastAndCall(const vtkm::cont::CellSetStructured<Dim>& cellset, Functor&& f, Args&&... args)
{
  f(cellset, std::forward<Args>(args)...);
}
 
template <typename ConnectivityStorageTag, typename Functor, typename... Args>
void CastAndCall(const vtkm::cont::CellSetSingleType<ConnectivityStorageTag>& cellset,
                 Functor&& f,
                 Args&&... args)
{
  f(cellset, std::forward<Args>(args)...);
}
 
template <typename T, typename S, typename U, typename Functor, typename... Args>
void CastAndCall(const vtkm::cont::CellSetExplicit<T, S, U>& cellset, Functor&& f, Args&&... args)
{
  f(cellset, std::forward<Args>(args)...);
}
 
template <typename PermutationType, typename CellSetType, typename Functor, typename... Args>
void CastAndCall(const vtkm::cont::CellSetPermutation<PermutationType, CellSetType>& cellset,
                 Functor&& f,
                 Args&&... args)
{
  f(cellset, std::forward<Args>(args)...);
}
 
template <typename Functor, typename... Args>
void CastAndCall(const vtkm::cont::CellSetExtrude& cellset, Functor&& f, Args&&... args)
{
  f(cellset, std::forward<Args>(args)...);
}
 
template <typename... Args>
void ConditionalCastAndCall(std::true_type, Args&&... args)
{
  vtkm::cont::CastAndCall(std::forward<Args>(args)...);
}
 
template <typename... Args>
void ConditionalCastAndCall(std::false_type, Args&&...)
{
}
 
namespace internal
{
struct DynamicTransformTagCastAndCall
{
};
 
struct DynamicTransformTagStatic
{
};
 
template <typename T>
struct DynamicTransformTraits
{
  using DynamicTag = vtkm::cont::internal::DynamicTransformTagStatic;
};
 
// Implemented here to avoid circular dependencies.
template <>
struct DynamicTransformTraits<vtkm::cont::UnknownArrayHandle>
{
  using DynamicTag = vtkm::cont::internal::DynamicTransformTagCastAndCall;
};
 
} // namespace internal
 
}
} // namespace vtkm::cont
 
#endif //vtk_m_cont_CastAndCall_h