Next iteration of improvements, still a long way from a working HTTP client.

glynos · glynos · commit 5ecb5c7833fc · 2013-08-28T20:35:10.000+02:00
diff --git a/http/src/http/v2/client/client.cpp b/http/src/http/v2/client/client.cpp
@@ -8,27 +8,36 @@
 namespace network {
   namespace http {
     namespace v2 {
-      client::client() {
+      client::client(client_options options)
+	: options_(options) {
 
       }
 
-      std::future<response> client::get(const request &req) {
-	return std::future<response>();
+      std::future<response> client::get(request req, request_options options) {
+	return do_request("GET", req, options);
       }
 
-      std::future<response> client::post(const request &req) {
-	return std::future<response>();
+      std::future<response> client::post(request req, request_options options) {
+	return do_request("POST", req, options);
       }
 
-      std::future<response> client::put(const request &req) {
-	return std::future<response>();
+      std::future<response> client::put(request req, request_options options) {
+	return do_request("PUT", req, options);
       }
 
-      std::future<response> client::delete_(const request &req) {
-	return std::future<response>();
+      std::future<response> client::delete_(request req, request_options options) {
+	return do_request("DELETE", req, options);
+      }
+
+      std::future<response> client::head(request req, request_options options) {
+	return do_request("HEAD", req, options);
+      }
+
+      std::future<response> client::options(request req, request_options options) {
+	return do_request("OPTIONS", req, options);
       }
 
-      std::future<response> client::head(const request &req) {
+      std::future<response> client::do_request(string_type method, request req, request_options options) {
 	return std::future<response>();
       }
     } // namespace v2
diff --git a/http/src/http/v2/constants.cpp b/http/src/http/v2/constants.cpp
@@ -6,53 +6,50 @@
 #include <network/http/v2/constants.hpp>
 #include <unordered_map>
 
-static std::unordered_map<int, std::string> status_message_map() {
-  std::unordered_map<int, std::string> status_messages;
-  status_messages[100] = "Continue";
-  status_messages[101] = "Switching Protocols";
-  status_messages[200] = "OK";
-  status_messages[201] = "Created";
-  status_messages[202] = "Accepted";
-  status_messages[203] = "Non-Authoritative Information";
-  status_messages[204] = "No Content";
-  status_messages[205] = "Reset Content";
-  status_messages[206] = "Partial Content";
-  status_messages[300] = "Multiple Choices";
-  status_messages[301] = "Moved Permanently";
-  status_messages[302] = "Found";
-  status_messages[303] = "See Other";
-  status_messages[304] = "Not Modified";
-  status_messages[305] = "Use Proxy";
-  status_messages[307] = "Temporary Redirect";
-  status_messages[400] = "Bad Request";
-  status_messages[401] = "Unauthorized";
-  status_messages[402] = "Payment Required";
-  status_messages[403] = "Forbidden";
-  status_messages[404] = "Not Found";
-  status_messages[405] = "Method Not Allowed";
-  status_messages[406] = "Not Acceptable";
-  status_messages[407] = "Proxy Authentication Required";
-  status_messages[408] = "Request Timeout";
-  status_messages[409] = "Conflict";
-  status_messages[410] = "Gone";
-  status_messages[411] = "Length Required";
-  status_messages[412] = "Precondition Failed";
-  status_messages[413] = "Request Entity Too Large";
-  status_messages[414] = "Request Uri Too Long";
-  status_messages[415] = "Unsupported Media Type";
-  status_messages[416] = "Request Range Not Satisfiable";
-  status_messages[417] = "Expectation Failed";
-  status_messages[500] = "Internal Error";
-  status_messages[501] = "Not Implemented";
-  status_messages[502] = "Bad Gateway";
-  status_messages[503] = "Service Unavailable";
-  status_messages[504] = "Gateway Timeout";
-  status_messages[505] = "HTTP Version Not Supported";
-}
-
+std::string message(int status_code) {
+  static std::unordered_map<int, std::string> status_messages{
+    std::make_pair(100, "Continue"),
+    std::make_pair(101, "Switching Protocols"),
+    std::make_pair(200, "OK"),
+    std::make_pair(201, "Created"),
+    std::make_pair(202, "Accepted"),
+    std::make_pair(203, "Non-Authoritative Information"),
+    std::make_pair(204, "No Content"),
+    std::make_pair(205, "Reset Content"),
+    std::make_pair(206, "Partial Content"),
+    std::make_pair(300, "Multiple Choices"),
+    std::make_pair(301, "Moved Permanently"),
+    std::make_pair(302, "Found"),
+    std::make_pair(303, "See Other"),
+    std::make_pair(304, "Not Modified"),
+    std::make_pair(305, "Use Proxy"),
+    std::make_pair(307, "Temporary Redirect"),
+    std::make_pair(400, "Bad Request"),
+    std::make_pair(401, "Unauthorized"),
+    std::make_pair(402, "Payment Required"),
+    std::make_pair(403, "Forbidden"),
+    std::make_pair(404, "Not Found"),
+    std::make_pair(405, "Method Not Allowed"),
+    std::make_pair(406, "Not Acceptable"),
+    std::make_pair(407, "Proxy Authentication Required"),
+    std::make_pair(408, "Request Timeout"),
+    std::make_pair(409, "Conflict"),
+    std::make_pair(410, "Gone"),
+    std::make_pair(411, "Length Required"),
+    std::make_pair(412, "Precondition Failed"),
+    std::make_pair(413, "Request Entity Too Large"),
+    std::make_pair(414, "Request Uri Too Long"),
+    std::make_pair(415, "Unsupported Media Type"),
+    std::make_pair(416, "Request Range Not Satisfiable"),
+    std::make_pair(417, "Expectation Failed"),
+    std::make_pair(500, "Internal Error"),
+    std::make_pair(501, "Not Implemented"),
+    std::make_pair(502, "Bad Gateway"),
+    std::make_pair(503, "Service Unavailable"),
+    std::make_pair(504, "Gateway Timeout"),
+    std::make_pair(505, "HTTP Version Not Supported"),
+      };
 
-std::string status_message(int status_code) {
-  static const auto status_messages = status_message_map();
   auto it = status_messages.find(status_code);
   if (it != status_messages.end()) {
     return it->second;
diff --git a/http/src/network/http/v2/client/client.hpp b/http/src/network/http/v2/client/client.hpp
@@ -6,7 +6,9 @@
 #ifndef __NETWORK_HTTP_V2_CLIENT_CLIENT_INC__
 #define __NETWORK_HTTP_V2_CLIENT_CLIENT_INC__
 
+#include <network/http/v2/client/client_options.hpp>
 #include <network/http/v2/client/request.hpp>
+#include <network/http/v2/client/request_options.hpp>
 #include <network/http/v2/client/response.hpp>
 #include <future>
 
@@ -17,19 +19,31 @@ namespace network {
 
       public:
 
-	client();
+	typedef request::string_type string_type;
+
+	enum class method { GET, PUT, POST, DELETE, HEAD, OPTIONS, };
+
+	explicit client(client_options options = client_options());
 	client(client const &) = delete;
 	client(client &&) = delete;
 
-	std::future<response> get(const request &req);
+	std::future<response> get(request req, request_options options = request_options());
+
+	std::future<response> post(request req, request_options options = request_options());
+
+	std::future<response> put(request req, request_options options = request_options());
+
+	std::future<response> delete_(request req, request_options options = request_options());
+
+	std::future<response> head(request req, request_options options = request_options());
 
-	std::future<response> post(const request &req);
+	std::future<response> options(request req, request_options options = request_options());
 
-	std::future<response> put(const request &req);
+      private:
 
-	std::future<response> delete_(const request &req);
+	std::future<response> do_request(string_type method, request req, request_options options);
 
-	std::future<response> head(const request &req);
+	client_options options_;
 
       };
     } // namespace v2
diff --git a/http/src/network/http/v2/client/request.hpp b/http/src/network/http/v2/client/request.hpp
@@ -9,6 +9,7 @@
 #include <cstdint>
 #include <memory>
 #include <string>
+#include <network/http/v2/constants.hpp>
 #include <network/http/v2/message_base.hpp>
 #include <network/uri.hpp>
 
@@ -46,46 +47,69 @@ namespace network {
 
       class request {
 
-	typedef byte_source::string_type string_type;
-
       public:
 
-	request(uri locator, std::shared_ptr<byte_source> source = nullptr)
-	  : locator_(locator), source_(source) { }
+	typedef byte_source::string_type string_type;
+
+	request(uri destination, std::shared_ptr<byte_source> source = nullptr)
+	  : destination_(destination), byte_source_(source) { }
 
 	request(const request &other)
-	  : locator_(other.locator_), source_(other.source_) { }
+	  : destination_(other.destination_), byte_source_(other.byte_source_) { }
 
 	request(request &&other) noexcept
-	: locator_(std::move(other.locator_)), source_(std::move(other.source_)) { }
+	  : destination_(std::move(other.destination_))
+	  , byte_source_(std::move(other.byte_source_)) { }
 
 	request &operator = (request other) {
 	  other.swap(*this);
 	  return *this;
 	}
 
 	void swap(request &other) noexcept {
-	  locator_.swap(other.locator_);
-	  source_.swap(other.source_);
+	  std::swap(destination_, other.destination_);
+	  std::swap(byte_source_, other.byte_source_);
+	  std::swap(headers_, other.headers_);
+	  std::swap(method_, other.method_);
+	  std::swap(version_, other.version_);
+	}
+
+	void set_body(std::shared_ptr<byte_source> byte_source) {
+	  byte_source_ = byte_source;
+	}
+
+	void add_header(string_type key, string_type value) {
+	  headers_.emplace(key, value);
+	}
+
+	void remove_header(string_type key) {
+	  headers_.erase(key);
+	}
+
+	void clear_headers() {
+	  headers_.clear();
+	}
+
+	void set_method(string_type method) {
+	  method_ = std::move(method);
+	}
+
+	string_type method() const {
+	  return method_;
+	}
+
+	void set_version(string_type version) {
+	  version_ = std::move(version);
+	}
+
+	string_type version() const {
+	  return version_;
 	}
 
-	void set_destination(string_type destination);
-	// source
-	// add_header
-	// remove_header
-	// clear_headers
-	// set_body
-	// append_body
-	// get_body
-
-	// method
-	// status
-	// status_message
-	// uri
-	// version
-
-	uri locator_;
-	std::shared_ptr<byte_source> source_;
+	uri destination_;
+	std::shared_ptr<byte_source> byte_source_;
+	std::map<string_type, string_type> headers_;
+	string_type method_, version_;
 
       };
     } // namespace v2
diff --git a/http/src/network/http/v2/constants.hpp b/http/src/network/http/v2/constants.hpp
diff --git a/http/test/v2/constants_test.cpp b/http/test/v2/constants_test.cpp
