Invocation.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_internal_Invocation_h
#define viskores_internal_Invocation_h
 
#include <viskores/Types.h>
#include <viskores/internal/FunctionInterface.h>
 
namespace viskores
{
namespace internal
{
 
template <typename ParameterInterface_,
          typename ControlInterface_,
          typename ExecutionInterface_,
          viskores::IdComponent InputDomainIndex_,
          typename OutputToInputMapType_ = viskores::internal::NullType,
          typename VisitArrayType_ = viskores::internal::NullType,
          typename ThreadToOutputMapType_ = viskores::internal::NullType,
          typename DeviceAdapterTag_ = viskores::internal::NullType>
struct Invocation
{
  using ParameterInterface = ParameterInterface_;
 
  using ControlInterface = ControlInterface_;
 
  using ExecutionInterface = ExecutionInterface_;
 
  static constexpr viskores::IdComponent InputDomainIndex = InputDomainIndex_;
 
  using OutputToInputMapType = OutputToInputMapType_;
 
  using VisitArrayType = VisitArrayType_;
 
  using ThreadToOutputMapType = ThreadToOutputMapType_;
 
  using DeviceAdapterTag = DeviceAdapterTag_;
 
  VISKORES_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>
  VISKORES_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 <viskores::IdComponent NewInputDomainIndex>
  struct ChangeInputDomainIndexType
  {
    using type = Invocation<ParameterInterface,
                            ControlInterface,
                            ExecutionInterface,
                            NewInputDomainIndex,
                            OutputToInputMapType,
                            VisitArrayType,
                            ThreadToOutputMapType,
                            DeviceAdapterTag>;
  };
 
  template <viskores::IdComponent NewInputDomainIndex>
  VISKORES_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>
  VISKORES_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>
  VISKORES_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>
  VISKORES_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>
  VISKORES_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;
 
  VISKORES_SUPPRESS_EXEC_WARNINGS
  VISKORES_EXEC_CONT
  const InputDomainType& GetInputDomain() const
  {
    return viskores::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 <viskores::IdComponent InputDomainIndex,
          typename ControlInterface,
          typename ExecutionInterface,
          typename ParameterInterface,
          typename OutputToInputMapType,
          typename VisitArrayType,
          typename ThreadToOutputMapType>
VISKORES_CONT viskores::internal::Invocation<ParameterInterface,
                                             ControlInterface,
                                             ExecutionInterface,
                                             InputDomainIndex,
                                             OutputToInputMapType,
                                             VisitArrayType,
                                             ThreadToOutputMapType>
make_Invocation(const ParameterInterface& params,
                ControlInterface,
                ExecutionInterface,
                OutputToInputMapType outputToInputMap,
                VisitArrayType visitArray,
                ThreadToOutputMapType threadToOutputMap)
{
  return viskores::internal::Invocation<ParameterInterface,
                                        ControlInterface,
                                        ExecutionInterface,
                                        InputDomainIndex,
                                        OutputToInputMapType,
                                        VisitArrayType,
                                        ThreadToOutputMapType>(
    params, outputToInputMap, visitArray, threadToOutputMap);
}
template <viskores::IdComponent InputDomainIndex,
          typename ControlInterface,
          typename ExecutionInterface,
          typename ParameterInterface>
VISKORES_CONT viskores::internal::
  Invocation<ParameterInterface, ControlInterface, ExecutionInterface, InputDomainIndex>
  make_Invocation(const ParameterInterface& params,
                  ControlInterface = ControlInterface(),
                  ExecutionInterface = ExecutionInterface())
{
  return viskores::internal::make_Invocation<InputDomainIndex>(params,
                                                               ControlInterface(),
                                                               ExecutionInterface(),
                                                               viskores::internal::NullType(),
                                                               viskores::internal::NullType(),
                                                               viskores::internal::NullType());
}
}
} // namespace viskores::internal
 
#endif //viskores_internal_Invocation_h