wrappers/function_wrappers.hh

// This file is a part of Catsfoot.
// Copyright (C) 2011  Uni Research
// Copyright (C) 2012  Valentin David
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Lesser Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU Lesser Public License for more details.
//
// You should have received a copy of the GNU Lesser Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.

#ifndef FUNCION_WRAPPERS_HH
# define FUNCION_WRAPPERS_HH

# include <functional>
# include <memory>
# include "../utils/call_with.hh"

namespace catsfoot {

  namespace details {
    template <typename T>
    struct member_wrapper;

    template <typename T, typename Ret, typename... Args>
    struct member_wrapper<Ret (T::*)(Args...)> {
    private:
      Ret (T::*f)(Args...);

    public:
      member_wrapper(Ret (T::*f)(Args...)): f(f) {}

      Ret operator()(T& t, Args&&... args...) const {
        return (t.*f)(std::forward<Args>(args)...);
      }
    };

    template <typename T, typename... Args>
    struct member_wrapper<void (T::*)(Args...)> {
    private:
      void (T::*f)(Args...);

    public:
      member_wrapper(void (T::*f)(Args...)): f(f) {}

      T operator()(T t, Args&&... args...) const {
        (t.*f)(std::forward<Args>(args)...);
        return t;
      }
    };

    template <typename T, typename Ret, typename... Args>
    struct member_wrapper<Ret (T::*)(Args...)const> {
    private:
      Ret (T::*f)(Args...)const;

    public:
      member_wrapper(Ret (T::*f)(Args...)const): f(f) {}

      Ret operator()(const T& t, Args&&... args...) const {
        return (t.*f)(std::forward<Args>(args)...);
      }
    };

  }

  template <typename T, typename Ret, typename... Args>
  std::function<Ret (T&, Args...)>
  wrap(Ret (T::*f)(Args...)) {
    return details::member_wrapper<Ret (T::*)(Args...)>(f);
  }

  template <typename T, typename... Args>
  std::function<T (T&, Args...)>
  wrap(void (T::*f)(Args...)) {
    return details::member_wrapper<void (T::*)(Args...)>(f);
  }

  template <typename T, typename Ret, typename... Args>
  std::function<Ret (const T&, Args...)>
  wrap(Ret (T::*f)(Args...) const) {
    return details::member_wrapper<Ret (T::*)(Args...)const>(f);
  }

  template <typename Ret, typename... Args>
  std::function<Ret (Args...)>
  wrap(Ret (*f)(Args...)) {
    return f;
  }

  template <typename T>
  std::function<T> wrap(const std::function<T>& f) {
    return f;
  }

  template <typename T>
  std::function<T> wrap(std::function<T>&& f) {
    return std::move(f);
  }

  template <typename T>
  struct wrapped {
    typedef decltype(wrap(std::declval<T>())) type;
  };

  template <typename... Args>
  struct disamb {
  private:
    template <typename Ret, typename T>
    struct member {
      typedef Ret (T::*type)(Args...);
    };

    template <typename Ret>
    struct fun {
      typedef Ret (*type)(Args...);
    };

  public:
    template <typename Ret, typename T>
    typename member<Ret,T>::type
    operator()(Ret (T::*f)(Args...)) const {
      return f;
    }

    template <typename Ret>
    typename fun<Ret>::type
    operator()(Ret (*f)(Args...)) const {
      return f;
    }
  };

  template <typename... Args>
  struct disamb_const {
  private:
    template <typename Ret, typename T>
    struct fun {
      typedef Ret (T::*const_type)(Args...) const;
    };

  public:
    template <typename Ret, typename T>
    typename fun<Ret,T>::const_type
    operator()(Ret (T::*f)(Args...) const) const {
      return f;
    }
  };

  template <typename T>
  struct constructor_wrap {
    template <typename... Args>
    T operator()(Args&&... args) const {
      return T(std::forward<Args>(args)...);
    }
  };

  namespace details {
    template <typename T>
    struct return_of {};

    template <typename T, typename... Args>
    struct return_of<T(Args...)> {
      typedef T type;
    };
  }

  template <typename T>
  std::function<T> constructor() {
    return constructor_wrap<typename details::return_of<T>::type>();
  }

  namespace details {
    template <typename T,
              typename = typename std::enable_if<!std::is_reference<T>::value>::type>
    T copy_if_non_const(T&& t) {
      return std::move(t);
    }

    template <typename T>
    T copy_if_non_const(T& t) {
      return T(t);
    }

    template <typename T>
    const T& copy_if_non_const(const T& t) {
      return t;
    }

    template <typename T>
    struct remove_side_effect_helper {
    private:
      T function;
    public:
      template <typename U,
                typename = typename
                std::enable_if
                <std::is_same<typename std::decay<U>::type,
                              T>::value>
                ::type>
      remove_side_effect_helper(U&& u): function(std::forward<U>(u)) {}

      remove_side_effect_helper(const remove_side_effect_helper& other)
        : function(other.function) {}
      remove_side_effect_helper(remove_side_effect_helper&& other)
        : function(std::move(other.function)) {}

      template <typename... Args,
                typename Ret =
                decltype(std::declval<T>()(std::declval<Args>()...))>
      Ret operator()(Args&&... args) const {
        std::tuple<decltype(copy_if_non_const(std::forward<Args>(args)))...>
          ret =
          std::tuple<decltype(copy_if_non_const(std::forward<Args>(args)))...>
          (copy_if_non_const(std::forward<Args>(args))...);
        return call_with(function, ret);
      }
    };

  }

  template <typename T>
  details::remove_side_effect_helper<typename std::decay<T>::type>
  remove_side_effect(T t) {
    return details::remove_side_effect_helper<typename std::decay<T>::type>(t);
  }

}

#endif