command_parser.hpp

Go to the documentation of this file.

#ifndef COMMAND_PARSER_HPP
#define COMMAND_PARSER_HPP
 
#include "engine/lsm.hpp"
#include "resp_encoder.hpp"
#include <string>
#include <utility>
#include <vector>

class ValidationResult {
public:
    bool success;
    std::string errmsg;
    std::string key;
    std::string value;
    ValidationResult() : success(false), errmsg(""), key(""), value("") {}
};

class CommandParser {
private:
    static std::vector<std::string> split(const std::string &str) {
        std::vector<std::string> tokens;
        std::string token;
        bool inQuotes = false;
        for (size_t i = 0; i < str.length(); ++i) {
            char c = str[i];
            if (c == '"') {
                inQuotes = !inQuotes;
            } else if (std::isspace(c) && !inQuotes) {
                if (!token.empty()) {
                    tokens.push_back(token);
                    token.clear();
                }
            } else {
                token += c;
            }
        }
        if (!token.empty()) {
            tokens.push_back(token);
        }
        return tokens;
    }

    static bool validate_set(const std::vector<std::string> &tokens, ValidationResult &result) {
        if (tokens.size() != 3) {
            result.success = false;
            result.errmsg = "wrong number of arguments for 'set' command";
            return false;
        }
        if (tokens[1].empty()) {
            result.success = false;
            result.errmsg = "invalid key";
            return false;
        }
        result.key = tokens[1];
        result.value = tokens[2];
        result.success = true;
        return true;
    }

    static bool validate_get(const std::vector<std::string> &tokens, ValidationResult &result) {
        if (tokens.size() != 2) {
            result.success = false;
            result.errmsg = "wrong number of arguments for 'get' command";
            return false;
        }
        if (tokens[1].empty()) {
            result.success = false;
            result.errmsg = "invalid key";
            return false;
        }
        result.key = tokens[1];
        result.success = true;
        return true;
    }

    static bool validate_del(const std::vector<std::string> &tokens, ValidationResult &result) {
        if (tokens.size() != 2) {
            result.success = false;
            result.errmsg = "wrong number of arguments for 'del' command";
            return false;
        }
        if (tokens[1].empty()) {
            result.success = false;
            result.errmsg = "invalid key";
            return false;
        }
        result.key = tokens[1];
        result.success = true;
        return true;
    }
    std::string
    help() {
        return "Available commands:\n"
               " SET <key> <value> - Set key to hold the string value\n"
               " GET <key>         - Get the value of key\n"
               " DEL <key>         - Delete a key\n"
               " help              - Show this help menu\n"
               " exit              - Exit the program\n"
               " clear             - Clear the screen\n";
    }
 
public:
    LSMTree db;

    CommandParser() = default;

    std::string parser(const std::string &line) {
        try {
            std::vector<std::string> tokens = split(line);
            if (tokens.empty()) {
                return "";
            }
 
            ValidationResult result;
            std::string command = tokens[0];
            std::transform(command.begin(), command.end(), command.begin(), ::tolower);
 
            if (command == "set") {
                if (!validate_set(tokens, result)) {
                    return RespEncoder::error(result.errmsg);
                }
                db.put(result.key, result.value);
                return RespEncoder::simpleString("OK");
            } else if (command == "get") {
                if (!validate_get(tokens, result)) {
                    return RespEncoder::error(result.errmsg);
                }
                std::pair<bool, std::string> found_value = db.get(result.key);
                if (!found_value.first) {
                    return "NULL\n";
                }
                return found_value.second + "\n";
            } else if (command == "del") {
                if (!validate_del(tokens, result)) {
                    return RespEncoder::error(result.errmsg);
                }
                std::pair<bool, std::string> found_value = db.get(result.key);
                if (!found_value.first) {
                    return "key \"" + result.key + "\" not found\n";
                }
                db.remove(result.key);
                return RespEncoder::integer(1);
            } else if (command == "help") {
                return help();
            } else if (command == "exit") {
                exit(0);
            } else if (command == "clear") {
                return "\033[2J\033[1;1H";
            } else {
                return RespEncoder::error("unknown command '" + command + "'");
            }
        } catch (const std::exception &e) {
            return RespEncoder::error(e.what());
        }
        return "";
    }
};
 
#endif