Invocation.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_Invocation_h
#define vtk_m_internal_Invocation_h
 
#include <vtkm/Types.h>
#include <vtkm/internal/FunctionInterface.h>
 
namespace vtkm
{
namespace internal
{
 
template <typename ParameterInterface_,
          typename ControlInterface_,
          typename ExecutionInterface_,
          vtkm::IdComponent InputDomainIndex_,
          typename OutputToInputMapType_ = vtkm::internal::NullType,
          typename VisitArrayType_ = vtkm::internal::NullType,
          typename ThreadToOutputMapType_ = vtkm::internal::NullType,
          typename DeviceAdapterTag_ = vtkm::internal::NullType>
struct Invocation
{
  using ParameterInterface = ParameterInterface_;
 
  using ControlInterface = ControlInterface_;
 
  using ExecutionInterface = ExecutionInterface_;
 
  static constexpr vtkm::IdComponent InputDomainIndex = InputDomainIndex_;
 
  using OutputToInputMapType = OutputToInputMapType_;
 
  using VisitArrayType = VisitArrayType_;
 
  using ThreadToOutputMapType = ThreadToOutputMapType_;
 
  using DeviceAdapterTag = DeviceAdapterTag_;
 
  VTKM_CONT
  Invocation(const ParameterInterface& parameters,
             OutputToInputMapType outputToInputMap = OutputToInputMapType(),
             VisitArrayType visitArray = VisitArrayType(),
             ThreadToOutputMapType threadToOutputMap = ThreadToOutputMapType())
    : Parameters(parameters)
    , OutputToInputMap(outputToInputMap)
    , VisitArray(visitArray)
    , ThreadToOutputMap(threadToOutputMap)
  {
  }
 
  Invocation(const Invocation&) = default;
 
  template <typename NewParameterInterface>
  struct ChangeParametersType
  {
    using type = Invocation<NewParameterInterface,
                            ControlInterface,
                            ExecutionInterface,
                            InputDomainIndex,
                            OutputToInputMapType,
                            VisitArrayType,
                            ThreadToOutputMapType,
                            DeviceAdapterTag>;
  };
 
  template <typename NewParameterInterface>
  VTKM_CONT typename ChangeParametersType<NewParameterInterface>::type ChangeParameters(
    const NewParameterInterface& newParameters) const
  {
    return typename ChangeParametersType<NewParameterInterface>::type(
      newParameters, this->OutputToInputMap, this->VisitArray, this->ThreadToOutputMap);
  }
 
  template <typename NewControlInterface>
  struct ChangeControlInterfaceType
  {
    using type = Invocation<ParameterInterface,
                            NewControlInterface,
                            ExecutionInterface,
                            InputDomainIndex,
                            OutputToInputMapType,
                            VisitArrayType,
                            ThreadToOutputMapType,
                            DeviceAdapterTag>;
  };
 
  template <typename NewControlInterface>
  typename ChangeControlInterfaceType<NewControlInterface>::type ChangeControlInterface(
    NewControlInterface) const
  {
    return typename ChangeControlInterfaceType<NewControlInterface>::type(
      this->Parameters, this->OutputToInputMap, this->VisitArray, this->ThreadToOutputMap);
  }
 
  template <typename NewExecutionInterface>
  struct ChangeExecutionInterfaceType
  {
    using type = Invocation<ParameterInterface,
                            NewExecutionInterface,
                            ExecutionInterface,
                            InputDomainIndex,
                            OutputToInputMapType,
                            VisitArrayType,
                            ThreadToOutputMapType,
                            DeviceAdapterTag>;
  };
 
  template <typename NewExecutionInterface>
  typename ChangeExecutionInterfaceType<NewExecutionInterface>::type ChangeExecutionInterface(
    NewExecutionInterface) const
  {
    return typename ChangeExecutionInterfaceType<NewExecutionInterface>::type(
      this->Parameters, this->OutputToInputMap, this->VisitArray, this->ThreadToOutputMap);
  }
 
  template <vtkm::IdComponent NewInputDomainIndex>
  struct ChangeInputDomainIndexType
  {
    using type = Invocation<ParameterInterface,
                            ControlInterface,
                            ExecutionInterface,
                            NewInputDomainIndex,
                            OutputToInputMapType,
                            VisitArrayType,
                            ThreadToOutputMapType,
                            DeviceAdapterTag>;
  };
 
  template <vtkm::IdComponent NewInputDomainIndex>
  VTKM_EXEC_CONT typename ChangeInputDomainIndexType<NewInputDomainIndex>::type
  ChangeInputDomainIndex() const
  {
    return typename ChangeInputDomainIndexType<NewInputDomainIndex>::type(
      this->Parameters, this->OutputToInputMap, this->VisitArray, this->ThreadToOutputMap);
  }
 
  template <typename NewOutputToInputMapType>
  struct ChangeOutputToInputMapType
  {
    using type = Invocation<ParameterInterface,
                            ControlInterface,
                            ExecutionInterface,
                            InputDomainIndex,
                            NewOutputToInputMapType,
                            VisitArrayType,
                            ThreadToOutputMapType,
                            DeviceAdapterTag>;
  };
 
  template <typename NewOutputToInputMapType>
  VTKM_CONT typename ChangeOutputToInputMapType<NewOutputToInputMapType>::type
  ChangeOutputToInputMap(NewOutputToInputMapType newOutputToInputMap) const
  {
    return typename ChangeOutputToInputMapType<NewOutputToInputMapType>::type(
      this->Parameters, newOutputToInputMap, this->VisitArray, this->ThreadToOutputMap);
  }
 
