Merge pull request AndreLouisCaron#13 from avitebskiy/feature-dev

Added MessageBuilder, RequestBuilder, and ResponseBuilder

.gitignore

@@ -1,2 +1,3 @@
 # git-ls-files --others --exclude-from=.git/info/exclude
 work/
+.idea/

.gitmodules

@@ -1,3 +1,3 @@
 [submodule "libs/http-parser"]
 	path = libs/http-parser
-	url = git://github.com/AndreLouisCaron/http-parser.git
+url=git://github.com/joyent/http-parser.git

CONTRIBUTORS.rst

@@ -17,3 +17,4 @@ The following people have contributed by providing feedback, reporting bugs,
 suggesting enhancements, etc.:
 
 * `pezcode <https://github.com/pezcode>`_
+* `avitebskiy <https://github.com/avitebskiy>`_

code/BufferedMessage.hpp

@@ -86,7 +86,7 @@ namespace http {
          */
         virtual void reset_buffers ()
         {
-            myBody.swap(std::string()), Base::reset_buffers();
+            std::string().swap(myBody), Base::reset_buffers();
         }
     };
 

code/CMakeLists.txt

@@ -6,19 +6,25 @@ set(headers
   Flags.hpp
   icompare.hpp
   Message.hpp
+  MessageBuilder.hpp
   Method.hpp
   Request.hpp
+  RequestBuilder.hpp
   Response.hpp
+  ResponseBuilder.hpp
   Url.hpp
 )
 set(sources
   Error.cpp
   Flags.cpp
   icompare.cpp
   Message.cpp
+  MessageBuilder.cpp
   Method.cpp
   Request.cpp
+  RequestBuilder.cpp
   Response.cpp
+  ResponseBuilder.cpp
   Url.cpp
 )
 add_library(httpxx

code/Flags.cpp

@@ -8,6 +8,92 @@
 #include "Flags.hpp"
 
 namespace http {
+	Flags::Flags() : myValue(Flags::Value(0))
+	{
+
+	}
+
+	Flags::Flags(const Flags& flags) : myValue(flags.myValue)
+	{
+
+	}
+
+	Flags::Flags(Value value) : myValue(value)
+	{
+
+	}
+
+	void Flags::set_chunked(bool chunked)
+	{
+		if(chunked)
+		{
+			myValue = (Flags::Value)((int)myValue | F_CHUNKED);
+		}
+		else
+		{
+			myValue = (Flags::Value)((int)myValue | ~F_CHUNKED) ;
+		}
+	}
+
+	void Flags::set_keepalive(bool keepalive)
+	{
+		if(keepalive)
+		{
+			myValue = (Flags::Value)((int)myValue | F_CONNECTION_KEEP_ALIVE);
+		}
+		else
+		{
+			myValue = (Flags::Value)((int)myValue | ~F_CONNECTION_KEEP_ALIVE) ;
+		}
+	}
+
+	void Flags::set_close(bool close)
+	{
+		if(close)
+		{
+			myValue = (Flags::Value)((int)myValue | F_CONNECTION_CLOSE);
+		}
+		else
+		{
+			myValue = (Flags::Value)((int)myValue | ~F_CONNECTION_CLOSE) ;
+		}
+	}
+
+	void Flags::set_trailing(bool trailing)
+	{
+		if(trailing)
+		{
+			myValue = (Flags::Value)((int)myValue | F_TRAILING);
+		}
+		else
+		{
+			myValue = (Flags::Value)((int)myValue | ~F_TRAILING) ;
+		}
+	}
+
+	void Flags::set_upgrade(bool upgrade)
+	{
+		if(upgrade)
+		{
+			myValue = (Flags::Value)((int)myValue | F_UPGRADE);
+		}
+		else
+		{
+			myValue = (Flags::Value)((int)myValue | ~F_UPGRADE) ;
+		}
+	}
+
+	void Flags::set_skipbody(bool skipbody)
+	{
+		if(skipbody)
+		{
+			myValue = (Flags::Value)((int)myValue | F_SKIPBODY);
+		}
+		else
+		{
+			myValue = (Flags::Value)((int)myValue | ~F_SKIPBODY) ;
+		}
+	}
 
     const Flags Flags::of ( const ::http_parser& parser )
     {
@@ -43,15 +129,20 @@ namespace http {
     {
         return (F_SKIPBODY);
     }
-
-    Flags::Flags ( Value value )
-        : myValue(value)
-    {
-    }
-
+
     bool Flags::operator& ( const Flags& rhs ) const
     {
         return ((myValue & rhs.myValue) != 0);
     }
 
+	http::Flags Flags::operator| ( const Flags& rhs ) const
+	{
+		return Flags((Value)(myValue | rhs.myValue));
+	}
+
+	http::Flags Flags::operator~ () const
+	{
+		return Flags((Value)(myValue));
+	}
+
 }

code/Flags.hpp

@@ -32,6 +32,17 @@ namespace http {
 
         /* class methods. */
     public:
+		Flags();
+		Flags(const Flags& flags);
+
+		void set_chunked(bool chunked);
+		void set_keepalive(bool keepalive);
+		void set_close(bool close);
+		void set_trailing(bool trailing);
+		void set_upgrade(bool upgrade);
+		void set_skipbody(bool skipbody);
+
+	public:
             /*!
              * @brief Extract the flags set in @a parser.
              */
@@ -92,6 +103,10 @@ namespace http {
              * @return @c true if all flags in @a rhs are signaled.
              */
         bool operator& ( const Flags& rhs ) const;
+
+		Flags operator| ( const Flags& rhs ) const;
+
+		Flags operator~ () const;
     };
 
 }

code/Message.cpp

@@ -226,6 +226,11 @@ namespace http {
         return (match->second);
     }
 
+	const Message::Headers& Message::headers() const
+	{
+		return myHeaders;
+	}
+
     bool Message::should_keep_alive () const
     {
         return (::http_should_keep_alive

code/Message.hpp

@@ -27,7 +27,7 @@ namespace http {
     class Message
     {
         /* nested types. */
-    private:
+	public:
         typedef std::map<std::string, std::string> Headers;
 
     protected:
@@ -200,6 +200,13 @@ namespace http {
              *  returns @c true.
              */
         std::string header ( const std::string& field ) const;
+
+		/*!
+		 * @brief Returns a const reference to the headers map
+		 * @warning This value is unspecified until @c headerscomplete()
+		 * returns @c true.
+		 */
+		const Headers& headers() const;
 
         /*!
          * @brief Check if this is not the last request/response.

code/MessageBuilder.cpp

@@ -0,0 +1,103 @@
+#include "MessageBuilder.hpp"
+
+#include <stdio.h>
+
+#if defined(_MSC_VER) && !defined(snprinf)
+#define snprintf sprintf_s
+#endif
+
+namespace http
+{
+	MessageBuilder::MessageBuilder() :
+		myMajorVersion(1), myMinorVersion(0)
+	{
+
+	}
+
+	MessageBuilder::MessageBuilder(const Message& message) : 
+		myMajorVersion(1), myMinorVersion(0)
+	{
+		if(message.headers_complete())
+		{
+			myMajorVersion = message.major_version();
+			myMinorVersion = message.minor_version();
+			myFlags = message.flags();
+			myHeaders = message.headers();
+		}
+	}
+
+	int MessageBuilder::major_version() const
+	{
+		return myMajorVersion;
+	}
+
+	void MessageBuilder::set_major_version(int majorVersion)
+	{
+		myMajorVersion = majorVersion;
+	}
+
+	int MessageBuilder::minor_version() const
+	{
+		return myMinorVersion;
+	}
+
+	void MessageBuilder::set_minor_version(int minorVersion)
+	{
+		myMinorVersion = minorVersion;
+	}
+
+	const Flags& MessageBuilder::flags() const
+	{
+		return myFlags;
+	}
+
+	Flags& MessageBuilder::flags()
+	{
+		return myFlags;
+	}
+
+	void MessageBuilder::set_flags(const Flags& flags)
+	{
+		myFlags = flags;
+	}
+
+	Message::Headers& MessageBuilder::headers()
+	{
+		return myHeaders;
+	}
+
+	const Message::Headers& MessageBuilder::headers() const
+	{
+		return myHeaders;
+	}
+
+	std::string MessageBuilder::version_to_string() const
+	{
+		std::string versionString("HTTP/");
+		char majorVersion[16] = {0};
+		char minorVersion[16] = {0};
+
+		snprintf(majorVersion, 16, "%d", major_version());
+		snprintf(minorVersion, 16, "%d", minor_version());
+
+		versionString += majorVersion;
+		versionString += ".";
+		versionString += minorVersion;
+
+		return versionString;
+	}
+
+	std::string MessageBuilder::headers_to_string() const
+	{
+		std::string headersString;
+		for(Message::Headers::const_iterator cit = myHeaders.cbegin(); cit != myHeaders.cend(); ++cit)
+		{
+			headersString += cit->first;
+			headersString += ": ";
+			headersString += cit->second;
+			headersString += "\r\n";
+		}
+
+		return headersString;
+	}
+}