andreacavalli/tdlib-fork
Archived
1
0
Fork 0
Code Pull Requests Releases Activity

Add language_pack_database option.

Browse Source 
GitOrigin-RevId: 99f4b3f75f396d5b25287f4a98bae2dfdda9df00
This commit is contained in:
levlam 2018-07-20 16:15:19 +03:00
parent 846ecc89a7
commit 92c04286e3
4 changed files with 52 additions and 26 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

59
td/telegram/LanguagePackManager.cpp
View File

@ -21,21 +21,33 @@
namespace td { namespace td {
void LanguagePackManager::start_up() { void LanguagePackManager::start_up() {
std::lock_guard<std::mutex> lock(language_packs_mutex_); std::lock_guard<std::mutex> lock(language_database_mutex_);
manager_count_++; manager_count_++;
language_pack_ = G()->shared_config().get_option_string("language_pack"); language_pack_ = G()->shared_config().get_option_string("language_pack");
language_code_ = G()->shared_config().get_option_string("language_code"); language_code_ = G()->shared_config().get_option_string("language_code");
LOG(INFO) << "Use language pack " << language_pack_ << " with language " << language_code_;
string database_path = G()->shared_config().get_option_string("language_database_path");
auto it = language_databases_.find(database_path);
if (it == language_databases_.end()) {
it = language_databases_.emplace(database_path, make_unique<LanguageDatabase>()).first;
it->second->path_ = std::move(database_path);
// TODO open database
}
database_ = it->second.get();
// TODO load language_pack_version from database // TODO load language_pack_version from database
LOG(INFO) << "Use language pack " << language_pack_ << " with language " << language_code_ << " with database "
<< database_->path_;
} }
void LanguagePackManager::tear_down() { void LanguagePackManager::tear_down() {
std::lock_guard<std::mutex> lock(language_packs_mutex_); std::lock_guard<std::mutex> lock(language_database_mutex_);
manager_count_--; manager_count_--;
if (manager_count_ == 0) { if (manager_count_ == 0) {
LOG(INFO) << "Clear language packs"; // can't clear language packs, because the may be accessed later using synchronous requests
language_packs_.clear(); // LOG(INFO) << "Clear language packs";
// language_databases_.clear();
} }
} }
@ -60,7 +72,7 @@ void LanguagePackManager::on_language_code_changed() {
} }
void LanguagePackManager::on_language_pack_version_changed(int32 new_version) { void LanguagePackManager::on_language_pack_version_changed(int32 new_version) {
Language *language = get_language(language_pack_, language_code_); Language *language = get_language(database_, language_pack_, language_code_);
int32 version = language == nullptr ? static_cast<int32>(-1) : language->version_.load(); int32 version = language == nullptr ? static_cast<int32>(-1) : language->version_.load();
if (version == -1) { if (version == -1) {
return; return;
@ -113,7 +125,7 @@ void LanguagePackManager::on_update_language_pack(tl_object_ptr<telegram_api::la
return; return;
} }
Language *language = get_language(language_pack_, language_code_); Language *language = get_language(database_, language_pack_, language_code_);
int32 version = language == nullptr ? static_cast<int32>(-1) : language->version_.load(); int32 version = language == nullptr ? static_cast<int32>(-1) : language->version_.load();
if (difference->version_ <= version) { if (difference->version_ <= version) {
LOG(INFO) << "Skip applying already applied updates"; LOG(INFO) << "Skip applying already applied updates";
@ -136,11 +148,12 @@ void LanguagePackManager::inc_generation() {
// TODO preload language and load language_pack_version from database // TODO preload language and load language_pack_version from database
} }
LanguagePackManager::Language *LanguagePackManager::get_language(const string &language_pack, LanguagePackManager::Language *LanguagePackManager::get_language(LanguageDatabase *database,
const string &language_pack,
const string &language_code) { const string &language_code) {
std::unique_lock<std::mutex> lock(language_packs_mutex_); std::unique_lock<std::mutex> lock(database->mutex_);
auto it = language_packs_.find(language_pack); auto it = database->language_packs_.find(language_pack);
if (it == language_packs_.end()) { if (it == database->language_packs_.end()) {
return nullptr; return nullptr;
} }
LanguagePack *pack = it->second.get(); LanguagePack *pack = it->second.get();
@ -159,12 +172,13 @@ LanguagePackManager::Language *LanguagePackManager::get_language(LanguagePack *l
return it->second.get(); return it->second.get();
} }
LanguagePackManager::Language *LanguagePackManager::add_language(const string &language_pack, LanguagePackManager::Language *LanguagePackManager::add_language(LanguageDatabase *database,
const string &language_pack,
const string &language_code) { const string &language_code) {
std::lock_guard<std::mutex> packs_lock(language_packs_mutex_); std::lock_guard<std::mutex> packs_lock(database->mutex_);
auto pack_it = language_packs_.find(language_pack); auto pack_it = database->language_packs_.find(language_pack);
if (pack_it == language_packs_.end()) { if (pack_it == database->language_packs_.end()) {
pack_it = language_packs_.emplace(language_pack, make_unique<LanguagePack>()).first; pack_it = database->language_packs_.emplace(language_pack, make_unique<LanguagePack>()).first;
} }
LanguagePack *pack = pack_it->second.get(); LanguagePack *pack = pack_it->second.get();
@ -269,7 +283,7 @@ void LanguagePackManager::get_languages(Promise<td_api::object_ptr<td_api::langu
void LanguagePackManager::get_language_pack_strings(string language_code, vector<string> keys, void LanguagePackManager::get_language_pack_strings(string language_code, vector<string> keys,
Promise<td_api::object_ptr<td_api::languagePackStrings>> promise) { Promise<td_api::object_ptr<td_api::languagePackStrings>> promise) {
Language *language = get_language(language_pack_, language_code); Language *language = get_language(database_, language_pack_, language_code);
if (language_has_strings(language, keys)) { if (language_has_strings(language, keys)) {
return promise.set_value(get_language_pack_strings_object(language, keys)); return promise.set_value(get_language_pack_strings_object(language, keys));
} }
@ -318,11 +332,11 @@ void LanguagePackManager::on_get_language_pack_strings(
string language_pack, string language_code, int32 version, bool is_diff, vector<string> keys, string language_pack, string language_code, int32 version, bool is_diff, vector<string> keys,
vector<tl_object_ptr<telegram_api::LangPackString>> results, vector<tl_object_ptr<telegram_api::LangPackString>> results,
Promise<td_api::object_ptr<td_api::languagePackStrings>> promise) { Promise<td_api::object_ptr<td_api::languagePackStrings>> promise) {
Language *language = get_language(language_pack, language_code); Language *language = get_language(database_, language_pack, language_code);
bool is_version_changed = false; bool is_version_changed = false;
if (language == nullptr || (language->version_ < version || !keys.empty())) { if (language == nullptr || (language->version_ < version || !keys.empty())) {
if (language == nullptr) { if (language == nullptr) {
language = add_language(language_pack, language_code); language = add_language(database_, language_pack, language_code);
CHECK(language != nullptr); CHECK(language != nullptr);
} }
std::lock_guard<std::mutex> lock(language->mutex_); std::lock_guard<std::mutex> lock(language->mutex_);
@ -411,7 +425,7 @@ void LanguagePackManager::on_get_language_pack_strings(
} }
void LanguagePackManager::on_failed_get_difference(string language_pack, string language_code) { void LanguagePackManager::on_failed_get_difference(string language_pack, string language_code) {
Language *language = get_language(language_pack, language_code); Language *language = get_language(database_, language_pack, language_code);
CHECK(language != nullptr); CHECK(language != nullptr);
std::lock_guard<std::mutex> lock(language->mutex_); std::lock_guard<std::mutex> lock(language->mutex_);
if (language->has_get_difference_query_) { if (language->has_get_difference_query_) {
@ -439,7 +453,8 @@ void LanguagePackManager::hangup() {
} }
int32 LanguagePackManager::manager_count_ = 0; int32 LanguagePackManager::manager_count_ = 0;
std::mutex LanguagePackManager::language_packs_mutex_; std::mutex LanguagePackManager::language_database_mutex_;
std::unordered_map<string, std::unique_ptr<LanguagePackManager::LanguagePack>> LanguagePackManager::language_packs_; std::unordered_map<string, std::unique_ptr<LanguagePackManager::LanguageDatabase>>
LanguagePackManager::language_databases_;
} // namespace td } // namespace td

15
td/telegram/LanguagePackManager.h
View File

@ -66,21 +66,28 @@ class LanguagePackManager : public NetQueryCallback {
std::unordered_map<string, std::unique_ptr<Language>> languages_; std::unordered_map<string, std::unique_ptr<Language>> languages_;
}; };
struct LanguageDatabase {
std::mutex mutex_;
string path_;
std::unordered_map<string, std::unique_ptr<LanguagePack>> language_packs_;
};
ActorShared<> parent_; ActorShared<> parent_;
string language_pack_; string language_pack_;
string language_code_; string language_code_;
LanguageDatabase *database_;
uint32 generation_ = 0; uint32 generation_ = 0;
static int32 manager_count_; static int32 manager_count_;
static std::mutex language_packs_mutex_; static std::mutex language_database_mutex_;
static std::unordered_map<string, std::unique_ptr<LanguagePack>> language_packs_; static std::unordered_map<string, std::unique_ptr<LanguageDatabase>> language_databases_;
static Language *get_language(const string &language_pack, const string &language_code); static Language *get_language(LanguageDatabase *database, const string &language_pack, const string &language_code);
static Language *get_language(LanguagePack *language_pack, const string &language_code); static Language *get_language(LanguagePack *language_pack, const string &language_code);
static Language *add_language(const string &language_pack, const string &language_code); static Language *add_language(LanguageDatabase *database, const string &language_pack, const string &language_code);
static bool language_has_string_unsafe(Language *language, const string &key); static bool language_has_string_unsafe(Language *language, const string &key);
static bool language_has_strings(Language *language, const vector<string> &keys); static bool language_has_strings(Language *language, const vector<string> &keys);

3
td/telegram/Td.cpp
View File

@ -6107,6 +6107,9 @@ void Td::on_request(uint64 id, td_api::setOption &request) {
} }
break; break;
case 'l': case 'l':
if (set_string_option("language_database_path")) {
return;
}
if (set_string_option("language_pack")) { if (set_string_option("language_pack")) {
return; return;
} }

1
tddb/td/db/SqliteDb.cpp
View File

@ -223,4 +223,5 @@ Result<SqliteStatement> SqliteDb::get_statement(CSlice statement) {
} }
return SqliteStatement(stmt, raw_); return SqliteStatement(stmt, raw_);
} }
} // namespace td } // namespace td