Skip to main content

SleepyDiscord::UWebSocketsDiscordClient

Inherits from SleepyDiscord::BaseDiscordClient, SleepyDiscord::GenericMessageReceiver

inherited members​

Public Classes inherited from SleepyDiscord::BaseDiscordClient

Name
structRawRequestModeTypeHelper
structRequest
structRequestModeType
structRequestModeType< Async >
structRequestModeType< Sync >
structRequestSettings

Public Types inherited from SleepyDiscord::BaseDiscordClient

Name
enumGetMessagesKey { na, around, before, after, limit}
enum boolAssignmentType { TilDueTime, EpochTime}
using std::function< void(Response)>RequestCallback
typedef TimedTaskPostableTask

Public Functions inherited from SleepyDiscord::BaseDiscordClient

Name
BaseDiscordClient() =default
BaseDiscordClient(const std::string _token)
~BaseDiscordClient()
Responserequest(const RequestMethod method, Route path, const std::string jsonParameters ="", const std::vector< Part > & multipartParameters ={}, RequestCallback callback =nullptr, const RequestMode mode =Sync_AsyncQueue)
template <class ParmType >
void
requestAsync(const RequestMethod method, Route path, std::function< void(ParmType)> callback, const std::string jsonParameters ="", const std::vector< Part > & multipartParameters ={}, const RequestMode mode =Async)
template <class ParmType >
Response
requestSync(const RequestMethod method, Route path, std::function< void(ParmType)> callback, const std::string jsonParameters ="", const std::vector< Part > & multipartParameters ={}, const RequestMode mode =Sync)
const Routepath(const char * source, std::initializer_list< std::string > values ={})
template <class RequestSettingsClass >
Response
request(const RequestMethod method, Route path, RequestSettingsClass & settings, const std::string jsonParameters ="", const std::initializer_list< Part > & multipartParameters ={})
template <RequestMode mode,class ParmType =void,class Callback =RequestCallback>
RequestModeType< mode >::ReturnType
request(const RequestMethod method, Route path, Callback callback, const std::string jsonParameters ="", const std::initializer_list< Part > & multipartParameters ={})
voidtestFunction(std::string teststring)
ObjectResponse< Gateway >getGateway(RequestSettings< ObjectResponse< Gateway >> settings ={})
ObjectResponse< Channel >getChannel(Snowflake< Channel > channelID, RequestSettings< ObjectResponse< Channel >> settings ={})
ObjectResponse< Channel >editChannel(Snowflake< Channel > channelID, std::string name ="", std::string topic ="", RequestSettings< ObjectResponse< Channel >> settings ={})
ObjectResponse< Channel >editChannelName(Snowflake< Channel > channelID, std::string name, RequestSettings< ObjectResponse< Channel >> settings ={})
ObjectResponse< Channel >editChannelTopic(Snowflake< Channel > channelID, std::string topic, RequestSettings< ObjectResponse< Channel >> settings ={})
ObjectResponse< Channel >deleteChannel(Snowflake< Channel > channelID, RequestSettings< ObjectResponse< Channel >> settings ={})
ArrayResponse< Message >getMessages(Snowflake< Channel > channelID, GetMessagesKey when, Snowflake< Message > messageID, uint8_t limit =0, RequestSettings< ArrayResponse< Message >> settings ={})
ObjectResponse< Message >getMessage(Snowflake< Channel > channelID, Snowflake< Message > messageID, RequestSettings< ObjectResponse< Message >> settings ={})
const EmbedcreateInvalidEmbed()
ObjectResponse< Message >sendMessage(Snowflake< Channel > channelID, std::string message, Embed embed =Embed::Flag::INVALID_EMBED, MessageReference replyingTo ={}, TTS tts =TTS::Default, RequestSettings< ObjectResponse< Message >> settings ={})
ObjectResponse< Message >sendMessage(SendMessageParams params, RequestSettings< ObjectResponse< Message >> settings ={})
ObjectResponse< Message >uploadFile(Snowflake< Channel > channelID, std::string fileLocation, std::string message, Embed embed =Embed::Flag::INVALID_EMBED, MessageReference replyingTo ={}, RequestSettings< ObjectResponse< Message >> settings ={})
ObjectResponse< Message >uploadFile(SendMessageParams params, std::string fileLocation, RequestSettings< ObjectResponse< Message >> settings ={})
BoolResponseaddReaction(Snowflake< Channel > channelID, Snowflake< Message > messageID, std::string emoji, RequestSettings< BoolResponse > settings ={})
BoolResponseremoveReaction(Snowflake< Channel > channelID, Snowflake< Message > messageID, std::string emoji, Snowflake< User > userID ="@me")
ArrayResponse< User >getReactions(Snowflake< Channel > channelID, Snowflake< Message > messageID, std::string emoji, RequestSettings< ArrayResponse< Reaction >> settings ={})
StandardResponseremoveAllReactions(Snowflake< Channel > channelID, Snowflake< Message > messageID, RequestSettings< StandardResponse > settings ={})
ObjectResponse< Message >editMessage(Snowflake< Channel > channelID, Snowflake< Message > messageID, std::string newMessage, Embed embed =Embed::Flag::INVALID_EMBED, RequestSettings< ObjectResponse< Message >> settings ={})
ObjectResponse< Message >editMessage(EditMessageParams params, RequestSettings< ObjectResponse< Message >> settings ={})
BoolResponsedeleteMessage(Snowflake< Channel > channelID, Snowflake< Message > messageID, RequestSettings< BoolResponse > settings ={})
BoolResponsebulkDeleteMessages(Snowflake< Channel > channelID, std::vector< Snowflake< Message >> messageIDs, RequestSettings< BoolResponse > settings ={})
BoolResponseeditChannelPermissions(Snowflake< Channel > channelID, Snowflake< Overwrite > overwriteID, int allow, int deny, std::string type)
ArrayResponse< Invite >getChannelInvites(Snowflake< Channel > channelID, RequestSettings< ArrayResponse< Invite >> settings ={})
ObjectResponse< Invite >createChannelInvite(Snowflake< Channel > channelID, const uint64_t maxAge =0, const uint64_t maxUses =0, const bool temporary =false, const bool unique =false)
BoolResponseremoveChannelPermission(Snowflake< Channel > channelID, std::string ID, RequestSettings< BoolResponse > settings ={})
BoolResponsesendTyping(Snowflake< Channel > channelID, RequestSettings< BoolResponse > settings ={})
ArrayResponse< Message >getPinnedMessages(Snowflake< Channel > channelID, RequestSettings< ArrayResponse< Message >> settings ={})
BoolResponsepinMessage(Snowflake< Channel > channelID, Snowflake< Message > messageID, RequestSettings< BoolResponse > settings ={})
BoolResponseunpinMessage(Snowflake< Channel > channelID, Snowflake< Message > messageID, RequestSettings< BoolResponse > settings ={})
StandardResponseaddRecipient(Snowflake< Channel > channelID, Snowflake< User > userID, RequestSettings< StandardResponse > settings ={})
StandardResponseremoveRecipient(Snowflake< Channel > channelID, Snowflake< User > userID, RequestSettings< StandardResponse > settings ={})
BoolResponsedeleteReaction(Snowflake< Channel > channelID, Snowflake< Message > messageID, std::string emoji)
StandardResponsedeleteAllReactions(Snowflake< Channel > channelID, Snowflake< Message > messageID)
BoolResponsedeleteChannelPermission(Snowflake< Channel > channelID, std::string ID)
StandardResponsedeleteRecipient(Snowflake< Channel > channelID, Snowflake< User > _userID)
ObjectResponse< Message >editMessage(Message message, std::string newMessage, Embed embed =Embed::Flag::INVALID_EMBED)
ObjectResponse< Message >sendMessage(Snowflake< Channel > channelID, std::string message, RequestSettings< ObjectResponse< Message >> settings)
ObjectResponse< Server >getServer(Snowflake< Server > serverID, RequestSettings< ObjectResponse< Server >> settings ={})
ObjectResponse< Server >deleteServer(Snowflake< Server > serverID, RequestSettings< ObjectResponse< Server >> settings ={})
ArrayResponse< Channel >getServerChannels(Snowflake< Server > serverID, RequestSettings< ArrayResponse< Channel >> settings ={})
ObjectResponse< Channel >createTextChannel(Snowflake< Server > serverID, std::string name, RequestSettings< ObjectResponse< Channel >> settings ={})
ObjectResponse< Channel >createChannel(Snowflake< Server > serverID, std::string name, Channel::ChannelType Type, RequestSettings< ObjectResponse< Channel >> settings ={})
ArrayResponse< Channel >editChannelPositions(Snowflake< Server > serverID, std::vector< std::pair< std::string, uint64_t >> positions, RequestSettings< ArrayResponse< Channel >> settings ={})
ObjectResponse< ServerMember >getMember(Snowflake< Server > serverID, Snowflake< User > userID, RequestSettings< ObjectResponse< ServerMember >> settings ={})
ArrayResponse< ServerMember >listMembers(Snowflake< Server > serverID, uint16_t limit =0, std::string after ="", RequestSettings< ArrayResponse< ServerMember >> settings ={})
ObjectResponse< ServerMember >addMember(Snowflake< Server > serverID, Snowflake< User > userID, std::string accesToken, std::string nick ="", std::vector< Role > roles ={}, bool mute =false, bool deaf =false)
BoolResponseeditMember(Snowflake< Server > serverID, Snowflake< User > userID, std::string nickname ="", std::vector< Snowflake< Role >> roles ={}, int8_t mute =-1, int8_t deaf =-1, Snowflake< Channel > channelID ={})
BoolResponsemuteServerMember(Snowflake< Server > serverID, Snowflake< User > userID, bool mute =true, RequestSettings< BoolResponse > settings ={})
BoolResponseeditNickname(Snowflake< Server > serverID, std::string newNickname, RequestSettings< BoolResponse > settings ={})
BoolResponseaddRole(Snowflake< Server > serverID, Snowflake< User > userID, Snowflake< Role > roleID, RequestSettings< BoolResponse > settings ={})
BoolResponseremoveRole(Snowflake< Server > serverID, Snowflake< User > userID, Snowflake< Role > roleID, RequestSettings< BoolResponse > settings ={})
BoolResponsekickMember(Snowflake< Server > serverID, Snowflake< User > userID, RequestSettings< BoolResponse > settings ={})
ArrayResponse< User >getBans(Snowflake< Server > serverID, RequestSettings< ArrayResponse< User >> settings ={})
BoolResponsebanMember(Snowflake< Server > serverID, Snowflake< User > userID, int deleteMessageDays =-1, std::string reason ="", RequestSettings< BoolResponse > settings ={})
BoolResponseunbanMember(Snowflake< Server > serverID, Snowflake< User > userID, RequestSettings< BoolResponse > settings ={})
ArrayResponse< Role >getRoles(Snowflake< Server > serverID, RequestSettings< ArrayResponse< Role >> settings ={})
ObjectResponse< Role >createRole(Snowflake< Server > serverID, std::string name ="", Permission permissions =Permission::NONE, unsigned int color =0, bool hoist =false, bool mentionable =false)
ArrayResponse< Role >editRolePosition(Snowflake< Server > serverID, std::vector< std::pair< std::string, uint64_t >> positions, RequestSettings< ArrayResponse< Role >> settings ={})
StringResponseeditRole(Snowflake< Server > serverID, Snowflake< Role > roleID, std::string name ="", Permission permissions =Permission::NONE, uint32_t color =1<< 24, int8_t hoist =-1, int8_t mentionable =-1)
BoolResponsedeleteRole(Snowflake< Server > serverID, Snowflake< Role > roleID, RequestSettings< BoolResponse > settings ={})
StandardResponsepruneMembers(Snowflake< Server > serverID, const unsigned int numOfDays, RequestSettings< StandardResponse > settings ={})
ArrayResponse< VoiceRegion >getVoiceRegions(RequestSettings< ArrayResponse< VoiceRegion >> settings ={})
ArrayResponse< Invite >getServerInvites(Snowflake< Server > serverID, RequestSettings< ArrayResponse< Invite >> settings ={})
StringResponsegetIntegrations(Snowflake< Server > serverID, RequestSettings< StringResponse > settings ={})
BoolResponsecreateIntegration(Snowflake< Server > serverID, std::string type, std::string integrationID, RequestSettings< BoolResponse > settings ={})
BoolResponseeditIntergration(Snowflake< Server > serverID, std::string integrationID, int expireBegavior, int expireGracePeriod, bool enbleEmoticons)
BoolResponsedeleteIntegration(Snowflake< Server > serverID, std::string integrationID, RequestSettings< BoolResponse > settings ={})
BoolResponsesyncIntegration(Snowflake< Server > serverID, std::string integrationID, RequestSettings< BoolResponse > settings ={})
ObjectResponse< ServerWidget >getServerWidget(Snowflake< Server > serverID, RequestSettings< ObjectResponse< ServerWidget >> settings ={})
ObjectResponse< Invite >inviteEndpoint(RequestMethod method, std::string inviteCode, RequestSettings< ObjectResponse< Invite >> settings ={})
ObjectResponse< Invite >getInvite(std::string inviteCode, RequestSettings< ObjectResponse< Invite >> settings ={})
ObjectResponse< Invite >deleteInvite(std::string inviteCode, RequestSettings< ObjectResponse< Invite >> settings ={})
ObjectResponse< Invite >acceptInvite(std::string inviteCode, RequestSettings< ObjectResponse< Invite >> settings ={})
ObjectResponse< User >getCurrentUser(RequestSettings< ObjectResponse< User >> settings ={})
ObjectResponse< User >getUser(Snowflake< User > userID, RequestSettings< ObjectResponse< User >> settings ={})
ArrayResponse< Server >getServers(RequestSettings< ArrayResponse< Server >> settings ={})
BoolResponseleaveServer(Snowflake< Server > serverID, RequestSettings< BoolResponse > settings ={})
ArrayResponse< Channel >getDirectMessageChannels(RequestSettings< ArrayResponse< Channel >> settings ={})
ObjectResponse< Channel >createDirectMessageChannel(std::string recipientID, RequestSettings< ObjectResponse< Channel >> settings ={})
ArrayResponse< Connection >getUserConnections(RequestSettings< ArrayResponse< Connection >> settings ={})
ObjectResponse< Webhook >createWebhook(Snowflake< Channel > channelID, std::string name, std::string avatar ="", RequestSettings< ObjectResponse< Webhook >> settings ={})
ArrayResponse< Webhook >getChannelWebhooks(Snowflake< Channel > channelID, RequestSettings< ArrayResponse< Webhook >> settings ={})
ArrayResponse< Webhook >getServerWebhooks(Snowflake< Server > serverID, RequestSettings< ArrayResponse< Webhook >> settings ={})
ObjectResponse< Webhook >getWebhook(Snowflake< Webhook > webhookID, std::string webhookToken ="", RequestSettings< ObjectResponse< Webhook >> settings ={})
ObjectResponse< Webhook >editWebhook(Snowflake< Webhook > webhookID, std::string webhookToken ="", std::string name ="", std::string avatar ="")
BoolResponsedeleteWebhook(Snowflake< Webhook > webhookID, std::string webhookToken ="", RequestSettings< BoolResponse > settings ={})
ObjectResponse< Webhook >requestExecuteWebhook(Snowflake< Webhook > webhookID, std::string webhookToken, std::pair< std::string, std::string > pair, bool wait, std::string username, std::string avatar_url, bool tts)
ObjectResponse< Webhook >executeWebhook(Snowflake< Webhook > webhookID, std::string webhookToken, std::string content, bool wait =false, std::string username ="", std::string avatar_url ="", bool tts =false)
ObjectResponse< Webhook >executeWebhook(Snowflake< Webhook > webhookID, std::string webhookToken, std::vector< Embed > embeds, bool wait =false, std::string username ="", std::string avatar_url ="", bool tts =false)
ObjectResponse< Webhook >executeWebhook(Snowflake< Webhook > webhookID, std::string webhookToken, filePathPart file, bool wait =false, std::string username ="", std::string avatar_url ="", bool tts =false)
template <typename Options =const AppCommand::EmptyOptions>
ObjectResponse< AppCommand >
createGlobalAppCommand(Snowflake< DiscordObject >::RawType applicationID, std::string name, std::string description, Options options =(std::nullptr_t) nullptr, bool defaultPermission =true, AppCommand::Type type =AppCommand::Type::NONE, RequestSettings< ObjectResponse< AppCommand >> settings ={})
template <typename Options =const AppCommand::EmptyOptions>
ObjectResponse< AppCommand >
editGlobalAppCommand(Snowflake< DiscordObject >::RawType applicationID, Snowflake< AppCommand > commandID, std::string name, std::string description, Options options =(std::nullptr_t) nullptr, bool defaultPermission =true, AppCommand::Type type =AppCommand::Type::NONE, RequestSettings< ObjectResponse< AppCommand >> settings ={})
ArrayResponse< AppCommand >getGlobalAppCommands(Snowflake< DiscordObject >::RawType applicationID, RequestSettings< ArrayResponse< AppCommand >> settings ={})
ObjectResponse< AppCommand >getGlobalAppCommand(Snowflake< DiscordObject >::RawType applicationID, Snowflake< AppCommand > commandID, RequestSettings< ObjectResponse< AppCommand >> settings ={})
BoolResponsedeleteGlobalAppCommand(Snowflake< DiscordObject >::RawType applicationID, Snowflake< AppCommand > commandID, RequestSettings< BoolResponse > settings ={})
template <typename Options =const AppCommand::EmptyOptions>
ObjectResponse< AppCommand >
createServerAppCommand(Snowflake< DiscordObject >::RawType applicationID, Snowflake< Server > serverID, std::string name, std::string description, Options options =(std::nullptr_t) nullptr, bool defaultPermission =true, AppCommand::Type type =AppCommand::Type::NONE, RequestSettings< ObjectResponse< AppCommand >> settings ={})
template <typename Options =const AppCommand::EmptyOptions>
ObjectResponse< AppCommand >
editServerAppCommand(Snowflake< DiscordObject >::RawType applicationID, Snowflake< Server > serverID, Snowflake< AppCommand > commandID, std::string name, std::string description, Options options =(std::nullptr_t) nullptr, RequestSettings< ObjectResponse< AppCommand >> settings ={})
ArrayResponse< AppCommand >getServerAppCommands(Snowflake< DiscordObject >::RawType applicationID, Snowflake< Server > serverID, RequestSettings< ArrayResponse< AppCommand >> settings ={})
ObjectResponse< AppCommand >getServerAppCommand(Snowflake< DiscordObject >::RawType applicationID, Snowflake< Server > serverID, Snowflake< AppCommand > commandID, RequestSettings< ObjectResponse< AppCommand >> settings ={})
BoolResponsedeleteServerAppCommand(Snowflake< DiscordObject >::RawType applicationID, Snowflake< Server > serverID, Snowflake< AppCommand > commandID, RequestSettings< BoolResponse > settings ={})
template <typename Type >
BoolResponse
createInteractionResponse(Snowflake< Interaction > interactionID, std::string token, Type response, RequestSettings< BoolResponse > settings ={})
ObjectResponse< Message >editOriginalInteractionResponse(Snowflake< DiscordObject >::RawType applicationID, std::string interactionToken, EditWebhookParams params, RequestSettings< BoolResponse > settings ={})
BoolResponsedeleteOriginalInteractionResponse(Snowflake< DiscordObject >::RawType applicationID, std::string interactionToken, RequestSettings< BoolResponse > settings ={})
ObjectResponse< Message >createFollowupMessage(Snowflake< DiscordObject >::RawType applicationID, std::string interactionToken, FollowupMessage params, RequestSettings< BoolResponse > settings ={})
ObjectResponse< Message >editFollowupMessage(Snowflake< DiscordObject >::RawType applicationID, std::string interactionToken, Snowflake< Message > messageID, EditWebhookParams params, RequestSettings< BoolResponse > settings ={})
BoolResponsedeleteFollowupMessage(Snowflake< DiscordObject >::RawType applicationID, std::string interactionToken, Snowflake< Message > messageID, RequestSettings< BoolResponse > settings ={})
BoolResponsebatchEditAppCommandPermissions(Snowflake< DiscordObject >::RawType applicationID, Snowflake< Server > serverID, std::vector< ServerAppCommandPermissions > permissions, RequestSettings< BoolResponse > settings ={})
Batch edits permissions for all commands in a guild. Takes an array of partial objects including id and permissions. https://discord.com/developers/docs/interactions/slash-commands#batch-edit-application-command-permissions
BoolResponseeditServerAppCommandPermission(Snowflake< DiscordObject >::RawType applicationID, Snowflake< Server > serverID, Snowflake< AppCommand > commandID, std::vector< AppCommand::Permissions > permissions, RequestSettings< BoolResponse > settings ={})
Edits command permissions for a specific command for your application in a guild. https://discord.com/developers/docs/interactions/slash-commands#edit-application-command-permissions
ArrayResponse< ServerAppCommandPermissions >getServerAppCommandPermissions(Snowflake< DiscordObject >::RawType applicationID, Snowflake< Server > serverID, RequestSettings< ArrayResponse< ServerAppCommandPermissions >> settings ={})
Fetches command permissions for all commands for your application in a guild. https://discord.com/developers/docs/interactions/slash-commands#get-guild-application-command-permissions
ObjectResponse< ServerAppCommandPermissions >getAppCommandPermissions(Snowflake< DiscordObject >::RawType applicationID, Snowflake< Server > serverID, Snowflake< AppCommand > commandID, RequestSettings< ObjectResponse< ServerAppCommandPermissions >> settings ={})
Fetches command permissions for a specific command for your application in a guild. https://discord.com/developers/docs/interactions/slash-commands#get-application-command-permissions
template <typename Options =const AppCommand::EmptyOptions>
ObjectResponse< AppCommand >
createAppCommand(Snowflake< DiscordObject >::RawType applicationID, Snowflake< Server > serverID, std::string name, std::string description, Options options =(std::nullptr_t) nullptr, bool defaultPermission =true, AppCommand::Type type =AppCommand::Type::NONE, RequestSettings< ObjectResponse< AppCommand >> settings ={})
template <typename Options =const AppCommand::EmptyOptions>
ObjectResponse< AppCommand >
editAppCommand(Snowflake< DiscordObject >::RawType applicationID, Snowflake< Server > serverID, Snowflake< AppCommand > commandID, std::string name, std::string description, Options options =(std::nullptr_t) nullptr, RequestSettings< ObjectResponse< AppCommand >> settings ={})
ArrayResponse< AppCommand >getAppCommands(Snowflake< DiscordObject >::RawType applicationID, Snowflake< Server > serverID, RequestSettings< ArrayResponse< AppCommand >> settings ={})
ObjectResponse< AppCommand >getAppCommand(Snowflake< DiscordObject >::RawType applicationID, Snowflake< Server > serverID, Snowflake< AppCommand > commandID, RequestSettings< ObjectResponse< AppCommand >> settings ={})
BoolResponsedeleteAppCommand(Snowflake< DiscordObject >::RawType applicationID, Snowflake< Server > serverID, Snowflake< AppCommand > commandID, RequestSettings< BoolResponse > settings ={})
BoolResponsebulkOverwriteServerAppCommands(Snowflake< DiscordObject >::RawType applicationID, Snowflake< Server > serverID, std::vector< AppCommand > commands, RequestSettings< BoolResponse > settings ={})
BoolResponsebulkOverwriteGlobalAppCommands(Snowflake< DiscordObject >::RawType applicationID, std::vector< AppCommand > commands, RequestSettings< BoolResponse > settings ={})
ObjectResponse< User >createStageInstance(Snowflake< Channel > channelID, std::string topic, StageInstance::PrivacyLevel privacyLevel =StageInstance::PrivacyLevel::NotSet, RequestSettings< ObjectResponse< User >> settings ={})
ObjectResponse< StageInstance >getStageInstance(Snowflake< Channel > channelID, RequestSettings< ObjectResponse< StageInstance >> settings ={})
BoolResponseeditStageInstance(Snowflake< Channel > channelID, std::string topic, StageInstance::PrivacyLevel privacyLevel =StageInstance::PrivacyLevel::NotSet, RequestSettings< BoolResponse > settings ={})
BoolResponsedeleteStageInstance(Snowflake< Channel > channelID, RequestSettings< BoolResponse > settings ={})
voidupdateStatus(std::string gameName ="", uint64_t idleSince =0, Status status =online, bool afk =false)
voidrequestServerMembers(ServerMembersRequest request)
voidgetServerBanner(Snowflake< Server > serverID, std::string serverBanner, std::string format, std::function< void(StandardResponse &)> callback)
voidgetServerBanner(Server & server, std::string format)
voidwaitTilReady()
const boolisReady()
const boolisQuiting()
const boolisBot()
const Snowflake< User >getID()
voidsetShardID(int _shardID, int _shardCount)
const intgetShardID()
const intgetShardCount()
const boolhasIntents()
const IntentsRawgetIntents()
voidsetIntents(IntentsRaw newIntents)
voidquit()
template <class Container ,typename T =typename Container::value_type>
void
setIntents(const Container & listOfIntents)
template <typename... Types>
void
setIntents(Intent first, Intent second, Types... others)
template <class Handler ,class... Types>
void
useCompression(Types &&... arguments)
voiduseCompression(bool value =true)
template <class Handler ,class... Types>
void
setScheduleHandler(Types &&... arguments)
GenericScheduleHandler &getScheduleHandler()
voidunschedule(Timer & timer)
virtual voidpostTask(PostableTask code)
std::shared_ptr< ServerCache >createServerCache()
voidsetServerCache(std::shared_ptr< ServerCache > cache)
std::shared_ptr< ServerCache > &getServerCache()
constexpr nonstd::string_viewgetCDN_URL()

