/Users/dlarimer/dev/libs/cmt/include/boost/cmt/asio/basic_socket_streambuf.hpp

//
// basic_socket_streambuf.hpp
// ~~~~~~~~~~~~~~~~~~~~~~~~~~
//
// Copyright (c) 2003-2010 Christopher M. Kohlhoff (chris at kohlhoff dot com)
//
// Distributed under the Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
//

#ifndef BOOST_CMT_ASIO_BASIC_SOCKET_STREAMBUF_HPP
#define BOOST_CMT_ASIO_BASIC_SOCKET_STREAMBUF_HPP

#if defined(_MSC_VER) && (_MSC_VER >= 1200)
# pragma once
#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)

#include <boost/asio/detail/config.hpp>

#if !defined(BOOST_NO_IOSTREAM)

#include <streambuf>
#include <boost/array.hpp>
#include <boost/preprocessor/arithmetic/inc.hpp>
#include <boost/preprocessor/repetition/enum_binary_params.hpp>
#include <boost/preprocessor/repetition/enum_params.hpp>
#include <boost/preprocessor/repetition/repeat_from_to.hpp>
#include <boost/asio/basic_socket.hpp>
#include <boost/asio/detail/throw_error.hpp>
#include <boost/asio/io_service.hpp>
#include <boost/asio/stream_socket_service.hpp>
#include <boost/cmt/asio.hpp>

#if !defined(BOOST_ASIO_SOCKET_STREAMBUF_MAX_ARITY)
#define BOOST_ASIO_SOCKET_STREAMBUF_MAX_ARITY 5
#endif // !defined(BOOST_ASIO_SOCKET_STREAMBUF_MAX_ARITY)

// A macro that should expand to:
//   template <typename T1, ..., typename Tn>
//   basic_socket_streambuf<Protocol, StreamSocketService>* connect(
//       T1 x1, ..., Tn xn)
//   {
//     init_buffers();
//     boost::system::error_code ec;
//     this->basic_socket<Protocol, StreamSocketService>::close(ec);
//     typedef typename Protocol::resolver resolver_type;
//     typedef typename resolver_type::query resolver_query;
//     resolver_query query(x1, ..., xn);
//     resolve_and_connect(query, ec);
//     return !ec ? this : 0;
//   }
// This macro should only persist within this file.

#define BOOST_ASIO_PRIVATE_CONNECT_DEF( z, n, data ) \
  template <BOOST_PP_ENUM_PARAMS(n, typename T)> \
  basic_socket_streambuf<Protocol, StreamSocketService>* connect( \
      BOOST_PP_ENUM_BINARY_PARAMS(n, T, x)) \
  { \
    init_buffers(); \
    boost::system::error_code ec; \
    this->basic_socket<Protocol, StreamSocketService>::close(ec); \
    typedef typename Protocol::resolver resolver_type; \
    typedef typename resolver_type::query resolver_query; \
    resolver_query query(BOOST_PP_ENUM_PARAMS(n, x)); \
    resolve_and_connect(query, ec); \
    return !ec ? this : 0; \
  } \
  

#include <boost/asio/detail/push_options.hpp>


namespace boost {
namespace cmt {
namespace asio {

