Progress: Client Constructor Test now Builds!

deanberris · deanberris · commit b59dcc54bec1 · 2011-12-08T23:51:25.000+11:00
After some re-modeling of the internal implementation of the response
object as well as the interface used for initializing the promises, now
the client constructor test finally builds! This means most (not all) of
the request and response methods required just to instantiate an HTTP
client instance is ready for the linking.

Much more work to be done to:

1) Re-work and simplify the other tests.

2) Mock the delegates and remove reliance on actual external testing
that needs a network connection.

3) Make the request and response objects actually work. This is a tall
order just because of the sheer amount of code required to make this
happen.

4) Make the request and response objects more efficient in its use of
memory and synchronization primitives. I have doubts on the efficiency
and effectiveness of using futures for the data but this seems to be the
most straight-forward approach for the meantime.

Sounds like a lot of work to do but hopefully it's not as hard as it
reads.
diff --git a/boost/network/protocol/http/client/connection/async_normal.ipp b/boost/network/protocol/http/client/connection/async_normal.ipp
@@ -86,13 +86,12 @@ struct http_async_connection_pimpl : boost::enable_shared_from_this<http_async_c
 
   void init_response(response &r) {
     impl::setter_access accessor;
-    this->source_promise = accessor.get_source_promise(r);
-    this->destination_promise = accessor.get_destination_promise(r);
-    this->headers_promise = accessor.get_headers_promise(r);
-    this->body_promise = accessor.get_body_promise(r);
-    this->version_promise = accessor.get_version_promise(r);
-    this->status_promise = accessor.get_status_promise(r);
-    this->status_message_promise = accessor.get_status_message_promise(r);
+    accessor.set_source_promise(r, this->source_promise);
+    accessor.set_destination_promise(r, this->destination_promise);
+    accessor.set_headers_promise(r, this->headers_promise);
+    accessor.set_body_promise(r, this->body_promise);
+    accessor.set_version_promise(r, this->version_promise);
+    accessor.set_status_message_promise(r, this->status_message_promise);
   }
 
   void set_errors(boost::system::error_code const & ec) {
@@ -392,16 +391,16 @@ struct http_async_connection_pimpl : boost::enable_shared_from_this<http_async_c
       this->destination_promise.set_exception(boost::copy_exception(error));
       switch (state) {
         case version:
-//          this->version_promise.set_exception(boost::copy_exception(error));
+          this->version_promise.set_exception(boost::copy_exception(error));
         case status:
-//          this->status_promise.set_exception(boost::copy_exception(error));
+          this->status_promise.set_exception(boost::copy_exception(error));
         case status_message:
-//          this->status_message_promise.set_exception(boost::copy_exception(error));
+          this->status_message_promise.set_exception(boost::copy_exception(error));
         case headers:
-//          this->headers_promise.set_exception(boost::copy_exception(error));
+          this->headers_promise.set_exception(boost::copy_exception(error));
         case body:
-//          this->body_promise.set_exception(boost::copy_exception(error));
-//          break;
+          this->body_promise.set_exception(boost::copy_exception(error));
+          break;
         default:
           BOOST_ASSERT(false && "Bug, report this to the developers!");
       }
diff --git a/boost/network/protocol/http/impl/access.hpp b/boost/network/protocol/http/impl/access.hpp
@@ -16,13 +16,13 @@ struct response;
 namespace impl {
 
 struct setter_access {
-  promise<std::string> get_version_promise(response &r);
-  promise<boost::uint16_t> get_status_promise(response &r);
-  promise<std::string> get_status_message_promise(response &r);
-  promise<std::multimap<std::string, std::string> > get_headers_promise(response &r);
-  promise<std::string> get_source_promise(response &r);
-  promise<std::string> get_destination_promise(response &r);
-  promise<std::string> get_body_promise(response &r);
+  void set_version_promise(response &r, promise<std::string> &p);
+  void set_status_promise(response &r, promise<boost::uint16_t> &p);
+  void set_status_message_promise(response &r, promise<std::string>&p);
+  void set_headers_promise(response &r, promise<std::multimap<std::string, std::string> > &p);
+  void set_source_promise(response &r, promise<std::string> &p);
+  void set_destination_promise(response &r, promise<std::string> &p);
+  void set_body_promise(response &r, promise<std::string> &p);
 };
 
 }  // namespace impl
diff --git a/boost/network/protocol/http/impl/access.ipp b/boost/network/protocol/http/impl/access.ipp
@@ -5,33 +5,33 @@
 
 namespace boost { namespace network { namespace http { namespace impl {
 
-promise<std::string> setter_access::get_version_promise(response &r) {
-  return r.get_version_promise();
+void setter_access::set_version_promise(response &r, promise<std::string> &p) {
+  return r.set_version_promise(p);
 }
 
-promise<boost::uint16_t> setter_access::get_status_promise(response &r) {
-  return r.get_status_promise();
+void setter_access::set_status_promise(response &r, promise<boost::uint16_t> &p) {
+  return r.set_status_promise(p);
 }
 
-promise<std::string> setter_access::get_status_message_promise(response &r) {
-  return r.get_status_message_promise();
+void setter_access::set_status_message_promise(response &r, promise<std::string> &p) {
+  return r.set_status_message_promise(p);
 }
 
-promise<std::multimap<std::string, std::string> >
-setter_access::get_headers_promise(response &r) {
-  return r.get_headers_promise();
+void
+setter_access::set_headers_promise(response &r, promise<std::multimap<std::string, std::string> > &p) {
+  return r.set_headers_promise(p);
 }
 
-promise<std::string> setter_access::get_source_promise(response &r) {
-  return r.get_source_promise();
+void setter_access::set_source_promise(response &r, promise<std::string> &p) {
+  return r.set_source_promise(p);
 }
 
-promise<std::string> setter_access::get_destination_promise(response &r) {
-  return r.get_destination_promise();
+void setter_access::set_destination_promise(response &r, promise<std::string> &p) {
+  return r.set_destination_promise(p);
 }
 
-promise<std::string> setter_access::get_body_promise(response &r) {
-  return r.get_body_promise();
+void setter_access::set_body_promise(response &r, promise<std::string> &p) {
+  return r.set_body_promise(p);
 }
 
 }  // namespace impl
diff --git a/boost/network/protocol/http/request/request_base.ipp b/boost/network/protocol/http/request/request_base.ipp
@@ -14,6 +14,10 @@ namespace boost { namespace network { namespace http {
 request_base::~request_base() {
   // default implementation, only required for linking.
 }
+
+request_storage_base::~request_storage_base() {
+  // default implementation, only required for linking.
+}
   
 } /* http */
 
diff --git a/boost/network/protocol/http/response/response.hpp b/boost/network/protocol/http/response/response.hpp
@@ -60,13 +60,13 @@ struct response : response_base {
   friend class impl::setter_access;  // Hide access through accessor class.
   // These methods are unique to the response type which will allow for creating
   // promises that can be set appropriately.
-  promise<std::string> get_version_promise();
-  promise<boost::uint16_t> get_status_promise();
-  promise<std::string> get_status_message_promise();
-  promise<std::multimap<std::string, std::string> > get_headers_promise();
-  promise<std::string> get_source_promise();
-  promise<std::string> get_destination_promise();
-  promise<std::string> get_body_promise();
+  void set_version_promise(promise<std::string>&);
+  void set_status_promise(promise<boost::uint16_t>&);
+  void set_status_message_promise(promise<std::string>&);
+  void set_headers_promise(promise<std::multimap<std::string, std::string> >&);
+  void set_source_promise(promise<std::string>&);
+  void set_destination_promise(promise<std::string>&);
+  void set_body_promise(promise<std::string>&);
 
   scoped_ptr<response_pimpl> pimpl_;
 };
diff --git a/boost/network/protocol/http/response/response.ipp b/boost/network/protocol/http/response/response.ipp
@@ -145,53 +145,39 @@ struct response_pimpl {
     }
   }
 
-  promise<std::string> get_source_promise() {
-    promise<std::string> promise_;
+  void set_source_promise(promise<std::string> &promise_) {
     unique_future<std::string> tmp_future = promise_.get_future();
     source_future_ = move(tmp_future);
-    return move(promise_);
   }
 
-  promise<std::string> get_destination_promise() {
-    promise<std::string> promise_;
+  void set_destination_promise(promise<std::string> &promise_) {
     unique_future<std::string> tmp_future = promise_.get_future();
     destination_future_ = move(tmp_future);
-    return move(promise_);
   }
 
-  promise<std::multimap<std::string, std::string> > get_headers_promise() {
-    promise<std::multimap<std::string, std::string> > promise_;
+  void set_headers_promise(promise<std::multimap<std::string, std::string> > &promise_) {
     unique_future<std::multimap<std::string, std::string> > tmp_future = promise_.get_future();
     headers_future_ = move(tmp_future);
-    return promise_;
   }
 
-  promise<boost::uint16_t> get_status_promise() {
-    promise<boost::uint16_t> promise_;
+  void set_status_promise(promise<boost::uint16_t> &promise_) {
     unique_future<boost::uint16_t> tmp_future = promise_.get_future();
     status_future_ = move(tmp_future);
-    return promise_;
   }
 
-  promise<std::string> get_status_message_promise() {
-    promise<std::string> promise_;
+  void set_status_message_promise(promise<std::string> &promise_) {
     unique_future<std::string> tmp_future = promise_.get_future();
     status_message_future_ = move(tmp_future);
-    return promise_;
   }
 
-  promise<std::string> get_version_promise() {
-    promise<std::string> promise_;
+  void set_version_promise(promise<std::string> &promise_) {
     unique_future<std::string> tmp_future = promise_.get_future();
     version_future_ = move(tmp_future);
-    return promise_;
   }
 
-  promise<std::string> get_body_promise() {
-    promise<std::string> promise_;
+  void set_body_promise(promise<std::string> &promise_) {
     unique_future<std::string> tmp_future = promise_.get_future();
     body_future_ = move(tmp_future);
-    return promise_;
   }
 
  private:
@@ -307,32 +293,32 @@ void response::get_version(std::string &version) const {
 
 response::~response() {}
 
-promise<std::string> response::get_version_promise() {
-  return pimpl_->get_version_promise();
+void response::set_version_promise(promise<std::string> &promise) {
+  return pimpl_->set_version_promise(promise);
 }
 
-promise<boost::uint16_t> response::get_status_promise() {
-  return pimpl_->get_status_promise();
+void response::set_status_promise(promise<boost::uint16_t> &promise) {
+  return pimpl_->set_status_promise(promise);
 }
 
-promise<std::string> response::get_status_message_promise() {
-  return pimpl_->get_status_message_promise();
+void response::set_status_message_promise(promise<std::string> &promise) {
+  return pimpl_->set_status_message_promise(promise);
 }
 
-promise<std::multimap<std::string, std::string> > response::get_headers_promise() {
-  return pimpl_->get_headers_promise();
+void response::set_headers_promise(promise<std::multimap<std::string, std::string> > &promise) {
+  return pimpl_->set_headers_promise(promise);
 }
 
-promise<std::string> response::get_source_promise() {
-  return pimpl_->get_source_promise();
+void response::set_source_promise(promise<std::string> &promise) {
+  return pimpl_->set_source_promise(promise);
 }
 
-promise<std::string> response::get_destination_promise() {
-  return pimpl_->get_destination_promise();
+void response::set_destination_promise(promise<std::string> &promise) {
+  return pimpl_->set_destination_promise(promise);
 }
 
-promise<std::string> response::get_body_promise() {
-  return pimpl_->get_body_promise();
+void response::set_body_promise(promise<std::string> &promise) {
+  return pimpl_->set_body_promise(promise);
 }
 
 }  // namespace http

Original file line number	Diff line number	Diff line change
`@@ -14,6 +14,10 @@ namespace boost { namespace network { namespace http {`
`14`	`14`	`request_base::~request_base() {`
`15`	`15`	`// default implementation, only required for linking.`
`16`	`16`	`}`
	`17`	`+`
	`18`	`+request_storage_base::~request_storage_base() {`
	`19`	`+ // default implementation, only required for linking.`
	`20`	`+}`
`17`	`21`
`18`	`22`	`} /* http */`
`19`	`23`