1 files changed, 15 insertions, 128 deletions

diff --git a/simpleperf/command.h b/simpleperf/command.h
index d06c5154..fe71a31a 100644
--- a/simpleperf/command.h
+++ b/simpleperf/command.h
@@ -18,152 +18,39 @@
 #define SIMPLE_PERF_COMMAND_H_
 
 #include <functional>
-#include <limits>
-#include <map>
 #include <memory>
-#include <optional>
+#include <limits>
 #include <string>
-#include <unordered_map>
 #include <vector>
 
 #include <android-base/logging.h>
 #include <android-base/macros.h>
 #include <android-base/parseint.h>
 
-namespace simpleperf {
-
-using OptionName = std::string;
-
-enum class OptionType {
-  SINGLE,    // this option has a single value (use the last one in the arg list)
-  MULTIPLE,  // this option can have multiple values (keep all values appeared in the arg list)
-  ORDERED,   // keep the order of this option in the arg list
-};
-
-enum class OptionValueType {
-  NONE,  // No value is needed
-  STRING,
-  OPT_STRING,  // optional string
-  UINT,
-  DOUBLE,
-};
-
-// Whether an option is allowed to pass through simpleperf_app_runner.
-enum class AppRunnerType {
-  NOT_ALLOWED,
-  ALLOWED,
-  CHECK_FD,
-  CHECK_PATH,
-};
-
-struct OptionFormat {
-  OptionValueType value_type;
-  OptionType type;
-  AppRunnerType app_runner_type = AppRunnerType::NOT_ALLOWED;
-};
-
-using OptionFormatMap = std::unordered_map<OptionName, OptionFormat>;
-
-union OptionValue {
-  const std::string* str_value;
-  uint64_t uint_value;
-  double double_value;
-};
-
-struct OptionValueMap {
-  std::multimap<OptionName, OptionValue> values;
-
-  bool PullBoolValue(const OptionName& name) { return PullValue(name).has_value(); }
-
-  template <typename T>
-  bool PullUintValue(const OptionName& name, T* value, uint64_t min = 0,
-                     uint64_t max = std::numeric_limits<T>::max()) {
-    if (auto option_value = PullValue(name); option_value) {
-      if (option_value->uint_value < min || option_value->uint_value > max) {
-        LOG(ERROR) << "invalid " << name << ": " << option_value->uint_value;
-        return false;
-      }
-      *value = option_value->uint_value;
-    }
-    return true;
+class Command {
+ public:
+  Command(const std::string& name, const std::string& short_help_string,
+          const std::string& long_help_string)
+      : name_(name), short_help_string_(short_help_string), long_help_string_(long_help_string) {
   }
 
-  bool PullDoubleValue(const OptionName& name, double* value,
-                       double min = std::numeric_limits<double>::lowest(),
-                       double max = std::numeric_limits<double>::max()) {
-    if (auto option_value = PullValue(name); option_value) {
-      if (option_value->double_value < min || option_value->double_value > max) {
-        LOG(ERROR) << "invalid " << name << ": " << option_value->double_value;
-        return false;
-      }
-      *value = option_value->double_value;
-    }
-    return true;
+  virtual ~Command() {
   }
 
-  void PullStringValue(const OptionName& name, std::string* value) {
-    if (auto option_value = PullValue(name); option_value) {
-      CHECK(option_value->str_value != nullptr);
-      *value = *option_value->str_value;
-    }
+  const std::string& Name() const {
+    return name_;
   }
 
-  std::optional<OptionValue> PullValue(const OptionName& name) {
-    std::optional<OptionValue> res;
-    if (auto it = values.find(name); it != values.end()) {
-      res.emplace(it->second);
-      values.erase(it);
-    }
-    return res;
+  const std::string& ShortHelpString() const {
+    return short_help_string_;
   }
 
-  std::vector<OptionValue> PullValues(const OptionName& name) {
-    auto pair = values.equal_range(name);
-    if (pair.first != pair.second) {
-      std::vector<OptionValue> res;
-      for (auto it = pair.first; it != pair.second; ++it) {
-        res.emplace_back(it->second);
-      }
-      values.erase(name);
-      return res;
-    }
-    return {};
+  const std::string LongHelpString() const {
+    return long_help_string_;
   }
-};
-
-inline const OptionFormatMap& GetCommonOptionFormatMap() {
-  static const OptionFormatMap option_formats = {
-      {"-h", {OptionValueType::NONE, OptionType::SINGLE, AppRunnerType::ALLOWED}},
-      {"--help", {OptionValueType::NONE, OptionType::SINGLE, AppRunnerType::ALLOWED}},
-      {"--log", {OptionValueType::STRING, OptionType::SINGLE, AppRunnerType::ALLOWED}},
-      {"--log-to-android-buffer",
-       {OptionValueType::NONE, OptionType::SINGLE, AppRunnerType::ALLOWED}},
-      {"--version", {OptionValueType::NONE, OptionType::SINGLE, AppRunnerType::ALLOWED}},
-  };
-  return option_formats;
-}
-
-class Command {
- public:
-  Command(const std::string& name, const std::string& short_help_string,
-          const std::string& long_help_string)
-      : name_(name), short_help_string_(short_help_string), long_help_string_(long_help_string) {}
-
-  virtual ~Command() {}
-
-  const std::string& Name() const { return name_; }
-
-  const std::string& ShortHelpString() const { return short_help_string_; }
-
-  const std::string LongHelpString() const { return long_help_string_; }
 
   virtual bool Run(const std::vector<std::string>& args) = 0;
 
-  bool PreprocessOptions(const std::vector<std::string>& args,
-                         const OptionFormatMap& option_formats, OptionValueMap* options,
-                         std::vector<std::pair<OptionName, OptionValue>>* ordered_options,
-                         std::vector<std::string>* non_option_args = nullptr);
-
   template <typename T>
   bool GetUintOption(const std::vector<std::string>& args, size_t* pi, T* value, uint64_t min = 0,
                      uint64_t max = std::numeric_limits<T>::max(), bool allow_suffixes = false) {
@@ -201,8 +88,8 @@ std::unique_ptr<Command> CreateCommandInstance(const std::string& cmd_name);
 const std::vector<std::string> GetAllCommandNames();
 bool RunSimpleperfCmd(int argc, char** argv);
 
+namespace simpleperf {
 extern bool log_to_android_buffer;
-
-}  // namespace simpleperf
+}
 
 #endif  // SIMPLE_PERF_COMMAND_H_