reorder by pattern

#include <iostream>
#include <iomanip>

#include <type_traits>
#include <utility>
#include <iterator>
#include <algorithm>
#include <deque>
#include <forward_list>

#include <cstdlib>
#include <cassert>

template< typename pattern_iterator, typename target_iterator >
void
pattern_sort(pattern_iterator pbeg, pattern_iterator pend, target_iterator beg, target_iterator end)
{
    using pattern_traits = std::iterator_traits< pattern_iterator >;
    using target_traits = std::iterator_traits< target_iterator >;
    static_assert(std::is_base_of< std::forward_iterator_tag, typename pattern_traits::iterator_category >{});
    static_assert(std::is_base_of< std::forward_iterator_tag, typename target_traits::iterator_category >{});
    struct iterator_adaptor
    {

        iterator_adaptor(typename pattern_traits::reference pattern)
            : p(&pattern)
        { ; }

        iterator_adaptor(iterator_adaptor &&)
            : p(nullptr)
        { ; }

        void
        operator = (iterator_adaptor && rhs) &
        {
            if (!!rhs.p) {
                std::swap(p, rhs.p);
                std::iter_swap(t, rhs.t);
            }
        }

        void
        operator = (typename target_traits::reference target) &
        {
            t = &target;
        }

        bool
        operator < (iterator_adaptor const & rhs) const
        {
            return (*p < *rhs.p);
        }

    private :

        typename pattern_traits::pointer p;
        typename target_traits::pointer t = nullptr;

    };
    std::deque< iterator_adaptor > proxy_(pbeg, pend);
    std::copy(beg, end, std::begin(proxy_));
    std::sort(std::begin(proxy_), std::end(proxy_));
}

int
main()
{
    std::forward_list< int > p{05, 04, 03, 02, 01};
    std::forward_list< int > t{50, 40, 30, 20, 10};
    std::copy(std::cbegin(p), std::cend(p), std::ostream_iterator< int >(std::cout, " ")); std::cout << std::endl;
    std::copy(std::cbegin(t), std::cend(t), std::ostream_iterator< int >(std::cout, " ")); std::cout << std::endl;
    pattern_sort(std::cbegin(p), std::cend(p), std::begin(t), std::end(t)); std::cout << std::endl;
    std::copy(std::cbegin(p), std::cend(p), std::ostream_iterator< int >(std::cout, " ")); std::cout << std::endl;
    std::copy(std::cbegin(t), std::cend(t), std::ostream_iterator< int >(std::cout, " ")); std::cout << std::endl;
    return EXIT_SUCCESS;
}