wrappers/operators.hh

// This file is a part of Catsfoot.
// Copyright (C) 2011  Uni Research
//
// 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 OPERATORS_HH
# define OPERATORS_HH

# include "../type_traits/is_constructible.hh"

namespace catsfoot {


  struct op_eq {
    template <typename T, typename U,
              typename Ret = decltype(std::declval<T>() == std::declval<U>())>
    Ret operator()(T&& t, U&& u) const {
      return std::forward<T>(t) == std::forward<U>(u);
    }
  };

  struct op_neq {
    template <typename T, typename U,
              typename Ret = decltype(std::declval<T>() != std::declval<U>())>
    Ret operator()(T&& t, U&& u) const {
      return std::forward<T>(t) != std::forward<U>(u);
    }
  };

  struct op_plus {
    template <typename T, typename U,
              typename Ret = decltype(std::declval<T>() + std::declval<U>())>
    Ret operator()(T&& t, U&& u) const {
      return std::forward<T>(t) + std::forward<U>(u);
    }
  };

  struct op_times {
    template <typename T, typename U,
              typename Ret = decltype(std::declval<T>() * std::declval<U>())>
    Ret operator()(T&& t, U&& u) const {
      return std::forward<T>(t) * std::forward<U>(u);
    }
  };

  struct op_lsh {
    template <typename T, typename U,
              typename Ret = decltype(std::declval<T>() << std::declval<U>())>
    Ret operator()(T&& t, U&& u) const {
      return t << std::forward<U>(u);
    }
  };

  struct op_lt {
    template <typename T, typename U,
              typename Ret = decltype(std::declval<T>() < std::declval<U>())>
    Ret operator()(T&& t, U&& u) const {
      return t < std::forward<U>(u);
    }
  };

  struct op_inc {
    template <typename T,
              typename Ret = decltype(++std::declval<T>())>
    Ret operator()(T&& t) const {
      return ++std::forward<T>(t);
    }
  };

  struct op_post_inc {
    template <typename T,
              typename Ret = decltype(++std::declval<T>())>
    Ret operator()(T&& t) const {
      return ++std::forward<T>(t);
    }
  };

  struct op_star {
    template <typename T,
              typename Ret = decltype(*std::declval<T>())>
    Ret operator()(T&& t) const {
      return *std::forward<T>(t);
    }
  };


  namespace details {
    template <typename T, bool = is_constructible<T>::value>
    struct wrapped_constructor;

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

    template <typename T, typename... Args>
    struct wrapped_constructor<T(Args...), false> {
    };
  }

  template <typename T>
  struct wrapped_constructor: public details::wrapped_constructor<T> {
  };

}

#endif