we don't need this

5 files changed, 0 insertions, 431 deletions

diff --git a/protocols/Telegram/tdlib/td/example/cpp/.gitignore b/protocols/Telegram/tdlib/td/example/cpp/.gitignore
deleted file mode 100644
index 336dc7d458..0000000000
--- a/protocols/Telegram/tdlib/td/example/cpp/.gitignore
+++ /dev/null
@@ -1 +0,0 @@
-td/
diff --git a/protocols/Telegram/tdlib/td/example/cpp/CMakeLists.txt b/protocols/Telegram/tdlib/td/example/cpp/CMakeLists.txt
deleted file mode 100644
index 19c4d11011..0000000000
--- a/protocols/Telegram/tdlib/td/example/cpp/CMakeLists.txt
+++ /dev/null
@@ -1,13 +0,0 @@
-cmake_minimum_required(VERSION 3.4 FATAL_ERROR)
-
-project(TdExample VERSION 1.0 LANGUAGES CXX)
-
-find_package(Td 1.8.14 REQUIRED)
-
-add_executable(tdjson_example tdjson_example.cpp)
-target_link_libraries(tdjson_example PRIVATE Td::TdJson)
-set_property(TARGET tdjson_example PROPERTY CXX_STANDARD 11)
-
-add_executable(td_example td_example.cpp)
-target_link_libraries(td_example PRIVATE Td::TdStatic)
-set_property(TARGET td_example PROPERTY CXX_STANDARD 14)
diff --git a/protocols/Telegram/tdlib/td/example/cpp/README.md b/protocols/Telegram/tdlib/td/example/cpp/README.md
deleted file mode 100644
index c8ee34d4fa..0000000000
--- a/protocols/Telegram/tdlib/td/example/cpp/README.md
+++ /dev/null
@@ -1,24 +0,0 @@
-# TDLib C++ basic usage examples
-
-TDLib should be prebuilt and installed to local subdirectory `td/`:
-```
-cd <path to TDLib sources>
-mkdir build
-cd build
-cmake -DCMAKE_BUILD_TYPE=Release -DCMAKE_INSTALL_PREFIX:PATH=../example/cpp/td ..
-cmake --build . --target install
-```
-Also, see [building](https://github.com/tdlib/td#building) for additional details on TDLib building.
-
-After this you can build the examples:
-```
-cd <path to TDLib sources>/example/cpp
-mkdir build
-cd build
-cmake -DCMAKE_BUILD_TYPE=Release -DTd_DIR=<full path to TDLib sources>/example/cpp/td/lib/cmake/Td ..
-cmake --build .
-```
-
-Documentation for all available classes and methods can be found at https://core.telegram.org/tdlib/docs.
-
-To run the examples you may need to manually copy needed shared libraries from `td/bin` to a directory containing built binaries.
diff --git a/protocols/Telegram/tdlib/td/example/cpp/td_example.cpp b/protocols/Telegram/tdlib/td/example/cpp/td_example.cpp
deleted file mode 100644
index b30afa8070..0000000000
--- a/protocols/Telegram/tdlib/td/example/cpp/td_example.cpp
+++ /dev/null
@@ -1,338 +0,0 @@
-//
-// Copyright Aliaksei Levin (levlam@telegram.org), Arseny Smirnov (arseny30@gmail.com) 2014-2023
-//
-// 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)
-//
-#include <td/telegram/Client.h>
-#include <td/telegram/td_api.h>
-#include <td/telegram/td_api.hpp>
-
-#include <cstdint>
-#include <functional>
-#include <iostream>
-#include <map>
-#include <memory>
-#include <sstream>
-#include <string>
-#include <vector>
-
-// Simple single-threaded example of TDLib usage.
-// Real world programs should use separate thread for the user input.
-// Example includes user authentication, receiving updates, getting chat list and sending text messages.
-
-// overloaded
-namespace detail {
-template <class... Fs>
-struct overload;
-
-template <class F>
-struct overload<F> : public F {
-  explicit overload(F f) : F(f) {
-  }
-};
-template <class F, class... Fs>
-struct overload<F, Fs...>
-    : public overload<F>
-    , public overload<Fs...> {
-  overload(F f, Fs... fs) : overload<F>(f), overload<Fs...>(fs...) {
-  }
-  using overload<F>::operator();
-  using overload<Fs...>::operator();
-};
-}  // namespace detail
-
-template <class... F>
-auto overloaded(F... f) {
-  return detail::overload<F...>(f...);
-}
-
-namespace td_api = td::td_api;
-
-class TdExample {
- public:
-  TdExample() {
-    td::ClientManager::execute(td_api::make_object<td_api::setLogVerbosityLevel>(1));
-    client_manager_ = std::make_unique<td::ClientManager>();
-    client_id_ = client_manager_->create_client_id();
-    send_query(td_api::make_object<td_api::getOption>("version"), {});
-  }
-
-  void loop() {
-    while (true) {
-      if (need_restart_) {
-        restart();
-      } else if (!are_authorized_) {
-        process_response(client_manager_->receive(10));
-      } else {
-        std::cout << "Enter action [q] quit [u] check for updates and request results [c] show chats [m <chat_id> "
-                     "<text>] send message [me] show self [l] logout: "
-                  << std::endl;
-        std::string line;
-        std::getline(std::cin, line);
-        std::istringstream ss(line);
-        std::string action;
-        if (!(ss >> action)) {
-          continue;
-        }
-        if (action == "q") {
-          return;
-        }
-        if (action == "u") {
-          std::cout << "Checking for updates..." << std::endl;
-          while (true) {
-            auto response = client_manager_->receive(0);
-            if (response.object) {
-              process_response(std::move(response));
-            } else {
-              break;
-            }
-          }
-        } else if (action == "close") {
-          std::cout << "Closing..." << std::endl;
-          send_query(td_api::make_object<td_api::close>(), {});
-        } else if (action == "me") {
-          send_query(td_api::make_object<td_api::getMe>(),
-                     [this](Object object) { std::cout << to_string(object) << std::endl; });
-        } else if (action == "l") {
-          std::cout << "Logging out..." << std::endl;
-          send_query(td_api::make_object<td_api::logOut>(), {});
-        } else if (action == "m") {
-          std::int64_t chat_id;
-          ss >> chat_id;
-          ss.get();
-          std::string text;
-          std::getline(ss, text);
-
-          std::cout << "Sending message to chat " << chat_id << "..." << std::endl;
-          auto send_message = td_api::make_object<td_api::sendMessage>();
-          send_message->chat_id_ = chat_id;
-          auto message_content = td_api::make_object<td_api::inputMessageText>();
-          message_content->text_ = td_api::make_object<td_api::formattedText>();
-          message_content->text_->text_ = std::move(text);
-          send_message->input_message_content_ = std::move(message_content);
-
-          send_query(std::move(send_message), {});
-        } else if (action == "c") {
-          std::cout << "Loading chat list..." << std::endl;
-          send_query(td_api::make_object<td_api::getChats>(nullptr, 20), [this](Object object) {
-            if (object->get_id() == td_api::error::ID) {
-              return;
-            }
-            auto chats = td::move_tl_object_as<td_api::chats>(object);
-            for (auto chat_id : chats->chat_ids_) {
-              std::cout << "[chat_id:" << chat_id << "] [title:" << chat_title_[chat_id] << "]" << std::endl;
-            }
-          });
-        }
-      }
-    }
-  }
-
- private:
-  using Object = td_api::object_ptr<td_api::Object>;
-  std::unique_ptr<td::ClientManager> client_manager_;
-  std::int32_t client_id_{0};
-
-  td_api::object_ptr<td_api::AuthorizationState> authorization_state_;
-  bool are_authorized_{false};
-  bool need_restart_{false};
-  std::uint64_t current_query_id_{0};
-  std::uint64_t authentication_query_id_{0};
-
-  std::map<std::uint64_t, std::function<void(Object)>> handlers_;
-
-  std::map<std::int64_t, td_api::object_ptr<td_api::user>> users_;
-
-  std::map<std::int64_t, std::string> chat_title_;
-
-  void restart() {
-    client_manager_.reset();
-    *this = TdExample();
-  }
-
-  void send_query(td_api::object_ptr<td_api::Function> f, std::function<void(Object)> handler) {
-    auto query_id = next_query_id();
-    if (handler) {
-      handlers_.emplace(query_id, std::move(handler));
-    }
-    client_manager_->send(client_id_, query_id, std::move(f));
-  }
-
-  void process_response(td::ClientManager::Response response) {
-    if (!response.object) {
-      return;
-    }
-    //std::cout << response.request_id << " " << to_string(response.object) << std::endl;
-    if (response.request_id == 0) {
-      return process_update(std::move(response.object));
-    }
-    auto it = handlers_.find(response.request_id);
-    if (it != handlers_.end()) {
-      it->second(std::move(response.object));
-      handlers_.erase(it);
-    }
-  }
-
-  std::string get_user_name(std::int64_t user_id) const {
-    auto it = users_.find(user_id);
-    if (it == users_.end()) {
-      return "unknown user";
-    }
-    return it->second->first_name_ + " " + it->second->last_name_;
-  }
-
-  std::string get_chat_title(std::int64_t chat_id) const {
-    auto it = chat_title_.find(chat_id);
-    if (it == chat_title_.end()) {
-      return "unknown chat";
-    }
-    return it->second;
-  }
-
-  void process_update(td_api::object_ptr<td_api::Object> update) {
-    td_api::downcast_call(
-        *update, overloaded(
-                     [this](td_api::updateAuthorizationState &update_authorization_state) {
-                       authorization_state_ = std::move(update_authorization_state.authorization_state_);
-                       on_authorization_state_update();
-                     },
-                     [this](td_api::updateNewChat &update_new_chat) {
-                       chat_title_[update_new_chat.chat_->id_] = update_new_chat.chat_->title_;
-                     },
-                     [this](td_api::updateChatTitle &update_chat_title) {
-                       chat_title_[update_chat_title.chat_id_] = update_chat_title.title_;
-                     },
-                     [this](td_api::updateUser &update_user) {
-                       auto user_id = update_user.user_->id_;
-                       users_[user_id] = std::move(update_user.user_);
-                     },
-                     [this](td_api::updateNewMessage &update_new_message) {
-                       auto chat_id = update_new_message.message_->chat_id_;
-                       std::string sender_name;
-                       td_api::downcast_call(*update_new_message.message_->sender_id_,
-                                             overloaded(
-                                                 [this, &sender_name](td_api::messageSenderUser &user) {
-                                                   sender_name = get_user_name(user.user_id_);
-                                                 },
-                                                 [this, &sender_name](td_api::messageSenderChat &chat) {
-                                                   sender_name = get_chat_title(chat.chat_id_);
-                                                 }));
-                       std::string text;
-                       if (update_new_message.message_->content_->get_id() == td_api::messageText::ID) {
-                         text = static_cast<td_api::messageText &>(*update_new_message.message_->content_).text_->text_;
-                       }
-                       std::cout << "Receive message: [chat_id:" << chat_id << "] [from:" << sender_name << "] ["
-                                 << text << "]" << std::endl;
-                     },
-                     [](auto &update) {}));
-  }
-
-  auto create_authentication_query_handler() {
-    return [this, id = authentication_query_id_](Object object) {
-      if (id == authentication_query_id_) {
-        check_authentication_error(std::move(object));
-      }
-    };
-  }
-
-  void on_authorization_state_update() {
-    authentication_query_id_++;
-    td_api::downcast_call(*authorization_state_,
-                          overloaded(
-                              [this](td_api::authorizationStateReady &) {
-                                are_authorized_ = true;
-                                std::cout << "Authorization is completed" << std::endl;
-                              },
-                              [this](td_api::authorizationStateLoggingOut &) {
-                                are_authorized_ = false;
-                                std::cout << "Logging out" << std::endl;
-                              },
-                              [this](td_api::authorizationStateClosing &) { std::cout << "Closing" << std::endl; },
-                              [this](td_api::authorizationStateClosed &) {
-                                are_authorized_ = false;
-                                need_restart_ = true;
-                                std::cout << "Terminated" << std::endl;
-                              },
-                              [this](td_api::authorizationStateWaitPhoneNumber &) {
-                                std::cout << "Enter phone number: " << std::flush;
-                                std::string phone_number;
-                                std::cin >> phone_number;
-                                send_query(
-                                    td_api::make_object<td_api::setAuthenticationPhoneNumber>(phone_number, nullptr),
-                                    create_authentication_query_handler());
-                              },
-                              [this](td_api::authorizationStateWaitEmailAddress &) {
-                                std::cout << "Enter email address: " << std::flush;
-                                std::string email_address;
-                                std::cin >> email_address;
-                                send_query(td_api::make_object<td_api::setAuthenticationEmailAddress>(email_address),
-                                           create_authentication_query_handler());
-                              },
-                              [this](td_api::authorizationStateWaitEmailCode &) {
-                                std::cout << "Enter email authentication code: " << std::flush;
-                                std::string code;
-                                std::cin >> code;
-                                send_query(td_api::make_object<td_api::checkAuthenticationEmailCode>(
-                                               td_api::make_object<td_api::emailAddressAuthenticationCode>(code)),
-                                           create_authentication_query_handler());
-                              },
-                              [this](td_api::authorizationStateWaitCode &) {
-                                std::cout << "Enter authentication code: " << std::flush;
-                                std::string code;
-                                std::cin >> code;
-                                send_query(td_api::make_object<td_api::checkAuthenticationCode>(code),
-                                           create_authentication_query_handler());
-                              },
-                              [this](td_api::authorizationStateWaitRegistration &) {
-                                std::string first_name;
-                                std::string last_name;
-                                std::cout << "Enter your first name: " << std::flush;
-                                std::cin >> first_name;
-                                std::cout << "Enter your last name: " << std::flush;
-                                std::cin >> last_name;
-                                send_query(td_api::make_object<td_api::registerUser>(first_name, last_name),
-                                           create_authentication_query_handler());
-                              },
-                              [this](td_api::authorizationStateWaitPassword &) {
-                                std::cout << "Enter authentication password: " << std::flush;
-                                std::string password;
-                                std::getline(std::cin, password);
-                                send_query(td_api::make_object<td_api::checkAuthenticationPassword>(password),
-                                           create_authentication_query_handler());
-                              },
-                              [this](td_api::authorizationStateWaitOtherDeviceConfirmation &state) {
-                                std::cout << "Confirm this login link on another device: " << state.link_ << std::endl;
-                              },
-                              [this](td_api::authorizationStateWaitTdlibParameters &) {
-                                auto request = td_api::make_object<td_api::setTdlibParameters>();
-                                request->database_directory_ = "tdlib";
-                                request->use_message_database_ = true;
-                                request->use_secret_chats_ = true;
-                                request->api_id_ = 94575;
-                                request->api_hash_ = "a3406de8d171bb422bb6ddf3bbd800e2";
-                                request->system_language_code_ = "en";
-                                request->device_model_ = "Desktop";
-                                request->application_version_ = "1.0";
-                                request->enable_storage_optimizer_ = true;
-                                send_query(std::move(request), create_authentication_query_handler());
-                              }));
-  }
-
-  void check_authentication_error(Object object) {
-    if (object->get_id() == td_api::error::ID) {
-      auto error = td::move_tl_object_as<td_api::error>(object);
-      std::cout << "Error: " << to_string(error) << std::flush;
-      on_authorization_state_update();
-    }
-  }
-
-  std::uint64_t next_query_id() {
-    return ++current_query_id_;
-  }
-};
-
-int main() {
-  TdExample example;
-  example.loop();
-}
diff --git a/protocols/Telegram/tdlib/td/example/cpp/tdjson_example.cpp b/protocols/Telegram/tdlib/td/example/cpp/tdjson_example.cpp
deleted file mode 100644
index 29a9be04be..0000000000
--- a/protocols/Telegram/tdlib/td/example/cpp/tdjson_example.cpp
+++ /dev/null
@@ -1,55 +0,0 @@
-//
-// Copyright Aliaksei Levin (levlam@telegram.org), Arseny Smirnov (arseny30@gmail.com) 2014-2023
-//
-// 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)
-//
-#include <iostream>
-#include <td/telegram/td_json_client.h>
-
-// Basic example of TDLib JSON interface usage.
-// Native interface should be preferred instead in C++, so here is only an example of
-// the main event cycle, which should be essentially the same for all languages.
-
-int main() {
-  // disable TDLib logging
-  td_execute("{\"@type\":\"setLogVerbosityLevel\", \"new_verbosity_level\":0}");
-
-  int client_id = td_create_client_id();
-  // somehow share the client_id with other threads, which will be able to send requests via td_send
-
-  // start the client by sending request to it
-  td_send(client_id, "{\"@type\":\"getOption\", \"name\":\"version\"}");
-
-  const bool test_incorrect_queries = false;
-  if (test_incorrect_queries) {
-    td_execute("{\"@type\":\"setLogVerbosityLevel\", \"new_verbosity_level\":1}");
-    td_execute("");
-    td_execute("test");
-    td_execute("\"test\"");
-    td_execute("{\"@type\":\"test\", \"@extra\":1}");
-
-    td_send(client_id, "{\"@type\":\"getFileMimeType\"}");
-    td_send(client_id, "{\"@type\":\"getFileMimeType\", \"@extra\":1}");
-    td_send(client_id, "{\"@type\":\"getFileMimeType\", \"@extra\":null}");
-    td_send(client_id, "{\"@type\":\"test\"}");
-    td_send(client_id, "[]");
-    td_send(client_id, "{\"@type\":\"test\", \"@extra\":1}");
-    td_send(client_id, "{\"@type\":\"sendMessage\", \"chat_id\":true, \"@extra\":1}");
-    td_send(client_id, "test");
-  }
-
-  const double WAIT_TIMEOUT = 10.0;  // seconds
-  while (true) {
-    const char *result = td_receive(WAIT_TIMEOUT);
-    if (result != nullptr) {
-      // parse the result as a JSON object and process it as an incoming update or an answer to a previously sent request
-
-      // if (result is UpdateAuthorizationState with authorizationStateClosed) {
-      //   break;
-      // }
-
-      std::cout << result << std::endl;
-    }
-  }
-}