Convert CommandMap to use std::string instead of char*

This allows it to own its keys and clean them up automatically on
destruction.

src/command_dynamic.cc

@@ -143,11 +143,11 @@ system_method_insert_object(const torrent::Object::list_type& args, int flags) {
     throw torrent::input_error("Invalid argument count.");
 
   torrent::Object::list_const_iterator itrArgs = args.begin();
-  const std::string& rawKey = (itrArgs++)->as_string();
+  const std::string& raw_key = (itrArgs++)->as_string();
 
-  if (rawKey.empty() ||
-      control->object_storage()->find_raw_string(torrent::raw_string::from_string(rawKey)) != control->object_storage()->end() ||
-      rpc::commands.has(rawKey) || rpc::commands.has(rawKey + ".set"))
+  if (raw_key.empty() ||
+      control->object_storage()->find_raw_string(torrent::raw_string::from_string(raw_key)) != control->object_storage()->end() ||
+      rpc::commands.has(raw_key) || rpc::commands.has(raw_key + ".set"))
     throw torrent::input_error("Invalid key.");
 
   torrent::Object value;
@@ -186,25 +186,25 @@ system_method_insert_object(const torrent::Object::list_type& args, int flags) {
     if ((itrArgs)->is_list())
       valueListType = (itrArgs)->as_list();
 
-    control->object_storage()->insert_str(rawKey, valueList, flags);
+    control->object_storage()->insert_str(raw_key, valueList, flags);
   } else {
-    control->object_storage()->insert_str(rawKey, value, flags);
+    control->object_storage()->insert_str(raw_key, value, flags);
   }
 
   if ((flags & rpc::object_storage::mask_type) == rpc::object_storage::flag_function_type ||
       (flags & rpc::object_storage::mask_type) == rpc::object_storage::flag_multi_type) {
 
     rpc::commands.insert_slot<rpc::command_base_is_type<rpc::command_base_call<rpc::target_type> >::type>
-      (create_new_key(rawKey),
+      (raw_key,
        std::bind(&rpc::object_storage::call_function_str, control->object_storage(),
-                 rawKey, std::placeholders::_1, std::placeholders::_2),
+                 raw_key, std::placeholders::_1, std::placeholders::_2),
        &rpc::command_base_call<rpc::target_type>,
        cmd_flags, NULL, NULL);
 
   } else {
     rpc::commands.insert_slot<rpc::command_base_is_type<rpc::command_base_call<rpc::target_type> >::type>
-      (create_new_key(rawKey),
-       std::bind(&rpc::object_storage::get_str, control->object_storage(), rawKey),
+      (raw_key,
+       std::bind(&rpc::object_storage::get_str, control->object_storage(), raw_key),
        &rpc::command_base_call<rpc::target_type>,
        cmd_flags, NULL, NULL);
   }
@@ -226,29 +226,29 @@ system_method_insert_object(const torrent::Object::list_type& args, int flags) {
     switch (flags & rpc::object_storage::mask_type) {
     case rpc::object_storage::flag_bool_type:
       rpc::commands.insert_slot<rpc::command_base_is_type<rpc::command_base_call_value<rpc::target_type> >::type>
-        (create_new_key<5>(rawKey, ".set"),
-         std::bind(&rpc::object_storage::set_str_bool, control->object_storage(), rawKey, std::placeholders::_2),
+        (raw_key + ".set",
+         std::bind(&rpc::object_storage::set_str_bool, control->object_storage(), raw_key, std::placeholders::_2),
          &rpc::command_base_call_value<rpc::target_type>,
          cmd_flags, NULL, NULL);
       break;
     case rpc::object_storage::flag_value_type:
       rpc::commands.insert_slot<rpc::command_base_is_type<rpc::command_base_call_value<rpc::target_type> >::type>
-        (create_new_key<5>(rawKey, ".set"),
-         std::bind(&rpc::object_storage::set_str_value, control->object_storage(), rawKey, std::placeholders::_2),
+        (raw_key + ".set",
+         std::bind(&rpc::object_storage::set_str_value, control->object_storage(), raw_key, std::placeholders::_2),
          &rpc::command_base_call_value<rpc::target_type>,
          cmd_flags, NULL, NULL);
       break;
     case rpc::object_storage::flag_string_type:
       rpc::commands.insert_slot<rpc::command_base_is_type<rpc::command_base_call_string<rpc::target_type> >::type>
-        (create_new_key<5>(rawKey, ".set"),
-         std::bind(&rpc::object_storage::set_str_string, control->object_storage(), rawKey, std::placeholders::_2),
+        (raw_key + ".set",
+         std::bind(&rpc::object_storage::set_str_string, control->object_storage(), raw_key, std::placeholders::_2),
          &rpc::command_base_call_string<rpc::target_type>,
          cmd_flags, NULL, NULL);
       break;
     case rpc::object_storage::flag_list_type:
       rpc::commands.insert_slot<rpc::command_base_is_type<rpc::command_base_call_list<rpc::target_type> >::type>
-        (create_new_key<5>(rawKey, ".set"),
-         std::bind(&rpc::object_storage::set_str_list, control->object_storage(), rawKey, std::placeholders::_2),
+        (raw_key + ".set",
+         std::bind(&rpc::object_storage::set_str_list, control->object_storage(), raw_key, std::placeholders::_2),
          &rpc::command_base_call_list<rpc::target_type>,
          cmd_flags, NULL, NULL);
       break;
@@ -345,7 +345,7 @@ system_method_redirect(const torrent::Object::list_type& args) {
   std::string new_key  = torrent::object_create_string(args.front());
   std::string dest_key = torrent::object_create_string(args.back());
 
-  rpc::commands.create_redirect(create_new_key(new_key), create_new_key(dest_key),
+  rpc::commands.create_redirect(new_key, dest_key,
                                 rpc::CommandMap::flag_public_xmlrpc | rpc::CommandMap::flag_delete_key | rpc::CommandMap::flag_modifiable);
 
   return torrent::Object();

src/command_helpers.h

@@ -148,11 +148,11 @@ void initialize_commands();
   rpc::commands.create_redirect(from_key, to_key, rpc::CommandMap::flag_public_xmlrpc | rpc::CommandMap::flag_tracker_target | rpc::CommandMap::flag_dont_delete);
 
 #define CMD2_REDIRECT_GENERIC_STR(from_key, to_key)                     \
-  rpc::commands.create_redirect(create_new_key(from_key), create_new_key(to_key), \
+  rpc::commands.create_redirect(from_key, to_key, \
                                 rpc::CommandMap::flag_public_xmlrpc | rpc::CommandMap::flag_no_target | rpc::CommandMap::flag_delete_key);
 
 #define CMD2_REDIRECT_GENERIC_STR_NO_EXPORT(from_key, to_key)                     \
-  rpc::commands.create_redirect(create_new_key(from_key), create_new_key(to_key), \
+  rpc::commands.create_redirect(from_key, to_key, \
                                 rpc::CommandMap::flag_no_target | rpc::CommandMap::flag_delete_key);
 
 //
@@ -188,24 +188,4 @@ template <typename T>
 object_convert_type<T, void>
 object_convert_void(T f) { return f; }
 
-//
-// Key creation:
-//
-
-template <int postfix_size>
-inline const char*
-create_new_key(const std::string& key, const char postfix[postfix_size]) {
-  char *buffer = new char[key.size() + std::max(postfix_size, 1)];
-  std::memcpy(buffer, key.c_str(), key.size() + 1);
-  std::memcpy(buffer + key.size(), postfix, postfix_size);
-  return buffer;
-}
-
-inline const char*
-create_new_key(const std::string& key) {
-  char *buffer = new char[key.size() + 1];
-  std::memcpy(buffer, key.c_str(), key.size() + 1);
-  return buffer;
-}
-
 #endif

src/command_network.cc

@@ -135,7 +135,7 @@ initialize_xmlrpc() {
     if (!(itr->second.m_flags & rpc::CommandMap::flag_public_xmlrpc))
       continue;
 
-    rpc::xmlrpc.insert_command(itr->first, itr->second.m_parm, itr->second.m_doc);
+    rpc::xmlrpc.insert_command(itr->first.c_str(), itr->second.m_parm, itr->second.m_doc);
   }
 
   lt_log_print(torrent::LOG_RPC_EVENTS, "XMLRPC initialized with %u functions.", count);

src/rpc/command_map.cc

@@ -36,7 +36,6 @@
 
 #include "config.h"
 
-#include <vector>
 #include <torrent/exceptions.h>
 #include <torrent/object.h>
 #include <torrent/data/file_list_iterator.h>
@@ -57,23 +56,8 @@ namespace rpc {
 
 command_base::stack_type command_base::current_stack;
 
-CommandMap::~CommandMap() {
-  std::vector<const char*> keys;
-
-  for (iterator itr = base_type::begin(), last = base_type::end(); itr != last; itr++) {
-//     if (!(itr->second.m_flags & flag_dont_delete))
-//       delete itr->second.m_variable;
-
-    if (itr->second.m_flags & flag_delete_key)
-      keys.push_back(itr->first);
-  }
-
-  for (std::vector<const char*>::iterator itr = keys.begin(), last = keys.end(); itr != last; itr++)
-    delete [] *itr;
-}
-
 CommandMap::iterator
-CommandMap::insert(key_type key, int flags, const char* parm, const char* doc) {
+CommandMap::insert(const key_type& key, int flags, const char* parm, const char* doc) {
   iterator itr = base_type::find(key);
 
   if (itr != base_type::end())
@@ -81,25 +65,11 @@ CommandMap::insert(key_type key, int flags, const char* parm, const char* doc) {
 
   // TODO: This is not honoring the public_xmlrpc flags!!!
   if (rpc::xmlrpc.is_valid() && (flags & flag_public_xmlrpc))
-  // if (rpc::xmlrpc.is_valid())
-    rpc::xmlrpc.insert_command(key, parm, doc);
+    rpc::xmlrpc.insert_command(key.c_str(), parm, doc);
 
   return base_type::insert(itr, value_type(key, command_map_data_type(flags, parm, doc)));
 }
 
-// void
-// CommandMap::insert(key_type key, const command_map_data_type src) {
-//   iterator itr = base_type::find(key);
-
-//   if (itr != base_type::end())
-//     throw torrent::internal_error("CommandMap::insert(...) tried to insert an already existing key.");
-
-//   itr = base_type::insert(itr, value_type(key, command_map_data_type(src.m_variable, src.m_flags | flag_dont_delete, src.m_parm, src.m_doc)));
-
-//   // We can assume all the slots are the same size.
-//   itr->second.m_anySlot = src.m_anySlot;
-// }
-
 void
 CommandMap::erase(iterator itr) {
   if (itr == end())
@@ -112,14 +82,11 @@ CommandMap::erase(iterator itr) {
 //   if (!(itr->second.m_flags & flag_dont_delete))
 //     delete itr->second.m_variable;
 
-  const char* key = itr->second.m_flags & flag_delete_key ? itr->first : NULL;
-
   base_type::erase(itr);
-  delete [] key;
 }
 
 void
-CommandMap::create_redirect(key_type key_new, key_type key_dest, int flags) {
+CommandMap::create_redirect(const key_type& key_new, const key_type& key_dest, int flags) {
   iterator new_itr  = base_type::find(key_new);
   iterator dest_itr = base_type::find(key_dest);
 
@@ -139,7 +106,7 @@ CommandMap::create_redirect(key_type key_new, key_type key_dest, int flags) {
 
   // TODO: This is not honoring the public_xmlrpc flags!!!
   if (rpc::xmlrpc.is_valid() && (flags & flag_public_xmlrpc))
-    rpc::xmlrpc.insert_command(key_new, dest_itr->second.m_parm, dest_itr->second.m_doc);
+    rpc::xmlrpc.insert_command(key_new.c_str(), dest_itr->second.m_parm, dest_itr->second.m_doc);
 
   iterator itr = base_type::insert(base_type::end(),
                                    value_type(key_new, command_map_data_type(flags,
@@ -152,7 +119,7 @@ CommandMap::create_redirect(key_type key_new, key_type key_dest, int flags) {
 }
 
 const CommandMap::mapped_type
-CommandMap::call_catch(key_type key, target_type target, const mapped_type& args, const char* err) {
+CommandMap::call_catch(const key_type& key, const target_type& target, const mapped_type& args, const char* err) {
   try {
     return call_command(key, args, target);
   } catch (torrent::input_error& e) {
@@ -162,7 +129,7 @@ CommandMap::call_catch(key_type key, target_type target, const mapped_type& args
 }
 
 const CommandMap::mapped_type
-CommandMap::call_command(key_type key, const mapped_type& arg, target_type target) {
+CommandMap::call_command(const key_type& key, const mapped_type& arg, const target_type& target) {
   iterator itr = base_type::find(key);
 
   if (itr == base_type::end())
@@ -172,7 +139,7 @@ CommandMap::call_command(key_type key, const mapped_type& arg, target_type targe
 }
 
 const CommandMap::mapped_type
-CommandMap::call_command(iterator itr, const mapped_type& arg, target_type target) {
+CommandMap::call_command(iterator itr, const mapped_type& arg, const target_type& target) {
   return itr->second.m_anySlot(&itr->second.m_variable, target, arg);
 }
 

src/rpc/command_map.h

@@ -46,10 +46,6 @@
 
 namespace rpc {
 
-struct command_map_comp : public std::binary_function<const char*, const char*, bool> {
-  bool operator () (const char* arg1, const char* arg2) const { return std::strcmp(arg1, arg2) < 0; }
-};
-
 struct command_map_data_type {
   // Some commands will need to share data, like get/set a variable. So
   // instead of using a single virtual member function, each command
@@ -73,9 +69,9 @@ struct command_map_data_type {
   const char*   m_doc;
 };
 
-class CommandMap : public std::map<const char*, command_map_data_type, command_map_comp> {
+class CommandMap : public std::map<std::string, command_map_data_type> {
 public:
-  typedef std::map<const char*, command_map_data_type, command_map_comp> base_type;
+  typedef std::map<std::string, command_map_data_type> base_type;
 
   typedef torrent::Object         mapped_type;
   typedef mapped_type::value_type mapped_value_type;
@@ -101,39 +97,37 @@ public:
   static const int flag_tracker_target = 0x400;
 
   CommandMap() {}
-  ~CommandMap();
+  ~CommandMap() {}
 
-  bool                has(const char* key) const        { return base_type::find(key) != base_type::end(); }
-  bool                has(const std::string& key) const { return has(key.c_str()); }
+  bool                has(const std::string& key) const { return base_type::find(key) != base_type::end(); }
 
   bool                is_modifiable(const_iterator itr) { return itr != end() && (itr->second.m_flags & flag_modifiable); }
 
-  iterator            insert(key_type key, int flags, const char* parm, const char* doc);
+  iterator            insert(const key_type& key, int flags, const char* parm, const char* doc);
 
   template <typename T, typename Slot>
   void
-  insert_slot(key_type key, Slot variable, command_base::any_slot targetSlot, int flags, const char* parm, const char* doc) {
+  insert_slot(const key_type& key, Slot variable, command_base::any_slot target_slot, int flags, const char* parm, const char* doc) {
     iterator itr = insert(key, flags, parm, doc);
     itr->second.m_variable.set_function<T>(variable);
-    itr->second.m_anySlot = targetSlot;
+    itr->second.m_anySlot = target_slot;
   }
 
-  //  void                insert(key_type key, const command_map_data_type src);
   void                erase(iterator itr);
 
-  void                create_redirect(key_type key_new, key_type key_dest, int flags);
+  void                create_redirect(const key_type& key_new, const key_type& key_dest, int flags);
 
-  const mapped_type   call(key_type key, const mapped_type& args = mapped_type());
-  const mapped_type   call(key_type key, target_type target, const mapped_type& args = mapped_type()) { return call_command(key, args, target); }
-  const mapped_type   call_catch(key_type key, target_type target, const mapped_type& args = mapped_type(), const char* err = "Command failed: ");
+  const mapped_type   call(const key_type& key, const mapped_type& args = mapped_type());
+  const mapped_type   call(const key_type& key, const target_type& target, const mapped_type& args = mapped_type()) { return call_command(key, args, target); }
+  const mapped_type   call_catch(const key_type& key, const target_type& target, const mapped_type& args = mapped_type(), const char* err = "Command failed: ");
 
-  const mapped_type   call_command  (key_type key, const mapped_type& arg, target_type target = target_type((int)command_base::target_generic, NULL));
-  const mapped_type   call_command  (iterator itr, const mapped_type& arg, target_type target = target_type((int)command_base::target_generic, NULL));
+  const mapped_type   call_command  (const key_type& key, const mapped_type& arg, const target_type& target = target_type((int)command_base::target_generic, NULL));
+  const mapped_type   call_command  (iterator itr, const mapped_type& arg, const target_type& target = target_type((int)command_base::target_generic, NULL));
 
-  const mapped_type   call_command_d(key_type key, core::Download* download, const mapped_type& arg)  { return call_command(key, arg, target_type((int)command_base::target_download, download)); }
-  const mapped_type   call_command_p(key_type key, torrent::Peer* peer, const mapped_type& arg)       { return call_command(key, arg, target_type((int)command_base::target_peer, peer)); }
-  const mapped_type   call_command_t(key_type key, torrent::Tracker* tracker, const mapped_type& arg) { return call_command(key, arg, target_type((int)command_base::target_tracker, tracker)); }
-  const mapped_type   call_command_f(key_type key, torrent::File* file, const mapped_type& arg)       { return call_command(key, arg, target_type((int)command_base::target_file, file)); }
+  const mapped_type   call_command_d(const key_type& key, core::Download* download, const mapped_type& arg)  { return call_command(key, arg, target_type((int)command_base::target_download, download)); }
+  const mapped_type   call_command_p(const key_type& key, torrent::Peer* peer, const mapped_type& arg)       { return call_command(key, arg, target_type((int)command_base::target_peer, peer)); }
+  const mapped_type   call_command_t(const key_type& key, torrent::Tracker* tracker, const mapped_type& arg) { return call_command(key, arg, target_type((int)command_base::target_tracker, tracker)); }
+  const mapped_type   call_command_f(const key_type& key, torrent::File* file, const mapped_type& arg)       { return call_command(key, arg, target_type((int)command_base::target_file, file)); }
 
 private:
   CommandMap(const CommandMap&);
@@ -175,7 +169,7 @@ create_object_list(const torrent::Object& o1, const torrent::Object& o2, const t
 }
 
 inline const CommandMap::mapped_type
-CommandMap::call(key_type key, const mapped_type& args) {
+CommandMap::call(const key_type& key, const mapped_type& args) {
   return call_command(key, args, make_target());
 }