| /* |
| * 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 "cli/cli_args.h" |
| |
| #include <cerrno> |
| #include <cstdlib> |
| #include <sstream> |
| |
| namespace tsfile_cli { |
| namespace { |
| |
| std::vector<std::string> split_csv(const std::string& s) { |
| std::vector<std::string> out; |
| std::string item; |
| std::istringstream iss(s); |
| while (std::getline(iss, item, ',')) { |
| if (!item.empty()) { |
| out.push_back(item); |
| } |
| } |
| return out; |
| } |
| |
| bool parse_ll(const std::string& s, long long& out) { |
| if (s.empty()) { |
| return false; |
| } |
| char* endp = nullptr; |
| errno = 0; |
| long long v = std::strtoll(s.c_str(), &endp, 10); |
| if (endp == nullptr || *endp != '\0' || errno == ERANGE) { |
| return false; |
| } |
| out = v; |
| return true; |
| } |
| |
| bool parse_format(const std::string& s, ParsedArgs::Format& out) { |
| if (s == "csv") { |
| out = ParsedArgs::Format::kCsv; |
| } else if (s == "tsv") { |
| out = ParsedArgs::Format::kTsv; |
| } else if (s == "json") { |
| out = ParsedArgs::Format::kJson; |
| } else if (s == "table") { |
| out = ParsedArgs::Format::kTable; |
| } else { |
| return false; |
| } |
| return true; |
| } |
| |
| bool parse_tag_filter_op(const std::string& s, ParsedArgs::TagFilterOp& out) { |
| if (s == "eq" || s == "=" || s == "==") { |
| out = ParsedArgs::TagFilterOp::kEq; |
| } else if (s == "neq" || s == "ne" || s == "!=") { |
| out = ParsedArgs::TagFilterOp::kNeq; |
| } else if (s == "lt" || s == "<") { |
| out = ParsedArgs::TagFilterOp::kLt; |
| } else if (s == "lteq" || s == "lte" || s == "le" || s == "<=") { |
| out = ParsedArgs::TagFilterOp::kLteq; |
| } else if (s == "gt" || s == ">") { |
| out = ParsedArgs::TagFilterOp::kGt; |
| } else if (s == "gteq" || s == "gte" || s == "ge" || s == ">=") { |
| out = ParsedArgs::TagFilterOp::kGteq; |
| } else if (s == "regexp" || s == "regex" || s == "=~") { |
| out = ParsedArgs::TagFilterOp::kRegexp; |
| } else if (s == "not-regexp" || s == "not-regex" || s == "!~") { |
| out = ParsedArgs::TagFilterOp::kNotRegexp; |
| } else { |
| return false; |
| } |
| return true; |
| } |
| |
| } // namespace |
| |
| ParsedArgs parse_args(const std::vector<std::string>& args) { |
| ParsedArgs p; |
| if (args.empty()) { |
| return p; |
| } |
| p.command = args[0]; |
| if (p.command == "--version") { |
| p.version = true; |
| } |
| if (p.command == "--help" || p.command == "-h") { |
| p.help = true; |
| } |
| // The subcommand must come first. A leading option means it was omitted; |
| // say so explicitly instead of failing later with a confusing message about |
| // the first real positional argument. |
| if (p.command.size() > 1 && p.command[0] == '-' && !p.version && !p.help) { |
| p.error = "the command must come before options (got option '" + |
| p.command + "'); run with --help for usage"; |
| return p; |
| } |
| |
| size_t i = 1; |
| auto need_value = [&](const std::string& flag, std::string& dst) -> bool { |
| if (i + 1 >= args.size()) { |
| p.error = "Missing value for " + flag; |
| return false; |
| } |
| dst = args[++i]; |
| return true; |
| }; |
| auto need_tag_filter_slot = [&](const std::string& flag) -> bool { |
| if (p.has_tag_filter) { |
| p.error = "Only one tag filter predicate is supported"; |
| return false; |
| } |
| if (i + 3 >= args.size()) { |
| p.error = "Missing value for " + flag; |
| return false; |
| } |
| return true; |
| }; |
| |
| for (; i < args.size(); ++i) { |
| const std::string& a = args[i]; |
| std::string val; |
| if (a == "-f" || a == "--format") { |
| if (!need_value(a, val)) { |
| return p; |
| } |
| if (!parse_format(val, p.format)) { |
| p.error = |
| "Invalid format: " + val + " (use csv|tsv|json|table)"; |
| return p; |
| } |
| } else if (a == "-d" || a == "--device") { |
| if (!need_value(a, p.device)) { |
| return p; |
| } |
| } else if (a == "-t" || a == "--table") { |
| if (!need_value(a, p.table)) { |
| return p; |
| } |
| } else if (a == "-m" || a == "--measurements") { |
| if (!need_value(a, val)) { |
| return p; |
| } |
| p.measurements = split_csv(val); |
| } else if (a == "-n" || a == "--limit") { |
| if (!need_value(a, val)) { |
| return p; |
| } |
| if (!parse_ll(val, p.limit)) { |
| p.error = "Invalid -n/--limit: " + val; |
| return p; |
| } |
| } else if (a == "--offset") { |
| if (!need_value(a, val)) { |
| return p; |
| } |
| if (!parse_ll(val, p.offset)) { |
| p.error = "Invalid --offset: " + val; |
| return p; |
| } |
| } else if (a == "--start") { |
| if (!need_value(a, val)) { |
| return p; |
| } |
| if (!parse_ll(val, p.start)) { |
| p.error = "Invalid --start: " + val; |
| return p; |
| } |
| p.has_start = true; |
| } else if (a == "--end") { |
| if (!need_value(a, val)) { |
| return p; |
| } |
| if (!parse_ll(val, p.end)) { |
| p.error = "Invalid --end: " + val; |
| return p; |
| } |
| p.has_end = true; |
| } else if (a == "--seed") { |
| if (!need_value(a, val)) { |
| return p; |
| } |
| if (!parse_ll(val, p.seed)) { |
| p.error = "Invalid --seed: " + val; |
| return p; |
| } |
| p.has_seed = true; |
| } else if (a == "-o" || a == "--output") { |
| if (!need_value(a, p.output)) { |
| return p; |
| } |
| } else if (a == "--columns") { |
| if (!need_value(a, p.columns)) { |
| return p; |
| } |
| } else if (a == "-v" || a == "--verbose") { |
| p.verbose = true; |
| } else if (a == "--header-match") { |
| p.header_match = true; |
| } else if (a == "--tag-filter") { |
| if (!need_tag_filter_slot(a)) { |
| return p; |
| } |
| p.has_tag_filter = true; |
| p.tag_filter_column = args[++i]; |
| std::string op = args[++i]; |
| if (!parse_tag_filter_op(op, p.tag_filter_op)) { |
| p.error = "Invalid --tag-filter operator: " + op + |
| " (use eq|neq|lt|lteq|gt|gteq|regexp|not-regexp)"; |
| return p; |
| } |
| p.tag_filter_value = args[++i]; |
| } else if (a == "--tag-between" || a == "--tag-not-between") { |
| if (!need_tag_filter_slot(a)) { |
| return p; |
| } |
| p.has_tag_filter = true; |
| p.tag_filter_op = (a == "--tag-between") |
| ? ParsedArgs::TagFilterOp::kBetween |
| : ParsedArgs::TagFilterOp::kNotBetween; |
| p.tag_filter_column = args[++i]; |
| p.tag_filter_value = args[++i]; |
| p.tag_filter_value2 = args[++i]; |
| } else if (a == "--model") { |
| if (!need_value(a, val)) { |
| return p; |
| } |
| if (val != "tree" && val != "table") { |
| p.error = "Invalid --model: " + val + " (use tree|table)"; |
| return p; |
| } |
| p.model = val; |
| } else if (a == "--no-header") { |
| p.no_header = true; |
| } else if (a == "-h" || a == "--help") { |
| p.help = true; |
| return p; // help wins; stop parsing the rest |
| } else if (a == "--version") { |
| p.version = true; |
| return p; // version wins; stop parsing the rest |
| } else if (a.size() > 1 && a[0] == '-') { |
| p.error = "Unknown flag: " + a; |
| return p; |
| } else { |
| if (p.file.empty()) { |
| p.file = a; |
| } else { |
| p.error = "Unexpected argument: " + a; |
| return p; |
| } |
| } |
| } |
| return p; |
| } |
| |
| } // namespace tsfile_cli |
