/Users/dlarimer/dev/libs/rpc/include/boost/rpc/http/http.hpp

#ifndef _BOOST_RPC_HTTP_HTTP_HPP
#define _BOOST_RPC_HTTP_HTTP_HPP

// download a file... 
http::request req;
req << http::url( "path" ) << http::header( "Content-Type", "json" )
    << "Hello World";
    
// execute the request and return once headers have been parsed.
// the body may be quite large, so we will simply return the socket and
// allow the requester to read the body 'at will'
http::response r = boost::rpc::http::exec( http::request( "url" ) ); 
r.code(); r.reason(); 
std::ofstream of.open( r.path(), "wb" );
while( size_t s = r.read_some( buf, size ) ) {
    of.write( buf, s );
}
r.body(); // reads the whole body and returns it as a string 


namespace boost { namespace rpc { namespace http {

 struct get {
    boost::filesystem::path path;
 };
 struct version {
    version( const std::string& v = "HTTP/1.1" ):ver(v){}
    std::string ver;
 };
 struct body {
    body( const std::string& str = "" );
    body( const boost::shared_ptr<std::iostream>& s );
    :m_body(s){};
    boost::shared_ptr<std::iostream> m_body;
 };

 struct header {
   header( const std::string& _name="", const std::string& _value="")
   :name(_name),value(_value){}

   std::string name;
   std::string value;
 };

 header get( const boost::filesystem::path& p ) 


 class request {
   public:
     request();
     const std::vector<header>& headers()const;
     friend request& operator<<( request& req, const header& h ) {
         req.m_headers.push_back(h);
         return req;
     }

     template<typename T>
     friend request& operator<<( request& req, const T& content ) {
         if( !m_body ) 
            m_body = boost::shared_ptr<std::iostream>(new std::stringstream());
         *m_body << content;
         return req;
     }
   private:
     std::string                      m_version;
     std::vector<header>              m_headers; 
     boost::shared_ptr<std::iostream> m_body;
 };

 class response {
    public:
        std::string         reason()const;
        int                 code()const;
        std::vector<header> headers()const;

        size_t      read_some( char* buf, size_t buf_size );   
        size_t      read( char* buf, size_t buf_size );   
        std::string body();
    private:
        response( boost::cmt::asio::socket::ptr& s );
        friend response exec( const request& );

        std::string                    m_http_version;
        int                            m_status_code;
        std::string                    m_reason_phrase;
        std::vector<header>            m_headers; 
        boost::cmt::asio::socket::ptr  m_sock;
 };
    

 class connection {
   public:
     connection();
     ~connection();

    
   private:
    class connection_private* my;
 };
} } }
#endif // _BOOST_RPC_HTTP_HTTP_HPP