SimpleFunctors.h

Go to the documentation of this file.

#ifndef NPSTAT_SIMPLEFUNCTORS_HH_
#define NPSTAT_SIMPLEFUNCTORS_HH_
 
namespace npstat {
  template <typename Result>
  struct Functor0 {
    typedef Result result_type;
 
    inline virtual ~Functor0() {}
    virtual Result operator()() const = 0;
  };
 
  template <typename Result, typename Arg1>
  struct Functor1 {
    typedef Result result_type;
    typedef Arg1 first_argument_type;
 
    inline virtual ~Functor1() {}
    virtual Result operator()(const Arg1&) const = 0;
  };
 
  template <typename Result, typename Arg1, typename Arg2>
  struct Functor2 {
    typedef Result result_type;
    typedef Arg1 first_argument_type;
    typedef Arg2 second_argument_type;
 
    inline virtual ~Functor2() {}
    virtual Result operator()(const Arg1&, const Arg2&) const = 0;
  };
 
  template <typename Result, typename Arg1, typename Arg2, typename Arg3>
  struct Functor3 {
    typedef Result result_type;
    typedef Arg1 first_argument_type;
    typedef Arg2 second_argument_type;
    typedef Arg3 third_argument_type;
 
    inline virtual ~Functor3() {}
    virtual Result operator()(const Arg1&, const Arg2&, const Arg3&) const = 0;
  };
 
  template <typename Result>
  struct Same : public Functor1<Result, Result> {
    inline Result operator()(const Result& a) const override { return a; }
  };
 
  template <typename Result>
  struct SameRef : public Functor1<const Result&, Result> {
    inline const Result& operator()(const Result& a) const { return a; }
  };
 
  template <typename Result>
  struct DefaultConstructor0 : public Functor0<Result> {
    inline Result operator()() const { return Result(); }
  };
 
  template <typename Result, typename Arg1>
  struct DefaultConstructor1 : public Functor1<Result, Arg1> {
    inline Result operator()(const Arg1&) const { return Result(); }
  };
 
  template <typename Result, typename Arg1, typename Arg2>
  struct DefaultConstructor2 : public Functor2<Result, Arg1, Arg2> {
    inline Result operator()(const Arg1&, const Arg2&) const { return Result(); }
  };
 
  template <typename Result, typename Arg1, typename Arg2, typename Arg3>
  struct DefaultConstructor3 : public Functor3<Result, Arg1, Arg2, Arg3> {
    inline Result operator()(const Arg1&, const Arg2&, const Arg3&) const { return Result(); }
  };
 
  template <typename Result, typename Arg1, typename CastType>
  struct CastingCopyConstructor : public Functor1<Result, Arg1> {
    inline Result operator()(const Arg1& a) const { return Result(static_cast<CastType>(a)); }
  };
 
  template <typename Result>
  struct FcnFunctor0 : public Functor0<Result> {
    inline explicit FcnFunctor0(Result (*fcn)()) : fcn_(fcn) {}
 
    inline Result operator()() const { return fcn_(); }
 
    FcnFunctor0() = delete;
 
  private:
    Result (*fcn_)();
  };
 
  template <typename Result, typename Arg1>
  struct FcnFunctor1 : public Functor1<Result, Arg1> {
    inline explicit FcnFunctor1(Result (*fcn)(Arg1)) : fcn_(fcn) {}
 
    inline Result operator()(const Arg1& a) const { return fcn_(a); }
 
    FcnFunctor1() = delete;
 
  private:
    Result (*fcn_)(Arg1);
  };
 
  template <typename Result, typename Arg1, typename Arg2>
  struct FcnFunctor2 : public Functor2<Result, Arg1, Arg2> {
    inline explicit FcnFunctor2(Result (*fcn)(Arg1, Arg2)) : fcn_(fcn) {}
 
    inline Result operator()(const Arg1& x, const Arg2& y) const { return fcn_(x, y); }
 
    FcnFunctor2() = delete;
 
  private:
    Result (*fcn_)(Arg1, Arg2);
  };
 
  template <typename Result, typename Arg1, typename Arg2, typename Arg3>
  struct FcnFunctor3 : public Functor3<Result, Arg1, Arg2, Arg3> {
    inline explicit FcnFunctor3(Result (*fcn)(Arg1, Arg2, Arg3)) : fcn_(fcn) {}
 
    inline Result operator()(const Arg1& x, const Arg2& y, const Arg3& z) const { return fcn_(x, y, z); }
 
    FcnFunctor3() = delete;
 
  private:
    Result (*fcn_)(Arg1, Arg2, Arg3);
  };
 
  template <class Container, class Result = typename Container::value_type>
  struct Element1D : public Functor1<Result, Container> {
    inline explicit Element1D(const unsigned long index) : idx(index) {}
 
    inline Result operator()(const Container& c) const { return c[idx]; }
 
    Element1D() = delete;
 
  private:
    unsigned long idx;
  };
 
