diff --git a/data/web/core.telegram.org/tdlib/docs.html b/data/web/core.telegram.org/tdlib/docs.html deleted file mode 100644 index a6dad42d1a..0000000000 --- a/data/web/core.telegram.org/tdlib/docs.html +++ /dev/null @@ -1,210 +0,0 @@ - - - -
- - - - -TDLib (Telegram Database library) is a cross-platform library for building Telegram clients. It can be easily used from almost any programming language.
-TDLib
has many advantages. Notably TDLib
is:
TDLib
can be used on Android, iOS, Windows, macOS, Linux, FreeBSD, OpenBSD, NetBSD, illumos, Windows Phone, WebAssembly, watchOS, tvOS, Tizen, Cygwin. It should also work on other *nix systems with or without minimal effort.TDLib
can be easily used with any programming language that is able to execute C functions. Additionally it already has native Java (using JNI
) bindings and .NET (using C++/CLI
and C++/CX
) bindings.TDLib
takes care of all network implementation details, encryption and local data storage.TDLib
instance handles more than 24000 active bots simultaneously.TDLib
API methods and public interfaces are fully documented.TDLib
guarantees that all updates are delivered in the right order.TDLib
remains stable on slow and unreliable Internet connections.TDLib
don't block each other or anything else, responses are sent when they are available.See our Getting Started tutorial for a description of basic TDLib concepts.
-Take a look at our examples.
-See a TDLib build instructions generator for detailed instructions on how to build TDLib.
-See description of our JSON, C++, Java and .NET interfaces.
-See the td_api.tl scheme or the automatically generated HTML documentation for a list of all available TDLib
methods and classes.
TDLib
depends on:
The simplest way to build TDLib
is to use our TDLib build instructions generator. You need only to choose your programming language and target operating system to receive complete build instructions.
In general, you need to install all TDLib
dependencies, enter directory containing TDLib
sources and compile them using CMake:
To build TDLib
on low memory devices you can run SplitSource.php script before compiling main TDLib
source code and compile only needed targets:
In our tests clang 6.0 with libc++ required less than 500 MB of RAM per file and GCC 4.9/6.3 used less than 1 GB of RAM per file.
-For C++ projects that use CMake, the best approach is to build TDLib
as part of your project or to install it system-wide.
There are several libraries that you could use in your CMake project:
-For example, part of your CMakeLists.txt may look like this:
Or you could install TDLib
and then reference it in your CMakeLists.txt like this:
See example/cpp/CMakeLists.txt.
-TDLib
provides native Java interface through JNI. To enable it, specify option -DTD_ENABLE_JNI=ON
to CMake.
See example/java for example of using TDLib
from Java and detailed build and usage instructions.
TDLib
provides native .NET interface through C++/CLI
and C++/CX
. To enable it, specify option -DTD_ENABLE_DOTNET=ON
to CMake. .NET Core supports C++/CLI
only since version 3.1 and only on Windows, so if older .NET Core is used or portability is needed, then TDLib
JSON interface should be used through P/Invoke instead.
See example/csharp for example of using TDLib
from C# and detailed build and usage instructions. See example/uwp for example of using TDLib
from C# UWP application and detailed build and usage instructions for Visual Studio Extension "TDLib for Universal Windows Platform".
When TDLib
is built with TD_ENABLE_DOTNET
option enabled, C++
documentation is removed from some files. You need to checkout these files to return C++
documentation back:
TDLib
provides efficient native C++, Java, and .NET interfaces. But for most use cases we suggest to use the JSON interface, which can be easily used with any programming language that is able to execute C functions. See td_json_client documentation for detailed JSON interface description, the td_api.tl scheme or the automatically generated HTML documentation for a list of all available TDLib
methods and classes.
TDLib
JSON interface adheres to semantic versioning and versions with the same major version number are binary and backward compatible, but the underlying TDLib
API can be different for different minor and even patch versions. If you need to support different TDLib
versions, then you can use a value of the version
option to find exact TDLib
version to use appropriate API methods.
See example/python/tdjson_example.py for an example of such usage.
-TDLib
is licensed under the terms of the Boost Software License. See LICENSE_1_0.txt for more information.
Contains declarations of all functions and types which represent a public TDLib interface.
+Go to the source code of this file.
++Typedefs | |
using | int32 = std::int32_t |
using | int53 = std::int64_t |
using | int64 = std::int64_t |
using | string = std::string |
using | bytes = std::string |
template<class Type > | |
using | array = std::vector< Type > |
using | BaseObject = ::td::TlObject |
template<class Type > | |
using | object_ptr = ::td::tl_object_ptr< Type > |
+Functions | |
template<class Type , class... Args> | |
object_ptr< Type > | make_object (Args &&... args) |
template<class ToType , class FromType > | |
object_ptr< ToType > | move_object_as (FromType &&from) |
std::string | to_string (const BaseObject &value) |
template<class T > | |
std::string | to_string (const object_ptr< T > &value) |
template<class T > | |
std::string | to_string (const std::vector< object_ptr< T >> &values) |
using int32 = std::int32_t | +
This type is used to store 32-bit signed integers, which can be represented as Number in JSON.
+ +using int53 = std::int64_t | +
This type is used to store 53-bit signed integers, which can be represented as Number in JSON.
+ +using int64 = std::int64_t | +
This type is used to store 64-bit signed integers, which can't be represented as Number in JSON and are represented as String instead.
+ +using string = std::string | +
This type is used to store UTF-8 strings.
+ +using bytes = std::string | +
This type is used to store arbitrary sequences of bytes. In JSON interface the bytes are base64-encoded.
+ +using array = std::vector<Type> | +
This type is used to store a list of objects of any type and is represented as Array in JSON.
+ +using BaseObject = ::td::TlObject | +
This class is a base class for all TDLib API classes and functions.
+ +using object_ptr = ::td::tl_object_ptr<Type> | +
A smart wrapper to store a pointer to a TDLib API object. Can be treated as an analogue of std::unique_ptr.
+ +object_ptr<Type> td::td_api::make_object | +( | +Args &&... | +args | ) | ++ |
A function to create a dynamically allocated TDLib API object. Can be treated as an analogue of std::make_unique. Usage example:
Type | Type of an object to construct. |
[in] | args | Arguments to pass to the object constructor. |
object_ptr<ToType> td::td_api::move_object_as | +( | +FromType && | +from | ) | ++ |
A function to cast a wrapped in td::td_api::object_ptr TDLib API object to its subclass or superclass. Casting an object to an incorrect type will lead to undefined behaviour. Usage example:
ToType | Type of a TDLib API object to move to. |
FromType | Type of a TDLib API object to move from, this is auto-deduced. |
[in] | from | Wrapped in td::td_api::object_ptr pointer to a TDLib API object. |
std::string td::td_api::to_string | +( | +const BaseObject & | +value | ) | ++ |
Returns a string representation of a TDLib API object.
[in] | value | The object. |
std::string td::td_api::to_string | +( | +const object_ptr< T > & | +value | ) | ++ |
Returns a string representation of a TDLib API object.
T | Object type, auto-deduced. |
[in] | value | The object. |
std::string td::td_api::to_string | +( | +const std::vector< object_ptr< T >> & | +values | ) | ++ |
Returns a string representation of a list of TDLib API objects.
T | Object type, auto-deduced. |
[in] | values | The objects. |