HttpParser.h

// Copyright (c) Stefano Cristiano
// SPDX-License-Identifier: MIT
#pragma once
#include "../Common/Result.h"
#include "../Common/Span.h"
#include "../Common/StringSpan.h"
#include "HttpExport.h"
 
namespace SC
{
 
struct SC_HTTP_EXPORT HttpParser
{
    enum class Method
    {
        HttpGET,     
        HttpPUT,     
        HttpPOST,    
        HttpHEAD,    
        HttpPATCH,   
        HttpDELETE,  
        HttpOPTIONS, 
    };
    Method method = Method::HttpGET; 
 
    size_t   tokenStart          = 0;    
    size_t   tokenLength         = 0;    
    uint32_t statusCode          = 0;    
    uint64_t contentLength       = 0;    
    bool     connectionKeepAlive = true; 
 
    enum class State
    {
        Parsing,  
        Result,   
        Finished, 
    };
 
    enum class Token
    {
        Method,       
        Url,          
        Version,      
        HeaderName,   
        HeaderValue,  
        HeadersEnd,   
        StatusCode,   
        StatusString, 
        Body          
    };
 
    Token token = Token::HeadersEnd; 
    State state = State::Parsing;    
 
    enum class Type
    {
        Request, 
        Response 
    };
    Type type = Type::Request; 
 
    Result parse(Span<const char> data, size_t& readBytes, Span<const char>& parsedData);
 
    enum class HeaderType
    {
        ContentLength = 0, 
        Connection    = 1, 
        ContentType   = 2, 
    };
 
    [[nodiscard]] bool matchesHeader(HeaderType headerName) const;
 
  private:
    size_t globalStart           = 0;
    size_t globalLength          = 0;
    int    topLevelCoroutine     = 0;
    int    nestedParserCoroutine = 0;
    bool   parsedContentLength   = false;
    bool   parsedConnection      = false;
    size_t matchIndex            = 0;
 
    static constexpr size_t numMatches = static_cast<size_t>(HeaderType::ContentType) + 1;
 
    size_t   matchingHeader[numMatches]      = {0};
    bool     matchingHeaderValid[numMatches] = {false};
    uint64_t number                          = 0;
 
    [[nodiscard]] bool parseHeaderName(char currentChar);
    [[nodiscard]] bool parseHeaderValue(char currentChar);
    [[nodiscard]] bool parseStatusCode(char currentChar);
    [[nodiscard]] bool parseNumberValue(char currentChar);
    [[nodiscard]] bool parseConnectionValue(char currentChar);
    [[nodiscard]] bool parseHeadersEnd(char currentChar);
    [[nodiscard]] bool parseMethod(char currentChar);
    [[nodiscard]] bool parseUrl(char currentChar);
 
    template <bool spaces>
    [[nodiscard]] bool parseVersion(char currentChar);
 
    template <bool (HttpParser::*Func)(char), Token currentResult>
    Result process(Span<const char>& data, size_t& readBytes, Span<const char>& parsedData);
};
 
} // namespace SC