  template <class Container, class Result = typename Container::value_type>
  struct Element1DAt : public Functor1<Result, Container> {
    inline explicit Element1DAt(const unsigned long index) : idx(index) {}
 
    inline Result operator()(const Container& c) const { return c.at(idx); }
 
    Element1DAt() = delete;
 
  private:
    unsigned long idx;
  };
 
  template <typename T1, typename T2>
  struct assign_left {
    inline T1& operator()(T1& left, const T2& right) const { return left = right; }
  };
 
  template <typename T1, typename T2>
  struct assign_right {
    inline T2& operator()(const T1& left, T2& right) const { return right = left; }
  };
 
  template <typename T1, typename T2>
  struct pluseq_left {
    inline T1& operator()(T1& left, const T2& right) const { return left += right; }
  };
 
  template <typename T1, typename T2>
  struct pluseq_right {
    inline T2& operator()(const T1& left, T2& right) const { return right += left; }
  };
 
  template <typename T1, typename T2>
  struct addmul_left {
    inline explicit addmul_left(const double weight) : w_(weight) {}
 
    inline T1& operator()(T1& left, const T2& right) const { return left += w_ * right; }
 
    addmul_left() = delete;
 
  private:
    double w_;
  };
 
  template <typename T1, typename T2>
  struct addmul_right {
    inline explicit addmul_right(const double weight) : w_(weight) {}
 
    inline T1& operator()(T1& left, const T2& right) const { return right += w_ * left; }
 
    addmul_right() = delete;
 
  private:
    double w_;
  };
 
  template <typename T1, typename T2>
  struct minuseq_left {
    inline T1& operator()(T1& left, const T2& right) const { return left -= right; }
  };
 
  template <typename T1, typename T2>
  struct minuseq_right {
    inline T2& operator()(const T1& left, T2& right) const { return right -= left; }
  };
 
  template <typename T1, typename T2>
  struct multeq_left {
    inline T1& operator()(T1& left, const T2& right) const { return left *= right; }
  };
 
  template <typename T1, typename T2>
  struct multeq_right {
    inline T2& operator()(const T1& left, T2& right) const { return right *= left; }
  };
 
  template <typename T1, typename T2>
  struct diveq_left {
    inline T1& operator()(T1& left, const T2& right) const { return left /= right; }
  };
 
  template <typename T1, typename T2>
  struct diveq_right {
    inline T2& operator()(const T1& left, T2& right) const { return right /= left; }
  };
 
  template <typename T1, typename T2>
  struct diveq_left_0by0isC {
    inline diveq_left_0by0isC() : C(T1()), leftZero(T1()), rightZero(T2()) {}
    inline explicit diveq_left_0by0isC(const T1& value) : C(value), leftZero(T1()), rightZero(T2()) {}
 
    inline T1& operator()(T1& left, const T2& right) const {
      if (right == rightZero)
        if (left == leftZero) {
          left = C;
          return left;
        }
      return left /= right;
    }
 
  private:
    T1 C;
    T1 leftZero;
    T2 rightZero;
  };
 
  template <typename T1, typename T2>
  struct diveq_right_0by0isC {
    inline diveq_right_0by0isC() : C(T2()), leftZero(T1()), rightZero(T2()) {}
    inline explicit diveq_right_0by0isC(const T2& value) : C(value), leftZero(T1()), rightZero(T2()) {}
 
    inline T2& operator()(const T1& left, T2& right) const {
      if (left == leftZero)
        if (right == rightZero) {
          right = C;
          return right;
        }
      return right /= left;
    }
 
  private:
    T2 C;
    T1 leftZero;
    T2 rightZero;
  };
 
  template <typename T1, typename T2, typename T3 = T1>
  struct scast_assign_left {
    inline T1& operator()(T1& left, const T2& right) const { return left = static_cast<T3>(right); }
  };
 
  template <typename T1, typename T2, typename T3 = T2>
  struct scast_assign_right {
    inline T2& operator()(const T1& left, T2& right) const { return right = static_cast<T3>(left); }
  };
 
  template <typename T1, typename T2, typename T3 = T1>
  struct scast_pluseq_left {
    inline T1& operator()(T1& left, const T2& right) const { return left += static_cast<T3>(right); }
  };
 
  template <typename T1, typename T2, typename T3 = T2>
  struct scast_pluseq_right {
    inline T2& operator()(const T1& left, T2& right) const { return right += static_cast<T3>(left); }
  };
 
  template <typename T1, typename T2, typename T3 = T1>
  struct scast_minuseq_left {
    inline T1& operator()(T1& left, const T2& right) const { return left -= static_cast<T3>(right); }
  };
 
  template <typename T1, typename T2, typename T3 = T2>
  struct scast_minuseq_right {
    inline T2& operator()(const T1& left, T2& right) const { return right -= static_cast<T3>(left); }
  };
}  // namespace npstat
 
#endif  // NPSTAT_SIMPLEFUNCTORS_HH_