  template <typename NewVisitArrayType>
  struct ChangeVisitArrayType
  {
    using type = Invocation<ParameterInterface,
                            ControlInterface,
                            ExecutionInterface,
                            InputDomainIndex,
                            OutputToInputMapType,
                            NewVisitArrayType,
                            ThreadToOutputMapType,
                            DeviceAdapterTag>;
  };
 
  template <typename NewVisitArrayType>
  VTKM_CONT typename ChangeVisitArrayType<NewVisitArrayType>::type ChangeVisitArray(
    NewVisitArrayType newVisitArray) const
  {
    return typename ChangeVisitArrayType<NewVisitArrayType>::type(
      this->Parameters, this->OutputToInputMap, newVisitArray, this->ThreadToOutputMap);
  }
 
  template <typename NewThreadToOutputMapType>
  struct ChangeThreadToOutputMapType
  {
    using type = Invocation<ParameterInterface,
                            ControlInterface,
                            ExecutionInterface,
                            InputDomainIndex,
                            OutputToInputMapType,
                            VisitArrayType,
                            NewThreadToOutputMapType,
                            DeviceAdapterTag>;
  };
 
  template <typename NewThreadToOutputMapType>
  VTKM_CONT typename ChangeThreadToOutputMapType<NewThreadToOutputMapType>::type
  ChangeThreadToOutputMap(NewThreadToOutputMapType newThreadToOutputMap) const
  {
    return typename ChangeThreadToOutputMapType<NewThreadToOutputMapType>::type(
      this->Parameters, this->OutputToInputMap, this->VisitArray, newThreadToOutputMap);
  }
 
  template <typename NewDeviceAdapterTag>
  struct ChangeDeviceAdapterTagType
  {
    using type = Invocation<ParameterInterface,
                            ControlInterface,
                            ExecutionInterface,
                            InputDomainIndex,
                            OutputToInputMapType,
                            VisitArrayType,
                            ThreadToOutputMapType,
                            NewDeviceAdapterTag>;
  };
 
  template <typename NewDeviceAdapterTag>
  VTKM_CONT typename ChangeDeviceAdapterTagType<NewDeviceAdapterTag>::type ChangeDeviceAdapterTag(
    NewDeviceAdapterTag) const
  {
    return typename ChangeDeviceAdapterTagType<NewDeviceAdapterTag>::type(
      this->Parameters, this->OutputToInputMap, this->VisitArray, this->ThreadToOutputMap);
  }
 
  using InputDomainType =
    typename ParameterInterface::template ParameterType<InputDomainIndex>::type;
 
  using InputDomainTag = typename ControlInterface::template ParameterType<InputDomainIndex>::type;
 
  VTKM_SUPPRESS_EXEC_WARNINGS
  VTKM_EXEC_CONT
  const InputDomainType& GetInputDomain() const
  {
    return vtkm::internal::ParameterGet<InputDomainIndex>(this->Parameters);
  }
 
  ParameterInterface Parameters;
  OutputToInputMapType OutputToInputMap;
  VisitArrayType VisitArray;
  ThreadToOutputMapType ThreadToOutputMap;
 
private:
  // Do not allow assignment of one Invocation to another. It is too expensive.
  void operator=(const Invocation<ParameterInterface,
                                  ControlInterface,
                                  ExecutionInterface,
                                  InputDomainIndex,
                                  OutputToInputMapType,
                                  VisitArrayType,
                                  ThreadToOutputMapType,
                                  DeviceAdapterTag>&) = delete;
};
 
template <vtkm::IdComponent InputDomainIndex,
          typename ControlInterface,
          typename ExecutionInterface,
          typename ParameterInterface,
          typename OutputToInputMapType,
          typename VisitArrayType,
          typename ThreadToOutputMapType>
VTKM_CONT vtkm::internal::Invocation<ParameterInterface,
                                     ControlInterface,
                                     ExecutionInterface,
                                     InputDomainIndex,
                                     OutputToInputMapType,
                                     VisitArrayType,
                                     ThreadToOutputMapType>
make_Invocation(const ParameterInterface& params,
                ControlInterface,
                ExecutionInterface,
                OutputToInputMapType outputToInputMap,
                VisitArrayType visitArray,
                ThreadToOutputMapType threadToOutputMap)
{
  return vtkm::internal::Invocation<ParameterInterface,
                                    ControlInterface,
                                    ExecutionInterface,
                                    InputDomainIndex,
                                    OutputToInputMapType,
                                    VisitArrayType,
                                    ThreadToOutputMapType>(
    params, outputToInputMap, visitArray, threadToOutputMap);
}
template <vtkm::IdComponent InputDomainIndex,
          typename ControlInterface,
          typename ExecutionInterface,
          typename ParameterInterface>
VTKM_CONT vtkm::internal::
  Invocation<ParameterInterface, ControlInterface, ExecutionInterface, InputDomainIndex>
  make_Invocation(const ParameterInterface& params,
                  ControlInterface = ControlInterface(),
                  ExecutionInterface = ExecutionInterface())
{
  return vtkm::internal::make_Invocation<InputDomainIndex>(params,
                                                           ControlInterface(),
                                                           ExecutionInterface(),
                                                           vtkm::internal::NullType(),
                                                           vtkm::internal::NullType(),
                                                           vtkm::internal::NullType());
}
}
} // namespace vtkm::internal
 
#endif //vtk_m_internal_Invocation_h