    using namespace boost::asio;

template <typename Protocol,
    typename StreamSocketService = stream_socket_service<Protocol> >
class basic_socket_streambuf
  : public std::streambuf,
    public basic_socket<Protocol, StreamSocketService>
{
public:
  typedef typename Protocol::endpoint endpoint_type;

  basic_socket_streambuf()
    : basic_socket<Protocol, StreamSocketService>(
        boost::cmt::asio::default_io_service() ),
      unbuffered_(false)
  {
    init_buffers();
  }

  virtual ~basic_socket_streambuf()
  {
    if (pptr() != pbase())
      overflow(traits_type::eof());
  }


  basic_socket_streambuf<Protocol, StreamSocketService>* connect(
      const endpoint_type& endpoint)
  {
    init_buffers();
    boost::system::error_code ec;
    this->basic_socket<Protocol, StreamSocketService>::close(ec);
    //TODO: MAKE ASYNC
    stack_retainable<promise<boost::system::error_code> > p;
    this->basic_socket<Protocol, StreamSocketService>::async_connect(endpoint, 
                       boost::bind( boost::cmt::asio::detail::error_handler_ec, &p, _1 ));
    return !p.wait() ? this : 0;
  }

#if defined(GENERATING_DOCUMENTATION)


  template <typename T1, ..., typename TN>
  basic_socket_streambuf<Protocol, StreamSocketService>* connect(
      T1 t1, ..., TN tn);
#else
  BOOST_PP_REPEAT_FROM_TO(
      1, BOOST_PP_INC(BOOST_ASIO_SOCKET_STREAMBUF_MAX_ARITY),
      BOOST_ASIO_PRIVATE_CONNECT_DEF, _ )
#endif


  basic_socket_streambuf<Protocol, StreamSocketService>* close()
  {
    boost::system::error_code ec;
    sync();
    this->basic_socket<Protocol, StreamSocketService>::close(ec);
    if (!ec)
      init_buffers();
    return !ec ? this : 0;
  }

protected:
  int_type underflow()
  {
    if (gptr() == egptr())
    {
      boost::system::error_code ec;
      stack_retainable<promise<size_t> > p;
      this->service.async_receive(
          this->implementation,
          boost::asio::buffer(boost::asio::buffer(get_buffer_) + putback_max),
          0, boost::bind( boost::cmt::asio::detail::read_write_handler_ec, &p, &ec, _1, _2 ));
      std::size_t bytes_transferred = p.wait();    
      if (ec)
        return traits_type::eof();
      setg(get_buffer_.begin(), get_buffer_.begin() + putback_max,
          get_buffer_.begin() + putback_max + bytes_transferred);
      return traits_type::to_int_type(*gptr());
    }
    else
    {
      return traits_type::eof();
    }
  }

  int_type overflow(int_type c)
  {
    if (unbuffered_)
    {
      if (traits_type::eq_int_type(c, traits_type::eof()))
      {
        // Nothing to do.
        return traits_type::not_eof(c);
      }
      else
      {
        // Send the single character immediately.
        boost::system::error_code ec;
        char_type ch = traits_type::to_char_type(c);

     //   boost::cmt::asio::write( *this, 
     //           boost::asio::buffer(&ch, sizeof(char_type)), ec);

      //      this->service.send(this->implementation,
      //          boost::asio::buffer(&ch, sizeof(char_type)), 0, ec);
      stack_retainable<promise<size_t> > p;
        this->service.async_send(
            this->implementation,
            boost::asio::buffer(&ch, sizeof(char_type)),
            0, boost::bind( boost::cmt::asio::detail::read_write_handler_ec, &p, &ec, _1, _2 ));
        std::size_t bytes_transferred = p.wait();  
        if (ec)
          return traits_type::eof();
        return c;
      }
    }
    else
    {
      // Send all data in the output buffer.
      boost::asio::const_buffer buffer =
        boost::asio::buffer(pbase(), pptr() - pbase());
      while (boost::asio::buffer_size(buffer) > 0)
      {
        boost::system::error_code ec;
 //       std::size_t bytes_transferred = boost::cmt::asio::write_some( this->implementation, 
  //                                      boost::asio::buffer(buffer), ec);
                                        
       stack_retainable<promise<size_t> > p;
        this->service.async_send(
            this->implementation, boost::asio::buffer(buffer),
            0, boost::bind( boost::cmt::asio::detail::read_write_handler_ec, &p, &ec, _1, _2 ));
        std::size_t bytes_transferred = p.wait();  
        if (ec)
          return traits_type::eof();
        buffer = buffer + bytes_transferred;
      }
      setp(put_buffer_.begin(), put_buffer_.end());

      // If the new character is eof then our work here is done.
      if (traits_type::eq_int_type(c, traits_type::eof()))
        return traits_type::not_eof(c);

      // Add the new character to the output buffer.
      *pptr() = traits_type::to_char_type(c);
      pbump(1);
      return c;
    }
  }

  int sync()
  {
    return overflow(traits_type::eof());
  }

  std::streambuf* setbuf(char_type* s, std::streamsize n)
  {
    if (pptr() == pbase() && s == 0 && n == 0)
    {
      unbuffered_ = true;
      setp(0, 0);
      return this;
    }

    return 0;
  }

private:

  void init_buffers()
  {
    setg(get_buffer_.begin(),
        get_buffer_.begin() + putback_max,
        get_buffer_.begin() + putback_max);
    if (unbuffered_)
      setp(0, 0);
    else
      setp(put_buffer_.begin(), put_buffer_.end());
  }

  template <typename ResolverQuery>
  void resolve_and_connect(const ResolverQuery& query,
      boost::system::error_code& ec)
  {
    typedef typename Protocol::resolver resolver_type;
    typedef typename resolver_type::iterator iterator_type;
    resolver_type resolver(
        boost::cmt::asio::default_io_service() );
    iterator_type i = resolver.resolve(query, ec);
    if (!ec)
    {
      iterator_type end;
      ec = boost::asio::error::host_not_found;
      while (ec && i != end)
      {
        this->basic_socket<Protocol, StreamSocketService>::close();
        this->basic_socket<Protocol, StreamSocketService>::connect(*i, ec);
        ++i;
      }
    }
  }

  enum { putback_max = 8 };
  enum { buffer_size = 512 };
  boost::array<char, buffer_size> get_buffer_;
  boost::array<char, buffer_size> put_buffer_;
  bool unbuffered_;
};
} // namespace asio
} // namespace cmt
} // namespace boost

#include <boost/asio/detail/pop_options.hpp>

#undef BOOST_ASIO_PRIVATE_CONNECT_DEF

#endif // !defined(BOOST_NO_IOSTREAM)

#endif // BOOST_ASIO_BASIC_SOCKET_STREAMBUF_HPP