Protected Functions inherited from SleepyDiscord::BaseDiscordClient

Name
virtual voidonDepletedRequestSupply(const Route::Bucket & bucket, time_t timeTilReset)
virtual voidonExceededRateLimit(bool global, std::time_t timeTilRetry, Request request, bool & continueRequest)
virtual voidonReady(Ready readyData)
virtual voidonResumed()
virtual voidonDeleteServer(UnavailableServer server)
virtual voidonEditServer(Server server)
virtual voidonBan(Snowflake< Server > serverID, User user)
virtual voidonUnban(Snowflake< Server > serverID, User user)
virtual voidonMember(Snowflake< Server > serverID, ServerMember member)
virtual voidonRemoveMember(Snowflake< Server > serverID, User user)
virtual voidonEditMember(Snowflake< Server > serverID, User user, std::vector< Snowflake< Role >> roles, std::string nick)
virtual voidonRole(Snowflake< Server > serverID, Role role)
virtual voidonDeleteRole(Snowflake< Server > serverID, Snowflake< Role > roleID)
virtual voidonEditRole(Snowflake< Server > serverID, Role role)
virtual voidonEditEmojis(Snowflake< Server > serverID, std::vector< Emoji > emojis)
virtual voidonMemberChunk(ServerMembersChunk memberChunk)
virtual voidonDeleteChannel(Channel channel)
virtual voidonEditChannel(Channel channel)
virtual voidonPinMessage(Snowflake< Channel > channelID, std::string lastPinTimestamp)
virtual voidonPresenceUpdate(PresenceUpdate presenseUpdate)
virtual voidonEditUser(User user)
virtual voidonEditUserSettings(const json::Value & jsonMessage)
virtual voidonEditVoiceState(VoiceState & state)
virtual voidonTyping(Snowflake< Channel > channelID, Snowflake< User > userID, time_t timestamp)
virtual voidonDeleteMessages(Snowflake< Channel > channelID, std::vector< Snowflake< Message >> messages)
virtual voidonEditMessage(MessageRevisions revisioins)
virtual voidonEditVoiceServer(VoiceServerUpdate & update)
virtual voidonReaction(Snowflake< User > userID, Snowflake< Channel > channelID, Snowflake< Message > messageID, Emoji emoji)
virtual voidonDeleteReaction(Snowflake< User > userID, Snowflake< Channel > channelID, Snowflake< Message > messageID, Emoji emoji)
virtual voidonDeleteAllReaction(Snowflake< Server > serverID, Snowflake< Channel > channelID, Snowflake< Message > messageID)
virtual voidonMessage(Message message)
virtual voidonServer(Server server)
virtual voidonChannel(Channel channel)
virtual voidonInteraction(Interaction interaction)
virtual voidonAppCommand(AppCommand appCommand)
virtual voidonEditAppCommand(AppCommand appCommand)
virtual voidonDeleteAppCommand(AppCommand appCommand)
virtual voidonStageInstance(StageInstance instance)
virtual voidonDeleteStageInstance(StageInstance instance)
virtual voidonEditStageInstance(StageInstance instance)
virtual voidonUnknownEvent(std::string name, const json::Value & data)
virtual voidonDispatch(const json::Value & t, json::Value & d)
virtual voidonHeartbeat()
virtual voidonHeartbeatAck()
virtual voidonInvaldSession()
virtual voidonDisconnect()
virtual voidonResume()
virtual voidonQuit()
virtual voidonRestart()
virtual voidonResponse(Response response)
virtual voidsleep(const unsigned int milliseconds)
virtual voidfileRead(const char path, std::string const file)
virtual voidtick(float deltaTime)
virtual voidonError(ErrorCode errorCode, const std::string errorMessage)
virtual voidprocessMessage(const std::string & message) override
virtual voidprocessMessage(const WebSocketMessage message) override
virtual voidprocessCloseCode(const int16_t code) override
voidheartbeat()
voidsendHeartbeat()
voidresetHeartbeatValues()
std::stringgetToken()
voidsetToken(const std::string & value)
voidstart(const std::string _token, const char maxNumOfThreads =DEFAULT_THREADS, int _shardID =0, int _shardCount =0)
virtual voidhandleFailToConnect() override
voidreconnect(const unsigned int status =4900)
virtual voidstopClient()
voidinitialize(GenericMessageReceiver *& messageProcessor) const
voidprocessMessage(GenericMessageReceiver *& messageProcessor, const std::string & message) const
voidprocessCloseCode(GenericMessageReceiver *& messageProcessor, const int16_t & code) const
virtual const time_tgetEpochTimeMillisecond()

