FunctionInterface.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_internal_FunctionInterface_h
#define vtk_m_internal_FunctionInterface_h
 
#include <vtkm/Deprecated.h>
#include <vtkm/Types.h>
 
#include <vtkm/internal/FunctionInterfaceDetailPre.h>
#include <vtkm/internal/IndexTag.h>
 
#include <utility>
 
namespace vtkm
{
namespace internal
{
 
namespace detail
{
 
template <typename OriginalSignature, typename Transform>
struct FunctionInterfaceStaticTransformType;
 
 
} // namespace detail
 
template <typename FunctionSignature>
class FunctionInterface
{
  template <typename OtherSignature>
  friend class FunctionInterface;
 
public:
  using Signature = FunctionSignature;
 
  VTKM_SUPPRESS_EXEC_WARNINGS
  FunctionInterface()
    : Parameters()
  {
  }
 
  VTKM_SUPPRESS_EXEC_WARNINGS
  explicit FunctionInterface(const detail::ParameterContainer<FunctionSignature>& p)
    : Parameters(p)
  {
  }
 
  // the number of parameters as an integral constant
  using SigInfo = detail::FunctionSigInfo<FunctionSignature>;
  using ComponentSig = typename SigInfo::Components;
  using ParameterSig = typename SigInfo::Parameters;
 
  template <vtkm::IdComponent ParameterIndex>
  struct ParameterType
  {
    using type = typename detail::AtType<ParameterIndex, FunctionSignature>::type;
  };
 
  static constexpr vtkm::IdComponent ARITY = SigInfo::Arity;
 
  VTKM_EXEC_CONT
  vtkm::IdComponent GetArity() const { return ARITY; }
 
  template <typename Transform>
  struct StaticTransformType
  {
    using type = FunctionInterface<
      typename detail::FunctionInterfaceStaticTransformType<FunctionSignature, Transform>::type>;
  };
 
  template <typename Transform>
  VTKM_CONT typename StaticTransformType<Transform>::type StaticTransformCont(
    const Transform& transform)
  {
    using FuncIface = typename StaticTransformType<Transform>::type;
    using PC = detail::ParameterContainer<typename FuncIface::Signature>;
    return FuncIface{ detail::DoStaticTransformCont<PC>(transform, this->Parameters) };
  }
 
  detail::ParameterContainer<FunctionSignature> Parameters;
};
 
template <vtkm::IdComponent ParameterIndex, typename FunctionSignature>
VTKM_EXEC_CONT auto ParameterGet(const FunctionInterface<FunctionSignature>& fInterface)
  -> decltype(detail::ParameterGet(fInterface.Parameters,
                                   vtkm::internal::IndexTag<ParameterIndex>{}))
{
  return detail::ParameterGet(fInterface.Parameters, vtkm::internal::IndexTag<ParameterIndex>{});
}
 
 
//============================================================================
 
template <typename R, typename... Args>
FunctionInterface<R(Args...)> make_FunctionInterface(const Args&... args)
{
// MSVC will issue deprecation warnings if this templated method is instantiated with
// a deprecated class here even if the method is called from a section of code where
// deprecation warnings are suppressed. This is annoying behavior since this templated
// method has no control over what class it is used from. To get around it, we have to
// suppress all deprecation warnings here.
#ifdef VTKM_MSVC
  VTKM_DEPRECATED_SUPPRESS_BEGIN
#endif
  detail::ParameterContainer<R(Args...)> container = { args... };
  return FunctionInterface<R(Args...)>{ container };
#ifdef VTKM_MSVC
  VTKM_DEPRECATED_SUPPRESS_END
#endif
}
}
} // namespace vtkm::internal
 
#include <vtkm/internal/FunctionInterfaceDetailPost.h>
 
#endif //vtk_m_internal_FunctionInterface_h