Syping/dtranslatebot
1
0
Fork 0
mirror of https://github.com/Syping/dtranslatebot.git synced 2024-11-25 07:10:23 +01:00
Code Issues Projects Releases Packages Wiki Activity

code optimisations and potential unique_ptr leak fix

Browse source
This commit is contained in:
Syping 2024-01-29 22:47:42 +01:00
parent eb301aee1c
commit f871441b78
7 changed files with 48 additions and 36 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

8
src/main.cpp
View file

@ -140,7 +140,7 @@ int main(int argc, char* argv[]) {
bot::settings::target s_target;
s_target.target = target;
s_target.webhook = webhook;
s_channel.targets.push_back(s_target);
s_channel.targets.emplace_back(s_target);
settings.lock();
settings.add_channel(s_channel, event.command.guild_id);
@ -158,7 +158,7 @@ int main(int argc, char* argv[]) {
bot::settings::target s_target;
s_target.target = target;
s_target.webhook = *webhook;
s_channel.targets.push_back(s_target);
s_channel.targets.emplace_back(s_target);
settings.lock();
settings.add_channel(s_channel, event.command.guild_id);
@ -217,7 +217,7 @@ int main(int argc, char* argv[]) {
webhook_subcommand.add_option(webhook_option);
command_translate.add_option(channel_subcommand);
command_translate.add_option(webhook_subcommand);
commands.push_back(command_translate);
commands.emplace_back(command_translate);
if (preferred_languages.size() > 1) {
dpp::slashcommand command_translate_pref("translate_pref", "Translate current channel (Preferred languages)", bot.me.id);
@ -240,7 +240,7 @@ int main(int argc, char* argv[]) {
webhook_pref_subcommand.add_option(webhook_option);
command_translate_pref.add_option(channel_pref_subcommand);
command_translate_pref.add_option(webhook_pref_subcommand);
commands.push_back(command_translate_pref);
commands.emplace_back(command_translate_pref);
}
bot.global_bulk_command_create(commands);

18
src/settings.cpp
View file

@ -16,8 +16,9 @@
* responsible for anything with use of the software, you are self responsible.
*****************************************************************************/
#include <dpp/dpp.h>
#include <dpp/json.h>
#include <mutex>
#include <fstream>
#include <iostream>
#include "settings.h"
#include "translate_libretranslate.h"
@ -34,8 +35,8 @@ void bot::settings::settings::add_channel(const bot::settings::channel &channel,
// We will create the guild structure when it is not in memory
bot::settings::guild guild;
guild.id = guild_id;
guild.channel.push_back(channel);
m_guilds.push_back(guild);
guild.channel.emplace_back(channel);
m_guilds.emplace_back(guild);
}
void bot::settings::settings::add_translatebot_webhook(const dpp::webhook &webhook)
@ -65,6 +66,7 @@ const bot::settings::channel* bot::settings::settings::get_channel(dpp::snowflak
if (channel->id == channel_id)
return &(*channel);
}
return nullptr;
}
}
return nullptr;
@ -92,7 +94,7 @@ const bot::settings::translate* bot::settings::settings::get_translate()
std::unique_ptr<bot::translate::translator> bot::settings::settings::get_translator()
{
const std::lock_guard<std::recursive_mutex> guard(m_mutex);
std::unique_ptr<bot::translate::translator> libretranslate(
std::unique_ptr<bot::translate::libretranslate> libretranslate(
new bot::translate::libretranslate(m_translate.hostname, m_translate.port, m_translate.url, m_translate.tls, m_translate.apiKey));
return libretranslate;
}
@ -246,7 +248,7 @@ bool bot::settings::settings::parse(const std::string &filename)
bot::settings::target target;
target.target = json_channel_target.value();
target.webhook = dpp::webhook(json_channel->at("webhook"));
channel.targets.push_back(target);
channel.targets.emplace_back(target);
m_webhookIds.push_back(target.webhook.id);
}
else if (json_channel_target.value().is_object()) {
@ -254,17 +256,17 @@ bool bot::settings::settings::parse(const std::string &filename)
bot::settings::target target;
target.target = json_target.key();
target.webhook = dpp::webhook(json_target.value());
channel.targets.push_back(target);
channel.targets.emplace_back(target);
m_webhookIds.push_back(target.webhook.id);
}
}
}
if (!channel.source.empty() && !channel.targets.empty())
guild.channel.push_back(channel);
guild.channel.emplace_back(channel);
}
}
m_guilds.push_back(guild);
m_guilds.emplace_back(guild);
}
}
}

4
src/translate_core.cpp
View file

