boost text stream

#include <boost/archive/text_iarchive.hpp>
#include <boost/archive/text_oarchive.hpp>
#include <boost/iostreams/stream.hpp>
#include <boost/iostreams/device/back_inserter.hpp>


#include <iostream>

struct Test
{
    int x;
    int y;
    int z;
};

namespace boost{
    namespace serialization{
        template<class Archive> void serialize(Archive & ar, Test & t, const unsigned int version){
            ar & t.x;
            ar & t.y;
            ar & t.z;
        }
    }
}
class output_stream
{
    std::string m_data;
    boost::iostreams::back_insert_device<std::string> m_inserter;
    boost::iostreams::stream<boost::iostreams::back_insert_device<std::string> > m_streamer;
    boost::archive::text_oarchive m_archive;

public:
    output_stream() : m_inserter(m_data), m_streamer(m_inserter), m_archive(m_streamer) { }

    const std::string& data() { m_streamer.flush();  return m_data; }

    template<typename T> boost::archive::text_oarchive& operator << (T& obj) {
        return (m_archive << obj);
    }
};

class input_stream
{
    boost::iostreams::basic_array_source<char> m_device;
    boost::iostreams::stream<boost::iostreams::basic_array_source<char> > m_stream;
    boost::archive::text_iarchive m_archive;

public:
    input_stream(const char *pData, size_t len) : m_device((const char *)pData, len), m_stream(m_device), m_archive(m_stream) { }

    input_stream(const std::string& data) : m_device((const char *)data.c_str(), data.length()), m_stream(m_device), m_archive(m_stream) { }
    template<typename T> boost::archive::text_iarchive& operator >> (T& obj){
        return (m_archive >> obj);
    }

};

int main(int argc, const char * argv[])
{
    Test t_1 = { 20, 40, 60 };
    Test t_2;

    output_stream o;
    o << t_1;

    input_stream i(o.data());
    i >> t_2;

    std::cout << t_2.x << ' ' << t_2.y << ' ' << t_2.z << std::endl;

    return 0;
}