Merge pull request #7 from copyleftdev/feature/enhances

Auto-merge PR #7: added improvments to code

Author: copyleftdev

parser.cpp

@@ -1,56 +1,143 @@
 #include <string>
+#include <string_view>
 #include <unordered_map>
-#include <sstream>
-#include <vector>
-
-struct HttpRequest {
-    std::string method;
-    std::string path;
-    std::string version;
-    std::unordered_map<std::string, std::string> headers;
-    std::string body;
+#include <optional>
+#include <stdexcept>
+#include <algorithm>
+#include <memory>
+
+class HttpParserError : public std::runtime_error {
+    using std::runtime_error::runtime_error;
 };
 
-class HttpParser {
+class HttpRequest final {
+public:
+    using Headers = std::unordered_map<std::string, std::string, std::hash<std::string>, std::equal_to<>>;
+    
+private:
+    std::string method_;
+    std::string path_;
+    std::string version_;
+    Headers headers_;
+    std::string body_;
+
 public:
-    HttpRequest parse(const std::string& raw_request) {
+    // Use string_view for efficient read-only access
+    [[nodiscard]] std::string_view method() const noexcept { return method_; }
+    [[nodiscard]] std::string_view path() const noexcept { return path_; }
+    [[nodiscard]] std::string_view version() const noexcept { return version_; }
+    [[nodiscard]] const Headers& headers() const noexcept { return headers_; }
+    [[nodiscard]] std::string_view body() const noexcept { return body_; }
+
+    // Friend declaration for the parser
+    friend class HttpParser;
+};
+
+class HttpParser final {
+public:
+    // Use string_view for efficient parsing without copying
+    [[nodiscard]] std::optional<HttpRequest> parse(std::string_view raw_request) const {
+        try {
+            return parse_impl(raw_request);
+        } catch (const std::exception&) {
+            return std::nullopt;
+        }
+    }
+
+private:
+    [[nodiscard]] HttpRequest parse_impl(std::string_view raw_request) const {
         HttpRequest request;
-        std::istringstream stream(raw_request);
-        std::string line;
+        size_t pos = 0;
+        size_t end_pos;
 
-        if (std::getline(stream, line)) {
-            parseRequestLine(line, request);
+        // Parse request line
+        if ((end_pos = raw_request.find("\r\n", pos)) == std::string_view::npos) {
+            throw HttpParserError("Invalid request line");
         }
+        parse_request_line(raw_request.substr(pos, end_pos - pos), request);
+        pos = end_pos + 2;
+
+        // Parse headers
+        while (pos < raw_request.size()) {
+            end_pos = raw_request.find("\r\n", pos);
+            if (end_pos == std::string_view::npos) {
+                throw HttpParserError("Invalid header format");
+            }
 
-        while (std::getline(stream, line) && line != "\r") {
-            if (line.empty()) break;
-            parseHeader(line, request);
+            // Check for end of headers
+            if (pos == end_pos) {
+                pos += 2;
+                break;
+            }
+
+            parse_header(raw_request.substr(pos, end_pos - pos), request);
+            pos = end_pos + 2;
         }
 
-        std::string body;
-        while (std::getline(stream, line)) {
-            body += line + "\n";
+        // Parse body
+        if (pos < raw_request.size()) {
+            request.body_ = std::string(raw_request.substr(pos));
         }
-        request.body = body;
 
         return request;
     }
 
-private:
-    void parseRequestLine(const std::string& line, HttpRequest& request) {
-        std::istringstream lineStream(line);
-        lineStream >> request.method >> request.path >> request.version;
+    static void parse_request_line(std::string_view line, HttpRequest& request) {
+        size_t method_end = line.find(' ');
+        if (method_end == std::string_view::npos) {
+            throw HttpParserError("Invalid request line format");
+        }
+
+        size_t path_end = line.find(' ', method_end + 1);
+        if (path_end == std::string_view::npos) {
+            throw HttpParserError("Invalid request line format");
+        }
+
+        request.method_ = std::string(line.substr(0, method_end));
+        request.path_ = std::string(line.substr(method_end + 1, path_end - method_end - 1));
+        request.version_ = std::string(line.substr(path_end + 1));
+        
+        // Validate HTTP method
+        if (!is_valid_method(request.method_)) {
+            throw HttpParserError("Invalid HTTP method");
+        }
     }
 
-    void parseHeader(const std::string& line, HttpRequest& request) {
-        size_t colonPos = line.find(':');
-        if (colonPos == std::string::npos) return;
+    static void parse_header(std::string_view line, HttpRequest& request) {
+        size_t colon_pos = line.find(':');
+        if (colon_pos == std::string_view::npos) {
+            throw HttpParserError("Invalid header format");
+        }
+
+        std::string_view key = line.substr(0, colon_pos);
+        std::string_view value = line.substr(colon_pos + 1);
+
+        // Trim whitespace
+        value = trim(value);
+        
+        if (!key.empty() && !value.empty()) {
+            request.headers_.emplace(
+                std::string(key),
+                std::string(value)
+            );
+        }
+    }
 
-        std::string key = line.substr(0, colonPos);
-        std::string value = line.substr(colonPos + 1);
-        value.erase(0, value.find_first_not_of(" "));
-        value.erase(value.find_last_not_of("\r") + 1);
+    [[nodiscard]] static std::string_view trim(std::string_view str) noexcept {
+        const auto first = str.find_first_not_of(" \t\r\n");
+        if (first == std::string_view::npos) return {};
+        
+        const auto last = str.find_last_not_of(" \t\r\n");
+        return str.substr(first, last - first + 1);
+    }
 
-        request.headers[key] = value;
+    [[nodiscard]] static bool is_valid_method(const std::string& method) noexcept {
+        static const auto valid_methods = std::array{
+            "GET", "POST", "PUT", "DELETE", "HEAD", 
+            "OPTIONS", "PATCH", "TRACE", "CONNECT"
+        };
+        
+        return std::find(valid_methods.begin(), valid_methods.end(), method) 
+               != valid_methods.end();
     }
 };