template<typename Container>
class rcontainer {
private:
    typedef typename Container::size_type   size_type;
    const Container&  m_container;
    size_type   m_index;

public:
    typedef typename Container::value_type    char_type;
    typedef boost::iostreams::source_tag    category;

    rcontainer (const Container& container) : m_container(container), m_index(0) { }
    ~rcontainer () { }

    std::streamsize read (char_type* value, std::streamsize size)
    {
        std::streamsize delta = static_cast<std::streamsize> (
            m_container.size() - m_index
        );

        std::streamsize result = std::min<std::streamsize> (size, delta);
        if (!result) return -1;

        std::copy (
            m_container.begin() + m_index,
            m_container.begin() + m_index + result, value
        );
        m_index += result;
        return result;
    }
};
/* -------------------------------------------------------------------------- */
template<typename Container>
class wcontainer {
private:
    typedef typename Container::size_type   size_type;
    Container&  m_container;
    size_type   m_index;

public:
    typedef typename Container::value_type    char_type;
    typedef boost::iostreams::sink_tag        category;

    wcontainer (Container& container)  : m_container(container), m_index(0) { }
    ~wcontainer () { }

    std::streamsize write (const char_type* value, std::streamsize size)
    {
        m_container.insert(m_container.end(), value, value + size);
        return size;
    }
};

typedef std::vector<unsigned char> sbuffer;

typedef std::vector<char> sbuffer;

namespace parser
{
    /* ---------------------------------------------------------------------- */
    typedef std::vector<unsigned char> sbuffer;
    typedef rcontainer <sbuffer> rdevice;
    typedef wcontainer <sbuffer> wdevice;
    /* ---------------------------------------------------------------------- */
    template <class T>
    inline void serialize (sbuffer& buffer, const T& rhs)
    {
        try
        {
            namespace bio = boost::iostreams;

            wdevice device (buffer);
            bio::stream_buffer<wdevice> stream (device);
            std::basic_ostream <unsigned char> ostream (&stream);
            //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;
        }
    }
    /* ---------------------------------------------------------------------- */
    template <class T>
    inline void deserialize (const sbuffer& buffer, T& rhs)
    {
        try
        {
            namespace bio = boost::iostreams;

            rdevice device (buffer);
            bio::stream_buffer<rdevice> stream (device);
            std::istream istream (&stream);


            boost::archive::binary_iarchive archive (istream);
            archive >> BOOST_SERIALIZATION_NVP (rhs);
        }
        catch (std::exception& ex)
        {
            std::cerr << ex.what() << std::endl;
        }
    }
    /* ---------------------------------------------------------------------- */
}

class RPCLIB_API rpcOutStreamBufDev: public rpcStreamBaseDevice

{

public:

rpcOutStreamBufDev(rpcStreamData&,rpcOutStreamData&);

virtual ~rpcOutStreamBufDev();

struct category : boost::iostreams::sink_tag {};


std::streamsize write(const char_type* s, std::streamsize n);

void FinishRPC();

private:

std::streamsize DoWrite(const char_type* s, std::streamsize n);

rpcOutStreamData* outStreamData_;

};

typedef boost::iostreams::stream_buffer<rpcOutStreamBufDev> rpcOutStreamBuffer;

rpcOutStreamData outData;

rpcOutStreamBufDev outDevice(commonDataForOut,outData);

rpcOutStreamBuffer outStreamBuf(outDevice, 0x10000);

std::ostream s(&outStreamBuf);

#include <algorithm>                       // copy, min
#include <iosfwd>                          // streamsize
#include <boost/iostreams/categories.hpp>  // sink_tag

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

 >     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;

// SockStreamBuf.h

#ifndef CSockStramBuf__H
#define CSockStramBuf__H

#include <iosfwd>
#include <Winsock2.h>
#include <string>

template
    <
    class Elem,
    class Tr = std::char_traits< Elem >
    >
class CSockStreamBuf : public std::basic_streambuf< Elem, Tr >
{
public:
    CSockStreamBuf( const std::string& sAddr, int iPort );
    virtual ~CSockStreamBuf();

    int GetState() const;

    //Implementing basic_streambuf
    int_type pbackfail( int_type =  Tr::eof() );
    std::streamsize xsputn( const char_type *buf, std::streamsize iCount );
    std::streamsize xsgetn( char_type *buf,    std::streamsize iCount );
    std::streamsize _Xsgetn_s( char_type *buf,    size_t iSize, std::streamsize iCount    );




private:
    int Connect( const std::string& sAddr, int iPort );
    bool Disconnect();

    std::string m_sAddr;
    int m_iPort;
    SOCKET m_Sock;
    int m_iState;
};

template< class Elem, class Tr >
typename CSockStreamBuf<Elem,Tr>::int_type CSockStreamBuf<Elem,Tr>::pbackfail(int_type /* = Tr::eof()  */)
{
    return Tr::eof();
}

