Added an ArrayBuf class that provides an array-based streambuf so that...

Added an ArrayBuf class that provides an array-based streambuf so that response content can now be directly serialized to a fixed-size char buffer with standard iostream interface

src/array_buf.h

+/* array_buf.h
+   Mathieu Stefani, 26 August 2015
+   
+   An array backed streambuf
+*/
+
+#pragma once
+
+#include <streambuf>
+
+namespace Io {
+
+enum class Init { Default, ZeroOut };
+
+template<typename CharT>
+class BasicOutArrayBuf : public std::basic_streambuf<CharT> {
+public:
+
+    BasicOutArrayBuf(CharT* begin, CharT* end, Init init = Init::Default) {
+        if (init == Init::ZeroOut) {
+            std::fill(begin, end, CharT());
+        }
+
+        this->setp(begin, end);
+    }
+
+    template<size_t N>
+    BasicOutArrayBuf(char (&arr)[N], Init init = Init::Default) {
+        if (init == Init::ZeroOut) {
+            std::fill(arr, arr + N, CharT());
+        }
+
+        this->setp(arr, arr + N);
+    }
+
+    size_t len() const {
+        return this->pptr() - this->pbase();
+    }
+
+};
+
+typedef BasicOutArrayBuf<char> OutArrayBuf;
+
+} // namespace IO

src/http.cc

@@ -11,6 +11,7 @@
 #include "http.h"
 #include "net.h"
 #include "peer.h"
+#include "array_buf.h"
 
 using namespace std;
 
@@ -22,6 +23,11 @@ static constexpr char CR = 0xD;
 static constexpr char LF = 0xA;
 static constexpr char CRLF[] = {CR, LF};
 
+template< class CharT, class Traits>
+std::basic_ostream<CharT, Traits>& crlf(std::basic_ostream<CharT, Traits>& os) {
+    os.write(CRLF, 2);
+}
+
 static constexpr const char* ParserData = "__Parser";
 
 namespace Private {
@@ -331,31 +337,6 @@ namespace Private {
         request.resource.clear();
     }
 
-    ssize_t
-    Writer::writeRaw(const void* data, size_t len) {
-        buf = static_cast<char *>(memcpy(buf, data, len));
-        buf += len;
-
-        return 0;
-    }
-
-    ssize_t
-    Writer::writeString(const char* str) {
-        const size_t len = std::strlen(str);
-        return writeRaw(str, std::strlen(str));
-    }
-
-    ssize_t
-    Writer::writeHeader(const char* name, const char* value) {
-        writeString(name);
-        writeChar(':');
-        writeString(value);
-        writeRaw(CRLF, 2);
-
-        return 0;
-    }
-
-
 } // namespace Private
 
 const char* methodString(Method method)
@@ -421,32 +402,26 @@ Response::writeTo(Tcp::Peer& peer)
     int fd = peer.fd();
 
     char buffer[Const::MaxBuffer];
-    std::memset(buffer, 0, Const::MaxBuffer);
-    Private::Writer fmt(buffer, sizeof buffer);
+    Io::OutArrayBuf obuf(buffer, Io::Init::ZeroOut);
 
-    fmt.writeString("HTTP/1.1 ");
-    fmt.writeInt(code_);
-    fmt.writeChar(' ');
-    fmt.writeString(codeString(static_cast<Code>(code_)));
-    fmt.writeRaw(CRLF, 2);
+    std::ostream stream(&obuf);
+    stream << "HTTP/1.1 ";
+    stream << code_;
+    stream << ' ';
+    stream << codeString(static_cast<Code>(code_));
+    stream << crlf;
 
     for (const auto& header: headers.list()) {
-        std::ostringstream oss;
-        header->write(oss);
-
-        std::string str = oss.str();
-        fmt.writeRaw(str.c_str(), str.size());
-        fmt.writeRaw(CRLF, 2);
+        header->write(stream);
+        stream << crlf;
     }
 
-    fmt.writeHeader("Content-Length", body.size());
-
-    fmt.writeRaw(CRLF, 2);
-    fmt.writeString(body.c_str());
+    stream << "Content-Length: " << body.size() << crlf;
+    stream << crlf;
 
-    const size_t len = fmt.cursor() - buffer;
+    stream << body;
 
-    ssize_t bytes = send(fd, buffer, len, 0);
+    ssize_t bytes = send(fd, buffer, obuf.len(), 0);
 }
 
 void

src/http.h

@@ -293,47 +293,6 @@ namespace Private {
         ssize_t contentLength;
     };
 
-    struct Writer {
-        Writer(char* buffer, size_t len) 
-            : buf(buffer)
-            , len(len)
-        { }
-
-        ssize_t writeRaw(const void* data, size_t len);
-        ssize_t writeString(const char* str);
-
-        template<typename T>
-        typename std::enable_if<
-                     std::is_integral<T>::value, ssize_t
-                  >::type
-        writeInt(T value) {
-            auto str = std::to_string(value);
-            return writeRaw(str.c_str(), str.size());
-        }
-
-        ssize_t writeChar(char c) {
-            *buf++ = c;
-            return 0;
-        }
-
-        ssize_t writeHeader(const char* name, const char* value);
-
-        template<typename T>
-        typename std::enable_if<
-                    std::is_arithmetic<T>::value, ssize_t
-                 >::type
-        writeHeader(const char* name, T value) {
-            auto str = std::to_string(value);
-            return writeHeader(name, str.c_str());
-        }
-
-        char *cursor() const { return buf; }
-
-    private:
-        char* buf;
-        size_t len;
-    };
-
 }
 
 class Handler : public Net::Tcp::Handler {