fujin/rtorrent
1
0
Fork 0
mirror of https://github.com/rakshasa/rtorrent.git synced 2026-10-14 13:16:17 +00:00
Code Issues Packages Projects Releases Wiki Activity

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

Browse Source 
This allows it to own its keys and clean them up automatically on
destruction.
This commit is contained in:
kannibalox
2024-10-27 11:07:41 -04:00
committed by Jari Sundell
parent ef937863fd
commit 34de2b4ac9
5 changed files with 47 additions and 106 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/command_dynamic.cc
+19 -19
View File
@@ -143,11 +143,11 @@ system_method_insert_object(const torrent::Object::list_type& args, int flags) {
throw torrent::input_error("Invalid argument count."); throw torrent::input_error("Invalid argument count.");
torrent::Object::list_const_iterator itrArgs = args.begin(); 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() || if (raw_key.empty() ||
control->object_storage()->find_raw_string(torrent::raw_string::from_string(rawKey)) != control->object_storage()->end() || control->object_storage()->find_raw_string(torrent::raw_string::from_string(raw_key)) != control->object_storage()->end() ||
rpc::commands.has(rawKey) || rpc::commands.has(rawKey + ".set")) rpc::commands.has(raw_key) || rpc::commands.has(raw_key + ".set"))
throw torrent::input_error("Invalid key."); throw torrent::input_error("Invalid key.");
torrent::Object value; torrent::Object value;
@@ -186,25 +186,25 @@ system_method_insert_object(const torrent::Object::list_type& args, int flags) {
if ((itrArgs)->is_list()) if ((itrArgs)->is_list())
valueListType = (itrArgs)->as_list(); valueListType = (itrArgs)->as_list();
control->object_storage()->insert_str(rawKey, valueList, flags); control->object_storage()->insert_str(raw_key, valueList, flags);
} else { } 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 || 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) { (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> 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(), 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>, &rpc::command_base_call<rpc::target_type>,
cmd_flags, NULL, NULL); cmd_flags, NULL, NULL);
} else { } else {
rpc::commands.insert_slot<rpc::command_base_is_type<rpc::command_base_call<rpc::target_type> >::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::get_str, control->object_storage(), rawKey), std::bind(&rpc::object_storage::get_str, control->object_storage(), raw_key),
&rpc::command_base_call<rpc::target_type>, &rpc::command_base_call<rpc::target_type>,
cmd_flags, NULL, NULL); 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) { switch (flags & rpc::object_storage::mask_type) {
case rpc::object_storage::flag_bool_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> rpc::commands.insert_slot<rpc::command_base_is_type<rpc::command_base_call_value<rpc::target_type> >::type>
(create_new_key<5>(rawKey, ".set"), (raw_key + ".set",
std::bind(&rpc::object_storage::set_str_bool, control->object_storage(), rawKey, std::placeholders::_2), std::bind(&rpc::object_storage::set_str_bool, control->object_storage(), raw_key, std::placeholders::_2),
&rpc::command_base_call_value<rpc::target_type>, &rpc::command_base_call_value<rpc::target_type>,
cmd_flags, NULL, NULL); cmd_flags, NULL, NULL);
break; break;
case rpc::object_storage::flag_value_type: 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> rpc::commands.insert_slot<rpc::command_base_is_type<rpc::command_base_call_value<rpc::target_type> >::type>
(create_new_key<5>(rawKey, ".set"), (raw_key + ".set",
std::bind(&rpc::object_storage::set_str_value, control->object_storage(), rawKey, std::placeholders::_2), std::bind(&rpc::object_storage::set_str_value, control->object_storage(), raw_key, std::placeholders::_2),
&rpc::command_base_call_value<rpc::target_type>, &rpc::command_base_call_value<rpc::target_type>,
cmd_flags, NULL, NULL); cmd_flags, NULL, NULL);
break; break;
case rpc::object_storage::flag_string_type: 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> rpc::commands.insert_slot<rpc::command_base_is_type<rpc::command_base_call_string<rpc::target_type> >::type>
(create_new_key<5>(rawKey, ".set"), (raw_key + ".set",
std::bind(&rpc::object_storage::set_str_string, control->object_storage(), rawKey, std::placeholders::_2), std::bind(&rpc::object_storage::set_str_string, control->object_storage(), raw_key, std::placeholders::_2),
&rpc::command_base_call_string<rpc::target_type>, &rpc::command_base_call_string<rpc::target_type>,
cmd_flags, NULL, NULL); cmd_flags, NULL, NULL);
break; break;
case rpc::object_storage::flag_list_type: 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> rpc::commands.insert_slot<rpc::command_base_is_type<rpc::command_base_call_list<rpc::target_type> >::type>
(create_new_key<5>(rawKey, ".set"), (raw_key + ".set",
std::bind(&rpc::object_storage::set_str_list, control->object_storage(), rawKey, std::placeholders::_2), std::bind(&rpc::object_storage::set_str_list, control->object_storage(), raw_key, std::placeholders::_2),
&rpc::command_base_call_list<rpc::target_type>, &rpc::command_base_call_list<rpc::target_type>,
cmd_flags, NULL, NULL); cmd_flags, NULL, NULL);
break; 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 new_key = torrent::object_create_string(args.front());
std::string dest_key = torrent::object_create_string(args.back()); 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); rpc::CommandMap::flag_public_xmlrpc | rpc::CommandMap::flag_delete_key | rpc::CommandMap::flag_modifiable);
return torrent::Object(); return torrent::Object();
src/command_helpers.h
+2 -22
View File
@@ -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); 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) \ #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); 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) \ #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); rpc::CommandMap::flag_no_target | rpc::CommandMap::flag_delete_key);
// //
@@ -188,24 +188,4 @@ template <typename T>
object_convert_type<T, void> object_convert_type<T, void>
object_convert_void(T f) { return f; } 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 #endif
src/command_network.cc
+1 -1
View File
@@ -135,7 +135,7 @@ initialize_xmlrpc() {
if (!(itr->second.m_flags & rpc::CommandMap::flag_public_xmlrpc)) if (!(itr->second.m_flags & rpc::CommandMap::flag_public_xmlrpc))
continue; 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); lt_log_print(torrent::LOG_RPC_EVENTS, "XMLRPC initialized with %u functions.", count);
src/rpc/command_map.cc
+7 -40
View File
@@ -36,7 +36,6 @@
#include "config.h" #include "config.h"
#include <vector>
#include <torrent/exceptions.h> #include <torrent/exceptions.h>
#include <torrent/object.h> #include <torrent/object.h>
#include <torrent/data/file_list_iterator.h> #include <torrent/data/file_list_iterator.h>
@@ -57,23 +56,8 @@ namespace rpc {
command_base::stack_type command_base::current_stack; 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::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); iterator itr = base_type::find(key);
if (itr != base_type::end()) 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!!! // TODO: This is not honoring the public_xmlrpc flags!!!
if (rpc::xmlrpc.is_valid() && (flags & flag_public_xmlrpc)) if (rpc::xmlrpc.is_valid() && (flags & flag_public_xmlrpc))
// if (rpc::xmlrpc.is_valid()) rpc::xmlrpc.insert_command(key.c_str(), parm, doc);
rpc::xmlrpc.insert_command(key, parm, doc);
return base_type::insert(itr, value_type(key, command_map_data_type(flags, 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 void
CommandMap::erase(iterator itr) { CommandMap::erase(iterator itr) {
if (itr == end()) if (itr == end())
@@ -112,14 +82,11 @@ CommandMap::erase(iterator itr) {
// if (!(itr->second.m_flags & flag_dont_delete)) // if (!(itr->second.m_flags & flag_dont_delete))
// delete itr->second.m_variable; // delete itr->second.m_variable;
const char* key = itr->second.m_flags & flag_delete_key ? itr->first : NULL;
base_type::erase(itr); base_type::erase(itr);
delete [] key;
} }
void 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 new_itr = base_type::find(key_new);
iterator dest_itr = base_type::find(key_dest); 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!!! // TODO: This is not honoring the public_xmlrpc flags!!!
if (rpc::xmlrpc.is_valid() && (flags & flag_public_xmlrpc)) 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(), iterator itr = base_type::insert(base_type::end(),
value_type(key_new, command_map_data_type(flags, 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 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 { try {
return call_command(key, args, target); return call_command(key, args, target);
} catch (torrent::input_error& e) { } 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 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); iterator itr = base_type::find(key);
if (itr == base_type::end()) 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 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); return itr->second.m_anySlot(&itr->second.m_variable, target, arg);
} }
src/rpc/command_map.h
+18 -24
View File
@@ -46,10 +46,6 @@
namespace rpc { 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 { struct command_map_data_type {
// Some commands will need to share data, like get/set a variable. So // Some commands will need to share data, like get/set a variable. So
// instead of using a single virtual member function, each command // instead of using a single virtual member function, each command
@@ -73,9 +69,9 @@ struct command_map_data_type {
const char* m_doc; 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: 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 torrent::Object mapped_type;
typedef mapped_type::value_type mapped_value_type; typedef mapped_type::value_type mapped_value_type;
@@ -101,39 +97,37 @@ public:
static const int flag_tracker_target = 0x400; static const int flag_tracker_target = 0x400;
CommandMap() {} 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 base_type::find(key) != base_type::end(); }
bool has(const std::string& key) const { return has(key.c_str()); }
bool is_modifiable(const_iterator itr) { return itr != end() && (itr->second.m_flags & flag_modifiable); } 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> template <typename T, typename Slot>
void 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); iterator itr = insert(key, flags, parm, doc);
itr->second.m_variable.set_function<T>(variable); 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 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(const 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(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(key_type key, target_type target, const mapped_type& args = mapped_type(), const char* err = "Command failed: "); 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 (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, 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_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(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_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(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_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(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_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: private:
CommandMap(const CommandMap&); 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 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()); return call_command(key, args, make_target());
} }