template< class Elem, class Tr >
std::streamsize CSockStreamBuf< Elem, Tr >::_Xsgetn_s( char_type *buf,    size_t iSize, std::streamsize iCount    )
{
    std::streamsize iRes = this->xsgetn( buf, iCount );
    return iRes;
}

template< class Elem, class Tr >
std::streamsize CSockStreamBuf< Elem, Tr >::xsputn( const typename CSockStreamBuf< Elem, Tr >::char_type *buf, std::streamsize iCount )
{
    std::streamsize iRes = send( m_Sock, buf, iCount, 0 );
    return iRes;
}

template< class Elem, class Tr >
std::streamsize CSockStreamBuf< Elem,Tr >::xsgetn( typename CSockStreamBuf< Elem, Tr >::char_type *buf, std::streamsize iCount )
{
    std::streamsize iRes = recv( m_Sock, buf, iCount, 0 );
    return iRes;
}

template< class Elem, class Tr >
CSockStreamBuf<Elem,Tr>::CSockStreamBuf( const std::string& sAddr, int iPort )
{
    this->Connect( sAddr, iPort );
}

template< class Elem, class Tr >
CSockStreamBuf<Elem,Tr>::~CSockStreamBuf()
{
    this->Disconnect();
}


template<class Elem, class Tr>
int CSockStreamBuf<Elem,Tr>::Connect( const std::string& sAddr, int iPort )
{
    //init winsock
    WSADATA wsaData;
    m_iState = WSAStartup(MAKEWORD(2,2), &wsaData);
    if( m_iState == NO_ERROR )
    {
        //creating socket
        SOCKET ConnectSocket;
        ConnectSocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
        if( ConnectSocket != INVALID_SOCKET )
        {
            //creating address object
            sockaddr_in sockAddr;
            sockAddr.sin_family = AF_INET;
            sockAddr.sin_addr.s_addr = inet_addr( sAddr.c_str() );
            sockAddr.sin_port = htons( iPort );
            //connecting
            m_iState = connect( ConnectSocket, (SOCKADDR*)&sockAddr, sizeof( sockAddr ) ) ;
            if( m_iState != SOCKET_ERROR )
            {
                m_sAddr = sAddr;
                m_iPort = iPort;
                m_Sock = ConnectSocket;
            }//if
        }//if
        else
        {
            m_iState = SOCKET_ERROR;
        }//else
    }//if
    return m_iState;
}

template< class Elem, class Tr >
bool CSockStreamBuf<Elem,Tr>::Disconnect()
{
    bool bRes = true;
    if( m_Sock != INVALID_SOCKET )
    {
        bRes = closesocket( m_Sock ) == 0; 
        
    }//if
    WSACleanup();
    return bRes;
}



#endif CSockStramBuf__H

            namespace bio = boost::iostreams;

            wdevice device (buffer);
            bio::stream_buffer<wdevice> stream (device);
            std::ostream ostream (&stream);

            boost::archive::binary_oarchive archive(ostream);
            archive << BOOST_SERIALIZATION_NVP (rhs);

2>C:\boost\boost/iostreams/detail/streambuf/indirect_streambuf.hpp(241) : warning C4996: 'std::char_traits<char>::move' was declared deprecated
2>        C:\Program Files\Microsoft Visual Studio 8\VC\include\iosfwd(470) : see declaration of 'std::char_traits<char>::move'
2>        Message: 'You have used a std:: construct that is not safe. See documentation on how to use the Safe Standard C++ Library'
2>        C:\boost\boost/iostreams/detail/streambuf/indirect_streambuf.hpp(230) : while compiling class template member function 'int boost::iostreams::detail::indirect_streambuf<T,Tr,Alloc,Mode>::underflow(void)'
2>        with
2>        [
2>            T=parser::wdevice,
2>            Tr=std::char_traits<char>,
2>            Alloc=std::allocator<char>,
2>            Mode=boost::iostreams::detail::io_mode_impl<2>::type
2>        ]
2>        C:\boost\boost/iostreams/stream_buffer.hpp(64) : see reference to class template instantiation 'boost::iostreams::detail::indirect_streambuf<T,Tr,Alloc,Mode>' being compiled
2>        with
2>        [
2>            T=parser::wdevice,
2>            Tr=std::char_traits<char>,
2>            Alloc=std::allocator<char>,
2>            Mode=boost::iostreams::detail::io_mode_impl<2>::type
2>        ]
2>        xxx.h(171) : see reference to class template instantiation 'boost::iostreams::stream_buffer<T>' being compiled
2>        with
2>        [
2>            T=parser::wdevice
2>        ]
2>        .\dataspy.cpp(104) : see reference to function template instantiation 'void parser::serialize<Channels>(parser::sbuffer &,const T &)' being compiled
2>        with
2>        [
2>            T=Channels
2>        ]
2>C:\Program Files\Microsoft Visual Studio 8\VC\include\xutility(2282) : warning C4996: 'std::_Copy_opt' was declared deprecated
2>        C:\Program Files\Microsoft Visual Studio 8\VC\include\xutility(2270) : see declaration of 'std::_Copy_opt'
2>        Message: 'You have used a std:: construct that is not safe. See documentation on how to use the Safe Standard C++ Library'
2>        e:\software\visual\atheros\wcl\stream.h(98) : see reference to function template instantiation '_OutIt std::copy<std::_Vector_const_iterator<_Ty,_Alloc>,char*>(_InIt,_InIt,_OutIt)' being compiled
2>        with
2>        [
2>            _OutIt=char *,
2>            _Ty=char,
2>            _Alloc=std::allocator<char>,
2>            _InIt=std::_Vector_const_iterator<char,std::allocator<char>>
2>        ]

