resp_decoder.hpp

Go to the documentation of this file.

#ifndef RESP_DECODER
#define RESP_DECODER
 
#include <string>
 
#define CRLF "\r\n"

enum Operation {
    SET,
    GET,
    DEL,
    UNKNOWN
};

class Resp {
public:
    Operation operation;
    std::string key;
    std::string value;
    bool success;
    std::string error;
    Resp() : operation(UNKNOWN), success(false) {}
};

class RespDecoder {
public:
    static Resp decode(const char *buffer, size_t length) {
        Resp resp;
 
        std::string_view input(buffer, length);
 
        if (input.empty() || input[0] != '*') {
            resp.error = "Invalid request: missing array marker";
            return resp;
        }
 
        size_t pos = input.find(CRLF);
        if (pos == std::string_view::npos) {
            resp.error = "Invalid request: malformed array header";
            return resp;
        }
 
        int num_args;
        try {
            num_args = std::stoi(std::string(input.substr(1, pos - 1)));
        } catch (std::exception &) {
            resp.error = "Invalid request: invalid argument count";
            return resp;
        }
 
        if (num_args < 2 || num_args > 3) {
            resp.error = "Invalid request: unexpected argument count";
            return resp;
        }
 
        input.remove_prefix(pos + 2);
        if (!parseOperation(input, resp)) {
            return resp;
        }
 
        if (!parseKey(input, resp)) {
            return resp;
        }
 
        if (resp.operation == SET) {
            if (num_args != 3) {
                resp.error = "Invalid request: SET requires a value";
                return resp;
            }
 
            if (!parseValue(input, resp)) {
                return resp;
            }
        } else if (num_args > 2) {
            resp.error = "Invalid request: too many arguments";
            return resp;
        }
 
        if (!input.empty() && input != CRLF) {
            resp.error = "Invalid request: extra data after command";
            return resp;
        }
 
        resp.success = true;
        return resp;
    }

    static Resp decode(const char *buffer) {
        return decode(buffer, std::strlen(buffer));
    }
 
private:
    static bool parseOperation(std::string_view &input, Resp &resp) {
        if (input.empty() || input[0] != '$') {
            resp.error = "Invalid request: missing operation string marker";
            return false;
        }
 
        size_t pos = input.find(CRLF);
        if (pos == std::string_view::npos) {
            resp.error = "Invalid request: malformed operation length";
            return false;
        }
 
        int op_len;
        try {
            op_len = std::stoi(std::string(input.substr(1, pos - 1)));
        } catch (std::exception &) {
            resp.error = "Invalid request: invalid operation length";
            return false;
        }
 
        input.remove_prefix(pos + 2);
        if (input.size() < static_cast<size_t>(op_len) + 2) {
            resp.error = "Invalid request: truncated operation";
            return false;
        }
 
        std::string_view op = input.substr(0, op_len);
 
        if (op == "DEL") {
            resp.operation = DEL;
        } else if (op == "GET") {
            resp.operation = GET;
        } else if (op == "SET") {
            resp.operation = SET;
        } else {
            resp.error = "Invalid request: unknown operation";
            return false;
        }
 
        input.remove_prefix(op_len + 2);
        return true;
    }

    static bool parseKey(std::string_view &input, Resp &resp) {
        if (input.empty() || input[0] != '$') {
            resp.error = "Invalid request: missing key string marker";
            return false;
        }
 
        size_t pos = input.find(CRLF);
        if (pos == std::string_view::npos) {
            resp.error = "Invalid request: malformed key length";
            return false;
        }
 
        int key_len;
        try {
            key_len = std::stoi(std::string(input.substr(1, pos - 1)));
        } catch (std::exception &) {
            resp.error = "Invalid request: invalid key length";
            return false;
        }
 
        input.remove_prefix(pos + 2);
 
        if (input.size() < static_cast<size_t>(key_len) + 2) {
            resp.error = "Invalid request: truncated key";
            return false;
        }
 
        resp.key = std::string(input.substr(0, key_len));
        input.remove_prefix(key_len + 2);
        return true;
    }

    static bool parseValue(std::string_view &input, Resp &resp) {
        if (input.empty() || input[0] != '$') {
            resp.error = "Invalid request: missing value string marker";
            return false;
        }
 
        size_t pos = input.find(CRLF);
        if (pos == std::string_view::npos) {
            resp.error = "Invalid request: malformed value length";
            return false;
        }
 
        int value_len;
        try {
            value_len = std::stoi(std::string(input.substr(1, pos - 1)));
        } catch (std::exception &) {
            resp.error = "Invalid request: invalid value length";
            return false;
        }
 
        input.remove_prefix(pos + 2);
 
        if (input.size() < static_cast<size_t>(value_len) + 2) {
            resp.error = "Invalid request: truncated value";
            return false;
        }
 
        resp.value = std::string(input.substr(0, value_len));
        input.remove_prefix(value_len + 2);
        return true;
    }
};
#endif