#ifndef TTR_H
#define TTR_H

#include  <functional>
#include <type_traits>
#include    <iterator>

namespace detail {

    template<class ...>
    struct param_tester
    {
        using type = void;
    };

    template<class... Args>
    using void_t = typename param_tester<Args...>::type;

    namespace dispatch {

        using std::swap;

        template<class T, class X = T, std::size_t N = 0, class voider = void_t<>>
        struct has_member_swap : private std::false_type { };

        template<class T, class X>
        struct has_member_swap<T, X, 0,
            void_t<decltype(swap(std::declval<T&>(), std::declval<X&>()))>
        > : private std::integral_constant<bool,
            std::is_move_assignable<T>::value &&
            std::is_move_constructible<T>::value
        > { };

        template<class T, class X, std::size_t N>
        struct has_member_swap<T[N], X[N], N,
            void_t<decltype(swap(std::declval<T[N]&>(), std::declval<X[N]&>()))>
        > : private std::integral_constant<bool,
            std::is_move_assignable<T>::value &&
            std::is_move_constructible<T>::value
        > { };
    }

    template<class Iter>
    struct has_iterator
    {
        enum {
            value = std::is_copy_constructible<Iter>::value &&
                    std::is_copy_assignable<Iter>::value    &&
                    std::is_destructible<Iter>::value       &&
                    dispatch::has_member_swap<Iter>::value
        };
    };

    template<class It, class voider = void_t<>>
    struct is_iterator : private std::false_type { };

    template<class It>
    struct is_iterator<It,
        void_t
        <
        decltype(++std::declval<It&>()),
        decltype(--std::declval<It&>()),
        decltype(* std::declval<It&>()),
        decltype(std::ptrdiff_t(std::declval<It&>().operator[](std::declval<std::ptrdiff_t>()))),
        decltype(std::declval<It&>() +  std::declval<std::ptrdiff_t>()),
        decltype(std::declval<It&>() -  std::declval<std::ptrdiff_t>()),
        decltype(std::ptrdiff_t(std::declval<It&>() - std::declval<It const&>())),
        decltype(std::declval<It&>() += std::declval<std::ptrdiff_t>()),
        decltype(std::declval<It&>() -= std::declval<std::ptrdiff_t>()),
        decltype(std::declval<It&>() == std::declval<It const&>()),
        decltype(std::declval<It&>() =  std::declval<It const&>())
        >
    > : private std::integral_constant<bool,
        has_iterator<It>::value ||
        std::is_pointer<It>::value> { };

    template<class It>
    struct is_iterator<It*> : std::true_type { };

    template<class It>
    struct is_iterator<It const*> : std::true_type { };

    template<class It>
    struct is_iterator<It* volatile> : std::true_type { };

    template<class It>
    struct is_iterator<It const* volatile> : std::true_type { };

    template<class It>
    using is_iterator_t = typename is_iterator<It>::type;

    template<class It>
    using is_iterator_v = typename is_iterator<It>::value;
}
#endif