From 1cfa6a67078b13d355c9fa92128a38b088f53597 Mon Sep 17 00:00:00 2001
From: "yons.kim" <yons.kim@samsung.com>
Date: Thu, 2 Apr 2015 18:50:04 +0900
Subject: [PATCH] Implements CommandLine class for parsing arguments

Change-Id: I29800483d3e7372fcf2001c9e4b23681316389db
---
 src/runtime/command_line.cc | 85 +++++++++++++++++++++++++++++++++++++--------
 src/runtime/command_line.h  | 28 ++++++++++++---
 2 files changed, 95 insertions(+), 18 deletions(-)

diff --git a/src/runtime/command_line.cc b/src/runtime/command_line.cc
index 4956ab4..a70f2b8 100644
--- a/src/runtime/command_line.cc
+++ b/src/runtime/command_line.cc
@@ -4,50 +4,107 @@
 
 #include "command_line.h"
 
-#include <string>
-
 #include "file_utils.h"
+#include <cstring>
 
 namespace wrt {
 
 namespace {
-  const char* kRuntimeName = "wrt";
+
+const char* kRuntimeName = "wrt";
+const char* kOptionPrefix = "--";
+const char* kOptionValueSeparator = "=";
+
+static bool IsValidOptionString(const char* argument) {
+  if (NULL != argument &&
+      strncmp(argument, kOptionPrefix, strlen(kOptionPrefix)) == 0) {
+    return true;
+  } else {
+    return false;
+  }
 }
 
+} // namespace
+
 CommandLine* CommandLine::current_process_commandline_ = NULL;
 
-CommandLine::CommandLine(int argc, char* argv[]) {
-  // parse program name and appid from arguments
+CommandLine::CommandLine(int argc, char* argv[])
+    : argc_(argc), argv_(argv) {
+  // Append option or push each arg(not option) into arguments_
+  for (int i=1; i < argc; ++i) {
+    if (IsValidOptionString(argv[i])) {
+      AppendOption(argv[i]);
+    } else {
+      arguments_.push_back(argv[i]);
+    }
+  }
+
+  // Parse program name and appid from argv_ or arguments_
   if (argc > 0) {
     program_ = utils::BaseName(argv[0]);
     if (program_ == kRuntimeName) {
-      if (argc > 1) {
-        appid_ = argv[1];
+      if (arguments_.size() > 0) {
+        // Suppose that appid is at the first of arguments_
+        appid_ = arguments_[0];
       }
     } else {
       appid_ = program_;
     }
   }
+}
+
+CommandLine::~CommandLine() {
+}
+
+void CommandLine::AppendOption(const char* argument) {
+  std::string option_string(argument);
+  std::string option_name;
+  std::string option_value;
+
+  int value_separator_pos = option_string.find(kOptionValueSeparator,
+                                               strlen(kOptionPrefix));
+  if (value_separator_pos >= 0) {
+    int substr_len = value_separator_pos - strlen(kOptionPrefix);
+    option_name = option_string.substr(strlen(kOptionPrefix), substr_len);
+    option_value = option_string.substr(value_separator_pos+1);
+  } else {
+    option_name = option_string.substr(strlen(kOptionPrefix),
+                                       value_separator_pos);
+  }
+
+  options_[option_name] = option_value;
+}
 
-  // make a string vector with arguments
-  for (int i=0; i < argc; ++i) {
-    argv_.push_back(argv[i]);
+bool CommandLine::HasOptionName(const std::string& option_name) {
+  return (options_.find(option_name) != options_.end());
+}
+
+std::string CommandLine::GetOptionValue(const std::string& option_name) {
+  if (HasOptionName(option_name)) {
+    return options_[option_name];
+  } else {
+    return std::string();
   }
 }
 
-CommandLine::~CommandLine() {
+// static
+void CommandLine::Reset() {
+  if (!!current_process_commandline_) {
+    delete current_process_commandline_;
+    current_process_commandline_ = NULL;
+  }
 }
 
+// static
 void CommandLine::Init(int argc, char* argv[]) {
   if (!current_process_commandline_) {
     current_process_commandline_ = new CommandLine(argc, argv);
   }
 }
 
+// static
 CommandLine* CommandLine::ForCurrentProcess() {
   return current_process_commandline_;
 }
 
-
-
-} // namespace wrt
+} // namespace wrt
\ No newline at end of file
diff --git a/src/runtime/command_line.h b/src/runtime/command_line.h
index ed62d60..582c25b 100644
--- a/src/runtime/command_line.h
+++ b/src/runtime/command_line.h
@@ -6,29 +6,49 @@
 #define WRT_RUNTIME_COMMAND_LINE_H_
 
 #include <string>
+#include <map>
 #include <vector>
 
 namespace wrt {
 
 class CommandLine {
  public:
+  // CommandLine only uses long options
+  typedef std::map<std::string, std::string> OptionMap;
+  // Arguments which except for option strings
+  typedef std::vector<std::string> Arguments;
+
   static void Init(int argc, char* argv[]);
   static CommandLine* ForCurrentProcess();
+  static void Reset();
+
+  // Test if options_ has 'option_name'
+  bool HasOptionName(const std::string& option_name);
+  // Get the option's value
+  std::string GetOptionValue(const std::string& option_name);
 
-  const std::string& appid() const { return appid_; }
-  const std::string& program() const { return program_; }
-  const std::vector<std::string>& argv() const { return argv_; }
+  const std::string appid() const { return appid_; }
+  const std::string program() const { return program_; }
+  const OptionMap& options() const { return options_; }
+  const Arguments& arguments() const { return arguments_; }
+  char** argv() const { return argv_; }
+  int argc() const { return argc_; }
 
  private:
   CommandLine(int argc, char* argv[]);
   virtual ~CommandLine();
 
+  void AppendOption(const char* argument);
+
   // The singleton CommandLine instance of current process
   static CommandLine* current_process_commandline_;
 
   std::string appid_;
   std::string program_;
-  std::vector<std::string> argv_;
+  OptionMap options_;
+  Arguments arguments_;
+  int argc_;
+  char** argv_;
 };
 
 } // namespace wrt
-- 
2.7.4