function.hh

Go to the documentation of this file.

// -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
// vi: set et ts=4 sw=2 sts=2:
#ifndef DUNE_FUNCTION_HH
#define DUNE_FUNCTION_HH
 
#include <utility>
 
#include "typetraits.hh"
 
namespace Dune {
 
  template <class Domain, class Range>
  class Function
  {
    typedef typename std::remove_cv<typename std::remove_reference< Domain >::type >::type RawDomainType;
    typedef typename std::remove_cv<typename std::remove_reference< Range >::type >::type RawRangeType;
 
  public:
 
    typedef RawRangeType RangeType;
 
    typedef RawDomainType DomainType;
 
    struct Traits
    {
      typedef RawDomainType DomainType;
      typedef RawRangeType RangeType;
    };
 
    void evaluate(const typename Traits::DomainType& x, typename Traits::RangeType& y) const;
  }; // end of Function class
 
 
 
  template <class DomainType, class RangeType>
  class VirtualFunction :
    public Function<const DomainType&, RangeType&>
  {
  public:
    typedef typename Function<const DomainType&, RangeType&>::Traits Traits;
 
    virtual ~VirtualFunction() {}
    virtual void evaluate(const typename Traits::DomainType& x, typename Traits::RangeType& y) const = 0;
  }; // end of VirtualFunction class
 
  namespace Impl {
 
  template<typename Domain, typename Range, typename F>
  class LambdaVirtualFunction final
    : public VirtualFunction<Domain, Range>
  {
  public:
    LambdaVirtualFunction(F&& f)
      : f_(std::move(f))
      {}
 
    LambdaVirtualFunction(const F& f)
      : f_(f)
      {}
 
    void evaluate(const Domain& x, Range& y) const override
      {
        y = f_(x);
      }
 
  private:
    const F f_;
  };
 
  } /* namespace Impl */
 
  template<typename Domain, typename Range, typename F>
  Impl::LambdaVirtualFunction< Domain, Range, std::decay_t<F> >
  makeVirtualFunction(F&& f)
  {
    return {std::forward<F>(f)};
  }
 
} // end namespace
 
#endif