Making necessary changes to make the one-liner example work.

Author: deanberris

boost/network/detail/wrapper_base.hpp

@@ -11,18 +11,29 @@ namespace boost { namespace network { namespace detail {
 
     template <class Tag>
         struct wrapper_base {
-            typedef Tag tag;
-            explicit wrapper_base(basic_message<tag> & message_)
+            explicit wrapper_base(basic_message<Tag> & message_)
                 : _message(message_)
-            { };
+            {};
 
             protected:
-                virtual ~wrapper_base() 
-                { }; // for extending only
+                ~wrapper_base() {}; // for extending only
 
-                mutable basic_message<tag> & _message;
+                basic_message<Tag> & _message;
         };
 
+    template <class Tag>
+        struct wrapper_base_const {
+            explicit wrapper_base_const(basic_message<Tag> const & message_)
+                : _message(message_)
+            {}
+
+            protected:
+                ~wrapper_base_const() {}; // for extending only
+
+                basic_message<Tag> const & _message;
+        };
+
+
 } // namespace detail
 
 } // namespace network

boost/network/message.hpp

@@ -44,49 +44,65 @@ namespace boost { namespace network {
 
         typedef Tag tag;
 
-        typedef typename headers_container<tag>::type headers_container_type;
-        typedef typename string<tag>::type string_type;
+        typedef typename headers_container<Tag>::type headers_container_type;
+        typedef typename string<Tag>::type string_type;
 
         basic_message()
             : _headers(), _body(), _source(), _destination()
-        { };
+        { }
 
         basic_message(const basic_message & other)
             : _headers(other._headers), _body(other._body), _source(other._source), _destination(other._destination)
-        { };
+        { }
 
-        basic_message & operator=(basic_message<tag> rhs) {
+        basic_message & operator=(basic_message<Tag> rhs) {
             rhs.swap(*this);
             return *this;
-        };
+        }
 
-        void swap(basic_message<tag> & other) {
+        void swap(basic_message<Tag> & other) {
             other._headers.swap(_headers);
             other._body.swap(_body);
             other._source.swap(_source);
             other._destination.swap(_destination);
-        };
+        }
 
         headers_container_type & headers() {
             return _headers;
-        };
+        }
+
+        headers_container_type headers() const {
+            return _headers;
+        }
 
         string_type & body() {
             return _body;
-        };
+        }
+
+        string_type body() const {
+            return _body;
+        }
 
         string_type & source() {
             return _source;
-        };
+        }
+
+        string_type source() const {
+            return _source;
+        }
 
         string_type & destination() {
             return _destination;
-        };
+        }
+
+        string_type destination() const {
+            return _destination;
+        }
 
         private:
 
-        friend struct detail::directive_base<tag> ;
-        friend struct detail::wrapper_base<tag> ;
+        friend struct detail::directive_base<Tag> ;
+        friend struct detail::wrapper_base<Tag> ;
 
         headers_container_type _headers;
         string_type _body;

boost/network/message/wrappers/body.hpp

@@ -16,18 +16,32 @@ namespace boost { namespace network {
     namespace impl {
         template <class Tag>
             struct body_wrapper : public detail::wrapper_base<Tag> {
-                typedef Tag tag;
-                typedef basic_message<tag> message_type;
+                typedef basic_message<Tag> message_type;
                 typedef typename string<Tag>::type string_type;
 
-                explicit body_wrapper(basic_message<tag> & message_)
-                    : detail::wrapper_base<tag>(message_)
+                explicit body_wrapper(basic_message<Tag> & message_)
+                    : detail::wrapper_base<Tag>(message_)
                 { };
 
                 operator string_type () const {
                     return string_type(detail::wrapper_base<Tag>::_message.body());
                 };
             };
+
+        template <class Tag>
+            struct body_wrapper_const : public detail::wrapper_base_const<Tag> {
+                typedef basic_message<Tag> message_type;
+                typedef typename string<Tag>::type string_type;
+
+                explicit body_wrapper_const(basic_message<Tag> const & message_)
+                    : detail::wrapper_base_const<Tag>(message_)
+                {};
+
+                operator string_type () const {
+                    return string_type(detail::wrapper_base_const<Tag>::_message.body());
+                }
+            };
+
     } // namespace impl
 
     template <class Tag>
@@ -36,6 +50,12 @@ namespace boost { namespace network {
             return impl::body_wrapper<Tag>(message_);
         }
 
+    template <class Tag>
+        inline typename string<Tag>::type
+        body(basic_message<Tag> const & message_) {
+            return impl::body_wrapper_const<Tag>(message_);
+        }
+
 } // namespace network
 
 } // namespace boost

libs/network/example/Jamfile.v2

@@ -31,3 +31,5 @@ exe simple_wget : simple_wget.cpp ;
 exe hello_world_server : http/hello_world_server.cpp ;
 
 exe hello_world_client : http/hello_world_client.cpp ;
+
+exe one_liner : http/one_liner.cpp ;

libs/network/example/http/one_liner.cpp

@@ -0,0 +1,16 @@
+
+// Copyright Dean Michael Berris 2010.
+// 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)
+
+#include <boost/network.hpp>
+
+using namespace std;
+using namespace boost::network;
+using namespace boost::network::http;
+
+int main(int argc, const char *argv[]) {
+    cout << body(client().get(client::request("http://www.boost.org/")));
+    return 0;
+}