From 408a4565897449b23fab20ce11acf302b0cbb07c Mon Sep 17 00:00:00 2001 From: levlam Date: Wed, 18 Sep 2019 06:55:43 +0300 Subject: [PATCH] Add strongly typed StickerSetId. GitOrigin-RevId: 518121f89e3a4c95ab5a2095a9bc2217090911de --- CMakeLists.txt | 2 + td/telegram/ContactsManager.cpp | 28 +- td/telegram/ContactsManager.h | 7 +- td/telegram/FileReferenceManager.cpp | 3 +- td/telegram/MessageContent.cpp | 2 +- td/telegram/MessageContent.h | 3 +- td/telegram/MessagesManager.cpp | 3 +- td/telegram/StickerSetId.h | 55 ++++ td/telegram/StickerSetId.hpp | 27 ++ td/telegram/StickersManager.cpp | 436 ++++++++++++++------------- td/telegram/StickersManager.h | 120 ++++---- td/telegram/StickersManager.hpp | 40 +-- td/telegram/Td.cpp | 38 +-- td/telegram/UpdatesManager.cpp | 5 +- 14 files changed, 442 insertions(+), 327 deletions(-) create mode 100644 td/telegram/StickerSetId.h create mode 100644 td/telegram/StickerSetId.hpp diff --git a/CMakeLists.txt b/CMakeLists.txt index 0641182bd..e9b173e46 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -623,6 +623,7 @@ set(TDLIB_SOURCE td/telegram/SequenceDispatcher.h td/telegram/SetWithPosition.h td/telegram/StateManager.h + td/telegram/StickerSetId.h td/telegram/StickersManager.h td/telegram/StorageManager.h td/telegram/Td.h @@ -666,6 +667,7 @@ set(TDLIB_SOURCE td/telegram/ReplyMarkup.hpp td/telegram/SecureValue.hpp td/telegram/SendCodeHelper.hpp + td/telegram/StickerSetId.hpp td/telegram/StickersManager.hpp td/telegram/VideoNotesManager.hpp td/telegram/VideosManager.hpp diff --git a/td/telegram/ContactsManager.cpp b/td/telegram/ContactsManager.cpp index 66473895f..bc1b57931 100644 --- a/td/telegram/ContactsManager.cpp +++ b/td/telegram/ContactsManager.cpp @@ -27,8 +27,8 @@ #include "td/telegram/Photo.h" #include "td/telegram/Photo.hpp" #include "td/telegram/SecretChatActor.h" +#include "td/telegram/StickerSetId.hpp" #include "td/telegram/StickersManager.h" -#include "td/telegram/StickersManager.hpp" #include "td/telegram/Td.h" #include "td/telegram/TdDb.h" #include "td/telegram/TopDialogManager.h" @@ -997,13 +997,13 @@ class UpdateChannelUsernameQuery : public Td::ResultHandler { class SetChannelStickerSetQuery : public Td::ResultHandler { Promise promise_; ChannelId channel_id_; - int64 sticker_set_id_; + StickerSetId sticker_set_id_; public: explicit SetChannelStickerSetQuery(Promise &&promise) : promise_(std::move(promise)) { } - void send(ChannelId channel_id, int64 sticker_set_id, + void send(ChannelId channel_id, StickerSetId sticker_set_id, telegram_api::object_ptr &&input_sticker_set) { channel_id_ = channel_id; sticker_set_id_ = sticker_set_id; @@ -3008,7 +3008,7 @@ void ContactsManager::ChannelFull::store(StorerT &storer) const { bool has_restricted_count = restricted_count != 0; bool has_banned_count = banned_count != 0; bool has_invite_link = !invite_link.empty(); - bool has_sticker_set = sticker_set_id != 0; + bool has_sticker_set = sticker_set_id.is_valid(); bool has_linked_channel_id = linked_channel_id.is_valid(); bool has_migrated_from_max_message_id = migrated_from_max_message_id.is_valid(); bool has_migrated_from_chat_id = migrated_from_chat_id.is_valid(); @@ -3045,7 +3045,7 @@ void ContactsManager::ChannelFull::store(StorerT &storer) const { store(invite_link, storer); } if (has_sticker_set) { - storer.context()->td().get_actor_unsafe()->stickers_manager_->store_sticker_set_id(sticker_set_id, storer); + store(sticker_set_id, storer); } if (has_linked_channel_id) { store(linked_channel_id, storer); @@ -3104,7 +3104,7 @@ void ContactsManager::ChannelFull::parse(ParserT &parser) { parse(invite_link, parser); } if (has_sticker_set) { - parser.context()->td().get_actor_unsafe()->stickers_manager_->parse_sticker_set_id(sticker_set_id, parser); + parse(sticker_set_id, parser); } if (has_linked_channel_id) { parse(linked_channel_id, parser); @@ -4504,7 +4504,8 @@ void ContactsManager::set_channel_username(ChannelId channel_id, const string &u td_->create_handler(std::move(promise))->send(channel_id, username); } -void ContactsManager::set_channel_sticker_set(ChannelId channel_id, int64 sticker_set_id, Promise &&promise) { +void ContactsManager::set_channel_sticker_set(ChannelId channel_id, StickerSetId sticker_set_id, + Promise &&promise) { auto c = get_channel(channel_id); if (c == nullptr) { return promise.set_error(Status::Error(6, "Supergroup not found")); @@ -4517,7 +4518,7 @@ void ContactsManager::set_channel_sticker_set(ChannelId channel_id, int64 sticke } telegram_api::object_ptr input_sticker_set; - if (sticker_set_id == 0) { + if (!sticker_set_id.is_valid()) { input_sticker_set = telegram_api::make_object(); } else { input_sticker_set = td_->stickers_manager_->get_input_sticker_set(sticker_set_id); @@ -7408,9 +7409,10 @@ void ContactsManager::on_get_chat_full(tl_object_ptr &&c auto can_set_sticker_set = (channel_full->flags_ & CHANNEL_FULL_FLAG_CAN_SET_STICKERS) != 0; auto can_view_statistics = (channel_full->flags_ & CHANNEL_FULL_FLAG_CAN_VIEW_STATISTICS) != 0; auto is_all_history_available = (channel_full->flags_ & CHANNEL_FULL_FLAG_IS_ALL_HISTORY_HIDDEN) == 0; - int64 sticker_set_id = channel_full->stickerset_ == nullptr - ? 0 - : td_->stickers_manager_->on_get_sticker_set(std::move(channel_full->stickerset_), true); + StickerSetId sticker_set_id; + if (channel_full->stickerset_ != nullptr) { + sticker_set_id = td_->stickers_manager_->on_get_sticker_set(std::move(channel_full->stickerset_), true); + } ChannelFull *channel = &channels_full_[channel_id]; channel->expires_at = Time::now() + CHANNEL_FULL_EXPIRE_TIME; @@ -9376,7 +9378,7 @@ void ContactsManager::on_update_channel_description(ChannelId channel_id, string } } -void ContactsManager::on_update_channel_sticker_set(ChannelId channel_id, int64 sticker_set_id) { +void ContactsManager::on_update_channel_sticker_set(ChannelId channel_id, StickerSetId sticker_set_id) { if (!channel_id.is_valid()) { LOG(ERROR) << "Receive invalid " << channel_id; return; @@ -11264,7 +11266,7 @@ tl_object_ptr ContactsManager::get_supergroup_full_i channel_full->description, channel_full->participant_count, channel_full->administrator_count, channel_full->restricted_count, channel_full->banned_count, DialogId(channel_full->linked_channel_id).get(), channel_full->can_get_participants, channel_full->can_set_username, channel_full->can_set_sticker_set, - channel_full->can_view_statistics, channel_full->is_all_history_available, channel_full->sticker_set_id, + channel_full->can_view_statistics, channel_full->is_all_history_available, channel_full->sticker_set_id.get(), channel_full->invite_link, get_basic_group_id_object(channel_full->migrated_from_chat_id, "get_supergroup_full_info_object"), channel_full->migrated_from_max_message_id.get()); diff --git a/td/telegram/ContactsManager.h b/td/telegram/ContactsManager.h index 21a618faf..d8d36b1a9 100644 --- a/td/telegram/ContactsManager.h +++ b/td/telegram/ContactsManager.h @@ -21,6 +21,7 @@ #include "td/telegram/Photo.h" #include "td/telegram/QueryCombiner.h" #include "td/telegram/SecretChatId.h" +#include "td/telegram/StickerSetId.h" #include "td/telegram/UserId.h" #include "td/actor/actor.h" @@ -176,7 +177,7 @@ class ContactsManager : public Actor { void on_update_channel_username(ChannelId channel_id, string &&username); void on_update_channel_description(ChannelId channel_id, string &&description); - void on_update_channel_sticker_set(ChannelId channel_id, int64 sticker_set_id); + void on_update_channel_sticker_set(ChannelId channel_id, StickerSetId sticker_set_id); void on_update_channel_linked_channel_id(ChannelId channel_id, ChannelId group_channel_id); void on_update_channel_is_all_history_available(ChannelId channel_id, bool is_all_history_available); void on_update_channel_default_permissions(ChannelId channel_id, RestrictedRights default_permissions); @@ -298,7 +299,7 @@ class ContactsManager : public Actor { void set_channel_username(ChannelId channel_id, const string &username, Promise &&promise); - void set_channel_sticker_set(ChannelId channel_id, int64 sticker_set_id, Promise &&promise); + void set_channel_sticker_set(ChannelId channel_id, StickerSetId sticker_set_id, Promise &&promise); void toggle_channel_sign_messages(ChannelId channel_id, bool sign_messages, Promise &&promise); @@ -706,7 +707,7 @@ class ContactsManager : public Actor { int32 banned_count = 0; string invite_link; - int64 sticker_set_id = 0; // do not forget to store along with access hash + StickerSetId sticker_set_id; ChannelId linked_channel_id; diff --git a/td/telegram/FileReferenceManager.cpp b/td/telegram/FileReferenceManager.cpp index db2fef24d..0472366c6 100644 --- a/td/telegram/FileReferenceManager.cpp +++ b/td/telegram/FileReferenceManager.cpp @@ -12,6 +12,7 @@ #include "td/telegram/files/FileManager.h" #include "td/telegram/Global.h" #include "td/telegram/MessagesManager.h" +#include "td/telegram/StickerSetId.h" #include "td/telegram/StickersManager.h" #include "td/telegram/WebPagesManager.h" @@ -354,7 +355,7 @@ void FileReferenceManager::reload_photo(PhotoSizeSource source, Promise pr break; case PhotoSizeSource::Type::StickerSetThumbnail: send_closure(G()->stickers_manager(), &StickersManager::reload_sticker_set, - source.sticker_set_thumbnail().sticker_set_id, + StickerSetId(source.sticker_set_thumbnail().sticker_set_id), source.sticker_set_thumbnail().sticker_set_access_hash, std::move(promise)); break; default: diff --git a/td/telegram/MessageContent.cpp b/td/telegram/MessageContent.cpp index 5264a99ca..cc73c97f1 100644 --- a/td/telegram/MessageContent.cpp +++ b/td/telegram/MessageContent.cpp @@ -5029,7 +5029,7 @@ void on_sent_message_content(Td *td, const MessageContent *content) { } } -int64 add_sticker_set(Td *td, tl_object_ptr &&input_sticker_set) { +StickerSetId add_sticker_set(Td *td, tl_object_ptr &&input_sticker_set) { return td->stickers_manager_->add_sticker_set(std::move(input_sticker_set)); } diff --git a/td/telegram/MessageContent.h b/td/telegram/MessageContent.h index 5d8644acc..b297fd380 100644 --- a/td/telegram/MessageContent.h +++ b/td/telegram/MessageContent.h @@ -15,6 +15,7 @@ #include "td/telegram/Photo.h" #include "td/telegram/ReplyMarkup.h" #include "td/telegram/secret_api.h" +#include "td/telegram/StickerSetId.h" #include "td/telegram/td_api.h" #include "td/telegram/telegram_api.h" #include "td/telegram/UserId.h" @@ -252,6 +253,6 @@ void add_message_content_dependencies(Dependencies &dependencies, const MessageC void on_sent_message_content(Td *td, const MessageContent *content); -int64 add_sticker_set(Td *td, tl_object_ptr &&input_sticker_set); +StickerSetId add_sticker_set(Td *td, tl_object_ptr &&input_sticker_set); } // namespace td diff --git a/td/telegram/MessagesManager.cpp b/td/telegram/MessagesManager.cpp index 72cefc648..3b7182214 100644 --- a/td/telegram/MessagesManager.cpp +++ b/td/telegram/MessagesManager.cpp @@ -41,6 +41,7 @@ #include "td/telegram/SecretChatActor.h" #include "td/telegram/SecretChatsManager.h" #include "td/telegram/SequenceDispatcher.h" +#include "td/telegram/StickerSetId.h" #include "td/telegram/Td.h" #include "td/telegram/TdDb.h" #include "td/telegram/TopDialogManager.h" @@ -23546,7 +23547,7 @@ tl_object_ptr MessagesManager::get_chat_event_action_ob auto action = move_tl_object_as(action_ptr); auto old_sticker_set_id = add_sticker_set(td_, std::move(action->prev_stickerset_)); auto new_sticker_set_id = add_sticker_set(td_, std::move(action->new_stickerset_)); - return make_tl_object(old_sticker_set_id, new_sticker_set_id); + return make_tl_object(old_sticker_set_id.get(), new_sticker_set_id.get()); } case telegram_api::channelAdminLogEventActionTogglePreHistoryHidden::ID: { auto action = move_tl_object_as(action_ptr); diff --git a/td/telegram/StickerSetId.h b/td/telegram/StickerSetId.h new file mode 100644 index 000000000..ec62040d0 --- /dev/null +++ b/td/telegram/StickerSetId.h @@ -0,0 +1,55 @@ +// +// Copyright Aliaksei Levin (levlam@telegram.org), Arseny Smirnov (arseny30@gmail.com) 2014-2019 +// +// Distributed under the Boost Software License, Version 1.0. (See accompanying +// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) +// +#pragma once + +#include "td/utils/common.h" +#include "td/utils/StringBuilder.h" + +#include +#include + +namespace td { + +class StickerSetId { + int64 id = 0; + + public: + StickerSetId() = default; + + explicit constexpr StickerSetId(int64 sticker_set_id) : id(sticker_set_id) { + } + template ::value>> + StickerSetId(T sticker_set_id) = delete; + + bool is_valid() const { + return id != 0; + } + + int64 get() const { + return id; + } + + bool operator==(const StickerSetId &other) const { + return id == other.id; + } + + bool operator!=(const StickerSetId &other) const { + return id != other.id; + } +}; + +struct StickerSetIdHash { + std::size_t operator()(StickerSetId sticker_set_id) const { + return std::hash()(sticker_set_id.get()); + } +}; + +inline StringBuilder &operator<<(StringBuilder &string_builder, StickerSetId sticker_set_id) { + return string_builder << "sticker set " << sticker_set_id.get(); +} + +} // namespace td diff --git a/td/telegram/StickerSetId.hpp b/td/telegram/StickerSetId.hpp new file mode 100644 index 000000000..a239bb6ae --- /dev/null +++ b/td/telegram/StickerSetId.hpp @@ -0,0 +1,27 @@ +// +// Copyright Aliaksei Levin (levlam@telegram.org), Arseny Smirnov (arseny30@gmail.com) 2014-2019 +// +// Distributed under the Boost Software License, Version 1.0. (See accompanying +// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) +// +#pragma once + +#include "td/telegram/StickerSetId.h" + +#include "td/telegram/StickersManager.h" +#include "td/telegram/StickersManager.hpp" +#include "td/telegram/Td.h" + +namespace td { + +template +void store(const StickerSetId &sticker_set_id, StorerT &storer) { + storer.context()->td().get_actor_unsafe()->stickers_manager_->store_sticker_set_id(sticker_set_id, storer); +} + +template +void parse(StickerSetId &sticker_set_id, ParserT &parser) { + parser.context()->td().get_actor_unsafe()->stickers_manager_->parse_sticker_set_id(sticker_set_id, parser); +} + +} // namespace td diff --git a/td/telegram/StickersManager.cpp b/td/telegram/StickersManager.cpp index 3e861c1fb..3df42fbcb 100644 --- a/td/telegram/StickersManager.cpp +++ b/td/telegram/StickersManager.cpp @@ -28,6 +28,7 @@ #include "td/telegram/misc.h" #include "td/telegram/net/DcId.h" #include "td/telegram/net/MtprotoHeader.h" +#include "td/telegram/StickerSetId.hpp" #include "td/telegram/StickersManager.hpp" #include "td/telegram/Td.h" #include "td/telegram/TdDb.h" @@ -225,14 +226,14 @@ class GetEmojiUrlQuery : public Td::ResultHandler { class GetArchivedStickerSetsQuery : public Td::ResultHandler { Promise promise_; - int64 offset_sticker_set_id_; + StickerSetId offset_sticker_set_id_; bool is_masks_; public: explicit GetArchivedStickerSetsQuery(Promise &&promise) : promise_(std::move(promise)) { } - void send(bool is_masks, int64 offset_sticker_set_id, int32 limit) { + void send(bool is_masks, StickerSetId offset_sticker_set_id, int32 limit) { offset_sticker_set_id_ = offset_sticker_set_id; is_masks_ = is_masks; LOG(INFO) << "Get archived " << (is_masks ? "mask" : "sticker") << " sets from " << offset_sticker_set_id @@ -245,7 +246,7 @@ class GetArchivedStickerSetsQuery : public Td::ResultHandler { is_masks_ = is_masks; send_query(G()->net_query_creator().create(create_storer( - telegram_api::messages_getArchivedStickers(flags, is_masks /*ignored*/, offset_sticker_set_id, limit)))); + telegram_api::messages_getArchivedStickers(flags, is_masks /*ignored*/, offset_sticker_set_id.get(), limit)))); } void on_result(uint64 id, BufferSlice packet) override { @@ -583,14 +584,14 @@ class ReorderStickerSetsQuery : public Td::ResultHandler { bool is_masks_; public: - void send(bool is_masks, vector sticker_set_ids) { + void send(bool is_masks, vector sticker_set_ids) { is_masks_ = is_masks; int32 flags = 0; if (is_masks) { flags |= telegram_api::messages_reorderStickerSets::MASKS_MASK; } - send_query(G()->net_query_creator().create(create_storer( - telegram_api::messages_reorderStickerSets(flags, is_masks /*ignored*/, std::move(sticker_set_ids))))); + send_query(G()->net_query_creator().create(create_storer(telegram_api::messages_reorderStickerSets( + flags, is_masks /*ignored*/, StickersManager::convert_sticker_set_ids(sticker_set_ids))))); } void on_result(uint64 id, BufferSlice packet) override { @@ -615,20 +616,20 @@ class ReorderStickerSetsQuery : public Td::ResultHandler { class GetStickerSetQuery : public Td::ResultHandler { Promise promise_; - int64 sticker_set_id_; + StickerSetId sticker_set_id_; string sticker_set_name_; public: explicit GetStickerSetQuery(Promise &&promise) : promise_(std::move(promise)) { } - void send(int64 sticker_set_id, tl_object_ptr &&input_sticker_set) { + void send(StickerSetId sticker_set_id, tl_object_ptr &&input_sticker_set) { sticker_set_id_ = sticker_set_id; if (input_sticker_set->get_id() == telegram_api::inputStickerSetShortName::ID) { sticker_set_name_ = static_cast(input_sticker_set.get())->short_name_; } - LOG(INFO) << "Load sticker set " << sticker_set_id << " from server: " << to_string(input_sticker_set); + LOG(INFO) << "Load " << sticker_set_id << " from server: " << to_string(input_sticker_set); send_query(G()->net_query_creator().create( create_storer(telegram_api::messages_getStickerSet(std::move(input_sticker_set))))); } @@ -644,7 +645,7 @@ class GetStickerSetQuery : public Td::ResultHandler { constexpr int64 GREAT_MINDS_COLOR_SET_ID = 151353307481243663; if (set->set_->id_ == GREAT_MINDS_COLOR_SET_ID) { string great_minds_name = "TelegramGreatMinds"; - if (sticker_set_id_ == StickersManager::GREAT_MINDS_SET_ID || + if (sticker_set_id_.get() == StickersManager::GREAT_MINDS_SET_ID || trim(to_lower(sticker_set_name_)) == to_lower(great_minds_name)) { set->set_->id_ = StickersManager::GREAT_MINDS_SET_ID; set->set_->short_name_ = std::move(great_minds_name); @@ -694,14 +695,14 @@ class SearchStickerSetsQuery : public Td::ResultHandler { class InstallStickerSetQuery : public Td::ResultHandler { Promise promise_; - int64 set_id_; + StickerSetId set_id_; bool is_archived_; public: explicit InstallStickerSetQuery(Promise &&promise) : promise_(std::move(promise)) { } - void send(int64 set_id, tl_object_ptr &&input_set, bool is_archived) { + void send(StickerSetId set_id, tl_object_ptr &&input_set, bool is_archived) { set_id_ = set_id; is_archived_ = is_archived; send_query(G()->net_query_creator().create( @@ -727,13 +728,13 @@ class InstallStickerSetQuery : public Td::ResultHandler { class UninstallStickerSetQuery : public Td::ResultHandler { Promise promise_; - int64 set_id_; + StickerSetId set_id_; public: explicit UninstallStickerSetQuery(Promise &&promise) : promise_(std::move(promise)) { } - void send(int64 set_id, tl_object_ptr &&input_set) { + void send(StickerSetId set_id, tl_object_ptr &&input_set) { set_id_ = set_id; send_query(G()->net_query_creator().create( create_storer(telegram_api::messages_uninstallStickerSet(std::move(input_set))))); @@ -763,10 +764,10 @@ class UninstallStickerSetQuery : public Td::ResultHandler { class ReadFeaturedStickerSetsQuery : public Td::ResultHandler { public: - void send(vector sticker_set_ids) { + void send(vector sticker_set_ids) { LOG(INFO) << "Read featured sticker sets " << format::as_array(sticker_set_ids); - send_query(G()->net_query_creator().create( - create_storer(telegram_api::messages_readFeaturedStickers(std::move(sticker_set_ids))))); + send_query(G()->net_query_creator().create(create_storer( + telegram_api::messages_readFeaturedStickers(StickersManager::convert_sticker_set_ids(sticker_set_ids))))); } void on_result(uint64 id, BufferSlice packet) override { @@ -861,7 +862,7 @@ class CreateNewStickerSetQuery : public Td::ResultHandler { return on_error(id, result_ptr.move_as_error()); } - td->stickers_manager_->on_get_messages_sticker_set(0, result_ptr.move_as_ok(), true); + td->stickers_manager_->on_get_messages_sticker_set(StickerSetId(), result_ptr.move_as_ok(), true); promise_.set_value(Unit()); } @@ -890,7 +891,7 @@ class AddStickerToSetQuery : public Td::ResultHandler { return on_error(id, result_ptr.move_as_error()); } - td->stickers_manager_->on_get_messages_sticker_set(0, result_ptr.move_as_ok(), true); + td->stickers_manager_->on_get_messages_sticker_set(StickerSetId(), result_ptr.move_as_ok(), true); promise_.set_value(Unit()); } @@ -919,7 +920,7 @@ class SetStickerPositionQuery : public Td::ResultHandler { return on_error(id, result_ptr.move_as_error()); } - td->stickers_manager_->on_get_messages_sticker_set(0, result_ptr.move_as_ok(), true); + td->stickers_manager_->on_get_messages_sticker_set(StickerSetId(), result_ptr.move_as_ok(), true); promise_.set_value(Unit()); } @@ -948,7 +949,7 @@ class DeleteStickerFromSetQuery : public Td::ResultHandler { return on_error(id, result_ptr.move_as_error()); } - td->stickers_manager_->on_get_messages_sticker_set(0, result_ptr.move_as_ok(), true); + td->stickers_manager_->on_get_messages_sticker_set(StickerSetId(), result_ptr.move_as_ok(), true); promise_.set_value(Unit()); } @@ -990,30 +991,21 @@ class StickersManager::StickerListLogEvent { class StickersManager::StickerSetListLogEvent { public: - vector sticker_set_ids; + vector sticker_set_ids; StickerSetListLogEvent() = default; - explicit StickerSetListLogEvent(vector sticker_set_ids) : sticker_set_ids(std::move(sticker_set_ids)) { + explicit StickerSetListLogEvent(vector sticker_set_ids) : sticker_set_ids(std::move(sticker_set_ids)) { } template void store(StorerT &storer) const { - StickersManager *stickers_manager = storer.context()->td().get_actor_unsafe()->stickers_manager_.get(); - td::store(narrow_cast(sticker_set_ids.size()), storer); - for (auto sticker_set_id : sticker_set_ids) { - stickers_manager->store_sticker_set_id(sticker_set_id, storer); - } + td::store(sticker_set_ids, storer); } template void parse(ParserT &parser) { - StickersManager *stickers_manager = parser.context()->td().get_actor_unsafe()->stickers_manager_.get(); - int32 size = parser.fetch_int(); - sticker_set_ids.resize(size); - for (auto &sticker_set_id : sticker_set_ids) { - stickers_manager->parse_sticker_set_id(sticker_set_id, parser); - } + td::parse(sticker_set_ids, parser); } }; @@ -1082,7 +1074,7 @@ tl_object_ptr StickersManager::get_sticker_object(FileId file_i : nullptr; const PhotoSize &thumbnail = sticker->m_thumbnail.file_id.is_valid() ? sticker->m_thumbnail : sticker->s_thumbnail; - return make_tl_object(sticker->set_id, sticker->dimensions.width, sticker->dimensions.height, + return make_tl_object(sticker->set_id.get(), sticker->dimensions.width, sticker->dimensions.height, sticker->alt, sticker->is_animated, sticker->is_mask, std::move(mask_position), get_photo_size_object(td_->file_manager_.get(), &thumbnail), td_->file_manager_->get_file_object(file_id)); @@ -1097,7 +1089,7 @@ tl_object_ptr StickersManager::get_stickers_object(const vecto return result; } -tl_object_ptr StickersManager::get_sticker_set_object(int64 sticker_set_id) const { +tl_object_ptr StickersManager::get_sticker_set_object(StickerSetId sticker_set_id) const { const StickerSet *sticker_set = get_sticker_set(sticker_set_id); CHECK(sticker_set != nullptr); CHECK(sticker_set->was_loaded); @@ -1115,14 +1107,14 @@ tl_object_ptr StickersManager::get_sticker_set_object(int64 } } return make_tl_object( - sticker_set->id, sticker_set->title, sticker_set->short_name, + sticker_set->id.get(), sticker_set->title, sticker_set->short_name, get_photo_size_object(td_->file_manager_.get(), &sticker_set->thumbnail), sticker_set->is_installed && !sticker_set->is_archived, sticker_set->is_archived, sticker_set->is_official, sticker_set->is_animated, sticker_set->is_masks, sticker_set->is_viewed, std::move(stickers), std::move(emojis)); } tl_object_ptr StickersManager::get_sticker_sets_object(int32 total_count, - const vector &sticker_set_ids, + const vector &sticker_set_ids, size_t covers_limit) const { vector> result; result.reserve(sticker_set_ids.size()); @@ -1143,7 +1135,7 @@ tl_object_ptr StickersManager::get_sticker_sets_object(int3 return make_tl_object(total_count, std::move(result)); } -tl_object_ptr StickersManager::get_sticker_set_info_object(int64 sticker_set_id, +tl_object_ptr StickersManager::get_sticker_set_info_object(StickerSetId sticker_set_id, size_t covers_limit) const { const StickerSet *sticker_set = get_sticker_set(sticker_set_id); CHECK(sticker_set != nullptr); @@ -1158,7 +1150,7 @@ tl_object_ptr StickersManager::get_sticker_set_info_obje } return make_tl_object( - sticker_set->id, sticker_set->title, sticker_set->short_name, + sticker_set->id.get(), sticker_set->title, sticker_set->short_name, get_photo_size_object(td_->file_manager_.get(), &sticker_set->thumbnail), sticker_set->is_installed && !sticker_set->is_archived, sticker_set->is_archived, sticker_set->is_official, sticker_set->is_animated, sticker_set->is_masks, sticker_set->is_viewed, @@ -1166,7 +1158,7 @@ tl_object_ptr StickersManager::get_sticker_set_info_obje std::move(stickers)); } -tl_object_ptr StickersManager::get_input_sticker_set(int64 sticker_set_id) const { +tl_object_ptr StickersManager::get_input_sticker_set(StickerSetId sticker_set_id) const { auto sticker_set = get_sticker_set(sticker_set_id); if (sticker_set == nullptr) { return nullptr; @@ -1189,8 +1181,8 @@ FileId StickersManager::on_get_sticker(unique_ptr new_sticker, bool rep s->dimensions = new_sticker->dimensions; s->is_changed = true; } - if (s->set_id != new_sticker->set_id && new_sticker->set_id != 0) { - LOG_IF(ERROR, s->set_id != 0) << "Sticker " << file_id << " set_id has changed"; + if (s->set_id != new_sticker->set_id && new_sticker->set_id.is_valid()) { + LOG_IF(ERROR, s->set_id.is_valid()) << "Sticker " << file_id << " set_id has changed"; s->set_id = new_sticker->set_id; s->is_changed = true; } @@ -1318,7 +1310,7 @@ const StickersManager::Sticker *StickersManager::get_sticker(FileId file_id) con return sticker->second.get(); } -StickersManager::StickerSet *StickersManager::get_sticker_set(int64 sticker_set_id) { +StickersManager::StickerSet *StickersManager::get_sticker_set(StickerSetId sticker_set_id) { auto sticker_set = sticker_sets_.find(sticker_set_id); if (sticker_set == sticker_sets_.end()) { return nullptr; @@ -1327,7 +1319,7 @@ StickersManager::StickerSet *StickersManager::get_sticker_set(int64 sticker_set_ return sticker_set->second.get(); } -const StickersManager::StickerSet *StickersManager::get_sticker_set(int64 sticker_set_id) const { +const StickersManager::StickerSet *StickersManager::get_sticker_set(StickerSetId sticker_set_id) const { auto sticker_set = sticker_sets_.find(sticker_set_id); if (sticker_set == sticker_sets_.end()) { return nullptr; @@ -1336,31 +1328,31 @@ const StickersManager::StickerSet *StickersManager::get_sticker_set(int64 sticke return sticker_set->second.get(); } -int64 StickersManager::get_sticker_set_id(const tl_object_ptr &set_ptr) { +StickerSetId StickersManager::get_sticker_set_id(const tl_object_ptr &set_ptr) { CHECK(set_ptr != nullptr); switch (set_ptr->get_id()) { case telegram_api::inputStickerSetEmpty::ID: - return 0; + return StickerSetId(); case telegram_api::inputStickerSetID::ID: - return static_cast(set_ptr.get())->id_; + return StickerSetId(static_cast(set_ptr.get())->id_); case telegram_api::inputStickerSetShortName::ID: LOG(ERROR) << "Receive sticker set by its short name"; return search_sticker_set(static_cast(set_ptr.get())->short_name_, Auto()); default: UNREACHABLE(); - return 0; + return StickerSetId(); } } -int64 StickersManager::add_sticker_set(tl_object_ptr &&set_ptr) { +StickerSetId StickersManager::add_sticker_set(tl_object_ptr &&set_ptr) { CHECK(set_ptr != nullptr); switch (set_ptr->get_id()) { case telegram_api::inputStickerSetEmpty::ID: - return 0; + return StickerSetId(); case telegram_api::inputStickerSetID::ID: { auto set = move_tl_object_as(set_ptr); - int64 set_id = set->id_; + StickerSetId set_id{set->id_}; add_sticker_set(set_id, set->access_hash_); return set_id; } @@ -1371,11 +1363,11 @@ int64 StickersManager::add_sticker_set(tl_object_ptr(); @@ -1482,7 +1474,7 @@ bool StickersManager::merge_stickers(FileId new_id, FileId old_id, bool can_dele tl_object_ptr StickersManager::get_input_sticker_set(const StickerSet *set) { CHECK(set != nullptr); - return make_tl_object(set->id, set->access_hash); + return make_tl_object(set->id.get(), set->access_hash); } void StickersManager::reload_installed_sticker_sets(bool is_masks, bool force) { @@ -1511,18 +1503,18 @@ void StickersManager::reload_featured_sticker_sets(bool force) { } } -int64 StickersManager::on_get_input_sticker_set(FileId sticker_file_id, - tl_object_ptr &&set_ptr, - MultiPromiseActor *load_data_multipromise_ptr) { +StickerSetId StickersManager::on_get_input_sticker_set(FileId sticker_file_id, + tl_object_ptr &&set_ptr, + MultiPromiseActor *load_data_multipromise_ptr) { if (set_ptr == nullptr) { - return 0; + return StickerSetId(); } switch (set_ptr->get_id()) { case telegram_api::inputStickerSetEmpty::ID: - return 0; + return StickerSetId(); case telegram_api::inputStickerSetID::ID: { auto set = move_tl_object_as(set_ptr); - int64 set_id = set->id_; + StickerSetId set_id{set->id_}; add_sticker_set(set_id, set->access_hash_); return set_id; } @@ -1533,7 +1525,7 @@ int64 StickersManager::on_get_input_sticker_set(FileId sticker_file_id, return search_sticker_set(set->short_name_, Auto()); } auto set_id = search_sticker_set(set->short_name_, load_data_multipromise_ptr->get_promise()); - if (set_id == 0) { + if (!set_id.is_valid()) { load_data_multipromise_ptr->add_promise( PromiseCreator::lambda([td = td_, sticker_file_id, short_name = set->short_name_](Result result) { if (result.is_ok()) { @@ -1546,14 +1538,14 @@ int64 StickersManager::on_get_input_sticker_set(FileId sticker_file_id, } default: UNREACHABLE(); - return 0; + return StickerSetId(); } } void StickersManager::on_resolve_sticker_set_short_name(FileId sticker_file_id, const string &short_name) { LOG(INFO) << "Resolve sticker " << sticker_file_id << " set to " << short_name; - int64 set_id = search_sticker_set(short_name, Auto()); - if (set_id != 0) { + StickerSetId set_id = search_sticker_set(short_name, Auto()); + if (set_id.is_valid()) { auto &s = stickers_[sticker_file_id]; if (s == nullptr) { LOG(ERROR) << "Can't find sticker " << sticker_file_id; @@ -1623,7 +1615,7 @@ bool StickersManager::has_input_media(FileId sticker_file_id, bool is_secret) co return true; } } else if (!file_view.is_encrypted()) { - if (sticker->set_id != 0) { + if (sticker->set_id.is_valid()) { // stickers within a set can be sent by id and access_hash return true; } @@ -1657,7 +1649,7 @@ SecretInputMedia StickersManager::get_secret_input_media(FileId sticker_file_id, return {}; } } else if (!file_view.is_encrypted()) { - if (sticker->set_id == 0) { + if (!sticker->set_id.is_valid()) { // stickers without set can't be sent by id and access_hash return {}; } @@ -1666,7 +1658,7 @@ SecretInputMedia StickersManager::get_secret_input_media(FileId sticker_file_id, } tl_object_ptr input_sticker_set = make_tl_object(); - if (sticker->set_id) { + if (sticker->set_id.is_valid()) { const StickerSet *sticker_set = get_sticker_set(sticker->set_id); CHECK(sticker_set != nullptr); if (sticker_set->is_inited) { @@ -1697,7 +1689,7 @@ SecretInputMedia StickersManager::get_secret_input_media(FileId sticker_file_id, auto &remote_location = file_view.remote_location(); if (remote_location.is_web()) { // web stickers shouldn't have set_id - LOG(ERROR) << "Have a web sticker in set " << sticker->set_id; + LOG(ERROR) << "Have a web sticker in " << sticker->set_id; return {}; } return SecretInputMedia{nullptr, make_tl_object( @@ -1748,8 +1740,9 @@ tl_object_ptr StickersManager::get_input_media( return nullptr; } -int64 StickersManager::on_get_sticker_set(tl_object_ptr &&set, bool is_changed) { - int64 set_id = set->id_; +StickerSetId StickersManager::on_get_sticker_set(tl_object_ptr &&set, bool is_changed) { + CHECK(set != nullptr); + StickerSetId set_id{set->id_}; StickerSet *s = add_sticker_set(set_id, set->access_hash_); bool is_installed = (set->flags_ & telegram_api::stickerSet::INSTALLED_DATE_MASK) != 0; @@ -1760,12 +1753,12 @@ int64 StickersManager::on_get_sticker_set(tl_object_ptrthumb_ != nullptr) { - auto photo_size = get_photo_size(td_->file_manager_.get(), {set_id, s->access_hash}, 0, 0, "", + auto photo_size = get_photo_size(td_->file_manager_.get(), {set_id.get(), s->access_hash}, 0, 0, "", DcId::create(set->thumb_dc_id_), DialogId(), std::move(set->thumb_), true, false); if (photo_size.get_offset() == 0) { thumbnail = std::move(photo_size.get<0>()); } else { - LOG(ERROR) << "Receive minithumbnail for a sticker set " << set_id; + LOG(ERROR) << "Receive minithumbnail for a " << set_id; } } if (!s->is_inited) { @@ -1783,32 +1776,32 @@ int64 StickersManager::on_get_sticker_set(tl_object_ptrid == set_id); if (s->access_hash != set->access_hash_) { - LOG(INFO) << "Sticker set " << set_id << " access hash has changed"; + LOG(INFO) << "Access hash of " << set_id << " has changed"; s->access_hash = set->access_hash_; s->is_changed = true; } if (s->title != set->title_) { - LOG(INFO) << "Sticker set " << set_id << " title has changed"; + LOG(INFO) << "Title of " << set_id << " has changed"; s->title = std::move(set->title_); s->is_changed = true; - if (installed_sticker_sets_hints_[s->is_masks].has_key(set_id)) { - installed_sticker_sets_hints_[s->is_masks].add(set_id, PSLICE() << s->title << ' ' << s->short_name); + if (installed_sticker_sets_hints_[s->is_masks].has_key(set_id.get())) { + installed_sticker_sets_hints_[s->is_masks].add(set_id.get(), PSLICE() << s->title << ' ' << s->short_name); } } if (s->short_name != set->short_name_) { - LOG(ERROR) << "Sticker set " << set_id << " short name has changed from \"" << s->short_name << "\" to \"" + LOG(ERROR) << "Short name of " << set_id << " has changed from \"" << s->short_name << "\" to \"" << set->short_name_ << "\""; short_name_to_sticker_set_id_.erase(clean_username(s->short_name)); s->short_name = std::move(set->short_name_); s->is_changed = true; - if (installed_sticker_sets_hints_[s->is_masks].has_key(set_id)) { - installed_sticker_sets_hints_[s->is_masks].add(set_id, PSLICE() << s->title << ' ' << s->short_name); + if (installed_sticker_sets_hints_[s->is_masks].has_key(set_id.get())) { + installed_sticker_sets_hints_[s->is_masks].add(set_id.get(), PSLICE() << s->title << ' ' << s->short_name); } } if (s->thumbnail != thumbnail) { - LOG(INFO) << "Sticker set " << set_id << " thumbnail has changed from " << s->thumbnail << " to " << thumbnail; + LOG(INFO) << "Thumbnail of " << set_id << " has changed from " << s->thumbnail << " to " << thumbnail; s->thumbnail = std::move(thumbnail); s->is_changed = true; } @@ -1829,8 +1822,8 @@ int64 StickersManager::on_get_sticker_set(tl_object_ptris_official = is_official; s->is_changed = true; } - LOG_IF(ERROR, s->is_animated != is_animated) << "Animated type of the sticker set " << set_id << " has changed"; - LOG_IF(ERROR, s->is_masks != is_masks) << "Masks type of the sticker set " << set_id << " has changed"; + LOG_IF(ERROR, s->is_animated != is_animated) << "Animated type of the " << set_id << " has changed"; + LOG_IF(ERROR, s->is_masks != is_masks) << "Masks type of the " << set_id << " has changed"; } short_name_to_sticker_set_id_.emplace(clean_username(s->short_name), set_id); @@ -1839,14 +1832,14 @@ int64 StickersManager::on_get_sticker_set(tl_object_ptr &&set_ptr, - bool is_changed) { - int64 set_id = 0; +StickerSetId StickersManager::on_get_sticker_set_covered(tl_object_ptr &&set_ptr, + bool is_changed) { + StickerSetId set_id; switch (set_ptr->get_id()) { case telegram_api::stickerSetCovered::ID: { auto covered_set = move_tl_object_as(set_ptr); set_id = on_get_sticker_set(std::move(covered_set->set_), is_changed); - if (set_id == 0) { + if (!set_id.is_valid()) { break; } @@ -1873,7 +1866,7 @@ int64 StickersManager::on_get_sticker_set_covered(tl_object_ptr(set_ptr); set_id = on_get_sticker_set(std::move(multicovered_set->set_), is_changed); - if (set_id == 0) { + if (!set_id.is_valid()) { break; } @@ -1902,17 +1895,17 @@ int64 StickersManager::on_get_sticker_set_covered(tl_object_ptr &&set, bool is_changed) { LOG(INFO) << "Receive sticker set " << to_string(set); auto set_id = on_get_sticker_set(std::move(set->set_), is_changed); - if (set_id == 0) { + if (!set_id.is_valid()) { return; } - if (sticker_set_id != 0 && sticker_set_id != set_id) { - LOG(ERROR) << "Expected sticker set " << sticker_set_id << ", but receive sticker set " << set_id; + if (sticker_set_id.is_valid() && sticker_set_id != set_id) { + LOG(ERROR) << "Expected " << sticker_set_id << ", but receive " << set_id; on_load_sticker_set_fail(sticker_set_id, Status::Error(500, "Internal server error")); return; } @@ -1986,8 +1979,8 @@ void StickersManager::on_get_messages_sticker_set(int64 sticker_set_id, send_update_installed_sticker_sets(); } -void StickersManager::on_load_sticker_set_fail(int64 sticker_set_id, const Status &error) { - if (sticker_set_id == 0) { +void StickersManager::on_load_sticker_set_fail(StickerSetId sticker_set_id, const Status &error) { + if (!sticker_set_id.is_valid()) { return; } update_load_requests(get_sticker_set(sticker_set_id), true, error); @@ -2047,19 +2040,19 @@ void StickersManager::on_get_installed_sticker_sets(bool is_masks, CHECK(constructor_id == telegram_api::messages_allStickers::ID); auto stickers = move_tl_object_as(stickers_ptr); - std::unordered_set uninstalled_sticker_sets(installed_sticker_set_ids_[is_masks].begin(), - installed_sticker_set_ids_[is_masks].end()); + std::unordered_set uninstalled_sticker_sets( + installed_sticker_set_ids_[is_masks].begin(), installed_sticker_set_ids_[is_masks].end()); - vector sets_to_load; - vector installed_sticker_set_ids; - vector hashes; - vector sticker_set_ids; + vector sets_to_load; + vector installed_sticker_set_ids; + vector debug_hashes; + vector debug_sticker_set_ids; std::reverse(stickers->sets_.begin(), stickers->sets_.end()); // apply installed sticker sets in reverse order for (auto &set : stickers->sets_) { - hashes.push_back(set->hash_); - sticker_set_ids.push_back(set->id_); - int64 set_id = on_get_sticker_set(std::move(set), false); - if (set_id == 0) { + debug_hashes.push_back(set->hash_); + debug_sticker_set_ids.push_back(set->id_); + StickerSetId set_id = on_get_sticker_set(std::move(set), false); + if (!set_id.is_valid()) { continue; } @@ -2080,9 +2073,9 @@ void StickersManager::on_get_installed_sticker_sets(bool is_masks, sets_to_load.push_back(set_id); } } - std::reverse(hashes.begin(), hashes.end()); + std::reverse(debug_hashes.begin(), debug_hashes.end()); std::reverse(installed_sticker_set_ids.begin(), installed_sticker_set_ids.end()); - std::reverse(sticker_set_ids.begin(), sticker_set_ids.end()); + std::reverse(debug_sticker_set_ids.begin(), debug_sticker_set_ids.end()); if (!sets_to_load.empty()) { load_sticker_sets(std::move(sets_to_load), Auto()); @@ -2099,12 +2092,12 @@ void StickersManager::on_get_installed_sticker_sets(bool is_masks, on_load_installed_sticker_sets_finished(is_masks, std::move(installed_sticker_set_ids)); if (installed_sticker_sets_hash_[is_masks] != stickers->hash_) { - LOG(ERROR) << "Sticker sets hash mismatch: server hash list = " << format::as_array(hashes) + LOG(ERROR) << "Sticker sets hash mismatch: server hash list = " << format::as_array(debug_hashes) << ", client hash list = " << format::as_array( transform(installed_sticker_set_ids_[is_masks], - [this](int64 sticker_set_id) { return get_sticker_set(sticker_set_id)->hash; })) - << ", server sticker set list = " << format::as_array(sticker_set_ids) + [this](StickerSetId sticker_set_id) { return get_sticker_set(sticker_set_id)->hash; })) + << ", server sticker set list = " << format::as_array(debug_sticker_set_ids) << ", client sticker set list = " << format::as_array(installed_sticker_set_ids_[is_masks]) << ", server hash = " << stickers->hash_ << ", client hash = " << installed_sticker_sets_hash_[is_masks]; } @@ -2152,7 +2145,7 @@ vector StickersManager::get_stickers(string emoji, int32 limit, bool for */ } - vector sets_to_load; + vector sets_to_load; bool need_load = false; for (const auto &sticker_set_id : installed_sticker_set_ids_[0]) { const StickerSet *sticker_set = get_sticker_set(sticker_set_id); @@ -2190,8 +2183,9 @@ vector StickersManager::get_stickers(string emoji, int32 limit, bool for LOG(INFO) << "Have " << recent_sticker_ids_[0] << " recent and " << favorite_sticker_ids_ << " favorite stickers"; for (const auto &sticker_id : prepend_sticker_ids) { const Sticker *s = get_sticker(sticker_id); - LOG(INFO) << "Have prepend sticker " << sticker_id << " from set " << s->set_id; - if (s->set_id != 0 && std::find(sets_to_load.begin(), sets_to_load.end(), s->set_id) == sets_to_load.end()) { + LOG(INFO) << "Have prepend sticker " << sticker_id << " from " << s->set_id; + if (s->set_id.is_valid() && + std::find(sets_to_load.begin(), sets_to_load.end(), s->set_id) == sets_to_load.end()) { const StickerSet *sticker_set = get_sticker_set(s->set_id); if (sticker_set == nullptr || !sticker_set->is_loaded) { sets_to_load.push_back(s->set_id); @@ -2252,7 +2246,7 @@ vector StickersManager::get_stickers(string emoji, int32 limit, bool for for (auto sticker_set : examined_sticker_sets) { auto it = sticker_set->emoji_stickers_map_.find(emoji); if (it != sticker_set->emoji_stickers_map_.end()) { - LOG(INFO) << "Add " << it->second << " stickers from set " << sticker_set->id; + LOG(INFO) << "Add " << it->second << " stickers from " << sticker_set->id; append(result, it->second); } } @@ -2280,7 +2274,7 @@ vector StickersManager::get_stickers(string emoji, int32 limit, bool for if (remove_emoji_modifiers(s->alt) == emoji) { LOG(INFO) << "Found prepend sticker " << sticker_id << " main emoji matches"; is_good = true; - } else if (s->set_id != 0) { + } else if (s->set_id.is_valid()) { const StickerSet *sticker_set = get_sticker_set(s->set_id); if (sticker_set != nullptr && sticker_set->was_loaded) { auto map_it = sticker_set->emoji_stickers_map_.find(emoji); @@ -2409,7 +2403,7 @@ void StickersManager::on_find_stickers_fail(const string &emoji, Status &&error) } } -vector StickersManager::get_installed_sticker_sets(bool is_masks, Promise &&promise) { +vector StickersManager::get_installed_sticker_sets(bool is_masks, Promise &&promise) { if (!are_installed_sticker_sets_loaded_[is_masks]) { load_installed_sticker_sets(is_masks, std::move(promise)); return {}; @@ -2446,47 +2440,49 @@ bool StickersManager::update_sticker_set_cache(const StickerSet *sticker_set, Pr return false; } -int64 StickersManager::get_sticker_set(int64 set_id, Promise &&promise) { +StickerSetId StickersManager::get_sticker_set(StickerSetId set_id, Promise &&promise) { const StickerSet *sticker_set = get_sticker_set(set_id); if (sticker_set == nullptr) { - if (set_id == GREAT_MINDS_SET_ID) { - do_reload_sticker_set(set_id, make_tl_object(set_id, 0), std::move(promise)); - return 0; + if (set_id.get() == GREAT_MINDS_SET_ID) { + do_reload_sticker_set(set_id, make_tl_object(GREAT_MINDS_SET_ID, 0), + std::move(promise)); + return StickerSetId(); } promise.set_error(Status::Error(400, "Sticker set not found")); - return 0; + return StickerSetId(); } if (update_sticker_set_cache(sticker_set, promise)) { - return 0; + return StickerSetId(); } promise.set_value(Unit()); return set_id; } -int64 StickersManager::search_sticker_set(const string &short_name_to_search, Promise &&promise) { +StickerSetId StickersManager::search_sticker_set(const string &short_name_to_search, Promise &&promise) { string short_name = clean_username(short_name_to_search); auto it = short_name_to_sticker_set_id_.find(short_name); const StickerSet *sticker_set = it == short_name_to_sticker_set_id_.end() ? nullptr : get_sticker_set(it->second); if (sticker_set == nullptr) { auto set_to_load = make_tl_object(short_name); - do_reload_sticker_set(0, std::move(set_to_load), std::move(promise)); - return 0; + do_reload_sticker_set(StickerSetId(), std::move(set_to_load), std::move(promise)); + return StickerSetId(); } if (update_sticker_set_cache(sticker_set, promise)) { - return 0; + return StickerSetId(); } promise.set_value(Unit()); return sticker_set->id; } -std::pair> StickersManager::search_installed_sticker_sets(bool is_masks, const string &query, - int32 limit, Promise &&promise) { +std::pair> StickersManager::search_installed_sticker_sets(bool is_masks, + const string &query, int32 limit, + Promise &&promise) { LOG(INFO) << "Search installed " << (is_masks ? "mask " : "") << "sticker sets with query = \"" << query << "\" and limit = " << limit; @@ -2503,10 +2499,10 @@ std::pair> StickersManager::search_installed_sticker_sets(b std::pair> result = installed_sticker_sets_hints_[is_masks].search(query, limit); promise.set_value(Unit()); - return {narrow_cast(result.first), std::move(result.second)}; + return {narrow_cast(result.first), convert_sticker_set_ids(result.second)}; } -vector StickersManager::search_sticker_sets(const string &query, Promise &&promise) { +vector StickersManager::search_sticker_sets(const string &query, Promise &&promise) { auto q = clean_name(query, 1000); auto it = found_sticker_sets_.find(q); if (it != found_sticker_sets_.end()) { @@ -2531,12 +2527,12 @@ void StickersManager::on_find_sticker_sets_success( return on_find_sticker_sets_fail(query, Status::Error(500, "Receive messages.foundStickerSetsNotModified")); case telegram_api::messages_foundStickerSets::ID: { auto found_stickers_sets = move_tl_object_as(sticker_sets); - vector &sticker_set_ids = found_sticker_sets_[query]; + vector &sticker_set_ids = found_sticker_sets_[query]; CHECK(sticker_set_ids.empty()); for (auto &sticker_set : found_stickers_sets->sets_) { - int64 set_id = on_get_sticker_set_covered(std::move(sticker_set), true); - if (set_id == 0) { + StickerSetId set_id = on_get_sticker_set_covered(std::move(sticker_set), true); + if (!set_id.is_valid()) { continue; } @@ -2576,7 +2572,8 @@ void StickersManager::on_find_sticker_sets_fail(const string &query, Status &&er } } -void StickersManager::change_sticker_set(int64 set_id, bool is_installed, bool is_archived, Promise &&promise) { +void StickersManager::change_sticker_set(StickerSetId set_id, bool is_installed, bool is_archived, + Promise &&promise) { if (is_installed && is_archived) { return promise.set_error(Status::Error(400, "Sticker set can't be installed and archived simultaneously")); } @@ -2615,8 +2612,8 @@ void StickersManager::change_sticker_set(int64 set_id, bool is_installed, bool i void StickersManager::on_update_sticker_set(StickerSet *sticker_set, bool is_installed, bool is_archived, bool is_changed, bool from_database) { - LOG(INFO) << "Update sticker set " << sticker_set->id << ": installed = " << is_installed - << ", archived = " << is_archived << ", changed = " << is_changed; + LOG(INFO) << "Update " << sticker_set->id << ": installed = " << is_installed << ", archived = " << is_archived + << ", changed = " << is_changed; CHECK(sticker_set->is_inited); if (is_archived) { is_installed = true; @@ -2635,22 +2632,22 @@ void StickersManager::on_update_sticker_set(StickerSet *sticker_set, bool is_ins bool is_added = sticker_set->is_installed && !sticker_set->is_archived; if (was_added != is_added) { - vector &sticker_set_ids = installed_sticker_set_ids_[sticker_set->is_masks]; + vector &sticker_set_ids = installed_sticker_set_ids_[sticker_set->is_masks]; need_update_installed_sticker_sets_[sticker_set->is_masks] = true; if (is_added) { installed_sticker_sets_hints_[sticker_set->is_masks].add( - sticker_set->id, PSLICE() << sticker_set->title << ' ' << sticker_set->short_name); + sticker_set->id.get(), PSLICE() << sticker_set->title << ' ' << sticker_set->short_name); sticker_set_ids.insert(sticker_set_ids.begin(), sticker_set->id); } else { - installed_sticker_sets_hints_[sticker_set->is_masks].remove(sticker_set->id); + installed_sticker_sets_hints_[sticker_set->is_masks].remove(sticker_set->id.get()); sticker_set_ids.erase(std::remove(sticker_set_ids.begin(), sticker_set_ids.end(), sticker_set->id), sticker_set_ids.end()); } } if (was_archived != is_archived && is_changed) { int32 &total_count = total_archived_sticker_set_count_[sticker_set->is_masks]; - vector &sticker_set_ids = archived_sticker_set_ids_[sticker_set->is_masks]; + vector &sticker_set_ids = archived_sticker_set_ids_[sticker_set->is_masks]; if (total_count < 0) { return; } @@ -2714,7 +2711,7 @@ void StickersManager::on_load_installed_sticker_sets_from_database(bool is_masks return reload_installed_sticker_sets(is_masks, true); } - vector sets_to_load; + vector sets_to_load; for (auto sticker_set_id : log_event.sticker_set_ids) { StickerSet *sticker_set = get_sticker_set(sticker_set_id); CHECK(sticker_set != nullptr); @@ -2735,16 +2732,17 @@ void StickersManager::on_load_installed_sticker_sets_from_database(bool is_masks })); } -void StickersManager::on_load_installed_sticker_sets_finished(bool is_masks, vector &&installed_sticker_set_ids, +void StickersManager::on_load_installed_sticker_sets_finished(bool is_masks, + vector &&installed_sticker_set_ids, bool from_database) { bool need_reload = false; - vector old_installed_sticker_set_ids; + vector old_installed_sticker_set_ids; if (!are_installed_sticker_sets_loaded_[is_masks] && !installed_sticker_set_ids_[is_masks].empty()) { old_installed_sticker_set_ids = std::move(installed_sticker_set_ids_[is_masks]); } installed_sticker_set_ids_[is_masks].clear(); for (auto set_id : installed_sticker_set_ids) { - CHECK(set_id != 0); + CHECK(set_id.is_valid()); auto sticker_set = get_sticker_set(set_id); CHECK(sticker_set != nullptr); @@ -2779,12 +2777,12 @@ void StickersManager::on_load_installed_sticker_sets_finished(bool is_masks, vec } } -string StickersManager::get_sticker_set_database_key(int64 set_id) { - return PSTRING() << "ss" << set_id; +string StickersManager::get_sticker_set_database_key(StickerSetId set_id) { + return PSTRING() << "ss" << set_id.get(); } -string StickersManager::get_full_sticker_set_database_key(int64 set_id) { - return PSTRING() << "ssf" << set_id; +string StickersManager::get_full_sticker_set_database_key(StickerSetId set_id) { + return PSTRING() << "ssf" << set_id.get(); } string StickersManager::get_sticker_set_database_value(const StickerSet *s, bool with_stickers) { @@ -2794,7 +2792,7 @@ string StickersManager::get_sticker_set_database_value(const StickerSet *s, bool BufferSlice value_buffer{storer_calc_length.get_length()}; auto value = value_buffer.as_slice(); - LOG(DEBUG) << "Sticker set " << s->id << " serialized size is " << value.size(); + LOG(DEBUG) << "Serialized size of " << s->id << " is " << value.size(); LogEventStorerUnsafe storer_unsafe(value.ubegin()); store_sticker_set(s, with_stickers, storer_unsafe); @@ -2807,7 +2805,7 @@ void StickersManager::update_sticker_set(StickerSet *sticker_set) { if (sticker_set->is_changed) { sticker_set->is_changed = false; if (G()->parameters().use_file_db) { - LOG(INFO) << "Save sticker set " << sticker_set->id << " to database"; + LOG(INFO) << "Save " << sticker_set->id << " to database"; if (sticker_set->is_inited) { G()->td_db()->get_sqlite_pmc()->set(get_sticker_set_database_key(sticker_set->id), get_sticker_set_database_value(sticker_set, false), Auto()); @@ -2823,7 +2821,7 @@ void StickersManager::update_sticker_set(StickerSet *sticker_set) { } } -void StickersManager::load_sticker_sets(vector &&sticker_set_ids, Promise &&promise) { +void StickersManager::load_sticker_sets(vector &&sticker_set_ids, Promise &&promise) { if (sticker_set_ids.empty()) { promise.set_value(Unit()); return; @@ -2842,21 +2840,22 @@ void StickersManager::load_sticker_sets(vector &&sticker_set_ids, Promise sticker_set->load_requests.push_back(load_request_id); if (sticker_set->load_requests.size() == 1u) { if (G()->parameters().use_file_db && !sticker_set->was_loaded) { - LOG(INFO) << "Trying to load sticker set " << sticker_set_id << " with stickers from database"; + LOG(INFO) << "Trying to load " << sticker_set_id << " with stickers from database"; G()->td_db()->get_sqlite_pmc()->get( get_full_sticker_set_database_key(sticker_set_id), PromiseCreator::lambda([sticker_set_id](string value) { send_closure(G()->stickers_manager(), &StickersManager::on_load_sticker_set_from_database, sticker_set_id, true, std::move(value)); })); } else { - LOG(INFO) << "Trying to load sticker set " << sticker_set_id << " with stickers from server"; + LOG(INFO) << "Trying to load " << sticker_set_id << " with stickers from server"; do_reload_sticker_set(sticker_set_id, get_input_sticker_set(sticker_set), Auto()); } } } } -void StickersManager::load_sticker_sets_without_stickers(vector &&sticker_set_ids, Promise &&promise) { +void StickersManager::load_sticker_sets_without_stickers(vector &&sticker_set_ids, + Promise &&promise) { if (sticker_set_ids.empty()) { promise.set_value(Unit()); return; @@ -2878,14 +2877,14 @@ void StickersManager::load_sticker_sets_without_stickers(vector &&sticker sticker_set->load_without_stickers_requests.push_back(load_request_id); if (sticker_set->load_without_stickers_requests.size() == 1u) { if (G()->parameters().use_file_db) { - LOG(INFO) << "Trying to load sticker set " << sticker_set_id << " from database"; + LOG(INFO) << "Trying to load " << sticker_set_id << " from database"; G()->td_db()->get_sqlite_pmc()->get( get_sticker_set_database_key(sticker_set_id), PromiseCreator::lambda([sticker_set_id](string value) { send_closure(G()->stickers_manager(), &StickersManager::on_load_sticker_set_from_database, sticker_set_id, false, std::move(value)); })); } else { - LOG(INFO) << "Trying to load sticker set " << sticker_set_id << " from server"; + LOG(INFO) << "Trying to load " << sticker_set_id << " from server"; do_reload_sticker_set(sticker_set_id, get_input_sticker_set(sticker_set), Auto()); } } @@ -2893,15 +2892,15 @@ void StickersManager::load_sticker_sets_without_stickers(vector &&sticker } } -void StickersManager::on_load_sticker_set_from_database(int64 sticker_set_id, bool with_stickers, string value) { +void StickersManager::on_load_sticker_set_from_database(StickerSetId sticker_set_id, bool with_stickers, string value) { StickerSet *sticker_set = get_sticker_set(sticker_set_id); CHECK(sticker_set != nullptr); if (sticker_set->was_loaded) { - LOG(INFO) << "Sticker set " << sticker_set_id << " was loaded"; + LOG(INFO) << "Receive from database previously loaded " << sticker_set_id; return; } if (!with_stickers && sticker_set->is_inited) { - LOG(INFO) << "Sticker set " << sticker_set_id << " was inited"; + LOG(INFO) << "Receive from database previously inited " << sticker_set_id; return; } @@ -2916,25 +2915,25 @@ void StickersManager::on_load_sticker_set_from_database(int64 sticker_set_id, bo return do_reload_sticker_set(sticker_set_id, get_input_sticker_set(sticker_set), Auto()); } - LOG(INFO) << "Successfully loaded sticker set " << sticker_set_id << " with" << (with_stickers ? "" : "out") + LOG(INFO) << "Successfully loaded " << sticker_set_id << " with" << (with_stickers ? "" : "out") << " stickers of size " << value.size() << " from database"; auto old_sticker_count = sticker_set->sticker_ids.size(); { - LOG_IF(ERROR, sticker_set->is_changed) << "Sticker set with" << (with_stickers ? "" : "out") << " stickers " - << sticker_set_id << " was changed before it is loaded from database"; + LOG_IF(ERROR, sticker_set->is_changed) << sticker_set_id << " with" << (with_stickers ? "" : "out") + << " stickers was changed before it is loaded from database"; LogEventParser parser(value); parse_sticker_set(sticker_set, parser); LOG_IF(ERROR, sticker_set->is_changed) - << "Sticker set with" << (with_stickers ? "" : "out") << " stickers " << sticker_set_id << " is changed"; + << sticker_set_id << " with" << (with_stickers ? "" : "out") << " stickers is changed"; parser.fetch_end(); auto status = parser.get_status(); if (status.is_error()) { G()->td_db()->get_sqlite_sync_pmc()->erase(with_stickers ? get_full_sticker_set_database_key(sticker_set_id) : get_sticker_set_database_key(sticker_set_id)); // need to crash, because the current StickerSet state is spoiled by parse_sticker_set - LOG(FATAL) << "Failed to parse sticker set " << sticker_set_id << ": " << status << ' ' + LOG(FATAL) << "Failed to parse " << sticker_set_id << ": " << status << ' ' << format::as_hex_dump<4>(Slice(value)); } } @@ -2950,12 +2949,13 @@ void StickersManager::on_load_sticker_set_from_database(int64 sticker_set_id, bo update_load_requests(sticker_set, with_stickers, Status::OK()); } -void StickersManager::reload_sticker_set(int64 sticker_set_id, int64 access_hash, Promise &&promise) { - do_reload_sticker_set(sticker_set_id, make_tl_object(sticker_set_id, access_hash), +void StickersManager::reload_sticker_set(StickerSetId sticker_set_id, int64 access_hash, Promise &&promise) { + do_reload_sticker_set(sticker_set_id, + make_tl_object(sticker_set_id.get(), access_hash), std::move(promise)); } -void StickersManager::do_reload_sticker_set(int64 sticker_set_id, +void StickersManager::do_reload_sticker_set(StickerSetId sticker_set_id, tl_object_ptr &&input_sticker_set, Promise &&promise) const { if (G()->close_flag()) { @@ -2964,7 +2964,7 @@ void StickersManager::do_reload_sticker_set(int64 sticker_set_id, td_->create_handler(std::move(promise))->send(sticker_set_id, std::move(input_sticker_set)); } -void StickersManager::on_install_sticker_set(int64 set_id, bool is_archived, +void StickersManager::on_install_sticker_set(StickerSetId set_id, bool is_archived, tl_object_ptr &&result) { StickerSet *sticker_set = get_sticker_set(set_id); CHECK(sticker_set != nullptr); @@ -2977,8 +2977,8 @@ void StickersManager::on_install_sticker_set(int64 set_id, bool is_archived, case telegram_api::messages_stickerSetInstallResultArchive::ID: { auto archived_sets = move_tl_object_as(result); for (auto &archived_set_ptr : archived_sets->sets_) { - int64 archived_sticker_set_id = on_get_sticker_set_covered(std::move(archived_set_ptr), true); - if (archived_sticker_set_id != 0) { + StickerSetId archived_sticker_set_id = on_get_sticker_set_covered(std::move(archived_set_ptr), true); + if (archived_sticker_set_id.is_valid()) { auto archived_sticker_set = get_sticker_set(archived_sticker_set_id); CHECK(archived_sticker_set != nullptr); update_sticker_set(archived_sticker_set); @@ -2993,7 +2993,7 @@ void StickersManager::on_install_sticker_set(int64 set_id, bool is_archived, send_update_installed_sticker_sets(); } -void StickersManager::on_uninstall_sticker_set(int64 set_id) { +void StickersManager::on_uninstall_sticker_set(StickerSetId set_id) { StickerSet *sticker_set = get_sticker_set(set_id); CHECK(sticker_set != nullptr); on_update_sticker_set(sticker_set, false, false, true); @@ -3012,7 +3012,7 @@ void StickersManager::on_update_sticker_sets() { reload_installed_sticker_sets(true, true); } -void StickersManager::view_featured_sticker_sets(const vector &sticker_set_ids) { +void StickersManager::view_featured_sticker_sets(const vector &sticker_set_ids) { for (auto sticker_set_id : sticker_set_ids) { auto set = get_sticker_set(sticker_set_id); if (set != nullptr && !set->is_viewed) { @@ -3038,23 +3038,24 @@ void StickersManager::read_featured_sticker_sets(void *td_void) { auto td = static_cast(td_void); auto &set_ids = td->stickers_manager_->pending_viewed_featured_sticker_set_ids_; - td->create_handler()->send(vector(set_ids.begin(), set_ids.end())); + td->create_handler()->send(vector(set_ids.begin(), set_ids.end())); set_ids.clear(); } -std::pair> StickersManager::get_archived_sticker_sets(bool is_masks, int64 offset_sticker_set_id, - int32 limit, bool force, - Promise &&promise) { +std::pair> StickersManager::get_archived_sticker_sets(bool is_masks, + StickerSetId offset_sticker_set_id, + int32 limit, bool force, + Promise &&promise) { if (limit <= 0) { promise.set_error(Status::Error(3, "Parameter limit must be positive")); return {}; } - vector &sticker_set_ids = archived_sticker_set_ids_[is_masks]; + vector &sticker_set_ids = archived_sticker_set_ids_[is_masks]; int32 total_count = total_archived_sticker_set_count_[is_masks]; if (total_count >= 0) { auto offset_it = sticker_set_ids.begin(); - if (offset_sticker_set_id != 0) { + if (offset_sticker_set_id.is_valid()) { offset_it = std::find(sticker_set_ids.begin(), sticker_set_ids.end(), offset_sticker_set_id); if (offset_it == sticker_set_ids.end()) { offset_it = sticker_set_ids.begin(); @@ -3062,13 +3063,13 @@ std::pair> StickersManager::get_archived_sticker_sets(bool ++offset_it; } } - vector result; + vector result; while (result.size() < static_cast(limit)) { if (offset_it == sticker_set_ids.end()) { break; } auto sticker_set_id = *offset_it++; - if (sticker_set_id == 0) { // end of the list + if (!sticker_set_id.is_valid()) { // end of the list promise.set_value(Unit()); return {total_count, std::move(result)}; } @@ -3085,10 +3086,10 @@ std::pair> StickersManager::get_archived_sticker_sets(bool } void StickersManager::on_get_archived_sticker_sets( - bool is_masks, int64 offset_sticker_set_id, vector> &&sticker_sets, - int32 total_count) { - vector &sticker_set_ids = archived_sticker_set_ids_[is_masks]; - if (!sticker_set_ids.empty() && sticker_set_ids.back() == 0) { + bool is_masks, StickerSetId offset_sticker_set_id, + vector> &&sticker_sets, int32 total_count) { + vector &sticker_set_ids = archived_sticker_set_ids_[is_masks]; + if (!sticker_set_ids.empty() && sticker_set_ids.back() == StickerSetId()) { return; } if (total_count < 0) { @@ -3098,13 +3099,13 @@ void StickersManager::on_get_archived_sticker_sets( // if 0 sticker sets are received, then set offset_sticker_set_id was found and there is no stickers after it // or it wasn't found and there is no archived sets at all bool is_last = - sticker_sets.empty() && - (offset_sticker_set_id == 0 || (!sticker_set_ids.empty() && offset_sticker_set_id == sticker_set_ids.back())); + sticker_sets.empty() && (!offset_sticker_set_id.is_valid() || + (!sticker_set_ids.empty() && offset_sticker_set_id == sticker_set_ids.back())); total_archived_sticker_set_count_[is_masks] = total_count; for (auto &sticker_set_covered : sticker_sets) { auto sticker_set_id = on_get_sticker_set_covered(std::move(sticker_set_covered), false); - if (sticker_set_id != 0) { + if (sticker_set_id.is_valid()) { auto sticker_set = get_sticker_set(sticker_set_id); CHECK(sticker_set != nullptr); update_sticker_set(sticker_set); @@ -3120,12 +3121,12 @@ void StickersManager::on_get_archived_sticker_sets( << " found"; total_archived_sticker_set_count_[is_masks] = static_cast(sticker_set_ids.size()); } - sticker_set_ids.push_back(0); + sticker_set_ids.push_back(StickerSetId()); } send_update_installed_sticker_sets(); } -vector StickersManager::get_featured_sticker_sets(Promise &&promise) { +vector StickersManager::get_featured_sticker_sets(Promise &&promise) { if (!are_featured_sticker_sets_loaded_) { load_featured_sticker_sets(std::move(promise)); return {}; @@ -3148,12 +3149,12 @@ void StickersManager::on_get_featured_sticker_sets( CHECK(constructor_id == telegram_api::messages_featuredStickers::ID); auto featured_stickers = move_tl_object_as(sticker_sets_ptr); - vector featured_sticker_set_ids; - std::unordered_set unread_sticker_set_ids(featured_stickers->unread_.begin(), - featured_stickers->unread_.end()); + vector featured_sticker_set_ids; + std::unordered_set unread_sticker_set_ids(featured_stickers->unread_.begin(), + featured_stickers->unread_.end()); for (auto &sticker_set : featured_stickers->sets_) { - int64 set_id = on_get_sticker_set_covered(std::move(sticker_set), true); - if (set_id == 0) { + StickerSetId set_id = on_get_sticker_set_covered(std::move(sticker_set), true); + if (!set_id.is_valid()) { continue; } @@ -3236,7 +3237,7 @@ void StickersManager::on_load_featured_sticker_sets_from_database(string value) return reload_featured_sticker_sets(true); } - vector sets_to_load; + vector sets_to_load; for (auto sticker_set_id : log_event.sticker_set_ids) { StickerSet *sticker_set = get_sticker_set(sticker_set_id); CHECK(sticker_set != nullptr); @@ -3255,7 +3256,7 @@ void StickersManager::on_load_featured_sticker_sets_from_database(string value) })); } -void StickersManager::on_load_featured_sticker_sets_finished(vector &&featured_sticker_set_ids) { +void StickersManager::on_load_featured_sticker_sets_finished(vector &&featured_sticker_set_ids) { featured_sticker_set_ids_ = std::move(featured_sticker_set_ids); are_featured_sticker_sets_loaded_ = true; need_update_featured_sticker_sets_ = true; @@ -3267,7 +3268,7 @@ void StickersManager::on_load_featured_sticker_sets_finished(vector &&fea } } -vector StickersManager::get_attached_sticker_sets(FileId file_id, Promise &&promise) { +vector StickersManager::get_attached_sticker_sets(FileId file_id, Promise &&promise) { if (!file_id.is_valid()) { promise.set_error(Status::Error(5, "Wrong file_id specified")); return {}; @@ -3312,11 +3313,11 @@ void StickersManager::send_get_attached_stickers_query(FileId file_id, Promise> &&sticker_sets) { - vector &sticker_set_ids = attached_sticker_sets_[file_id]; + vector &sticker_set_ids = attached_sticker_sets_[file_id]; sticker_set_ids.clear(); for (auto &sticker_set_covered : sticker_sets) { auto sticker_set_id = on_get_sticker_set_covered(std::move(sticker_set_covered), true); - if (sticker_set_id != 0) { + if (sticker_set_id.is_valid()) { auto sticker_set = get_sticker_set(sticker_set_id); CHECK(sticker_set != nullptr); update_sticker_set(sticker_set); @@ -3329,18 +3330,19 @@ void StickersManager::on_get_attached_sticker_sets( // -1 - order can't be applied, because some sticker sets aren't loaded or aren't installed, // 0 - order wasn't changed, 1 - order was partly replaced by the new order, 2 - order was replaced by the new order -int StickersManager::apply_installed_sticker_sets_order(bool is_masks, const vector &sticker_set_ids) { +int StickersManager::apply_installed_sticker_sets_order(bool is_masks, const vector &sticker_set_ids) { if (!are_installed_sticker_sets_loaded_[is_masks]) { return -1; } - vector ¤t_sticker_set_ids = installed_sticker_set_ids_[is_masks]; + vector ¤t_sticker_set_ids = installed_sticker_set_ids_[is_masks]; if (sticker_set_ids == current_sticker_set_ids) { return 0; } - std::unordered_set valid_set_ids(current_sticker_set_ids.begin(), current_sticker_set_ids.end()); - vector new_sticker_set_ids; + std::unordered_set valid_set_ids(current_sticker_set_ids.begin(), + current_sticker_set_ids.end()); + vector new_sticker_set_ids; for (auto sticker_set_id : sticker_set_ids) { auto it = valid_set_ids.find(sticker_set_id); if (it != valid_set_ids.end()) { @@ -3354,7 +3356,7 @@ int StickersManager::apply_installed_sticker_sets_order(bool is_masks, const vec return 0; } if (!valid_set_ids.empty()) { - vector missed_sticker_set_ids; + vector missed_sticker_set_ids; for (auto sticker_set_id : current_sticker_set_ids) { auto it = valid_set_ids.find(sticker_set_id); if (it != valid_set_ids.end()) { @@ -3379,7 +3381,7 @@ int StickersManager::apply_installed_sticker_sets_order(bool is_masks, const vec return 2; } -void StickersManager::on_update_sticker_sets_order(bool is_masks, const vector &sticker_set_ids) { +void StickersManager::on_update_sticker_sets_order(bool is_masks, const vector &sticker_set_ids) { int result = apply_installed_sticker_sets_order(is_masks, sticker_set_ids); if (result < 0) { return reload_installed_sticker_sets(is_masks, true); @@ -3389,7 +3391,7 @@ void StickersManager::on_update_sticker_sets_order(bool is_masks, const vector &sticker_set_ids, +void StickersManager::reorder_installed_sticker_sets(bool is_masks, const vector &sticker_set_ids, Promise &&promise) { auto result = apply_installed_sticker_sets_order(is_masks, sticker_set_ids); if (result < 0) { @@ -3846,7 +3848,7 @@ vector StickersManager::get_attached_sticker_file_ids(const vectorset_id == 0) { + if (!s->set_id.is_valid()) { // only stickers from sticker sets can be attached to files continue; } @@ -3875,7 +3877,7 @@ vector StickersManager::get_attached_sticker_file_ids(const vector &sticker_set_ids) const { +int32 StickersManager::get_sticker_sets_hash(const vector &sticker_set_ids) const { vector numbers; numbers.reserve(sticker_set_ids.size()); for (auto sticker_set_id : sticker_set_ids) { @@ -3895,7 +3897,7 @@ int32 StickersManager::get_featured_sticker_sets_hash() const { CHECK(sticker_set != nullptr); CHECK(sticker_set->is_inited); - uint64 pack_id = static_cast(sticker_set_id); + uint64 pack_id = static_cast(sticker_set_id.get()); numbers.push_back(static_cast(pack_id >> 32)); numbers.push_back(static_cast(pack_id & 0xFFFFFFFF)); @@ -3906,10 +3908,18 @@ int32 StickersManager::get_featured_sticker_sets_hash() const { return get_vector_hash(numbers); } +vector StickersManager::convert_sticker_set_ids(const vector &sticker_set_ids) { + return transform(sticker_set_ids, [](StickerSetId sticker_set_id) { return sticker_set_id.get(); }); +} + +vector StickersManager::convert_sticker_set_ids(const vector &sticker_set_ids) { + return transform(sticker_set_ids, [](int64 sticker_set_id) { return StickerSetId(sticker_set_id); }); +} + td_api::object_ptr StickersManager::get_update_installed_sticker_sets_object( int is_masks) const { - return td_api::make_object(is_masks != 0, - vector(installed_sticker_set_ids_[is_masks])); + return td_api::make_object( + is_masks != 0, convert_sticker_set_ids(installed_sticker_set_ids_[is_masks])); } void StickersManager::send_update_installed_sticker_sets(bool from_database) { @@ -4203,7 +4213,7 @@ bool StickersManager::add_recent_sticker_impl(bool is_attached, FileId sticker_i promise.set_error(Status::Error(7, "Sticker not found")); return false; } - if (sticker->set_id == 0) { + if (!sticker->set_id.is_valid()) { promise.set_error(Status::Error(7, "Stickers without sticker set can't be added to recent")); return false; } @@ -4614,7 +4624,7 @@ bool StickersManager::add_favorite_sticker_impl(FileId sticker_id, Promise promise.set_error(Status::Error(7, "Sticker not found")); return false; } - if (sticker->set_id == 0) { + if (!sticker->set_id.is_valid()) { promise.set_error(Status::Error(7, "Stickers without sticker set can't be favorite")); return false; } @@ -4733,7 +4743,7 @@ vector StickersManager::get_sticker_emojis(const tl_object_ptrset_id == 0) { + if (!sticker->set_id.is_valid()) { promise.set_value(Unit()); return {}; } diff --git a/td/telegram/StickersManager.h b/td/telegram/StickersManager.h index b30446c95..646f4604e 100644 --- a/td/telegram/StickersManager.h +++ b/td/telegram/StickersManager.h @@ -15,6 +15,7 @@ #include "td/telegram/files/FileSourceId.h" #include "td/telegram/Photo.h" #include "td/telegram/SecretInputMedia.h" +#include "td/telegram/StickerSetId.h" #include "td/utils/buffer.h" #include "td/utils/common.h" @@ -38,18 +39,22 @@ class StickersManager : public Actor { public: static constexpr int64 GREAT_MINDS_SET_ID = 1842540969984001; + static vector convert_sticker_set_ids(const vector &sticker_set_ids); + static vector convert_sticker_set_ids(const vector &sticker_set_ids); + StickersManager(Td *td, ActorShared<> parent); tl_object_ptr get_sticker_object(FileId file_id) const; tl_object_ptr get_stickers_object(const vector &sticker_ids) const; - tl_object_ptr get_sticker_set_object(int64 sticker_set_id) const; + tl_object_ptr get_sticker_set_object(StickerSetId sticker_set_id) const; - tl_object_ptr get_sticker_sets_object(int32 total_count, const vector &sticker_set_ids, + tl_object_ptr get_sticker_sets_object(int32 total_count, + const vector &sticker_set_ids, size_t covers_limit) const; - tl_object_ptr get_input_sticker_set(int64 sticker_set_id) const; + tl_object_ptr get_input_sticker_set(StickerSetId sticker_set_id) const; void create_sticker(FileId file_id, PhotoSize thumbnail, Dimensions dimensions, tl_object_ptr sticker, bool is_animated, @@ -69,68 +74,69 @@ class StickersManager : public Actor { vector search_stickers(string emoji, int32 limit, Promise &&promise); - vector get_installed_sticker_sets(bool is_masks, Promise &&promise); + vector get_installed_sticker_sets(bool is_masks, Promise &&promise); bool has_webp_thumbnail(const tl_object_ptr &sticker); - int64 get_sticker_set_id(const tl_object_ptr &set_ptr); + StickerSetId get_sticker_set_id(const tl_object_ptr &set_ptr); - int64 add_sticker_set(tl_object_ptr &&set_ptr); + StickerSetId add_sticker_set(tl_object_ptr &&set_ptr); - int64 get_sticker_set(int64 set_id, Promise &&promise); + StickerSetId get_sticker_set(StickerSetId set_id, Promise &&promise); - int64 search_sticker_set(const string &short_name_to_search, Promise &&promise); + StickerSetId search_sticker_set(const string &short_name_to_search, Promise &&promise); - std::pair> search_installed_sticker_sets(bool is_masks, const string &query, int32 limit, - Promise &&promise); + std::pair> search_installed_sticker_sets(bool is_masks, const string &query, int32 limit, + Promise &&promise); - vector search_sticker_sets(const string &query, Promise &&promise); + vector search_sticker_sets(const string &query, Promise &&promise); - void change_sticker_set(int64 set_id, bool is_installed, bool is_archived, Promise &&promise); + void change_sticker_set(StickerSetId set_id, bool is_installed, bool is_archived, Promise &&promise); - void view_featured_sticker_sets(const vector &sticker_set_ids); + void view_featured_sticker_sets(const vector &sticker_set_ids); void on_get_installed_sticker_sets(bool is_masks, tl_object_ptr &&stickers_ptr); void on_get_installed_sticker_sets_failed(bool is_masks, Status error); - void on_get_messages_sticker_set(int64 sticker_set_id, tl_object_ptr &&set, + void on_get_messages_sticker_set(StickerSetId sticker_set_id, tl_object_ptr &&set, bool is_changed); - int64 on_get_sticker_set(tl_object_ptr &&set, bool is_changed); + StickerSetId on_get_sticker_set(tl_object_ptr &&set, bool is_changed); - int64 on_get_sticker_set_covered(tl_object_ptr &&set_ptr, bool is_changed); + StickerSetId on_get_sticker_set_covered(tl_object_ptr &&set_ptr, bool is_changed); - void on_load_sticker_set_fail(int64 sticker_set_id, const Status &error); + void on_load_sticker_set_fail(StickerSetId sticker_set_id, const Status &error); - void on_install_sticker_set(int64 set_id, bool is_archived, + void on_install_sticker_set(StickerSetId set_id, bool is_archived, tl_object_ptr &&result); - void on_uninstall_sticker_set(int64 set_id); + void on_uninstall_sticker_set(StickerSetId set_id); void on_update_sticker_sets(); - void on_update_sticker_sets_order(bool is_masks, const vector &sticker_set_ids); + void on_update_sticker_sets_order(bool is_masks, const vector &sticker_set_ids); - std::pair> get_archived_sticker_sets(bool is_masks, int64 offset_sticker_set_id, int32 limit, - bool force, Promise &&promise); + std::pair> get_archived_sticker_sets(bool is_masks, StickerSetId offset_sticker_set_id, + int32 limit, bool force, Promise &&promise); - void on_get_archived_sticker_sets(bool is_masks, int64 offset_sticker_set_id, + void on_get_archived_sticker_sets(bool is_masks, StickerSetId offset_sticker_set_id, vector> &&sticker_sets, int32 total_count); - vector get_featured_sticker_sets(Promise &&promise); + vector get_featured_sticker_sets(Promise &&promise); void on_get_featured_sticker_sets(tl_object_ptr &&sticker_sets_ptr); void on_get_featured_sticker_sets_failed(Status error); - vector get_attached_sticker_sets(FileId file_id, Promise &&promise); + vector get_attached_sticker_sets(FileId file_id, Promise &&promise); void on_get_attached_sticker_sets(FileId file_id, vector> &&sticker_sets); - void reorder_installed_sticker_sets(bool is_masks, const vector &sticker_set_ids, Promise &&promise); + void reorder_installed_sticker_sets(bool is_masks, const vector &sticker_set_ids, + Promise &&promise); FileId upload_sticker_file(UserId user_id, const tl_object_ptr &sticker, Promise &&promise); @@ -201,7 +207,7 @@ class StickersManager : public Actor { td_api::object_ptr get_emoji_suggestions_url_result(int64 random_id); - void reload_sticker_set(int64 sticker_set_id, int64 access_hash, Promise &&promise); + void reload_sticker_set(StickerSetId sticker_set_id, int64 access_hash, Promise &&promise); void reload_installed_sticker_sets(bool is_masks, bool force); @@ -246,10 +252,10 @@ class StickersManager : public Actor { void get_current_state(vector> &updates) const; template - void store_sticker_set_id(int64 sticker_set_id, StorerT &storer) const; + void store_sticker_set_id(StickerSetId sticker_set_id, StorerT &storer) const; template - void parse_sticker_set_id(int64 &sticker_set_id, ParserT &parser); + void parse_sticker_set_id(StickerSetId &sticker_set_id, ParserT &parser); private: static constexpr int32 MAX_FEATURED_STICKER_SET_VIEW_DELAY = 5; @@ -263,7 +269,7 @@ class StickersManager : public Actor { class Sticker { public: - int64 set_id = 0; + StickerSetId set_id; string alt; Dimensions dimensions; PhotoSize s_thumbnail; @@ -285,7 +291,7 @@ class StickersManager : public Actor { bool was_loaded = false; bool is_loaded = false; - int64 id = 0; + StickerSetId id; int64 access_hash = 0; string title; string short_name; @@ -337,56 +343,58 @@ class StickersManager : public Actor { static tl_object_ptr get_mask_point_object(int32 point); - tl_object_ptr get_sticker_set_info_object(int64 sticker_set_id, size_t covers_limit) const; + tl_object_ptr get_sticker_set_info_object(StickerSetId sticker_set_id, + size_t covers_limit) const; Sticker *get_sticker(FileId file_id); const Sticker *get_sticker(FileId file_id) const; FileId on_get_sticker(unique_ptr new_sticker, bool replace); - StickerSet *get_sticker_set(int64 sticker_set_id); - const StickerSet *get_sticker_set(int64 sticker_set_id) const; + StickerSet *get_sticker_set(StickerSetId sticker_set_id); + const StickerSet *get_sticker_set(StickerSetId sticker_set_id) const; - StickerSet *add_sticker_set(int64 sticker_set_id, int64 access_hash); + StickerSet *add_sticker_set(StickerSetId sticker_set_id, int64 access_hash); std::pair on_get_sticker_document(tl_object_ptr &&document_ptr); static tl_object_ptr get_input_sticker_set(const StickerSet *set); - int64 on_get_input_sticker_set(FileId sticker_file_id, tl_object_ptr &&set_ptr, - MultiPromiseActor *load_data_multipromise_ptr = nullptr); + StickerSetId on_get_input_sticker_set(FileId sticker_file_id, tl_object_ptr &&set_ptr, + MultiPromiseActor *load_data_multipromise_ptr = nullptr); void on_resolve_sticker_set_short_name(FileId sticker_file_id, const string &short_name); - int apply_installed_sticker_sets_order(bool is_masks, const vector &sticker_set_ids); + int apply_installed_sticker_sets_order(bool is_masks, const vector &sticker_set_ids); void on_update_sticker_set(StickerSet *sticker_set, bool is_installed, bool is_archived, bool is_changed, bool from_database = false); - static string get_sticker_set_database_key(int64 set_id); + static string get_sticker_set_database_key(StickerSetId set_id); - static string get_full_sticker_set_database_key(int64 set_id); + static string get_full_sticker_set_database_key(StickerSetId set_id); string get_sticker_set_database_value(const StickerSet *s, bool with_stickers); void update_sticker_set(StickerSet *sticker_set); - void load_sticker_sets(vector &&sticker_set_ids, Promise &&promise); + void load_sticker_sets(vector &&sticker_set_ids, Promise &&promise); - void load_sticker_sets_without_stickers(vector &&sticker_set_ids, Promise &&promise); + void load_sticker_sets_without_stickers(vector &&sticker_set_ids, Promise &&promise); - void on_load_sticker_set_from_database(int64 sticker_set_id, bool with_stickers, string value); + void on_load_sticker_set_from_database(StickerSetId sticker_set_id, bool with_stickers, string value); void update_load_requests(StickerSet *sticker_set, bool with_stickers, const Status &status); void update_load_request(uint32 load_request_id, const Status &status); - void do_reload_sticker_set(int64 sticker_set_id, tl_object_ptr &&input_sticker_set, + void do_reload_sticker_set(StickerSetId sticker_set_id, + tl_object_ptr &&input_sticker_set, Promise &&promise) const; static void read_featured_sticker_sets(void *td_void); - int32 get_sticker_sets_hash(const vector &sticker_set_ids) const; + int32 get_sticker_sets_hash(const vector &sticker_set_ids) const; int32 get_featured_sticker_sets_hash() const; @@ -400,12 +408,12 @@ class StickersManager : public Actor { void on_load_installed_sticker_sets_from_database(bool is_masks, string value); - void on_load_installed_sticker_sets_finished(bool is_masks, vector &&installed_sticker_set_ids, + void on_load_installed_sticker_sets_finished(bool is_masks, vector &&installed_sticker_set_ids, bool from_database = false); void on_load_featured_sticker_sets_from_database(string value); - void on_load_featured_sticker_sets_finished(vector &&featured_sticker_set_ids); + void on_load_featured_sticker_sets_finished(vector &&featured_sticker_set_ids); void on_load_recent_stickers_from_database(bool is_attached, string value); @@ -520,12 +528,12 @@ class StickersManager : public Actor { Td *td_; ActorShared<> parent_; - std::unordered_map, FileIdHash> stickers_; // file_id -> Sticker - std::unordered_map> sticker_sets_; // id -> StickerSet - std::unordered_map short_name_to_sticker_set_id_; + std::unordered_map, FileIdHash> stickers_; // file_id -> Sticker + std::unordered_map, StickerSetIdHash> sticker_sets_; // id -> StickerSet + std::unordered_map short_name_to_sticker_set_id_; - vector installed_sticker_set_ids_[2]; - vector featured_sticker_set_ids_; + vector installed_sticker_set_ids_[2]; + vector featured_sticker_set_ids_; vector recent_sticker_ids_[2]; vector favorite_sticker_ids_; @@ -559,20 +567,20 @@ class StickersManager : public Actor { vector favorite_sticker_file_ids_; FileSourceId favorite_stickers_file_source_id_; - vector archived_sticker_set_ids_[2]; + vector archived_sticker_set_ids_[2]; int32 total_archived_sticker_set_count_[2] = {-1, -1}; - std::unordered_map, FileIdHash> attached_sticker_sets_; + std::unordered_map, FileIdHash> attached_sticker_sets_; Hints installed_sticker_sets_hints_[2]; // search installed sticker sets by their title and name std::unordered_map> found_stickers_; std::unordered_map>> search_stickers_queries_; - std::unordered_map> found_sticker_sets_; + std::unordered_map> found_sticker_sets_; std::unordered_map>> search_sticker_sets_queries_; - std::unordered_set pending_viewed_featured_sticker_set_ids_; + std::unordered_set pending_viewed_featured_sticker_set_ids_; Timeout pending_featured_sticker_set_views_timeout_; int32 recent_stickers_limit_ = 200; diff --git a/td/telegram/StickersManager.hpp b/td/telegram/StickersManager.hpp index ce158c64e..5a4a8b5fd 100644 --- a/td/telegram/StickersManager.hpp +++ b/td/telegram/StickersManager.hpp @@ -25,7 +25,7 @@ void StickersManager::store_sticker(FileId file_id, bool in_sticker_set, StorerT auto it = stickers_.find(file_id); CHECK(it != stickers_.end()); const Sticker *sticker = it->second.get(); - bool has_sticker_set_access_hash = sticker->set_id != 0 && !in_sticker_set; + bool has_sticker_set_access_hash = sticker->set_id.is_valid() && !in_sticker_set; BEGIN_STORE_FLAGS(); STORE_FLAG(sticker->is_mask); STORE_FLAG(has_sticker_set_access_hash); @@ -33,7 +33,7 @@ void StickersManager::store_sticker(FileId file_id, bool in_sticker_set, StorerT STORE_FLAG(sticker->is_animated); END_STORE_FLAGS(); if (!in_sticker_set) { - store(sticker->set_id, storer); + store(sticker->set_id.get(), storer); if (has_sticker_set_access_hash) { auto sticker_set = get_sticker_set(sticker->set_id); CHECK(sticker_set != nullptr); @@ -81,14 +81,16 @@ FileId StickersManager::parse_sticker(bool in_sticker_set, ParserT &parser) { return FileId(); } if (!in_sticker_set) { - parse(sticker->set_id, parser); + int64 set_id; + parse(set_id, parser); + sticker->set_id = StickerSetId(set_id); if (has_sticker_set_access_hash) { int64 sticker_set_access_hash; parse(sticker_set_access_hash, parser); add_sticker_set(sticker->set_id, sticker_set_access_hash); } else { // backward compatibility - sticker->set_id = 0; + sticker->set_id = StickerSetId(); } } parse(sticker->alt, parser); @@ -133,7 +135,7 @@ void StickersManager::store_sticker_set(const StickerSet *sticker_set, bool with STORE_FLAG(sticker_set->is_thumbnail_reloaded); STORE_FLAG(sticker_set->is_animated); END_STORE_FLAGS(); - store(sticker_set->id, storer); + store(sticker_set->id.get(), storer); store(sticker_set->access_hash, storer); if (sticker_set->is_inited) { store(sticker_set->title, storer); @@ -195,9 +197,9 @@ void StickersManager::parse_sticker_set(StickerSet *sticker_set, ParserT &parser int64 access_hash; parse(sticker_set_id, parser); parse(access_hash, parser); - CHECK(sticker_set->id == sticker_set_id); + CHECK(sticker_set->id.get() == sticker_set_id); if (sticker_set->access_hash != access_hash) { - LOG(ERROR) << "Sticker set " << sticker_set_id << " access hash has changed from " << access_hash << " to " + LOG(ERROR) << "Access hash of " << sticker_set_id << " has changed from " << access_hash << " to " << sticker_set->access_hash; } @@ -231,21 +233,21 @@ void StickersManager::parse_sticker_set(StickerSet *sticker_set, ParserT &parser on_update_sticker_set(sticker_set, is_installed, is_archived, false, true); } else { if (sticker_set->title != title) { - LOG(INFO) << "Sticker set " << sticker_set_id << " title has changed"; + LOG(INFO) << "Title of " << sticker_set_id << " has changed"; } if (sticker_set->short_name != short_name) { - LOG(ERROR) << "Sticker set " << sticker_set_id << " short name has changed from \"" << short_name << "\" to \"" + LOG(ERROR) << "Short name of " << sticker_set_id << " has changed from \"" << short_name << "\" to \"" << sticker_set->short_name << "\""; } if (sticker_set->sticker_count != sticker_count || sticker_set->hash != hash) { sticker_set->is_loaded = false; } if (sticker_set->is_animated != is_animated) { - LOG(ERROR) << "Sticker set " << sticker_set_id << " is_animated has changed from \"" << is_animated - << "\" to \"" << sticker_set->is_animated << "\""; + LOG(ERROR) << "Is animated of " << sticker_set_id << " has changed from \"" << is_animated << "\" to \"" + << sticker_set->is_animated << "\""; } if (sticker_set->is_masks != is_masks) { - LOG(ERROR) << "Sticker set " << sticker_set_id << " is_masks has changed from \"" << is_masks << "\" to \"" + LOG(ERROR) << "Is masks of " << sticker_set_id << " has changed from \"" << is_masks << "\" to \"" << sticker_set->is_masks << "\""; } } @@ -270,7 +272,7 @@ void StickersManager::parse_sticker_set(StickerSet *sticker_set, ParserT &parser Sticker *sticker = get_sticker(sticker_id); CHECK(sticker != nullptr); if (sticker->set_id != sticker_set->id) { - LOG_IF(ERROR, sticker->set_id != 0) << "Sticker " << sticker_id << " set_id has changed"; + LOG_IF(ERROR, sticker->set_id.is_valid()) << "Sticker " << sticker_id << " set_id has changed"; sticker->set_id = sticker_set->id; sticker->is_changed = true; } @@ -294,17 +296,19 @@ void StickersManager::parse_sticker_set(StickerSet *sticker_set, ParserT &parser } template -void StickersManager::store_sticker_set_id(int64 sticker_set_id, StorerT &storer) const { - CHECK(sticker_set_id != 0); +void StickersManager::store_sticker_set_id(StickerSetId sticker_set_id, StorerT &storer) const { + CHECK(sticker_set_id.is_valid()); const StickerSet *sticker_set = get_sticker_set(sticker_set_id); CHECK(sticker_set != nullptr); - store(sticker_set_id, storer); + store(sticker_set_id.get(), storer); store(sticker_set->access_hash, storer); } template -void StickersManager::parse_sticker_set_id(int64 &sticker_set_id, ParserT &parser) { - parse(sticker_set_id, parser); +void StickersManager::parse_sticker_set_id(StickerSetId &sticker_set_id, ParserT &parser) { + int64 set_id; + parse(set_id, parser); + sticker_set_id = StickerSetId(set_id); int64 sticker_set_access_hash; parse(sticker_set_access_hash, parser); add_sticker_set(sticker_set_id, sticker_set_access_hash); diff --git a/td/telegram/Td.cpp b/td/telegram/Td.cpp index de2ec72b0..93b6b177a 100644 --- a/td/telegram/Td.cpp +++ b/td/telegram/Td.cpp @@ -71,6 +71,7 @@ #include "td/telegram/SecureManager.h" #include "td/telegram/SecureValue.h" #include "td/telegram/StateManager.h" +#include "td/telegram/StickerSetId.h" #include "td/telegram/StickersManager.h" #include "td/telegram/StorageManager.h" #include "td/telegram/TdDb.h" @@ -235,12 +236,12 @@ class GetRecentMeUrlsQuery : public Td::ResultHandler { auto url = move_tl_object_as(url_ptr); result->url_ = std::move(url->url_); auto sticker_set_id = td->stickers_manager_->on_get_sticker_set_covered(std::move(url->set_), false); - if (sticker_set_id == 0) { + if (!sticker_set_id.is_valid()) { LOG(ERROR) << "Receive invalid sticker set"; result = nullptr; break; } - result->type_ = make_tl_object(sticker_set_id); + result->type_ = make_tl_object(sticker_set_id.get()); break; } case telegram_api::recentMeUrlUnknown::ID: @@ -2387,7 +2388,7 @@ class SearchStickersRequest : public RequestActor<> { class GetInstalledStickerSetsRequest : public RequestActor<> { bool is_masks_; - vector sticker_set_ids_; + vector sticker_set_ids_; void do_run(Promise &&promise) override { sticker_set_ids_ = td->stickers_manager_->get_installed_sticker_sets(is_masks_, std::move(promise)); @@ -2405,11 +2406,11 @@ class GetInstalledStickerSetsRequest : public RequestActor<> { class GetArchivedStickerSetsRequest : public RequestActor<> { bool is_masks_; - int64 offset_sticker_set_id_; + StickerSetId offset_sticker_set_id_; int32 limit_; int32 total_count_; - vector sticker_set_ids_; + vector sticker_set_ids_; void do_run(Promise &&promise) override { std::tie(total_count_, sticker_set_ids_) = td->stickers_manager_->get_archived_sticker_sets( @@ -2431,7 +2432,7 @@ class GetArchivedStickerSetsRequest : public RequestActor<> { }; class GetTrendingStickerSetsRequest : public RequestActor<> { - vector sticker_set_ids_; + vector sticker_set_ids_; void do_run(Promise &&promise) override { sticker_set_ids_ = td->stickers_manager_->get_featured_sticker_sets(std::move(promise)); @@ -2449,7 +2450,7 @@ class GetTrendingStickerSetsRequest : public RequestActor<> { class GetAttachedStickerSetsRequest : public RequestActor<> { FileId file_id_; - vector sticker_set_ids_; + vector sticker_set_ids_; void do_run(Promise &&promise) override { sticker_set_ids_ = td->stickers_manager_->get_attached_sticker_sets(file_id_, std::move(promise)); @@ -2466,9 +2467,9 @@ class GetAttachedStickerSetsRequest : public RequestActor<> { }; class GetStickerSetRequest : public RequestActor<> { - int64 set_id_; + StickerSetId set_id_; - int64 sticker_set_id_; + StickerSetId sticker_set_id_; void do_run(Promise &&promise) override { sticker_set_id_ = td->stickers_manager_->get_sticker_set(set_id_, std::move(promise)); @@ -2488,7 +2489,7 @@ class GetStickerSetRequest : public RequestActor<> { class SearchStickerSetRequest : public RequestActor<> { string name_; - int64 sticker_set_id_; + StickerSetId sticker_set_id_; void do_run(Promise &&promise) override { sticker_set_id_ = td->stickers_manager_->search_sticker_set(name_, std::move(promise)); @@ -2510,7 +2511,7 @@ class SearchInstalledStickerSetsRequest : public RequestActor<> { string query_; int32 limit_; - std::pair> sticker_set_ids_; + std::pair> sticker_set_ids_; void do_run(Promise &&promise) override { sticker_set_ids_ = @@ -2530,7 +2531,7 @@ class SearchInstalledStickerSetsRequest : public RequestActor<> { class SearchStickerSetsRequest : public RequestActor<> { string query_; - vector sticker_set_ids_; + vector sticker_set_ids_; void do_run(Promise &&promise) override { sticker_set_ids_ = td->stickers_manager_->search_sticker_sets(query_, std::move(promise)); @@ -2547,7 +2548,7 @@ class SearchStickerSetsRequest : public RequestActor<> { }; class ChangeStickerSetRequest : public RequestOnceActor { - int64 set_id_; + StickerSetId set_id_; bool is_installed_; bool is_archived_; @@ -2600,7 +2601,7 @@ class CreateNewStickerSetRequest : public RequestOnceActor { void do_send_result() override { auto set_id = td->stickers_manager_->search_sticker_set(name_, Auto()); - if (set_id == 0) { + if (!set_id.is_valid()) { return send_error(Status::Error(500, "Created sticker set not found")); } send_result(td->stickers_manager_->get_sticker_set_object(set_id)); @@ -2629,7 +2630,7 @@ class AddStickerToSetRequest : public RequestOnceActor { void do_send_result() override { auto set_id = td->stickers_manager_->search_sticker_set(name_, Auto()); - if (set_id == 0) { + if (!set_id.is_valid()) { return send_error(Status::Error(500, "Sticker set not found")); } send_result(td->stickers_manager_->get_sticker_set_object(set_id)); @@ -6435,7 +6436,7 @@ void Td::on_request(uint64 id, td_api::setSupergroupUsername &request) { void Td::on_request(uint64 id, const td_api::setSupergroupStickerSet &request) { CREATE_OK_REQUEST_PROMISE(); - contacts_manager_->set_channel_sticker_set(ChannelId(request.supergroup_id_), request.sticker_set_id_, + contacts_manager_->set_channel_sticker_set(ChannelId(request.supergroup_id_), StickerSetId(request.sticker_set_id_), std::move(promise)); } @@ -6535,14 +6536,15 @@ void Td::on_request(uint64 id, const td_api::changeStickerSet &request) { void Td::on_request(uint64 id, const td_api::viewTrendingStickerSets &request) { CHECK_IS_USER(); - stickers_manager_->view_featured_sticker_sets(request.sticker_set_ids_); + stickers_manager_->view_featured_sticker_sets(StickersManager::convert_sticker_set_ids(request.sticker_set_ids_)); send_closure(actor_id(this), &Td::send_result, id, make_tl_object()); } void Td::on_request(uint64 id, td_api::reorderInstalledStickerSets &request) { CHECK_IS_USER(); CREATE_OK_REQUEST_PROMISE(); - stickers_manager_->reorder_installed_sticker_sets(request.is_masks_, request.sticker_set_ids_, std::move(promise)); + stickers_manager_->reorder_installed_sticker_sets( + request.is_masks_, StickersManager::convert_sticker_set_ids(request.sticker_set_ids_), std::move(promise)); } void Td::on_request(uint64 id, td_api::uploadStickerFile &request) { diff --git a/td/telegram/UpdatesManager.cpp b/td/telegram/UpdatesManager.cpp index 6da480f27..048e4d8d2 100644 --- a/td/telegram/UpdatesManager.cpp +++ b/td/telegram/UpdatesManager.cpp @@ -1822,7 +1822,7 @@ void UpdatesManager::on_update(tl_object_ptr update } void UpdatesManager::on_update(tl_object_ptr update, bool /*force_apply*/) { - td_->stickers_manager_->on_get_messages_sticker_set(0, std::move(update->stickerset_), true); + td_->stickers_manager_->on_get_messages_sticker_set(StickerSetId(), std::move(update->stickerset_), true); } void UpdatesManager::on_update(tl_object_ptr update, bool /*force_apply*/) { @@ -1831,7 +1831,8 @@ void UpdatesManager::on_update(tl_object_ptr up void UpdatesManager::on_update(tl_object_ptr update, bool /*force_apply*/) { bool is_masks = (update->flags_ & telegram_api::updateStickerSetsOrder::MASKS_MASK) != 0; - td_->stickers_manager_->on_update_sticker_sets_order(is_masks, update->order_); + td_->stickers_manager_->on_update_sticker_sets_order(is_masks, + StickersManager::convert_sticker_set_ids(update->order_)); } void UpdatesManager::on_update(tl_object_ptr update, bool /*force_apply*/) {