forked from Green-Sky/tomato
Green Sky
47ad96e2b6
da438763d5 chore: Release 0.2.19 f90417987c chore: Add cmake flag to disable unit tests. 7df3f99417 docs: Document that group topic lock is default on. 9e9ed77390 docs: Add missing param docs for callbacks. 0ec4978de5 refactor: Don't expose Tox_System in the public API a3d1b8595c docs: Public headers, Core/toxcore -> Tox/the Tox library f78d0f3f39 docs: Public headers, events_alloc -> internal 817518949e docs: Public headers, NULL-terminated -> NUL-terminated be085db191 docs: Public headers, spellcheck 4c902955f3 docs: Public headers, 80 column width comments be8a82a818 docs: Public headers, null -> NULL 419d783d95 docs: Public headers, tox -> Tox 5c8aa65e41 docs: Update user data API explanation ad4921dbaa cleanup: A more descriptive error for group invite accept function git-subtree-dir: external/toxcore/c-toxcore git-subtree-split: da438763d5b8e071de6e061a1dcaddd2177dff7d
1710 lines
52 KiB
C
1710 lines
52 KiB
C
/* SPDX-License-Identifier: GPL-3.0-or-later
|
|
* Copyright © 2016-2021 The TokTok team.
|
|
*/
|
|
#include "tox.h"
|
|
|
|
#include <stdlib.h>
|
|
|
|
#include "ccompat.h"
|
|
#include "tox_private.h"
|
|
|
|
#define SET_ERROR_PARAMETER(param, x) \
|
|
do { \
|
|
if (param != nullptr) { \
|
|
*param = x; \
|
|
} \
|
|
} while (0)
|
|
|
|
uint32_t tox_version_major(void)
|
|
{
|
|
return TOX_VERSION_MAJOR;
|
|
}
|
|
uint32_t tox_version_minor(void)
|
|
{
|
|
return TOX_VERSION_MINOR;
|
|
}
|
|
uint32_t tox_version_patch(void)
|
|
{
|
|
return TOX_VERSION_PATCH;
|
|
}
|
|
uint32_t tox_public_key_size(void)
|
|
{
|
|
return TOX_PUBLIC_KEY_SIZE;
|
|
}
|
|
uint32_t tox_secret_key_size(void)
|
|
{
|
|
return TOX_SECRET_KEY_SIZE;
|
|
}
|
|
uint32_t tox_conference_uid_size(void)
|
|
{
|
|
return TOX_CONFERENCE_UID_SIZE;
|
|
}
|
|
uint32_t tox_conference_id_size(void)
|
|
{
|
|
return TOX_CONFERENCE_ID_SIZE;
|
|
}
|
|
uint32_t tox_nospam_size(void)
|
|
{
|
|
return TOX_NOSPAM_SIZE;
|
|
}
|
|
uint32_t tox_address_size(void)
|
|
{
|
|
return TOX_ADDRESS_SIZE;
|
|
}
|
|
uint32_t tox_max_name_length(void)
|
|
{
|
|
return TOX_MAX_NAME_LENGTH;
|
|
}
|
|
uint32_t tox_max_status_message_length(void)
|
|
{
|
|
return TOX_MAX_STATUS_MESSAGE_LENGTH;
|
|
}
|
|
uint32_t tox_max_friend_request_length(void)
|
|
{
|
|
return TOX_MAX_FRIEND_REQUEST_LENGTH;
|
|
}
|
|
uint32_t tox_max_message_length(void)
|
|
{
|
|
return TOX_MAX_MESSAGE_LENGTH;
|
|
}
|
|
uint32_t tox_max_custom_packet_size(void)
|
|
{
|
|
return TOX_MAX_CUSTOM_PACKET_SIZE;
|
|
}
|
|
uint32_t tox_hash_length(void)
|
|
{
|
|
return TOX_HASH_LENGTH;
|
|
}
|
|
uint32_t tox_file_id_length(void)
|
|
{
|
|
return TOX_FILE_ID_LENGTH;
|
|
}
|
|
uint32_t tox_max_filename_length(void)
|
|
{
|
|
return TOX_MAX_FILENAME_LENGTH;
|
|
}
|
|
uint32_t tox_max_hostname_length(void)
|
|
{
|
|
return TOX_MAX_HOSTNAME_LENGTH;
|
|
}
|
|
uint32_t tox_group_max_topic_length(void)
|
|
{
|
|
return TOX_GROUP_MAX_TOPIC_LENGTH;
|
|
}
|
|
uint32_t tox_group_max_part_length(void)
|
|
{
|
|
return TOX_GROUP_MAX_PART_LENGTH;
|
|
}
|
|
uint32_t tox_group_max_message_length(void)
|
|
{
|
|
return TOX_GROUP_MAX_MESSAGE_LENGTH;
|
|
}
|
|
uint32_t tox_group_max_custom_lossy_packet_length(void)
|
|
{
|
|
return TOX_GROUP_MAX_CUSTOM_LOSSY_PACKET_LENGTH;
|
|
}
|
|
uint32_t tox_group_max_custom_lossless_packet_length(void)
|
|
{
|
|
return TOX_GROUP_MAX_CUSTOM_LOSSLESS_PACKET_LENGTH;
|
|
}
|
|
uint32_t tox_group_max_group_name_length(void)
|
|
{
|
|
return TOX_GROUP_MAX_GROUP_NAME_LENGTH;
|
|
}
|
|
uint32_t tox_group_max_password_size(void)
|
|
{
|
|
return TOX_GROUP_MAX_PASSWORD_SIZE;
|
|
}
|
|
uint32_t tox_group_chat_id_size(void)
|
|
{
|
|
return TOX_GROUP_CHAT_ID_SIZE;
|
|
}
|
|
uint32_t tox_group_peer_public_key_size(void)
|
|
{
|
|
return TOX_GROUP_PEER_PUBLIC_KEY_SIZE;
|
|
}
|
|
uint32_t tox_group_peer_ip_string_max_length(void)
|
|
{
|
|
return TOX_GROUP_PEER_IP_STRING_MAX_LENGTH;
|
|
}
|
|
uint32_t tox_dht_node_ip_string_size(void)
|
|
{
|
|
return TOX_DHT_NODE_IP_STRING_SIZE;
|
|
}
|
|
uint32_t tox_dht_node_public_key_size(void)
|
|
{
|
|
return TOX_DHT_NODE_PUBLIC_KEY_SIZE;
|
|
}
|
|
|
|
bool tox_options_get_ipv6_enabled(const Tox_Options *options)
|
|
{
|
|
return options->ipv6_enabled;
|
|
}
|
|
void tox_options_set_ipv6_enabled(Tox_Options *options, bool ipv6_enabled)
|
|
{
|
|
options->ipv6_enabled = ipv6_enabled;
|
|
}
|
|
bool tox_options_get_udp_enabled(const Tox_Options *options)
|
|
{
|
|
return options->udp_enabled;
|
|
}
|
|
void tox_options_set_udp_enabled(Tox_Options *options, bool udp_enabled)
|
|
{
|
|
options->udp_enabled = udp_enabled;
|
|
}
|
|
Tox_Proxy_Type tox_options_get_proxy_type(const Tox_Options *options)
|
|
{
|
|
return options->proxy_type;
|
|
}
|
|
void tox_options_set_proxy_type(Tox_Options *options, Tox_Proxy_Type proxy_type)
|
|
{
|
|
options->proxy_type = proxy_type;
|
|
}
|
|
const char *tox_options_get_proxy_host(const Tox_Options *options)
|
|
{
|
|
return options->proxy_host;
|
|
}
|
|
void tox_options_set_proxy_host(Tox_Options *options, const char *proxy_host)
|
|
{
|
|
options->proxy_host = proxy_host;
|
|
}
|
|
uint16_t tox_options_get_proxy_port(const Tox_Options *options)
|
|
{
|
|
return options->proxy_port;
|
|
}
|
|
void tox_options_set_proxy_port(Tox_Options *options, uint16_t proxy_port)
|
|
{
|
|
options->proxy_port = proxy_port;
|
|
}
|
|
uint16_t tox_options_get_start_port(const Tox_Options *options)
|
|
{
|
|
return options->start_port;
|
|
}
|
|
void tox_options_set_start_port(Tox_Options *options, uint16_t start_port)
|
|
{
|
|
options->start_port = start_port;
|
|
}
|
|
uint16_t tox_options_get_end_port(const Tox_Options *options)
|
|
{
|
|
return options->end_port;
|
|
}
|
|
void tox_options_set_end_port(Tox_Options *options, uint16_t end_port)
|
|
{
|
|
options->end_port = end_port;
|
|
}
|
|
uint16_t tox_options_get_tcp_port(const Tox_Options *options)
|
|
{
|
|
return options->tcp_port;
|
|
}
|
|
void tox_options_set_tcp_port(Tox_Options *options, uint16_t tcp_port)
|
|
{
|
|
options->tcp_port = tcp_port;
|
|
}
|
|
bool tox_options_get_hole_punching_enabled(const Tox_Options *options)
|
|
{
|
|
return options->hole_punching_enabled;
|
|
}
|
|
void tox_options_set_hole_punching_enabled(Tox_Options *options, bool hole_punching_enabled)
|
|
{
|
|
options->hole_punching_enabled = hole_punching_enabled;
|
|
}
|
|
Tox_Savedata_Type tox_options_get_savedata_type(const Tox_Options *options)
|
|
{
|
|
return options->savedata_type;
|
|
}
|
|
void tox_options_set_savedata_type(Tox_Options *options, Tox_Savedata_Type savedata_type)
|
|
{
|
|
options->savedata_type = savedata_type;
|
|
}
|
|
size_t tox_options_get_savedata_length(const Tox_Options *options)
|
|
{
|
|
return options->savedata_length;
|
|
}
|
|
void tox_options_set_savedata_length(Tox_Options *options, size_t savedata_length)
|
|
{
|
|
options->savedata_length = savedata_length;
|
|
}
|
|
tox_log_cb *tox_options_get_log_callback(const Tox_Options *options)
|
|
{
|
|
return options->log_callback;
|
|
}
|
|
void tox_options_set_log_callback(Tox_Options *options, tox_log_cb *log_callback)
|
|
{
|
|
options->log_callback = log_callback;
|
|
}
|
|
void *tox_options_get_log_user_data(const Tox_Options *options)
|
|
{
|
|
return options->log_user_data;
|
|
}
|
|
void tox_options_set_log_user_data(Tox_Options *options, void *log_user_data)
|
|
{
|
|
options->log_user_data = log_user_data;
|
|
}
|
|
bool tox_options_get_local_discovery_enabled(const Tox_Options *options)
|
|
{
|
|
return options->local_discovery_enabled;
|
|
}
|
|
void tox_options_set_local_discovery_enabled(Tox_Options *options, bool local_discovery_enabled)
|
|
{
|
|
options->local_discovery_enabled = local_discovery_enabled;
|
|
}
|
|
bool tox_options_get_dht_announcements_enabled(const Tox_Options *options)
|
|
{
|
|
return options->dht_announcements_enabled;
|
|
}
|
|
void tox_options_set_dht_announcements_enabled(Tox_Options *options, bool dht_announcements_enabled)
|
|
{
|
|
options->dht_announcements_enabled = dht_announcements_enabled;
|
|
}
|
|
bool tox_options_get_experimental_thread_safety(const Tox_Options *options)
|
|
{
|
|
return options->experimental_thread_safety;
|
|
}
|
|
void tox_options_set_experimental_thread_safety(
|
|
Tox_Options *options, bool experimental_thread_safety)
|
|
{
|
|
options->experimental_thread_safety = experimental_thread_safety;
|
|
}
|
|
bool tox_options_get_experimental_groups_persistence(const Tox_Options *options)
|
|
{
|
|
return options->experimental_groups_persistence;
|
|
}
|
|
void tox_options_set_experimental_groups_persistence(
|
|
Tox_Options *options, bool experimental_groups_persistence)
|
|
{
|
|
options->experimental_groups_persistence = experimental_groups_persistence;
|
|
}
|
|
|
|
const uint8_t *tox_options_get_savedata_data(const Tox_Options *options)
|
|
{
|
|
return options->savedata_data;
|
|
}
|
|
|
|
void tox_options_set_savedata_data(Tox_Options *options, const uint8_t *savedata_data, size_t length)
|
|
{
|
|
options->savedata_data = savedata_data;
|
|
options->savedata_length = length;
|
|
}
|
|
|
|
void tox_options_default(Tox_Options *options)
|
|
{
|
|
if (options != nullptr) {
|
|
const Tox_Options default_options = {false};
|
|
*options = default_options;
|
|
tox_options_set_ipv6_enabled(options, true);
|
|
tox_options_set_udp_enabled(options, true);
|
|
tox_options_set_proxy_type(options, TOX_PROXY_TYPE_NONE);
|
|
tox_options_set_hole_punching_enabled(options, true);
|
|
tox_options_set_local_discovery_enabled(options, true);
|
|
tox_options_set_dht_announcements_enabled(options, true);
|
|
tox_options_set_experimental_thread_safety(options, false);
|
|
tox_options_set_experimental_groups_persistence(options, false);
|
|
}
|
|
}
|
|
|
|
Tox_Options *tox_options_new(Tox_Err_Options_New *error)
|
|
{
|
|
Tox_Options *options = (Tox_Options *)calloc(1, sizeof(Tox_Options));
|
|
|
|
if (options != nullptr) {
|
|
tox_options_default(options);
|
|
SET_ERROR_PARAMETER(error, TOX_ERR_OPTIONS_NEW_OK);
|
|
return options;
|
|
}
|
|
|
|
SET_ERROR_PARAMETER(error, TOX_ERR_OPTIONS_NEW_MALLOC);
|
|
return nullptr;
|
|
}
|
|
|
|
void tox_options_free(Tox_Options *options)
|
|
{
|
|
free(options);
|
|
}
|
|
|
|
const char *tox_user_status_to_string(Tox_User_Status value)
|
|
{
|
|
switch (value) {
|
|
case TOX_USER_STATUS_NONE:
|
|
return "TOX_USER_STATUS_NONE";
|
|
|
|
case TOX_USER_STATUS_AWAY:
|
|
return "TOX_USER_STATUS_AWAY";
|
|
|
|
case TOX_USER_STATUS_BUSY:
|
|
return "TOX_USER_STATUS_BUSY";
|
|
}
|
|
|
|
return "<invalid Tox_User_Status>";
|
|
}
|
|
const char *tox_message_type_to_string(Tox_Message_Type value)
|
|
{
|
|
switch (value) {
|
|
case TOX_MESSAGE_TYPE_NORMAL:
|
|
return "TOX_MESSAGE_TYPE_NORMAL";
|
|
|
|
case TOX_MESSAGE_TYPE_ACTION:
|
|
return "TOX_MESSAGE_TYPE_ACTION";
|
|
}
|
|
|
|
return "<invalid Tox_Message_Type>";
|
|
}
|
|
const char *tox_proxy_type_to_string(Tox_Proxy_Type value)
|
|
{
|
|
switch (value) {
|
|
case TOX_PROXY_TYPE_NONE:
|
|
return "TOX_PROXY_TYPE_NONE";
|
|
|
|
case TOX_PROXY_TYPE_HTTP:
|
|
return "TOX_PROXY_TYPE_HTTP";
|
|
|
|
case TOX_PROXY_TYPE_SOCKS5:
|
|
return "TOX_PROXY_TYPE_SOCKS5";
|
|
}
|
|
|
|
return "<invalid Tox_Proxy_Type>";
|
|
}
|
|
const char *tox_savedata_type_to_string(Tox_Savedata_Type value)
|
|
{
|
|
switch (value) {
|
|
case TOX_SAVEDATA_TYPE_NONE:
|
|
return "TOX_SAVEDATA_TYPE_NONE";
|
|
|
|
case TOX_SAVEDATA_TYPE_TOX_SAVE:
|
|
return "TOX_SAVEDATA_TYPE_TOX_SAVE";
|
|
|
|
case TOX_SAVEDATA_TYPE_SECRET_KEY:
|
|
return "TOX_SAVEDATA_TYPE_SECRET_KEY";
|
|
}
|
|
|
|
return "<invalid Tox_Savedata_Type>";
|
|
}
|
|
const char *tox_log_level_to_string(Tox_Log_Level value)
|
|
{
|
|
switch (value) {
|
|
case TOX_LOG_LEVEL_TRACE:
|
|
return "TOX_LOG_LEVEL_TRACE";
|
|
|
|
case TOX_LOG_LEVEL_DEBUG:
|
|
return "TOX_LOG_LEVEL_DEBUG";
|
|
|
|
case TOX_LOG_LEVEL_INFO:
|
|
return "TOX_LOG_LEVEL_INFO";
|
|
|
|
case TOX_LOG_LEVEL_WARNING:
|
|
return "TOX_LOG_LEVEL_WARNING";
|
|
|
|
case TOX_LOG_LEVEL_ERROR:
|
|
return "TOX_LOG_LEVEL_ERROR";
|
|
}
|
|
|
|
return "<invalid Tox_Log_Level>";
|
|
}
|
|
const char *tox_err_options_new_to_string(Tox_Err_Options_New value)
|
|
{
|
|
switch (value) {
|
|
case TOX_ERR_OPTIONS_NEW_OK:
|
|
return "TOX_ERR_OPTIONS_NEW_OK";
|
|
|
|
case TOX_ERR_OPTIONS_NEW_MALLOC:
|
|
return "TOX_ERR_OPTIONS_NEW_MALLOC";
|
|
}
|
|
|
|
return "<invalid Tox_Err_Options_New>";
|
|
}
|
|
const char *tox_err_new_to_string(Tox_Err_New value)
|
|
{
|
|
switch (value) {
|
|
case TOX_ERR_NEW_OK:
|
|
return "TOX_ERR_NEW_OK";
|
|
|
|
case TOX_ERR_NEW_NULL:
|
|
return "TOX_ERR_NEW_NULL";
|
|
|
|
case TOX_ERR_NEW_MALLOC:
|
|
return "TOX_ERR_NEW_MALLOC";
|
|
|
|
case TOX_ERR_NEW_PORT_ALLOC:
|
|
return "TOX_ERR_NEW_PORT_ALLOC";
|
|
|
|
case TOX_ERR_NEW_PROXY_BAD_TYPE:
|
|
return "TOX_ERR_NEW_PROXY_BAD_TYPE";
|
|
|
|
case TOX_ERR_NEW_PROXY_BAD_HOST:
|
|
return "TOX_ERR_NEW_PROXY_BAD_HOST";
|
|
|
|
case TOX_ERR_NEW_PROXY_BAD_PORT:
|
|
return "TOX_ERR_NEW_PROXY_BAD_PORT";
|
|
|
|
case TOX_ERR_NEW_PROXY_NOT_FOUND:
|
|
return "TOX_ERR_NEW_PROXY_NOT_FOUND";
|
|
|
|
case TOX_ERR_NEW_LOAD_ENCRYPTED:
|
|
return "TOX_ERR_NEW_LOAD_ENCRYPTED";
|
|
|
|
case TOX_ERR_NEW_LOAD_BAD_FORMAT:
|
|
return "TOX_ERR_NEW_LOAD_BAD_FORMAT";
|
|
}
|
|
|
|
return "<invalid Tox_Err_New>";
|
|
}
|
|
const char *tox_err_bootstrap_to_string(Tox_Err_Bootstrap value)
|
|
{
|
|
switch (value) {
|
|
case TOX_ERR_BOOTSTRAP_OK:
|
|
return "TOX_ERR_BOOTSTRAP_OK";
|
|
|
|
case TOX_ERR_BOOTSTRAP_NULL:
|
|
return "TOX_ERR_BOOTSTRAP_NULL";
|
|
|
|
case TOX_ERR_BOOTSTRAP_BAD_HOST:
|
|
return "TOX_ERR_BOOTSTRAP_BAD_HOST";
|
|
|
|
case TOX_ERR_BOOTSTRAP_BAD_PORT:
|
|
return "TOX_ERR_BOOTSTRAP_BAD_PORT";
|
|
}
|
|
|
|
return "<invalid Tox_Err_Bootstrap>";
|
|
}
|
|
const char *tox_connection_to_string(Tox_Connection value)
|
|
{
|
|
switch (value) {
|
|
case TOX_CONNECTION_NONE:
|
|
return "TOX_CONNECTION_NONE";
|
|
|
|
case TOX_CONNECTION_TCP:
|
|
return "TOX_CONNECTION_TCP";
|
|
|
|
case TOX_CONNECTION_UDP:
|
|
return "TOX_CONNECTION_UDP";
|
|
}
|
|
|
|
return "<invalid Tox_Connection>";
|
|
}
|
|
const char *tox_err_set_info_to_string(Tox_Err_Set_Info value)
|
|
{
|
|
switch (value) {
|
|
case TOX_ERR_SET_INFO_OK:
|
|
return "TOX_ERR_SET_INFO_OK";
|
|
|
|
case TOX_ERR_SET_INFO_NULL:
|
|
return "TOX_ERR_SET_INFO_NULL";
|
|
|
|
case TOX_ERR_SET_INFO_TOO_LONG:
|
|
return "TOX_ERR_SET_INFO_TOO_LONG";
|
|
}
|
|
|
|
return "<invalid Tox_Err_Set_Info>";
|
|
}
|
|
const char *tox_err_friend_add_to_string(Tox_Err_Friend_Add value)
|
|
{
|
|
switch (value) {
|
|
case TOX_ERR_FRIEND_ADD_OK:
|
|
return "TOX_ERR_FRIEND_ADD_OK";
|
|
|
|
case TOX_ERR_FRIEND_ADD_NULL:
|
|
return "TOX_ERR_FRIEND_ADD_NULL";
|
|
|
|
case TOX_ERR_FRIEND_ADD_TOO_LONG:
|
|
return "TOX_ERR_FRIEND_ADD_TOO_LONG";
|
|
|
|
case TOX_ERR_FRIEND_ADD_NO_MESSAGE:
|
|
return "TOX_ERR_FRIEND_ADD_NO_MESSAGE";
|
|
|
|
case TOX_ERR_FRIEND_ADD_OWN_KEY:
|
|
return "TOX_ERR_FRIEND_ADD_OWN_KEY";
|
|
|
|
case TOX_ERR_FRIEND_ADD_ALREADY_SENT:
|
|
return "TOX_ERR_FRIEND_ADD_ALREADY_SENT";
|
|
|
|
case TOX_ERR_FRIEND_ADD_BAD_CHECKSUM:
|
|
return "TOX_ERR_FRIEND_ADD_BAD_CHECKSUM";
|
|
|
|
case TOX_ERR_FRIEND_ADD_SET_NEW_NOSPAM:
|
|
return "TOX_ERR_FRIEND_ADD_SET_NEW_NOSPAM";
|
|
|
|
case TOX_ERR_FRIEND_ADD_MALLOC:
|
|
return "TOX_ERR_FRIEND_ADD_MALLOC";
|
|
}
|
|
|
|
return "<invalid Tox_Err_Friend_Add>";
|
|
}
|
|
const char *tox_err_friend_delete_to_string(Tox_Err_Friend_Delete value)
|
|
{
|
|
switch (value) {
|
|
case TOX_ERR_FRIEND_DELETE_OK:
|
|
return "TOX_ERR_FRIEND_DELETE_OK";
|
|
|
|
case TOX_ERR_FRIEND_DELETE_FRIEND_NOT_FOUND:
|
|
return "TOX_ERR_FRIEND_DELETE_FRIEND_NOT_FOUND";
|
|
}
|
|
|
|
return "<invalid Tox_Err_Friend_Delete>";
|
|
}
|
|
const char *tox_err_friend_by_public_key_to_string(Tox_Err_Friend_By_Public_Key value)
|
|
{
|
|
switch (value) {
|
|
case TOX_ERR_FRIEND_BY_PUBLIC_KEY_OK:
|
|
return "TOX_ERR_FRIEND_BY_PUBLIC_KEY_OK";
|
|
|
|
case TOX_ERR_FRIEND_BY_PUBLIC_KEY_NULL:
|
|
return "TOX_ERR_FRIEND_BY_PUBLIC_KEY_NULL";
|
|
|
|
case TOX_ERR_FRIEND_BY_PUBLIC_KEY_NOT_FOUND:
|
|
return "TOX_ERR_FRIEND_BY_PUBLIC_KEY_NOT_FOUND";
|
|
}
|
|
|
|
return "<invalid Tox_Err_Friend_By_Public_Key>";
|
|
}
|
|
const char *tox_err_friend_get_public_key_to_string(Tox_Err_Friend_Get_Public_Key value)
|
|
{
|
|
switch (value) {
|
|
case TOX_ERR_FRIEND_GET_PUBLIC_KEY_OK:
|
|
return "TOX_ERR_FRIEND_GET_PUBLIC_KEY_OK";
|
|
|
|
case TOX_ERR_FRIEND_GET_PUBLIC_KEY_FRIEND_NOT_FOUND:
|
|
return "TOX_ERR_FRIEND_GET_PUBLIC_KEY_FRIEND_NOT_FOUND";
|
|
}
|
|
|
|
return "<invalid Tox_Err_Friend_Get_Public_Key>";
|
|
}
|
|
const char *tox_err_friend_get_last_online_to_string(Tox_Err_Friend_Get_Last_Online value)
|
|
{
|
|
switch (value) {
|
|
case TOX_ERR_FRIEND_GET_LAST_ONLINE_OK:
|
|
return "TOX_ERR_FRIEND_GET_LAST_ONLINE_OK";
|
|
|
|
case TOX_ERR_FRIEND_GET_LAST_ONLINE_FRIEND_NOT_FOUND:
|
|
return "TOX_ERR_FRIEND_GET_LAST_ONLINE_FRIEND_NOT_FOUND";
|
|
}
|
|
|
|
return "<invalid Tox_Err_Friend_Get_Last_Online>";
|
|
}
|
|
const char *tox_err_friend_query_to_string(Tox_Err_Friend_Query value)
|
|
{
|
|
switch (value) {
|
|
case TOX_ERR_FRIEND_QUERY_OK:
|
|
return "TOX_ERR_FRIEND_QUERY_OK";
|
|
|
|
case TOX_ERR_FRIEND_QUERY_NULL:
|
|
return "TOX_ERR_FRIEND_QUERY_NULL";
|
|
|
|
case TOX_ERR_FRIEND_QUERY_FRIEND_NOT_FOUND:
|
|
return "TOX_ERR_FRIEND_QUERY_FRIEND_NOT_FOUND";
|
|
}
|
|
|
|
return "<invalid Tox_Err_Friend_Query>";
|
|
}
|
|
const char *tox_err_set_typing_to_string(Tox_Err_Set_Typing value)
|
|
{
|
|
switch (value) {
|
|
case TOX_ERR_SET_TYPING_OK:
|
|
return "TOX_ERR_SET_TYPING_OK";
|
|
|
|
case TOX_ERR_SET_TYPING_FRIEND_NOT_FOUND:
|
|
return "TOX_ERR_SET_TYPING_FRIEND_NOT_FOUND";
|
|
}
|
|
|
|
return "<invalid Tox_Err_Set_Typing>";
|
|
}
|
|
const char *tox_err_friend_send_message_to_string(Tox_Err_Friend_Send_Message value)
|
|
{
|
|
switch (value) {
|
|
case TOX_ERR_FRIEND_SEND_MESSAGE_OK:
|
|
return "TOX_ERR_FRIEND_SEND_MESSAGE_OK";
|
|
|
|
case TOX_ERR_FRIEND_SEND_MESSAGE_NULL:
|
|
return "TOX_ERR_FRIEND_SEND_MESSAGE_NULL";
|
|
|
|
case TOX_ERR_FRIEND_SEND_MESSAGE_FRIEND_NOT_FOUND:
|
|
return "TOX_ERR_FRIEND_SEND_MESSAGE_FRIEND_NOT_FOUND";
|
|
|
|
case TOX_ERR_FRIEND_SEND_MESSAGE_FRIEND_NOT_CONNECTED:
|
|
return "TOX_ERR_FRIEND_SEND_MESSAGE_FRIEND_NOT_CONNECTED";
|
|
|
|
case TOX_ERR_FRIEND_SEND_MESSAGE_SENDQ:
|
|
return "TOX_ERR_FRIEND_SEND_MESSAGE_SENDQ";
|
|
|
|
case TOX_ERR_FRIEND_SEND_MESSAGE_TOO_LONG:
|
|
return "TOX_ERR_FRIEND_SEND_MESSAGE_TOO_LONG";
|
|
|
|
case TOX_ERR_FRIEND_SEND_MESSAGE_EMPTY:
|
|
return "TOX_ERR_FRIEND_SEND_MESSAGE_EMPTY";
|
|
}
|
|
|
|
return "<invalid Tox_Err_Friend_Send_Message>";
|
|
}
|
|
const char *tox_file_control_to_string(Tox_File_Control value)
|
|
{
|
|
switch (value) {
|
|
case TOX_FILE_CONTROL_RESUME:
|
|
return "TOX_FILE_CONTROL_RESUME";
|
|
|
|
case TOX_FILE_CONTROL_PAUSE:
|
|
return "TOX_FILE_CONTROL_PAUSE";
|
|
|
|
case TOX_FILE_CONTROL_CANCEL:
|
|
return "TOX_FILE_CONTROL_CANCEL";
|
|
}
|
|
|
|
return "<invalid Tox_File_Control>";
|
|
}
|
|
const char *tox_err_file_control_to_string(Tox_Err_File_Control value)
|
|
{
|
|
switch (value) {
|
|
case TOX_ERR_FILE_CONTROL_OK:
|
|
return "TOX_ERR_FILE_CONTROL_OK";
|
|
|
|
case TOX_ERR_FILE_CONTROL_FRIEND_NOT_FOUND:
|
|
return "TOX_ERR_FILE_CONTROL_FRIEND_NOT_FOUND";
|
|
|
|
case TOX_ERR_FILE_CONTROL_FRIEND_NOT_CONNECTED:
|
|
return "TOX_ERR_FILE_CONTROL_FRIEND_NOT_CONNECTED";
|
|
|
|
case TOX_ERR_FILE_CONTROL_NOT_FOUND:
|
|
return "TOX_ERR_FILE_CONTROL_NOT_FOUND";
|
|
|
|
case TOX_ERR_FILE_CONTROL_NOT_PAUSED:
|
|
return "TOX_ERR_FILE_CONTROL_NOT_PAUSED";
|
|
|
|
case TOX_ERR_FILE_CONTROL_DENIED:
|
|
return "TOX_ERR_FILE_CONTROL_DENIED";
|
|
|
|
case TOX_ERR_FILE_CONTROL_ALREADY_PAUSED:
|
|
return "TOX_ERR_FILE_CONTROL_ALREADY_PAUSED";
|
|
|
|
case TOX_ERR_FILE_CONTROL_SENDQ:
|
|
return "TOX_ERR_FILE_CONTROL_SENDQ";
|
|
}
|
|
|
|
return "<invalid Tox_Err_File_Control>";
|
|
}
|
|
const char *tox_err_file_seek_to_string(Tox_Err_File_Seek value)
|
|
{
|
|
switch (value) {
|
|
case TOX_ERR_FILE_SEEK_OK:
|
|
return "TOX_ERR_FILE_SEEK_OK";
|
|
|
|
case TOX_ERR_FILE_SEEK_FRIEND_NOT_FOUND:
|
|
return "TOX_ERR_FILE_SEEK_FRIEND_NOT_FOUND";
|
|
|
|
case TOX_ERR_FILE_SEEK_FRIEND_NOT_CONNECTED:
|
|
return "TOX_ERR_FILE_SEEK_FRIEND_NOT_CONNECTED";
|
|
|
|
case TOX_ERR_FILE_SEEK_NOT_FOUND:
|
|
return "TOX_ERR_FILE_SEEK_NOT_FOUND";
|
|
|
|
case TOX_ERR_FILE_SEEK_DENIED:
|
|
return "TOX_ERR_FILE_SEEK_DENIED";
|
|
|
|
case TOX_ERR_FILE_SEEK_INVALID_POSITION:
|
|
return "TOX_ERR_FILE_SEEK_INVALID_POSITION";
|
|
|
|
case TOX_ERR_FILE_SEEK_SENDQ:
|
|
return "TOX_ERR_FILE_SEEK_SENDQ";
|
|
}
|
|
|
|
return "<invalid Tox_Err_File_Seek>";
|
|
}
|
|
const char *tox_err_file_get_to_string(Tox_Err_File_Get value)
|
|
{
|
|
switch (value) {
|
|
case TOX_ERR_FILE_GET_OK:
|
|
return "TOX_ERR_FILE_GET_OK";
|
|
|
|
case TOX_ERR_FILE_GET_NULL:
|
|
return "TOX_ERR_FILE_GET_NULL";
|
|
|
|
case TOX_ERR_FILE_GET_FRIEND_NOT_FOUND:
|
|
return "TOX_ERR_FILE_GET_FRIEND_NOT_FOUND";
|
|
|
|
case TOX_ERR_FILE_GET_NOT_FOUND:
|
|
return "TOX_ERR_FILE_GET_NOT_FOUND";
|
|
}
|
|
|
|
return "<invalid Tox_Err_File_Get>";
|
|
}
|
|
const char *tox_err_file_send_to_string(Tox_Err_File_Send value)
|
|
{
|
|
switch (value) {
|
|
case TOX_ERR_FILE_SEND_OK:
|
|
return "TOX_ERR_FILE_SEND_OK";
|
|
|
|
case TOX_ERR_FILE_SEND_NULL:
|
|
return "TOX_ERR_FILE_SEND_NULL";
|
|
|
|
case TOX_ERR_FILE_SEND_FRIEND_NOT_FOUND:
|
|
return "TOX_ERR_FILE_SEND_FRIEND_NOT_FOUND";
|
|
|
|
case TOX_ERR_FILE_SEND_FRIEND_NOT_CONNECTED:
|
|
return "TOX_ERR_FILE_SEND_FRIEND_NOT_CONNECTED";
|
|
|
|
case TOX_ERR_FILE_SEND_NAME_TOO_LONG:
|
|
return "TOX_ERR_FILE_SEND_NAME_TOO_LONG";
|
|
|
|
case TOX_ERR_FILE_SEND_TOO_MANY:
|
|
return "TOX_ERR_FILE_SEND_TOO_MANY";
|
|
}
|
|
|
|
return "<invalid Tox_Err_File_Send>";
|
|
}
|
|
const char *tox_err_file_send_chunk_to_string(Tox_Err_File_Send_Chunk value)
|
|
{
|
|
switch (value) {
|
|
case TOX_ERR_FILE_SEND_CHUNK_OK:
|
|
return "TOX_ERR_FILE_SEND_CHUNK_OK";
|
|
|
|
case TOX_ERR_FILE_SEND_CHUNK_NULL:
|
|
return "TOX_ERR_FILE_SEND_CHUNK_NULL";
|
|
|
|
case TOX_ERR_FILE_SEND_CHUNK_FRIEND_NOT_FOUND:
|
|
return "TOX_ERR_FILE_SEND_CHUNK_FRIEND_NOT_FOUND";
|
|
|
|
case TOX_ERR_FILE_SEND_CHUNK_FRIEND_NOT_CONNECTED:
|
|
return "TOX_ERR_FILE_SEND_CHUNK_FRIEND_NOT_CONNECTED";
|
|
|
|
case TOX_ERR_FILE_SEND_CHUNK_NOT_FOUND:
|
|
return "TOX_ERR_FILE_SEND_CHUNK_NOT_FOUND";
|
|
|
|
case TOX_ERR_FILE_SEND_CHUNK_NOT_TRANSFERRING:
|
|
return "TOX_ERR_FILE_SEND_CHUNK_NOT_TRANSFERRING";
|
|
|
|
case TOX_ERR_FILE_SEND_CHUNK_INVALID_LENGTH:
|
|
return "TOX_ERR_FILE_SEND_CHUNK_INVALID_LENGTH";
|
|
|
|
case TOX_ERR_FILE_SEND_CHUNK_SENDQ:
|
|
return "TOX_ERR_FILE_SEND_CHUNK_SENDQ";
|
|
|
|
case TOX_ERR_FILE_SEND_CHUNK_WRONG_POSITION:
|
|
return "TOX_ERR_FILE_SEND_CHUNK_WRONG_POSITION";
|
|
}
|
|
|
|
return "<invalid Tox_Err_File_Send_Chunk>";
|
|
}
|
|
const char *tox_conference_type_to_string(Tox_Conference_Type value)
|
|
{
|
|
switch (value) {
|
|
case TOX_CONFERENCE_TYPE_TEXT:
|
|
return "TOX_CONFERENCE_TYPE_TEXT";
|
|
|
|
case TOX_CONFERENCE_TYPE_AV:
|
|
return "TOX_CONFERENCE_TYPE_AV";
|
|
}
|
|
|
|
return "<invalid Tox_Conference_Type>";
|
|
}
|
|
const char *tox_err_conference_new_to_string(Tox_Err_Conference_New value)
|
|
{
|
|
switch (value) {
|
|
case TOX_ERR_CONFERENCE_NEW_OK:
|
|
return "TOX_ERR_CONFERENCE_NEW_OK";
|
|
|
|
case TOX_ERR_CONFERENCE_NEW_INIT:
|
|
return "TOX_ERR_CONFERENCE_NEW_INIT";
|
|
}
|
|
|
|
return "<invalid Tox_Err_Conference_New>";
|
|
}
|
|
const char *tox_err_conference_delete_to_string(Tox_Err_Conference_Delete value)
|
|
{
|
|
switch (value) {
|
|
case TOX_ERR_CONFERENCE_DELETE_OK:
|
|
return "TOX_ERR_CONFERENCE_DELETE_OK";
|
|
|
|
case TOX_ERR_CONFERENCE_DELETE_CONFERENCE_NOT_FOUND:
|
|
return "TOX_ERR_CONFERENCE_DELETE_CONFERENCE_NOT_FOUND";
|
|
}
|
|
|
|
return "<invalid Tox_Err_Conference_Delete>";
|
|
}
|
|
const char *tox_err_conference_peer_query_to_string(Tox_Err_Conference_Peer_Query value)
|
|
{
|
|
switch (value) {
|
|
case TOX_ERR_CONFERENCE_PEER_QUERY_OK:
|
|
return "TOX_ERR_CONFERENCE_PEER_QUERY_OK";
|
|
|
|
case TOX_ERR_CONFERENCE_PEER_QUERY_CONFERENCE_NOT_FOUND:
|
|
return "TOX_ERR_CONFERENCE_PEER_QUERY_CONFERENCE_NOT_FOUND";
|
|
|
|
case TOX_ERR_CONFERENCE_PEER_QUERY_PEER_NOT_FOUND:
|
|
return "TOX_ERR_CONFERENCE_PEER_QUERY_PEER_NOT_FOUND";
|
|
|
|
case TOX_ERR_CONFERENCE_PEER_QUERY_NO_CONNECTION:
|
|
return "TOX_ERR_CONFERENCE_PEER_QUERY_NO_CONNECTION";
|
|
}
|
|
|
|
return "<invalid Tox_Err_Conference_Peer_Query>";
|
|
}
|
|
const char *tox_err_conference_set_max_offline_to_string(Tox_Err_Conference_Set_Max_Offline value)
|
|
{
|
|
switch (value) {
|
|
case TOX_ERR_CONFERENCE_SET_MAX_OFFLINE_OK:
|
|
return "TOX_ERR_CONFERENCE_SET_MAX_OFFLINE_OK";
|
|
|
|
case TOX_ERR_CONFERENCE_SET_MAX_OFFLINE_CONFERENCE_NOT_FOUND:
|
|
return "TOX_ERR_CONFERENCE_SET_MAX_OFFLINE_CONFERENCE_NOT_FOUND";
|
|
}
|
|
|
|
return "<invalid Tox_Err_Conference_Set_Max_Offline>";
|
|
}
|
|
const char *tox_err_conference_invite_to_string(Tox_Err_Conference_Invite value)
|
|
{
|
|
switch (value) {
|
|
case TOX_ERR_CONFERENCE_INVITE_OK:
|
|
return "TOX_ERR_CONFERENCE_INVITE_OK";
|
|
|
|
case TOX_ERR_CONFERENCE_INVITE_CONFERENCE_NOT_FOUND:
|
|
return "TOX_ERR_CONFERENCE_INVITE_CONFERENCE_NOT_FOUND";
|
|
|
|
case TOX_ERR_CONFERENCE_INVITE_FAIL_SEND:
|
|
return "TOX_ERR_CONFERENCE_INVITE_FAIL_SEND";
|
|
|
|
case TOX_ERR_CONFERENCE_INVITE_NO_CONNECTION:
|
|
return "TOX_ERR_CONFERENCE_INVITE_NO_CONNECTION";
|
|
}
|
|
|
|
return "<invalid Tox_Err_Conference_Invite>";
|
|
}
|
|
const char *tox_err_conference_join_to_string(Tox_Err_Conference_Join value)
|
|
{
|
|
switch (value) {
|
|
case TOX_ERR_CONFERENCE_JOIN_OK:
|
|
return "TOX_ERR_CONFERENCE_JOIN_OK";
|
|
|
|
case TOX_ERR_CONFERENCE_JOIN_INVALID_LENGTH:
|
|
return "TOX_ERR_CONFERENCE_JOIN_INVALID_LENGTH";
|
|
|
|
case TOX_ERR_CONFERENCE_JOIN_WRONG_TYPE:
|
|
return "TOX_ERR_CONFERENCE_JOIN_WRONG_TYPE";
|
|
|
|
case TOX_ERR_CONFERENCE_JOIN_FRIEND_NOT_FOUND:
|
|
return "TOX_ERR_CONFERENCE_JOIN_FRIEND_NOT_FOUND";
|
|
|
|
case TOX_ERR_CONFERENCE_JOIN_DUPLICATE:
|
|
return "TOX_ERR_CONFERENCE_JOIN_DUPLICATE";
|
|
|
|
case TOX_ERR_CONFERENCE_JOIN_INIT_FAIL:
|
|
return "TOX_ERR_CONFERENCE_JOIN_INIT_FAIL";
|
|
|
|
case TOX_ERR_CONFERENCE_JOIN_FAIL_SEND:
|
|
return "TOX_ERR_CONFERENCE_JOIN_FAIL_SEND";
|
|
}
|
|
|
|
return "<invalid Tox_Err_Conference_Join>";
|
|
}
|
|
const char *tox_err_conference_send_message_to_string(Tox_Err_Conference_Send_Message value)
|
|
{
|
|
switch (value) {
|
|
case TOX_ERR_CONFERENCE_SEND_MESSAGE_OK:
|
|
return "TOX_ERR_CONFERENCE_SEND_MESSAGE_OK";
|
|
|
|
case TOX_ERR_CONFERENCE_SEND_MESSAGE_CONFERENCE_NOT_FOUND:
|
|
return "TOX_ERR_CONFERENCE_SEND_MESSAGE_CONFERENCE_NOT_FOUND";
|
|
|
|
case TOX_ERR_CONFERENCE_SEND_MESSAGE_TOO_LONG:
|
|
return "TOX_ERR_CONFERENCE_SEND_MESSAGE_TOO_LONG";
|
|
|
|
case TOX_ERR_CONFERENCE_SEND_MESSAGE_NO_CONNECTION:
|
|
return "TOX_ERR_CONFERENCE_SEND_MESSAGE_NO_CONNECTION";
|
|
|
|
case TOX_ERR_CONFERENCE_SEND_MESSAGE_FAIL_SEND:
|
|
return "TOX_ERR_CONFERENCE_SEND_MESSAGE_FAIL_SEND";
|
|
}
|
|
|
|
return "<invalid Tox_Err_Conference_Send_Message>";
|
|
}
|
|
const char *tox_err_conference_title_to_string(Tox_Err_Conference_Title value)
|
|
{
|
|
switch (value) {
|
|
case TOX_ERR_CONFERENCE_TITLE_OK:
|
|
return "TOX_ERR_CONFERENCE_TITLE_OK";
|
|
|
|
case TOX_ERR_CONFERENCE_TITLE_CONFERENCE_NOT_FOUND:
|
|
return "TOX_ERR_CONFERENCE_TITLE_CONFERENCE_NOT_FOUND";
|
|
|
|
case TOX_ERR_CONFERENCE_TITLE_INVALID_LENGTH:
|
|
return "TOX_ERR_CONFERENCE_TITLE_INVALID_LENGTH";
|
|
|
|
case TOX_ERR_CONFERENCE_TITLE_FAIL_SEND:
|
|
return "TOX_ERR_CONFERENCE_TITLE_FAIL_SEND";
|
|
}
|
|
|
|
return "<invalid Tox_Err_Conference_Title>";
|
|
}
|
|
const char *tox_err_conference_get_type_to_string(Tox_Err_Conference_Get_Type value)
|
|
{
|
|
switch (value) {
|
|
case TOX_ERR_CONFERENCE_GET_TYPE_OK:
|
|
return "TOX_ERR_CONFERENCE_GET_TYPE_OK";
|
|
|
|
case TOX_ERR_CONFERENCE_GET_TYPE_CONFERENCE_NOT_FOUND:
|
|
return "TOX_ERR_CONFERENCE_GET_TYPE_CONFERENCE_NOT_FOUND";
|
|
}
|
|
|
|
return "<invalid Tox_Err_Conference_Get_Type>";
|
|
}
|
|
const char *tox_err_conference_by_id_to_string(Tox_Err_Conference_By_Id value)
|
|
{
|
|
switch (value) {
|
|
case TOX_ERR_CONFERENCE_BY_ID_OK:
|
|
return "TOX_ERR_CONFERENCE_BY_ID_OK";
|
|
|
|
case TOX_ERR_CONFERENCE_BY_ID_NULL:
|
|
return "TOX_ERR_CONFERENCE_BY_ID_NULL";
|
|
|
|
case TOX_ERR_CONFERENCE_BY_ID_NOT_FOUND:
|
|
return "TOX_ERR_CONFERENCE_BY_ID_NOT_FOUND";
|
|
}
|
|
|
|
return "<invalid Tox_Err_Conference_By_Id>";
|
|
}
|
|
const char *tox_err_conference_by_uid_to_string(Tox_Err_Conference_By_Uid value)
|
|
{
|
|
switch (value) {
|
|
case TOX_ERR_CONFERENCE_BY_UID_OK:
|
|
return "TOX_ERR_CONFERENCE_BY_UID_OK";
|
|
|
|
case TOX_ERR_CONFERENCE_BY_UID_NULL:
|
|
return "TOX_ERR_CONFERENCE_BY_UID_NULL";
|
|
|
|
case TOX_ERR_CONFERENCE_BY_UID_NOT_FOUND:
|
|
return "TOX_ERR_CONFERENCE_BY_UID_NOT_FOUND";
|
|
}
|
|
|
|
return "<invalid Tox_Err_Conference_By_Uid>";
|
|
}
|
|
const char *tox_err_friend_custom_packet_to_string(Tox_Err_Friend_Custom_Packet value)
|
|
{
|
|
switch (value) {
|
|
case TOX_ERR_FRIEND_CUSTOM_PACKET_OK:
|
|
return "TOX_ERR_FRIEND_CUSTOM_PACKET_OK";
|
|
|
|
case TOX_ERR_FRIEND_CUSTOM_PACKET_NULL:
|
|
return "TOX_ERR_FRIEND_CUSTOM_PACKET_NULL";
|
|
|
|
case TOX_ERR_FRIEND_CUSTOM_PACKET_FRIEND_NOT_FOUND:
|
|
return "TOX_ERR_FRIEND_CUSTOM_PACKET_FRIEND_NOT_FOUND";
|
|
|
|
case TOX_ERR_FRIEND_CUSTOM_PACKET_FRIEND_NOT_CONNECTED:
|
|
return "TOX_ERR_FRIEND_CUSTOM_PACKET_FRIEND_NOT_CONNECTED";
|
|
|
|
case TOX_ERR_FRIEND_CUSTOM_PACKET_INVALID:
|
|
return "TOX_ERR_FRIEND_CUSTOM_PACKET_INVALID";
|
|
|
|
case TOX_ERR_FRIEND_CUSTOM_PACKET_EMPTY:
|
|
return "TOX_ERR_FRIEND_CUSTOM_PACKET_EMPTY";
|
|
|
|
case TOX_ERR_FRIEND_CUSTOM_PACKET_TOO_LONG:
|
|
return "TOX_ERR_FRIEND_CUSTOM_PACKET_TOO_LONG";
|
|
|
|
case TOX_ERR_FRIEND_CUSTOM_PACKET_SENDQ:
|
|
return "TOX_ERR_FRIEND_CUSTOM_PACKET_SENDQ";
|
|
}
|
|
|
|
return "<invalid Tox_Err_Friend_Custom_Packet>";
|
|
}
|
|
const char *tox_err_get_port_to_string(Tox_Err_Get_Port value)
|
|
{
|
|
switch (value) {
|
|
case TOX_ERR_GET_PORT_OK:
|
|
return "TOX_ERR_GET_PORT_OK";
|
|
|
|
case TOX_ERR_GET_PORT_NOT_BOUND:
|
|
return "TOX_ERR_GET_PORT_NOT_BOUND";
|
|
}
|
|
|
|
return "<invalid Tox_Err_Get_Port>";
|
|
}
|
|
const char *tox_group_privacy_state_to_string(Tox_Group_Privacy_State value)
|
|
{
|
|
switch (value) {
|
|
case TOX_GROUP_PRIVACY_STATE_PUBLIC:
|
|
return "TOX_GROUP_PRIVACY_STATE_PUBLIC";
|
|
|
|
case TOX_GROUP_PRIVACY_STATE_PRIVATE:
|
|
return "TOX_GROUP_PRIVACY_STATE_PRIVATE";
|
|
}
|
|
|
|
return "<invalid Tox_Group_Privacy_State>";
|
|
}
|
|
const char *tox_group_topic_lock_to_string(Tox_Group_Topic_Lock value)
|
|
{
|
|
switch (value) {
|
|
case TOX_GROUP_TOPIC_LOCK_ENABLED:
|
|
return "TOX_GROUP_TOPIC_LOCK_ENABLED";
|
|
|
|
case TOX_GROUP_TOPIC_LOCK_DISABLED:
|
|
return "TOX_GROUP_TOPIC_LOCK_DISABLED";
|
|
}
|
|
|
|
return "<invalid Tox_Group_Topic_Lock>";
|
|
}
|
|
const char *tox_group_voice_state_to_string(Tox_Group_Voice_State value)
|
|
{
|
|
switch (value) {
|
|
case TOX_GROUP_VOICE_STATE_ALL:
|
|
return "TOX_GROUP_VOICE_STATE_ALL";
|
|
|
|
case TOX_GROUP_VOICE_STATE_MODERATOR:
|
|
return "TOX_GROUP_VOICE_STATE_MODERATOR";
|
|
|
|
case TOX_GROUP_VOICE_STATE_FOUNDER:
|
|
return "TOX_GROUP_VOICE_STATE_FOUNDER";
|
|
}
|
|
|
|
return "<invalid Tox_Group_Voice_State>";
|
|
}
|
|
const char *tox_group_role_to_string(Tox_Group_Role value)
|
|
{
|
|
switch (value) {
|
|
case TOX_GROUP_ROLE_FOUNDER:
|
|
return "TOX_GROUP_ROLE_FOUNDER";
|
|
|
|
case TOX_GROUP_ROLE_MODERATOR:
|
|
return "TOX_GROUP_ROLE_MODERATOR";
|
|
|
|
case TOX_GROUP_ROLE_USER:
|
|
return "TOX_GROUP_ROLE_USER";
|
|
|
|
case TOX_GROUP_ROLE_OBSERVER:
|
|
return "TOX_GROUP_ROLE_OBSERVER";
|
|
}
|
|
|
|
return "<invalid Tox_Group_Role>";
|
|
}
|
|
const char *tox_err_group_new_to_string(Tox_Err_Group_New value)
|
|
{
|
|
switch (value) {
|
|
case TOX_ERR_GROUP_NEW_OK:
|
|
return "TOX_ERR_GROUP_NEW_OK";
|
|
|
|
case TOX_ERR_GROUP_NEW_TOO_LONG:
|
|
return "TOX_ERR_GROUP_NEW_TOO_LONG";
|
|
|
|
case TOX_ERR_GROUP_NEW_EMPTY:
|
|
return "TOX_ERR_GROUP_NEW_EMPTY";
|
|
|
|
case TOX_ERR_GROUP_NEW_INIT:
|
|
return "TOX_ERR_GROUP_NEW_INIT";
|
|
|
|
case TOX_ERR_GROUP_NEW_STATE:
|
|
return "TOX_ERR_GROUP_NEW_STATE";
|
|
|
|
case TOX_ERR_GROUP_NEW_ANNOUNCE:
|
|
return "TOX_ERR_GROUP_NEW_ANNOUNCE";
|
|
}
|
|
|
|
return "<invalid Tox_Err_Group_New>";
|
|
}
|
|
const char *tox_err_group_join_to_string(Tox_Err_Group_Join value)
|
|
{
|
|
switch (value) {
|
|
case TOX_ERR_GROUP_JOIN_OK:
|
|
return "TOX_ERR_GROUP_JOIN_OK";
|
|
|
|
case TOX_ERR_GROUP_JOIN_INIT:
|
|
return "TOX_ERR_GROUP_JOIN_INIT";
|
|
|
|
case TOX_ERR_GROUP_JOIN_BAD_CHAT_ID:
|
|
return "TOX_ERR_GROUP_JOIN_BAD_CHAT_ID";
|
|
|
|
case TOX_ERR_GROUP_JOIN_EMPTY:
|
|
return "TOX_ERR_GROUP_JOIN_EMPTY";
|
|
|
|
case TOX_ERR_GROUP_JOIN_TOO_LONG:
|
|
return "TOX_ERR_GROUP_JOIN_TOO_LONG";
|
|
|
|
case TOX_ERR_GROUP_JOIN_PASSWORD:
|
|
return "TOX_ERR_GROUP_JOIN_PASSWORD";
|
|
|
|
case TOX_ERR_GROUP_JOIN_CORE:
|
|
return "TOX_ERR_GROUP_JOIN_CORE";
|
|
}
|
|
|
|
return "<invalid Tox_Err_Group_Join>";
|
|
}
|
|
const char *tox_err_group_is_connected_to_string(Tox_Err_Group_Is_Connected value)
|
|
{
|
|
switch (value) {
|
|
case TOX_ERR_GROUP_IS_CONNECTED_OK:
|
|
return "TOX_ERR_GROUP_IS_CONNECTED_OK";
|
|
|
|
case TOX_ERR_GROUP_IS_CONNECTED_GROUP_NOT_FOUND:
|
|
return "TOX_ERR_GROUP_IS_CONNECTED_GROUP_NOT_FOUND";
|
|
}
|
|
|
|
return "<invalid Tox_Err_Group_Is_Connected>";
|
|
}
|
|
const char *tox_err_group_disconnect_to_string(Tox_Err_Group_Disconnect value)
|
|
{
|
|
switch (value) {
|
|
case TOX_ERR_GROUP_DISCONNECT_OK:
|
|
return "TOX_ERR_GROUP_DISCONNECT_OK";
|
|
|
|
case TOX_ERR_GROUP_DISCONNECT_GROUP_NOT_FOUND:
|
|
return "TOX_ERR_GROUP_DISCONNECT_GROUP_NOT_FOUND";
|
|
|
|
case TOX_ERR_GROUP_DISCONNECT_ALREADY_DISCONNECTED:
|
|
return "TOX_ERR_GROUP_DISCONNECT_ALREADY_DISCONNECTED";
|
|
}
|
|
|
|
return "<invalid Tox_Err_Group_Disconnect>";
|
|
}
|
|
const char *tox_err_group_reconnect_to_string(Tox_Err_Group_Reconnect value)
|
|
{
|
|
switch (value) {
|
|
case TOX_ERR_GROUP_RECONNECT_OK:
|
|
return "TOX_ERR_GROUP_RECONNECT_OK";
|
|
|
|
case TOX_ERR_GROUP_RECONNECT_GROUP_NOT_FOUND:
|
|
return "TOX_ERR_GROUP_RECONNECT_GROUP_NOT_FOUND";
|
|
|
|
case TOX_ERR_GROUP_RECONNECT_CORE:
|
|
return "TOX_ERR_GROUP_RECONNECT_CORE";
|
|
}
|
|
|
|
return "<invalid Tox_Err_Group_Reconnect>";
|
|
}
|
|
const char *tox_err_group_leave_to_string(Tox_Err_Group_Leave value)
|
|
{
|
|
switch (value) {
|
|
case TOX_ERR_GROUP_LEAVE_OK:
|
|
return "TOX_ERR_GROUP_LEAVE_OK";
|
|
|
|
case TOX_ERR_GROUP_LEAVE_GROUP_NOT_FOUND:
|
|
return "TOX_ERR_GROUP_LEAVE_GROUP_NOT_FOUND";
|
|
|
|
case TOX_ERR_GROUP_LEAVE_TOO_LONG:
|
|
return "TOX_ERR_GROUP_LEAVE_TOO_LONG";
|
|
|
|
case TOX_ERR_GROUP_LEAVE_FAIL_SEND:
|
|
return "TOX_ERR_GROUP_LEAVE_FAIL_SEND";
|
|
}
|
|
|
|
return "<invalid Tox_Err_Group_Leave>";
|
|
}
|
|
const char *tox_err_group_self_query_to_string(Tox_Err_Group_Self_Query value)
|
|
{
|
|
switch (value) {
|
|
case TOX_ERR_GROUP_SELF_QUERY_OK:
|
|
return "TOX_ERR_GROUP_SELF_QUERY_OK";
|
|
|
|
case TOX_ERR_GROUP_SELF_QUERY_GROUP_NOT_FOUND:
|
|
return "TOX_ERR_GROUP_SELF_QUERY_GROUP_NOT_FOUND";
|
|
}
|
|
|
|
return "<invalid Tox_Err_Group_Self_Query>";
|
|
}
|
|
const char *tox_err_group_self_name_set_to_string(Tox_Err_Group_Self_Name_Set value)
|
|
{
|
|
switch (value) {
|
|
case TOX_ERR_GROUP_SELF_NAME_SET_OK:
|
|
return "TOX_ERR_GROUP_SELF_NAME_SET_OK";
|
|
|
|
case TOX_ERR_GROUP_SELF_NAME_SET_GROUP_NOT_FOUND:
|
|
return "TOX_ERR_GROUP_SELF_NAME_SET_GROUP_NOT_FOUND";
|
|
|
|
case TOX_ERR_GROUP_SELF_NAME_SET_TOO_LONG:
|
|
return "TOX_ERR_GROUP_SELF_NAME_SET_TOO_LONG";
|
|
|
|
case TOX_ERR_GROUP_SELF_NAME_SET_INVALID:
|
|
return "TOX_ERR_GROUP_SELF_NAME_SET_INVALID";
|
|
|
|
case TOX_ERR_GROUP_SELF_NAME_SET_FAIL_SEND:
|
|
return "TOX_ERR_GROUP_SELF_NAME_SET_FAIL_SEND";
|
|
}
|
|
|
|
return "<invalid Tox_Err_Group_Self_Name_Set>";
|
|
}
|
|
const char *tox_err_group_self_status_set_to_string(Tox_Err_Group_Self_Status_Set value)
|
|
{
|
|
switch (value) {
|
|
case TOX_ERR_GROUP_SELF_STATUS_SET_OK:
|
|
return "TOX_ERR_GROUP_SELF_STATUS_SET_OK";
|
|
|
|
case TOX_ERR_GROUP_SELF_STATUS_SET_GROUP_NOT_FOUND:
|
|
return "TOX_ERR_GROUP_SELF_STATUS_SET_GROUP_NOT_FOUND";
|
|
|
|
case TOX_ERR_GROUP_SELF_STATUS_SET_FAIL_SEND:
|
|
return "TOX_ERR_GROUP_SELF_STATUS_SET_FAIL_SEND";
|
|
}
|
|
|
|
return "<invalid Tox_Err_Group_Self_Status_Set>";
|
|
}
|
|
const char *tox_err_group_peer_query_to_string(Tox_Err_Group_Peer_Query value)
|
|
{
|
|
switch (value) {
|
|
case TOX_ERR_GROUP_PEER_QUERY_OK:
|
|
return "TOX_ERR_GROUP_PEER_QUERY_OK";
|
|
|
|
case TOX_ERR_GROUP_PEER_QUERY_GROUP_NOT_FOUND:
|
|
return "TOX_ERR_GROUP_PEER_QUERY_GROUP_NOT_FOUND";
|
|
|
|
case TOX_ERR_GROUP_PEER_QUERY_PEER_NOT_FOUND:
|
|
return "TOX_ERR_GROUP_PEER_QUERY_PEER_NOT_FOUND";
|
|
}
|
|
|
|
return "<invalid Tox_Err_Group_Peer_Query>";
|
|
}
|
|
const char *tox_err_group_state_query_to_string(Tox_Err_Group_State_Query value)
|
|
{
|
|
switch (value) {
|
|
case TOX_ERR_GROUP_STATE_QUERY_OK:
|
|
return "TOX_ERR_GROUP_STATE_QUERY_OK";
|
|
|
|
case TOX_ERR_GROUP_STATE_QUERY_GROUP_NOT_FOUND:
|
|
return "TOX_ERR_GROUP_STATE_QUERY_GROUP_NOT_FOUND";
|
|
}
|
|
|
|
return "<invalid Tox_Err_Group_State_Query>";
|
|
}
|
|
const char *tox_err_group_topic_set_to_string(Tox_Err_Group_Topic_Set value)
|
|
{
|
|
switch (value) {
|
|
case TOX_ERR_GROUP_TOPIC_SET_OK:
|
|
return "TOX_ERR_GROUP_TOPIC_SET_OK";
|
|
|
|
case TOX_ERR_GROUP_TOPIC_SET_GROUP_NOT_FOUND:
|
|
return "TOX_ERR_GROUP_TOPIC_SET_GROUP_NOT_FOUND";
|
|
|
|
case TOX_ERR_GROUP_TOPIC_SET_TOO_LONG:
|
|
return "TOX_ERR_GROUP_TOPIC_SET_TOO_LONG";
|
|
|
|
case TOX_ERR_GROUP_TOPIC_SET_PERMISSIONS:
|
|
return "TOX_ERR_GROUP_TOPIC_SET_PERMISSIONS";
|
|
|
|
case TOX_ERR_GROUP_TOPIC_SET_FAIL_CREATE:
|
|
return "TOX_ERR_GROUP_TOPIC_SET_FAIL_CREATE";
|
|
|
|
case TOX_ERR_GROUP_TOPIC_SET_FAIL_SEND:
|
|
return "TOX_ERR_GROUP_TOPIC_SET_FAIL_SEND";
|
|
|
|
case TOX_ERR_GROUP_TOPIC_SET_DISCONNECTED:
|
|
return "TOX_ERR_GROUP_TOPIC_SET_DISCONNECTED";
|
|
}
|
|
|
|
return "<invalid Tox_Err_Group_Topic_Set>";
|
|
}
|
|
const char *tox_err_group_send_message_to_string(Tox_Err_Group_Send_Message value)
|
|
{
|
|
switch (value) {
|
|
case TOX_ERR_GROUP_SEND_MESSAGE_OK:
|
|
return "TOX_ERR_GROUP_SEND_MESSAGE_OK";
|
|
|
|
case TOX_ERR_GROUP_SEND_MESSAGE_GROUP_NOT_FOUND:
|
|
return "TOX_ERR_GROUP_SEND_MESSAGE_GROUP_NOT_FOUND";
|
|
|
|
case TOX_ERR_GROUP_SEND_MESSAGE_TOO_LONG:
|
|
return "TOX_ERR_GROUP_SEND_MESSAGE_TOO_LONG";
|
|
|
|
case TOX_ERR_GROUP_SEND_MESSAGE_EMPTY:
|
|
return "TOX_ERR_GROUP_SEND_MESSAGE_EMPTY";
|
|
|
|
case TOX_ERR_GROUP_SEND_MESSAGE_BAD_TYPE:
|
|
return "TOX_ERR_GROUP_SEND_MESSAGE_BAD_TYPE";
|
|
|
|
case TOX_ERR_GROUP_SEND_MESSAGE_PERMISSIONS:
|
|
return "TOX_ERR_GROUP_SEND_MESSAGE_PERMISSIONS";
|
|
|
|
case TOX_ERR_GROUP_SEND_MESSAGE_FAIL_SEND:
|
|
return "TOX_ERR_GROUP_SEND_MESSAGE_FAIL_SEND";
|
|
|
|
case TOX_ERR_GROUP_SEND_MESSAGE_DISCONNECTED:
|
|
return "TOX_ERR_GROUP_SEND_MESSAGE_DISCONNECTED";
|
|
}
|
|
|
|
return "<invalid Tox_Err_Group_Send_Message>";
|
|
}
|
|
const char *tox_err_group_send_private_message_to_string(Tox_Err_Group_Send_Private_Message value)
|
|
{
|
|
switch (value) {
|
|
case TOX_ERR_GROUP_SEND_PRIVATE_MESSAGE_OK:
|
|
return "TOX_ERR_GROUP_SEND_PRIVATE_MESSAGE_OK";
|
|
|
|
case TOX_ERR_GROUP_SEND_PRIVATE_MESSAGE_GROUP_NOT_FOUND:
|
|
return "TOX_ERR_GROUP_SEND_PRIVATE_MESSAGE_GROUP_NOT_FOUND";
|
|
|
|
case TOX_ERR_GROUP_SEND_PRIVATE_MESSAGE_PEER_NOT_FOUND:
|
|
return "TOX_ERR_GROUP_SEND_PRIVATE_MESSAGE_PEER_NOT_FOUND";
|
|
|
|
case TOX_ERR_GROUP_SEND_PRIVATE_MESSAGE_TOO_LONG:
|
|
return "TOX_ERR_GROUP_SEND_PRIVATE_MESSAGE_TOO_LONG";
|
|
|
|
case TOX_ERR_GROUP_SEND_PRIVATE_MESSAGE_EMPTY:
|
|
return "TOX_ERR_GROUP_SEND_PRIVATE_MESSAGE_EMPTY";
|
|
|
|
case TOX_ERR_GROUP_SEND_PRIVATE_MESSAGE_BAD_TYPE:
|
|
return "TOX_ERR_GROUP_SEND_PRIVATE_MESSAGE_BAD_TYPE";
|
|
|
|
case TOX_ERR_GROUP_SEND_PRIVATE_MESSAGE_PERMISSIONS:
|
|
return "TOX_ERR_GROUP_SEND_PRIVATE_MESSAGE_PERMISSIONS";
|
|
|
|
case TOX_ERR_GROUP_SEND_PRIVATE_MESSAGE_FAIL_SEND:
|
|
return "TOX_ERR_GROUP_SEND_PRIVATE_MESSAGE_FAIL_SEND";
|
|
|
|
case TOX_ERR_GROUP_SEND_PRIVATE_MESSAGE_DISCONNECTED:
|
|
return "TOX_ERR_GROUP_SEND_PRIVATE_MESSAGE_DISCONNECTED";
|
|
}
|
|
|
|
return "<invalid Tox_Err_Group_Send_Private_Message>";
|
|
}
|
|
const char *tox_err_group_send_custom_packet_to_string(Tox_Err_Group_Send_Custom_Packet value)
|
|
{
|
|
switch (value) {
|
|
case TOX_ERR_GROUP_SEND_CUSTOM_PACKET_OK:
|
|
return "TOX_ERR_GROUP_SEND_CUSTOM_PACKET_OK";
|
|
|
|
case TOX_ERR_GROUP_SEND_CUSTOM_PACKET_GROUP_NOT_FOUND:
|
|
return "TOX_ERR_GROUP_SEND_CUSTOM_PACKET_GROUP_NOT_FOUND";
|
|
|
|
case TOX_ERR_GROUP_SEND_CUSTOM_PACKET_TOO_LONG:
|
|
return "TOX_ERR_GROUP_SEND_CUSTOM_PACKET_TOO_LONG";
|
|
|
|
case TOX_ERR_GROUP_SEND_CUSTOM_PACKET_EMPTY:
|
|
return "TOX_ERR_GROUP_SEND_CUSTOM_PACKET_EMPTY";
|
|
|
|
case TOX_ERR_GROUP_SEND_CUSTOM_PACKET_DISCONNECTED:
|
|
return "TOX_ERR_GROUP_SEND_CUSTOM_PACKET_DISCONNECTED";
|
|
|
|
case TOX_ERR_GROUP_SEND_CUSTOM_PACKET_FAIL_SEND:
|
|
return "TOX_ERR_GROUP_SEND_CUSTOM_PACKET_FAIL_SEND";
|
|
}
|
|
|
|
return "<invalid Tox_Err_Group_Send_Custom_Packet>";
|
|
}
|
|
const char *tox_err_group_send_custom_private_packet_to_string(Tox_Err_Group_Send_Custom_Private_Packet value)
|
|
{
|
|
switch (value) {
|
|
case TOX_ERR_GROUP_SEND_CUSTOM_PRIVATE_PACKET_OK:
|
|
return "TOX_ERR_GROUP_SEND_CUSTOM_PRIVATE_PACKET_OK";
|
|
|
|
case TOX_ERR_GROUP_SEND_CUSTOM_PRIVATE_PACKET_GROUP_NOT_FOUND:
|
|
return "TOX_ERR_GROUP_SEND_CUSTOM_PRIVATE_PACKET_GROUP_NOT_FOUND";
|
|
|
|
case TOX_ERR_GROUP_SEND_CUSTOM_PRIVATE_PACKET_TOO_LONG:
|
|
return "TOX_ERR_GROUP_SEND_CUSTOM_PRIVATE_PACKET_TOO_LONG";
|
|
|
|
case TOX_ERR_GROUP_SEND_CUSTOM_PRIVATE_PACKET_EMPTY:
|
|
return "TOX_ERR_GROUP_SEND_CUSTOM_PRIVATE_PACKET_EMPTY";
|
|
|
|
case TOX_ERR_GROUP_SEND_CUSTOM_PRIVATE_PACKET_PEER_NOT_FOUND:
|
|
return "TOX_ERR_GROUP_SEND_CUSTOM_PRIVATE_PACKET_PEER_NOT_FOUND";
|
|
|
|
case TOX_ERR_GROUP_SEND_CUSTOM_PRIVATE_PACKET_FAIL_SEND:
|
|
return "TOX_ERR_GROUP_SEND_CUSTOM_PRIVATE_PACKET_FAIL_SEND";
|
|
|
|
case TOX_ERR_GROUP_SEND_CUSTOM_PRIVATE_PACKET_DISCONNECTED:
|
|
return "TOX_ERR_GROUP_SEND_CUSTOM_PRIVATE_PACKET_DISCONNECTED";
|
|
}
|
|
|
|
return "<invalid Tox_Err_Group_Send_Custom_Private_Packet>";
|
|
}
|
|
const char *tox_err_group_invite_friend_to_string(Tox_Err_Group_Invite_Friend value)
|
|
{
|
|
switch (value) {
|
|
case TOX_ERR_GROUP_INVITE_FRIEND_OK:
|
|
return "TOX_ERR_GROUP_INVITE_FRIEND_OK";
|
|
|
|
case TOX_ERR_GROUP_INVITE_FRIEND_GROUP_NOT_FOUND:
|
|
return "TOX_ERR_GROUP_INVITE_FRIEND_GROUP_NOT_FOUND";
|
|
|
|
case TOX_ERR_GROUP_INVITE_FRIEND_FRIEND_NOT_FOUND:
|
|
return "TOX_ERR_GROUP_INVITE_FRIEND_FRIEND_NOT_FOUND";
|
|
|
|
case TOX_ERR_GROUP_INVITE_FRIEND_INVITE_FAIL:
|
|
return "TOX_ERR_GROUP_INVITE_FRIEND_INVITE_FAIL";
|
|
|
|
case TOX_ERR_GROUP_INVITE_FRIEND_FAIL_SEND:
|
|
return "TOX_ERR_GROUP_INVITE_FRIEND_FAIL_SEND";
|
|
|
|
case TOX_ERR_GROUP_INVITE_FRIEND_DISCONNECTED:
|
|
return "TOX_ERR_GROUP_INVITE_FRIEND_DISCONNECTED";
|
|
}
|
|
|
|
return "<invalid Tox_Err_Group_Invite_Friend>";
|
|
}
|
|
const char *tox_err_group_invite_accept_to_string(Tox_Err_Group_Invite_Accept value)
|
|
{
|
|
switch (value) {
|
|
case TOX_ERR_GROUP_INVITE_ACCEPT_OK:
|
|
return "TOX_ERR_GROUP_INVITE_ACCEPT_OK";
|
|
|
|
case TOX_ERR_GROUP_INVITE_ACCEPT_BAD_INVITE:
|
|
return "TOX_ERR_GROUP_INVITE_ACCEPT_BAD_INVITE";
|
|
|
|
case TOX_ERR_GROUP_INVITE_ACCEPT_INIT_FAILED:
|
|
return "TOX_ERR_GROUP_INVITE_ACCEPT_INIT_FAILED";
|
|
|
|
case TOX_ERR_GROUP_INVITE_ACCEPT_TOO_LONG:
|
|
return "TOX_ERR_GROUP_INVITE_ACCEPT_TOO_LONG";
|
|
|
|
case TOX_ERR_GROUP_INVITE_ACCEPT_EMPTY:
|
|
return "TOX_ERR_GROUP_INVITE_ACCEPT_EMPTY";
|
|
|
|
case TOX_ERR_GROUP_INVITE_ACCEPT_PASSWORD:
|
|
return "TOX_ERR_GROUP_INVITE_ACCEPT_PASSWORD";
|
|
|
|
case TOX_ERR_GROUP_INVITE_ACCEPT_FRIEND_NOT_FOUND:
|
|
return "TOX_ERR_GROUP_INVITE_ACCEPT_FRIEND_NOT_FOUND";
|
|
|
|
case TOX_ERR_GROUP_INVITE_ACCEPT_FAIL_SEND:
|
|
return "TOX_ERR_GROUP_INVITE_ACCEPT_FAIL_SEND";
|
|
}
|
|
|
|
return "<invalid Tox_Err_Group_Invite_Accept>";
|
|
}
|
|
const char *tox_group_exit_type_to_string(Tox_Group_Exit_Type value)
|
|
{
|
|
switch (value) {
|
|
case TOX_GROUP_EXIT_TYPE_QUIT:
|
|
return "TOX_GROUP_EXIT_TYPE_QUIT";
|
|
|
|
case TOX_GROUP_EXIT_TYPE_TIMEOUT:
|
|
return "TOX_GROUP_EXIT_TYPE_TIMEOUT";
|
|
|
|
case TOX_GROUP_EXIT_TYPE_DISCONNECTED:
|
|
return "TOX_GROUP_EXIT_TYPE_DISCONNECTED";
|
|
|
|
case TOX_GROUP_EXIT_TYPE_SELF_DISCONNECTED:
|
|
return "TOX_GROUP_EXIT_TYPE_SELF_DISCONNECTED";
|
|
|
|
case TOX_GROUP_EXIT_TYPE_KICK:
|
|
return "TOX_GROUP_EXIT_TYPE_KICK";
|
|
|
|
case TOX_GROUP_EXIT_TYPE_SYNC_ERROR:
|
|
return "TOX_GROUP_EXIT_TYPE_SYNC_ERROR";
|
|
}
|
|
|
|
return "<invalid Tox_Group_Exit_Type>";
|
|
}
|
|
const char *tox_group_join_fail_to_string(Tox_Group_Join_Fail value)
|
|
{
|
|
switch (value) {
|
|
case TOX_GROUP_JOIN_FAIL_PEER_LIMIT:
|
|
return "TOX_GROUP_JOIN_FAIL_PEER_LIMIT";
|
|
|
|
case TOX_GROUP_JOIN_FAIL_INVALID_PASSWORD:
|
|
return "TOX_GROUP_JOIN_FAIL_INVALID_PASSWORD";
|
|
|
|
case TOX_GROUP_JOIN_FAIL_UNKNOWN:
|
|
return "TOX_GROUP_JOIN_FAIL_UNKNOWN";
|
|
}
|
|
|
|
return "<invalid Tox_Group_Join_Fail>";
|
|
}
|
|
const char *tox_err_group_set_password_to_string(Tox_Err_Group_Set_Password value)
|
|
{
|
|
switch (value) {
|
|
case TOX_ERR_GROUP_SET_PASSWORD_OK:
|
|
return "TOX_ERR_GROUP_SET_PASSWORD_OK";
|
|
|
|
case TOX_ERR_GROUP_SET_PASSWORD_GROUP_NOT_FOUND:
|
|
return "TOX_ERR_GROUP_SET_PASSWORD_GROUP_NOT_FOUND";
|
|
|
|
case TOX_ERR_GROUP_SET_PASSWORD_PERMISSIONS:
|
|
return "TOX_ERR_GROUP_SET_PASSWORD_PERMISSIONS";
|
|
|
|
case TOX_ERR_GROUP_SET_PASSWORD_TOO_LONG:
|
|
return "TOX_ERR_GROUP_SET_PASSWORD_TOO_LONG";
|
|
|
|
case TOX_ERR_GROUP_SET_PASSWORD_FAIL_SEND:
|
|
return "TOX_ERR_GROUP_SET_PASSWORD_FAIL_SEND";
|
|
|
|
case TOX_ERR_GROUP_SET_PASSWORD_MALLOC:
|
|
return "TOX_ERR_GROUP_SET_PASSWORD_MALLOC";
|
|
|
|
case TOX_ERR_GROUP_SET_PASSWORD_DISCONNECTED:
|
|
return "TOX_ERR_GROUP_SET_PASSWORD_DISCONNECTED";
|
|
}
|
|
|
|
return "<invalid Tox_Err_Group_Set_Password>";
|
|
}
|
|
const char *tox_err_group_set_topic_lock_to_string(Tox_Err_Group_Set_Topic_Lock value)
|
|
{
|
|
switch (value) {
|
|
case TOX_ERR_GROUP_SET_TOPIC_LOCK_OK:
|
|
return "TOX_ERR_GROUP_SET_TOPIC_LOCK_OK";
|
|
|
|
case TOX_ERR_GROUP_SET_TOPIC_LOCK_GROUP_NOT_FOUND:
|
|
return "TOX_ERR_GROUP_SET_TOPIC_LOCK_GROUP_NOT_FOUND";
|
|
|
|
case TOX_ERR_GROUP_SET_TOPIC_LOCK_INVALID:
|
|
return "TOX_ERR_GROUP_SET_TOPIC_LOCK_INVALID";
|
|
|
|
case TOX_ERR_GROUP_SET_TOPIC_LOCK_PERMISSIONS:
|
|
return "TOX_ERR_GROUP_SET_TOPIC_LOCK_PERMISSIONS";
|
|
|
|
case TOX_ERR_GROUP_SET_TOPIC_LOCK_FAIL_SET:
|
|
return "TOX_ERR_GROUP_SET_TOPIC_LOCK_FAIL_SET";
|
|
|
|
case TOX_ERR_GROUP_SET_TOPIC_LOCK_FAIL_SEND:
|
|
return "TOX_ERR_GROUP_SET_TOPIC_LOCK_FAIL_SEND";
|
|
|
|
case TOX_ERR_GROUP_SET_TOPIC_LOCK_DISCONNECTED:
|
|
return "TOX_ERR_GROUP_SET_TOPIC_LOCK_DISCONNECTED";
|
|
}
|
|
|
|
return "<invalid Tox_Err_Group_Set_Topic_Lock>";
|
|
}
|
|
const char *tox_err_group_set_voice_state_to_string(Tox_Err_Group_Set_Voice_State value)
|
|
{
|
|
switch (value) {
|
|
case TOX_ERR_GROUP_SET_VOICE_STATE_OK:
|
|
return "TOX_ERR_GROUP_SET_VOICE_STATE_OK";
|
|
|
|
case TOX_ERR_GROUP_SET_VOICE_STATE_GROUP_NOT_FOUND:
|
|
return "TOX_ERR_GROUP_SET_VOICE_STATE_GROUP_NOT_FOUND";
|
|
|
|
case TOX_ERR_GROUP_SET_VOICE_STATE_PERMISSIONS:
|
|
return "TOX_ERR_GROUP_SET_VOICE_STATE_PERMISSIONS";
|
|
|
|
case TOX_ERR_GROUP_SET_VOICE_STATE_FAIL_SET:
|
|
return "TOX_ERR_GROUP_SET_VOICE_STATE_FAIL_SET";
|
|
|
|
case TOX_ERR_GROUP_SET_VOICE_STATE_FAIL_SEND:
|
|
return "TOX_ERR_GROUP_SET_VOICE_STATE_FAIL_SEND";
|
|
|
|
case TOX_ERR_GROUP_SET_VOICE_STATE_DISCONNECTED:
|
|
return "TOX_ERR_GROUP_SET_VOICE_STATE_DISCONNECTED";
|
|
}
|
|
|
|
return "<invalid Tox_Err_Group_Set_Voice_State>";
|
|
}
|
|
const char *tox_err_group_set_privacy_state_to_string(Tox_Err_Group_Set_Privacy_State value)
|
|
{
|
|
switch (value) {
|
|
case TOX_ERR_GROUP_SET_PRIVACY_STATE_OK:
|
|
return "TOX_ERR_GROUP_SET_PRIVACY_STATE_OK";
|
|
|
|
case TOX_ERR_GROUP_SET_PRIVACY_STATE_GROUP_NOT_FOUND:
|
|
return "TOX_ERR_GROUP_SET_PRIVACY_STATE_GROUP_NOT_FOUND";
|
|
|
|
case TOX_ERR_GROUP_SET_PRIVACY_STATE_PERMISSIONS:
|
|
return "TOX_ERR_GROUP_SET_PRIVACY_STATE_PERMISSIONS";
|
|
|
|
case TOX_ERR_GROUP_SET_PRIVACY_STATE_FAIL_SET:
|
|
return "TOX_ERR_GROUP_SET_PRIVACY_STATE_FAIL_SET";
|
|
|
|
case TOX_ERR_GROUP_SET_PRIVACY_STATE_FAIL_SEND:
|
|
return "TOX_ERR_GROUP_SET_PRIVACY_STATE_FAIL_SEND";
|
|
|
|
case TOX_ERR_GROUP_SET_PRIVACY_STATE_DISCONNECTED:
|
|
return "TOX_ERR_GROUP_SET_PRIVACY_STATE_DISCONNECTED";
|
|
}
|
|
|
|
return "<invalid Tox_Err_Group_Set_Privacy_State>";
|
|
}
|
|
const char *tox_err_group_set_peer_limit_to_string(Tox_Err_Group_Set_Peer_Limit value)
|
|
{
|
|
switch (value) {
|
|
case TOX_ERR_GROUP_SET_PEER_LIMIT_OK:
|
|
return "TOX_ERR_GROUP_SET_PEER_LIMIT_OK";
|
|
|
|
case TOX_ERR_GROUP_SET_PEER_LIMIT_GROUP_NOT_FOUND:
|
|
return "TOX_ERR_GROUP_SET_PEER_LIMIT_GROUP_NOT_FOUND";
|
|
|
|
case TOX_ERR_GROUP_SET_PEER_LIMIT_PERMISSIONS:
|
|
return "TOX_ERR_GROUP_SET_PEER_LIMIT_PERMISSIONS";
|
|
|
|
case TOX_ERR_GROUP_SET_PEER_LIMIT_FAIL_SET:
|
|
return "TOX_ERR_GROUP_SET_PEER_LIMIT_FAIL_SET";
|
|
|
|
case TOX_ERR_GROUP_SET_PEER_LIMIT_FAIL_SEND:
|
|
return "TOX_ERR_GROUP_SET_PEER_LIMIT_FAIL_SEND";
|
|
|
|
case TOX_ERR_GROUP_SET_PEER_LIMIT_DISCONNECTED:
|
|
return "TOX_ERR_GROUP_SET_PEER_LIMIT_DISCONNECTED";
|
|
}
|
|
|
|
return "<invalid Tox_Err_Group_Set_Peer_Limit>";
|
|
}
|
|
const char *tox_err_group_set_ignore_to_string(Tox_Err_Group_Set_Ignore value)
|
|
{
|
|
switch (value) {
|
|
case TOX_ERR_GROUP_SET_IGNORE_OK:
|
|
return "TOX_ERR_GROUP_SET_IGNORE_OK";
|
|
|
|
case TOX_ERR_GROUP_SET_IGNORE_GROUP_NOT_FOUND:
|
|
return "TOX_ERR_GROUP_SET_IGNORE_GROUP_NOT_FOUND";
|
|
|
|
case TOX_ERR_GROUP_SET_IGNORE_PEER_NOT_FOUND:
|
|
return "TOX_ERR_GROUP_SET_IGNORE_PEER_NOT_FOUND";
|
|
|
|
case TOX_ERR_GROUP_SET_IGNORE_SELF:
|
|
return "TOX_ERR_GROUP_SET_IGNORE_SELF";
|
|
}
|
|
|
|
return "<invalid Tox_Err_Group_Set_Ignore>";
|
|
}
|
|
const char *tox_err_group_set_role_to_string(Tox_Err_Group_Set_Role value)
|
|
{
|
|
switch (value) {
|
|
case TOX_ERR_GROUP_SET_ROLE_OK:
|
|
return "TOX_ERR_GROUP_SET_ROLE_OK";
|
|
|
|
case TOX_ERR_GROUP_SET_ROLE_GROUP_NOT_FOUND:
|
|
return "TOX_ERR_GROUP_SET_ROLE_GROUP_NOT_FOUND";
|
|
|
|
case TOX_ERR_GROUP_SET_ROLE_PEER_NOT_FOUND:
|
|
return "TOX_ERR_GROUP_SET_ROLE_PEER_NOT_FOUND";
|
|
|
|
case TOX_ERR_GROUP_SET_ROLE_PERMISSIONS:
|
|
return "TOX_ERR_GROUP_SET_ROLE_PERMISSIONS";
|
|
|
|
case TOX_ERR_GROUP_SET_ROLE_ASSIGNMENT:
|
|
return "TOX_ERR_GROUP_SET_ROLE_ASSIGNMENT";
|
|
|
|
case TOX_ERR_GROUP_SET_ROLE_FAIL_ACTION:
|
|
return "TOX_ERR_GROUP_SET_ROLE_FAIL_ACTION";
|
|
|
|
case TOX_ERR_GROUP_SET_ROLE_SELF:
|
|
return "TOX_ERR_GROUP_SET_ROLE_SELF";
|
|
}
|
|
|
|
return "<invalid Tox_Err_Group_Set_Role>";
|
|
}
|
|
const char *tox_err_group_kick_peer_to_string(Tox_Err_Group_Kick_Peer value)
|
|
{
|
|
switch (value) {
|
|
case TOX_ERR_GROUP_KICK_PEER_OK:
|
|
return "TOX_ERR_GROUP_KICK_PEER_OK";
|
|
|
|
case TOX_ERR_GROUP_KICK_PEER_GROUP_NOT_FOUND:
|
|
return "TOX_ERR_GROUP_KICK_PEER_GROUP_NOT_FOUND";
|
|
|
|
case TOX_ERR_GROUP_KICK_PEER_PEER_NOT_FOUND:
|
|
return "TOX_ERR_GROUP_KICK_PEER_PEER_NOT_FOUND";
|
|
|
|
case TOX_ERR_GROUP_KICK_PEER_PERMISSIONS:
|
|
return "TOX_ERR_GROUP_KICK_PEER_PERMISSIONS";
|
|
|
|
case TOX_ERR_GROUP_KICK_PEER_FAIL_ACTION:
|
|
return "TOX_ERR_GROUP_KICK_PEER_FAIL_ACTION";
|
|
|
|
case TOX_ERR_GROUP_KICK_PEER_FAIL_SEND:
|
|
return "TOX_ERR_GROUP_KICK_PEER_FAIL_SEND";
|
|
|
|
case TOX_ERR_GROUP_KICK_PEER_SELF:
|
|
return "TOX_ERR_GROUP_KICK_PEER_SELF";
|
|
}
|
|
|
|
return "<invalid Tox_Err_Group_Kick_Peer>";
|
|
}
|
|
const char *tox_group_mod_event_to_string(Tox_Group_Mod_Event value)
|
|
{
|
|
switch (value) {
|
|
case TOX_GROUP_MOD_EVENT_KICK:
|
|
return "TOX_GROUP_MOD_EVENT_KICK";
|
|
|
|
case TOX_GROUP_MOD_EVENT_OBSERVER:
|
|
return "TOX_GROUP_MOD_EVENT_OBSERVER";
|
|
|
|
case TOX_GROUP_MOD_EVENT_USER:
|
|
return "TOX_GROUP_MOD_EVENT_USER";
|
|
|
|
case TOX_GROUP_MOD_EVENT_MODERATOR:
|
|
return "TOX_GROUP_MOD_EVENT_MODERATOR";
|
|
}
|
|
|
|
return "<invalid Tox_Group_Mod_Event>";
|
|
}
|