#include <iostream>

#include <vector>

template<class _Ty>
struct scm_remove_reference
{
    typedef _Ty type;
};

template<class _Ty>
struct scm_remove_reference<_Ty&>
{	// remove reference
	typedef _Ty type;
};

template<class _Ty>
struct scm_remove_reference<_Ty&&>
{	// remove rvalue reference
	typedef _Ty type;
};


template <class T>
typename scm_remove_reference<T>::type&&
scm_move(T&& a)
{
    // works
    //return ((typename scm_remove_reference<T>::type&&)a);

    // works not
    return (a);
}

class rv_test
{
public:
    rv_test() {}
    virtual ~rv_test() {}

    rv_test(const rv_test& r)
        : _int_vec(r._int_vec)
    {
        std::cout << "default ctor" << std::endl;
    }
    rv_test(rv_test&& moved)
    {
        std::cout << "move ctor" << std::endl;
        *this = scm_move(moved);
        //swap(moved);
    }
    rv_test &operator=(const rv_test& r)
    {
        _int_vec = r._int_vec;
        return (*this);
    }
    rv_test &operator=(rv_test&& moved)
    {
        //rv_test tmp(scm_move(moved));
        //swap(tmp);
        swap(moved);
        return (*this);
    }
    void swap(rv_test& r)
    {
        _int_vec.swap(r._int_vec);
    }

    std::vector<int>    _int_vec;
};

rv_test test_storm(int a)
{
    rv_test t;
    t._int_vec.push_back(a);
    return (t);
}

int main()
{
    std::cout << "sick, sad world..." << std::endl;

    rv_test b;
    
    b = test_storm(666);

    return (0);
}