@ -23,6 +23,10 @@ bot::translate::translator::translator()
{
}
bot::translate::translator::~translator()
{
}
const std::vector<bot::translate::language> bot::translate::translator::get_languages()
{
std::cerr << "WARNING: translator::get_languages() have being called." << std::endl;

1
src/translate_core.h
View file

@ -32,6 +32,7 @@ namespace bot {
class translator {
public:
explicit translator();
virtual ~translator();
virtual const std::vector<bot::translate::language> get_languages();
virtual const std::string translate(const std::string &text, const std::string &source, const std::string &target);
};

29
src/translate_libretranslate.cpp
View file

@ -19,12 +19,17 @@
#include <dpp/json.h>
#include <dpp/httpsclient.h>
#include "translate_libretranslate.h"
using namespace std::string_literals;
bot::translate::libretranslate::libretranslate(const std::string &hostname, uint16_t port, const std::string &url, bool tls, const std::string apiKey) :
m_hostname(hostname), m_port(port), m_url(url), m_tls(tls), m_apiKey(apiKey)
{
}
bot::translate::libretranslate::~libretranslate()
{
}
const std::vector<bot::translate::language> bot::translate::libretranslate::get_languages()
{
std::vector<bot::translate::language> languages;
@ -34,20 +39,20 @@ const std::vector<bot::translate::language> bot::translate::libretranslate::get_
if (http_request.get_status() == 200) {
const dpp::json response = dpp::json::parse(http_request.get_content());
if (response.is_array()) {
for (auto json_language = response.begin(); json_language != response.end(); json_language++) {
if (json_language->is_object()) {
for (const auto &json_language : response) {
if (json_language.is_object()) {
bot::translate::language language;
auto json_lang_code = json_language.value().find("code");
if (json_lang_code != json_language.value().end())
auto json_lang_code = json_language.find("code");
if (json_lang_code != json_language.end())
language.code = json_lang_code.value();
auto json_lang_name = json_language.value().find("name");
if (json_lang_name != json_language.value().end())
auto json_lang_name = json_language.find("name");
if (json_lang_name != json_language.end())
language.name = json_lang_name.value();
if (!language.code.empty() && !language.name.empty())
languages.push_back(language);
languages.emplace_back(language);
}
}
}
@ -66,14 +71,14 @@ const std::vector<bot::translate::language> bot::translate::libretranslate::get_
const std::string bot::translate::libretranslate::translate(const std::string &text, const std::string &source, const std::string &target)
{
const dpp::http_headers http_headers = {
{"Content-Type", "application/json"}
{"Content-Type"s, "application/json"s}
};
dpp::json json_body = {
{"q", text},
{"source", source},
{"target", target},
{"format", "text"}
{"q"s, text},
{"source"s, source},
{"target"s, target},
{"format"s, "text"s}
};
if (!m_apiKey.empty())

5
src/translate_libretranslate.h
View file

@ -28,8 +28,9 @@ namespace bot {
class libretranslate : public translator {
public:
explicit libretranslate(const std::string &hostname, uint16_t port, const std::string &url, bool tls, const std::string apiKey = {});
const std::vector<bot::translate::language> get_languages();
const std::string translate(const std::string &text, const std::string &source, const std::string &target);
~libretranslate() override;
const std::vector<bot::translate::language> get_languages() override;
const std::string translate(const std::string &text, const std::string &source, const std::string &target) override;
private:
std::string m_apiKey;

17
src/webhook_push.cpp
View file

@ -19,12 +19,14 @@
#include <future>
#include <regex>
#include "webhook_push.h"
using namespace std::string_literals;
using namespace std::string_view_literals;
void bot::webhook_push::run(const bot::translated_message &message, dpp::cluster *bot)
{
dpp::json json_body = {
{"username", message.author},
{"avatar_url", message.avatar}
{"username"s, message.author},
{"avatar_url"s, message.avatar}
};
// We will split too long messages into multiple messages
@ -39,18 +41,15 @@ void bot::webhook_push::run(const bot::translated_message &message, dpp::cluster
}
else {
std::cmatch match;
const std::regex eos_regex("^.*(\\.|\\?|\\!|\\。)\\s.*$");
const std::regex eop_regex("^.*(\\,)\\s.*$");
const std::regex eow_regex("^.*()\\s.*$");
if (std::regex_match(message_eov.begin(), message_eov.end(), match, eos_regex)) {
if (std::regex_match(message_eov.begin(), message_eov.end(), match, std::regex("^.*(\\.|\\?|\\!|\\。)\\s.*$"s))) {
json_body["content"] = message_v.substr(0, 1334 + match.position(1));
message_v = message_v.substr(1334 + match.position(1));
}
else if (std::regex_match(message_eov.begin(), message_eov.end(), match, eop_regex)) {
else if (std::regex_match(message_eov.begin(), message_eov.end(), match, std::regex("^.*(\\,)\\s.*$"s))) {
json_body["content"] = message_v.substr(0, 1334 + match.position(1));
message_v = message_v.substr(1334 + match.position(1));
}
else if (std::regex_match(message_eov.begin(), message_eov.end(), match, eow_regex)) {
else if (std::regex_match(message_eov.begin(), message_eov.end(), match, std::regex("^.*()\\s.*$"s))) {
json_body["content"] = message_v.substr(0, 1334 + match.position(1));
message_v = message_v.substr(1334 + match.position(1));
}
@ -63,7 +62,7 @@ void bot::webhook_push::run(const bot::translated_message &message, dpp::cluster
if (message_v.length() <= 2000) {
json_body["content"] = message_v;
message_v = std::string_view();
message_v = ""sv;
push_request(message.webhook.id, message.webhook.token, json_body.dump(), bot);
}
}