#include <iostream>
#include <boost/range/algorithm.hpp>
#include <vector>

int main() 
{ 
    std::vector<int> vec = {1, 5, 3, 2, 1};
    boost::copy(boost::unique(boost::sort(vec)),
            std::ostream_iterator<int>(std::cout, ", "));
    
    return 0;
}

#include <iostream>
#include <vector>
#include <algorithm>
#include <type_traits>
#include <iterator>

#include <boost/range/algorithm.hpp>


#define RANGE(func, vec, ...) tmp_func(vec, [&]() { return func(vec.begin(), vec.end(), ##__VA_ARGS__); } )

template<typename T_vec, typename T_func>
auto tmp_func(T_vec &vec, T_func const& func) -> typename std::enable_if< std::is_void<decltype(func())>::value, T_vec& >::type 
{ func(); return vec; }

template<typename T_vec, typename T_func>
auto tmp_func(T_vec &vec, T_func const& func) -> typename std::enable_if< std::is_same<decltype(func()), decltype(vec.begin())>::value, T_vec& >::type 
{ auto it = func(); vec.resize(it - vec.begin()); return vec; }

template<typename T_vec, typename T_func>
auto tmp_func(T_vec &vec, T_func const& func) -> typename std::enable_if< !std::is_void<decltype(func())>::value && !std::is_same<decltype(func()), decltype(vec.begin())>::value, T_vec& >::type 
{ func(); return vec; }


int main() 
{ 
    std::vector<int> vec2 = {1, 5, 3, 2, 1, 1};    
    //boost::copy(boost::unique(boost::sort(vec)), std::ostream_iterator<int>(std::cout, ", "));
    RANGE(std::copy, RANGE(std::unique, RANGE(std::sort, vec2) ), std::ostream_iterator<int>(std::cout, ", "));

    return 0;
}

#include <iostream>
#include <boost/range/algorithm.hpp>
#include <vector>

int main() 
{ 
    std::vector<int> vec = {1, 5, 3, 2, 1};
    boost::copy(boost::unique(boost::sort(vec)),
            std::ostream_iterator<int>(std::cout, ", "));
    
    return 0;
}

    
    std::vector<int> vec = {1, 5, 3, 2, 1};
    std::sort(vec.begin(), vec.end());
    auto unique_end = std::unique(vec.begin(), vec.end());
    std::copy(vec.begin(), unique_end,
            std::ostream_iterator<int>(std::cout, ", "));

boost::sort(vec)->unique()->copy( std::ostream_iterator<int>(std::cout, ", ") );

boost::copy(boost::unique(boost::sort(vec)), std::ostream_iterator<int>(std::cout, ", "));

boost::sort(vec)->unique()->copy( std::ostream_iterator<int>(std::cout, ", ") );

boost::sort(vec)->unique()->copy( std::ostream_iterator<int>(std::cout, ", ") );

boost::copy(vec)->sort()->unique()->copy( std::ostream_iterator<int>(std::cout, ", ") );

ucs_vec->sort()->unique()->copy( std::ostream_iterator<int>(std::cout, ", ") );

#include <iostream>
#include <vector>
#include <algorithm>
#include <type_traits>
#include <iterator>
#include <memory>

#include <boost/range/algorithm.hpp>


#define RANGE(func, vec, ...) tmp_func(vec, [&]() { return func(vec.begin(), vec.end(), ##__VA_ARGS__); } )

template<typename T_vec, typename T_func>
auto tmp_func(T_vec &vec, T_func const& func) -> typename std::enable_if< std::is_void<decltype(func())>::value, T_vec& >::type 
{ func(); return vec; }

template<typename T_vec, typename T_func>
auto tmp_func(T_vec &vec, T_func const& func) -> typename std::enable_if< std::is_same<decltype(func()), decltype(vec.begin())>::value, T_vec& >::type 
{ auto it = func(); vec.resize(it - vec.begin()); return vec; }

template<typename T_vec, typename T_func>
auto tmp_func(T_vec &vec, T_func const& func) -> typename std::enable_if< !std::is_void<decltype(func())>::value && !std::is_same<decltype(func()), decltype(vec.begin())>::value, T_vec& >::type 
{ func(); return vec; }


// ------------------------------------------------------
template<typename T> struct ucs_wrapper_t;
template<typename T> ucs_wrapper_t<T> ucs_wrapper(T &ref) { return ucs_wrapper_t<T>(ref); }

template<typename T>
struct ucs_wrapper_t 
{
    struct algo_t {
        T &ref;
        algo_t(T &src) : ref(src) {}
        auto copy() { return ucs_wrapper_t<T>(T(ref)); }          
        template<typename ...Args> auto copy(Args ...args) { return ucs_wrapper(RANGE(std::copy, ref, args...)); }
        template<typename ...Args> auto unique(Args ...args) { return ucs_wrapper(RANGE(std::unique, ref, args...)); }
        template<typename ...Args> auto sort(Args ...args) { return ucs_wrapper(RANGE(std::sort, ref, args...)); }
    };    
    
    T copied;
    std::unique_ptr<algo_t> algo_ptr;
    ucs_wrapper_t(T &src) : algo_ptr(new algo_t(src)) {}
    ucs_wrapper_t(T &&src) : copied(src), algo_ptr(new algo_t(copied)) {}
    std::unique_ptr<algo_t>& operator->() { return algo_ptr; }
};


int main() 
{ 
    std::vector<int> vec2 = {1, 5, 3, 2, 1, 1};    
    //boost::copy(boost::unique(boost::sort(vec)), std::ostream_iterator<int>(std::cout, ", "));
    //RANGE(std::copy, RANGE(std::unique, RANGE(std::sort, vec2) ), std::ostream_iterator<int>(std::cout, ", "));
    
    auto ucs_vec = ucs_wrapper(vec2);
    
    // work with copied vector
    ucs_vec->copy()->sort()->unique()->copy( std::ostream_iterator<int>(std::cout, ", ") );
    
    std::cout << std::endl;
    for(auto &i : vec2) std::cout << i << ", "; 
   
    // work with source vector
    std::cout << std::endl;
    ucs_vec->sort()->unique()->copy( std::ostream_iterator<int>(std::cout, ", ") );
    
    std::cout << std::endl;
    for(auto &i : vec2) std::cout << i << ", ";    

    return 0;
}