From f09e24607aa2a5bebbc5b416e4dc4a1aafda6965 Mon Sep 17 00:00:00 2001
From: Maxime Coste <frrrwww@gmail.com>
Date: Fri, 29 Mar 2013 19:34:57 +0100
Subject: [PATCH] add support for adding to options instead of replacing

---
 src/commands.cc       | 28 ++++++++++++++++++----------
 src/option_manager.hh |  8 ++++++++
 src/option_types.hh   | 21 +++++++++++++++++++++
 3 files changed, 47 insertions(+), 10 deletions(-)

diff --git a/src/commands.cc b/src/commands.cc
index b9ebd3b4..3043fbd8 100644
--- a/src/commands.cc
+++ b/src/commands.cc
@@ -437,31 +437,39 @@ void exec_commands_in_file(const CommandParameters& params,
 
 void set_global_option(const CommandParameters& params, Context& context)
 {
-    if (params.size() != 2)
-        throw wrong_argument_count();
+    ParametersParser parser(params, { { "add", false } }, 2, 2);
 
-    GlobalOptions::instance().get_local_option(params[0]).set_from_string(params[1]);
+    Option& opt = GlobalOptions::instance().get_local_option(parser[0]);
+    if (parser.has_option("add"))
+        opt.add_from_string(parser[1]);
+    else
+        opt.set_from_string(parser[1]);
 }
 
 void set_buffer_option(const CommandParameters& params, Context& context)
 {
-    ParametersParser parser(params, { { "buffer", true } });
-    if (parser.positional_count() != 2)
-        throw wrong_argument_count();
+    ParametersParser parser(params, { { "buffer", true }, { "add", false } }, 2, 2);
 
     OptionManager& options = parser.has_option("buffer") ?
         BufferManager::instance().get_buffer(parser.option_value("buffer")).options()
       : context.buffer().options();
 
-    options.get_local_option(parser[0]).set_from_string(parser[1]);
+    Option& opt = options.get_local_option(parser[0]);
+    if (parser.has_option("add"))
+        opt.add_from_string(parser[1]);
+    else
+        opt.set_from_string(parser[1]);
 }
 
 void set_window_option(const CommandParameters& params, Context& context)
 {
-    if (params.size() != 2)
-        throw wrong_argument_count();
+    ParametersParser parser(params, { { "add", false } }, 2, 2);
 
-    context.window().options().get_local_option(params[0]).set_from_string(params[1]);
+    Option& opt = context.window().options().get_local_option(parser[0]);
+    if (parser.has_option("add"))
+        opt.add_from_string(parser[1]);
+    else
+        opt.set_from_string(parser[1]);
 }
 
 void declare_option(const CommandParameters& params, Context& context)
diff --git a/src/option_manager.hh b/src/option_manager.hh
index 96271b0d..e82cb010 100644
--- a/src/option_manager.hh
+++ b/src/option_manager.hh
@@ -30,6 +30,7 @@ public:
 
     virtual String get_as_string() const = 0;
     virtual void   set_from_string(const String& str) = 0;
+    virtual void   add_from_string(const String& str) = 0;
 
     String name() const { return m_name; }
     OptionManager& manager() const { return m_manager; }
@@ -106,6 +107,13 @@ public:
         option_from_string(str, val);
         set(val);
     }
+    void add_from_string(const String& str) override
+    {
+        T val;
+        option_from_string(str, val);
+        if (option_add(m_value, val))
+            m_manager.on_option_changed(*this);
+    }
 
     Option* clone(OptionManager& manager) const override
     {
diff --git a/src/option_types.hh b/src/option_types.hh
index ab2955ca..a63a2512 100644
--- a/src/option_types.hh
+++ b/src/option_types.hh
@@ -16,6 +16,7 @@ inline void option_from_string(const String& str, String& opt) { opt = str; }
 
 inline String option_to_string(int opt) { return int_to_str(opt); }
 inline void option_from_string(const String& str, int& opt) { opt = str_to_int(str); }
+inline bool option_add(int& opt, int val) { opt += val; return val != 0; }
 
 inline String option_to_string(bool opt) { return opt ? "true" : "false"; }
 inline void option_from_string(const String& str, bool& opt)
@@ -54,6 +55,13 @@ void option_from_string(const String& str, std::vector<T>& opt)
     }
 }
 
+template<typename T>
+bool option_add(std::vector<T>& opt, const std::vector<T>& vec)
+{
+    std::copy(vec.begin(), vec.end(), back_inserter(opt));
+    return not vec.empty();
+}
+
 
 template<size_t I, typename... Types>
 struct TupleOptionDetail
@@ -112,6 +120,19 @@ inline void option_from_string(const String& str, StronglyTypedNumber<RealType,
      opt = StronglyTypedNumber<RealType, ValueType>{str_to_int(str)};
 }
 
+template<typename RealType, typename ValueType = int>
+inline bool option_add(StronglyTypedNumber<RealType, ValueType>& opt,
+                       StronglyTypedNumber<RealType, ValueType> val)
+{
+    opt += val; return val != 0;
+}
+
+template<typename T>
+bool option_add(T&, const T&)
+{
+    throw runtime_error("no add operation supported for this option type");
+}
+
 }
 
 #endif // option_types_hh_INCLUDED