...
...
...

2>        xxx.h(176) : see reference to function template instantiation 'Archive &boost::archive::detail::interface_oarchive<Archive>::operator <<<const boost::serialization::nvp<T>>(const boost::serialization::nvp<T> &)' being compiled
2>        with
2>        [
2>            Archive=boost::archive::binary_oarchive,
2>            T=const Channels
2>        ]
2>C:\boost\boost/archive/detail/oserializer.hpp(132) : error C2955: 'boost::type' : use of class template requires template argument list
2>        C:\boost\boost/type.hpp(14) : see declaration of 'boost::type'
2>C:\boost\boost/archive/detail/oserializer.hpp(132) : error C2039: 'value' : is not a member of 'boost::type'
2>        C:\boost\boost/type.hpp(14) : see declaration of 'boost::type'
2>C:\boost\boost/archive/detail/oserializer.hpp(132) : error C2065: 'value' : undeclared identifier

# pragma warning (disable : 4267)

C:\boost\boost/iostreams/detail/streambuf/indirect_streambuf.hpp(241) : warning C4996: 'std::char_traits<char>::move' was declared deprecated
        C:\Program Files\Microsoft Visual Studio 8\VC\include\iosfwd(470) : see declaration of 'std::char_traits<char>::move'
        Message: 'You have used a std:: construct that is not safe. See documentation on how to use the Safe Standard C++ Library'
        C:\boost\boost/iostreams/detail/streambuf/indirect_streambuf.hpp(230) : while compiling class template member function 'int boost::iostreams::detail::indirect_streambuf<T,Tr,Alloc,Mode>::underflow(void)'
        with
        [
            T=parser::wdevice,
            Tr=std::char_traits<char>,
            Alloc=std::allocator<char>,
            Mode=boost::iostreams::detail::io_mode_impl<2>::type
        ]
        C:\boost\boost/iostreams/stream_buffer.hpp(64) : see reference to class template instantiation 'boost::iostreams::detail::indirect_streambuf<T,Tr,Alloc,Mode>' being compiled
        with
        [
            T=parser::wdevice,
            Tr=std::char_traits<char>,
            Alloc=std::allocator<char>,
            Mode=boost::iostreams::detail::io_mode_impl<2>::type
        ]
        parser.h(179) : see reference to class template instantiation 'boost::iostreams::stream_buffer<T>' being compiled
        with
        [
            T=parser::wdevice
        ]
        (104) : see reference to function template instantiation 'void parser::serialize<Channels>(parser::sbuffer &,const T &)' being compiled
        with
        [
            T=Channels
        ]

        std::copy (
            m_container.begin() + m_index,
            m_container.begin() + m_index + result,
            stdext::checked_array_iterator<char_type *> (value, result)
        );

C:\boost\boost/iostreams/detail/streambuf/indirect_streambuf.hpp(241) : warning C4996: 'std::char_traits<char>::move' was declared deprecated
        C:\Program Files\Microsoft Visual Studio 8\VC\include\iosfwd(470) : see declaration of 'std::char_traits<char>::move'
        Message: 'You have used a std:: construct that is not safe. See documentation on how to use the Safe Standard C++ Library'
        C:\boost\boost/iostreams/detail/streambuf/indirect_streambuf.hpp(230) : while compiling class template member function 'int boost::iostreams::detail::indirect_streambuf<T,Tr,Alloc,Mode>::underflow(void)'
        with
        [
            T=parser::wdevice,
            Tr=std::char_traits<char>,
            Alloc=std::allocator<char>,
            Mode=boost::iostreams::detail::io_mode_impl<2>::type
        ]
        C:\boost\boost/iostreams/stream_buffer.hpp(64) : see reference to class template instantiation 'boost::iostreams::detail::indirect_streambuf<T,Tr,Alloc,Mode>' being compiled
        with
        [
            T=parser::wdevice,
            Tr=std::char_traits<char>,
            Alloc=std::allocator<char>,
            Mode=boost::iostreams::detail::io_mode_impl<2>::type
        ]
        e:\wcl\parser.h(179) : see reference to class template instantiation 'boost::iostreams::stream_buffer<T>' being compiled
        with
        [
            T=parser::wdevice
        ]
        .\data.cpp(104) : see reference to function template instantiation 'void parser::serialize<Channels>(parser::sbuffer &,const T &)' being compiled
        with
        [
            T=Channels
        ]