Public Functions inherited from SleepyDiscord::GenericMessageReceiver

Name
virtual~GenericMessageReceiver() =default
virtual voidinitialize()
virtual voidhandleFailToConnect()
virtual voidprocessMessage(const std::string & message) =0
virtual voidprocessCloseCode(const int16_t )
virtual voidprocessMessage(const WebSocketMessage message)

Protected Functions inherited from SleepyDiscord::GenericMessageReceiver

Name
const time_tgetRetryDelay()

Public Attributes inherited from SleepyDiscord::GenericMessageReceiver

Name
WebsocketConnectionconnection

Protected Attributes inherited from SleepyDiscord::GenericMessageReceiver

Name
intconsecutiveReconnectsCount
TimerreconnectTimer

Public Functions Documentation​

function UWebSocketsDiscordClient​

inline UWebSocketsDiscordClient()

function UWebSocketsDiscordClient​

UWebSocketsDiscordClient(
const std::string token,
const char numOfThreads =3
)

function ~UWebSocketsDiscordClient​

~UWebSocketsDiscordClient()

function run​

virtual void run()

Reimplements: SleepyDiscord::BaseDiscordClient::run

function schedule​

virtual Timer schedule(
std::function< void()> code,
const time_t milliseconds
)

Reimplements: SleepyDiscord::BaseDiscordClient::schedule


Updated on 13 April 2022 at 18:39:59 UTC