>     std::streamsize write(const char_type* s, std::streamsize n)
 >     {
mysocket_.write(s, n);
 >         return n;
 >     }

std::size_t Socket::read  (unsigned char buffer[], std::size_t size);
std::size_t Socket::write (unsigned char buffer[], std::size_t size);

enum TYPE    { ... };
enum SUBTYPE    { ... };
enum RESULT    { ... ;
enum STATE    { ... };

struct HEADER 
{
    TYPE    type;
    SUBTYPE    subtype;
    COMMAND    command;
    union 
    {
        unsigned value;
        RESULT     result;
        STATE     state;
    };

    HEADER () : type ((TYPE)0), subtype ((SUBTYPE)0),
        command ((COMMAND)0), value (0){}
    HEADER (TYPE wfType, SUBTYPE wfSubtype, COMMAND wfCommand)
        : type (wfType), subtype (wfSubtype), command (wfCommand), value (0){}
    ~HEADER() {}

};

namespace boost { namespace iostreams { namespace example {

template<typename Container>
class container_sink {
public:
    typedef typename Container::value_type  char_type;
    typedef sink_tag                        category;
    container_sink(Container& container) : container_(container) { }
    std::streamsize write(const char_type* s, std::streamsize n)
    {
        container_.insert(container_.end(), s, s + n);
        return n;
    }
    Container& container() { return container_; }
private:
    Container& container_;
};

} } } // End namespace boost::iostreams:example

template<typename Container>
class container_source {
public:
    typedef typename Container::value_type  char_type;
    typedef source_tag                      category;
    container_source(Container& container) 
        : container_(container), pos_(0)
        { }
    std::streamsize read(char_type* s, std::streamsize n)
    {
        using namespace std;
        streamsize amt = static_cast<streamsize>(container_.size() - pos_);
        streamsize result = (min)(n, amt);
        if (result != 0) {
            std::copy( container_.begin() + pos_, 
                       container_.begin() + pos_ + result, 
                       s );
            pos_ += result;
            return result;
        } else {
            return -1; // EOF
        }
    }
    Container& container() { return container_; }
private:
    typedef typename Container::size_type   size_type;
    Container&  container_;
    size_type   pos_;
};

} } } // End namespace boost::iostreams:example

typedef boost::iostreams::seekable_device_tag  category;

typedef std::vector <unsigned char> sbuffer;
typedef container_stream <sbuffer> sdevice;
typedef boost::iostreams::stream_buffer<sdevice> sstream;

namespase parser
{
    template <class T>
    inline void serialize (sbuffer& buffer, const T& rhs)
    {
        try
        {
            sstream stream (sdevice (buffer));
            std::ostream ostream (&stream);
            boost::archive::binary_oarchive archive (ostream);
            archive << BOOST_SERIALIZATION_NVP (rhs);
        }
        catch (std::exception& ex)
        {
             std::cerr << ex.what() << std::endl;
        }
    }
}

        sdevice dev(buffer);
        sstream stream (dev);
        std::ostream ostream (&stream);

: error C2664: 'std::basic_ostream<_Elem,_Traits>::basic_ostream(std::basic_streambuf<_Elem,_Traits> *,bool)' : cannot convert parameter 1 from 'parser::sstream *__w64 ' to 'std::basic_streambuf<_Elem,_Traits> *'
2>        with
2>        [
2>            _Elem=char,
2>            _Traits=std::char_traits<char>
2>        ]
2>        Types pointed to are unrelated; conversion requires reinterpret_cast, C-style cast or function-style cast
2>        .\xxx.cpp(104) : see reference to function template instantiation 'void

typedef std::vector <unsigned char> sbuffer;
typedef container_stream <sbuffer> sdevice;
typedef boost::iostreams::stream_buffer<sdevice> sstream;