cpp/src/parser/path_visitor.cpp

/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * License); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */

#include "path_visitor.h"

namespace storage {
antlrcpp::Any PathVisitor::visitPath(PathParser::PathContext* ctx) {
    if (ctx->prefixPath() != nullptr) {
        return visitPrefixPath(ctx->prefixPath());
    } else {
        return visitSuffixPath(ctx->suffixPath());
    }
}

antlrcpp::Any PathVisitor::visitPrefixPath(PathParser::PrefixPathContext* ctx) {
    std::vector<PathParser::NodeNameContext*> node_names = ctx->nodeName();
    std::vector<std::string> path;
    path.reserve(node_names.size() + 1);
    path.push_back(ctx->ROOT()->getText());
    for (uint64_t i = 0; i < node_names.size(); i++) {
        path.push_back(parse_node_name(node_names[i]));
    }
    return path;
}

antlrcpp::Any PathVisitor::visitSuffixPath(PathParser::SuffixPathContext* ctx) {
    std::vector<PathParser::NodeNameContext*> node_names = ctx->nodeName();
    std::vector<std::string> path;
    path.reserve(node_names.size());
    for (uint64_t i = 0; i < node_names.size(); i++) {
        path.emplace_back(parse_node_name(node_names[i]));
    }
    return path;
}
std::string PathVisitor::parse_node_name(PathParser::NodeNameContext* ctx) {
    std::string node_name = ctx->getText();
    if (starts_with(node_name, BACK_QUOTE_STRING) &&
        ends_with(node_name, BACK_QUOTE_STRING)) {
        std::string unWrapped = node_name.substr(1, node_name.length() - 2);
        if (is_real_number(unWrapped) ||
            !std::regex_match(unWrapped, IDENTIFIER_PATTERN)) {
            return node_name;
        }

        return unWrapped;
    }

    return node_name;
}
bool PathVisitor::is_real_number(const std::string& str) {
    std::string s = str;
    if (starts_with(s, "+") || starts_with(s, "-")) {
        std::string removeSign = s.substr(1);
        if (starts_with(removeSign, "+") || starts_with(removeSign, "-")) {
            return false;
        } else {
            s = removeSign;
        }
    }
    size_t index = 0;
    auto it = std::find_if(s.begin(), s.end(),
                           [](const char& c) { return c != '0'; });
    if (it != s.end()) {
        index = it - s.begin();
    }

    if (index > 0 && (s[index] == 'e' || s[index] == 'E')) {
        return is_creatable(s.substr(index - 1));
    } else {
        return is_creatable(s.substr(index));
    }
}
bool PathVisitor::starts_with(const std::string& str,
                              const std::string& prefix) {
    if (prefix.size() > str.size()) {
        return false;
    }
    return str.substr(0, prefix.size()) == prefix;
}

bool PathVisitor::ends_with(const std::string& str, const std::string& suffix) {
    if (suffix.size() > str.size()) {
        return false;
    }
    return str.substr(str.size() - suffix.size()) == suffix;
}

bool PathVisitor::is_creatable(const std::string& str) {
    try {
        std::stod(str);
        return true;
    } catch (const std::invalid_argument& e) {
        return false;
    } catch (const std::out_of_range& e) {
        return false;
    }
}
}  // namespace storage