mlTypedProcessing.h

Go to the documentation of this file.

/*************************************************************************************
**
** Copyright 2013, MeVis Medical Solutions AG
**
** The user may use this file in accordance with the license agreement provided with
** the Software or, alternatively, in accordance with the terms contained in a
** written agreement between the user and MeVis Medical Solutions AG.
**
** For further information use the contact form at https://www.mevislab.de/contact
**
**************************************************************************************/
 
#ifndef ML_TYPED_PROCESSING_H
#define ML_TYPED_PROCESSING_H
 
#include "mlInitSystemML.h"
 
#include "mlTypedHandlers.h"
 
ML_START_NAMESPACE
 
namespace internal
{

  template <class Processor, template <typename, int, typename> class VariableType>
  class SingleTypeCaller : public VariableType<SingleTypeCaller<Processor, VariableType>, 0, internal::EmptyType >
  {
  public:
    inline void process(int dataType, Processor& f)
    {
      _f = &f;
      internal::EmptyType args;
      this->template doSwitchingCode<internal::EmptyTypeTuple4, internal::EmptyType >(dataType, args);
    }
 
    template<typename Types>
    inline void doSwitchingWithLabel(const internal::EmptyType&, internal::EmptyType*)
    {
      _f->template process<typename Types::T0>();
    }
  private:
    Processor* _f;
  };

  template <class Processor,
    template <typename, int, typename> class VariableType1,
    template <typename, int, typename> class VariableType2>
  class DualTypeCaller :
    public VariableType1<DualTypeCaller<Processor, VariableType1, VariableType2>, 0, internal::EmptyType >,
    public VariableType2<DualTypeCaller<Processor, VariableType1, VariableType2>, 1, internal::EmptyType >
  {
  public:
    inline void process(int firstDataType, int secondDataType, Processor& f)
    {
      _f = &f;
      _secondDataType = secondDataType;
      internal::EmptyType args;
      static_cast<VariableType1<DualTypeCaller<Processor, VariableType1, VariableType2>, 0, internal::EmptyType > *>(this)->template doSwitchingCode<internal::EmptyTypeTuple4, internal::EmptyType >(firstDataType, args);
    }
 
    template<typename Types>
    inline void doSwitchingWithLabel(const internal::EmptyType& args, internal::EmptyType*)
    {
      static_cast<VariableType2<DualTypeCaller<Processor, VariableType1, VariableType2>, 1, internal::EmptyType > *>(this)->template doSwitchingCode<Types, internal::DispatchVariableType1Label >(_secondDataType, args);
    }
 
    template<typename Types>
    inline void doSwitchingWithLabel(const internal::EmptyType&, internal::DispatchVariableType1Label*)
    {
      _f->template process<typename Types::T0, typename Types::T1>();
    }
 
    private:
      Processor* _f;
      int _secondDataType;
  };
 
}
 
namespace TypedProcessing
{

 
  template <template <typename, int, typename> class VariableType, class Processor>
  static inline void call(MLDataType dataType, Processor& processor)
  {
    internal::SingleTypeCaller<Processor, VariableType> caller;
    caller.process(dataType, processor);
  }

  template <template <typename, int, typename> class VariableType1,
    template <typename, int, typename> class VariableType2,
  class Processor>
    static inline void call(MLDataType firstDataType, MLDataType secondDataType, Processor& processor)
  {
    internal::DualTypeCaller<Processor, VariableType1, VariableType2> caller;
    caller.process(firstDataType, secondDataType, processor);
  }
}
 
ML_END_NAMESPACE
 
#endif