OptionHandler now knows its option can be used in -i list option,

changeable in aria2.changeOption or aria2.changeGlobalOption.

OptionHandler also now its option is cumulative.

1 files changed, 31 insertions, 92 deletions

diff --git a/src/RpcMethod.cc b/src/RpcMethod.cc
index 89ae8587..14a2df4e 100644
--- a/src/RpcMethod.cc
+++ b/src/RpcMethod.cc
@@ -47,6 +47,7 @@
 #include "prefs.h"
 #include "fmt.h"
 #include "DlAbortEx.h"
+#include "a2functional.h"
 
 namespace aria2 {
 
@@ -79,41 +80,37 @@ RpcResponse RpcMethod::execute
 }
 
 namespace {
-template<typename InputIterator>
+template<typename InputIterator, typename Pred>
 void gatherOption
 (InputIterator first, InputIterator last,
- const std::set<std::string>& allowedOptions,
- const SharedHandle<Option>& option,
+ Pred pred,
+ Option* option,
  const SharedHandle<OptionParser>& optionParser)
 {
   for(; first != last; ++first) {
     const std::string& optionName = (*first).first;
-    if(allowedOptions.count(optionName) == 0) {
+    const Pref* pref = option::k2p(optionName);
+    if(!pref) {
       throw DL_ABORT_EX
-        (fmt("%s option cannot be used in this context.",
-             optionName.c_str()));
-    } else {
-      const Pref* pref = option::k2p(optionName);
-      const SharedHandle<OptionHandler>& handler = optionParser->find(pref);
-      if(!handler) {
-        throw DL_ABORT_EX
-          (fmt("We don't know how to deal with %s option",
-               optionName.c_str()));
-      }
-      const String* opval = downcast<String>((*first).second);
-      if(opval) {
-        handler->parse(*option.get(), opval->s());
-      } else {
-        // header and index-out option can take array as value
-        const List* oplist = downcast<List>((*first).second);
-        if(oplist &&
-           (optionName == PREF_HEADER->k || optionName == PREF_INDEX_OUT->k)) {
-          for(List::ValueType::const_iterator argiter = oplist->begin(),
-                eoi = oplist->end(); argiter != eoi; ++argiter) {
-            const String* opval = downcast<String>(*argiter);
-            if(opval) {
-              handler->parse(*option.get(), opval->s());
-            }
+        (fmt("We don't know how to deal with %s option", optionName.c_str()));
+    }
+    const SharedHandle<OptionHandler>& handler = optionParser->find(pref);
+    if(!handler || !pred(handler)) {
+      throw DL_ABORT_EX
+        (fmt("%s option cannot be used in this context.", optionName.c_str()));
+    }
+    const String* opval = downcast<String>((*first).second);
+    if(opval) {
+      handler->parse(*option, opval->s());
+    } else if(handler->getCumulative()) {
+      // header and index-out option can take array as value
+      const List* oplist = downcast<List>((*first).second);
+      if(oplist) {
+        for(List::ValueType::const_iterator argiter = oplist->begin(),
+              eoi = oplist->end(); argiter != eoi; ++argiter) {
+          const String* opval = downcast<String>(*argiter);
+          if(opval) {
+            handler->parse(*option, opval->s());
           }
         }
       }
@@ -122,92 +119,34 @@ void gatherOption
 }
 } // namespace
 
-void RpcMethod::gatherRequestOption
-(const SharedHandle<Option>& option, const Dict* optionsDict)
+void RpcMethod::gatherRequestOption(Option* option, const Dict* optionsDict)
 {
   if(optionsDict) {
     gatherOption(optionsDict->begin(), optionsDict->end(),
-                 listRequestOptions(),
+                 mem_fun_sh(&OptionHandler::getInitialOption),
                  option, optionParser_);
   }
 }
 
-namespace {
-// Copy option in the range [optNameFirst, optNameLast) from src to
-// dest.
-template<typename InputIterator>
-void applyOption(InputIterator optNameFirst,
-                 InputIterator optNameLast,
-                 Option* dest,
-                 Option* src)
-{
-  for(; optNameFirst != optNameLast; ++optNameFirst) {
-    const Pref* pref = option::k2p(*optNameFirst);
-    if(src->defined(pref)) {
-      dest->put(pref, src->get(pref));
-    }
-  }
-}
-} // namespace
-
-const std::set<std::string>& listChangeableOptions()
-{
-  static const std::string OPTIONS[] = {
-    PREF_BT_MAX_PEERS->k,
-    PREF_BT_REQUEST_PEER_SPEED_LIMIT->k,
-    PREF_MAX_DOWNLOAD_LIMIT->k,
-    PREF_MAX_UPLOAD_LIMIT->k
-  };
-  static std::set<std::string> options(vbegin(OPTIONS), vend(OPTIONS));
-  return options;
-}
-
-void RpcMethod::gatherChangeableOption
-(const SharedHandle<Option>& option, const Dict* optionsDict)
+void RpcMethod::gatherChangeableOption(Option* option, const Dict* optionsDict)
 {
   if(optionsDict) {
     gatherOption(optionsDict->begin(), optionsDict->end(),
-                 listChangeableOptions(),
+                 mem_fun_sh(&OptionHandler::getChangeOption),
                  option, optionParser_);
   }
 }
 
-void RpcMethod::applyChangeableOption(Option* dest, Option* src) const
-{
-  applyOption(listChangeableOptions().begin(), listChangeableOptions().end(),
-              dest, src);
-}
-
-const std::set<std::string>& listChangeableGlobalOptions()
-{
-  static const std::string OPTIONS[] = {
-    PREF_MAX_OVERALL_UPLOAD_LIMIT->k,
-    PREF_MAX_OVERALL_DOWNLOAD_LIMIT->k,
-    PREF_MAX_CONCURRENT_DOWNLOADS->k,
-    PREF_LOG->k,
-    PREF_LOG_LEVEL->k
-  };
-  static std::set<std::string> options(vbegin(OPTIONS), vend(OPTIONS));
-  return options;
-}
-
 void RpcMethod::gatherChangeableGlobalOption
-(const SharedHandle<Option>& option, const Dict* optionsDict)
+(Option* option, const Dict* optionsDict)
 {
   if(optionsDict) {
     gatherOption(optionsDict->begin(), optionsDict->end(),
-                 listChangeableGlobalOptions(),
+                 mem_fun_sh(&OptionHandler::getGlobalChangeOption),
                  option, optionParser_);
   }
 }
 
-void RpcMethod::applyChangeableGlobalOption(Option* dest, Option* src) const
-{
-  applyOption(listChangeableGlobalOptions().begin(),
-              listChangeableGlobalOptions().end(),
-              dest, src);
-}
-
 } // namespace rpc
 
 } // namespace aria2