thijn/SqMod
1
0
Fork 0
mirror of https://github.com/VCMP-SqMod/SqMod.git synced 2026-04-21 11:37:23 +02:00
Code Releases Activity

Compare commits

base: thijn/SqMod:3e75e36cdf724d4f6f50d479114dd9d769308a39
Branches Tags
thijn/SqMod:master thijn/SqMod:discord2 thijn/SqMod:discordb thijn/SqMod:legacy-db thijn/SqMod:discord
thijn/SqMod:e7c708d9 thijn/SqMod:8d15f4b6
..
compare: thijn/SqMod:discordb
Branches Tags
thijn/SqMod:master thijn/SqMod:discord2 thijn/SqMod:discordb thijn/SqMod:legacy-db thijn/SqMod:discord
thijn/SqMod:e7c708d9 thijn/SqMod:8d15f4b6

36 Commits
3e75e36cdf .. discordb

Author SHA1 Message Date
Sandu Liviu Catalin 8d93ab482c Incomplete Discord implementation. 2023-03-23 20:24:29 +02:00
Sandu Liviu Catalin e0761bf3b9 Create FindFFmpeg.cmake 2023-03-23 20:24:02 +02:00
Sandu Liviu Catalin a589fbede0 Create FindOpus.cmake 2023-03-23 20:24:00 +02:00
Sandu Liviu Catalin 6422c1aad4 Create FindSodium.cmake 2023-03-23 20:23:57 +02:00
Sandu Liviu Catalin aa8953dd8e Add a placeholder template library. 2023-03-23 20:23:35 +02:00
Sandu Liviu Catalin fa79a51c46 Remove unused files. 2023-03-23 20:23:17 +02:00
Sandu Liviu Catalin 2431f69391 Update SQLite Trace and Profile implementation. 
Don't use deprecated features.
 2023-03-23 20:22:58 +02:00
Sandu Liviu Catalin 3cd3320e02 Disable current RegEx implementation. 
POCO switched to pcre2.
 2023-03-23 20:22:12 +02:00
Sandu Liviu Catalin aca50cab7c Update CivetWeb library. 2023-03-23 20:21:27 +02:00
Sandu Liviu Catalin 5d5d5b7920 Disable CURL deprecation warnings. 2023-03-23 20:21:13 +02:00
Sandu Liviu Catalin cbd8f8b028 Add D++ library. 2023-03-23 20:20:44 +02:00
Sandu Liviu Catalin b08a024298 Add Inja template library. 2023-03-23 20:20:01 +02:00
Sandu Liviu Catalin 0ef37e977c Add nlohmann JSON library. 2023-03-23 20:19:46 +02:00
Sandu Liviu Catalin 233fc103f9 Update POCO library. 2023-03-23 20:19:11 +02:00
Sandu Liviu Catalin 8d15f4b6e9 Add a basic ID pool.
continuous-integration/drone/push Build is pending
Details
continuous-integration/drone Build is passing
Details
continuous-integration/drone/tag Build was killed
Details
2023-03-05 19:51:09 +02:00
Sandu Liviu Catalin c0d142ab34 Update sqmod.h
continuous-integration/drone/push Build was killed
Details
2023-03-05 17:12:29 +02:00
Sandu Liviu Catalin f77ec9482f Update Main.cpp 2023-03-05 17:11:38 +02:00
Sandu Liviu Catalin 4fc1e892f7 Update Core.cpp 2023-03-05 17:11:36 +02:00
Sandu Liviu Catalin 015047a935 Update Core.cpp 2023-03-05 17:00:39 +02:00
Sandu Liviu Catalin bc1fc1d245 Allow external native plug-ins to interact wit the script. 
Very primitive mechanism but better than nothing.
 2023-03-05 15:38:59 +02:00
Sandu Liviu Catalin 2a069f3040 Update CMakeLists.txt 2023-03-05 15:37:30 +02:00
Sandu Liviu Catalin d295828545 Add GetJSON method to buffer. 2023-03-05 15:37:24 +02:00
Sandu Liviu Catalin 483ac37bdb Update CMakeLists.txt
continuous-integration/drone/push Build was killed
Details
2022-10-04 02:29:05 +03:00
Sandu Liviu Catalin 78dc76e6b4 Object to typename helper. 2022-10-03 18:32:06 +03:00
Sandu Liviu Catalin e29070af49 Update Official.cpp 2022-10-03 18:31:48 +03:00
Sandu Liviu Catalin 1f25b3ea60 Update sqratUtil.h 2022-10-03 18:31:36 +03:00
Sandu Liviu Catalin 52cfa235be Update JSON.hpp
continuous-integration/drone/push Build was killed
Details
2022-10-02 21:47:20 +03:00
Sandu Liviu Catalin ec7f1183d8 Basic hooking into json parsing. 
Also allow customization of the fallback meta-method.
 2022-10-02 21:24:12 +03:00
Sandu Liviu Catalin a788e059a5 Implement _tojson meta-method for base types. 2022-09-18 15:02:39 +03:00
Sandu Liviu Catalin 5f20ffc4de Remove the manual comma. 2022-09-17 23:49:37 +03:00
Sandu Liviu Catalin 08106156c4 Don't add comma for the root container. 2022-09-17 23:42:48 +03:00
Sandu Liviu Catalin 60119ff8fa Include comma after separator braces. 2022-09-17 23:41:43 +03:00
Sandu Liviu Catalin f4720ae77a Implement custom types in JSON. 2022-09-17 23:25:16 +03:00
Sandu Liviu Catalin c9fb257f48 Update ThreadPool.hpp 2022-09-15 23:03:50 +03:00
Sandu Liviu Catalin 475a428366 Update Data.hpp 2022-09-15 23:03:44 +03:00
Sandu Liviu Catalin 42ac0e32b7 Implement JSON serialization. 
Just the basics.
 2022-09-15 23:03:38 +03:00
3196 changed files with 429809 additions and 74465 deletions
Expand all files Collapse all files
CMakeLists.txt
+9 -83
View File
@@ -1,14 +1,13 @@
cmake_minimum_required(VERSION 3.7)
cmake_minimum_required(VERSION 3.21)
project(SqMod)
# This plug-in only works on 64-bit
if(CMAKE_SIZEOF_VOID_P EQUAL 4)
message(FATAL_ERROR "SqMod does not support 32-but platforms anymore.")
message(FATAL_ERROR "SqMod does not support 32-bit platforms anymore.")
endif()
# Tell CMake where to find our scripts
set(CMAKE_MODULE_PATH ${PROJECT_SOURCE_DIR}/cmake)
set(CMAKE_MODULE_PATH ${PROJECT_SOURCE_DIR}/vendor/POCO/cmake)
set(CMAKE_MODULE_PATH ${PROJECT_SOURCE_DIR}/cmake ${PROJECT_SOURCE_DIR}/vendor/POCO/cmake)
# Several plugin options
option(ENABLE_API21 "Build for 2.1 API." OFF)
@@ -18,87 +17,14 @@ option(ENABLE_BUILTIN_MYSQL_C "Enable built-in MySQL connector library" OFF)
#option(FORCE_32BIT_BIN "Create a 32-bit executable binary if the compiler defaults to 64-bit." OFF)
# This option should only be available in certain conditions
if(WIN32 AND MINGW)
option(COPY_DEPENDENCIES "Copy deppendent DLLs into the deps folder." OFF)
option(COPY_DEPENDENCIES "Copy dependent DLLs into the deps folder." OFF)
endif()
# Discord suppport
option(ENABLE_DISCORD "Enable built-in Discord support." ON)
# C++14 is mandatory
set(CPP_STD_NUMBER 14)
include(CheckCXXCompilerFlag)
# C++ standard availability check
if(${CMAKE_CXX_COMPILER_ID} MATCHES "(GNU)+")
# Specific flags
set(CPP_STD_COMPILER_FLAG "-std=c++14")
# Don't even bother with previous version
if(CPP_STD_NUMBER LESS 20 AND NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 8.0)
check_cxx_compiler_flag(-std=c++20 HAVE_FLAG_STD_CXX20)
check_cxx_compiler_flag(-std=c++2a HAVE_FLAG_STD_CXX2A)
if(HAVE_FLAG_STD_CXX20 OR HAVE_FLAG_STD_CXX2A)
# We can use C++20
set(CPP_STD_NUMBER 20)
# Specific flags
if (HAVE_FLAG_STD_CXX2A AND NOT HAVE_FLAG_STD_CXX20)
set(CPP_STD_COMPILER_FLAG "-std=c++2a")
else()
set(CPP_STD_COMPILER_FLAG "-std=c++20")
endif()
# Need these workarounds for older CMake
if(${CMAKE_VERSION} VERSION_LESS "3.8.0")
if (NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 10.0)
set(CMAKE_CXX20_STANDARD_COMPILE_OPTION "-std=c++20")
set(CMAKE_CXX20_EXTENSION_COMPILE_OPTION "-std=gnu++20")
elseif (NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 8.0)
set(CMAKE_CXX20_STANDARD_COMPILE_OPTION "-std=c++2a")
set(CMAKE_CXX20_EXTENSION_COMPILE_OPTION "-std=gnu++2a")
endif()
endif()
endif()
endif()
# Don't even bother with previous version
if(CPP_STD_NUMBER LESS 17 AND NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 7.0)
check_cxx_compiler_flag(-std=c++17 HAVE_FLAG_STD_CXX17)
check_cxx_compiler_flag(-std=c++1z HAVE_FLAG_STD_CXX1Z)
if(HAVE_FLAG_STD_CXX17 OR HAVE_FLAG_STD_CXX1Z)
# We can use C++17
set(CPP_STD_NUMBER 17)
# Specific flags
if (HAVE_FLAG_STD_CXX1Z AND NOT HAVE_FLAG_STD_CXX17)
set(CPP_STD_COMPILER_FLAG "-std=c++1z")
else()
set(CPP_STD_COMPILER_FLAG "-std=c++17")
endif()
# Need these workarounds for older CMake
if(${CMAKE_VERSION} VERSION_LESS "3.8.0")
if (NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 8.0)
set(CMAKE_CXX17_STANDARD_COMPILE_OPTION "-std=c++17")
set(CMAKE_CXX17_EXTENSION_COMPILE_OPTION "-std=gnu++17")
elseif (NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 5.1)
set(CMAKE_CXX17_STANDARD_COMPILE_OPTION "-std=c++1z")
set(CMAKE_CXX17_EXTENSION_COMPILE_OPTION "-std=gnu++1z")
endif()
endif()
endif()
endif()
else()
# C++14 is mandatory
set(CPP_STD_NUMBER 14)
endif()
message(STATUS "SqMod: Using C++${CPP_STD_NUMBER} standard.")
# Default to the identified standard
if(CMAKE_VERSION VERSION_LESS "3.1")
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${CPP_STD_COMPILER_FLAG}")
else()
# Apparently the above does not work with cmake from on debian 8
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${CPP_STD_COMPILER_FLAG}")
# F* you too Debian. What can I say.
if(CMAKE_VERSION VERSION_LESS "3.8.0" AND CPP_STD_NUMBER LESS 17)
# Try the standard method as well
set(CMAKE_CXX_STANDARD ${CPP_STD_NUMBER})
set(CMAKE_CXX_STANDARD_REQUIRED ON)
endif()
endif()
# C++17 is mandatory (globally)
set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
# Strip binary
set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} -s -g")
cmake/FindFFmpeg.cmake
+152
View File
@@ -0,0 +1,152 @@
# vim: ts=2 sw=2
# - Try to find the required ffmpeg components(default: AVFORMAT, AVUTIL, AVCODEC)
#
# Once done this will define
# FFMPEG_FOUND - System has the all required components.
# FFMPEG_INCLUDE_DIRS - Include directory necessary for using the required components headers.
# FFMPEG_LIBRARIES - Link these to use the required ffmpeg components.
# FFMPEG_DEFINITIONS - Compiler switches required for using the required ffmpeg components.
#
# For each of the components it will additionally set.
# - AVCODEC
# - AVDEVICE
# - AVFORMAT
# - AVFILTER
# - AVUTIL
# - POSTPROC
# - SWSCALE
# - SWRESAMPLE
# the following variables will be defined
# <component>_FOUND - System has <component>
# <component>_INCLUDE_DIRS - Include directory necessary for using the <component> headers
# <component>_LIBRARIES - Link these to use <component>
# <component>_DEFINITIONS - Compiler switches required for using <component>
# <component>_VERSION - The components version
#
# Copyright (c) 2006, Matthias Kretz, <kretz@kde.org>
# Copyright (c) 2008, Alexander Neundorf, <neundorf@kde.org>
# Copyright (c) 2011, Michael Jansen, <kde@michael-jansen.biz>
#
# Redistribution and use is allowed according to the terms of the BSD license.
# For details see the accompanying COPYING-CMAKE-SCRIPTS file.
include(FindPackageHandleStandardArgs)
# The default components were taken from a survey over other FindFFMPEG.cmake files
if (NOT FFmpeg_FIND_COMPONENTS)
set(FFmpeg_FIND_COMPONENTS AVCODEC AVFORMAT AVUTIL)
endif ()
#
### Macro: set_component_found
#
# Marks the given component as found if both *_LIBRARIES AND *_INCLUDE_DIRS is present.
#
macro(set_component_found _component )
if (${_component}_LIBRARIES AND ${_component}_INCLUDE_DIRS)
# message(STATUS " - ${_component} found.")
set(${_component}_FOUND TRUE)
else ()
# message(STATUS " - ${_component} not found.")
endif ()
endmacro()
#
### Macro: find_component
#
# Checks for the given component by invoking pkgconfig and then looking up the libraries and
# include directories.
#
macro(find_component _component _pkgconfig _library _header)
if (NOT WIN32)
# use pkg-config to get the directories and then use these values
# in the FIND_PATH() and FIND_LIBRARY() calls
find_package(PkgConfig)
if (PKG_CONFIG_FOUND)
pkg_check_modules(PC_${_component} ${_pkgconfig})
endif ()
endif (NOT WIN32)
find_path(${_component}_INCLUDE_DIRS ${_header}
HINTS
${PC_${_component}_INCLUDEDIR}
${PC_${_component}_INCLUDE_DIRS}
PATH_SUFFIXES
ffmpeg
)
find_library(${_component}_LIBRARIES NAMES ${_library}
HINTS
${PC_${_component}_LIBDIR}
${PC_${_component}_LIBRARY_DIRS}
)
set(${_component}_DEFINITIONS ${PC_${_component}_CFLAGS_OTHER} CACHE STRING "The ${_component} CFLAGS.")
set(${_component}_VERSION ${PC_${_component}_VERSION} CACHE STRING "The ${_component} version number.")
set_component_found(${_component})
mark_as_advanced(
${_component}_INCLUDE_DIRS
${_component}_LIBRARIES
${_component}_DEFINITIONS
${_component}_VERSION)
endmacro()
# Check for cached results. If there are skip the costly part.
if (NOT FFMPEG_LIBRARIES)
# Check for all possible component.
find_component(AVCODEC libavcodec avcodec libavcodec/avcodec.h)
find_component(AVFORMAT libavformat avformat libavformat/avformat.h)
find_component(AVDEVICE libavdevice avdevice libavdevice/avdevice.h)
find_component(AVUTIL libavutil avutil libavutil/avutil.h)
find_component(AVFILTER libavfilter avfilter libavfilter/avfilter.h)
find_component(SWSCALE libswscale swscale libswscale/swscale.h)
find_component(POSTPROC libpostproc postproc libpostproc/postprocess.h)
find_component(SWRESAMPLE libswresample swresample libswresample/swresample.h)
# Check if the required components were found and add their stuff to the FFMPEG_* vars.
foreach (_component ${FFmpeg_FIND_COMPONENTS})
if (${_component}_FOUND)
# message(STATUS "Required component ${_component} present.")
set(FFMPEG_LIBRARIES ${FFMPEG_LIBRARIES} ${${_component}_LIBRARIES})
set(FFMPEG_DEFINITIONS ${FFMPEG_DEFINITIONS} ${${_component}_DEFINITIONS})
list(APPEND FFMPEG_INCLUDE_DIRS ${${_component}_INCLUDE_DIRS})
else ()
# message(STATUS "Required component ${_component} missing.")
endif ()
endforeach ()
# Build the include path with duplicates removed.
if (FFMPEG_INCLUDE_DIRS)
list(REMOVE_DUPLICATES FFMPEG_INCLUDE_DIRS)
endif ()
# cache the vars.
set(FFMPEG_INCLUDE_DIRS ${FFMPEG_INCLUDE_DIRS} CACHE STRING "The FFmpeg include directories." FORCE)
set(FFMPEG_LIBRARIES ${FFMPEG_LIBRARIES} CACHE STRING "The FFmpeg libraries." FORCE)
set(FFMPEG_DEFINITIONS ${FFMPEG_DEFINITIONS} CACHE STRING "The FFmpeg cflags." FORCE)
mark_as_advanced(FFMPEG_INCLUDE_DIRS
FFMPEG_LIBRARIES
FFMPEG_DEFINITIONS)
endif ()
# Now set the noncached _FOUND vars for the components.
foreach (_component AVCODEC AVDEVICE AVFORMAT AVUTIL POSTPROCESS SWSCALE)
set_component_found(${_component})
endforeach ()
# Compile the list of required vars
set(_FFmpeg_REQUIRED_VARS FFMPEG_LIBRARIES FFMPEG_INCLUDE_DIRS)
foreach (_component ${FFmpeg_FIND_COMPONENTS})
list(APPEND _FFmpeg_REQUIRED_VARS ${_component}_LIBRARIES ${_component}_INCLUDE_DIRS)
endforeach ()
# Give a nice error message if some of the required vars are missing.
find_package_handle_standard_args(FFmpeg DEFAULT_MSG ${_FFmpeg_REQUIRED_VARS})
cmake/FindOpus.cmake
+36
View File
@@ -0,0 +1,36 @@
# OPUS_FOUND - system has opus
# OPUS_INCLUDE_DIRS - the opus include directory
# OPUS_LIBRARIES - The libraries needed to use opus
find_path(OPUS_INCLUDE_DIRS
NAMES opus/opus.h
PATH_SUFFIXES include
)
if(OPUS_INCLUDE_DIRS)
set(HAVE_OPUS_OPUS_H 1)
endif()
if(OPUS_USE_STATIC_LIBS)
find_library(OPUS_LIBRARIES NAMES "libopus.a")
else()
find_library(OPUS_LIBRARIES NAMES opus)
endif()
if(OPUS_LIBRARIES)
if(OPUS_USE_STATIC_LIBS)
find_library(LIBM NAMES "libm.a" "libm.tbd")
else()
find_library(LIBM NAMES m)
endif()
if(LIBM)
list(APPEND OPUS_LIBRARIES ${LIBM})
endif()
endif()
include(FindPackageHandleStandardArgs)
find_package_handle_standard_args(Opus
DEFAULT_MSG
OPUS_INCLUDE_DIRS OPUS_LIBRARIES HAVE_OPUS_OPUS_H
)
mark_as_advanced(OPUS_INCLUDE_DIRS OPUS_LIBRARIES HAVE_OPUS_OPUS_H)
cmake/FindSodium.cmake
+293
View File
@@ -0,0 +1,293 @@
# Written in 2016 by Henrik Steffen Gaßmann <henrik@gassmann.onl>
#
# To the extent possible under law, the author(s) have dedicated all copyright
# and related and neighboring rights to this software to the public domain
# worldwide. This software is distributed without any warranty.
#
# You should have received a copy of the CC0 Public Domain Dedication along with
# this software. If not, see
#
# http://creativecommons.org/publicdomain/zero/1.0/
#
# ##############################################################################
# Tries to find the local libsodium installation.
#
# On Windows the sodium_DIR environment variable is used as a default hint which
# can be overridden by setting the corresponding cmake variable.
#
# Once done the following variables will be defined:
#
# sodium_FOUND sodium_INCLUDE_DIR sodium_LIBRARY_DEBUG sodium_LIBRARY_RELEASE
# sodium_VERSION_STRING
#
# Furthermore an imported "sodium" target is created.
#
if(CMAKE_C_COMPILER_ID STREQUAL "GNU" OR CMAKE_C_COMPILER_ID STREQUAL "Clang")
set(_GCC_COMPATIBLE 1)
endif()
# static library option
if(NOT DEFINED sodium_USE_STATIC_LIBS)
option(sodium_USE_STATIC_LIBS "enable to statically link against sodium" OFF)
endif()
if(NOT (sodium_USE_STATIC_LIBS EQUAL sodium_USE_STATIC_LIBS_LAST))
unset(sodium_LIBRARY CACHE)
unset(sodium_LIBRARY_DEBUG CACHE)
unset(sodium_LIBRARY_RELEASE CACHE)
unset(sodium_DLL_DEBUG CACHE)
unset(sodium_DLL_RELEASE CACHE)
set(sodium_USE_STATIC_LIBS_LAST
${sodium_USE_STATIC_LIBS}
CACHE INTERNAL "internal change tracking variable")
endif()
# ##############################################################################
# UNIX
if(UNIX)
# import pkg-config
find_package(PkgConfig)
if(PKG_CONFIG_FOUND)
pkg_check_modules(sodium_PKG QUIET libsodium)
endif()
if(sodium_USE_STATIC_LIBS)
if(sodium_PKG_STATIC_LIBRARIES)
foreach(_libname ${sodium_PKG_STATIC_LIBRARIES})
if(NOT _libname MATCHES "^lib.*\\.a$") # ignore strings already ending
# with .a
list(INSERT sodium_PKG_STATIC_LIBRARIES 0 "lib${_libname}.a")
endif()
endforeach()
list(REMOVE_DUPLICATES sodium_PKG_STATIC_LIBRARIES)
else()
# if pkgconfig for libsodium doesn't provide static lib info, then
# override PKG_STATIC here..
set(sodium_PKG_STATIC_LIBRARIES libsodium.a)
endif()
set(XPREFIX sodium_PKG_STATIC)
else()
if(sodium_PKG_LIBRARIES STREQUAL "")
set(sodium_PKG_LIBRARIES sodium)
endif()
set(XPREFIX sodium_PKG)
endif()
find_path(sodium_INCLUDE_DIR sodium.h HINTS ${${XPREFIX}_INCLUDE_DIRS})
find_library(sodium_LIBRARY_DEBUG
NAMES ${${XPREFIX}_LIBRARIES}
HINTS ${${XPREFIX}_LIBRARY_DIRS})
find_library(sodium_LIBRARY_RELEASE
NAMES ${${XPREFIX}_LIBRARIES}
HINTS ${${XPREFIX}_LIBRARY_DIRS})
# ############################################################################
# Windows
elseif(WIN32)
set(sodium_DIR "$ENV{sodium_DIR}" CACHE FILEPATH "sodium install directory")
mark_as_advanced(sodium_DIR)
find_path(sodium_INCLUDE_DIR sodium.h
HINTS ${sodium_DIR}
PATH_SUFFIXES include)
if(MSVC)
# detect target architecture
file(WRITE "${CMAKE_CURRENT_BINARY_DIR}/arch.cpp" [=[
#if defined _M_IX86
#error ARCH_VALUE x86_32
#elif defined _M_X64
#error ARCH_VALUE x86_64
#endif
#error ARCH_VALUE unknown
]=])
try_compile(_UNUSED_VAR "${CMAKE_CURRENT_BINARY_DIR}"
"${CMAKE_CURRENT_BINARY_DIR}/arch.cpp"
OUTPUT_VARIABLE _COMPILATION_LOG)
string(REGEX
REPLACE ".*ARCH_VALUE ([a-zA-Z0-9_]+).*"
"\\1"
_TARGET_ARCH
"${_COMPILATION_LOG}")
# construct library path
if(_TARGET_ARCH STREQUAL "x86_32")
string(APPEND _PLATFORM_PATH "Win32")
elseif(_TARGET_ARCH STREQUAL "x86_64")
string(APPEND _PLATFORM_PATH "x64")
else()
message(
FATAL_ERROR
"the ${_TARGET_ARCH} architecture is not supported by Findsodium.cmake."
)
endif()
string(APPEND _PLATFORM_PATH "/$$CONFIG$$")
if(MSVC_VERSION LESS 1900)
math(EXPR _VS_VERSION "${MSVC_VERSION} / 10 - 60")
else()
math(EXPR _VS_VERSION "${MSVC_VERSION} / 10 - 50")
endif()
string(APPEND _PLATFORM_PATH "/v${_VS_VERSION}")
if(sodium_USE_STATIC_LIBS)
string(APPEND _PLATFORM_PATH "/static")
else()
string(APPEND _PLATFORM_PATH "/dynamic")
endif()
string(REPLACE "$$CONFIG$$"
"Debug"
_DEBUG_PATH_SUFFIX
"${_PLATFORM_PATH}")
string(REPLACE "$$CONFIG$$"
"Release"
_RELEASE_PATH_SUFFIX
"${_PLATFORM_PATH}")
find_library(sodium_LIBRARY_DEBUG libsodium.lib
HINTS ${sodium_DIR}
PATH_SUFFIXES ${_DEBUG_PATH_SUFFIX})
find_library(sodium_LIBRARY_RELEASE libsodium.lib
HINTS ${sodium_DIR}
PATH_SUFFIXES ${_RELEASE_PATH_SUFFIX})
if(NOT sodium_USE_STATIC_LIBS)
set(CMAKE_FIND_LIBRARY_SUFFIXES_BCK ${CMAKE_FIND_LIBRARY_SUFFIXES})
set(CMAKE_FIND_LIBRARY_SUFFIXES ".dll")
find_library(sodium_DLL_DEBUG libsodium
HINTS ${sodium_DIR}
PATH_SUFFIXES ${_DEBUG_PATH_SUFFIX})
find_library(sodium_DLL_RELEASE libsodium
HINTS ${sodium_DIR}
PATH_SUFFIXES ${_RELEASE_PATH_SUFFIX})
set(CMAKE_FIND_LIBRARY_SUFFIXES ${CMAKE_FIND_LIBRARY_SUFFIXES_BCK})
endif()
elseif(_GCC_COMPATIBLE)
if(sodium_USE_STATIC_LIBS)
find_library(sodium_LIBRARY_DEBUG libsodium.a
HINTS ${sodium_DIR}
PATH_SUFFIXES lib)
find_library(sodium_LIBRARY_RELEASE libsodium.a
HINTS ${sodium_DIR}
PATH_SUFFIXES lib)
else()
find_library(sodium_LIBRARY_DEBUG libsodium.dll.a
HINTS ${sodium_DIR}
PATH_SUFFIXES lib)
find_library(sodium_LIBRARY_RELEASE libsodium.dll.a
HINTS ${sodium_DIR}
PATH_SUFFIXES lib)
file(GLOB _DLL
LIST_DIRECTORIES false
RELATIVE "${sodium_DIR}/bin"
"${sodium_DIR}/bin/libsodium*.dll")
find_library(sodium_DLL_DEBUG ${_DLL} libsodium
HINTS ${sodium_DIR}
PATH_SUFFIXES bin)
find_library(sodium_DLL_RELEASE ${_DLL} libsodium
HINTS ${sodium_DIR}
PATH_SUFFIXES bin)
endif()
else()
message(FATAL_ERROR "this platform is not supported by FindSodium.cmake")
endif()
# ############################################################################
# unsupported
else()
message(FATAL_ERROR "this platform is not supported by FindSodium.cmake")
endif()
# ##############################################################################
# common stuff
# extract sodium version
if(sodium_INCLUDE_DIR)
set(_VERSION_HEADER "${sodium_INCLUDE_DIR}/sodium/version.h")
if(EXISTS "${_VERSION_HEADER}")
file(READ "${_VERSION_HEADER}" _VERSION_HEADER_CONTENT)
string(
REGEX
REPLACE
".*#define[ \t]*SODIUM_VERSION_STRING[ \t]*\"([^\n]*)\".*"
"\\1"
sodium_VERSION_STRING
"${_VERSION_HEADER_CONTENT}")
set(sodium_VERSION_STRING "${sodium_VERSION_STRING}")
endif()
endif()
# communicate results
include(FindPackageHandleStandardArgs)
find_package_handle_standard_args(sodium
REQUIRED_VARS
sodium_LIBRARY_RELEASE
sodium_LIBRARY_DEBUG
sodium_INCLUDE_DIR
VERSION_VAR
sodium_VERSION_STRING)
# mark file paths as advanced
mark_as_advanced(sodium_INCLUDE_DIR)
mark_as_advanced(sodium_LIBRARY_DEBUG)
mark_as_advanced(sodium_LIBRARY_RELEASE)
if(WIN32)
mark_as_advanced(sodium_DLL_DEBUG)
mark_as_advanced(sodium_DLL_RELEASE)
endif()
# create imported target
if(sodium_USE_STATIC_LIBS)
set(_LIB_TYPE STATIC)
else()
set(_LIB_TYPE SHARED)
endif()
add_library(sodium ${_LIB_TYPE} IMPORTED)
set_target_properties(sodium
PROPERTIES INTERFACE_INCLUDE_DIRECTORIES
"${sodium_INCLUDE_DIR}"
IMPORTED_LINK_INTERFACE_LANGUAGES
"C")
if(sodium_USE_STATIC_LIBS)
set_target_properties(sodium
PROPERTIES INTERFACE_COMPILE_DEFINITIONS
"SODIUM_STATIC"
IMPORTED_LOCATION
"${sodium_LIBRARY_RELEASE}"
IMPORTED_LOCATION_DEBUG
"${sodium_LIBRARY_DEBUG}")
else()
if(UNIX)
set_target_properties(sodium
PROPERTIES IMPORTED_LOCATION
"${sodium_LIBRARY_RELEASE}"
IMPORTED_LOCATION_DEBUG
"${sodium_LIBRARY_DEBUG}")
elseif(WIN32)
set_target_properties(sodium
PROPERTIES IMPORTED_IMPLIB
"${sodium_LIBRARY_RELEASE}"
IMPORTED_IMPLIB_DEBUG
"${sodium_LIBRARY_DEBUG}")
if(NOT (sodium_DLL_DEBUG MATCHES ".*-NOTFOUND"))
set_target_properties(sodium
PROPERTIES IMPORTED_LOCATION_DEBUG
"${sodium_DLL_DEBUG}")
endif()
if(NOT (sodium_DLL_RELEASE MATCHES ".*-NOTFOUND"))
set_target_properties(sodium
PROPERTIES IMPORTED_LOCATION_RELWITHDEBINFO
"${sodium_DLL_RELEASE}"
IMPORTED_LOCATION_MINSIZEREL
"${sodium_DLL_RELEASE}"
IMPORTED_LOCATION_RELEASE
"${sodium_DLL_RELEASE}")
endif()
endif()
endif()
module/Base/AABB.cpp
+17
View File
@@ -4,6 +4,7 @@
#include "Base/DynArg.hpp"
#include "Core/Buffer.hpp"
#include "Core/Utility.hpp"
#include "Library/JSON.hpp"
// ------------------------------------------------------------------------------------------------
namespace SqMod {
@@ -300,6 +301,21 @@ String AABB::ToString() const
return fmt::format("{},{},{},{},{},{}", min.x, min.y, min.z, max.x, max.y, max.z);
}
// ------------------------------------------------------------------------------------------------
void AABB::ToJSON(CtxJSON & ctx) const
{
if (ctx.mObjectOverArray)
{
fmt::format_to(std::back_inserter(ctx.mOutput), "{{min:{{x:{},y:{},z:{}}},max:{{x:{},y:{},z:{}}},",
min.x, min.y, min.z, max.x, max.y, max.z);
}
else
{
fmt::format_to(std::back_inserter(ctx.mOutput), "{{min:[{},{},{}],max:[{},{},{}]}},",
min.x, min.y, min.z, max.x, max.y, max.z);
}
}
// ------------------------------------------------------------------------------------------------
void AABB::SetStr(SQChar delim, StackStrF & values)
{
@@ -793,6 +809,7 @@ void Register_AABB(HSQUIRRELVM vm)
.SquirrelFunc(_SC("cmp"), &SqDynArgFwd< SqDynArgCmpFn< AABB >, SQFloat, SQInteger, bool, std::nullptr_t, AABB >)
.SquirrelFunc(_SC("_typename"), &Typename::Fn)
.Func(_SC("_tostring"), &AABB::ToString)
.Func(_SC("_tojson"), &AABB::ToJSON)
// Meta-methods
.SquirrelFunc(_SC("_add"), &SqDynArgFwd< SqDynArgAddFn< AABB >, SQFloat, SQInteger, bool, std::nullptr_t, AABB >)
.SquirrelFunc(_SC("_sub"), &SqDynArgFwd< SqDynArgSubFn< AABB >, SQFloat, SQInteger, bool, std::nullptr_t, AABB >)
module/Base/AABB.hpp
+5
View File
@@ -304,6 +304,11 @@ struct AABB
*/
SQMOD_NODISCARD String ToString() const;
/* --------------------------------------------------------------------------------------------
* Used by the script engine to convert an instance of this type to a JSON string.
*/
void ToJSON(CtxJSON & ctx) const;
/* --------------------------------------------------------------------------------------------
* Set the values extracted from the specified string using the specified delimiter.
*/
module/Base/Circle.cpp
+15
View File
@@ -3,6 +3,7 @@
#include "Base/DynArg.hpp"
#include "Core/Buffer.hpp"
#include "Core/Utility.hpp"
#include "Library/JSON.hpp"
#include "Library/Numeric/Random.hpp"
// ------------------------------------------------------------------------------------------------
@@ -360,6 +361,19 @@ String Circle::ToString() const
return fmt::format("{},{},{}", pos.x, pos.y, rad);
}
// ------------------------------------------------------------------------------------------------
void Circle::ToJSON(CtxJSON & ctx) const
{
if (ctx.mObjectOverArray)
{
fmt::format_to(std::back_inserter(ctx.mOutput), "{{x:{},y:{},r:{}}},", pos.x, pos.y, rad);
}
else
{
fmt::format_to(std::back_inserter(ctx.mOutput), "[{},{},{}],", pos.x, pos.y, rad);
}
}
// ------------------------------------------------------------------------------------------------
void Circle::SetRadius(Value nr)
{
@@ -552,6 +566,7 @@ void Register_Circle(HSQUIRRELVM vm)
.SquirrelFunc(_SC("cmp"), &SqDynArgFwd< SqDynArgCmpFn< Circle >, SQFloat, SQInteger, bool, std::nullptr_t, Circle >)
.SquirrelFunc(_SC("_typename"), &Typename::Fn)
.Func(_SC("_tostring"), &Circle::ToString)
.Func(_SC("_toJSON"), &Circle::ToJSON)
// Meta-methods
.SquirrelFunc(_SC("_add"), &SqDynArgFwd< SqDynArgAddFn< Circle >, SQFloat, SQInteger, bool, std::nullptr_t, Circle >)
.SquirrelFunc(_SC("_sub"), &SqDynArgFwd< SqDynArgSubFn< Circle >, SQFloat, SQInteger, bool, std::nullptr_t, Circle >)
module/Base/Circle.hpp
+5
View File
@@ -341,6 +341,11 @@ struct Circle
*/
SQMOD_NODISCARD String ToString() const;
/* --------------------------------------------------------------------------------------------
* Used by the script engine to convert an instance of this type to a JSON string.
*/
void ToJSON(CtxJSON & ctx) const;
/* --------------------------------------------------------------------------------------------
* Set the specified radius.
*/
module/Base/Color3.cpp
+15
View File
@@ -4,6 +4,7 @@
#include "Base/DynArg.hpp"
#include "Core/Buffer.hpp"
#include "Core/Utility.hpp"
#include "Library/JSON.hpp"
#include "Library/Numeric/Random.hpp"
// ------------------------------------------------------------------------------------------------
@@ -481,6 +482,19 @@ String Color3::ToString() const
return fmt::format("{},{},{}", r, g, b);
}
// ------------------------------------------------------------------------------------------------
void Color3::ToJSON(CtxJSON & ctx) const
{
if (ctx.mObjectOverArray)
{
fmt::format_to(std::back_inserter(ctx.mOutput), "{{r:{},g:{},b:{}}},", r, g, b);
}
else
{
fmt::format_to(std::back_inserter(ctx.mOutput), "[{},{},{}],", r, g, b);
}
}
// ------------------------------------------------------------------------------------------------
void Color3::SetScalar(Value ns)
{
@@ -741,6 +755,7 @@ void Register_Color3(HSQUIRRELVM vm)
.SquirrelFunc(_SC("cmp"), &SqDynArgFwd< SqDynArgCmpFn< Color3 >, SQFloat, SQInteger, bool, std::nullptr_t, Color3 >)
.SquirrelFunc(_SC("_typename"), &Typename::Fn)
.Func(_SC("_tostring"), &Color3::ToString)
.Func(_SC("_tojson"), &Color3::ToJSON)
// Meta-methods
.SquirrelFunc(_SC("_add"), &SqDynArgFwd< SqDynArgAddFn< Color3 >, SQFloat, SQInteger, bool, std::nullptr_t, Color3 >)
.SquirrelFunc(_SC("_sub"), &SqDynArgFwd< SqDynArgSubFn< Color3 >, SQFloat, SQInteger, bool, std::nullptr_t, Color3 >)
module/Base/Color3.hpp
+5
View File
@@ -405,6 +405,11 @@ struct Color3
*/
SQMOD_NODISCARD String ToString() const;
/* --------------------------------------------------------------------------------------------
* Used by the script engine to convert an instance of this type to a JSON string.
*/
void ToJSON(CtxJSON & ctx) const;
/* --------------------------------------------------------------------------------------------
* Set all components to the specified scalar value.
*/
module/Base/Color4.cpp
+15
View File
@@ -4,6 +4,7 @@
#include "Base/DynArg.hpp"
#include "Core/Buffer.hpp"
#include "Core/Utility.hpp"
#include "Library/JSON.hpp"
#include "Library/Numeric/Random.hpp"
// ------------------------------------------------------------------------------------------------
@@ -506,6 +507,19 @@ String Color4::ToString() const
return fmt::format("{},{},{},{}", r, g, b, a);
}
// ------------------------------------------------------------------------------------------------
void Color4::ToJSON(CtxJSON & ctx) const
{
if (ctx.mObjectOverArray)
{
fmt::format_to(std::back_inserter(ctx.mOutput), "{{r:{},g:{},b:{},a:{}}},", r, g, b, a);
}
else
{
fmt::format_to(std::back_inserter(ctx.mOutput), "[{},{},{},{}],", r, g, b, a);
}
}
// ------------------------------------------------------------------------------------------------
void Color4::SetScalar(Value ns)
{
@@ -781,6 +795,7 @@ void Register_Color4(HSQUIRRELVM vm)
.SquirrelFunc(_SC("cmp"), &SqDynArgFwd< SqDynArgCmpFn< Color4 >, SQFloat, SQInteger, bool, std::nullptr_t, Color4 >)
.SquirrelFunc(_SC("_typename"), &Typename::Fn)
.Func(_SC("_tostring"), &Color4::ToString)
.Func(_SC("_tojson"), &Color4::ToJSON)
// Meta-methods
.SquirrelFunc(_SC("_add"), &SqDynArgFwd< SqDynArgAddFn< Color4 >, SQFloat, SQInteger, bool, std::nullptr_t, Color4 >)
.SquirrelFunc(_SC("_sub"), &SqDynArgFwd< SqDynArgSubFn< Color4 >, SQFloat, SQInteger, bool, std::nullptr_t, Color4 >)
module/Base/Color4.hpp
+5
View File
@@ -405,6 +405,11 @@ struct Color4
*/
SQMOD_NODISCARD String ToString() const;
/* --------------------------------------------------------------------------------------------
* Used by the script engine to convert an instance of this type to a JSON string.
*/
void ToJSON(CtxJSON & ctx) const;
/* --------------------------------------------------------------------------------------------
* Set all components to the specified scalar value.
*/
module/Base/Quaternion.cpp
+15
View File
@@ -5,6 +5,7 @@
#include "Base/DynArg.hpp"
#include "Core/Buffer.hpp"
#include "Core/Utility.hpp"
#include "Library/JSON.hpp"
#include "Library/Numeric/Random.hpp"
// ------------------------------------------------------------------------------------------------
@@ -349,6 +350,19 @@ String Quaternion::ToString() const
return fmt::format("{},{},{},{}", x, y, z, w);
}
// ------------------------------------------------------------------------------------------------
void Quaternion::ToJSON(CtxJSON & ctx) const
{
if (ctx.mObjectOverArray)
{
fmt::format_to(std::back_inserter(ctx.mOutput), "{{x:{},y:{},z:{},w:{}}},", x, y, z, w);
}
else
{
fmt::format_to(std::back_inserter(ctx.mOutput), "[{},{},{},{}],", x, y, z, w);
}
}
// ------------------------------------------------------------------------------------------------
void Quaternion::SetScalar(Value ns)
{
@@ -775,6 +789,7 @@ void Register_Quaternion(HSQUIRRELVM vm)
.SquirrelFunc(_SC("cmp"), &SqDynArgFwd< SqDynArgCmpFn< Quaternion >, SQFloat, SQInteger, bool, std::nullptr_t, Quaternion >)
.SquirrelFunc(_SC("_typename"), &Typename::Fn)
.Func(_SC("_tostring"), &Quaternion::ToString)
.Func(_SC("_tojson"), &Quaternion::ToJSON)
// Meta-methods
.SquirrelFunc(_SC("_add"), &SqDynArgFwd< SqDynArgAddFn< Quaternion >, SQFloat, SQInteger, bool, std::nullptr_t, Quaternion >)
.SquirrelFunc(_SC("_sub"), &SqDynArgFwd< SqDynArgSubFn< Quaternion >, SQFloat, SQInteger, bool, std::nullptr_t, Quaternion >)
module/Base/Quaternion.hpp
+5
View File
@@ -296,6 +296,11 @@ struct Quaternion
*/
SQMOD_NODISCARD String ToString() const;
/* --------------------------------------------------------------------------------------------
* Used by the script engine to convert an instance of this type to a JSON string.
*/
void ToJSON(CtxJSON & ctx) const;
/* --------------------------------------------------------------------------------------------
* Set all components to the specified scalar value.
*/
module/Base/Shared.hpp
+3
View File
@@ -6,6 +6,9 @@
// ------------------------------------------------------------------------------------------------
namespace SqMod {
// ------------------------------------------------------------------------------------------------
struct CtxJSON;
/* ------------------------------------------------------------------------------------------------
* Helper constants used by the bas types.
*/
module/Base/Sphere.cpp
+15
View File
@@ -3,6 +3,7 @@
#include "Base/DynArg.hpp"
#include "Core/Buffer.hpp"
#include "Core/Utility.hpp"
#include "Library/JSON.hpp"
#include "Library/Numeric/Random.hpp"
// ------------------------------------------------------------------------------------------------
@@ -360,6 +361,19 @@ String Sphere::ToString() const
return fmt::format("{},{},{},{}", pos.x, pos.y, pos.z, rad);
}
// ------------------------------------------------------------------------------------------------
void Sphere::ToJSON(CtxJSON & ctx) const
{
if (ctx.mObjectOverArray)
{
fmt::format_to(std::back_inserter(ctx.mOutput), "{{x:{},y:{},z:{},r:{}}},", pos.x, pos.y, pos.z, rad);
}
else
{
fmt::format_to(std::back_inserter(ctx.mOutput), "[{},{},{},{}],", pos.x, pos.y, pos.z, rad);
}
}
// ------------------------------------------------------------------------------------------------
void Sphere::SetRadius(Value nr)
{
@@ -527,6 +541,7 @@ void Register_Sphere(HSQUIRRELVM vm)
.SquirrelFunc(_SC("cmp"), &SqDynArgFwd< SqDynArgCmpFn< Sphere >, SQFloat, SQInteger, bool, std::nullptr_t, Sphere >)
.SquirrelFunc(_SC("_typename"), &Typename::Fn)
.Func(_SC("_tostring"), &Sphere::ToString)
.Func(_SC("_tojson"), &Sphere::ToJSON)
// Meta-methods
.SquirrelFunc(_SC("_add"), &SqDynArgFwd< SqDynArgAddFn< Sphere >, SQFloat, SQInteger, bool, std::nullptr_t, Sphere >)
.SquirrelFunc(_SC("_sub"), &SqDynArgFwd< SqDynArgSubFn< Sphere >, SQFloat, SQInteger, bool, std::nullptr_t, Sphere >)
module/Base/Sphere.hpp
+5
View File
@@ -341,6 +341,11 @@ struct Sphere
*/
SQMOD_NODISCARD String ToString() const;
/* --------------------------------------------------------------------------------------------
* Used by the script engine to convert an instance of this type to a JSON string.
*/
void ToJSON(CtxJSON & ctx) const;
/* --------------------------------------------------------------------------------------------
* Set the specified radius.
*/
module/Base/Vector2.cpp
+15
View File
@@ -4,6 +4,7 @@
#include "Base/DynArg.hpp"
#include "Core/Buffer.hpp"
#include "Core/Utility.hpp"
#include "Library/JSON.hpp"
#include "Library/Numeric/Random.hpp"
// ------------------------------------------------------------------------------------------------
@@ -295,6 +296,19 @@ String Vector2::ToString() const
return fmt::format("{},{}", x, y);
}
// ------------------------------------------------------------------------------------------------
void Vector2::ToJSON(CtxJSON & ctx) const
{
if (ctx.mObjectOverArray)
{
fmt::format_to(std::back_inserter(ctx.mOutput), "{{x:{},y:{}}},", x, y);
}
else
{
fmt::format_to(std::back_inserter(ctx.mOutput), "[{},{}],", x, y);
}
}
// ------------------------------------------------------------------------------------------------
void Vector2::SetScalar(Value ns)
{
@@ -428,6 +442,7 @@ void Register_Vector2(HSQUIRRELVM vm)
.SquirrelFunc(_SC("cmp"), &SqDynArgFwd< SqDynArgCmpFn< Vector2 >, SQFloat, SQInteger, bool, std::nullptr_t, Vector2 >)
.SquirrelFunc(_SC("_typename"), &Typename::Fn)
.Func(_SC("_tostring"), &Vector2::ToString)
.Func(_SC("_tojson"), &Vector2::ToJSON)
// Meta-methods
.SquirrelFunc(_SC("_add"), &SqDynArgFwd< SqDynArgAddFn< Vector2 >, SQFloat, SQInteger, bool, std::nullptr_t, Vector2 >)
.SquirrelFunc(_SC("_sub"), &SqDynArgFwd< SqDynArgSubFn< Vector2 >, SQFloat, SQInteger, bool, std::nullptr_t, Vector2 >)
module/Base/Vector2.hpp
+5
View File
@@ -285,6 +285,11 @@ struct Vector2
*/
SQMOD_NODISCARD String ToString() const;
/* --------------------------------------------------------------------------------------------
* Used by the script engine to convert an instance of this type to a JSON string.
*/
void ToJSON(CtxJSON & ctx) const;
/* --------------------------------------------------------------------------------------------
* Set all components to the specified scalar value.
*/
module/Base/Vector2i.cpp
+15
View File
@@ -4,6 +4,7 @@
#include "Base/DynArg.hpp"
#include "Core/Buffer.hpp"
#include "Core/Utility.hpp"
#include "Library/JSON.hpp"
#include "Library/Numeric/Random.hpp"
// ------------------------------------------------------------------------------------------------
@@ -441,6 +442,19 @@ String Vector2i::ToString() const
return fmt::format("{},{}", x, y);
}
// ------------------------------------------------------------------------------------------------
void Vector2i::ToJSON(CtxJSON & ctx) const
{
if (ctx.mObjectOverArray)
{
fmt::format_to(std::back_inserter(ctx.mOutput), "{{x:{},y:{}}},", x, y);
}
else
{
fmt::format_to(std::back_inserter(ctx.mOutput), "[{},{}],", x, y);
}
}
// ------------------------------------------------------------------------------------------------
void Vector2i::SetScalar(Value ns)
{
@@ -574,6 +588,7 @@ void Register_Vector2i(HSQUIRRELVM vm)
.SquirrelFunc(_SC("cmp"), &SqDynArgFwd< SqDynArgCmpFn< Vector2i >, SQFloat, SQInteger, bool, std::nullptr_t, Vector2i >)
.SquirrelFunc(_SC("_typename"), &Typename::Fn)
.Func(_SC("_tostring"), &Vector2i::ToString)
.Func(_SC("_tojson"), &Vector2i::ToJSON)
// Meta-methods
.SquirrelFunc(_SC("_add"), &SqDynArgFwd< SqDynArgAddFn< Vector2i >, SQFloat, SQInteger, bool, std::nullptr_t, Vector2i >)
.SquirrelFunc(_SC("_sub"), &SqDynArgFwd< SqDynArgSubFn< Vector2i >, SQFloat, SQInteger, bool, std::nullptr_t, Vector2i >)
module/Base/Vector2i.hpp
+5
View File
@@ -390,6 +390,11 @@ struct Vector2i
*/
SQMOD_NODISCARD String ToString() const;
/* --------------------------------------------------------------------------------------------
* Used by the script engine to convert an instance of this type to a JSON string.
*/
void ToJSON(CtxJSON & ctx) const;
/* --------------------------------------------------------------------------------------------
* Set all components to the specified scalar value.
*/
module/Base/Vector3.cpp
+15
View File
@@ -5,6 +5,7 @@
#include "Base/DynArg.hpp"
#include "Core/Buffer.hpp"
#include "Core/Utility.hpp"
#include "Library/JSON.hpp"
#include "Library/Numeric/Random.hpp"
// ------------------------------------------------------------------------------------------------
@@ -331,6 +332,19 @@ String Vector3::ToString() const
return fmt::format("{},{},{}", x, y, z);
}
// ------------------------------------------------------------------------------------------------
void Vector3::ToJSON(CtxJSON & ctx) const
{
if (ctx.mObjectOverArray)
{
fmt::format_to(std::back_inserter(ctx.mOutput), "{{x:{},y:{},z:{}}},", x, y, z);
}
else
{
fmt::format_to(std::back_inserter(ctx.mOutput), "[{},{},{}],", x, y, z);
}
}
// ------------------------------------------------------------------------------------------------
void Vector3::SetScalar(Value ns)
{
@@ -696,6 +710,7 @@ void Register_Vector3(HSQUIRRELVM vm)
.SquirrelFunc(_SC("cmp"), &SqDynArgFwd< SqDynArgCmpFn< Vector3 >, SQFloat, SQInteger, bool, std::nullptr_t, Vector3 >)
.SquirrelFunc(_SC("_typename"), &Typename::Fn)
.Func(_SC("_tostring"), &Vector3::ToString)
.Func(_SC("_tojson"), &Vector3::ToJSON)
// Meta-methods
.SquirrelFunc(_SC("_add"), &SqDynArgFwd< SqDynArgAddFn< Vector3 >, SQFloat, SQInteger, bool, std::nullptr_t, Vector3 >)
.SquirrelFunc(_SC("_sub"), &SqDynArgFwd< SqDynArgSubFn< Vector3 >, SQFloat, SQInteger, bool, std::nullptr_t, Vector3 >)
module/Base/Vector3.hpp
+5
View File
@@ -297,6 +297,11 @@ struct Vector3
*/
SQMOD_NODISCARD String ToString() const;
/* --------------------------------------------------------------------------------------------
* Used by the script engine to convert an instance of this type to a JSON string.
*/
void ToJSON(CtxJSON & ctx) const;
/* --------------------------------------------------------------------------------------------
* Set all components to the specified scalar value.
*/
module/Base/Vector4.cpp
+15
View File
@@ -5,6 +5,7 @@
#include "Base/DynArg.hpp"
#include "Core/Buffer.hpp"
#include "Core/Utility.hpp"
#include "Library/JSON.hpp"
#include "Library/Numeric/Random.hpp"
// ------------------------------------------------------------------------------------------------
@@ -344,6 +345,19 @@ String Vector4::ToString() const
return fmt::format("{},{},{},{}", x, y, z, w);
}
// ------------------------------------------------------------------------------------------------
void Vector4::ToJSON(CtxJSON & ctx) const
{
if (ctx.mObjectOverArray)
{
fmt::format_to(std::back_inserter(ctx.mOutput), "{{x:{},y:{},z:{},w:{}}},", x, y, z, w);
}
else
{
fmt::format_to(std::back_inserter(ctx.mOutput), "[{},{},{},{}],", x, y, z, w);
}
}
// ------------------------------------------------------------------------------------------------
void Vector4::SetScalar(Value ns)
{
@@ -526,6 +540,7 @@ void Register_Vector4(HSQUIRRELVM vm)
.SquirrelFunc(_SC("cmp"), &SqDynArgFwd< SqDynArgCmpFn< Vector4 >, SQFloat, SQInteger, bool, std::nullptr_t, Vector4 >)
.SquirrelFunc(_SC("_typename"), &Typename::Fn)
.Func(_SC("_tostring"), &Vector4::ToString)
.Func(_SC("_tojson"), &Vector4::ToJSON)
// Meta-methods
.SquirrelFunc(_SC("_add"), &SqDynArgFwd< SqDynArgAddFn< Vector4 >, SQFloat, SQInteger, bool, std::nullptr_t, Vector4 >)
.SquirrelFunc(_SC("_sub"), &SqDynArgFwd< SqDynArgSubFn< Vector4 >, SQFloat, SQInteger, bool, std::nullptr_t, Vector4 >)
module/Base/Vector4.hpp
+5
View File
@@ -295,6 +295,11 @@ struct Vector4
*/
SQMOD_NODISCARD String ToString() const;
/* --------------------------------------------------------------------------------------------
* Used by the script engine to convert an instance of this type to a JSON string.
*/
void ToJSON(CtxJSON & ctx) const;
/* --------------------------------------------------------------------------------------------
* Set all components to the specified scalar value.
*/
module/CMakeLists.txt
+46 -8
View File
@@ -1,5 +1,7 @@
# Create the Squirrel module
add_library(SqModule MODULE SqBase.hpp Main.cpp
# SDK
SDK/sqmod.h
# VCMP
VCMP/vcmp.h
VCMP/vcmp20.h
@@ -90,6 +92,7 @@ add_library(SqModule MODULE SqBase.hpp Main.cpp
Library/Utils.cpp Library/Utils.hpp
Library/Utils/Announce.cpp Library/Utils/Announce.hpp
Library/Utils/String.cpp Library/Utils/String.hpp
Library/Utils/Template.cpp Library/Utils/Template.hpp
Library/Utils/Vector.cpp Library/Utils/Vector.hpp
Library/XML.cpp Library/XML.hpp
Library/ZMQ.cpp Library/ZMQ.hpp
@@ -114,7 +117,10 @@ add_library(SqModule MODULE SqBase.hpp Main.cpp
Core.cpp Core.hpp
Logger.cpp Logger.hpp
Register.cpp
Exports.cpp
)
# The module requires C++ 17
set_property(TARGET SqModule PROPERTY CXX_STANDARD 17)
# Various definitions required by the plug-in
target_compile_definitions(SqModule PRIVATE SCRAT_USE_EXCEPTIONS=1)
# SDK targeting
@@ -132,7 +138,7 @@ if(WIN32 OR MINGW)
target_link_libraries(SqModule wsock32 ws2_32 shlwapi)
endif()
# Link to base libraries
target_link_libraries(SqModule RPMalloc Squirrel fmt::fmt SimpleINI TinyDir xxHash ConcurrentQueue SAJSON CPR UTF8Lib PUGIXML CivetWeb maxminddb libzmq-static)
target_link_libraries(SqModule RPMalloc Squirrel fmt::fmt SimpleINI TinyDir xxHash ConcurrentQueue SAJSON CPR UTF8Lib PUGIXML CivetWeb inja maxminddb libzmq-static)
# Link to POCO libraries
target_link_libraries(SqModule Poco::Foundation Poco::Crypto Poco::Data Poco::Net)
# Does POCO have SQLite support?
@@ -171,6 +177,31 @@ if(POSTGRESQL_FOUND)
# Inform the plug-in that it can make use of this library
target_compile_definitions(SqModule PRIVATE SQMOD_POCO_HAS_POSTGRESQL=1)
endif()
# Is Discord support enabled?
if(ENABLE_DISCORD)
target_link_libraries(SqModule dpp)
target_sources(SqModule PRIVATE
Library/Discord.cpp Library/Discord.hpp
Library/Discord/Application.hpp Library/Discord/Application.cpp
Library/Discord/Automod.hpp Library/Discord/Automod.cpp
Library/Discord/Channel.hpp Library/Discord/Channel.cpp
Library/Discord/Client.hpp Library/Discord/Client.cpp
Library/Discord/Cluster.hpp Library/Discord/Cluster.cpp
Library/Discord/Command.hpp Library/Discord/Command.cpp
Library/Discord/Constants.hpp Library/Discord/Constants.cpp
Library/Discord/Events.hpp Library/Discord/Events.cpp
Library/Discord/Guild.hpp Library/Discord/Guild.cpp
Library/Discord/Integration.hpp Library/Discord/Integration.cpp
Library/Discord/Message.hpp Library/Discord/Message.cpp
Library/Discord/Misc.hpp Library/Discord/Misc.cpp
Library/Discord/Presence.hpp Library/Discord/Presence.cpp
Library/Discord/Role.hpp Library/Discord/Role.cpp
Library/Discord/User.hpp Library/Discord/User.cpp
Library/Discord/Utilities.hpp Library/Discord/Utilities.cpp
)
# Inform the plug-in that discord is enabled
target_compile_definitions(SqModule PRIVATE SQMOD_DISCORD=1)
endif()
# Determine if build mode
if(${CMAKE_BUILD_TYPE} MATCHES "(Release)+")
target_compile_definitions(SqModule PRIVATE NDEBUG=1)
@@ -201,6 +232,7 @@ else(WIN32)
endif(WIN32)
# Include current directory in the search path
target_include_directories(SqModule PRIVATE ${CMAKE_CURRENT_LIST_DIR})
target_include_directories(SqModule PRIVATE ${CMAKE_CURRENT_LIST_DIR}/SDK)
target_include_directories(SqModule PRIVATE ${CMAKE_CURRENT_LIST_DIR}/VCMP)
target_include_directories(SqModule PRIVATE ${CMAKE_CURRENT_LIST_DIR}/Sqrat)
# Include PCRE directory in the header search path
@@ -214,6 +246,12 @@ else()
endif()
# Copy module into the plug-ins folder
add_custom_command(TARGET SqModule POST_BUILD COMMAND ${CMAKE_COMMAND} -E copy_if_different $<TARGET_FILE:SqModule> "${PROJECT_SOURCE_DIR}/bin/plugins")
# Copy DPP into the bin folder
if (ENABLE_DISCORD)
if (WIN32 OR MINGW)
add_custom_command(TARGET SqModule POST_BUILD COMMAND ${CMAKE_COMMAND} -E copy_if_different $<TARGET_FILE:dpp> "${PROJECT_SOURCE_DIR}/bin")
endif()
endif()
# Copy several dependent DLLs on windows to make distribution easier (used mainly by people that distribute builds)
if(WIN32 AND MINGW AND COPY_DEPENDENCIES)
get_filename_component(MINGW_BIN_PATH ${CMAKE_C_COMPILER} DIRECTORY REALPATH)
@@ -222,12 +260,12 @@ if(WIN32 AND MINGW AND COPY_DEPENDENCIES)
endif()
# Make sure the deps folder exists
file(MAKE_DIRECTORY "${PROJECT_SOURCE_DIR}/bin/deps")
# Copy dependencies into the plug-ins folder (only so it can be distributed with the DLL)
# Copy dependencies into the deps folder (only so it can be distributed with the DLL)
file(COPY "${MINGW_BIN_PATH}/zlib1.dll" DESTINATION "${PROJECT_SOURCE_DIR}/bin/deps")
file(COPY "${MINGW_BIN_PATH}/libpq.dll" DESTINATION "${PROJECT_SOURCE_DIR}/bin/deps")
file(COPY "${MINGW_BIN_PATH}/libzstd.dll" DESTINATION "${PROJECT_SOURCE_DIR}/bin/deps")
file(COPY "${MINGW_BIN_PATH}/libpsl-5.dll" DESTINATION "${PROJECT_SOURCE_DIR}/bin/deps")
file(COPY "${MINGW_BIN_PATH}/libffi-7.dll" DESTINATION "${PROJECT_SOURCE_DIR}/bin/deps")
file(COPY "${MINGW_BIN_PATH}/libffi-8.dll" DESTINATION "${PROJECT_SOURCE_DIR}/bin/deps")
file(COPY "${MINGW_BIN_PATH}/libcurl-4.dll" DESTINATION "${PROJECT_SOURCE_DIR}/bin/deps")
file(COPY "${MINGW_BIN_PATH}/libssh2-1.dll" DESTINATION "${PROJECT_SOURCE_DIR}/bin/deps")
file(COPY "${MINGW_BIN_PATH}/libidn2-0.dll" DESTINATION "${PROJECT_SOURCE_DIR}/bin/deps")
@@ -245,17 +283,17 @@ if(WIN32 AND MINGW AND COPY_DEPENDENCIES)
file(COPY "${MINGW_BIN_PATH}/libp11-kit-0.dll" DESTINATION "${PROJECT_SOURCE_DIR}/bin/deps")
file(COPY "${MINGW_BIN_PATH}/libbrotlidec.dll" DESTINATION "${PROJECT_SOURCE_DIR}/bin/deps")
file(COPY "${MINGW_BIN_PATH}/libbrotlicommon.dll" DESTINATION "${PROJECT_SOURCE_DIR}/bin/deps")
file(COPY "${MINGW_BIN_PATH}/libunistring-2.dll" DESTINATION "${PROJECT_SOURCE_DIR}/bin/deps")
file(COPY "${MINGW_BIN_PATH}/libunistring-5.dll" DESTINATION "${PROJECT_SOURCE_DIR}/bin/deps")
file(COPY "${MINGW_BIN_PATH}/libnghttp2-14.dll" DESTINATION "${PROJECT_SOURCE_DIR}/bin/deps")
file(COPY "${MINGW_BIN_PATH}/libwinpthread-1.dll" DESTINATION "${PROJECT_SOURCE_DIR}/bin/deps")
file(COPY "${MINGW_BIN_PATH}/libstdc++-6.dll" DESTINATION "${PROJECT_SOURCE_DIR}/bin/deps")
if(CMAKE_SIZEOF_VOID_P EQUAL 8 AND NOT FORCE_32BIT_BIN)
file(COPY "${MINGW_BIN_PATH}/libgcc_s_seh-1.dll" DESTINATION "${PROJECT_SOURCE_DIR}/bin/deps")
file(COPY "${MINGW_BIN_PATH}/libssl-1_1-x64.dll" DESTINATION "${PROJECT_SOURCE_DIR}/bin/deps")
file(COPY "${MINGW_BIN_PATH}/libcrypto-1_1-x64.dll" DESTINATION "${PROJECT_SOURCE_DIR}/bin/deps")
file(COPY "${MINGW_BIN_PATH}/libssl-3-x64.dll" DESTINATION "${PROJECT_SOURCE_DIR}/bin/deps")
file(COPY "${MINGW_BIN_PATH}/libcrypto-3-x64.dll" DESTINATION "${PROJECT_SOURCE_DIR}/bin/deps")
else()
file(COPY "${MINGW_BIN_PATH}/libssl-1_1.dll" DESTINATION "${PROJECT_SOURCE_DIR}/bin/deps")
file(COPY "${MINGW_BIN_PATH}/libcrypto-1_1.dll" DESTINATION "${PROJECT_SOURCE_DIR}/bin/deps")
file(COPY "${MINGW_BIN_PATH}/libssl-3.dll" DESTINATION "${PROJECT_SOURCE_DIR}/bin/deps")
file(COPY "${MINGW_BIN_PATH}/libcrypto-3.dll" DESTINATION "${PROJECT_SOURCE_DIR}/bin/deps")
endif()
if(POCO_UNBUNDLED)
file(COPY "${MINGW_BIN_PATH}/libexpat-1.dll" DESTINATION "${PROJECT_SOURCE_DIR}/bin/deps")
module/Core.cpp
+123 -8
View File
@@ -49,6 +49,9 @@ extern void TerminateRoutines();
extern void TerminateCommands();
extern void TerminateSignals();
extern void TerminateNet();
#ifdef SQMOD_DISCORD
extern void TerminateDiscord();
#endif
extern void TerminatePocoNet();
extern void TerminatePocoData();
@@ -161,6 +164,7 @@ Core::Core() noexcept
, m_Scripts()
, m_PendingScripts()
, m_Options()
, m_ExtCommands{nullptr, nullptr, nullptr, nullptr}
, m_Blips()
, m_Checkpoints()
, m_KeyBinds()
@@ -441,9 +445,9 @@ bool Core::Execute()
m_LockPostLoadSignal = false;
m_LockUnloadSignal = false;
//cLogDbg(m_Verbosity >= 1, "Signaling outside plug-ins to register their API");
cLogDbg(m_Verbosity >= 1, "Signaling outside plug-ins that the API is being registered");
// Tell modules to do their monkey business
//_Func->SendPluginCommand(0xDEADBABE, "");
_Func->SendPluginCommand(SQMOD_LOAD_CMD, SQMOD_HOST_NAME);
// Load pending scripts while we're in the bounds of the allowed recursiveness
for (unsigned levels = 0; !m_PendingScripts.empty() && (levels < 8); ++levels)
@@ -511,9 +515,9 @@ void Core::Terminate(bool shutdown)
// Clear the callbacks
ResetSignalPair(mOnUnload);
//cLogDbg(m_Verbosity >= 1, "Signaling outside plug-ins to release their resources");
cLogDbg(m_Verbosity >= 1, "Signaling outside plug-ins to release their resources");
// Tell modules to do their monkey business
//_Func->SendPluginCommand(0xDEADC0DE, "");
_Func->SendPluginCommand(SQMOD_TERMINATE_CMD, SQMOD_HOST_NAME);
}
cLogDbg(m_Verbosity >= 1, "Clearing the entity containers");
@@ -552,6 +556,11 @@ void Core::Terminate(bool shutdown)
// Release network
TerminateNet();
cLogDbg(m_Verbosity >= 1, "Network terminated");
// Release DPP
#ifdef SQMOD_DISCORD
TerminateDiscord();
cLogDbg(m_Verbosity >= 1, "Discord terminated");
#endif
// Release Poco statement results
TerminatePocoNet();
TerminatePocoData();
@@ -596,9 +605,9 @@ void Core::Terminate(bool shutdown)
HSQUIRRELVM sq_vm = m_VM;
m_VM = nullptr;
//cLogDbg(m_Verbosity >= 1, "Signaling outside plug-ins the virtual machine is closing");
cLogDbg(m_Verbosity >= 1, "Signaling outside plug-ins the virtual machine is closing");
// Tell modules to do their monkey business
//_Func->SendPluginCommand(0xBAAAAAAD, "");
_Func->SendPluginCommand(SQMOD_CLOSING_CMD, SQMOD_HOST_NAME);
// Release any callbacks from the logger
Logger::Get().Release();
cLogDbg(m_Verbosity >= 2, "Closing Virtual Machine");
@@ -629,9 +638,9 @@ void Core::Terminate(bool shutdown)
// Destroy the VM context, if any
delete ctx;
//cLogDbg(m_Verbosity >= 1, "Signaling outside plug-ins to release the virtual machine");
cLogDbg(m_Verbosity >= 1, "Signaling outside plug-ins the virtual machine was closed");
// Tell modules to do their monkey business
//_Func->SendPluginCommand(0xDEADBEAF, "");
_Func->SendPluginCommand(SQMOD_RELEASED_CMD, SQMOD_HOST_NAME);
}
OutputMessage("Squirrel plug-in was successfully terminated");
@@ -904,6 +913,81 @@ String Core::FetchCodeLine(const SQChar * src, SQInteger line, bool trim)
return script->FetchLine(line, trim);
}
// ------------------------------------------------------------------------------------------------
int32_t Core::RegisterExtCommand(ExtPluginCommand_t fn)
{
ExtPluginCommand_t * slot = nullptr;
// Find a free slot or matching function pointer in the pool
for (size_t i = 0; i < m_ExtCommands.max_size(); ++i)
{
// Is this slot available and are we still looking for a slot?
if (m_ExtCommands[i] == nullptr && slot == nullptr)
{
slot = &m_ExtCommands[i]; // Found a slot
}
// We keep looking for duplicates even if we found the slot
else if (m_ExtCommands[i] == fn)
{
return 0; // Already registered
}
}
// Do we have a free slot?
if (slot != nullptr)
{
*slot = fn; // Use this slot
return 1; // Successfully registered
}
// No space in the pool
return -1;
}
// ------------------------------------------------------------------------------------------------
int32_t Core::UnregisterExtCommand(ExtPluginCommand_t fn)
{
// Find the matching function pointer
for (size_t i = 0; i < m_ExtCommands.max_size(); ++i)
{
// Is this the same pointer?
if (m_ExtCommands[i] != nullptr && m_ExtCommands[i] == fn)
{
// Forget about it
m_ExtCommands[i] = nullptr;
return 1; // Successfully unregistered
}
}
// No space
return -1;
}
// ------------------------------------------------------------------------------------------------
int32_t Core::SendExtCommand(int32_t target, int32_t req, int32_t tag, const uint8_t * data, size_t size)
{
int32_t count = 0;
// Send the command to all registered function pointers
for (size_t i = 0; i < m_ExtCommands.max_size(); ++i)
{
if (m_ExtCommands[i] != nullptr)
{
const int32_t r = m_ExtCommands[i](target, req, tag, data, size);
// Command processed
++count;
// Command failed?
if (r < 0)
{
LogErr("External command failed (%i): target(%i), req(%i), tag(%i), data(%p), size (%zu)",
r, target, req, tag, data, size);
}
// Command consumed?
else if (r > 0)
{
break; // This function pointer requested exclusive access over this command
}
}
}
// Return how many function pointers received this command
return count;
}
// ------------------------------------------------------------------------------------------------
bool Core::DoScripts(Scripts::iterator itr, Scripts::iterator end)
{
@@ -2371,6 +2455,8 @@ void Core::InitEvents()
InitSignalPair(mOnServerOption, m_Events, "ServerOption");
InitSignalPair(mOnScriptReload, m_Events, "ScriptReload");
InitSignalPair(mOnScriptLoaded, m_Events, "ScriptLoaded");
InitSignalPair(mOnExtCommandReply, m_Events, "ExtCommandReply");
InitSignalPair(mOnExtCommandEvent, m_Events, "ExtCommandEvent");
}
// ------------------------------------------------------------------------------------------------
void Core::DropEvents()
@@ -2516,6 +2602,8 @@ void Core::DropEvents()
ResetSignalPair(mOnServerOption);
ResetSignalPair(mOnScriptReload);
ResetSignalPair(mOnScriptLoaded);
ResetSignalPair(mOnExtCommandReply);
ResetSignalPair(mOnExtCommandEvent);
m_Events.Release();
}
@@ -2861,6 +2949,31 @@ static LightObj & SqGetClientDataBuffer()
return Core::Get().GetClientDataBuffer();
}
// ------------------------------------------------------------------------------------------------
static SQInteger SqSendExtCommand(int32_t target, int32_t req, int32_t tag, SqBuffer & buffer)
{
// Default to an empty/null buffer
const uint8_t * data = nullptr;
size_t size = 0;
// Does the buffer actually point to anything?
if (buffer.GetRef())
{
data = buffer.GetRef()->Begin< uint8_t >();
size = buffer.GetRef()->PositionAs< size_t >();
}
// Forward the request
return Core::Get().SendExtCommand(target, req, tag, data, size);
}
// ------------------------------------------------------------------------------------------------
static SQInteger SqSendExtCommandStr(int32_t target, int32_t req, int32_t tag, StackStrF & str)
{
// Forward the request
return Core::Get().SendExtCommand(target, req, tag,
reinterpret_cast< const uint8_t * >(str.mPtr),
str.mLen <= 0 ? 0 : static_cast< size_t >(str.mLen));
}
// ================================================================================================
void Register_Core(HSQUIRRELVM vm)
{
@@ -2910,6 +3023,8 @@ void Register_Core(HSQUIRRELVM vm)
.Func(_SC("DestroyPickup"), &SqDelPickup)
.Func(_SC("DestroyVehicle"), &SqDelVehicle)
.Func(_SC("ClientDataBuffer"), &SqGetClientDataBuffer)
.Func(_SC("SendExtCommand"), &SqSendExtCommand)
.FmtFunc(_SC("SendExtCommandStr"), &SqSendExtCommandStr)
.Func(_SC("OnPreLoad"), &SqGetPreLoadEvent)
.Func(_SC("OnPostLoad"), &SqGetPostLoadEvent)
.Func(_SC("OnUnload"), &SqGetUnloadEvent)
module/Core.hpp
+35
View File
@@ -9,6 +9,9 @@
// ------------------------------------------------------------------------------------------------
#include <unordered_map>
// ------------------------------------------------------------------------------------------------
#include "SDK/sqmod.h"
// ------------------------------------------------------------------------------------------------
namespace SqMod {
@@ -56,6 +59,8 @@ public:
typedef std::vector< ScriptSrc > Scripts; // List of loaded scripts.
// --------------------------------------------------------------------------------------------
typedef std::unordered_map< String, String > Options; // List of custom options.
// --------------------------------------------------------------------------------------------
typedef std::array< ExtPluginCommand_t, 4 > ExtCommands; // 4 external command parsers should be enough.
private:
@@ -68,6 +73,7 @@ private:
Scripts m_Scripts; // Loaded scripts objects.
Scripts m_PendingScripts; // Pending scripts objects.
Options m_Options; // Custom configuration options.
ExtCommands m_ExtCommands; // External command parsers pointers.
// --------------------------------------------------------------------------------------------
Blips m_Blips; // Blips pool.
@@ -399,6 +405,23 @@ public:
*/
SQMOD_NODISCARD String FetchCodeLine(const SQChar * src, SQInteger line, bool trim = true);
/* --------------------------------------------------------------------------------------------
* Register a pointer to a function used to processes commands from script.
* Returns -1 it failed (no free slot), 0 if it was already registered and 1 if it succeeded.
*/
int32_t RegisterExtCommand(ExtPluginCommand_t fn);
/* --------------------------------------------------------------------------------------------
* Remove a pointer to a function used to processes commands from script.
* Returns -1 it failed (no free slot) and 1 if it succeeded.
*/
int32_t UnregisterExtCommand(ExtPluginCommand_t fn);
/* --------------------------------------------------------------------------------------------
* Send a command to all functions currently registered to receive them.
*/
int32_t SendExtCommand(int32_t target, int32_t req, int32_t tag, const uint8_t * data, size_t size);
protected:
/* --------------------------------------------------------------------------------------------
@@ -710,6 +733,16 @@ public:
*/
void EmitClientScriptData(int32_t player_id, const uint8_t * data, size_t size);
/* --------------------------------------------------------------------------------------------
* Send a response to the script that may have resulted from a previous command.
*/
void EmitExtCommandReply(int32_t sender, int32_t tag, const uint8_t * data, size_t size);
/* --------------------------------------------------------------------------------------------
* Forward an event to the script from an external plug-in.
*/
void EmitExtCommandEvent(int32_t sender, int32_t tag, const uint8_t * data, size_t size);
public:
/* --------------------------------------------------------------------------------------------
@@ -864,6 +897,8 @@ public:
SignalPair mOnServerOption{};
SignalPair mOnScriptReload{};
SignalPair mOnScriptLoaded{};
SignalPair mOnExtCommandReply{};
SignalPair mOnExtCommandEvent{};
};
/* ------------------------------------------------------------------------------------------------
module/Core/Common.cpp
+8
View File
@@ -248,6 +248,14 @@ String SqTypeName(HSQUIRRELVM vm, SQInteger idx)
return String(val.mPtr, static_cast< size_t >(val.mLen));
}
// ------------------------------------------------------------------------------------------------
String SqTypeName(HSQUIRRELVM vm, LightObj & obj)
{
const StackGuard sg(vm);
sq_pushobject(vm, obj);
return SqTypeName(vm, -1);
}
// ------------------------------------------------------------------------------------------------
LightObj BufferToStrObj(const Buffer & b)
{
module/Core/Common.hpp
+5
View File
@@ -242,6 +242,11 @@ SQMOD_NODISCARD const SQChar * SqTypeName(SQObjectType type);
*/
SQMOD_NODISCARD String SqTypeName(HSQUIRRELVM vm, SQInteger idx);
/* ------------------------------------------------------------------------------------------------
* Retrieve the string representation of a certain type from a script object.
*/
SQMOD_NODISCARD String SqTypeName(HSQUIRRELVM vm, LightObj & obj);
/* ------------------------------------------------------------------------------------------------
* Create a script string instance from a buffer.
*/
module/Core/Events.inc
+39 -1
View File
@@ -347,7 +347,7 @@ void Core::EmitIncomingConnection(char * player_name, size_t name_buffer_size, c
// Release any stored buffer information
m_IncomingNameBuffer = nullptr;
m_IncomingNameCapacity = 0;
// We catched the exception so we can release the assigned buffer
// We caught the exception so we can release the assigned buffer
throw; // re-throw it
}
// Release any stored buffer information
@@ -2246,6 +2246,44 @@ void Core::EmitClientScriptData(int32_t player_id, const uint8_t * data, size_t
m_ClientData.Release();
}
// ------------------------------------------------------------------------------------------------
void Core::EmitExtCommandReply(int32_t sender, int32_t tag, const uint8_t * data, size_t size)
{
SQMOD_CO_EV_TRACEBACK("[TRACE<] Core::ExtCommandReply(%i, %i, %p, %zu)", sender, tag, data, size)
// Don't even bother if there's no one listening
if (!(mOnExtCommandReply.first->IsEmpty()))
{
// Allocate a buffer with the received size
Buffer b(static_cast< Buffer::SzType >(size));
// Replicate the data to the allocated buffer
b.Write(0, reinterpret_cast< Buffer::ConstPtr >(data), static_cast< Buffer::SzType >(size));
// Prepare an object for the obtained buffer
LightObj obj(SqTypeIdentity< SqBuffer >{}, m_VM, std::move(b));
// Forward the event call
(*mOnExtCommandReply.first)(sender, tag, obj, size);
}
SQMOD_CO_EV_TRACEBACK("[TRACE>] Core::ExtCommandReply")
}
// ------------------------------------------------------------------------------------------------
void Core::EmitExtCommandEvent(int32_t sender, int32_t tag, const uint8_t * data, size_t size)
{
SQMOD_CO_EV_TRACEBACK("[TRACE<] Core::ExtCommandEvent(%i, %i, %p, %zu)", sender, tag, data, size)
// Don't even bother if there's no one listening
if (!(mOnExtCommandEvent.first->IsEmpty()))
{
// Allocate a buffer with the received size
Buffer b(static_cast< Buffer::SzType >(size));
// Replicate the data to the allocated buffer
b.Write(0, reinterpret_cast< Buffer::ConstPtr >(data), static_cast< Buffer::SzType >(size));
// Prepare an object for the obtained buffer
LightObj obj(SqTypeIdentity< SqBuffer >{}, m_VM, std::move(b));
// Forward the event call
(*mOnExtCommandEvent.first)(sender, tag, obj, size);
}
SQMOD_CO_EV_TRACEBACK("[TRACE>] Core::ExtCommandEvent")
}
#undef NULL_SQOBJ_ // don't need this anymore
} // Namespace:: SqMod
module/Core/ThreadPool.hpp
+12 -4
View File
@@ -80,7 +80,7 @@ struct ThreadPoolItem
/* --------------------------------------------------------------------------------------------
* Invoked in main thread by the thread pool after the task was completed.
* If it returns true then it will be put back into the queue to be processed again.
* If the boolean parameter is trye then the thread-pool is in the process of shutting down.
* If the boolean parameter is true then the thread-pool is in the process of shutting down.
*/
SQMOD_NODISCARD virtual bool OnCompleted(bool SQ_UNUSED_ARG(stop)) { return false; }
@@ -110,13 +110,13 @@ private:
* Destructor.
*/
~ThreadPool();
public:
// --------------------------------------------------------------------------------------------
using Item = std::unique_ptr< ThreadPoolItem >; // Owning pointer of an item.
private:
// --------------------------------------------------------------------------------------------
using Pool = std::vector< std::thread >; // Worker container.
using Item = std::unique_ptr< ThreadPoolItem >; // Owning pointer of an item.
// --------------------------------------------------------------------------------------------
using Finished = moodycamel::ConcurrentQueue< Item >; // Finished items.
// --------------------------------------------------------------------------------------------
@@ -190,6 +190,14 @@ public:
Enqueue(Item{item});
}
/* --------------------------------------------------------------------------------------------
* Queue an item to be processed. Will take ownership of the given pointer!
*/
template < class T > void CastEnqueue(std::unique_ptr< T > && item)
{
Enqueue(Item{std::forward< std::unique_ptr< T > >(item)});
}
/* --------------------------------------------------------------------------------------------
* Queue an item to be processed. Will take ownership of the given pointer!
*/
module/Exports.cpp
+73
View File
@@ -0,0 +1,73 @@
// ------------------------------------------------------------------------------------------------
#include "Core.hpp"
// ------------------------------------------------------------------------------------------------
#include <cstring>
// ------------------------------------------------------------------------------------------------
#include <sqmod.h>
// ------------------------------------------------------------------------------------------------
namespace SqMod {
// ------------------------------------------------------------------------------------------------
static int32_t RegisterCommandFn(ExtPluginCommand_t fn)
{
return Core::Get().RegisterExtCommand(fn);
}
// ------------------------------------------------------------------------------------------------
static int32_t UnregisterCommandFn(ExtPluginCommand_t fn)
{
return Core::Get().UnregisterExtCommand(fn);
}
// ------------------------------------------------------------------------------------------------
static int32_t SendCommandFn(int32_t target, int32_t req, int32_t tag, const uint8_t * data, size_t size)
{
return Core::Get().SendExtCommand(target, req, tag, data, size);
}
// ------------------------------------------------------------------------------------------------
static int32_t SendCommandReplyFn(int32_t sender, int32_t tag, const uint8_t * data, size_t size)
{
// Mark the initialization as successful by default
const CoreState cs(SQMOD_SUCCESS);
// Forward the call to the script callbacks
Core::Get().EmitExtCommandReply(sender, tag, data, size);
// Return the last known plug-in state
return Core::Get().GetState();
}
// ------------------------------------------------------------------------------------------------
static int32_t SendCommandEventFn(int32_t sender, int32_t tag, const uint8_t * data, size_t size)
{
// Mark the initialization as successful by default
const CoreState cs(SQMOD_SUCCESS);
// Forward the call to the script callbacks
Core::Get().EmitExtCommandEvent(sender, tag, data, size);
// Return the last known plug-in state
return Core::Get().GetState();
}
// ------------------------------------------------------------------------------------------------
static const SQ_MOD_EXPORTS g_SqModExports{
sizeof(SQ_MOD_EXPORTS),
&RegisterCommandFn,
&UnregisterCommandFn,
&SendCommandFn,
&SendCommandReplyFn,
&SendCommandEventFn
};
// The server needs a pointer to a pointer, and a persistent one
static const SQ_MOD_EXPORTS * g_SqModExportsPtr = &g_SqModExports;
// ------------------------------------------------------------------------------------------------
void InitExports()
{
// Tell the server about the pointer to the exports structure
_Func->ExportFunctions(_Info->pluginId, reinterpret_cast< const void ** >(&g_SqModExportsPtr), sizeof(HSQ_MOD_EXPORTS));
}
} // Namespace:: SqMod
module/Library/Discord.cpp
+51
View File
@@ -0,0 +1,51 @@
// ------------------------------------------------------------------------------------------------
#include "Library/Discord.hpp"
#include "Library/Discord/Cluster.hpp"
// ------------------------------------------------------------------------------------------------
namespace SqMod {
// ------------------------------------------------------------------------------------------------
void TerminateDiscord()
{
// Go over all clusters and try to terminate them
for (DpCluster * inst = DpCluster::sHead; inst && inst->mNext != DpCluster::sHead; inst = inst->mNext)
{
inst->Terminate(); // Terminate the cluster
}
}
// ------------------------------------------------------------------------------------------------
void ProcessDiscord()
{
// Go over all clusters and allow them to process data
for (DpCluster * inst = DpCluster::sHead; inst && inst->mNext != DpCluster::sHead; inst = inst->mNext)
{
inst->Process();
}
}
// ------------------------------------------------------------------------------------------------
extern void Register_Discord_Constants(HSQUIRRELVM vm, Table & ns);
extern void Register_Discord_Events(HSQUIRRELVM vm, Table & ns);
extern void Register_Discord_Misc(HSQUIRRELVM vm, Table & ns);
extern void Register_Discord_Cluster(HSQUIRRELVM vm, Table & ns);
// ================================================================================================
void Register_Discord(HSQUIRRELVM vm)
{
Table ns(vm);
// --------------------------------------------------------------------------------------------
Register_Discord_Constants(vm, ns);
{
Table ens(vm);
Register_Discord_Events(vm, ens);
ns.Bind(_SC("Event"), ens);
}
Register_Discord_Misc(vm, ns);
Register_Discord_Cluster(vm, ns);
// --------------------------------------------------------------------------------------------
RootTable(vm).Bind(_SC("SqDiscord"), ns);
}
} // Namespace:: SqMod
module/Library/Discord.hpp
+17
View File
@@ -0,0 +1,17 @@
#pragma once
// ------------------------------------------------------------------------------------------------
#include "Library/IO/Buffer.hpp"
// ------------------------------------------------------------------------------------------------
#include <atomic>
// ------------------------------------------------------------------------------------------------
#include <sqratFunction.h>
#include <concurrentqueue.h>
#include <dpp/dpp.h>
// ------------------------------------------------------------------------------------------------
namespace SqMod {
} // Namespace:: SqMod
module/Library/Discord/Application.cpp
+9
View File
@@ -0,0 +1,9 @@
// ------------------------------------------------------------------------------------------------
#include "Library/Discord/Application.hpp"
// ------------------------------------------------------------------------------------------------
namespace SqMod {
} // Namespace:: SqMod
module/Library/Utils/JSON.hpp → module/Library/Discord/Application.hpp
+1 -2
View File
@@ -4,8 +4,7 @@
#include "Core/Utility.hpp"
// ------------------------------------------------------------------------------------------------
#define JSMN_HEADER
#include <jsmn.h>
#include <dpp/dpp.h>
// ------------------------------------------------------------------------------------------------
namespace SqMod {
module/Library/Discord/Automod.cpp
+9
View File
@@ -0,0 +1,9 @@
// ------------------------------------------------------------------------------------------------
#include "Library/Discord/Automod.hpp"
// ------------------------------------------------------------------------------------------------
namespace SqMod {
} // Namespace:: SqMod
module/Library/Discord/Automod.hpp
+13
View File
@@ -0,0 +1,13 @@
#pragma once
// ------------------------------------------------------------------------------------------------
#include "Core/Utility.hpp"
// ------------------------------------------------------------------------------------------------
#include <dpp/dpp.h>
// ------------------------------------------------------------------------------------------------
namespace SqMod {
} // Namespace:: SqMod
module/Library/Discord/Channel.cpp
+9
View File
@@ -0,0 +1,9 @@
// ------------------------------------------------------------------------------------------------
#include "Library/Discord/Channel.hpp"
// ------------------------------------------------------------------------------------------------
namespace SqMod {
} // Namespace:: SqMod
module/Library/Discord/Channel.hpp
+13
View File
@@ -0,0 +1,13 @@
#pragma once
// ------------------------------------------------------------------------------------------------
#include "Core/Utility.hpp"
// ------------------------------------------------------------------------------------------------
#include <dpp/dpp.h>
// ------------------------------------------------------------------------------------------------
namespace SqMod {
} // Namespace:: SqMod
module/Library/Discord/Client.cpp
+9
View File
@@ -0,0 +1,9 @@
// ------------------------------------------------------------------------------------------------
#include "Library/Discord/Client.hpp"
// ------------------------------------------------------------------------------------------------
namespace SqMod {
} // Namespace:: SqMod
module/Library/Discord/Client.hpp
+13
View File
@@ -0,0 +1,13 @@
#pragma once
// ------------------------------------------------------------------------------------------------
#include "Core/Utility.hpp"
// ------------------------------------------------------------------------------------------------
#include <dpp/dpp.h>
// ------------------------------------------------------------------------------------------------
namespace SqMod {
} // Namespace:: SqMod
module/Library/Discord/Cluster.cpp
+492
View File
@@ -0,0 +1,492 @@
// ------------------------------------------------------------------------------------------------
#include "Library/Discord/Cluster.hpp"
#include "Library/Discord/Events.hpp"
#include "Logger.hpp"
// ------------------------------------------------------------------------------------------------
namespace SqMod {
// ------------------------------------------------------------------------------------------------
SQMOD_DECL_TYPENAME(SqDpClusterTypename, _SC("SqDiscordCluster"))
SQMOD_DECL_TYPENAME(SqDpClusterOptionsTypename, _SC("SqDiscordClusterOptions"))
// ------------------------------------------------------------------------------------------------
DpCluster::DpCluster(DpClusterOptions & o)
: Base(), mQueue(4096)
, mC(std::make_unique< dpp::cluster >(o.mToken, o.mIntents, o.mShards, o.mClusterID, o.mMaxClusters, o.mCompressed, o.mPolicy, o.mRequestThreads, o.mRequestThreadsRaw))
, mSqEvents(), mEvents(), mEventsHandle()
{
// Make sure all event handles are not valid
mEventsHandle.fill(0);
// Initialize event signals
InitEvents();
// Proxy library logging to our logger
if (!o.mCustomLogging)
{
mC->on_log([](const dpp::log_t& event) {
switch (event.severity)
{
case dpp::ll_trace: Logger::Get().Send(LOGL_DBG, true, event.message.c_str(), event.message.size()); break;
case dpp::ll_debug: Logger::Get().Send(LOGL_DBG, true, event.message.c_str(), event.message.size()); break;
case dpp::ll_info: Logger::Get().Send(LOGL_INF, true, event.message.c_str(), event.message.size()); break;
case dpp::ll_warning: Logger::Get().Send(LOGL_WRN, true, event.message.c_str(), event.message.size()); break;
case dpp::ll_error: Logger::Get().Send(LOGL_ERR, true, event.message.c_str(), event.message.size()); break;
case dpp::ll_critical: Logger::Get().Send(LOGL_FTL, true, event.message.c_str(), event.message.size()); break;
default: break;
}
});
}
// Remember this instance
ChainInstance();
}
// ------------------------------------------------------------------------------------------------
SQMOD_NODISCARD LightObj EventToScriptObject(uint8_t type, uintptr_t data);
void EventInvokeCleanup(uint8_t type, uintptr_t data);
// ------------------------------------------------------------------------------------------------
void DpCluster::Process(bool force)
{
// Is there a valid connection?
if (!mC && !force)
{
return; // No point in going forward
}
EventItem event;
// Retrieve each event individually and process it
for (size_t count = mQueue.size_approx(), n = 0; n <= count; ++n)
{
// Try to get an event from the queue
if (mQueue.try_dequeue(event))
{
// Fetch the type of event
const auto id = static_cast< size_t >(event->GetEventID());
// Is this a valid event and is anyone listening to it?
if (!(event->mFrom) || !(mEvents[id].first) || mEvents[id].first->IsEmpty())
{
continue; // Move on
}
// Transform the event instance into a script object
LightObj obj = event->ToScriptObject();
// Allow the script to take ownership of the event instance now
[[maybe_unused]] auto p = event.release();
// Don't abort everything down the line for an error caused by a discord event handler
try {
(*mEvents[id].first)(obj); // Forward the call to the associated signal
} catch (const std::exception & e) {
LogErr("Squirrel exception caught in (%s) discord event", p->GetEventName().data());
LogSInf("Message: %s", e.what());
}
// Allow the event instance to clean itself (i.e. invalidate itself)
// User should not keep this event object for later use!
// Event data is accessible only during the event signal
p->Cleanup();
}
}
}
// ------------------------------------------------------------------------------------------------
void DpCluster::Terminate()
{
// Stop the cluster connection
if (mC) mC->shutdown();
// Release associated script objects
mSqEvents.Release();
// Release event signal objects
DropEvents();
// Delete the cluster instance
mC.reset();
}
// ================================================================================================
void Register_Discord_Cluster(HSQUIRRELVM vm, Table & ns)
{
ns.Bind(_SC("ClusterOptions"),
Class< DpClusterOptions >(vm, SqDpClusterOptionsTypename::Str)
// Constructors
.Ctor< StackStrF & >()
// Meta-methods
.SquirrelFunc(_SC("_typename"), &SqDpClusterOptionsTypename::Fn)
);
ns.Bind(_SC("Cluster"),
Class< DpCluster, NoCopy< DpCluster > >(vm, SqDpClusterTypename::Str)
// Constructors
.Ctor< DpClusterOptions & >()
// Meta-methods
.SquirrelFunc(_SC("_typename"), &SqDpClusterTypename::Fn)
// Member Properties
.Prop(_SC("On"), &DpCluster::GetEvents)
// Member Methods
.Func(_SC("Start"), &DpCluster::Start)
.Func(_SC("Stop"), &DpCluster::Stop)
.Func(_SC("EnableEvent"), &DpCluster::EnableEvent)
.Func(_SC("DisableEvent"), &DpCluster::DisableEvent)
);
}
// ------------------------------------------------------------------------------------------------
DpCluster & DpCluster::EnableEvent(SQInteger id)
{
// Retrieve managed cluster instance
auto & c = Valid("enable event on a");
// Assigned event handle
dpp::event_handle eh = 0;
// Make sure the specified event handle is valid
if (id >= 0 && id < static_cast< SQInteger >(DpEventID::Max))
{
eh = mEventsHandle[static_cast< size_t >(id)]; // Get the real handle
}
// Is this event already enabled?
if (eh != 0)
{
return *this; // Job already done
}
// Identify event type
switch (id)
{
case DpEventID::VoiceStateUpdate: eh = c.on_voice_state_update.attach([this](const dpp::voice_state_update_t & e) { OnVoiceStateUpdate(e); }); break;
case DpEventID::VoiceClientDisconnect: eh = c.on_voice_client_disconnect.attach([this](const dpp::voice_client_disconnect_t & e) { OnVoiceClientDisconnect(e); }); break;
case DpEventID::VoiceClientSpeaking: eh = c.on_voice_client_speaking.attach([this](const dpp::voice_client_speaking_t & e) { OnVoiceClientSpeaking(e); }); break;
case DpEventID::Log: eh = c.on_log.attach([this](const dpp::log_t & e) { OnLog(e); }); break;
case DpEventID::GuildJoinRequestDelete: eh = c.on_guild_join_request_delete.attach([this](const dpp::guild_join_request_delete_t & e) { OnGuildJoinRequestDelete(e); }); break;
case DpEventID::InteractionCreate: eh = c.on_interaction_create.attach([this](const dpp::interaction_create_t & e) { OnInteractionCreate(e); }); break;
case DpEventID::SlashCommand: eh = c.on_slashcommand.attach([this](const dpp::slashcommand_t & e) { OnSlashCommand(e); }); break;
case DpEventID::ButtonClick: eh = c.on_button_click.attach([this](const dpp::button_click_t & e) { OnButtonClick(e); }); break;
case DpEventID::AutoComplete: eh = c.on_autocomplete.attach([this](const dpp::autocomplete_t & e) { OnAutoComplete(e); }); break;
case DpEventID::SelectClick: eh = c.on_select_click.attach([this](const dpp::select_click_t & e) { OnSelectClick(e); }); break;
case DpEventID::MessageContextMenu: eh = c.on_message_context_menu.attach([this](const dpp::message_context_menu_t & e) { OnMessageContextMenu(e); }); break;
case DpEventID::UserContextMenu: eh = c.on_user_context_menu.attach([this](const dpp::user_context_menu_t & e) { OnUserContextMenu(e); }); break;
case DpEventID::FormSubmit: eh = c.on_form_submit.attach([this](const dpp::form_submit_t & e) { OnFormSubmit(e); }); break;
case DpEventID::GuildDelete: eh = c.on_guild_delete.attach([this](const dpp::guild_delete_t & e) { OnGuildDelete(e); }); break;
case DpEventID::ChannelDelete: eh = c.on_channel_delete.attach([this](const dpp::channel_delete_t & e) { OnChannelDelete(e); }); break;
case DpEventID::ChannelUpdate: eh = c.on_channel_update.attach([this](const dpp::channel_update_t & e) { OnChannelUpdate(e); }); break;
case DpEventID::Ready: eh = c.on_ready.attach([this](const dpp::ready_t & e) { OnReady(e); }); break;
case DpEventID::MessageDelete: eh = c.on_message_delete.attach([this](const dpp::message_delete_t & e) { OnMessageDelete(e); }); break;
case DpEventID::GuildMemberRemove: eh = c.on_guild_member_remove.attach([this](const dpp::guild_member_remove_t & e) { OnGuildMemberRemove(e); }); break;
case DpEventID::Resumed: eh = c.on_resumed.attach([this](const dpp::resumed_t & e) { OnResumed(e); }); break;
case DpEventID::GuildRoleCreate: eh = c.on_guild_role_create.attach([this](const dpp::guild_role_create_t & e) { OnGuildRoleCreate(e); }); break;
case DpEventID::TypingStart: eh = c.on_typing_start.attach([this](const dpp::typing_start_t & e) { OnTypingStart(e); }); break;
case DpEventID::MessageReactionAdd: eh = c.on_message_reaction_add.attach([this](const dpp::message_reaction_add_t & e) { OnMessageReactionAdd(e); }); break;
case DpEventID::GuildMembersChunk: eh = c.on_guild_members_chunk.attach([this](const dpp::guild_members_chunk_t & e) { OnGuildMembersChunk(e); }); break;
case DpEventID::MessageReactionRemove: eh = c.on_message_reaction_remove.attach([this](const dpp::message_reaction_remove_t & e) { OnMessageReactionRemove(e); }); break;
case DpEventID::GuildCreate: eh = c.on_guild_create.attach([this](const dpp::guild_create_t & e) { OnGuildCreate(e); }); break;
case DpEventID::ChannelCreate: eh = c.on_channel_create.attach([this](const dpp::channel_create_t & e) { OnChannelCreate(e); }); break;
case DpEventID::MessageReactionRemoveEmoji: eh = c.on_message_reaction_remove_emoji.attach([this](const dpp::message_reaction_remove_emoji_t & e) { OnMessageReactionRemoveEmoji(e); }); break;
case DpEventID::MessageDeleteDulk: eh = c.on_message_delete_bulk.attach([this](const dpp::message_delete_bulk_t & e) { OnMessageDeleteDulk(e); }); break;
case DpEventID::GuildRoleUpdate: eh = c.on_guild_role_update.attach([this](const dpp::guild_role_update_t & e) { OnGuildRoleUpdate(e); }); break;
case DpEventID::GuildRoleDelete: eh = c.on_guild_role_delete.attach([this](const dpp::guild_role_delete_t & e) { OnGuildRoleDelete(e); }); break;
case DpEventID::ChannelPinsUpdate: eh = c.on_channel_pins_update.attach([this](const dpp::channel_pins_update_t & e) { OnChannelPinsUpdate(e); }); break;
case DpEventID::MessageReactionRemoveAll: eh = c.on_message_reaction_remove_all.attach([this](const dpp::message_reaction_remove_all_t & e) { OnMessageReactionRemoveAll(e); }); break;
case DpEventID::VoiceServerUpdate: eh = c.on_voice_server_update.attach([this](const dpp::voice_server_update_t & e) { OnVoiceServerUpdate(e); }); break;
case DpEventID::GuildEmojisUpdate: eh = c.on_guild_emojis_update.attach([this](const dpp::guild_emojis_update_t & e) { OnGuildEmojisUpdate(e); }); break;
case DpEventID::GuildStickersUpdate: eh = c.on_guild_stickers_update.attach([this](const dpp::guild_stickers_update_t & e) { OnGuildStickersUpdate(e); }); break;
case DpEventID::PresenceUpdate: eh = c.on_presence_update.attach([this](const dpp::presence_update_t & e) { OnPresenceUpdate(e); }); break;
case DpEventID::WebhooksUpdate: eh = c.on_webhooks_update.attach([this](const dpp::webhooks_update_t & e) { OnWebhooksUpdate(e); }); break;
case DpEventID::AutomodRuleCreate: eh = c.on_automod_rule_create.attach([this](const dpp::automod_rule_create_t & e) { OnAutomodRuleCreate(e); }); break;
case DpEventID::AutomodRuleUpdate: eh = c.on_automod_rule_update.attach([this](const dpp::automod_rule_update_t & e) { OnAutomodRuleUpdate(e); }); break;
case DpEventID::AutomodRuleDelete: eh = c.on_automod_rule_delete.attach([this](const dpp::automod_rule_delete_t & e) { OnAutomodRuleDelete(e); }); break;
case DpEventID::AutomodRuleExecute: eh = c.on_automod_rule_execute.attach([this](const dpp::automod_rule_execute_t & e) { OnAutomodRuleExecute(e); }); break;
case DpEventID::GuildMemberAdd: eh = c.on_guild_member_add.attach([this](const dpp::guild_member_add_t & e) { OnGuildMemberAdd(e); }); break;
case DpEventID::InviteDelete: eh = c.on_invite_delete.attach([this](const dpp::invite_delete_t & e) { OnInviteDelete(e); }); break;
case DpEventID::GuildUpdate: eh = c.on_guild_update.attach([this](const dpp::guild_update_t & e) { OnGuildUpdate(e); }); break;
case DpEventID::GuildIntegrationsUpdate: eh = c.on_guild_integrations_update.attach([this](const dpp::guild_integrations_update_t & e) { OnGuildIntegrationsUpdate(e); }); break;
case DpEventID::GuildMemberUpdate: eh = c.on_guild_member_update.attach([this](const dpp::guild_member_update_t & e) { OnGuildMemberUpdate(e); }); break;
case DpEventID::InviteCreate: eh = c.on_invite_create.attach([this](const dpp::invite_create_t & e) { OnInviteCreate(e); }); break;
case DpEventID::MessageUpdate: eh = c.on_message_update.attach([this](const dpp::message_update_t & e) { OnMessageUpdate(e); }); break;
case DpEventID::UserUpdate: eh = c.on_user_update.attach([this](const dpp::user_update_t & e) { OnUserUpdate(e); }); break;
case DpEventID::MessageCreate: eh = c.on_message_create.attach([this](const dpp::message_create_t & e) { OnMessageCreate(e); }); break;
case DpEventID::GuildBanAdd: eh = c.on_guild_ban_add.attach([this](const dpp::guild_ban_add_t & e) { OnGuildBanAdd(e); }); break;
case DpEventID::GuildBanRemove: eh = c.on_guild_ban_remove.attach([this](const dpp::guild_ban_remove_t & e) { OnGuildBanRemove(e); }); break;
case DpEventID::IntegrationCreate: eh = c.on_integration_create.attach([this](const dpp::integration_create_t & e) { OnIntegrationCreate(e); }); break;
case DpEventID::IntegrationUpdate: eh = c.on_integration_update.attach([this](const dpp::integration_update_t & e) { OnIntegrationUpdate(e); }); break;
case DpEventID::IntegrationDelete: eh = c.on_integration_delete.attach([this](const dpp::integration_delete_t & e) { OnIntegrationDelete(e); }); break;
case DpEventID::ThreadCreate: eh = c.on_thread_create.attach([this](const dpp::thread_create_t & e) { OnThreadCreate(e); }); break;
case DpEventID::ThreadUpdate: eh = c.on_thread_update.attach([this](const dpp::thread_update_t & e) { OnThreadUpdate(e); }); break;
case DpEventID::ThreadDelete: eh = c.on_thread_delete.attach([this](const dpp::thread_delete_t & e) { OnThreadDelete(e); }); break;
case DpEventID::ThreadListSync: eh = c.on_thread_list_sync.attach([this](const dpp::thread_list_sync_t & e) { OnThreadListSync(e); }); break;
case DpEventID::ThreadMemberUpdate: eh = c.on_thread_member_update.attach([this](const dpp::thread_member_update_t & e) { OnThreadMemberUpdate(e); }); break;
case DpEventID::ThreadMembersUpdate: eh = c.on_thread_members_update.attach([this](const dpp::thread_members_update_t & e) { OnThreadMembersUpdate(e); }); break;
case DpEventID::GuildScheduledEventCreate: eh = c.on_guild_scheduled_event_create.attach([this](const dpp::guild_scheduled_event_create_t & e) { OnGuildScheduledEventCreate(e); }); break;
case DpEventID::GuildScheduledEventUpdate: eh = c.on_guild_scheduled_event_update.attach([this](const dpp::guild_scheduled_event_update_t & e) { OnGuildScheduledEventUpdate(e); }); break;
case DpEventID::GuildScheduledEventDelete: eh = c.on_guild_scheduled_event_delete.attach([this](const dpp::guild_scheduled_event_delete_t & e) { OnGuildScheduledEventDelete(e); }); break;
case DpEventID::GuildScheduledEventUserAdd: eh = c.on_guild_scheduled_event_user_add.attach([this](const dpp::guild_scheduled_event_user_add_t & e) { OnGuildScheduledEventUserAdd(e); }); break;
case DpEventID::GuildScheduledEventUserRemove: eh = c.on_guild_scheduled_event_user_remove.attach([this](const dpp::guild_scheduled_event_user_remove_t & e) { OnGuildScheduledEventUserRemove(e); }); break;
case DpEventID::VoiceBufferSend: eh = c.on_voice_buffer_send.attach([this](const dpp::voice_buffer_send_t & e) { OnVoiceBufferSend(e); }); break;
case DpEventID::VoiceUserTalking: eh = c.on_voice_user_talking.attach([this](const dpp::voice_user_talking_t & e) { OnVoiceUserTalking(e); }); break;
case DpEventID::VoiceReady: eh = c.on_voice_ready.attach([this](const dpp::voice_ready_t & e) { OnVoiceReady(e); }); break;
case DpEventID::VoiceReceive: eh = c.on_voice_receive.attach([this](const dpp::voice_receive_t & e) { OnVoiceReceive(e); }); break;
case DpEventID::VoiceReceiveCombined: eh = c.on_voice_receive_combined.attach([this](const dpp::voice_receive_t & e) { OnVoiceReceiveCombined(e); }); break;
case DpEventID::VoiceTrackMarker: eh = c.on_voice_track_marker.attach([this](const dpp::voice_track_marker_t & e) { OnVoiceTrackMarker(e); }); break;
case DpEventID::StageInstanceCreate: eh = c.on_stage_instance_create.attach([this](const dpp::stage_instance_create_t & e) { OnStageInstanceCreate(e); }); break;
case DpEventID::StageInstanceUpdate: eh = c.on_stage_instance_update.attach([this](const dpp::stage_instance_update_t & e) { OnStageInstanceUpdate(e); }); break;
case DpEventID::StageInstanceDelete: eh = c.on_stage_instance_delete.attach([this](const dpp::stage_instance_delete_t & e) { OnStageInstanceDelete(e); }); break;
case DpEventID::Max: // Fall through
default: STHROWF("Invalid discord event identifier {}", id);
}
// Remember the designated event handle
mEventsHandle[static_cast< size_t >(id)] = eh;
// Allow chaining
return *this;
}
// ------------------------------------------------------------------------------------------------
DpCluster & DpCluster::DisableEvent(SQInteger id)
{
// Retrieve managed cluster instance
auto & c = Valid("disable event on a");
// Assigned event handle
dpp::event_handle eh = 0;
// Make sure the specified event handle is valid
if (id >= 0 && id < static_cast< SQInteger >(DpEventID::Max))
{
eh = mEventsHandle[static_cast< size_t >(id)]; // Get the real handle
}
// Is there anything attached to event dispatched?
if (eh == 0)
{
return *this; // Nothing to detach
}
// Identify event type
switch (id)
{
case DpEventID::VoiceStateUpdate: c.on_voice_state_update.detach(eh); break;
case DpEventID::VoiceClientDisconnect: c.on_voice_client_disconnect.detach(eh); break;
case DpEventID::VoiceClientSpeaking: c.on_voice_client_speaking.detach(eh); break;
case DpEventID::Log: c.on_log.detach(eh); break;
case DpEventID::GuildJoinRequestDelete: c.on_guild_join_request_delete.detach(eh); break;
case DpEventID::InteractionCreate: c.on_interaction_create.detach(eh); break;
case DpEventID::SlashCommand: c.on_slashcommand.detach(eh); break;
case DpEventID::ButtonClick: c.on_button_click.detach(eh); break;
case DpEventID::AutoComplete: c.on_autocomplete.detach(eh); break;
case DpEventID::SelectClick: c.on_select_click.detach(eh); break;
case DpEventID::MessageContextMenu: c.on_message_context_menu.detach(eh); break;
case DpEventID::UserContextMenu: c.on_user_context_menu.detach(eh); break;
case DpEventID::FormSubmit: c.on_form_submit.detach(eh); break;
case DpEventID::GuildDelete: c.on_guild_delete.detach(eh); break;
case DpEventID::ChannelDelete: c.on_channel_delete.detach(eh); break;
case DpEventID::ChannelUpdate: c.on_channel_update.detach(eh); break;
case DpEventID::Ready: c.on_ready.detach(eh); break;
case DpEventID::MessageDelete: c.on_message_delete.detach(eh); break;
case DpEventID::GuildMemberRemove: c.on_guild_member_remove.detach(eh); break;
case DpEventID::Resumed: c.on_resumed.detach(eh); break;
case DpEventID::GuildRoleCreate: c.on_guild_role_create.detach(eh); break;
case DpEventID::TypingStart: c.on_typing_start.detach(eh); break;
case DpEventID::MessageReactionAdd: c.on_message_reaction_add.detach(eh); break;
case DpEventID::GuildMembersChunk: c.on_guild_members_chunk.detach(eh); break;
case DpEventID::MessageReactionRemove: c.on_message_reaction_remove.detach(eh); break;
case DpEventID::GuildCreate: c.on_guild_create.detach(eh); break;
case DpEventID::ChannelCreate: c.on_channel_create.detach(eh); break;
case DpEventID::MessageReactionRemoveEmoji: c.on_message_reaction_remove_emoji.detach(eh); break;
case DpEventID::MessageDeleteDulk: c.on_message_delete_bulk.detach(eh); break;
case DpEventID::GuildRoleUpdate: c.on_guild_role_update.detach(eh); break;
case DpEventID::GuildRoleDelete: c.on_guild_role_delete.detach(eh); break;
case DpEventID::ChannelPinsUpdate: c.on_channel_pins_update.detach(eh); break;
case DpEventID::MessageReactionRemoveAll: c.on_message_reaction_remove_all.detach(eh); break;
case DpEventID::VoiceServerUpdate: c.on_voice_server_update.detach(eh); break;
case DpEventID::GuildEmojisUpdate: c.on_guild_emojis_update.detach(eh); break;
case DpEventID::GuildStickersUpdate: c.on_guild_stickers_update.detach(eh); break;
case DpEventID::PresenceUpdate: c.on_presence_update.detach(eh); break;
case DpEventID::WebhooksUpdate: c.on_webhooks_update.detach(eh); break;
case DpEventID::AutomodRuleCreate: c.on_automod_rule_create.detach(eh); break;
case DpEventID::AutomodRuleUpdate: c.on_automod_rule_update.detach(eh); break;
case DpEventID::AutomodRuleDelete: c.on_automod_rule_delete.detach(eh); break;
case DpEventID::AutomodRuleExecute: c.on_automod_rule_execute.detach(eh); break;
case DpEventID::GuildMemberAdd: c.on_guild_member_add.detach(eh); break;
case DpEventID::InviteDelete: c.on_invite_delete.detach(eh); break;
case DpEventID::GuildUpdate: c.on_guild_update.detach(eh); break;
case DpEventID::GuildIntegrationsUpdate: c.on_guild_integrations_update.detach(eh); break;
case DpEventID::GuildMemberUpdate: c.on_guild_member_update.detach(eh); break;
case DpEventID::InviteCreate: c.on_invite_create.detach(eh); break;
case DpEventID::MessageUpdate: c.on_message_update.detach(eh); break;
case DpEventID::UserUpdate: c.on_user_update.detach(eh); break;
case DpEventID::MessageCreate: c.on_message_create.detach(eh); break;
case DpEventID::GuildBanAdd: c.on_guild_ban_add.detach(eh); break;
case DpEventID::GuildBanRemove: c.on_guild_ban_remove.detach(eh); break;
case DpEventID::IntegrationCreate: c.on_integration_create.detach(eh); break;
case DpEventID::IntegrationUpdate: c.on_integration_update.detach(eh); break;
case DpEventID::IntegrationDelete: c.on_integration_delete.detach(eh); break;
case DpEventID::ThreadCreate: c.on_thread_create.detach(eh); break;
case DpEventID::ThreadUpdate: c.on_thread_update.detach(eh); break;
case DpEventID::ThreadDelete: c.on_thread_delete.detach(eh); break;
case DpEventID::ThreadListSync: c.on_thread_list_sync.detach(eh); break;
case DpEventID::ThreadMemberUpdate: c.on_thread_member_update.detach(eh); break;
case DpEventID::ThreadMembersUpdate: c.on_thread_members_update.detach(eh); break;
case DpEventID::GuildScheduledEventCreate: c.on_guild_scheduled_event_create.detach(eh); break;
case DpEventID::GuildScheduledEventUpdate: c.on_guild_scheduled_event_update.detach(eh); break;
case DpEventID::GuildScheduledEventDelete: c.on_guild_scheduled_event_delete.detach(eh); break;
case DpEventID::GuildScheduledEventUserAdd: c.on_guild_scheduled_event_user_add.detach(eh); break;
case DpEventID::GuildScheduledEventUserRemove: c.on_guild_scheduled_event_user_remove.detach(eh); break;
case DpEventID::VoiceBufferSend: c.on_voice_buffer_send.detach(eh); break;
case DpEventID::VoiceUserTalking: c.on_voice_user_talking.detach(eh); break;
case DpEventID::VoiceReady: c.on_voice_ready.detach(eh); break;
case DpEventID::VoiceReceive: c.on_voice_receive.detach(eh); break;
case DpEventID::VoiceReceiveCombined: c.on_voice_receive_combined.detach(eh); break;
case DpEventID::VoiceTrackMarker: c.on_voice_track_marker.detach(eh); break;
case DpEventID::StageInstanceCreate: c.on_stage_instance_create.detach(eh); break;
case DpEventID::StageInstanceUpdate: c.on_stage_instance_update.detach(eh); break;
case DpEventID::StageInstanceDelete: c.on_stage_instance_delete.detach(eh); break;
case DpEventID::Max: // Fall through
default: STHROWF("Invalid discord event identifier {}", id);
}
// Forget about this event handler
mEventsHandle[static_cast< size_t >(id)] = 0;
// Allow chaining
return *this;
}
// ------------------------------------------------------------------------------------------------
void DpCluster::OnVoiceStateUpdate(const dpp::voice_state_update_t & ev)
{ mQueue.enqueue(EventItem(new DpVoiceStateUpdateEvent(ev))); }
void DpCluster::OnVoiceClientDisconnect(const dpp::voice_client_disconnect_t & ev)
{ mQueue.enqueue(EventItem(new DpVoiceClientDisconnectEvent(ev))); }
void DpCluster::OnVoiceClientSpeaking(const dpp::voice_client_speaking_t & ev)
{ mQueue.enqueue(EventItem(new DpVoiceClientSpeakingEvent(ev))); }
void DpCluster::OnLog(const dpp::log_t & ev)
{ mQueue.enqueue(EventItem(new DpLogEvent(ev))); }
void DpCluster::OnGuildJoinRequestDelete(const dpp::guild_join_request_delete_t & ev)
{ mQueue.enqueue(EventItem(new DpGuildJoinRequestDeleteEvent(ev))); }
void DpCluster::OnInteractionCreate(const dpp::interaction_create_t & ev)
{ mQueue.enqueue(EventItem(new DpInteractionCreateEvent(ev))); }
void DpCluster::OnSlashCommand(const dpp::slashcommand_t & ev)
{ mQueue.enqueue(EventItem(new DpSlashCommandEvent(ev))); }
void DpCluster::OnButtonClick(const dpp::button_click_t & ev)
{ mQueue.enqueue(EventItem(new DpButtonClickEvent(ev))); }
void DpCluster::OnAutoComplete(const dpp::autocomplete_t & ev)
{ mQueue.enqueue(EventItem(new DpAutoCompleteEvent(ev))); }
void DpCluster::OnSelectClick(const dpp::select_click_t & ev)
{ mQueue.enqueue(EventItem(new DpSelectClickEvent(ev))); }
void DpCluster::OnMessageContextMenu(const dpp::message_context_menu_t & ev)
{ mQueue.enqueue(EventItem(new DpMessageContextMenuEvent(ev))); }
void DpCluster::OnUserContextMenu(const dpp::user_context_menu_t & ev)
{ mQueue.enqueue(EventItem(new DpUserContextMenuEvent(ev))); }
void DpCluster::OnFormSubmit(const dpp::form_submit_t & ev)
{ mQueue.enqueue(EventItem(new DpFormSubmitEvent(ev))); }
void DpCluster::OnGuildDelete(const dpp::guild_delete_t & ev)
{ mQueue.enqueue(EventItem(new DpGuildDeleteEvent(ev))); }
void DpCluster::OnChannelDelete(const dpp::channel_delete_t & ev)
{ mQueue.enqueue(EventItem(new DpChannelDeleteEvent(ev))); }
void DpCluster::OnChannelUpdate(const dpp::channel_update_t & ev)
{ mQueue.enqueue(EventItem(new DpChannelUpdateEvent(ev))); }
void DpCluster::OnReady(const dpp::ready_t & ev)
{ mQueue.enqueue(EventItem(new DpReadyEvent(ev))); }
void DpCluster::OnMessageDelete(const dpp::message_delete_t & ev)
{ mQueue.enqueue(EventItem(new DpMessageDeleteEvent(ev))); }
void DpCluster::OnGuildMemberRemove(const dpp::guild_member_remove_t & ev)
{ mQueue.enqueue(EventItem(new DpGuildMemberRemoveEvent(ev))); }
void DpCluster::OnResumed(const dpp::resumed_t & ev)
{ mQueue.enqueue(EventItem(new DpResumedEvent(ev))); }
void DpCluster::OnGuildRoleCreate(const dpp::guild_role_create_t & ev)
{ mQueue.enqueue(EventItem(new DpGuildRoleCreateEvent(ev))); }
void DpCluster::OnTypingStart(const dpp::typing_start_t & ev)
{ mQueue.enqueue(EventItem(new DpTypingStartEvent(ev))); }
void DpCluster::OnMessageReactionAdd(const dpp::message_reaction_add_t & ev)
{ mQueue.enqueue(EventItem(new DpMessageReactionAddEvent(ev))); }
void DpCluster::OnGuildMembersChunk(const dpp::guild_members_chunk_t & ev)
{ mQueue.enqueue(EventItem(new DpGuildMembersChunkEvent(ev))); }
void DpCluster::OnMessageReactionRemove(const dpp::message_reaction_remove_t & ev)
{ mQueue.enqueue(EventItem(new DpMessageReactionRemoveEvent(ev))); }
void DpCluster::OnGuildCreate(const dpp::guild_create_t & ev)
{ mQueue.enqueue(EventItem(new DpGuildCreateEvent(ev))); }
void DpCluster::OnChannelCreate(const dpp::channel_create_t & ev)
{ mQueue.enqueue(EventItem(new DpChannelCreateEvent(ev))); }
void DpCluster::OnMessageReactionRemoveEmoji(const dpp::message_reaction_remove_emoji_t & ev)
{ mQueue.enqueue(EventItem(new DpMessageReactionRemoveEmojiEvent(ev))); }
void DpCluster::OnMessageDeleteDulk(const dpp::message_delete_bulk_t & ev)
{ mQueue.enqueue(EventItem(new DpMessageDeleteDulkEvent(ev))); }
void DpCluster::OnGuildRoleUpdate(const dpp::guild_role_update_t & ev)
{ mQueue.enqueue(EventItem(new DpGuildRoleUpdateEvent(ev))); }
void DpCluster::OnGuildRoleDelete(const dpp::guild_role_delete_t & ev)
{ mQueue.enqueue(EventItem(new DpGuildRoleDeleteEvent(ev))); }
void DpCluster::OnChannelPinsUpdate(const dpp::channel_pins_update_t & ev)
{ mQueue.enqueue(EventItem(new DpChannelPinsUpdateEvent(ev))); }
void DpCluster::OnMessageReactionRemoveAll(const dpp::message_reaction_remove_all_t & ev)
{ mQueue.enqueue(EventItem(new DpMessageReactionRemoveAllEvent(ev))); }
void DpCluster::OnVoiceServerUpdate(const dpp::voice_server_update_t & ev)
{ mQueue.enqueue(EventItem(new DpVoiceServerUpdateEvent(ev))); }
void DpCluster::OnGuildEmojisUpdate(const dpp::guild_emojis_update_t & ev)
{ mQueue.enqueue(EventItem(new DpGuildEmojisUpdateEvent(ev))); }
void DpCluster::OnGuildStickersUpdate(const dpp::guild_stickers_update_t & ev)
{ mQueue.enqueue(EventItem(new DpGuildStickersUpdateEvent(ev))); }
void DpCluster::OnPresenceUpdate(const dpp::presence_update_t & ev)
{ mQueue.enqueue(EventItem(new DpPresenceUpdateEvent(ev))); }
void DpCluster::OnWebhooksUpdate(const dpp::webhooks_update_t & ev)
{ mQueue.enqueue(EventItem(new DpWebhooksUpdateEvent(ev))); }
void DpCluster::OnAutomodRuleCreate(const dpp::automod_rule_create_t & ev)
{ mQueue.enqueue(EventItem(new DpAutomodRuleCreateEvent(ev))); }
void DpCluster::OnAutomodRuleUpdate(const dpp::automod_rule_update_t & ev)
{ mQueue.enqueue(EventItem(new DpAutomodRuleUpdateEvent(ev))); }
void DpCluster::OnAutomodRuleDelete(const dpp::automod_rule_delete_t & ev)
{ mQueue.enqueue(EventItem(new DpAutomodRuleDeleteEvent(ev))); }
void DpCluster::OnAutomodRuleExecute(const dpp::automod_rule_execute_t & ev)
{ mQueue.enqueue(EventItem(new DpAutomodRuleExecuteEvent(ev))); }
void DpCluster::OnGuildMemberAdd(const dpp::guild_member_add_t & ev)
{ mQueue.enqueue(EventItem(new DpGuildMemberAddEvent(ev))); }
void DpCluster::OnInviteDelete(const dpp::invite_delete_t & ev)
{ mQueue.enqueue(EventItem(new DpInviteDeleteEvent(ev))); }
void DpCluster::OnGuildUpdate(const dpp::guild_update_t & ev)
{ mQueue.enqueue(EventItem(new DpGuildUpdateEvent(ev))); }
void DpCluster::OnGuildIntegrationsUpdate(const dpp::guild_integrations_update_t & ev)
{ mQueue.enqueue(EventItem(new DpGuildIntegrationsUpdateEvent(ev))); }
void DpCluster::OnGuildMemberUpdate(const dpp::guild_member_update_t & ev)
{ mQueue.enqueue(EventItem(new DpGuildMemberUpdateEvent(ev))); }
void DpCluster::OnInviteCreate(const dpp::invite_create_t & ev)
{ mQueue.enqueue(EventItem(new DpInviteCreateEvent(ev))); }
void DpCluster::OnMessageUpdate(const dpp::message_update_t & ev)
{ mQueue.enqueue(EventItem(new DpMessageUpdateEvent(ev))); }
void DpCluster::OnUserUpdate(const dpp::user_update_t & ev)
{ mQueue.enqueue(EventItem(new DpUserUpdateEvent(ev))); }
void DpCluster::OnMessageCreate(const dpp::message_create_t & ev)
{ mQueue.enqueue(EventItem(new DpMessageCreateEvent(ev))); }
void DpCluster::OnGuildBanAdd(const dpp::guild_ban_add_t & ev)
{ mQueue.enqueue(EventItem(new DpGuildBanAddEvent(ev))); }
void DpCluster::OnGuildBanRemove(const dpp::guild_ban_remove_t & ev)
{ mQueue.enqueue(EventItem(new DpGuildBanRemoveEvent(ev))); }
void DpCluster::OnIntegrationCreate(const dpp::integration_create_t & ev)
{ mQueue.enqueue(EventItem(new DpIntegrationCreateEvent(ev))); }
void DpCluster::OnIntegrationUpdate(const dpp::integration_update_t & ev)
{ mQueue.enqueue(EventItem(new DpIntegrationUpdateEvent(ev))); }
void DpCluster::OnIntegrationDelete(const dpp::integration_delete_t & ev)
{ mQueue.enqueue(EventItem(new DpIntegrationDeleteEvent(ev))); }
void DpCluster::OnThreadCreate(const dpp::thread_create_t & ev)
{ mQueue.enqueue(EventItem(new DpThreadCreateEvent(ev))); }
void DpCluster::OnThreadUpdate(const dpp::thread_update_t & ev)
{ mQueue.enqueue(EventItem(new DpThreadUpdateEvent(ev))); }
void DpCluster::OnThreadDelete(const dpp::thread_delete_t & ev)
{ mQueue.enqueue(EventItem(new DpThreadDeleteEvent(ev))); }
void DpCluster::OnThreadListSync(const dpp::thread_list_sync_t & ev)
{ mQueue.enqueue(EventItem(new DpThreadListSyncEvent(ev))); }
void DpCluster::OnThreadMemberUpdate(const dpp::thread_member_update_t & ev)
{ mQueue.enqueue(EventItem(new DpThreadMemberUpdateEvent(ev))); }
void DpCluster::OnThreadMembersUpdate(const dpp::thread_members_update_t & ev)
{ mQueue.enqueue(EventItem(new DpThreadMembersUpdateEvent(ev))); }
void DpCluster::OnGuildScheduledEventCreate(const dpp::guild_scheduled_event_create_t & ev)
{ mQueue.enqueue(EventItem(new DpGuildScheduledEventCreateEvent(ev))); }
void DpCluster::OnGuildScheduledEventUpdate(const dpp::guild_scheduled_event_update_t & ev)
{ mQueue.enqueue(EventItem(new DpGuildScheduledEventUpdateEvent(ev))); }
void DpCluster::OnGuildScheduledEventDelete(const dpp::guild_scheduled_event_delete_t & ev)
{ mQueue.enqueue(EventItem(new DpGuildScheduledEventDeleteEvent(ev))); }
void DpCluster::OnGuildScheduledEventUserAdd(const dpp::guild_scheduled_event_user_add_t & ev)
{ mQueue.enqueue(EventItem(new DpGuildScheduledEventUserAddEvent(ev))); }
void DpCluster::OnGuildScheduledEventUserRemove(const dpp::guild_scheduled_event_user_remove_t & ev)
{ mQueue.enqueue(EventItem(new DpGuildScheduledEventUserRemoveEvent(ev))); }
void DpCluster::OnVoiceBufferSend(const dpp::voice_buffer_send_t & ev)
{ mQueue.enqueue(EventItem(new DpVoiceBufferSendEvent(ev))); }
void DpCluster::OnVoiceUserTalking(const dpp::voice_user_talking_t & ev)
{ mQueue.enqueue(EventItem(new DpVoiceUserTalkingEvent(ev))); }
void DpCluster::OnVoiceReady(const dpp::voice_ready_t & ev)
{ mQueue.enqueue(EventItem(new DpVoiceReadyEvent(ev))); }
void DpCluster::OnVoiceReceive(const dpp::voice_receive_t & ev)
{ mQueue.enqueue(EventItem(new DpVoiceReceiveEvent(ev))); }
void DpCluster::OnVoiceReceiveCombined(const dpp::voice_receive_t & ev)
{ mQueue.enqueue(EventItem(new DpVoiceReceiveCombinedEvent(ev))); }
void DpCluster::OnVoiceTrackMarker(const dpp::voice_track_marker_t & ev)
{ mQueue.enqueue(EventItem(new DpVoiceTrackMarkerEvent(ev))); }
void DpCluster::OnStageInstanceCreate(const dpp::stage_instance_create_t & ev)
{ mQueue.enqueue(EventItem(new DpStageInstanceCreateEvent(ev))); }
void DpCluster::OnStageInstanceUpdate(const dpp::stage_instance_update_t & ev)
{ mQueue.enqueue(EventItem(new DpStageInstanceUpdateEvent(ev))); }
void DpCluster::OnStageInstanceDelete(const dpp::stage_instance_delete_t & ev)
{ mQueue.enqueue(EventItem(new DpStageInstanceDeleteEvent(ev))); }
} // Namespace:: SqMod
module/Library/Discord/Cluster.hpp
+337
View File
@@ -0,0 +1,337 @@
#pragma once
// ------------------------------------------------------------------------------------------------
#include "Core/Utility.hpp"
#include "Core/Signal.hpp"
// ------------------------------------------------------------------------------------------------
#include "Library/Discord/Constants.hpp"
#include "Library/Discord/Misc.hpp"
// ------------------------------------------------------------------------------------------------
#include <chrono>
#include <memory>
#include <functional>
#include <string_view>
// ------------------------------------------------------------------------------------------------
#include <concurrentqueue.h>
#include <dpp/dpp.h>
// ------------------------------------------------------------------------------------------------
namespace SqMod {
// ------------------------------------------------------------------------------------------------
struct DpEventBase;
/* ------------------------------------------------------------------------------------------------
*
*/
struct DpClusterOptions
{
// The bot token to use for all HTTP commands and websocket connections.
std::string mToken{};
// A bitmask of dpd::intents values for all shards on this cluster. This is required to be sent for all bots with over 100 servers.
uint32_t mIntents{dpp::i_default_intents};
// The total number of shards on this bot. If there are multiple clusters, then (shards / clusters) actual shards will run on this cluster.
// If you omit this value, the library will attempt to query the Discord API for the correct number of shards to start.
uint32_t mShards{0};
// The ID of this cluster, should be between 0 and MAXCLUSTERS-1
uint32_t mClusterID{0};
// The total number of clusters that are active, which may be on separate processes or even separate machines.
uint32_t mMaxClusters{1};
// Whether or not to use compression for shards on this cluster. Saves a ton of bandwidth at the cost of some CPU
bool mCompressed{true};
// Set the user caching policy for the cluster, either lazy (only cache users/members when they message the bot) or aggressive (request whole member lists on seeing new guilds too)
dpp::cache_policy_t mPolicy{dpp::cp_aggressive, dpp::cp_aggressive, dpp::cp_aggressive};
// The number of threads to allocate for making HTTP requests to Discord. This defaults to 12. You can increase this at runtime via the object returned from get_rest().
uint32_t mRequestThreads{12};
// The number of threads to allocate for making HTTP requests to sites outside of Discord. This defaults to 1. You can increase this at runtime via the object returned from get_raw_rest().
uint32_t mRequestThreadsRaw{1};
// Disable automatic forwarding of logged messages to internal logging. Allows to handle logging manually without risking duplicate output (at the cost of some performance, ofc).
bool mCustomLogging{false};
/* --------------------------------------------------------------------------------------------
* Base constructors.
*/
DpClusterOptions(StackStrF & token)
: mToken(token.ToStr())
{
}
/* --------------------------------------------------------------------------------------------
* Copy/Move constructors.
*/
DpClusterOptions(const DpClusterOptions &) noexcept = default;
DpClusterOptions(DpClusterOptions &&) noexcept = default;
/* --------------------------------------------------------------------------------------------
* Copy/Move assignment operators.
*/
DpClusterOptions & operator = (const DpClusterOptions &) noexcept = default;
DpClusterOptions & operator = (DpClusterOptions &&) noexcept = default;
};
/* ------------------------------------------------------------------------------------------------
* Primitive implementation of a discord client with basic functionality.
*/
struct DpCluster : public SqChainedInstances< DpCluster >
{
using Base = SqChainedInstances< DpCluster >;
/* --------------------------------------------------------------------------------------------
* Queue of events generated from other threads.
*/
using EventItem = std::unique_ptr< DpEventBase >;
using EventQueue = moodycamel::ConcurrentQueue< EventItem >;
/* --------------------------------------------------------------------------------------------
* Type of container for cluster signals.
*/
using Signals = std::array< SignalPair, static_cast< size_t >(DpEventID::Max) >;
/* --------------------------------------------------------------------------------------------
* Type of container for event handles.
*/
using EventHandle = std::array< dpp::event_handle, static_cast< size_t >(DpEventID::Max) >;
/* --------------------------------------------------------------------------------------------
* Event queue.
*/
EventQueue mQueue{4096};
/* --------------------------------------------------------------------------------------------
* Managed cluster instance.
*/
std::unique_ptr< dpp::cluster > mC;
/* --------------------------------------------------------------------------------------------
* Table containing the emitted cluster events.
*/
LightObj mSqEvents{};
/* --------------------------------------------------------------------------------------------
* Cluster signals.
*/
Signals mEvents{};
/* --------------------------------------------------------------------------------------------
* Event handles for bound event event handlers so they can be stopped at any time.
*/
EventHandle mEventsHandle{};
/* --------------------------------------------------------------------------------------------
* Base constructors.
*/
DpCluster(DpClusterOptions & o);
/* --------------------------------------------------------------------------------------------
* Copy/Move constructors (disabled).
*/
DpCluster(const DpCluster &) noexcept = delete;
DpCluster(DpCluster &&) noexcept = delete;
/* --------------------------------------------------------------------------------------------
* Destructor.
*/
~DpCluster()
{
Stop();
// Forget about this instance
UnchainInstance();
}
/* --------------------------------------------------------------------------------------------
* Copy/Move assignment operators (disabled).
*/
DpCluster & operator = (const DpCluster &) noexcept = delete;
DpCluster & operator = (DpCluster &&) noexcept = delete;
/* --------------------------------------------------------------------------------------------
* Check if the managed cluster instance is valid and throw an exception otherwise.
*/
void Validate() const
{
if (!mC)
{
STHROWF("Discord cluster instance is not valid anymore.");
}
}
/* --------------------------------------------------------------------------------------------
* Check if the managed cluster instance is valid and throw an exception otherwise.
*/
void Validate(const char * m) const
{
if (!mC)
{
STHROWF("Cannot {} a cluster instance that is not valid anymore.", fmt::to_string_view(m));
}
}
/* --------------------------------------------------------------------------------------------
* Check if the managed cluster instance is valid and throw an exception otherwise.
*/
dpp::cluster & Valid() const { Validate(); return *mC; }
/* --------------------------------------------------------------------------------------------
* Check if the managed cluster instance is valid and throw an exception otherwise.
*/
dpp::cluster & Valid(const char * m) const { Validate(m); return *mC; }
/* --------------------------------------------------------------------------------------------
* Process the cluster. This is used internally on each server frame.
*/
void Process(bool force = false);
/* --------------------------------------------------------------------------------------------
* Terminate the cluster. This is used internally when the VM is shutting down.
*/
void Terminate();
/* --------------------------------------------------------------------------------------------
* Start the cluster.
*/
DpCluster & Start() { Valid("start").start(dpp::st_return); return *this; }
/* --------------------------------------------------------------------------------------------
* Stop the cluster.
*/
void Stop() { Valid("stop").shutdown(); }
/* --------------------------------------------------------------------------------------------
* Retrieve the events table of this cluster.
*/
SQMOD_NODISCARD LightObj & GetEvents()
{
return mSqEvents;
}
/* --------------------------------------------------------------------------------------------
* Enable a certain event for the cluster.
*/
DpCluster & EnableEvent(SQInteger id);
/* --------------------------------------------------------------------------------------------
* Disable a certain event for the cluster.
*/
DpCluster & DisableEvent(SQInteger id);
private:
/* --------------------------------------------------------------------------------------------
* Signal initialization.
*/
void InitEvents()
{
// Ignore the call if already initialized
if (!mSqEvents.IsNull())
{
return;
}
// Create a new table on the stack with enough space pre-allocated
sq_newtableex(SqVM(), static_cast< SQInteger >(DpEventID::Max + 1));
// Grab the table object from the stack
mSqEvents = LightObj(-1, SqVM());
// Pop the table object from the stack
sq_pop(SqVM(), 1);
// Proceed to initializing the events
for (size_t i = 0; i < mEvents.size(); ++i)
{
InitSignalPair(mEvents[i], mSqEvents, DpEventID::NAME[i]);
}
}
/* --------------------------------------------------------------------------------------------
* Signal termination.
*/
void DropEvents()
{
for (auto & e : mEvents)
{
ResetSignalPair(e);
}
}
/* --------------------------------------------------------------------------------------------
* Event handlers.
*/
void OnVoiceStateUpdate(const dpp::voice_state_update_t & ev);
void OnVoiceClientDisconnect(const dpp::voice_client_disconnect_t & ev);
void OnVoiceClientSpeaking(const dpp::voice_client_speaking_t & ev);
void OnLog(const dpp::log_t & ev);
void OnGuildJoinRequestDelete(const dpp::guild_join_request_delete_t & ev);
void OnInteractionCreate(const dpp::interaction_create_t & ev);
void OnSlashCommand(const dpp::slashcommand_t & ev);
void OnButtonClick(const dpp::button_click_t & ev);
void OnAutoComplete(const dpp::autocomplete_t & ev);
void OnSelectClick(const dpp::select_click_t & ev);
void OnMessageContextMenu(const dpp::message_context_menu_t & ev);
void OnUserContextMenu(const dpp::user_context_menu_t & ev);
void OnFormSubmit(const dpp::form_submit_t & ev);
void OnGuildDelete(const dpp::guild_delete_t & ev);
void OnChannelDelete(const dpp::channel_delete_t & ev);
void OnChannelUpdate(const dpp::channel_update_t & ev);
void OnReady(const dpp::ready_t & ev);
void OnMessageDelete(const dpp::message_delete_t & ev);
void OnGuildMemberRemove(const dpp::guild_member_remove_t & ev);
void OnResumed(const dpp::resumed_t & ev);
void OnGuildRoleCreate(const dpp::guild_role_create_t & ev);
void OnTypingStart(const dpp::typing_start_t & ev);
void OnMessageReactionAdd(const dpp::message_reaction_add_t & ev);
void OnGuildMembersChunk(const dpp::guild_members_chunk_t & ev);
void OnMessageReactionRemove(const dpp::message_reaction_remove_t & ev);
void OnGuildCreate(const dpp::guild_create_t & ev);
void OnChannelCreate(const dpp::channel_create_t & ev);
void OnMessageReactionRemoveEmoji(const dpp::message_reaction_remove_emoji_t & ev);
void OnMessageDeleteDulk(const dpp::message_delete_bulk_t & ev);
void OnGuildRoleUpdate(const dpp::guild_role_update_t & ev);
void OnGuildRoleDelete(const dpp::guild_role_delete_t & ev);
void OnChannelPinsUpdate(const dpp::channel_pins_update_t & ev);
void OnMessageReactionRemoveAll(const dpp::message_reaction_remove_all_t & ev);
void OnVoiceServerUpdate(const dpp::voice_server_update_t & ev);
void OnGuildEmojisUpdate(const dpp::guild_emojis_update_t & ev);
void OnGuildStickersUpdate(const dpp::guild_stickers_update_t & ev);
void OnPresenceUpdate(const dpp::presence_update_t & ev);
void OnWebhooksUpdate(const dpp::webhooks_update_t & ev);
void OnAutomodRuleCreate(const dpp::automod_rule_create_t & ev);
void OnAutomodRuleUpdate(const dpp::automod_rule_update_t & ev);
void OnAutomodRuleDelete(const dpp::automod_rule_delete_t & ev);
void OnAutomodRuleExecute(const dpp::automod_rule_execute_t & ev);
void OnGuildMemberAdd(const dpp::guild_member_add_t & ev);
void OnInviteDelete(const dpp::invite_delete_t & ev);
void OnGuildUpdate(const dpp::guild_update_t & ev);
void OnGuildIntegrationsUpdate(const dpp::guild_integrations_update_t & ev);
void OnGuildMemberUpdate(const dpp::guild_member_update_t & ev);
void OnInviteCreate(const dpp::invite_create_t & ev);
void OnMessageUpdate(const dpp::message_update_t & ev);
void OnUserUpdate(const dpp::user_update_t & ev);
void OnMessageCreate(const dpp::message_create_t & ev);
void OnGuildBanAdd(const dpp::guild_ban_add_t & ev);
void OnGuildBanRemove(const dpp::guild_ban_remove_t & ev);
void OnIntegrationCreate(const dpp::integration_create_t & ev);
void OnIntegrationUpdate(const dpp::integration_update_t & ev);
void OnIntegrationDelete(const dpp::integration_delete_t & ev);
void OnThreadCreate(const dpp::thread_create_t & ev);
void OnThreadUpdate(const dpp::thread_update_t & ev);
void OnThreadDelete(const dpp::thread_delete_t & ev);
void OnThreadListSync(const dpp::thread_list_sync_t & ev);
void OnThreadMemberUpdate(const dpp::thread_member_update_t & ev);
void OnThreadMembersUpdate(const dpp::thread_members_update_t & ev);
void OnGuildScheduledEventCreate(const dpp::guild_scheduled_event_create_t & ev);
void OnGuildScheduledEventUpdate(const dpp::guild_scheduled_event_update_t & ev);
void OnGuildScheduledEventDelete(const dpp::guild_scheduled_event_delete_t & ev);
void OnGuildScheduledEventUserAdd(const dpp::guild_scheduled_event_user_add_t & ev);
void OnGuildScheduledEventUserRemove(const dpp::guild_scheduled_event_user_remove_t & ev);
void OnVoiceBufferSend(const dpp::voice_buffer_send_t & ev);
void OnVoiceUserTalking(const dpp::voice_user_talking_t & ev);
void OnVoiceReady(const dpp::voice_ready_t & ev);
void OnVoiceReceive(const dpp::voice_receive_t & ev);
void OnVoiceReceiveCombined(const dpp::voice_receive_t & ev);
void OnVoiceTrackMarker(const dpp::voice_track_marker_t & ev);
void OnStageInstanceCreate(const dpp::stage_instance_create_t & ev);
void OnStageInstanceUpdate(const dpp::stage_instance_update_t & ev);
void OnStageInstanceDelete(const dpp::stage_instance_delete_t & ev);
};
} // Namespace:: SqMod
module/Library/Discord/Command.cpp
+9
View File
@@ -0,0 +1,9 @@
// ------------------------------------------------------------------------------------------------
#include "Library/Discord/Command.hpp"
// ------------------------------------------------------------------------------------------------
namespace SqMod {
} // Namespace:: SqMod
module/Library/Discord/Command.hpp
+13
View File
@@ -0,0 +1,13 @@
#pragma once
// ------------------------------------------------------------------------------------------------
#include "Core/Utility.hpp"
// ------------------------------------------------------------------------------------------------
#include <dpp/dpp.h>
// ------------------------------------------------------------------------------------------------
namespace SqMod {
} // Namespace:: SqMod
module/Library/Discord/Constants.cpp
+282
View File
@@ -0,0 +1,282 @@
// ------------------------------------------------------------------------------------------------
#include "Library/Discord/Constants.hpp"
// ------------------------------------------------------------------------------------------------
#include <sqratConst.h>
// ------------------------------------------------------------------------------------------------
namespace SqMod {
// ------------------------------------------------------------------------------------------------
const std::array< const char *, static_cast< size_t >(DpEventID::Max) > DpEventID::NAME{
"VoiceStateUpdate",
"VoiceClientDisconnect",
"VoiceClientSpeaking",
"Log",
"GuildJoinRequestDelete",
"InteractionCreate",
"SlashCommand",
"ButtonClick",
"AutoComplete",
"SelectClick",
"MessageContextMenu",
"UserContextMenu",
"FormSubmit",
"GuildDelete",
"ChannelDelete",
"ChannelUpdate",
"Ready",
"MessageDelete",
"GuildMemberRemove",
"Resumed",
"GuildRoleCreate",
"TypingStart",
"MessageReactionAdd",
"GuildMembersChunk",
"MessageReactionRemove",
"GuildCreate",
"ChannelCreate",
"MessageReactionRemoveEmoji",
"MessageDeleteDulk",
"GuildRoleUpdate",
"GuildRoleDelete",
"ChannelPinsUpdate",
"MessageReactionRemoveAll",
"VoiceServerUpdate",
"GuildEmojisUpdate",
"GuildStickersUpdate",
"PresenceUpdate",
"WebhooksUpdate",
"AutomodRuleCreate",
"AutomodRuleUpdate",
"AutomodRuleDelete",
"AutomodRuleExecute",
"GuildMemberAdd",
"InviteDelete",
"GuildUpdate",
"GuildIntegrationsUpdate",
"GuildMemberUpdate",
"InviteCreate",
"MessageUpdate",
"UserUpdate",
"MessageCreate",
"GuildBanAdd",
"GuildBanRemove",
"IntegrationCreate",
"IntegrationUpdate",
"IntegrationDelete",
"ThreadCreate",
"ThreadUpdate",
"ThreadDelete",
"ThreadListSync",
"ThreadMemberUpdate",
"ThreadMembersUpdate",
"GuildScheduledEventCreate",
"GuildScheduledEventUpdate",
"GuildScheduledEventDelete",
"GuildScheduledEventUserAdd",
"GuildScheduledEventUserRemove",
"VoiceBufferSend",
"VoiceUserTalking",
"VoiceReady",
"VoiceReceive",
"VoiceReceiveCombined",
"VoiceTrackMarker",
"StageInstanceCreate",
"StageInstanceUpdate",
"StageInstanceDelete",
};
// ------------------------------------------------------------------------------------------------
static const EnumElement g_DpLogLevelEnum[] = {
{_SC("Trace"), static_cast< SQInteger >(dpp::ll_trace)},
{_SC("Debug"), static_cast< SQInteger >(dpp::ll_debug)},
{_SC("Info"), static_cast< SQInteger >(dpp::ll_info)},
{_SC("Warning"), static_cast< SQInteger >(dpp::ll_warning)},
{_SC("Error"), static_cast< SQInteger >(dpp::ll_error)},
{_SC("Critical"), static_cast< SQInteger >(dpp::ll_critical)},
};
// ------------------------------------------------------------------------------------------------
static const EnumElement g_DpVoiceStateFlagsEnum[] = {
{_SC("Deaf"), static_cast< SQInteger >(dpp::vs_deaf)},
{_SC("Mute"), static_cast< SQInteger >(dpp::vs_mute)},
{_SC("SelfMute"), static_cast< SQInteger >(dpp::vs_self_mute)},
{_SC("SelfDeaf"), static_cast< SQInteger >(dpp::vs_self_deaf)},
{_SC("SelfStream"), static_cast< SQInteger >(dpp::vs_self_stream)},
{_SC("SelfVideo"), static_cast< SQInteger >(dpp::vs_self_video)},
{_SC("Suppress"), static_cast< SQInteger >(dpp::vs_suppress)},
};
// ------------------------------------------------------------------------------------------------
static const EnumElement g_DpEmojiFlagsEnum[] = {
{_SC("RequireColons"), static_cast< SQInteger >(dpp::e_require_colons)},
{_SC("Managed"), static_cast< SQInteger >(dpp::e_managed)},
{_SC("Animated"), static_cast< SQInteger >(dpp::e_animated)},
{_SC("Available"), static_cast< SQInteger >(dpp::e_available)},
};
// ------------------------------------------------------------------------------------------------
static const EnumElement g_DpPresenceFlagsEnum[] = {
{_SC("DesktopOnline"), static_cast< SQInteger >(dpp::p_desktop_online)},
{_SC("DesktopDND"), static_cast< SQInteger >(dpp::p_desktop_dnd)},
{_SC("DesktopIdle"), static_cast< SQInteger >(dpp::p_desktop_idle)},
{_SC("WebOnline"), static_cast< SQInteger >(dpp::p_web_online)},
{_SC("WebDND"), static_cast< SQInteger >(dpp::p_web_dnd)},
{_SC("WebIdle"), static_cast< SQInteger >(dpp::p_web_idle)},
{_SC("MobileOnline"), static_cast< SQInteger >(dpp::p_mobile_online)},
{_SC("MobileDND"), static_cast< SQInteger >(dpp::p_mobile_dnd)},
{_SC("MobileIdle"), static_cast< SQInteger >(dpp::p_mobile_idle)},
{_SC("StatusOnline"), static_cast< SQInteger >(dpp::p_status_online)},
{_SC("StatusDND"), static_cast< SQInteger >(dpp::p_status_dnd)},
{_SC("StatusIdle"), static_cast< SQInteger >(dpp::p_status_idle)},
};
// ------------------------------------------------------------------------------------------------
static const EnumElement g_DpPresenceStatusEnum[] = {
{_SC("Offline"), static_cast< SQInteger >(dpp::ps_offline)},
{_SC("Online"), static_cast< SQInteger >(dpp::ps_online)},
{_SC("DND"), static_cast< SQInteger >(dpp::ps_dnd)},
{_SC("Idle"), static_cast< SQInteger >(dpp::ps_idle)},
// Bit shift for desktop status
{_SC("ShiftDesktop"), static_cast< SQInteger >(PF_SHIFT_DESKTOP)},
{_SC("ShiftWeb"), static_cast< SQInteger >(PF_SHIFT_WEB)},
{_SC("ShiftMobile"), static_cast< SQInteger >(PF_SHIFT_MOBILE)},
{_SC("ShiftMain"), static_cast< SQInteger >(PF_SHIFT_MAIN)},
{_SC("StatusMask"), static_cast< SQInteger >(PF_STATUS_MASK)},
{_SC("ClearDesktop"), static_cast< SQInteger >(PF_CLEAR_DESKTOP)},
{_SC("ClearWeb"), static_cast< SQInteger >(PF_CLEAR_WEB)},
{_SC("ClearMobile"), static_cast< SQInteger >(PF_CLEAR_MOBILE)},
{_SC("ClearStatus"), static_cast< SQInteger >(PF_CLEAR_STATUS)},
};
// ------------------------------------------------------------------------------------------------
static const EnumElement g_DpActivityTypeEnum[] = {
{_SC("Game"), static_cast< SQInteger >(dpp::at_game)},
{_SC("Streaming"), static_cast< SQInteger >(dpp::at_streaming)},
{_SC("Listening"), static_cast< SQInteger >(dpp::at_listening)},
{_SC("Watching"), static_cast< SQInteger >(dpp::at_watching)},
{_SC("Custom"), static_cast< SQInteger >(dpp::at_custom)},
{_SC("Competing"), static_cast< SQInteger >(dpp::at_competing)},
};
// ------------------------------------------------------------------------------------------------
static const EnumElement g_DpActivityFlagsEnum[] = {
{_SC("Instance"), static_cast< SQInteger >(dpp::af_instance)},
{_SC("Join"), static_cast< SQInteger >(dpp::af_join)},
{_SC("Spectate"), static_cast< SQInteger >(dpp::af_spectate)},
{_SC("JoinRequest"), static_cast< SQInteger >(dpp::af_join_request)},
{_SC("Sync"), static_cast< SQInteger >(dpp::af_sync)},
{_SC("Play"), static_cast< SQInteger >(dpp::af_play)},
{_SC("PartyPrivacyFriends"), static_cast< SQInteger >(dpp::af_party_privacy_friends)},
{_SC("PartyPrivacyVoiceChannel"), static_cast< SQInteger >(dpp::af_party_privacy_voice_channel)},
{_SC("Embedded"), static_cast< SQInteger >(dpp::af_embedded)},
};
// ------------------------------------------------------------------------------------------------
static const EnumElement g_DpRegionEnum[] = {
{_SC("Brazil"), static_cast< SQInteger >(dpp::r_brazil)},
{_SC("CentralEurope"), static_cast< SQInteger >(dpp::r_central_europe)},
{_SC("HongKong"), static_cast< SQInteger >(dpp::r_hong_kong)},
{_SC("India"), static_cast< SQInteger >(dpp::r_india)},
{_SC("Japan"), static_cast< SQInteger >(dpp::r_japan)},
{_SC("Russia"), static_cast< SQInteger >(dpp::r_russia)},
{_SC("Singapore"), static_cast< SQInteger >(dpp::r_singapore)},
{_SC("SouthAfrica"), static_cast< SQInteger >(dpp::r_south_africa)},
{_SC("Sydney"), static_cast< SQInteger >(dpp::r_sydney)},
{_SC("UsCentral"), static_cast< SQInteger >(dpp::r_us_central)},
{_SC("UsEast"), static_cast< SQInteger >(dpp::r_us_east)},
{_SC("UsSouth"), static_cast< SQInteger >(dpp::r_us_south)},
{_SC("UsWest"), static_cast< SQInteger >(dpp::r_us_west)},
{_SC("WesternEurope"), static_cast< SQInteger >(dpp::r_western_europe)},
};
// ------------------------------------------------------------------------------------------------
static const EnumElement g_DpGuildFlagsEnum[] = {
{_SC("Large"), static_cast< SQInteger >(dpp::g_large)},
{_SC("Unavailable"), static_cast< SQInteger >(dpp::g_unavailable)},
{_SC("WidgetEnabled"), static_cast< SQInteger >(dpp::g_widget_enabled)},
{_SC("InviteSplash"), static_cast< SQInteger >(dpp::g_invite_splash)},
{_SC("VipRegions"), static_cast< SQInteger >(dpp::g_vip_regions)},
{_SC("VanityURL"), static_cast< SQInteger >(dpp::g_vanity_url)},
{_SC("Verified"), static_cast< SQInteger >(dpp::g_verified)},
{_SC("Partnered"), static_cast< SQInteger >(dpp::g_partnered)},
{_SC("Community"), static_cast< SQInteger >(dpp::g_community)},
{_SC("RoleSubscriptionEnabled"), static_cast< SQInteger >(dpp::g_role_subscription_enabled)},
{_SC("News"), static_cast< SQInteger >(dpp::g_news)},
{_SC("Discoverable"), static_cast< SQInteger >(dpp::g_discoverable)},
{_SC("Featureable"), static_cast< SQInteger >(dpp::g_featureable)},
{_SC("AnimatedIcon"), static_cast< SQInteger >(dpp::g_animated_icon)},
{_SC("Banner"), static_cast< SQInteger >(dpp::g_banner)},
{_SC("WelcomeScreenEnabled"), static_cast< SQInteger >(dpp::g_welcome_screen_enabled)},
{_SC("MemberVerificationGate"), static_cast< SQInteger >(dpp::g_member_verification_gate)},
{_SC("PreviewEnabled"), static_cast< SQInteger >(dpp::g_preview_enabled)},
{_SC("NoJoinNotifications"), static_cast< SQInteger >(dpp::g_no_join_notifications)},
{_SC("NoBoostNotifications"), static_cast< SQInteger >(dpp::g_no_boost_notifications)},
{_SC("HasAnimatedIcon"), static_cast< SQInteger >(dpp::g_has_animated_icon)},
{_SC("HasAnimatedBanner"), static_cast< SQInteger >(dpp::g_has_animated_banner)},
{_SC("NoSetupTips"), static_cast< SQInteger >(dpp::g_no_setup_tips)},
{_SC("NoStickerGreeting"), static_cast< SQInteger >(dpp::g_no_sticker_greeting)},
{_SC("MonetizationEnabled"), static_cast< SQInteger >(dpp::g_monetization_enabled)},
{_SC("MoreStickers"), static_cast< SQInteger >(dpp::g_more_stickers)},
{_SC("CreatorStorePageEnabled"), static_cast< SQInteger >(dpp::g_creator_store_page_enabled)},
{_SC("RoleIcons"), static_cast< SQInteger >(dpp::g_role_icons)},
{_SC("SevenDayThreadArchive"), static_cast< SQInteger >(dpp::g_seven_day_thread_archive)},
{_SC("ThreeDayThreadArchive"), static_cast< SQInteger >(dpp::g_three_day_thread_archive)},
{_SC("TicketedEvents"), static_cast< SQInteger >(dpp::g_ticketed_events)},
{_SC("ChannelBanners"), static_cast< SQInteger >(dpp::g_channel_banners)},
};
// ------------------------------------------------------------------------------------------------
static const EnumElement g_DpGuildFlagsExtraEnum[] = {
{_SC("PremiumProgressBarEnabled"), static_cast< SQInteger >(dpp::g_premium_progress_bar_enabled)},
{_SC("AnimatedBanner"), static_cast< SQInteger >(dpp::g_animated_banner)},
{_SC("AutoModeration"), static_cast< SQInteger >(dpp::g_auto_moderation)},
{_SC("InvitesDisabled"), static_cast< SQInteger >(dpp::g_invites_disabled)},
{_SC("DeveloperSupportServer"), static_cast< SQInteger >(dpp::g_developer_support_server)},
{_SC("NoRoleSubscriptionNotifications"), static_cast< SQInteger >(dpp::g_no_role_subscription_notifications)},
{_SC("NoRoleSubscriptionNotificationReplies"), static_cast< SQInteger >(dpp::g_no_role_subscription_notification_replies)},
{_SC("RoleSubscriptionsAvailableForPurchase"), static_cast< SQInteger >(dpp::g_role_subscriptions_available_for_purchase)},
};
// ------------------------------------------------------------------------------------------------
static const EnumElement g_DpGuildMemberFlagsEnum[] = {
{_SC("Deaf"), static_cast< SQInteger >(dpp::gm_deaf)},
{_SC("Mute"), static_cast< SQInteger >(dpp::gm_mute)},
{_SC("Pending"), static_cast< SQInteger >(dpp::gm_pending)},
{_SC("AnimatedAvatar"), static_cast< SQInteger >(dpp::gm_animated_avatar)},
{_SC("VoiceAction"), static_cast< SQInteger >(dpp::gm_voice_action)},
};
// ------------------------------------------------------------------------------------------------
static const EnumElements g_EnumList[] = {
{_SC("SqDiscordLogLevel"), g_DpLogLevelEnum},
{_SC("SqDiscordVoiceStateFlags"), g_DpVoiceStateFlagsEnum},
{_SC("SqDiscordEmojiFlags"), g_DpEmojiFlagsEnum},
{_SC("SqDiscordPresenceFlags"), g_DpPresenceFlagsEnum},
{_SC("SqDiscordPresenceStatus"), g_DpPresenceStatusEnum},
{_SC("SqDiscordActivityType"), g_DpActivityTypeEnum},
{_SC("SqDiscordActivityFlags"), g_DpActivityFlagsEnum},
{_SC("SqDiscordRegion"), g_DpRegionEnum},
{_SC("SqDiscordGuildFlags"), g_DpGuildFlagsEnum},
{_SC("SqDiscordGuildFlagsExtra"), g_DpGuildFlagsExtraEnum},
{_SC("SqDiscordGuildMemberFlags"), g_DpGuildMemberFlagsEnum},
};
// ------------------------------------------------------------------------------------------------
void Register_Discord_Constants(HSQUIRRELVM vm, Table & ns)
{
RegisterEnumerations(vm, g_EnumList);
// --------------------------------------------------------------------------------------------
Enumeration e(vm);
// Bind all events using their associated name
for (SQInteger i = 0; i < static_cast< SQInteger >(DpEventID::Max); ++i)
{
e.Const(DpEventID::NAME[i], i);
}
// Expose the constants
ConstTable(vm).Enum(_SC("SqDiscordEvent"), e);
}
} // Namespace:: SqMod
module/Library/Discord/Constants.hpp
+655
View File
@@ -0,0 +1,655 @@
#pragma once
// ------------------------------------------------------------------------------------------------
#include "Core/Utility.hpp"
// ------------------------------------------------------------------------------------------------
#include <dpp/dpp.h>
// ------------------------------------------------------------------------------------------------
#include <array>
#include <string_view>
// ------------------------------------------------------------------------------------------------
namespace SqMod {
/* ------------------------------------------------------------------------------------------------
* Unique ID for each event.
*/
struct DpEventID
{
/* --------------------------------------------------------------------------------------------
* ID enumeration.
*/
enum Type
{
VoiceStateUpdate=0,
VoiceClientDisconnect,
VoiceClientSpeaking,
Log,
GuildJoinRequestDelete,
InteractionCreate,
SlashCommand,
ButtonClick,
AutoComplete,
SelectClick,
MessageContextMenu,
UserContextMenu,
FormSubmit,
GuildDelete,
ChannelDelete,
ChannelUpdate,
Ready,
MessageDelete,
GuildMemberRemove,
Resumed,
GuildRoleCreate,
TypingStart,
MessageReactionAdd,
GuildMembersChunk,
MessageReactionRemove,
GuildCreate,
ChannelCreate,
MessageReactionRemoveEmoji,
MessageDeleteDulk,
GuildRoleUpdate,
GuildRoleDelete,
ChannelPinsUpdate,
MessageReactionRemoveAll,
VoiceServerUpdate,
GuildEmojisUpdate,
GuildStickersUpdate,
PresenceUpdate,
WebhooksUpdate,
AutomodRuleCreate,
AutomodRuleUpdate,
AutomodRuleDelete,
AutomodRuleExecute,
GuildMemberAdd,
InviteDelete,
GuildUpdate,
GuildIntegrationsUpdate,
GuildMemberUpdate,
InviteCreate,
MessageUpdate,
UserUpdate,
MessageCreate,
GuildBanAdd,
GuildBanRemove,
IntegrationCreate,
IntegrationUpdate,
IntegrationDelete,
ThreadCreate,
ThreadUpdate,
ThreadDelete,
ThreadListSync,
ThreadMemberUpdate,
ThreadMembersUpdate,
GuildScheduledEventCreate,
GuildScheduledEventUpdate,
GuildScheduledEventDelete,
GuildScheduledEventUserAdd,
GuildScheduledEventUserRemove,
VoiceBufferSend,
VoiceUserTalking,
VoiceReady,
VoiceReceive,
VoiceReceiveCombined,
VoiceTrackMarker,
StageInstanceCreate,
StageInstanceUpdate,
StageInstanceDelete,
Max
};
/* --------------------------------------------------------------------------------------------
* String identification for each event ID.
*/
static const std::array< const char *, static_cast< size_t >(Max) > NAME;
};
/* ------------------------------------------------------------------------------------------------
* Structures that hold compile-time type information for events.
*/
struct DpVoiceStateUpdateEventInfo
{
using Type = dpp::voice_state_update_t;
static inline constexpr size_t ID = DpEventID::VoiceStateUpdate;
static inline constexpr std::string_view Name = "VoiceStateUpdate";
};
struct DpVoiceClientDisconnectEventInfo
{
using Type = dpp::voice_client_disconnect_t;
static inline constexpr size_t ID = DpEventID::VoiceClientDisconnect;
static inline constexpr std::string_view Name = "VoiceClientDisconnect";
};
struct DpVoiceClientSpeakingEventInfo
{
using Type = dpp::voice_client_speaking_t;
static inline constexpr size_t ID = DpEventID::VoiceClientSpeaking;
static inline constexpr std::string_view Name = "VoiceClientSpeaking";
};
struct DpLogEventInfo
{
using Type = dpp::log_t;
static inline constexpr size_t ID = DpEventID::Log;
static inline constexpr std::string_view Name = "Log";
};
struct DpGuildJoinRequestDeleteEventInfo
{
using Type = dpp::guild_join_request_delete_t;
static inline constexpr size_t ID = DpEventID::GuildJoinRequestDelete;
static inline constexpr std::string_view Name = "GuildJoinRequestDelete";
};
struct DpInteractionCreateEventInfo
{
using Type = dpp::interaction_create_t;
static inline constexpr size_t ID = DpEventID::InteractionCreate;
static inline constexpr std::string_view Name = "InteractionCreate";
};
struct DpSlashCommandEventInfo
{
using Type = dpp::slashcommand_t;
static inline constexpr size_t ID = DpEventID::SlashCommand;
static inline constexpr std::string_view Name = "SlashCommand";
};
struct DpButtonClickEventInfo
{
using Type = dpp::button_click_t;
static inline constexpr size_t ID = DpEventID::ButtonClick;
static inline constexpr std::string_view Name = "ButtonClick";
};
struct DpAutoCompleteEventInfo
{
using Type = dpp::autocomplete_t;
static inline constexpr size_t ID = DpEventID::AutoComplete;
static inline constexpr std::string_view Name = "AutoComplete";
};
struct DpSelectClickEventInfo
{
using Type = dpp::select_click_t;
static inline constexpr size_t ID = DpEventID::SelectClick;
static inline constexpr std::string_view Name = "SelectClick";
};
struct DpMessageContextMenuEventInfo
{
using Type = dpp::message_context_menu_t;
static inline constexpr size_t ID = DpEventID::MessageContextMenu;
static inline constexpr std::string_view Name = "MessageContextMenu";
};
struct DpUserContextMenuEventInfo
{
using Type = dpp::user_context_menu_t;
static inline constexpr size_t ID = DpEventID::UserContextMenu;
static inline constexpr std::string_view Name = "UserContextMenu";
};
struct DpFormSubmitEventInfo
{
using Type = dpp::form_submit_t;
static inline constexpr size_t ID = DpEventID::FormSubmit;
static inline constexpr std::string_view Name = "FormSubmit";
};
struct DpGuildDeleteEventInfo
{
using Type = dpp::guild_delete_t;
static inline constexpr size_t ID = DpEventID::GuildDelete;
static inline constexpr std::string_view Name = "GuildDelete";
};
struct DpChannelDeleteEventInfo
{
using Type = dpp::channel_delete_t;
static inline constexpr size_t ID = DpEventID::ChannelDelete;
static inline constexpr std::string_view Name = "ChannelDelete";
};
struct DpChannelUpdateEventInfo
{
using Type = dpp::channel_update_t;
static inline constexpr size_t ID = DpEventID::ChannelUpdate;
static inline constexpr std::string_view Name = "ChannelUpdate";
};
struct DpReadyEventInfo
{
using Type = dpp::ready_t;
static inline constexpr size_t ID = DpEventID::Ready;
static inline constexpr std::string_view Name = "Ready";
};
struct DpMessageDeleteEventInfo
{
using Type = dpp::message_delete_t;
static inline constexpr size_t ID = DpEventID::MessageDelete;
static inline constexpr std::string_view Name = "MessageDelete";
};
struct DpGuildMemberRemoveEventInfo
{
using Type = dpp::guild_member_remove_t;
static inline constexpr size_t ID = DpEventID::GuildMemberRemove;
static inline constexpr std::string_view Name = "GuildMemberRemove";
};
struct DpResumedEventInfo
{
using Type = dpp::resumed_t;
static inline constexpr size_t ID = DpEventID::Resumed;
static inline constexpr std::string_view Name = "Resumed";
};
struct DpGuildRoleCreateEventInfo
{
using Type = dpp::guild_role_create_t;
static inline constexpr size_t ID = DpEventID::GuildRoleCreate;
static inline constexpr std::string_view Name = "GuildRoleCreate";
};
struct DpTypingStartEventInfo
{
using Type = dpp::typing_start_t;
static inline constexpr size_t ID = DpEventID::TypingStart;
static inline constexpr std::string_view Name = "TypingStart";
};
struct DpMessageReactionAddEventInfo
{
using Type = dpp::message_reaction_add_t;
static inline constexpr size_t ID = DpEventID::MessageReactionAdd;
static inline constexpr std::string_view Name = "MessageReactionAdd";
};
struct DpGuildMembersChunkEventInfo
{
using Type = dpp::guild_members_chunk_t;
static inline constexpr size_t ID = DpEventID::GuildMembersChunk;
static inline constexpr std::string_view Name = "GuildMembersChunk";
};
struct DpMessageReactionRemoveEventInfo
{
using Type = dpp::message_reaction_remove_t;
static inline constexpr size_t ID = DpEventID::MessageReactionRemove;
static inline constexpr std::string_view Name = "MessageReactionRemove";
};
struct DpGuildCreateEventInfo
{
using Type = dpp::guild_create_t;
static inline constexpr size_t ID = DpEventID::GuildCreate;
static inline constexpr std::string_view Name = "GuildCreate";
};
struct DpChannelCreateEventInfo
{
using Type = dpp::channel_create_t;
static inline constexpr size_t ID = DpEventID::ChannelCreate;
static inline constexpr std::string_view Name = "ChannelCreate";
};
struct DpMessageReactionRemoveEmojiEventInfo
{
using Type = dpp::message_reaction_remove_emoji_t;
static inline constexpr size_t ID = DpEventID::MessageReactionRemoveEmoji;
static inline constexpr std::string_view Name = "MessageReactionRemoveEmoji";
};
struct DpMessageDeleteDulkEventInfo
{
using Type = dpp::message_delete_bulk_t;
static inline constexpr size_t ID = DpEventID::MessageDeleteDulk;
static inline constexpr std::string_view Name = "MessageDeleteDulk";
};
struct DpGuildRoleUpdateEventInfo
{
using Type = dpp::guild_role_update_t;
static inline constexpr size_t ID = DpEventID::GuildRoleUpdate;
static inline constexpr std::string_view Name = "GuildRoleUpdate";
};
struct DpGuildRoleDeleteEventInfo
{
using Type = dpp::guild_role_delete_t;
static inline constexpr size_t ID = DpEventID::GuildRoleDelete;
static inline constexpr std::string_view Name = "GuildRoleDelete";
};
struct DpChannelPinsUpdateEventInfo
{
using Type = dpp::channel_pins_update_t;
static inline constexpr size_t ID = DpEventID::ChannelPinsUpdate;
static inline constexpr std::string_view Name = "ChannelPinsUpdate";
};
struct DpMessageReactionRemoveAllEventInfo
{
using Type = dpp::message_reaction_remove_all_t;
static inline constexpr size_t ID = DpEventID::MessageReactionRemoveAll;
static inline constexpr std::string_view Name = "MessageReactionRemoveAll";
};
struct DpVoiceServerUpdateEventInfo
{
using Type = dpp::voice_server_update_t;
static inline constexpr size_t ID = DpEventID::VoiceServerUpdate;
static inline constexpr std::string_view Name = "VoiceServerUpdate";
};
struct DpGuildEmojisUpdateEventInfo
{
using Type = dpp::guild_emojis_update_t;
static inline constexpr size_t ID = DpEventID::GuildEmojisUpdate;
static inline constexpr std::string_view Name = "GuildEmojisUpdate";
};
struct DpGuildStickersUpdateEventInfo
{
using Type = dpp::guild_stickers_update_t;
static inline constexpr size_t ID = DpEventID::GuildStickersUpdate;
static inline constexpr std::string_view Name = "GuildStickersUpdate";
};
struct DpPresenceUpdateEventInfo
{
using Type = dpp::presence_update_t;
static inline constexpr size_t ID = DpEventID::PresenceUpdate;
static inline constexpr std::string_view Name = "PresenceUpdate";
};
struct DpWebhooksUpdateEventInfo
{
using Type = dpp::webhooks_update_t;
static inline constexpr size_t ID = DpEventID::WebhooksUpdate;
static inline constexpr std::string_view Name = "WebhooksUpdate";
};
struct DpAutomodRuleCreateEventInfo
{
using Type = dpp::automod_rule_create_t;
static inline constexpr size_t ID = DpEventID::AutomodRuleCreate;
static inline constexpr std::string_view Name = "AutomodRuleCreate";
};
struct DpAutomodRuleUpdateEventInfo
{
using Type = dpp::automod_rule_update_t;
static inline constexpr size_t ID = DpEventID::AutomodRuleUpdate;
static inline constexpr std::string_view Name = "AutomodRuleUpdate";
};
struct DpAutomodRuleDeleteEventInfo
{
using Type = dpp::automod_rule_delete_t;
static inline constexpr size_t ID = DpEventID::AutomodRuleDelete;
static inline constexpr std::string_view Name = "AutomodRuleDelete";
};
struct DpAutomodRuleExecuteEventInfo
{
using Type = dpp::automod_rule_execute_t;
static inline constexpr size_t ID = DpEventID::AutomodRuleExecute;
static inline constexpr std::string_view Name = "AutomodRuleExecute";
};
struct DpGuildMemberAddEventInfo
{
using Type = dpp::guild_member_add_t;
static inline constexpr size_t ID = DpEventID::GuildMemberAdd;
static inline constexpr std::string_view Name = "GuildMemberAdd";
};
struct DpInviteDeleteEventInfo
{
using Type = dpp::invite_delete_t;
static inline constexpr size_t ID = DpEventID::InviteDelete;
static inline constexpr std::string_view Name = "InviteDelete";
};
struct DpGuildUpdateEventInfo
{
using Type = dpp::guild_update_t;
static inline constexpr size_t ID = DpEventID::GuildUpdate;
static inline constexpr std::string_view Name = "GuildUpdate";
};
struct DpGuildIntegrationsUpdateEventInfo
{
using Type = dpp::guild_integrations_update_t;
static inline constexpr size_t ID = DpEventID::GuildIntegrationsUpdate;
static inline constexpr std::string_view Name = "GuildIntegrationsUpdate";
};
struct DpGuildMemberUpdateEventInfo
{
using Type = dpp::guild_member_update_t;
static inline constexpr size_t ID = DpEventID::GuildMemberUpdate;
static inline constexpr std::string_view Name = "GuildMemberUpdate";
};
struct DpInviteCreateEventInfo
{
using Type = dpp::invite_create_t;
static inline constexpr size_t ID = DpEventID::InviteCreate;
static inline constexpr std::string_view Name = "InviteCreate";
};
struct DpMessageUpdateEventInfo
{
using Type = dpp::message_update_t;
static inline constexpr size_t ID = DpEventID::MessageUpdate;
static inline constexpr std::string_view Name = "MessageUpdate";
};
struct DpUserUpdateEventInfo
{
using Type = dpp::user_update_t;
static inline constexpr size_t ID = DpEventID::UserUpdate;
static inline constexpr std::string_view Name = "UserUpdate";
};
struct DpMessageCreateEventInfo
{
using Type = dpp::message_create_t;
static inline constexpr size_t ID = DpEventID::MessageCreate;
static inline constexpr std::string_view Name = "MessageCreate";
};
struct DpGuildBanAddEventInfo
{
using Type = dpp::guild_ban_add_t;
static inline constexpr size_t ID = DpEventID::GuildBanAdd;
static inline constexpr std::string_view Name = "GuildBanAdd";
};
struct DpGuildBanRemoveEventInfo
{
using Type = dpp::guild_ban_remove_t;
static inline constexpr size_t ID = DpEventID::GuildBanRemove;
static inline constexpr std::string_view Name = "GuildBanRemove";
};
struct DpIntegrationCreateEventInfo
{
using Type = dpp::integration_create_t;
static inline constexpr size_t ID = DpEventID::IntegrationCreate;
static inline constexpr std::string_view Name = "IntegrationCreate";
};
struct DpIntegrationUpdateEventInfo
{
using Type = dpp::integration_update_t;
static inline constexpr size_t ID = DpEventID::IntegrationUpdate;
static inline constexpr std::string_view Name = "IntegrationUpdate";
};
struct DpIntegrationDeleteEventInfo
{
using Type = dpp::integration_delete_t;
static inline constexpr size_t ID = DpEventID::IntegrationDelete;
static inline constexpr std::string_view Name = "IntegrationDelete";
};
struct DpThreadCreateEventInfo
{
using Type = dpp::thread_create_t;
static inline constexpr size_t ID = DpEventID::ThreadCreate;
static inline constexpr std::string_view Name = "ThreadCreate";
};
struct DpThreadUpdateEventInfo
{
using Type = dpp::thread_update_t;
static inline constexpr size_t ID = DpEventID::ThreadUpdate;
static inline constexpr std::string_view Name = "ThreadUpdate";
};
struct DpThreadDeleteEventInfo
{
using Type = dpp::thread_delete_t;
static inline constexpr size_t ID = DpEventID::ThreadDelete;
static inline constexpr std::string_view Name = "ThreadDelete";
};
struct DpThreadListSyncEventInfo
{
using Type = dpp::thread_list_sync_t;
static inline constexpr size_t ID = DpEventID::ThreadListSync;
static inline constexpr std::string_view Name = "ThreadListSync";
};
struct DpThreadMemberUpdateEventInfo
{
using Type = dpp::thread_member_update_t;
static inline constexpr size_t ID = DpEventID::ThreadMemberUpdate;
static inline constexpr std::string_view Name = "ThreadMemberUpdate";
};
struct DpThreadMembersUpdateEventInfo
{
using Type = dpp::thread_members_update_t;
static inline constexpr size_t ID = DpEventID::ThreadMembersUpdate;
static inline constexpr std::string_view Name = "ThreadMembersUpdate";
};
struct DpGuildScheduledEventCreateEventInfo
{
using Type = dpp::guild_scheduled_event_create_t;
static inline constexpr size_t ID = DpEventID::GuildScheduledEventCreate;
static inline constexpr std::string_view Name = "GuildScheduledEventCreate";
};
struct DpGuildScheduledEventUpdateEventInfo
{
using Type = dpp::guild_scheduled_event_update_t;
static inline constexpr size_t ID = DpEventID::GuildScheduledEventUpdate;
static inline constexpr std::string_view Name = "GuildScheduledEventUpdate";
};
struct DpGuildScheduledEventDeleteEventInfo
{
using Type = dpp::guild_scheduled_event_delete_t;
static inline constexpr size_t ID = DpEventID::GuildScheduledEventDelete;
static inline constexpr std::string_view Name = "GuildScheduledEventDelete";
};
struct DpGuildScheduledEventUserAddEventInfo
{
using Type = dpp::guild_scheduled_event_user_add_t;
static inline constexpr size_t ID = DpEventID::GuildScheduledEventUserAdd;
static inline constexpr std::string_view Name = "GuildScheduledEventUserAdd";
};
struct DpGuildScheduledEventUserRemoveEventInfo
{
using Type = dpp::guild_scheduled_event_user_remove_t;
static inline constexpr size_t ID = DpEventID::GuildScheduledEventUserRemove;
static inline constexpr std::string_view Name = "GuildScheduledEventUserRemove";
};
struct DpVoiceBufferSendEventInfo
{
using Type = dpp::voice_buffer_send_t;
static inline constexpr size_t ID = DpEventID::VoiceBufferSend;
static inline constexpr std::string_view Name = "VoiceBufferSend";
};
struct DpVoiceUserTalkingEventInfo
{
using Type = dpp::voice_user_talking_t;
static inline constexpr size_t ID = DpEventID::VoiceUserTalking;
static inline constexpr std::string_view Name = "VoiceUserTalking";
};
struct DpVoiceReadyEventInfo
{
using Type = dpp::voice_ready_t;
static inline constexpr size_t ID = DpEventID::VoiceReady;
static inline constexpr std::string_view Name = "VoiceReady";
};
struct DpVoiceReceiveEventInfo
{
using Type = dpp::voice_receive_t;
static inline constexpr size_t ID = DpEventID::VoiceReceive;
static inline constexpr std::string_view Name = "VoiceReceive";
};
struct DpVoiceReceiveCombinedEventInfo
{
using Type = dpp::voice_receive_t;
static inline constexpr size_t ID = DpEventID::VoiceReceiveCombined;
static inline constexpr std::string_view Name = "VoiceReceiveCombined";
};
struct DpVoiceTrackMarkerEventInfo
{
using Type = dpp::voice_track_marker_t;
static inline constexpr size_t ID = DpEventID::VoiceTrackMarker;
static inline constexpr std::string_view Name = "VoiceTrackMarker";
};
struct DpStageInstanceCreateEventInfo
{
using Type = dpp::stage_instance_create_t;
static inline constexpr size_t ID = DpEventID::StageInstanceCreate;
static inline constexpr std::string_view Name = "StageInstanceCreate";
};
struct DpStageInstanceUpdateEventInfo
{
using Type = dpp::stage_instance_update_t;
static inline constexpr size_t ID = DpEventID::StageInstanceUpdate;
static inline constexpr std::string_view Name = "StageInstanceUpdate";
};
struct DpStageInstanceDeleteEventInfo
{
using Type = dpp::stage_instance_delete_t;
static inline constexpr size_t ID = DpEventID::StageInstanceDelete;
static inline constexpr std::string_view Name = "StageInstanceDelete";
};
/* ------------------------------------------------------------------------------------------------
* Utility used to acquire event information at compile time.
*/
template < int > struct EventInfoID;
/* ------------------------------------------------------------------------------------------------
* Implementation.
*/
template < > struct EventInfoID< DpEventID::VoiceStateUpdate > : public DpVoiceStateUpdateEventInfo { };
template < > struct EventInfoID< DpEventID::VoiceClientDisconnect > : public DpVoiceClientDisconnectEventInfo { };
template < > struct EventInfoID< DpEventID::VoiceClientSpeaking > : public DpVoiceClientSpeakingEventInfo { };
template < > struct EventInfoID< DpEventID::Log > : public DpLogEventInfo { };
template < > struct EventInfoID< DpEventID::GuildJoinRequestDelete > : public DpGuildJoinRequestDeleteEventInfo { };
template < > struct EventInfoID< DpEventID::InteractionCreate > : public DpInteractionCreateEventInfo { };
template < > struct EventInfoID< DpEventID::SlashCommand > : public DpSlashCommandEventInfo { };
template < > struct EventInfoID< DpEventID::ButtonClick > : public DpButtonClickEventInfo { };
template < > struct EventInfoID< DpEventID::AutoComplete > : public DpAutoCompleteEventInfo { };
template < > struct EventInfoID< DpEventID::SelectClick > : public DpSelectClickEventInfo { };
template < > struct EventInfoID< DpEventID::MessageContextMenu > : public DpMessageContextMenuEventInfo { };
template < > struct EventInfoID< DpEventID::UserContextMenu > : public DpUserContextMenuEventInfo { };
template < > struct EventInfoID< DpEventID::FormSubmit > : public DpFormSubmitEventInfo { };
template < > struct EventInfoID< DpEventID::GuildDelete > : public DpGuildDeleteEventInfo { };
template < > struct EventInfoID< DpEventID::ChannelDelete > : public DpChannelDeleteEventInfo { };
template < > struct EventInfoID< DpEventID::ChannelUpdate > : public DpChannelUpdateEventInfo { };
template < > struct EventInfoID< DpEventID::Ready > : public DpReadyEventInfo { };
template < > struct EventInfoID< DpEventID::MessageDelete > : public DpMessageDeleteEventInfo { };
template < > struct EventInfoID< DpEventID::GuildMemberRemove > : public DpGuildMemberRemoveEventInfo { };
template < > struct EventInfoID< DpEventID::Resumed > : public DpResumedEventInfo { };
template < > struct EventInfoID< DpEventID::GuildRoleCreate > : public DpGuildRoleCreateEventInfo { };
template < > struct EventInfoID< DpEventID::TypingStart > : public DpTypingStartEventInfo { };
template < > struct EventInfoID< DpEventID::MessageReactionAdd > : public DpMessageReactionAddEventInfo { };
template < > struct EventInfoID< DpEventID::GuildMembersChunk > : public DpGuildMembersChunkEventInfo { };
template < > struct EventInfoID< DpEventID::MessageReactionRemove > : public DpMessageReactionRemoveEventInfo { };
template < > struct EventInfoID< DpEventID::GuildCreate > : public DpGuildCreateEventInfo { };
template < > struct EventInfoID< DpEventID::ChannelCreate > : public DpChannelCreateEventInfo { };
template < > struct EventInfoID< DpEventID::MessageReactionRemoveEmoji > : public DpMessageReactionRemoveEmojiEventInfo { };
template < > struct EventInfoID< DpEventID::MessageDeleteDulk > : public DpMessageDeleteDulkEventInfo { };
template < > struct EventInfoID< DpEventID::GuildRoleUpdate > : public DpGuildRoleUpdateEventInfo { };
template < > struct EventInfoID< DpEventID::GuildRoleDelete > : public DpGuildRoleDeleteEventInfo { };
template < > struct EventInfoID< DpEventID::ChannelPinsUpdate > : public DpChannelPinsUpdateEventInfo { };
template < > struct EventInfoID< DpEventID::MessageReactionRemoveAll > : public DpMessageReactionRemoveAllEventInfo { };
template < > struct EventInfoID< DpEventID::VoiceServerUpdate > : public DpVoiceServerUpdateEventInfo { };
template < > struct EventInfoID< DpEventID::GuildEmojisUpdate > : public DpGuildEmojisUpdateEventInfo { };
template < > struct EventInfoID< DpEventID::GuildStickersUpdate > : public DpGuildStickersUpdateEventInfo { };
template < > struct EventInfoID< DpEventID::PresenceUpdate > : public DpPresenceUpdateEventInfo { };
template < > struct EventInfoID< DpEventID::WebhooksUpdate > : public DpWebhooksUpdateEventInfo { };
template < > struct EventInfoID< DpEventID::AutomodRuleCreate > : public DpAutomodRuleCreateEventInfo { };
template < > struct EventInfoID< DpEventID::AutomodRuleUpdate > : public DpAutomodRuleUpdateEventInfo { };
template < > struct EventInfoID< DpEventID::AutomodRuleDelete > : public DpAutomodRuleDeleteEventInfo { };
template < > struct EventInfoID< DpEventID::AutomodRuleExecute > : public DpAutomodRuleExecuteEventInfo { };
template < > struct EventInfoID< DpEventID::GuildMemberAdd > : public DpGuildMemberAddEventInfo { };
template < > struct EventInfoID< DpEventID::InviteDelete > : public DpInviteDeleteEventInfo { };
template < > struct EventInfoID< DpEventID::GuildUpdate > : public DpGuildUpdateEventInfo { };
template < > struct EventInfoID< DpEventID::GuildIntegrationsUpdate > : public DpGuildIntegrationsUpdateEventInfo { };
template < > struct EventInfoID< DpEventID::GuildMemberUpdate > : public DpGuildMemberUpdateEventInfo { };
template < > struct EventInfoID< DpEventID::InviteCreate > : public DpInviteCreateEventInfo { };
template < > struct EventInfoID< DpEventID::MessageUpdate > : public DpMessageUpdateEventInfo { };
template < > struct EventInfoID< DpEventID::UserUpdate > : public DpUserUpdateEventInfo { };
template < > struct EventInfoID< DpEventID::MessageCreate > : public DpMessageCreateEventInfo { };
template < > struct EventInfoID< DpEventID::GuildBanAdd > : public DpGuildBanAddEventInfo { };
template < > struct EventInfoID< DpEventID::GuildBanRemove > : public DpGuildBanRemoveEventInfo { };
template < > struct EventInfoID< DpEventID::IntegrationCreate > : public DpIntegrationCreateEventInfo { };
template < > struct EventInfoID< DpEventID::IntegrationUpdate > : public DpIntegrationUpdateEventInfo { };
template < > struct EventInfoID< DpEventID::IntegrationDelete > : public DpIntegrationDeleteEventInfo { };
template < > struct EventInfoID< DpEventID::ThreadCreate > : public DpThreadCreateEventInfo { };
template < > struct EventInfoID< DpEventID::ThreadUpdate > : public DpThreadUpdateEventInfo { };
template < > struct EventInfoID< DpEventID::ThreadDelete > : public DpThreadDeleteEventInfo { };
template < > struct EventInfoID< DpEventID::ThreadListSync > : public DpThreadListSyncEventInfo { };
template < > struct EventInfoID< DpEventID::ThreadMemberUpdate > : public DpThreadMemberUpdateEventInfo { };
template < > struct EventInfoID< DpEventID::ThreadMembersUpdate > : public DpThreadMembersUpdateEventInfo { };
template < > struct EventInfoID< DpEventID::GuildScheduledEventCreate > : public DpGuildScheduledEventCreateEventInfo { };
template < > struct EventInfoID< DpEventID::GuildScheduledEventUpdate > : public DpGuildScheduledEventUpdateEventInfo { };
template < > struct EventInfoID< DpEventID::GuildScheduledEventDelete > : public DpGuildScheduledEventDeleteEventInfo { };
template < > struct EventInfoID< DpEventID::GuildScheduledEventUserAdd > : public DpGuildScheduledEventUserAddEventInfo { };
template < > struct EventInfoID< DpEventID::GuildScheduledEventUserRemove > : public DpGuildScheduledEventUserRemoveEventInfo { };
template < > struct EventInfoID< DpEventID::VoiceBufferSend > : public DpVoiceBufferSendEventInfo { };
template < > struct EventInfoID< DpEventID::VoiceUserTalking > : public DpVoiceUserTalkingEventInfo { };
template < > struct EventInfoID< DpEventID::VoiceReady > : public DpVoiceReadyEventInfo { };
template < > struct EventInfoID< DpEventID::VoiceReceive > : public DpVoiceReceiveEventInfo { };
template < > struct EventInfoID< DpEventID::VoiceReceiveCombined > : public DpVoiceReceiveCombinedEventInfo { };
template < > struct EventInfoID< DpEventID::VoiceTrackMarker > : public DpVoiceTrackMarkerEventInfo { };
template < > struct EventInfoID< DpEventID::StageInstanceCreate > : public DpStageInstanceCreateEventInfo { };
template < > struct EventInfoID< DpEventID::StageInstanceUpdate > : public DpStageInstanceUpdateEventInfo { };
template < > struct EventInfoID< DpEventID::StageInstanceDelete > : public DpStageInstanceDeleteEventInfo { };
} // Namespace:: SqMod
module/Library/Discord/Events.cpp
+777
View File
@@ -0,0 +1,777 @@
// ------------------------------------------------------------------------------------------------
#include "Library/Discord/Events.hpp"
// ------------------------------------------------------------------------------------------------
namespace SqMod {
// ------------------------------------------------------------------------------------------------
SQMOD_DECL_TYPENAME(SqDpVoiceStateUpdateEvent, _SC("SqDiscordVoiceStateUpdateEvent"))
SQMOD_DECL_TYPENAME(SqDpVoiceClientDisconnectEvent, _SC("SqDiscordVoiceClientDisconnectEvent"))
SQMOD_DECL_TYPENAME(SqDpVoiceClientSpeakingEvent, _SC("SqDiscordVoiceClientSpeakingEvent"))
SQMOD_DECL_TYPENAME(SqDpLogEvent, _SC("SqDiscordLogEvent"))
SQMOD_DECL_TYPENAME(SqDpGuildJoinRequestDeleteEvent, _SC("SqDiscordGuildJoinRequestDeleteEvent"))
SQMOD_DECL_TYPENAME(SqDpInteractionCreateEvent, _SC("SqDiscordInteractionCreateEvent"))
SQMOD_DECL_TYPENAME(SqDpSlashCommandEvent, _SC("SqDiscordSlashCommandEvent"))
SQMOD_DECL_TYPENAME(SqDpButtonClickEvent, _SC("SqDiscordButtonClickEvent"))
SQMOD_DECL_TYPENAME(SqDpAutoCompleteEvent, _SC("SqDiscordAutoCompleteEvent"))
SQMOD_DECL_TYPENAME(SqDpSelectClickEvent, _SC("SqDiscordSelectClickEvent"))
SQMOD_DECL_TYPENAME(SqDpMessageContextMenuEvent, _SC("SqDiscordMessageContextMenuEvent"))
SQMOD_DECL_TYPENAME(SqDpUserContextMenuEvent, _SC("SqDiscordUserContextMenuEvent"))
SQMOD_DECL_TYPENAME(SqDpFormSubmitEvent, _SC("SqDiscordFormSubmitEvent"))
SQMOD_DECL_TYPENAME(SqDpGuildDeleteEvent, _SC("SqDiscordGuildDeleteEvent"))
SQMOD_DECL_TYPENAME(SqDpChannelDeleteEvent, _SC("SqDiscordChannelDeleteEvent"))
SQMOD_DECL_TYPENAME(SqDpChannelUpdateEvent, _SC("SqDiscordChannelUpdateEvent"))
SQMOD_DECL_TYPENAME(SqDpReadyEvent, _SC("SqDiscordReadyEvent"))
SQMOD_DECL_TYPENAME(SqDpMessageDeleteEvent, _SC("SqDiscordMessageDeleteEvent"))
SQMOD_DECL_TYPENAME(SqDpGuildMemberRemoveEvent, _SC("SqDiscordGuildMemberRemoveEvent"))
SQMOD_DECL_TYPENAME(SqDpResumedEvent, _SC("SqDiscordResumedEvent"))
SQMOD_DECL_TYPENAME(SqDpGuildRoleCreateEvent, _SC("SqDiscordGuildRoleCreateEvent"))
SQMOD_DECL_TYPENAME(SqDpTypingStartEvent, _SC("SqDiscordTypingStartEvent"))
SQMOD_DECL_TYPENAME(SqDpMessageReactionAddEvent, _SC("SqDiscordMessageReactionAddEvent"))
SQMOD_DECL_TYPENAME(SqDpGuildMembersChunkEvent, _SC("SqDiscordGuildMembersChunkEvent"))
SQMOD_DECL_TYPENAME(SqDpMessageReactionRemoveEvent, _SC("SqDiscordMessageReactionRemoveEvent"))
SQMOD_DECL_TYPENAME(SqDpGuildCreateEvent, _SC("SqDiscordGuildCreateEvent"))
SQMOD_DECL_TYPENAME(SqDpChannelCreateEvent, _SC("SqDiscordChannelCreateEvent"))
SQMOD_DECL_TYPENAME(SqDpMessageReactionRemoveEmojiEvent, _SC("SqDiscordMessageReactionRemoveEmojiEvent"))
SQMOD_DECL_TYPENAME(SqDpMessageDeleteDulkEvent, _SC("SqDiscordMessageDeleteDulkEvent"))
SQMOD_DECL_TYPENAME(SqDpGuildRoleUpdateEvent, _SC("SqDiscordGuildRoleUpdateEvent"))
SQMOD_DECL_TYPENAME(SqDpGuildRoleDeleteEvent, _SC("SqDiscordGuildRoleDeleteEvent"))
SQMOD_DECL_TYPENAME(SqDpChannelPinsUpdateEvent, _SC("SqDiscordChannelPinsUpdateEvent"))
SQMOD_DECL_TYPENAME(SqDpMessageReactionRemoveAllEvent, _SC("SqDiscordMessageReactionRemoveAllEvent"))
SQMOD_DECL_TYPENAME(SqDpVoiceServerUpdateEvent, _SC("SqDiscordVoiceServerUpdateEvent"))
SQMOD_DECL_TYPENAME(SqDpGuildEmojisUpdateEvent, _SC("SqDiscordGuildEmojisUpdateEvent"))
SQMOD_DECL_TYPENAME(SqDpGuildStickersUpdateEvent, _SC("SqDiscordGuildStickersUpdateEvent"))
SQMOD_DECL_TYPENAME(SqDpPresenceUpdateEvent, _SC("SqDiscordPresenceUpdateEvent"))
SQMOD_DECL_TYPENAME(SqDpWebhooksUpdateEvent, _SC("SqDiscordWebhooksUpdateEvent"))
SQMOD_DECL_TYPENAME(SqDpAutomodRuleCreateEvent, _SC("SqDiscordAutomodRuleCreateEvent"))
SQMOD_DECL_TYPENAME(SqDpAutomodRuleUpdateEvent, _SC("SqDiscordAutomodRuleUpdateEvent"))
SQMOD_DECL_TYPENAME(SqDpAutomodRuleDeleteEvent, _SC("SqDiscordAutomodRuleDeleteEvent"))
SQMOD_DECL_TYPENAME(SqDpAutomodRuleExecuteEvent, _SC("SqDiscordAutomodRuleExecuteEvent"))
SQMOD_DECL_TYPENAME(SqDpGuildMemberAddEvent, _SC("SqDiscordGuildMemberAddEvent"))
SQMOD_DECL_TYPENAME(SqDpInviteDeleteEvent, _SC("SqDiscordInviteDeleteEvent"))
SQMOD_DECL_TYPENAME(SqDpGuildUpdateEvent, _SC("SqDiscordGuildUpdateEvent"))
SQMOD_DECL_TYPENAME(SqDpGuildIntegrationsUpdateEvent, _SC("SqDiscordGuildIntegrationsUpdateEvent"))
SQMOD_DECL_TYPENAME(SqDpGuildMemberUpdateEvent, _SC("SqDiscordGuildMemberUpdateEvent"))
SQMOD_DECL_TYPENAME(SqDpInviteCreateEvent, _SC("SqDiscordInviteCreateEvent"))
SQMOD_DECL_TYPENAME(SqDpMessageUpdateEvent, _SC("SqDiscordMessageUpdateEvent"))
SQMOD_DECL_TYPENAME(SqDpUserUpdateEvent, _SC("SqDiscordUserUpdateEvent"))
SQMOD_DECL_TYPENAME(SqDpMessageCreateEvent, _SC("SqDiscordMessageCreateEvent"))
SQMOD_DECL_TYPENAME(SqDpGuildBanAddEvent, _SC("SqDiscordGuildBanAddEvent"))
SQMOD_DECL_TYPENAME(SqDpGuildBanRemoveEvent, _SC("SqDiscordGuildBanRemoveEvent"))
SQMOD_DECL_TYPENAME(SqDpIntegrationCreateEvent, _SC("SqDiscordIntegrationCreateEvent"))
SQMOD_DECL_TYPENAME(SqDpIntegrationUpdateEvent, _SC("SqDiscordIntegrationUpdateEvent"))
SQMOD_DECL_TYPENAME(SqDpIntegrationDeleteEvent, _SC("SqDiscordIntegrationDeleteEvent"))
SQMOD_DECL_TYPENAME(SqDpThreadCreateEvent, _SC("SqDiscordThreadCreateEvent"))
SQMOD_DECL_TYPENAME(SqDpThreadUpdateEvent, _SC("SqDiscordThreadUpdateEvent"))
SQMOD_DECL_TYPENAME(SqDpThreadDeleteEvent, _SC("SqDiscordThreadDeleteEvent"))
SQMOD_DECL_TYPENAME(SqDpThreadListSyncEvent, _SC("SqDiscordThreadListSyncEvent"))
SQMOD_DECL_TYPENAME(SqDpThreadMemberUpdateEvent, _SC("SqDiscordThreadMemberUpdateEvent"))
SQMOD_DECL_TYPENAME(SqDpThreadMembersUpdateEvent, _SC("SqDiscordThreadMembersUpdateEvent"))
SQMOD_DECL_TYPENAME(SqDpGuildScheduledEventCreateEvent, _SC("SqDiscordGuildScheduledEventCreateEvent"))
SQMOD_DECL_TYPENAME(SqDpGuildScheduledEventUpdateEvent, _SC("SqDiscordGuildScheduledEventUpdateEvent"))
SQMOD_DECL_TYPENAME(SqDpGuildScheduledEventDeleteEvent, _SC("SqDiscordGuildScheduledEventDeleteEvent"))
SQMOD_DECL_TYPENAME(SqDpGuildScheduledEventUserAddEvent, _SC("SqDiscordGuildScheduledEventUserAddEvent"))
SQMOD_DECL_TYPENAME(SqDpGuildScheduledEventUserRemoveEvent, _SC("SqDiscordGuildScheduledEventUserRemoveEvent"))
SQMOD_DECL_TYPENAME(SqDpVoiceBufferSendEvent, _SC("SqDiscordVoiceBufferSendEvent"))
SQMOD_DECL_TYPENAME(SqDpVoiceUserTalkingEvent, _SC("SqDiscordVoiceUserTalkingEvent"))
SQMOD_DECL_TYPENAME(SqDpVoiceReadyEvent, _SC("SqDiscordVoiceReadyEvent"))
SQMOD_DECL_TYPENAME(SqDpVoiceReceiveEvent, _SC("SqDiscordVoiceReceiveEvent"))
SQMOD_DECL_TYPENAME(SqDpVoiceReceiveCombinedEvent, _SC("SqDiscordVoiceReceiveCombinedEvent"))
SQMOD_DECL_TYPENAME(SqDpVoiceTrackMarkerEvent, _SC("SqDiscordVoiceTrackMarkerEvent"))
SQMOD_DECL_TYPENAME(SqDpStageInstanceCreateEvent, _SC("SqDiscordStageInstanceCreateEvent"))
SQMOD_DECL_TYPENAME(SqDpStageInstanceUpdateEvent, _SC("SqDiscordStageInstanceUpdateEvent"))
SQMOD_DECL_TYPENAME(SqDpStageInstanceDeleteEvent, _SC("SqDiscordStageInstanceDeleteEvent"))
// ------------------------------------------------------------------------------------------------
void Register_Discord_Events(HSQUIRRELVM vm, Table & ns)
{
// --------------------------------------------------------------------------------------------
ns.Bind(_SC("VoiceStateUpdate"),
Class< DpVoiceStateUpdateEvent, NoConstructor< DpVoiceStateUpdateEvent > >(vm, SqDpVoiceStateUpdateEvent::Str)
// Meta-methods
.SquirrelFunc(_SC("_typename"), &SqDpVoiceStateUpdateEvent::Fn)
.Func(_SC("_tostring"), &DpVoiceStateUpdateEvent::GetRawEvent)
// Member Properties
.Prop(_SC("Raw"), &DpVoiceStateUpdateEvent::GetRawEvent)
.Prop(_SC("State"), &DpVoiceStateUpdateEvent::GetState)
);
// --------------------------------------------------------------------------------------------
ns.Bind(_SC("VoiceClientDisconnect"),
Class< DpVoiceClientDisconnectEvent, NoConstructor< DpVoiceClientDisconnectEvent > >(vm, SqDpVoiceClientDisconnectEvent::Str)
// Meta-methods
.SquirrelFunc(_SC("_typename"), &SqDpVoiceClientDisconnectEvent::Fn)
.Func(_SC("_tostring"), &DpVoiceClientDisconnectEvent::GetRawEvent)
// Member Properties
.Prop(_SC("Raw"), &DpVoiceClientDisconnectEvent::GetRawEvent)
);
// --------------------------------------------------------------------------------------------
ns.Bind(_SC("VoiceClientSpeaking"),
Class< DpVoiceClientSpeakingEvent, NoConstructor< DpVoiceClientSpeakingEvent > >(vm, SqDpVoiceClientSpeakingEvent::Str)
// Meta-methods
.SquirrelFunc(_SC("_typename"), &SqDpVoiceClientSpeakingEvent::Fn)
.Func(_SC("_tostring"), &DpVoiceClientSpeakingEvent::GetRawEvent)
// Member Properties
.Prop(_SC("Raw"), &DpVoiceClientSpeakingEvent::GetRawEvent)
);
// --------------------------------------------------------------------------------------------
ns.Bind(_SC("Log"),
Class< DpLogEvent, NoConstructor< DpLogEvent > >(vm, SqDpLogEvent::Str)
// Meta-methods
.SquirrelFunc(_SC("_typename"), &SqDpLogEvent::Fn)
.Func(_SC("_tostring"), &DpLogEvent::GetRawEvent)
// Member Properties
.Prop(_SC("Raw"), &DpLogEvent::GetRawEvent)
.Prop(_SC("Severity"), &DpLogEvent::GetSeverity)
.Prop(_SC("Message"), &DpLogEvent::GetMessage)
);
// --------------------------------------------------------------------------------------------
ns.Bind(_SC("GuildJoinRequestDelete"),
Class< DpGuildJoinRequestDeleteEvent, NoConstructor< DpGuildJoinRequestDeleteEvent > >(vm, SqDpGuildJoinRequestDeleteEvent::Str)
// Meta-methods
.SquirrelFunc(_SC("_typename"), &SqDpGuildJoinRequestDeleteEvent::Fn)
.Func(_SC("_tostring"), &DpGuildJoinRequestDeleteEvent::GetRawEvent)
// Member Properties
.Prop(_SC("Raw"), &DpGuildJoinRequestDeleteEvent::GetRawEvent)
);
// --------------------------------------------------------------------------------------------
ns.Bind(_SC("InteractionCreate"),
Class< DpInteractionCreateEvent, NoConstructor< DpInteractionCreateEvent > >(vm, SqDpInteractionCreateEvent::Str)
// Meta-methods
.SquirrelFunc(_SC("_typename"), &SqDpInteractionCreateEvent::Fn)
.Func(_SC("_tostring"), &DpInteractionCreateEvent::GetRawEvent)
// Member Properties
.Prop(_SC("Raw"), &DpInteractionCreateEvent::GetRawEvent)
);
// --------------------------------------------------------------------------------------------
ns.Bind(_SC("SlashCommand"),
Class< DpSlashCommandEvent, NoConstructor< DpSlashCommandEvent > >(vm, SqDpSlashCommandEvent::Str)
// Meta-methods
.SquirrelFunc(_SC("_typename"), &SqDpSlashCommandEvent::Fn)
.Func(_SC("_tostring"), &DpSlashCommandEvent::GetRawEvent)
// Member Properties
.Prop(_SC("Raw"), &DpSlashCommandEvent::GetRawEvent)
);
// --------------------------------------------------------------------------------------------
ns.Bind(_SC("ButtonClick"),
Class< DpButtonClickEvent, NoConstructor< DpButtonClickEvent > >(vm, SqDpButtonClickEvent::Str)
// Meta-methods
.SquirrelFunc(_SC("_typename"), &SqDpButtonClickEvent::Fn)
.Func(_SC("_tostring"), &DpButtonClickEvent::GetRawEvent)
// Member Properties
.Prop(_SC("Raw"), &DpButtonClickEvent::GetRawEvent)
);
// --------------------------------------------------------------------------------------------
ns.Bind(_SC("AutoComplete"),
Class< DpAutoCompleteEvent, NoConstructor< DpAutoCompleteEvent > >(vm, SqDpAutoCompleteEvent::Str)
// Meta-methods
.SquirrelFunc(_SC("_typename"), &SqDpAutoCompleteEvent::Fn)
.Func(_SC("_tostring"), &DpAutoCompleteEvent::GetRawEvent)
// Member Properties
.Prop(_SC("Raw"), &DpAutoCompleteEvent::GetRawEvent)
);
// --------------------------------------------------------------------------------------------
ns.Bind(_SC("SelectClick"),
Class< DpSelectClickEvent, NoConstructor< DpSelectClickEvent > >(vm, SqDpSelectClickEvent::Str)
// Meta-methods
.SquirrelFunc(_SC("_typename"), &SqDpSelectClickEvent::Fn)
.Func(_SC("_tostring"), &DpSelectClickEvent::GetRawEvent)
// Member Properties
.Prop(_SC("Raw"), &DpSelectClickEvent::GetRawEvent)
);
// --------------------------------------------------------------------------------------------
ns.Bind(_SC("MessageContextMenu"),
Class< DpMessageContextMenuEvent, NoConstructor< DpMessageContextMenuEvent > >(vm, SqDpMessageContextMenuEvent::Str)
// Meta-methods
.SquirrelFunc(_SC("_typename"), &SqDpMessageContextMenuEvent::Fn)
.Func(_SC("_tostring"), &DpMessageContextMenuEvent::GetRawEvent)
// Member Properties
.Prop(_SC("Raw"), &DpMessageContextMenuEvent::GetRawEvent)
);
// --------------------------------------------------------------------------------------------
ns.Bind(_SC("UserContextMenu"),
Class< DpUserContextMenuEvent, NoConstructor< DpUserContextMenuEvent > >(vm, SqDpUserContextMenuEvent::Str)
// Meta-methods
.SquirrelFunc(_SC("_typename"), &SqDpUserContextMenuEvent::Fn)
.Func(_SC("_tostring"), &DpUserContextMenuEvent::GetRawEvent)
// Member Properties
.Prop(_SC("Raw"), &DpUserContextMenuEvent::GetRawEvent)
);
// --------------------------------------------------------------------------------------------
ns.Bind(_SC("FormSubmit"),
Class< DpFormSubmitEvent, NoConstructor< DpFormSubmitEvent > >(vm, SqDpFormSubmitEvent::Str)
// Meta-methods
.SquirrelFunc(_SC("_typename"), &SqDpFormSubmitEvent::Fn)
.Func(_SC("_tostring"), &DpFormSubmitEvent::GetRawEvent)
// Member Properties
.Prop(_SC("Raw"), &DpFormSubmitEvent::GetRawEvent)
);
// --------------------------------------------------------------------------------------------
ns.Bind(_SC("GuildDelete"),
Class< DpGuildDeleteEvent, NoConstructor< DpGuildDeleteEvent > >(vm, SqDpGuildDeleteEvent::Str)
// Meta-methods
.SquirrelFunc(_SC("_typename"), &SqDpGuildDeleteEvent::Fn)
.Func(_SC("_tostring"), &DpGuildDeleteEvent::GetRawEvent)
// Member Properties
.Prop(_SC("Raw"), &DpGuildDeleteEvent::GetRawEvent)
);
// --------------------------------------------------------------------------------------------
ns.Bind(_SC("ChannelDelete"),
Class< DpChannelDeleteEvent, NoConstructor< DpChannelDeleteEvent > >(vm, SqDpChannelDeleteEvent::Str)
// Meta-methods
.SquirrelFunc(_SC("_typename"), &SqDpChannelDeleteEvent::Fn)
.Func(_SC("_tostring"), &DpChannelDeleteEvent::GetRawEvent)
// Member Properties
.Prop(_SC("Raw"), &DpChannelDeleteEvent::GetRawEvent)
);
// --------------------------------------------------------------------------------------------
ns.Bind(_SC("ChannelUpdate"),
Class< DpChannelUpdateEvent, NoConstructor< DpChannelUpdateEvent > >(vm, SqDpChannelUpdateEvent::Str)
// Meta-methods
.SquirrelFunc(_SC("_typename"), &SqDpChannelUpdateEvent::Fn)
.Func(_SC("_tostring"), &DpChannelUpdateEvent::GetRawEvent)
// Member Properties
.Prop(_SC("Raw"), &DpChannelUpdateEvent::GetRawEvent)
);
// --------------------------------------------------------------------------------------------
ns.Bind(_SC("Ready"),
Class< DpReadyEvent, NoConstructor< DpReadyEvent > >(vm, SqDpReadyEvent::Str)
// Meta-methods
.SquirrelFunc(_SC("_typename"), &SqDpReadyEvent::Fn)
.Func(_SC("_tostring"), &DpReadyEvent::GetRawEvent)
// Member Properties
.Prop(_SC("Raw"), &DpReadyEvent::GetRawEvent)
);
// --------------------------------------------------------------------------------------------
ns.Bind(_SC("MessageDelete"),
Class< DpMessageDeleteEvent, NoConstructor< DpMessageDeleteEvent > >(vm, SqDpMessageDeleteEvent::Str)
// Meta-methods
.SquirrelFunc(_SC("_typename"), &SqDpMessageDeleteEvent::Fn)
.Func(_SC("_tostring"), &DpMessageDeleteEvent::GetRawEvent)
// Member Properties
.Prop(_SC("Raw"), &DpMessageDeleteEvent::GetRawEvent)
);
// --------------------------------------------------------------------------------------------
ns.Bind(_SC("GuildMemberRemove"),
Class< DpGuildMemberRemoveEvent, NoConstructor< DpGuildMemberRemoveEvent > >(vm, SqDpGuildMemberRemoveEvent::Str)
// Meta-methods
.SquirrelFunc(_SC("_typename"), &SqDpGuildMemberRemoveEvent::Fn)
.Func(_SC("_tostring"), &DpGuildMemberRemoveEvent::GetRawEvent)
// Member Properties
.Prop(_SC("Raw"), &DpGuildMemberRemoveEvent::GetRawEvent)
);
// --------------------------------------------------------------------------------------------
ns.Bind(_SC("Resumed"),
Class< DpResumedEvent, NoConstructor< DpResumedEvent > >(vm, SqDpResumedEvent::Str)
// Meta-methods
.SquirrelFunc(_SC("_typename"), &SqDpResumedEvent::Fn)
.Func(_SC("_tostring"), &DpResumedEvent::GetRawEvent)
// Member Properties
.Prop(_SC("Raw"), &DpResumedEvent::GetRawEvent)
);
// --------------------------------------------------------------------------------------------
ns.Bind(_SC("GuildRoleCreate"),
Class< DpGuildRoleCreateEvent, NoConstructor< DpGuildRoleCreateEvent > >(vm, SqDpGuildRoleCreateEvent::Str)
// Meta-methods
.SquirrelFunc(_SC("_typename"), &SqDpGuildRoleCreateEvent::Fn)
.Func(_SC("_tostring"), &DpGuildRoleCreateEvent::GetRawEvent)
// Member Properties
.Prop(_SC("Raw"), &DpGuildRoleCreateEvent::GetRawEvent)
);
// --------------------------------------------------------------------------------------------
ns.Bind(_SC("TypingStart"),
Class< DpTypingStartEvent, NoConstructor< DpTypingStartEvent > >(vm, SqDpTypingStartEvent::Str)
// Meta-methods
.SquirrelFunc(_SC("_typename"), &SqDpTypingStartEvent::Fn)
.Func(_SC("_tostring"), &DpTypingStartEvent::GetRawEvent)
// Member Properties
.Prop(_SC("Raw"), &DpTypingStartEvent::GetRawEvent)
);
// --------------------------------------------------------------------------------------------
ns.Bind(_SC("MessageReactionAdd"),
Class< DpMessageReactionAddEvent, NoConstructor< DpMessageReactionAddEvent > >(vm, SqDpMessageReactionAddEvent::Str)
// Meta-methods
.SquirrelFunc(_SC("_typename"), &SqDpMessageReactionAddEvent::Fn)
.Func(_SC("_tostring"), &DpMessageReactionAddEvent::GetRawEvent)
// Member Properties
.Prop(_SC("Raw"), &DpMessageReactionAddEvent::GetRawEvent)
);
// --------------------------------------------------------------------------------------------
ns.Bind(_SC("GuildMembersChunk"),
Class< DpGuildMembersChunkEvent, NoConstructor< DpGuildMembersChunkEvent > >(vm, SqDpGuildMembersChunkEvent::Str)
// Meta-methods
.SquirrelFunc(_SC("_typename"), &SqDpGuildMembersChunkEvent::Fn)
.Func(_SC("_tostring"), &DpGuildMembersChunkEvent::GetRawEvent)
// Member Properties
.Prop(_SC("Raw"), &DpGuildMembersChunkEvent::GetRawEvent)
);
// --------------------------------------------------------------------------------------------
ns.Bind(_SC("MessageReactionRemove"),
Class< DpMessageReactionRemoveEvent, NoConstructor< DpMessageReactionRemoveEvent > >(vm, SqDpMessageReactionRemoveEvent::Str)
// Meta-methods
.SquirrelFunc(_SC("_typename"), &SqDpMessageReactionRemoveEvent::Fn)
.Func(_SC("_tostring"), &DpMessageReactionRemoveEvent::GetRawEvent)
// Member Properties
.Prop(_SC("Raw"), &DpMessageReactionRemoveEvent::GetRawEvent)
);
// --------------------------------------------------------------------------------------------
ns.Bind(_SC("GuildCreate"),
Class< DpGuildCreateEvent, NoConstructor< DpGuildCreateEvent > >(vm, SqDpGuildCreateEvent::Str)
// Meta-methods
.SquirrelFunc(_SC("_typename"), &SqDpGuildCreateEvent::Fn)
.Func(_SC("_tostring"), &DpGuildCreateEvent::GetRawEvent)
// Member Properties
.Prop(_SC("Raw"), &DpGuildCreateEvent::GetRawEvent)
);
// --------------------------------------------------------------------------------------------
ns.Bind(_SC("ChannelCreate"),
Class< DpChannelCreateEvent, NoConstructor< DpChannelCreateEvent > >(vm, SqDpChannelCreateEvent::Str)
// Meta-methods
.SquirrelFunc(_SC("_typename"), &SqDpChannelCreateEvent::Fn)
.Func(_SC("_tostring"), &DpChannelCreateEvent::GetRawEvent)
// Member Properties
.Prop(_SC("Raw"), &DpChannelCreateEvent::GetRawEvent)
);
// --------------------------------------------------------------------------------------------
ns.Bind(_SC("MessageReactionRemoveEmoji"),
Class< DpMessageReactionRemoveEmojiEvent, NoConstructor< DpMessageReactionRemoveEmojiEvent > >(vm, SqDpMessageReactionRemoveEmojiEvent::Str)
// Meta-methods
.SquirrelFunc(_SC("_typename"), &SqDpMessageReactionRemoveEmojiEvent::Fn)
.Func(_SC("_tostring"), &DpMessageReactionRemoveEmojiEvent::GetRawEvent)
// Member Properties
.Prop(_SC("Raw"), &DpMessageReactionRemoveEmojiEvent::GetRawEvent)
);
// --------------------------------------------------------------------------------------------
ns.Bind(_SC("MessageDeleteDulk"),
Class< DpMessageDeleteDulkEvent, NoConstructor< DpMessageDeleteDulkEvent > >(vm, SqDpMessageDeleteDulkEvent::Str)
// Meta-methods
.SquirrelFunc(_SC("_typename"), &SqDpMessageDeleteDulkEvent::Fn)
.Func(_SC("_tostring"), &DpMessageDeleteDulkEvent::GetRawEvent)
// Member Properties
.Prop(_SC("Raw"), &DpMessageDeleteDulkEvent::GetRawEvent)
);
// --------------------------------------------------------------------------------------------
ns.Bind(_SC("GuildRoleUpdate"),
Class< DpGuildRoleUpdateEvent, NoConstructor< DpGuildRoleUpdateEvent > >(vm, SqDpGuildRoleUpdateEvent::Str)
// Meta-methods
.SquirrelFunc(_SC("_typename"), &SqDpGuildRoleUpdateEvent::Fn)
.Func(_SC("_tostring"), &DpGuildRoleUpdateEvent::GetRawEvent)
// Member Properties
.Prop(_SC("Raw"), &DpGuildRoleUpdateEvent::GetRawEvent)
);
// --------------------------------------------------------------------------------------------
ns.Bind(_SC("GuildRoleDelete"),
Class< DpGuildRoleDeleteEvent, NoConstructor< DpGuildRoleDeleteEvent > >(vm, SqDpGuildRoleDeleteEvent::Str)
// Meta-methods
.SquirrelFunc(_SC("_typename"), &SqDpGuildRoleDeleteEvent::Fn)
.Func(_SC("_tostring"), &DpGuildRoleDeleteEvent::GetRawEvent)
// Member Properties
.Prop(_SC("Raw"), &DpGuildRoleDeleteEvent::GetRawEvent)
);
// --------------------------------------------------------------------------------------------
ns.Bind(_SC("ChannelPinsUpdate"),
Class< DpChannelPinsUpdateEvent, NoConstructor< DpChannelPinsUpdateEvent > >(vm, SqDpChannelPinsUpdateEvent::Str)
// Meta-methods
.SquirrelFunc(_SC("_typename"), &SqDpChannelPinsUpdateEvent::Fn)
.Func(_SC("_tostring"), &DpChannelPinsUpdateEvent::GetRawEvent)
// Member Properties
.Prop(_SC("Raw"), &DpChannelPinsUpdateEvent::GetRawEvent)
);
// --------------------------------------------------------------------------------------------
ns.Bind(_SC("MessageReactionRemoveAll"),
Class< DpMessageReactionRemoveAllEvent, NoConstructor< DpMessageReactionRemoveAllEvent > >(vm, SqDpMessageReactionRemoveAllEvent::Str)
// Meta-methods
.SquirrelFunc(_SC("_typename"), &SqDpMessageReactionRemoveAllEvent::Fn)
.Func(_SC("_tostring"), &DpMessageReactionRemoveAllEvent::GetRawEvent)
// Member Properties
.Prop(_SC("Raw"), &DpMessageReactionRemoveAllEvent::GetRawEvent)
);
// --------------------------------------------------------------------------------------------
ns.Bind(_SC("VoiceServerUpdate"),
Class< DpVoiceServerUpdateEvent, NoConstructor< DpVoiceServerUpdateEvent > >(vm, SqDpVoiceServerUpdateEvent::Str)
// Meta-methods
.SquirrelFunc(_SC("_typename"), &SqDpVoiceServerUpdateEvent::Fn)
.Func(_SC("_tostring"), &DpVoiceServerUpdateEvent::GetRawEvent)
// Member Properties
.Prop(_SC("Raw"), &DpVoiceServerUpdateEvent::GetRawEvent)
);
// --------------------------------------------------------------------------------------------
ns.Bind(_SC("GuildEmojisUpdate"),
Class< DpGuildEmojisUpdateEvent, NoConstructor< DpGuildEmojisUpdateEvent > >(vm, SqDpGuildEmojisUpdateEvent::Str)
// Meta-methods
.SquirrelFunc(_SC("_typename"), &SqDpGuildEmojisUpdateEvent::Fn)
.Func(_SC("_tostring"), &DpGuildEmojisUpdateEvent::GetRawEvent)
// Member Properties
.Prop(_SC("Raw"), &DpGuildEmojisUpdateEvent::GetRawEvent)
);
// --------------------------------------------------------------------------------------------
ns.Bind(_SC("GuildStickersUpdate"),
Class< DpGuildStickersUpdateEvent, NoConstructor< DpGuildStickersUpdateEvent > >(vm, SqDpGuildStickersUpdateEvent::Str)
// Meta-methods
.SquirrelFunc(_SC("_typename"), &SqDpGuildStickersUpdateEvent::Fn)
.Func(_SC("_tostring"), &DpGuildStickersUpdateEvent::GetRawEvent)
// Member Properties
.Prop(_SC("Raw"), &DpGuildStickersUpdateEvent::GetRawEvent)
);
// --------------------------------------------------------------------------------------------
ns.Bind(_SC("PresenceUpdate"),
Class< DpPresenceUpdateEvent, NoConstructor< DpPresenceUpdateEvent > >(vm, SqDpPresenceUpdateEvent::Str)
// Meta-methods
.SquirrelFunc(_SC("_typename"), &SqDpPresenceUpdateEvent::Fn)
.Func(_SC("_tostring"), &DpPresenceUpdateEvent::GetRawEvent)
// Member Properties
.Prop(_SC("Raw"), &DpPresenceUpdateEvent::GetRawEvent)
);
// --------------------------------------------------------------------------------------------
ns.Bind(_SC("WebhooksUpdate"),
Class< DpWebhooksUpdateEvent, NoConstructor< DpWebhooksUpdateEvent > >(vm, SqDpWebhooksUpdateEvent::Str)
// Meta-methods
.SquirrelFunc(_SC("_typename"), &SqDpWebhooksUpdateEvent::Fn)
.Func(_SC("_tostring"), &DpWebhooksUpdateEvent::GetRawEvent)
// Member Properties
.Prop(_SC("Raw"), &DpWebhooksUpdateEvent::GetRawEvent)
);
// --------------------------------------------------------------------------------------------
ns.Bind(_SC("AutomodRuleCreate"),
Class< DpAutomodRuleCreateEvent, NoConstructor< DpAutomodRuleCreateEvent > >(vm, SqDpAutomodRuleCreateEvent::Str)
// Meta-methods
.SquirrelFunc(_SC("_typename"), &SqDpAutomodRuleCreateEvent::Fn)
.Func(_SC("_tostring"), &DpAutomodRuleCreateEvent::GetRawEvent)
// Member Properties
.Prop(_SC("Raw"), &DpAutomodRuleCreateEvent::GetRawEvent)
);
// --------------------------------------------------------------------------------------------
ns.Bind(_SC("AutomodRuleUpdate"),
Class< DpAutomodRuleUpdateEvent, NoConstructor< DpAutomodRuleUpdateEvent > >(vm, SqDpAutomodRuleUpdateEvent::Str)
// Meta-methods
.SquirrelFunc(_SC("_typename"), &SqDpAutomodRuleUpdateEvent::Fn)
.Func(_SC("_tostring"), &DpAutomodRuleUpdateEvent::GetRawEvent)
// Member Properties
.Prop(_SC("Raw"), &DpAutomodRuleUpdateEvent::GetRawEvent)
);
// --------------------------------------------------------------------------------------------
ns.Bind(_SC("AutomodRuleDelete"),
Class< DpAutomodRuleDeleteEvent, NoConstructor< DpAutomodRuleDeleteEvent > >(vm, SqDpAutomodRuleDeleteEvent::Str)
// Meta-methods
.SquirrelFunc(_SC("_typename"), &SqDpAutomodRuleDeleteEvent::Fn)
.Func(_SC("_tostring"), &DpAutomodRuleDeleteEvent::GetRawEvent)
// Member Properties
.Prop(_SC("Raw"), &DpAutomodRuleDeleteEvent::GetRawEvent)
);
// --------------------------------------------------------------------------------------------
ns.Bind(_SC("AutomodRuleExecute"),
Class< DpAutomodRuleExecuteEvent, NoConstructor< DpAutomodRuleExecuteEvent > >(vm, SqDpAutomodRuleExecuteEvent::Str)
// Meta-methods
.SquirrelFunc(_SC("_typename"), &SqDpAutomodRuleExecuteEvent::Fn)
.Func(_SC("_tostring"), &DpAutomodRuleExecuteEvent::GetRawEvent)
// Member Properties
.Prop(_SC("Raw"), &DpAutomodRuleExecuteEvent::GetRawEvent)
);
// --------------------------------------------------------------------------------------------
ns.Bind(_SC("GuildMemberAdd"),
Class< DpGuildMemberAddEvent, NoConstructor< DpGuildMemberAddEvent > >(vm, SqDpGuildMemberAddEvent::Str)
// Meta-methods
.SquirrelFunc(_SC("_typename"), &SqDpGuildMemberAddEvent::Fn)
.Func(_SC("_tostring"), &DpGuildMemberAddEvent::GetRawEvent)
// Member Properties
.Prop(_SC("Raw"), &DpGuildMemberAddEvent::GetRawEvent)
);
// --------------------------------------------------------------------------------------------
ns.Bind(_SC("InviteDelete"),
Class< DpInviteDeleteEvent, NoConstructor< DpInviteDeleteEvent > >(vm, SqDpInviteDeleteEvent::Str)
// Meta-methods
.SquirrelFunc(_SC("_typename"), &SqDpInviteDeleteEvent::Fn)
.Func(_SC("_tostring"), &DpInviteDeleteEvent::GetRawEvent)
// Member Properties
.Prop(_SC("Raw"), &DpInviteDeleteEvent::GetRawEvent)
);
// --------------------------------------------------------------------------------------------
ns.Bind(_SC("GuildUpdate"),
Class< DpGuildUpdateEvent, NoConstructor< DpGuildUpdateEvent > >(vm, SqDpGuildUpdateEvent::Str)
// Meta-methods
.SquirrelFunc(_SC("_typename"), &SqDpGuildUpdateEvent::Fn)
.Func(_SC("_tostring"), &DpGuildUpdateEvent::GetRawEvent)
// Member Properties
.Prop(_SC("Raw"), &DpGuildUpdateEvent::GetRawEvent)
);
// --------------------------------------------------------------------------------------------
ns.Bind(_SC("GuildIntegrationsUpdate"),
Class< DpGuildIntegrationsUpdateEvent, NoConstructor< DpGuildIntegrationsUpdateEvent > >(vm, SqDpGuildIntegrationsUpdateEvent::Str)
// Meta-methods
.SquirrelFunc(_SC("_typename"), &SqDpGuildIntegrationsUpdateEvent::Fn)
.Func(_SC("_tostring"), &DpGuildIntegrationsUpdateEvent::GetRawEvent)
// Member Properties
.Prop(_SC("Raw"), &DpGuildIntegrationsUpdateEvent::GetRawEvent)
);
// --------------------------------------------------------------------------------------------
ns.Bind(_SC("GuildMemberUpdate"),
Class< DpGuildMemberUpdateEvent, NoConstructor< DpGuildMemberUpdateEvent > >(vm, SqDpGuildMemberUpdateEvent::Str)
// Meta-methods
.SquirrelFunc(_SC("_typename"), &SqDpGuildMemberUpdateEvent::Fn)
.Func(_SC("_tostring"), &DpGuildMemberUpdateEvent::GetRawEvent)
// Member Properties
.Prop(_SC("Raw"), &DpGuildMemberUpdateEvent::GetRawEvent)
);
// --------------------------------------------------------------------------------------------
ns.Bind(_SC("InviteCreate"),
Class< DpInviteCreateEvent, NoConstructor< DpInviteCreateEvent > >(vm, SqDpInviteCreateEvent::Str)
// Meta-methods
.SquirrelFunc(_SC("_typename"), &SqDpInviteCreateEvent::Fn)
.Func(_SC("_tostring"), &DpInviteCreateEvent::GetRawEvent)
// Member Properties
.Prop(_SC("Raw"), &DpInviteCreateEvent::GetRawEvent)
);
// --------------------------------------------------------------------------------------------
ns.Bind(_SC("MessageUpdate"),
Class< DpMessageUpdateEvent, NoConstructor< DpMessageUpdateEvent > >(vm, SqDpMessageUpdateEvent::Str)
// Meta-methods
.SquirrelFunc(_SC("_typename"), &SqDpMessageUpdateEvent::Fn)
.Func(_SC("_tostring"), &DpMessageUpdateEvent::GetRawEvent)
// Member Properties
.Prop(_SC("Raw"), &DpMessageUpdateEvent::GetRawEvent)
);
// --------------------------------------------------------------------------------------------
ns.Bind(_SC("UserUpdate"),
Class< DpUserUpdateEvent, NoConstructor< DpUserUpdateEvent > >(vm, SqDpUserUpdateEvent::Str)
// Meta-methods
.SquirrelFunc(_SC("_typename"), &SqDpUserUpdateEvent::Fn)
.Func(_SC("_tostring"), &DpUserUpdateEvent::GetRawEvent)
// Member Properties
.Prop(_SC("Raw"), &DpUserUpdateEvent::GetRawEvent)
);
// --------------------------------------------------------------------------------------------
ns.Bind(_SC("MessageCreate"),
Class< DpMessageCreateEvent, NoConstructor< DpMessageCreateEvent > >(vm, SqDpMessageCreateEvent::Str)
// Meta-methods
.SquirrelFunc(_SC("_typename"), &SqDpMessageCreateEvent::Fn)
.Func(_SC("_tostring"), &DpMessageCreateEvent::GetRawEvent)
// Member Properties
.Prop(_SC("Raw"), &DpMessageCreateEvent::GetRawEvent)
);
// --------------------------------------------------------------------------------------------
ns.Bind(_SC("GuildBanAdd"),
Class< DpGuildBanAddEvent, NoConstructor< DpGuildBanAddEvent > >(vm, SqDpGuildBanAddEvent::Str)
// Meta-methods
.SquirrelFunc(_SC("_typename"), &SqDpGuildBanAddEvent::Fn)
.Func(_SC("_tostring"), &DpGuildBanAddEvent::GetRawEvent)
// Member Properties
.Prop(_SC("Raw"), &DpGuildBanAddEvent::GetRawEvent)
);
// --------------------------------------------------------------------------------------------
ns.Bind(_SC("GuildBanRemove"),
Class< DpGuildBanRemoveEvent, NoConstructor< DpGuildBanRemoveEvent > >(vm, SqDpGuildBanRemoveEvent::Str)
// Meta-methods
.SquirrelFunc(_SC("_typename"), &SqDpGuildBanRemoveEvent::Fn)
.Func(_SC("_tostring"), &DpGuildBanRemoveEvent::GetRawEvent)
// Member Properties
.Prop(_SC("Raw"), &DpGuildBanRemoveEvent::GetRawEvent)
);
// --------------------------------------------------------------------------------------------
ns.Bind(_SC("IntegrationCreate"),
Class< DpIntegrationCreateEvent, NoConstructor< DpIntegrationCreateEvent > >(vm, SqDpIntegrationCreateEvent::Str)
// Meta-methods
.SquirrelFunc(_SC("_typename"), &SqDpIntegrationCreateEvent::Fn)
.Func(_SC("_tostring"), &DpIntegrationCreateEvent::GetRawEvent)
// Member Properties
.Prop(_SC("Raw"), &DpIntegrationCreateEvent::GetRawEvent)
);
// --------------------------------------------------------------------------------------------
ns.Bind(_SC("IntegrationUpdate"),
Class< DpIntegrationUpdateEvent, NoConstructor< DpIntegrationUpdateEvent > >(vm, SqDpIntegrationUpdateEvent::Str)
// Meta-methods
.SquirrelFunc(_SC("_typename"), &SqDpIntegrationUpdateEvent::Fn)
.Func(_SC("_tostring"), &DpIntegrationUpdateEvent::GetRawEvent)
// Member Properties
.Prop(_SC("Raw"), &DpIntegrationUpdateEvent::GetRawEvent)
);
// --------------------------------------------------------------------------------------------
ns.Bind(_SC("IntegrationDelete"),
Class< DpIntegrationDeleteEvent, NoConstructor< DpIntegrationDeleteEvent > >(vm, SqDpIntegrationDeleteEvent::Str)
// Meta-methods
.SquirrelFunc(_SC("_typename"), &SqDpIntegrationDeleteEvent::Fn)
.Func(_SC("_tostring"), &DpIntegrationDeleteEvent::GetRawEvent)
// Member Properties
.Prop(_SC("Raw"), &DpIntegrationDeleteEvent::GetRawEvent)
);
// --------------------------------------------------------------------------------------------
ns.Bind(_SC("ThreadCreate"),
Class< DpThreadCreateEvent, NoConstructor< DpThreadCreateEvent > >(vm, SqDpThreadCreateEvent::Str)
// Meta-methods
.SquirrelFunc(_SC("_typename"), &SqDpThreadCreateEvent::Fn)
.Func(_SC("_tostring"), &DpThreadCreateEvent::GetRawEvent)
// Member Properties
.Prop(_SC("Raw"), &DpThreadCreateEvent::GetRawEvent)
);
// --------------------------------------------------------------------------------------------
ns.Bind(_SC("ThreadUpdate"),
Class< DpThreadUpdateEvent, NoConstructor< DpThreadUpdateEvent > >(vm, SqDpThreadUpdateEvent::Str)
// Meta-methods
.SquirrelFunc(_SC("_typename"), &SqDpThreadUpdateEvent::Fn)
.Func(_SC("_tostring"), &DpThreadUpdateEvent::GetRawEvent)
// Member Properties
.Prop(_SC("Raw"), &DpThreadUpdateEvent::GetRawEvent)
);
// --------------------------------------------------------------------------------------------
ns.Bind(_SC("ThreadDelete"),
Class< DpThreadDeleteEvent, NoConstructor< DpThreadDeleteEvent > >(vm, SqDpThreadDeleteEvent::Str)
// Meta-methods
.SquirrelFunc(_SC("_typename"), &SqDpThreadDeleteEvent::Fn)
.Func(_SC("_tostring"), &DpThreadDeleteEvent::GetRawEvent)
// Member Properties
.Prop(_SC("Raw"), &DpThreadDeleteEvent::GetRawEvent)
);
// --------------------------------------------------------------------------------------------
ns.Bind(_SC("ThreadListSync"),
Class< DpThreadListSyncEvent, NoConstructor< DpThreadListSyncEvent > >(vm, SqDpThreadListSyncEvent::Str)
// Meta-methods
.SquirrelFunc(_SC("_typename"), &SqDpThreadListSyncEvent::Fn)
.Func(_SC("_tostring"), &DpThreadListSyncEvent::GetRawEvent)
// Member Properties
.Prop(_SC("Raw"), &DpThreadListSyncEvent::GetRawEvent)
);
// --------------------------------------------------------------------------------------------
ns.Bind(_SC("ThreadMemberUpdate"),
Class< DpThreadMemberUpdateEvent, NoConstructor< DpThreadMemberUpdateEvent > >(vm, SqDpThreadMemberUpdateEvent::Str)
// Meta-methods
.SquirrelFunc(_SC("_typename"), &SqDpThreadMemberUpdateEvent::Fn)
.Func(_SC("_tostring"), &DpThreadMemberUpdateEvent::GetRawEvent)
// Member Properties
.Prop(_SC("Raw"), &DpThreadMemberUpdateEvent::GetRawEvent)
);
// --------------------------------------------------------------------------------------------
ns.Bind(_SC("ThreadMembersUpdate"),
Class< DpThreadMembersUpdateEvent, NoConstructor< DpThreadMembersUpdateEvent > >(vm, SqDpThreadMembersUpdateEvent::Str)
// Meta-methods
.SquirrelFunc(_SC("_typename"), &SqDpThreadMembersUpdateEvent::Fn)
.Func(_SC("_tostring"), &DpThreadMembersUpdateEvent::GetRawEvent)
// Member Properties
.Prop(_SC("Raw"), &DpThreadMembersUpdateEvent::GetRawEvent)
);
// --------------------------------------------------------------------------------------------
ns.Bind(_SC("GuildScheduledEventCreate"),
Class< DpGuildScheduledEventCreateEvent, NoConstructor< DpGuildScheduledEventCreateEvent > >(vm, SqDpGuildScheduledEventCreateEvent::Str)
// Meta-methods
.SquirrelFunc(_SC("_typename"), &SqDpGuildScheduledEventCreateEvent::Fn)
.Func(_SC("_tostring"), &DpGuildScheduledEventCreateEvent::GetRawEvent)
// Member Properties
.Prop(_SC("Raw"), &DpGuildScheduledEventCreateEvent::GetRawEvent)
);
// --------------------------------------------------------------------------------------------
ns.Bind(_SC("GuildScheduledEventUpdate"),
Class< DpGuildScheduledEventUpdateEvent, NoConstructor< DpGuildScheduledEventUpdateEvent > >(vm, SqDpGuildScheduledEventUpdateEvent::Str)
// Meta-methods
.SquirrelFunc(_SC("_typename"), &SqDpGuildScheduledEventUpdateEvent::Fn)
.Func(_SC("_tostring"), &DpGuildScheduledEventUpdateEvent::GetRawEvent)
// Member Properties
.Prop(_SC("Raw"), &DpGuildScheduledEventUpdateEvent::GetRawEvent)
);
// --------------------------------------------------------------------------------------------
ns.Bind(_SC("GuildScheduledEventDelete"),
Class< DpGuildScheduledEventDeleteEvent, NoConstructor< DpGuildScheduledEventDeleteEvent > >(vm, SqDpGuildScheduledEventDeleteEvent::Str)
// Meta-methods
.SquirrelFunc(_SC("_typename"), &SqDpGuildScheduledEventDeleteEvent::Fn)
.Func(_SC("_tostring"), &DpGuildScheduledEventDeleteEvent::GetRawEvent)
// Member Properties
.Prop(_SC("Raw"), &DpGuildScheduledEventDeleteEvent::GetRawEvent)
);
// --------------------------------------------------------------------------------------------
ns.Bind(_SC("GuildScheduledEventUserAdd"),
Class< DpGuildScheduledEventUserAddEvent, NoConstructor< DpGuildScheduledEventUserAddEvent > >(vm, SqDpGuildScheduledEventUserAddEvent::Str)
// Meta-methods
.SquirrelFunc(_SC("_typename"), &SqDpGuildScheduledEventUserAddEvent::Fn)
.Func(_SC("_tostring"), &DpGuildScheduledEventUserAddEvent::GetRawEvent)
// Member Properties
.Prop(_SC("Raw"), &DpGuildScheduledEventUserAddEvent::GetRawEvent)
);
// --------------------------------------------------------------------------------------------
ns.Bind(_SC("GuildScheduledEventUserRemove"),
Class< DpGuildScheduledEventUserRemoveEvent, NoConstructor< DpGuildScheduledEventUserRemoveEvent > >(vm, SqDpGuildScheduledEventUserRemoveEvent::Str)
// Meta-methods
.SquirrelFunc(_SC("_typename"), &SqDpGuildScheduledEventUserRemoveEvent::Fn)
.Func(_SC("_tostring"), &DpGuildScheduledEventUserRemoveEvent::GetRawEvent)
// Member Properties
.Prop(_SC("Raw"), &DpGuildScheduledEventUserRemoveEvent::GetRawEvent)
);
// --------------------------------------------------------------------------------------------
ns.Bind(_SC("VoiceBufferSend"),
Class< DpVoiceBufferSendEvent, NoConstructor< DpVoiceBufferSendEvent > >(vm, SqDpVoiceBufferSendEvent::Str)
// Meta-methods
.SquirrelFunc(_SC("_typename"), &SqDpVoiceBufferSendEvent::Fn)
.Func(_SC("_tostring"), &DpVoiceBufferSendEvent::GetRawEvent)
// Member Properties
.Prop(_SC("Raw"), &DpVoiceBufferSendEvent::GetRawEvent)
);
// --------------------------------------------------------------------------------------------
ns.Bind(_SC("VoiceUserTalking"),
Class< DpVoiceUserTalkingEvent, NoConstructor< DpVoiceUserTalkingEvent > >(vm, SqDpVoiceUserTalkingEvent::Str)
// Meta-methods
.SquirrelFunc(_SC("_typename"), &SqDpVoiceUserTalkingEvent::Fn)
.Func(_SC("_tostring"), &DpVoiceUserTalkingEvent::GetRawEvent)
// Member Properties
.Prop(_SC("Raw"), &DpVoiceUserTalkingEvent::GetRawEvent)
);
// --------------------------------------------------------------------------------------------
ns.Bind(_SC("VoiceReady"),
Class< DpVoiceReadyEvent, NoConstructor< DpVoiceReadyEvent > >(vm, SqDpVoiceReadyEvent::Str)
// Meta-methods
.SquirrelFunc(_SC("_typename"), &SqDpVoiceReadyEvent::Fn)
.Func(_SC("_tostring"), &DpVoiceReadyEvent::GetRawEvent)
// Member Properties
.Prop(_SC("Raw"), &DpVoiceReadyEvent::GetRawEvent)
);
// --------------------------------------------------------------------------------------------
ns.Bind(_SC("VoiceReceive"),
Class< DpVoiceReceiveEvent, NoConstructor< DpVoiceReceiveEvent > >(vm, SqDpVoiceReceiveEvent::Str)
// Meta-methods
.SquirrelFunc(_SC("_typename"), &SqDpVoiceReceiveEvent::Fn)
.Func(_SC("_tostring"), &DpVoiceReceiveEvent::GetRawEvent)
// Member Properties
.Prop(_SC("Raw"), &DpVoiceReceiveEvent::GetRawEvent)
);
// --------------------------------------------------------------------------------------------
ns.Bind(_SC("VoiceReceive"),
Class< DpVoiceReceiveCombinedEvent, NoConstructor< DpVoiceReceiveCombinedEvent > >(vm, SqDpVoiceReceiveCombinedEvent::Str)
// Meta-methods
.SquirrelFunc(_SC("_typename"), &SqDpVoiceReceiveCombinedEvent::Fn)
.Func(_SC("_tostring"), &DpVoiceReceiveCombinedEvent::GetRawEvent)
// Member Properties
.Prop(_SC("Raw"), &DpVoiceReceiveCombinedEvent::GetRawEvent)
);
// --------------------------------------------------------------------------------------------
ns.Bind(_SC("VoiceTrackMarker"),
Class< DpVoiceTrackMarkerEvent, NoConstructor< DpVoiceTrackMarkerEvent > >(vm, SqDpVoiceTrackMarkerEvent::Str)
// Meta-methods
.SquirrelFunc(_SC("_typename"), &SqDpVoiceTrackMarkerEvent::Fn)
.Func(_SC("_tostring"), &DpVoiceTrackMarkerEvent::GetRawEvent)
// Member Properties
.Prop(_SC("Raw"), &DpVoiceTrackMarkerEvent::GetRawEvent)
);
// --------------------------------------------------------------------------------------------
ns.Bind(_SC("StageInstanceCreate"),
Class< DpStageInstanceCreateEvent, NoConstructor< DpStageInstanceCreateEvent > >(vm, SqDpStageInstanceCreateEvent::Str)
// Meta-methods
.SquirrelFunc(_SC("_typename"), &SqDpStageInstanceCreateEvent::Fn)
.Func(_SC("_tostring"), &DpStageInstanceCreateEvent::GetRawEvent)
// Member Properties
.Prop(_SC("Raw"), &DpStageInstanceCreateEvent::GetRawEvent)
);
// --------------------------------------------------------------------------------------------
ns.Bind(_SC("StageInstanceUpdate"),
Class< DpStageInstanceUpdateEvent, NoConstructor< DpStageInstanceUpdateEvent > >(vm, SqDpStageInstanceUpdateEvent::Str)
// Meta-methods
.SquirrelFunc(_SC("_typename"), &SqDpStageInstanceUpdateEvent::Fn)
.Func(_SC("_tostring"), &DpStageInstanceUpdateEvent::GetRawEvent)
// Member Properties
.Prop(_SC("Raw"), &DpStageInstanceUpdateEvent::GetRawEvent)
);
// --------------------------------------------------------------------------------------------
ns.Bind(_SC("StageInstanceDelete"),
Class< DpStageInstanceDeleteEvent, NoConstructor< DpStageInstanceDeleteEvent > >(vm, SqDpStageInstanceDeleteEvent::Str)
// Meta-methods
.SquirrelFunc(_SC("_typename"), &SqDpStageInstanceDeleteEvent::Fn)
.Func(_SC("_tostring"), &DpStageInstanceDeleteEvent::GetRawEvent)
// Member Properties
.Prop(_SC("Raw"), &DpStageInstanceDeleteEvent::GetRawEvent)
);
}
} // Namespace:: SqMod
module/Library/Discord/Events.hpp
+2683
View File
File diff suppressed because it is too large Load Diff
module/Library/Discord/Guild.cpp
+65
View File
@@ -0,0 +1,65 @@
// ------------------------------------------------------------------------------------------------
#include "Library/Discord/Guild.hpp"
// ------------------------------------------------------------------------------------------------
namespace SqMod {
// ------------------------------------------------------------------------------------------------
SQMOD_DECL_TYPENAME(SqDpGuildMember, _SC("SqDiscordGuildMember"))
SQMOD_DECL_TYPENAME(SqDpGuild, _SC("SqDiscordGuild"))
// ------------------------------------------------------------------------------------------------
void Register_Discord_Guild(HSQUIRRELVM vm, Table & ns)
{
ns.Bind(_SC("GuildMember"),
Class< DpGuildMember, NoConstructor< DpGuildMember > >(vm, SqDpGuildMember::Str)
// Meta-methods
.SquirrelFunc(_SC("_typename"), &SqDpGuildMember::Fn)
.Func(_SC("_cmp"), &DpGuildMember::SqCmp)
// Member Properties
.Prop(_SC("Valid"), &DpGuildMember::IsValid)
.Prop(_SC("JSON"), &DpGuildMember::BuildJSON)
.Prop(_SC("Nickname"), &DpGuildMember::GetNickname, &DpGuildMember::SetNickname)
.Prop(_SC("Roles"), &DpGuildMember::GetRoles)
.Prop(_SC("RolesCount"), &DpGuildMember::RolesCount)
.Prop(_SC("GuildID"), &DpGuildMember::GetGuildID, &DpGuildMember::SetGuildID)
.Prop(_SC("UserID"), &DpGuildMember::GetUserID, &DpGuildMember::SetUserID)
.Prop(_SC("Avatar"), &DpGuildMember::GetAvatar, &DpGuildMember::SetAvatar)
.Prop(_SC("CommunicationDisabledUntil"), &DpGuildMember::GetCommunicationDisabledUntil, &DpGuildMember::SetCommunicationDisabledUntil)
.Prop(_SC("JoinedAt"), &DpGuildMember::GetJoinedAt)
.Prop(_SC("PremiumSince"), &DpGuildMember::GetPremiumSince)
.Prop(_SC("Flags"), &DpGuildMember::GetFlags, &DpGuildMember::SetFlags)
.Prop(_SC("CommunicationDisabled"), &DpGuildMember::IsCommunicationDisabled)
.Prop(_SC("Deaf"), &DpGuildMember::GetDeaf, &DpGuildMember::SetDeaf)
.Prop(_SC("Muted"), &DpGuildMember::GetMuted, &DpGuildMember::SetMuted)
.Prop(_SC("IsPending"), &DpGuildMember::IsPending)
.Prop(_SC("HasAnimatedGuildAvatar"), &DpGuildMember::HasAnimatedGuildAvatar)
.Prop(_SC("Mention"), &DpGuildMember::GetMention)
// Member Methods
.Func(_SC("BuildJSON"), &DpGuildMember::BuildJSON_)
.Func(_SC("GetNickname"), &DpGuildMember::ApplyNickname)
.Func(_SC("AddRole"), &DpGuildMember::AddRole)
.Func(_SC("EachRole"), &DpGuildMember::EachRole)
.Func(_SC("ClearRoles"), &DpGuildMember::ClearRoles)
.Func(_SC("FilterRoles"), &DpGuildMember::FilterRoles)
.Func(_SC("GetFlags"), &DpGuildMember::ApplyFlags)
.Func(_SC("GetAvatarURL"), &DpGuildMember::GetAvatarURL)
);
// --------------------------------------------------------------------------------------------
ns.Bind(_SC("Guild"),
Class< DpGuild, NoConstructor< DpGuild > >(vm, SqDpGuild::Str)
// Meta-methods
.SquirrelFunc(_SC("_typename"), &SqDpGuild::Fn)
// Member Properties
.Prop(_SC("Valid"), &DpGuild::IsValid)
.Prop(_SC("JSON"), &DpGuild::BuildJSON)
.Prop(_SC("Name"), &DpGuild::GetName, &DpGuild::SetName)
.Prop(_SC("Description"), &DpGuild::GetDescription, &DpGuild::SetDescription)
// Member Methods
.Func(_SC("BuildJSON"), &DpGuild::BuildJSON_)
.Func(_SC("GetName"), &DpGuild::ApplyName)
.Func(_SC("GetDescription"), &DpGuild::ApplyDescription)
);
}
} // Namespace:: SqMod
module/Library/Discord/Guild.hpp
+421
View File
@@ -0,0 +1,421 @@
#pragma once
// ------------------------------------------------------------------------------------------------
#include "Core/Utility.hpp"
// ------------------------------------------------------------------------------------------------
#include <dpp/dpp.h>
// ------------------------------------------------------------------------------------------------
#include <chrono>
// ------------------------------------------------------------------------------------------------
namespace SqMod {
/* ------------------------------------------------------------------------------------------------
* Represents a guild on Discord (AKA a server).
*/
struct DpGuildMember
{
using Ptr = std::unique_ptr< dpp::guild_member >;
/* --------------------------------------------------------------------------------------------
* Referenced guild member instance.
*/
Ptr mPtr{nullptr};
/* --------------------------------------------------------------------------------------------
* Whether the referenced pointer is owned.
*/
bool mOwned{false};
/* --------------------------------------------------------------------------------------------
* Default constructor.
*/
DpGuildMember() noexcept = default;
/* --------------------------------------------------------------------------------------------
* Explicit constructor.
*/
explicit DpGuildMember(Ptr::pointer ptr, bool owned = false) noexcept
: mPtr(ptr), mOwned(owned)
{ }
/* --------------------------------------------------------------------------------------------
* Copy constructor.
*/
explicit DpGuildMember(const Ptr::element_type & o) noexcept
: DpGuildMember(new Ptr::element_type(o), true)
{ }
/* --------------------------------------------------------------------------------------------
* Move constructor.
*/
explicit DpGuildMember(Ptr::element_type && o) noexcept
: DpGuildMember(new Ptr::element_type(std::forward< Ptr::element_type >(o)), true)
{ }
/* --------------------------------------------------------------------------------------------
* Copy constructor (disabled).
*/
DpGuildMember(const DpGuildMember & o) = delete;
/* --------------------------------------------------------------------------------------------
* Move constructor.
*/
DpGuildMember(DpGuildMember && o) noexcept = default;
/* --------------------------------------------------------------------------------------------
* Destructor.
*/
~DpGuildMember() noexcept { Cleanup(); }
/* --------------------------------------------------------------------------------------------
* Copy assignment operator (disabled).
*/
DpGuildMember & operator = (const DpGuildMember & o) = delete;
/* --------------------------------------------------------------------------------------------
* Move assignment operator.
*/
DpGuildMember & operator = (DpGuildMember && o) noexcept
{
if (this != &o) {
// Do we own this to try delete it?
Cleanup();
// Transfer members values
mPtr = std::move(o.mPtr);
mOwned = o.mOwned;
}
return *this;
}
/* --------------------------------------------------------------------------------------------
* Release any referenced resources and default to an empty/invalid state.
*/
void Cleanup()
{
// Do we own this to try delete it?
if (!mOwned && mPtr) {
// Not our job, simply forget about it
[[maybe_unused]] auto p = mPtr.release();
} else mPtr.reset(); // We own this so delete the instance
}
/* --------------------------------------------------------------------------------------------
* Validate the managed handle.
*/
void Validate() const { if (!mPtr) STHROWF("Invalid discord voice state handle"); }
/* --------------------------------------------------------------------------------------------
* Validate the managed handle and retrieve a const reference to it.
*/
SQMOD_NODISCARD Ptr::element_type & Valid() const { Validate(); return *mPtr; }
/* --------------------------------------------------------------------------------------------
* Check whether a valid instance is managed.
*/
SQMOD_NODISCARD bool IsValid() const { return static_cast< bool >(mPtr); }
/* --------------------------------------------------------------------------------------------
* Build json representation of the object.
*/
SQMOD_NODISCARD std::string BuildJSON() const { return Valid().build_json(); }
SQMOD_NODISCARD std::string BuildJSON_(bool with_id) const { return Valid().build_json(with_id); }
/* --------------------------------------------------------------------------------------------
* Check if this member is equal to another member object.
*/
SQMOD_NODISCARD SQInteger SqCmp(const DpGuildMember & o) const
{
if (Valid() == o.Valid()) {
return 0;
// Nonsense...
} else if (Valid().user_id > o.Valid().user_id) {
return 1;
} else {
return -1;
}
}
/* --------------------------------------------------------------------------------------------
* Retrieve the nickname, or empty string if they don't have a nickname on this guild.
*/
SQMOD_NODISCARD const std::string & GetNickname() const { return Valid().nickname; }
/* --------------------------------------------------------------------------------------------
* Modify the nickname.
*/
void SetNickname(StackStrF & name) const { Valid().set_nickname(name.ToStr()); }
/* --------------------------------------------------------------------------------------------
* Modify the nickname.
*/
DpGuildMember & ApplyNickname(StackStrF & name) { SetNickname(name); return *this; }
/* --------------------------------------------------------------------------------------------
* Retrieve the list of roles this user has on this guild.
*/
SQMOD_NODISCARD Array GetRoles() const
{
return Array(SqVM()).Reserve(static_cast< SQInteger >(Valid().roles.size()))
.AppendFromVector(Valid().roles);
}
/* --------------------------------------------------------------------------------------------
* Retrieve the number of roles.
*/
SQMOD_NODISCARD SQInteger RolesCount() const { return static_cast< SQInteger >(Valid().roles.size()); }
/* --------------------------------------------------------------------------------------------
* Add a new role.
*/
DpGuildMember & AddRole(dpp::snowflake role) { Valid().roles.push_back(role); return *this; }
/* --------------------------------------------------------------------------------------------
* Iterate all roles.
*/
DpGuildMember & EachRole(Function & fn)
{
for (const auto & a : Valid().roles)
{
fn.Execute(a);
}
return *this;
}
/* --------------------------------------------------------------------------------------------
* Retrieve the number of roles.
*/
DpGuildMember & ClearRoles(dpp::snowflake role) { Valid().roles.clear(); return *this; }
/* --------------------------------------------------------------------------------------------
* Filter roles.
*/
DpGuildMember & FilterRoles(Function & fn)
{
std::vector< dpp::snowflake > list;
// Reserve memory in advance
list.reserve(Valid().roles.size());
// Process each role individually
for (const auto & role : Valid().roles)
{
auto ret = fn.Eval(role);
// (null || true) == keep & false == skip
if (!ret.IsNull() || !ret.template Cast< bool >())
{
list.push_back(role); // Keep this role
}
}
// Use filtered roles
Valid().roles.swap(list);
// Allow chaining
return *this;
}
/* --------------------------------------------------------------------------------------------
* Retrieve the guild id.
*/
SQMOD_NODISCARD dpp::snowflake GetGuildID() const { return Valid().guild_id; }
/* --------------------------------------------------------------------------------------------
* Modify the guild id.
*/
void SetGuildID(dpp::snowflake id) { Valid().guild_id = id; }
/* --------------------------------------------------------------------------------------------
* Retrieve the user id.
*/
SQMOD_NODISCARD dpp::snowflake GetUserID() const { return Valid().user_id; }
/* --------------------------------------------------------------------------------------------
* Modify the guild id.
*/
void SetUserID(dpp::snowflake id) { Valid().guild_id = id; }
/* --------------------------------------------------------------------------------------------
* Retrieve the user avatar (per-server avatar is a nitro only feature).
*/
SQMOD_NODISCARD const dpp::utility::iconhash & GetAvatar() const { return Valid().avatar; }
/* --------------------------------------------------------------------------------------------
* Modify the user avatar (per-server avatar is a nitro only feature).
*/
void SetAvatar(const dpp::utility::iconhash & a) const { Valid().avatar = a; }
/* --------------------------------------------------------------------------------------------
* Retrieve the date and time when the time out will be removed; until then, they cannot interact with the guild.
*/
SQMOD_NODISCARD SQInteger GetCommunicationDisabledUntil() const
{
return std::chrono::time_point_cast< std::chrono::seconds >(
std::chrono::system_clock::from_time_t(Valid().communication_disabled_until)
).time_since_epoch().count();
}
/* --------------------------------------------------------------------------------------------
* Assign a timestamp until communication is disabled.
*/
void SetCommunicationDisabledUntil(SQInteger ts) const
{
Valid().set_communication_disabled_until(
std::chrono::system_clock::to_time_t(std::chrono::time_point< std::chrono::system_clock >(std::chrono::seconds(ts)))
);
}
/* --------------------------------------------------------------------------------------------
* Retrieve the date and time the user joined the guild.
*/
SQMOD_NODISCARD SQInteger GetJoinedAt() const
{
return std::chrono::time_point_cast< std::chrono::seconds >(
std::chrono::system_clock::from_time_t(Valid().joined_at)
).time_since_epoch().count();
}
/* --------------------------------------------------------------------------------------------
* Retrieve the date and time since the user is boosting.
*/
SQMOD_NODISCARD SQInteger GetPremiumSince() const
{
return std::chrono::time_point_cast< std::chrono::seconds >(
std::chrono::system_clock::from_time_t(Valid().premium_since)
).time_since_epoch().count();
}
/* --------------------------------------------------------------------------------------------
* Retrieve the guild flags. Built from the bitmask defined by SqDiscordGuildMemberFlags.
*/
SQMOD_NODISCARD SQInteger GetFlags() const { return static_cast< SQInteger >(Valid().flags); }
/* --------------------------------------------------------------------------------------------
* Modify the guild flags.
*/
void SetFlags(SQInteger f) const { Valid().flags = static_cast< uint8_t >(f); }
/* --------------------------------------------------------------------------------------------
* Modify the guild flags.
*/
DpGuildMember & ApplyFlags(SQInteger f) { SetFlags(f); return *this; }
/* --------------------------------------------------------------------------------------------
* Check whether the user is in time-out (communication disabled).
*/
SQMOD_NODISCARD bool IsCommunicationDisabled() const { return Valid().is_communication_disabled(); }
/* --------------------------------------------------------------------------------------------
* Check whether the user is deafened.
*/
SQMOD_NODISCARD bool GetDeaf() const { return Valid().is_deaf(); }
/* --------------------------------------------------------------------------------------------
* Check whether the user is deafened.
*/
void SetDeaf(bool is_deafened) const { Valid().set_deaf(is_deafened); }
/* --------------------------------------------------------------------------------------------
* Check whether the user is muted.
*/
SQMOD_NODISCARD bool GetMuted() const { return Valid().is_muted(); }
/* --------------------------------------------------------------------------------------------
* Check whether the user is muted.
*/
void SetMuted(bool is_muted) const { Valid().set_mute(is_muted); }
/* --------------------------------------------------------------------------------------------
* Check whether the user is pending verification by membership screening.
*/
SQMOD_NODISCARD bool IsPending() const { return Valid().is_pending(); }
/* --------------------------------------------------------------------------------------------
* Check whether the the user's per-guild custom avatar is animated.
*/
SQMOD_NODISCARD bool HasAnimatedGuildAvatar() const { return Valid().has_animated_guild_avatar(); }
/* --------------------------------------------------------------------------------------------
* Check whether the the user's per-guild custom avatar is animated.
*/
SQMOD_NODISCARD std::string GetAvatarURL(SQInteger size, SQInteger format, bool animated) const
{ return Valid().get_avatar_url(static_cast< uint16_t >(size), static_cast< dpp::image_type >(format), animated); }
/* --------------------------------------------------------------------------------------------
* Retrieve a ping/mention for the user by nickname.
*/
SQMOD_NODISCARD std::string GetMention() const { return Valid().get_mention(); }
};
/* ------------------------------------------------------------------------------------------------
* Represents a guild on Discord (AKA a server)
*/
struct DpGuild
{
using Ptr = std::unique_ptr< dpp::guild >;
/* --------------------------------------------------------------------------------------------
* Referenced guild instance.
*/
Ptr mPtr{nullptr};
/* --------------------------------------------------------------------------------------------
* Whether the referenced pointer is owned.
*/
bool mOwned{false};
/* --------------------------------------------------------------------------------------------
* Default constructor.
*/
DpGuild() noexcept = default;
/* --------------------------------------------------------------------------------------------
* Explicit constructor.
*/
explicit DpGuild(Ptr::pointer ptr, bool owned = false) noexcept
: mPtr(ptr), mOwned(owned)
{ }
/* --------------------------------------------------------------------------------------------
* Copy constructor.
*/
explicit DpGuild(const Ptr::element_type & o) noexcept
: DpGuild(new Ptr::element_type(o), true)
{ }
/* --------------------------------------------------------------------------------------------
* Move constructor.
*/
explicit DpGuild(Ptr::element_type && o) noexcept
: DpGuild(new Ptr::element_type(std::forward< Ptr::element_type >(o)), true)
{ }
/* --------------------------------------------------------------------------------------------
* Copy constructor (disabled).
*/
DpGuild(const DpGuild & o) = delete;
/* --------------------------------------------------------------------------------------------
* Move constructor.
*/
DpGuild(DpGuild && o) noexcept = default;
/* --------------------------------------------------------------------------------------------
* Destructor.
*/
~DpGuild() noexcept { Cleanup(); }
/* --------------------------------------------------------------------------------------------
* Copy assignment operator (disabled).
*/
DpGuild & operator = (const DpGuild & o) = delete;
/* --------------------------------------------------------------------------------------------
* Move assignment operator.
*/
DpGuild & operator = (DpGuild && o) noexcept
{
if (this != &o) {
// Do we own this to try delete it?
Cleanup();
// Transfer members values
mPtr = std::move(o.mPtr);
mOwned = o.mOwned;
}
return *this;
}
/* --------------------------------------------------------------------------------------------
* Release any referenced resources and default to an empty/invalid state.
*/
void Cleanup()
{
// Do we own this to try delete it?
if (!mOwned && mPtr) {
// Not our job, simply forget about it
[[maybe_unused]] auto p = mPtr.release();
} else mPtr.reset(); // We own this so delete the instance
}
/* --------------------------------------------------------------------------------------------
* Validate the managed handle.
*/
void Validate() const { if (!mPtr) STHROWF("Invalid discord guild handle"); }
/* --------------------------------------------------------------------------------------------
* Validate the managed handle and retrieve a const reference to it.
*/
SQMOD_NODISCARD Ptr::element_type & Valid() const { Validate(); return *mPtr; }
/* --------------------------------------------------------------------------------------------
* Check whether a valid instance is managed.
*/
SQMOD_NODISCARD bool IsValid() const { return static_cast< bool >(mPtr); }
/* --------------------------------------------------------------------------------------------
* Build json representation of the object.
*/
SQMOD_NODISCARD std::string BuildJSON() const { return Valid().build_json(); }
SQMOD_NODISCARD std::string BuildJSON_(bool with_id) const { return Valid().build_json(with_id); }
/* --------------------------------------------------------------------------------------------
* Retrieve the guild name. Min length: 2, Max length: 100 (not including leading/trailing spaces)
*/
SQMOD_NODISCARD const std::string & GetName() const { return Valid().name; }
/* --------------------------------------------------------------------------------------------
* Modify the guild name. Min length: 2, Max length: 100 (not including leading/trailing spaces)
*/
void SetName(StackStrF & name) const { Valid().set_name(name.ToStr()); }
/* --------------------------------------------------------------------------------------------
* Modify the guild name. Min length: 2, Max length: 100 (not including leading/trailing spaces)
*/
DpGuild & ApplyName(StackStrF & name) { SetName(name); return *this; }
/* --------------------------------------------------------------------------------------------
* Retrieve the server description.
*/
SQMOD_NODISCARD const std::string & GetDescription() const { return Valid().description; }
/* --------------------------------------------------------------------------------------------
* Modify the server description.
*/
void SetDescription(StackStrF & description) const { Valid().description = description.ToStr(); }
/* --------------------------------------------------------------------------------------------
* Modify the server description.
*/
DpGuild & ApplyDescription(StackStrF & description) { SetDescription(description); return *this; }
};
} // Namespace:: SqMod
module/Library/Discord/Integration.cpp
+9
View File
@@ -0,0 +1,9 @@
// ------------------------------------------------------------------------------------------------
#include "Library/Discord/Integration.hpp"
// ------------------------------------------------------------------------------------------------
namespace SqMod {
} // Namespace:: SqMod
module/Library/Discord/Integration.hpp
+13
View File
@@ -0,0 +1,13 @@
#pragma once
// ------------------------------------------------------------------------------------------------
#include "Core/Utility.hpp"
// ------------------------------------------------------------------------------------------------
#include <dpp/dpp.h>
// ------------------------------------------------------------------------------------------------
namespace SqMod {
} // Namespace:: SqMod
module/Library/Discord/Message.cpp
+9
View File
@@ -0,0 +1,9 @@
// ------------------------------------------------------------------------------------------------
#include "Library/Discord/Message.hpp"
// ------------------------------------------------------------------------------------------------
namespace SqMod {
} // Namespace:: SqMod
module/Library/Discord/Message.hpp
+13
View File
@@ -0,0 +1,13 @@
#pragma once
// ------------------------------------------------------------------------------------------------
#include "Core/Utility.hpp"
// ------------------------------------------------------------------------------------------------
#include <dpp/dpp.h>
// ------------------------------------------------------------------------------------------------
namespace SqMod {
} // Namespace:: SqMod
module/Library/Discord/Misc.cpp
+117
View File
@@ -0,0 +1,117 @@
// ------------------------------------------------------------------------------------------------
#include "Library/Discord/Misc.hpp"
// ------------------------------------------------------------------------------------------------
namespace SqMod {
// ------------------------------------------------------------------------------------------------
SQMOD_DECL_TYPENAME(SqDpCachePolicy, _SC("SqDiscordCachePolicy"))
SQMOD_DECL_TYPENAME(SqDpUptime, _SC("SqDiscordUptime"))
SQMOD_DECL_TYPENAME(SqDpIconHash, _SC("SqDiscordIconHash"))
SQMOD_DECL_TYPENAME(SqDpVoiceState, _SC("SqDiscordVoiceState"))
SQMOD_DECL_TYPENAME(SqDpEmoji, _SC("SqDiscordEmoji"))
// ------------------------------------------------------------------------------------------------
void Register_Discord_Misc(HSQUIRRELVM vm, Table & ns)
{
// --------------------------------------------------------------------------------------------
ns.Bind(_SC("Uptime"),
Class< dpp::utility::uptime >(vm, SqDpUptime::Str)
// Constructors
.Ctor()
.Ctor< double >()
// Meta-methods
.SquirrelFunc(_SC("_typename"), &SqDpUptime::Fn)
.Func(_SC("_tostring"), &dpp::utility::uptime::to_string)
// Member Variables
.Var(_SC("Days"), &dpp::utility::uptime::days)
.Var(_SC("Hours"), &dpp::utility::uptime::hours)
.Var(_SC("Minutes"), &dpp::utility::uptime::mins)
.Var(_SC("Seconds"), &dpp::utility::uptime::secs)
// Member Methods
.Func(_SC("ToSeconds"), &dpp::utility::uptime::to_secs)
.Func(_SC("ToMilliseconds"), &dpp::utility::uptime::to_msecs)
);
// --------------------------------------------------------------------------------------------
ns.Bind(_SC("IconHash"),
Class< dpp::utility::iconhash >(vm, SqDpIconHash::Str)
// Constructors
.Ctor()
.Ctor< const std::string & >()
.Ctor< uint64_t, uint64_t >()
// Meta-methods
.SquirrelFunc(_SC("_typename"), &SqDpIconHash::Fn)
.Func(_SC("_tostring"), &dpp::utility::iconhash::to_string)
// Member Variables
.Var(_SC("High"), &dpp::utility::iconhash::first)
.Var(_SC("Low"), &dpp::utility::iconhash::second)
// Member Methods
.Func(_SC("Set"), &dpp::utility::iconhash::set)
);
// --------------------------------------------------------------------------------------------
ns.Bind(_SC("CachePolicy"),
Class< DpCachePolicy >(vm, SqDpCachePolicy::Str)
// Constructors
.Ctor()
.Ctor< SQInteger >()
.Ctor< SQInteger, SQInteger >()
.Ctor< SQInteger, SQInteger, SQInteger >()
// Meta-methods
.SquirrelFunc(_SC("_typename"), &SqDpCachePolicy::Fn)
// Member Variables
.Var(_SC("UserPolicy"), &DpCachePolicy::mUserPolicy)
.Var(_SC("EmojiPolicy"), &DpCachePolicy::mEmojiPolicy)
.Var(_SC("RolePolicy"), &DpCachePolicy::mRolePolicy)
);
// --------------------------------------------------------------------------------------------
ns.Bind(_SC("VoiceState"),
Class< DpVoiceState, NoConstructor< DpVoiceState > >(vm, SqDpVoiceState::Str)
// Meta-methods
.SquirrelFunc(_SC("_typename"), &SqDpVoiceState::Fn)
// Member Properties
.Prop(_SC("Valid"), &DpVoiceState::IsValid)
.Prop(_SC("JSON"), &DpVoiceState::BuildJSON)
.Prop(_SC("GuildID"), &DpVoiceState::GetGuildID)
.Prop(_SC("ChannelID"), &DpVoiceState::GetChannelID)
.Prop(_SC("UserID"), &DpVoiceState::GetUserID)
.Prop(_SC("SessionID"), &DpVoiceState::GetSessionID)
.Prop(_SC("Flags"), &DpVoiceState::GetFlags, &DpVoiceState::SetFlags)
.Prop(_SC("RequestToSpeak"), &DpVoiceState::GetRequestToSpeak)
.Prop(_SC("IsDeaf"), &DpVoiceState::IsDeaf)
.Prop(_SC("IsMute"), &DpVoiceState::IsMute)
.Prop(_SC("IsSelfMute"), &DpVoiceState::IsSelfMute)
.Prop(_SC("IsSelfDeaf"), &DpVoiceState::IsSelfDeaf)
.Prop(_SC("SelfStream"), &DpVoiceState::SelfStream)
.Prop(_SC("SelfVideo"), &DpVoiceState::SelfVideo)
.Prop(_SC("IsSuppressed"), &DpVoiceState::IsSuppressed)
// Member Methods
.Func(_SC("BuildJSON"), &DpVoiceState::BuildJSON_)
);
// --------------------------------------------------------------------------------------------
ns.Bind(_SC("Emoji"),
Class< DpEmoji, NoCopy< DpEmoji > >(vm, SqDpEmoji::Str)
// Constructors
.Ctor()
.Ctor< StackStrF &, dpp::snowflake, SQInteger >()
// Meta-methods
.SquirrelFunc(_SC("_typename"), &SqDpEmoji::Fn)
// Member Properties
.Prop(_SC("Valid"), &DpEmoji::IsValid)
.Prop(_SC("JSON"), &DpEmoji::BuildJSON)
.Prop(_SC("Name"), &DpEmoji::GetName, &DpEmoji::SetName)
.Prop(_SC("ImageData"), &DpEmoji::GetImageData)
.Prop(_SC("RequiresColons"), &DpEmoji::GetRequiresColons)
.Prop(_SC("IsManaged"), &DpEmoji::GetIsManaged)
.Prop(_SC("IsAnimated"), &DpEmoji::GetIsAnimated)
.Prop(_SC("IsAvailable"), &DpEmoji::GetIsAvailable)
.Prop(_SC("Format"), &DpEmoji::Format)
.Prop(_SC("Mention"), &DpEmoji::GetMention)
// Member Methods
.Func(_SC("SetName"), &DpEmoji::ApplyName)
.Func(_SC("GetMention"), &DpEmoji::GetMention_)
.Func(_SC("BuildJSON"), &DpEmoji::BuildJSON_)
.Func(_SC("LoadImage"), &DpEmoji::LoadImage)
);
}
} // Namespace:: SqMod
module/Library/Discord/Misc.hpp
+393
View File
@@ -0,0 +1,393 @@
#pragma once
// ------------------------------------------------------------------------------------------------
#include "Library/Discord/Utilities.hpp"
// ------------------------------------------------------------------------------------------------
#include <dpp/dpp.h>
// ------------------------------------------------------------------------------------------------
#include <chrono>
// ------------------------------------------------------------------------------------------------
namespace SqMod {
/* ------------------------------------------------------------------------------------------------
* Represents the caching policy of the cluster.
*/
struct DpCachePolicy
{
SQInteger mUserPolicy{dpp::cp_aggressive};
SQInteger mEmojiPolicy{dpp::cp_aggressive};
SQInteger mRolePolicy{dpp::cp_aggressive};
/* --------------------------------------------------------------------------------------------
* Default constructor.
*/
DpCachePolicy() noexcept = default;
/* --------------------------------------------------------------------------------------------
* Explicit constructor.
*/
explicit DpCachePolicy(SQInteger user) noexcept
: mUserPolicy(user), mEmojiPolicy(dpp::cp_aggressive), mRolePolicy(dpp::cp_aggressive)
{ }
/* --------------------------------------------------------------------------------------------
* Explicit constructor.
*/
DpCachePolicy(SQInteger user, SQInteger emoji) noexcept
: mUserPolicy(user), mEmojiPolicy(emoji), mRolePolicy(dpp::cp_aggressive)
{ }
/* --------------------------------------------------------------------------------------------
* Explicit constructor.
*/
DpCachePolicy(SQInteger user, SQInteger emoji, SQInteger role) noexcept
: mUserPolicy(user), mEmojiPolicy(emoji), mRolePolicy(role)
{ }
/* --------------------------------------------------------------------------------------------
* Copy constructor.
*/
DpCachePolicy(const DpCachePolicy &) noexcept = default;
/* --------------------------------------------------------------------------------------------
* Convert to native cache policy type.
*/
SQMOD_NODISCARD dpp::cache_policy_t ToNative() const noexcept
{
return dpp::cache_policy_t{
static_cast< dpp::cache_policy_setting_t >(mUserPolicy),
static_cast< dpp::cache_policy_setting_t >(mEmojiPolicy),
static_cast< dpp::cache_policy_setting_t >(mRolePolicy)
};
}
};
/* ------------------------------------------------------------------------------------------------
* Represents the voice state of a user on a guild.
* These are stored in the DpGuild object, and accessible there, or via DpChannel::GetVoiceMembers.
*/
struct DpVoiceState
{
using Ptr = std::unique_ptr< dpp::voicestate >;
/* --------------------------------------------------------------------------------------------
* Referenced voice state instance.
*/
Ptr mPtr{nullptr};
/* --------------------------------------------------------------------------------------------
* Whether the referenced pointer is owned.
*/
bool mOwned{false};
/* --------------------------------------------------------------------------------------------
* Default constructor.
*/
DpVoiceState() noexcept = default;
/* --------------------------------------------------------------------------------------------
* Explicit constructor.
*/
explicit DpVoiceState(Ptr::pointer ptr, bool owned = false) noexcept
: mPtr(ptr), mOwned(owned)
{ }
/* --------------------------------------------------------------------------------------------
* Explicit constructor.
*/
explicit DpVoiceState(const Ptr::element_type & o) noexcept
: DpVoiceState(new Ptr::element_type(o), true)
{ }
/* --------------------------------------------------------------------------------------------
* Move constructor.
*/
explicit DpVoiceState(Ptr::element_type && o) noexcept
: DpVoiceState(new Ptr::element_type(std::forward< Ptr::element_type >(o)), true)
{ }
/* --------------------------------------------------------------------------------------------
* Copy constructor (disabled).
*/
DpVoiceState(const DpVoiceState & o) = delete;
/* --------------------------------------------------------------------------------------------
* Move constructor.
*/
DpVoiceState(DpVoiceState && o) noexcept = default;
/* --------------------------------------------------------------------------------------------
* Destructor.
*/
~DpVoiceState() noexcept { Cleanup(); }
/* --------------------------------------------------------------------------------------------
* Copy assignment operator (disabled).
*/
DpVoiceState & operator = (const DpVoiceState & o) = delete;
/* --------------------------------------------------------------------------------------------
* Move assignment operator.
*/
DpVoiceState & operator = (DpVoiceState && o) noexcept
{
if (this != &o) {
Cleanup();
// Transfer members values
mPtr = std::move(o.mPtr);
mOwned = o.mOwned;
}
return *this;
}
/* --------------------------------------------------------------------------------------------
* Release any referenced resources and default to an empty/invalid state.
*/
void Cleanup()
{
// Do we own this to try delete it?
if (!mOwned && mPtr) {
// Not our job, simply forget about it
[[maybe_unused]] auto p = mPtr.release();
} else mPtr.reset(); // We own this so delete the instance
}
/* --------------------------------------------------------------------------------------------
* Validate the managed handle.
*/
void Validate() const { if (!mPtr) STHROWF("Invalid discord voice state handle"); }
/* --------------------------------------------------------------------------------------------
* Validate the managed handle and retrieve a const reference to it.
*/
SQMOD_NODISCARD Ptr::element_type & Valid() const { Validate(); return *mPtr; }
/* --------------------------------------------------------------------------------------------
* Check whether a valid instance is managed.
*/
SQMOD_NODISCARD bool IsValid() const { return static_cast< bool >(mPtr); }
/* --------------------------------------------------------------------------------------------
* Retrieve the guild id this voice state is for (optional).
*/
SQMOD_NODISCARD dpp::snowflake GetGuildID() const { return Valid().guild_id; }
/* --------------------------------------------------------------------------------------------
* Retrieve the channel id this user is connected to (may be empty).
*/
SQMOD_NODISCARD dpp::snowflake GetChannelID() const { return Valid().channel_id; }
/* --------------------------------------------------------------------------------------------
* Retrieve the user id this voice state is for.
*/
SQMOD_NODISCARD dpp::snowflake GetUserID() const { return Valid().user_id; }
/* --------------------------------------------------------------------------------------------
* Retrieve the session id for this voice state.
*/
SQMOD_NODISCARD const std::string & GetSessionID() const { return Valid().session_id; }
/* --------------------------------------------------------------------------------------------
* Retrieve the voice state flags (see SqDiscordVoiceStateFlags).
*/
SQMOD_NODISCARD SQInteger GetFlags() const { return Valid().flags; }
/* --------------------------------------------------------------------------------------------
* Modify the voice state flags (see SqDiscordVoiceStateFlags).
*/
void SetFlags(SQInteger flags) const { Valid().flags = flags; }
/* --------------------------------------------------------------------------------------------
* Retrieve the time at which the user requested to speak, or 0.
*/
SQMOD_NODISCARD SQInteger GetRequestToSpeak() const {
return static_cast< SQInteger >(std::chrono::duration_cast< std::chrono::seconds >(
std::chrono::system_clock::from_time_t(Valid().request_to_speak).time_since_epoch()
).count());
}
/* --------------------------------------------------------------------------------------------
* Build json representation of the object.
*/
SQMOD_NODISCARD std::string BuildJSON() const { return Valid().build_json(); }
SQMOD_NODISCARD std::string BuildJSON_(bool with_id) const { return Valid().build_json(with_id); }
/* --------------------------------------------------------------------------------------------
* Check if the user is deafened by the server.
*/
SQMOD_NODISCARD bool IsDeaf() const { return Valid().is_deaf(); }
/* --------------------------------------------------------------------------------------------
* Check if the user is muted by the server.
*/
SQMOD_NODISCARD bool IsMute() const { return Valid().is_mute(); }
/* --------------------------------------------------------------------------------------------
* Check if the user muted themselves.
*/
SQMOD_NODISCARD bool IsSelfMute() const { return Valid().is_self_mute(); }
/* --------------------------------------------------------------------------------------------
* Check if the user deafened themselves.
*/
SQMOD_NODISCARD bool IsSelfDeaf() const { return Valid().is_self_deaf(); }
/* --------------------------------------------------------------------------------------------
* Check if the user is streaming using "Go Live".
*/
SQMOD_NODISCARD bool SelfStream() const { return Valid().self_stream(); }
/* --------------------------------------------------------------------------------------------
* Check if the user's camera is enabled.
*/
SQMOD_NODISCARD bool SelfVideo() const { return Valid().self_video(); }
/* --------------------------------------------------------------------------------------------
* Check if user is suppressed. "HELP HELP I'M BEING SUPPRESSED!"
*/
SQMOD_NODISCARD bool IsSuppressed() const { return Valid().is_suppressed(); }
};
/* ------------------------------------------------------------------------------------------------
* Represents the voice state of a user on a guild.
*/
struct DpEmoji
{
using Ptr = std::unique_ptr< dpp::emoji >;
/* --------------------------------------------------------------------------------------------
* Referenced voice state instance.
*/
Ptr mPtr{nullptr};
/* --------------------------------------------------------------------------------------------
* Whether the referenced pointer is owned.
*/
bool mOwned{false};
/* --------------------------------------------------------------------------------------------
* Default constructor.
*/
DpEmoji() noexcept = default;
/* --------------------------------------------------------------------------------------------
* Explicit constructor.
*/
explicit DpEmoji(Ptr::pointer ptr, bool owned = false) noexcept
: mPtr(ptr), mOwned(owned)
{ }
/* --------------------------------------------------------------------------------------------
* Explicit constructor.
*/
explicit DpEmoji(const Ptr::element_type & o) noexcept
: DpEmoji(new Ptr::element_type(o), true)
{ }
/* --------------------------------------------------------------------------------------------
* Move constructor.
*/
explicit DpEmoji(Ptr::element_type && o) noexcept
: DpEmoji(new Ptr::element_type(std::forward< Ptr::element_type >(o)), true)
{ }
/* --------------------------------------------------------------------------------------------
* Explicit constructor.
*/
DpEmoji(StackStrF & name, dpp::snowflake id, SQInteger flags)
: DpEmoji(new Ptr::element_type(name.ToStr(), id, static_cast< uint8_t >(flags)), true)
{ }
/* --------------------------------------------------------------------------------------------
* Copy constructor (disabled).
*/
DpEmoji(const DpEmoji & o) = delete;
/* --------------------------------------------------------------------------------------------
* Move constructor.
*/
DpEmoji(DpEmoji && o) noexcept = default;
/* --------------------------------------------------------------------------------------------
* Destructor.
*/
~DpEmoji() noexcept { Cleanup(); }
/* --------------------------------------------------------------------------------------------
* Copy assignment operator (disabled).
*/
DpEmoji & operator = (const DpEmoji & o) = delete;
/* --------------------------------------------------------------------------------------------
* Move assignment operator.
*/
DpEmoji & operator = (DpEmoji && o) noexcept
{
if (this != &o) {
Cleanup();
// Transfer members values
mPtr = std::move(o.mPtr);
mOwned = o.mOwned;
}
return *this;
}
/* --------------------------------------------------------------------------------------------
* Release any referenced resources and default to an empty/invalid state.
*/
void Cleanup()
{
// Do we own this to try delete it?
if (!mOwned && mPtr) {
// Not our job, simply forget about it
[[maybe_unused]] auto p = mPtr.release();
} else mPtr.reset(); // We own this so delete the instance
}
/* --------------------------------------------------------------------------------------------
* Validate the managed handle.
*/
void Validate() const { if (!mPtr) STHROWF("Invalid discord voice state handle"); }
/* --------------------------------------------------------------------------------------------
* Validate the managed handle and retrieve a const reference to it.
*/
SQMOD_NODISCARD Ptr::element_type & Valid() const { Validate(); return *mPtr; }
/* --------------------------------------------------------------------------------------------
* Check whether a valid instance is managed.
*/
SQMOD_NODISCARD bool IsValid() const { return static_cast< bool >(mPtr); }
/* --------------------------------------------------------------------------------------------
* Retrieve the name of the emoji.
*/
SQMOD_NODISCARD const std::string & GetName() const { return Valid().name; }
/* --------------------------------------------------------------------------------------------
* Modify the name of the emoji.
*/
void SetName(StackStrF & name) const { Valid().name = name.ToStr(); }
/* --------------------------------------------------------------------------------------------
* Modify the name of the emoji.
*/
DpEmoji & ApplyName(StackStrF & name) { SetName(name); return *this; }
/* --------------------------------------------------------------------------------------------
* Retrieve the user who uploaded the emoji.
*/
SQMOD_NODISCARD dpp::snowflake GetUserID() const { return Valid().user_id; }
/* --------------------------------------------------------------------------------------------
* Modify the user who uploaded the emoji.
*/
void SetUserID(dpp::snowflake id) const { Valid().user_id = id; }
/* --------------------------------------------------------------------------------------------
* Modify the user who uploaded the emoji.
*/
DpEmoji & ApplyUserID(dpp::snowflake id) { SetUserID(id); return *this; }
/* --------------------------------------------------------------------------------------------
* Retrieve the flags for the emoji from SqDiscordEmojiFlags.
*/
SQMOD_NODISCARD SQInteger GetFlags() const { return Valid().flags; }
/* --------------------------------------------------------------------------------------------
* Modify the flags for the emoji from SqDiscordEmojiFlags.
*/
void SetFlags(SQInteger flags) const { Valid().flags = static_cast< uint8_t >(flags); }
/* --------------------------------------------------------------------------------------------
* Modify the flags for the emoji from SqDiscordEmojiFlags.
*/
DpEmoji & ApplyFlags(SQInteger flags) { SetFlags(flags); return *this; }
/* --------------------------------------------------------------------------------------------
* Retrieve the image data for the emoji if uploading.
*/
SQMOD_NODISCARD LightObj GetImageData() const { return !Valid().image_data ? LightObj{} : LightObj(*Valid().image_data); }
/* --------------------------------------------------------------------------------------------
* Create a mentionable emoji.
*/
SQMOD_NODISCARD std::string GetMention_(StackStrF & name, dpp::snowflake id, bool is_animated = false) const
{ return Valid().get_mention(name.ToStr(), id, is_animated); }
/* --------------------------------------------------------------------------------------------
* Build json representation of the object.
*/
SQMOD_NODISCARD std::string BuildJSON() const { return Valid().build_json(); }
SQMOD_NODISCARD std::string BuildJSON_(bool with_id) const { return Valid().build_json(with_id); }
/* --------------------------------------------------------------------------------------------
* Retrieve whether the Emoji requires colons.
*/
SQMOD_NODISCARD bool GetRequiresColons() const { return Valid().requires_colons(); }
/* --------------------------------------------------------------------------------------------
* Retrieve whether the Emoji is managed.
*/
SQMOD_NODISCARD bool GetIsManaged() const { return Valid().is_managed(); }
/* --------------------------------------------------------------------------------------------
* Retrieve whether the Emoji is animated.
*/
SQMOD_NODISCARD bool GetIsAnimated() const { return Valid().is_animated(); }
/* --------------------------------------------------------------------------------------------
* Retrieve whether the Emoji is available.
*/
SQMOD_NODISCARD bool GetIsAvailable() const { return Valid().is_available(); }
/* --------------------------------------------------------------------------------------------
* Load an image into the object as base64.
*/
DpEmoji & LoadImage(StackStrF & data, SQInteger type) { Valid().load_image(data.ToStr(), static_cast< dpp::image_type >(type)); return *this; }
/* --------------------------------------------------------------------------------------------
* Format to name if unicode, name:id if has id or a:name:id if animated.
*/
SQMOD_NODISCARD std::string Format() const { return Valid().format(); }
/* --------------------------------------------------------------------------------------------
* Retrieve the mention/ping for the emoji.
*/
SQMOD_NODISCARD std::string GetMention() const { return Valid().get_mention(); }
};
} // Namespace:: SqMod
module/Library/Discord/Presence.cpp
+143
View File
@@ -0,0 +1,143 @@
// ------------------------------------------------------------------------------------------------
#include "Library/Discord/Presence.hpp"
// ------------------------------------------------------------------------------------------------
namespace SqMod {
// ------------------------------------------------------------------------------------------------
SQMOD_DECL_TYPENAME(SqDpActivityButton, _SC("SqDiscordActivityButton"))
SQMOD_DECL_TYPENAME(SqDpActivityButtons, _SC("SqDiscordActivityButtons"))
SQMOD_DECL_TYPENAME(SqDpActivityAssets, _SC("SqDiscordActivityAssets"))
SQMOD_DECL_TYPENAME(SqDpActivitySecrets, _SC("SqDiscordActivitySecrets"))
SQMOD_DECL_TYPENAME(SqDpActivity, _SC("SqDiscordActivity"))
SQMOD_DECL_TYPENAME(SqDpActivities, _SC("SqDiscordActivities"))
SQMOD_DECL_TYPENAME(SqDpPresence, _SC("SqDiscordPresence"))
// ------------------------------------------------------------------------------------------------
void Register_Discord_Presence(HSQUIRRELVM vm, Table & ns)
{
// --------------------------------------------------------------------------------------------
ns.Bind(_SC("ActivityButton"),
Class< DpActivityButton, NoCopy< DpActivityButton > >(vm, SqDpActivityButton::Str)
// Constructors
.Ctor()
// Meta-methods
.SquirrelFunc(_SC("_typename"), &SqDpActivityButton::Fn)
// Member Properties
.Prop(_SC("Valid"), &DpActivityButton::IsValid)
.Prop(_SC("Label"), &DpActivityButton::GetLabel, &DpActivityButton::SetLabel)
.Prop(_SC("URL"), &DpActivityButton::GetURL, &DpActivityButton::SetURL)
// Member Methods
.Func(_SC("SetLabel"), &DpActivityButton::ApplyLabel)
.Func(_SC("SetURL"), &DpActivityButton::ApplyURL)
);
// --------------------------------------------------------------------------------------------
Register_Discord_VectorProxy< dpp::activity_button, DpActivityButton, SqDpActivityButton >(vm, ns, _SC("ActivityButtons"));
// --------------------------------------------------------------------------------------------
ns.Bind(_SC("ActivityAssets"),
Class< DpActivityAssets, NoCopy< DpActivityAssets > >(vm, SqDpActivityAssets::Str)
// Constructors
.Ctor()
// Meta-methods
.SquirrelFunc(_SC("_typename"), &SqDpActivityAssets::Fn)
// Member Properties
.Prop(_SC("Valid"), &DpActivityAssets::IsValid)
.Prop(_SC("LargeImage"), &DpActivityAssets::GetLargeImage, &DpActivityAssets::SetLargeImage)
.Prop(_SC("LargeText"), &DpActivityAssets::GetLargeText, &DpActivityAssets::SetLargeText)
.Prop(_SC("SmallImage"), &DpActivityAssets::GetSmallImage, &DpActivityAssets::SetSmallImage)
.Prop(_SC("SmallText"), &DpActivityAssets::GetSmallText, &DpActivityAssets::SetSmallText)
// Member Methods
.Func(_SC("SetLargeImage"), &DpActivityAssets::ApplyLargeImage)
.Func(_SC("SetLargeText"), &DpActivityAssets::ApplyLargeText)
.Func(_SC("SetSmallImage"), &DpActivityAssets::ApplySmallImage)
.Func(_SC("SetSmallText"), &DpActivityAssets::ApplySmallText)
);
// --------------------------------------------------------------------------------------------
ns.Bind(_SC("ActivitySecrets"),
Class< DpActivitySecrets, NoCopy< DpActivitySecrets > >(vm, SqDpActivitySecrets::Str)
// Constructors
.Ctor()
// Meta-methods
.SquirrelFunc(_SC("_typename"), &SqDpActivitySecrets::Fn)
// Member Properties
.Prop(_SC("Valid"), &DpActivitySecrets::IsValid)
.Prop(_SC("Join"), &DpActivitySecrets::GetJoin, &DpActivitySecrets::SetJoin)
.Prop(_SC("Spectate"), &DpActivitySecrets::GetSpectate, &DpActivitySecrets::SetSpectate)
.Prop(_SC("Match"), &DpActivitySecrets::GetMatch, &DpActivitySecrets::SetMatch)
// Member Methods
.Func(_SC("SetJoin"), &DpActivitySecrets::ApplyJoin)
.Func(_SC("SetSpectate"), &DpActivitySecrets::ApplySpectate)
.Func(_SC("SetMatch"), &DpActivitySecrets::ApplyMatch)
);
// --------------------------------------------------------------------------------------------
ns.Bind(_SC("Activity"),
Class< DpActivity, NoCopy< DpActivity > >(vm, SqDpActivity::Str)
// Constructors
.Ctor()
.Ctor< SQInteger, StackStrF &, StackStrF &, StackStrF & >()
// Meta-methods
.SquirrelFunc(_SC("_typename"), &SqDpActivity::Fn)
// Member Properties
.Prop(_SC("Valid"), &DpActivity::IsValid)
.Prop(_SC("Name"), &DpActivity::GetName, &DpActivity::SetName)
.Prop(_SC("State"), &DpActivity::GetState, &DpActivity::SetState)
.Prop(_SC("Details"), &DpActivity::GetDetails, &DpActivity::SetDetails)
.Prop(_SC("Assets"), &DpActivity::GetAssets)
.Prop(_SC("Buttons"), &DpActivity::GetButtons)
.Prop(_SC("Emoji"), &DpActivity::GetEmoji)
.Prop(_SC("PartyID"), &DpActivity::GetPartyID)
.Prop(_SC("CurrentPartySize"), &DpActivity::GetCurrentPartySize)
.Prop(_SC("MaxPartySize"), &DpActivity::GetMaxPartySize)
.Prop(_SC("Secrets"), &DpActivity::GetSecrets)
.Prop(_SC("URL"), &DpActivity::GetURL, &DpActivity::SetURL)
.Prop(_SC("Type"), &DpActivity::GetType, &DpActivity::SetType)
.Prop(_SC("CreatedAt"), &DpActivity::GetCreatedAt, &DpActivity::SetCreatedAt)
.Prop(_SC("Start"), &DpActivity::GetStart, &DpActivity::SetStart)
.Prop(_SC("End"), &DpActivity::GetEnd, &DpActivity::SetEnd)
.Prop(_SC("ApplicationID"), &DpActivity::GetApplicationID)
.Prop(_SC("Flags"), &DpActivity::GetFlags, &DpActivity::SetFlags)
.Prop(_SC("Instance"), &DpActivity::IsInstance)
// Member Methods
.Func(_SC("SetName"), &DpActivity::ApplyName)
.Func(_SC("SetState"), &DpActivity::ApplyState)
.Func(_SC("SetDetails"), &DpActivity::ApplyDetails)
.Func(_SC("SetURL"), &DpActivity::ApplyURL)
.Func(_SC("SetType"), &DpActivity::ApplyType)
.Func(_SC("SetCreatedAt"), &DpActivity::ApplyCreatedAt)
.Func(_SC("SetStart"), &DpActivity::ApplyStart)
.Func(_SC("SetEnd"), &DpActivity::ApplyEnd)
.Func(_SC("SetFlags"), &DpActivity::ApplyFlags)
.Func(_SC("GetLargeAssetURL"), &DpActivity::GetLargeAssetURL)
.Func(_SC("GetSmallAssetURL"), &DpActivity::GetSmallAssetURL)
);
// --------------------------------------------------------------------------------------------
Register_Discord_VectorProxy< dpp::activity, DpActivity, SqDpActivities >(vm, ns, _SC("Activities"));
// --------------------------------------------------------------------------------------------
ns.Bind(_SC("Presence"),
Class< DpPresence, NoCopy< DpPresence > >(vm, SqDpPresence::Str)
// Constructors
.Ctor()
.Ctor< SQInteger, DpActivity & >()
.Ctor< SQInteger, SQInteger, StackStrF & >()
// Meta-methods
.SquirrelFunc(_SC("_typename"), &SqDpPresence::Fn)
// Member Properties
.Prop(_SC("Valid"), &DpPresence::IsValid)
.Prop(_SC("JSON"), &DpPresence::BuildJSON)
.Prop(_SC("UserID"), &DpPresence::GetUserID, &DpPresence::SetUserID)
.Prop(_SC("GuildID"), &DpPresence::GetGuildID, &DpPresence::SetGuildID)
.Prop(_SC("Flags"), &DpPresence::GetFlags, &DpPresence::SetFlags)
.Prop(_SC("Activities"), &DpPresence::GetActivities)
.Prop(_SC("DesktopStatus"), &DpPresence::GetDesktopStatus)
.Prop(_SC("WebStatus"), &DpPresence::GetWebStatus)
.Prop(_SC("MobileStatus"), &DpPresence::GetMobileStatus)
.Prop(_SC("Status"), &DpPresence::GetStatus)
// Member Methods
.Func(_SC("SetUserID"), &DpPresence::ApplyUserID)
.Func(_SC("SetGuildID"), &DpPresence::ApplyGuildID)
.Func(_SC("SetFlags"), &DpPresence::ApplyFlags)
.Func(_SC("BuildJSON"), &DpVoiceState::BuildJSON_)
);
}
} // Namespace:: SqMod
module/Library/Discord/Presence.hpp
+928
View File
@@ -0,0 +1,928 @@
#pragma once
// ------------------------------------------------------------------------------------------------
#include "Library/Discord/Misc.hpp"
// ------------------------------------------------------------------------------------------------
#include <dpp/dpp.h>
// ------------------------------------------------------------------------------------------------
#include <chrono>
// ------------------------------------------------------------------------------------------------
namespace SqMod {
/* ------------------------------------------------------------------------------------------------
* An activity button is a custom button shown in the rich presence. Can be to join a game or whatever.
*/
struct DpActivityButton
{
using Ptr = std::unique_ptr< dpp::activity_button >;
/* --------------------------------------------------------------------------------------------
* Referenced activity instance.
*/
Ptr mPtr{nullptr};
/* --------------------------------------------------------------------------------------------
* Whether the referenced pointer is owned.
*/
bool mOwned{false};
/* --------------------------------------------------------------------------------------------
* Default constructor.
*/
DpActivityButton() noexcept
: DpActivityButton(new Ptr::element_type(), true)
{ }
/* --------------------------------------------------------------------------------------------
* Explicit constructor.
*/
explicit DpActivityButton(Ptr::pointer ptr, bool owned = false) noexcept
: mPtr(ptr), mOwned(owned)
{ }
/* --------------------------------------------------------------------------------------------
* Copy constructor.
*/
explicit DpActivityButton(const Ptr::element_type & o) noexcept
: DpActivityButton(new Ptr::element_type(o), true)
{ }
/* --------------------------------------------------------------------------------------------
* Move constructor.
*/
explicit DpActivityButton(Ptr::element_type && o) noexcept
: DpActivityButton(new Ptr::element_type(std::forward< Ptr::element_type >(o)), true)
{ }
/* --------------------------------------------------------------------------------------------
* Copy constructor (disabled).
*/
DpActivityButton(const DpActivityButton & o) = delete;
/* --------------------------------------------------------------------------------------------
* Move constructor.
*/
DpActivityButton(DpActivityButton && o) noexcept = default;
/* --------------------------------------------------------------------------------------------
* Destructor.
*/
~DpActivityButton() noexcept { Cleanup(); }
/* --------------------------------------------------------------------------------------------
* Copy assignment operator (disabled).
*/
DpActivityButton & operator = (const DpActivityButton & o) = delete;
/* --------------------------------------------------------------------------------------------
* Move assignment operator.
*/
DpActivityButton & operator = (DpActivityButton && o) noexcept
{
if (this != &o) {
Cleanup();
// Transfer members values
mPtr = std::move(o.mPtr);
mOwned = o.mOwned;
}
return *this;
}
/* --------------------------------------------------------------------------------------------
* Release any referenced resources and default to an empty/invalid state.
*/
void Cleanup()
{
// Do we own this to try delete it?
if (!mOwned && mPtr) {
// Not our job, simply forget about it
[[maybe_unused]] auto p = mPtr.release();
} else mPtr.reset(); // We own this so delete the instance
}
/* --------------------------------------------------------------------------------------------
* Validate the managed handle.
*/
void Validate() const { if (!mPtr) STHROWF("Invalid discord activity button handle"); }
/* --------------------------------------------------------------------------------------------
* Validate the managed handle and retrieve a const reference to it.
*/
SQMOD_NODISCARD Ptr::element_type & Valid() const { Validate(); return *mPtr; }
/* --------------------------------------------------------------------------------------------
* Check whether a valid instance is managed.
*/
SQMOD_NODISCARD bool IsValid() const { return static_cast< bool >(mPtr); }
/* --------------------------------------------------------------------------------------------
* Retrieve the text shown on the button (1-32 characters).
*/
SQMOD_NODISCARD const std::string & GetLabel() const { return Valid().label; }
/* --------------------------------------------------------------------------------------------
* Modify the text shown on the button (1-32 characters).
*/
void SetLabel(StackStrF & label) const { Valid().label = label.ToStr(); }
/* --------------------------------------------------------------------------------------------
* Modify the text shown on the button (1-32 characters).
*/
DpActivityButton & ApplyLabel(StackStrF & label) { SetLabel(label); return *this; }
/* --------------------------------------------------------------------------------------------
* Retrieve the url opened when clicking the button (1-512 characters). It's may be empty.
*/
SQMOD_NODISCARD const std::string & GetURL() const { return Valid().url; }
/* --------------------------------------------------------------------------------------------
* Modify the url opened when clicking the button (1-512 characters).
*/
void SetURL(StackStrF & url) const { Valid().url = url.ToStr(); }
/* --------------------------------------------------------------------------------------------
* Modify the url opened when clicking the button (1-512 characters).
*/
DpActivityButton & ApplyURL(StackStrF & url) { SetURL(url); return *this; }
};
/* ------------------------------------------------------------------------------------------------
* An activity asset are the images and the hover text displayed in the rich presence.
*/
struct DpActivityAssets
{
using Ptr = std::unique_ptr< dpp::activity_assets >;
/* --------------------------------------------------------------------------------------------
* Referenced activity instance.
*/
Ptr mPtr{nullptr};
/* --------------------------------------------------------------------------------------------
* Whether the referenced pointer is owned.
*/
bool mOwned{false};
/* --------------------------------------------------------------------------------------------
* Default constructor.
*/
DpActivityAssets() noexcept
: DpActivityAssets(new Ptr::element_type(), true)
{ }
/* --------------------------------------------------------------------------------------------
* Explicit constructor.
*/
explicit DpActivityAssets(Ptr::pointer ptr, bool owned = false) noexcept
: mPtr(ptr), mOwned(owned)
{ }
/* --------------------------------------------------------------------------------------------
* Copy constructor.
*/
explicit DpActivityAssets(const Ptr::element_type & o) noexcept
: DpActivityAssets(new Ptr::element_type(o), true)
{ }
/* --------------------------------------------------------------------------------------------
* Move constructor.
*/
explicit DpActivityAssets(Ptr::element_type && o) noexcept
: DpActivityAssets(new Ptr::element_type(std::forward< Ptr::element_type >(o)), true)
{ }
/* --------------------------------------------------------------------------------------------
* Copy constructor (disabled).
*/
DpActivityAssets(const DpActivityAssets & o) = delete;
/* --------------------------------------------------------------------------------------------
* Move constructor.
*/
DpActivityAssets(DpActivityAssets && o) noexcept = default;
/* --------------------------------------------------------------------------------------------
* Destructor.
*/
~DpActivityAssets() noexcept { Cleanup(); }
/* --------------------------------------------------------------------------------------------
* Copy assignment operator (disabled).
*/
DpActivityAssets & operator = (const DpActivityAssets & o) = delete;
/* --------------------------------------------------------------------------------------------
* Move assignment operator.
*/
DpActivityAssets & operator = (DpActivityAssets && o) noexcept
{
if (this != &o) {
Cleanup();
// Transfer members values
mPtr = std::move(o.mPtr);
mOwned = o.mOwned;
}
return *this;
}
/* --------------------------------------------------------------------------------------------
* Release any referenced resources and default to an empty/invalid state.
*/
void Cleanup()
{
// Do we own this to try delete it?
if (!mOwned && mPtr) {
// Not our job, simply forget about it
[[maybe_unused]] auto p = mPtr.release();
} else mPtr.reset(); // We own this so delete the instance
}
/* --------------------------------------------------------------------------------------------
* Validate the managed handle.
*/
void Validate() const { if (!mPtr) STHROWF("Invalid discord activity assets handle"); }
/* --------------------------------------------------------------------------------------------
* Validate the managed handle and retrieve a const reference to it.
*/
SQMOD_NODISCARD Ptr::element_type & Valid() const { Validate(); return *mPtr; }
/* --------------------------------------------------------------------------------------------
* Check whether a valid instance is managed.
*/
SQMOD_NODISCARD bool IsValid() const { return static_cast< bool >(mPtr); }
/* --------------------------------------------------------------------------------------------
* Retrieve the large asset image which usually contain snowflake ID or prefixed image ID.
*/
SQMOD_NODISCARD const std::string & GetLargeImage() const { return Valid().large_image; }
/* --------------------------------------------------------------------------------------------
* Modify the large asset image.
*/
void SetLargeImage(StackStrF & large_image) const { Valid().large_image = large_image.ToStr(); }
/* --------------------------------------------------------------------------------------------
* Modify the large asset image.
*/
DpActivityAssets & ApplyLargeImage(StackStrF & large_image) { SetLargeImage(large_image); return *this; }
/* --------------------------------------------------------------------------------------------
* Retrieve the text displayed when hovering over the large image of the activity.
*/
SQMOD_NODISCARD const std::string & GetLargeText() const { return Valid().large_text; }
/* --------------------------------------------------------------------------------------------
* Modify the text displayed when hovering over the large image of the activity.
*/
void SetLargeText(StackStrF & large_text) const { Valid().large_text = large_text.ToStr(); }
/* --------------------------------------------------------------------------------------------
* Modify the text displayed when hovering over the large image of the activity.
*/
DpActivityAssets & ApplyLargeText(StackStrF & large_text) { SetLargeText(large_text); return *this; }
/* --------------------------------------------------------------------------------------------
* Retrieve the small asset image which usually contain snowflake ID or prefixed image ID.
*/
SQMOD_NODISCARD const std::string & GetSmallImage() const { return Valid().small_image; }
/* --------------------------------------------------------------------------------------------
* Modify the small asset image.
*/
void SetSmallImage(StackStrF & small_image) const { Valid().small_image = small_image.ToStr(); }
/* --------------------------------------------------------------------------------------------
* Modify the small asset image.
*/
DpActivityAssets & ApplySmallImage(StackStrF & small_image) { SetSmallImage(small_image); return *this; }
/* --------------------------------------------------------------------------------------------
* Retrieve the text displayed when hovering over the small image of the activity.
*/
SQMOD_NODISCARD const std::string & GetSmallText() const { return Valid().small_text; }
/* --------------------------------------------------------------------------------------------
* Modify the text displayed when hovering over the small image of the activity.
*/
void SetSmallText(StackStrF & small_text) const { Valid().small_text = small_text.ToStr(); }
/* --------------------------------------------------------------------------------------------
* Modify the text displayed when hovering over the small image of the activity.
*/
DpActivityAssets & ApplySmallText(StackStrF & small_text) { SetSmallText(small_text); return *this; }
};
/* ------------------------------------------------------------------------------------------------
* Secrets for Rich Presence joining and spectating.
*/
struct DpActivitySecrets
{
using Ptr = std::unique_ptr< dpp::activity_secrets >;
/* --------------------------------------------------------------------------------------------
* Referenced activity instance.
*/
Ptr mPtr{nullptr};
/* --------------------------------------------------------------------------------------------
* Whether the referenced pointer is owned.
*/
bool mOwned{false};
/* --------------------------------------------------------------------------------------------
* Default constructor.
*/
DpActivitySecrets() noexcept
: DpActivitySecrets(new Ptr::element_type(), true)
{ }
/* --------------------------------------------------------------------------------------------
* Explicit constructor.
*/
explicit DpActivitySecrets(Ptr::pointer ptr, bool owned = false) noexcept
: mPtr(ptr), mOwned(owned)
{ }
/* --------------------------------------------------------------------------------------------
* Copy constructor.
*/
explicit DpActivitySecrets(const Ptr::element_type & o) noexcept
: DpActivitySecrets(new Ptr::element_type(o), true)
{ }
/* --------------------------------------------------------------------------------------------
* Move constructor.
*/
explicit DpActivitySecrets(Ptr::element_type && o) noexcept
: DpActivitySecrets(new Ptr::element_type(std::forward< Ptr::element_type >(o)), true)
{ }
/* --------------------------------------------------------------------------------------------
* Copy constructor (disabled).
*/
DpActivitySecrets(const DpActivitySecrets & o) = delete;
/* --------------------------------------------------------------------------------------------
* Move constructor.
*/
DpActivitySecrets(DpActivitySecrets && o) noexcept = default;
/* --------------------------------------------------------------------------------------------
* Destructor.
*/
~DpActivitySecrets() noexcept { Cleanup(); }
/* --------------------------------------------------------------------------------------------
* Copy assignment operator (disabled).
*/
DpActivitySecrets & operator = (const DpActivitySecrets & o) = delete;
/* --------------------------------------------------------------------------------------------
* Move assignment operator.
*/
DpActivitySecrets & operator = (DpActivitySecrets && o) noexcept
{
if (this != &o) {
Cleanup();
// Transfer members values
mPtr = std::move(o.mPtr);
mOwned = o.mOwned;
}
return *this;
}
/* --------------------------------------------------------------------------------------------
* Release any referenced resources and default to an empty/invalid state.
*/
void Cleanup()
{
// Do we own this to try delete it?
if (!mOwned && mPtr) {
// Not our job, simply forget about it
[[maybe_unused]] auto p = mPtr.release();
} else mPtr.reset(); // We own this so delete the instance
}
/* --------------------------------------------------------------------------------------------
* Validate the managed handle.
*/
void Validate() const { if (!mPtr) STHROWF("Invalid discord activity secrets handle"); }
/* --------------------------------------------------------------------------------------------
* Validate the managed handle and retrieve a const reference to it.
*/
SQMOD_NODISCARD Ptr::element_type & Valid() const { Validate(); return *mPtr; }
/* --------------------------------------------------------------------------------------------
* Check whether a valid instance is managed.
*/
SQMOD_NODISCARD bool IsValid() const { return static_cast< bool >(mPtr); }
/* --------------------------------------------------------------------------------------------
* Retrieve the secret for joining a party.
*/
SQMOD_NODISCARD const std::string & GetJoin() const { return Valid().join; }
/* --------------------------------------------------------------------------------------------
* Modify the secret for joining a party.
*/
void SetJoin(StackStrF & join) const { Valid().join = join.ToStr(); }
/* --------------------------------------------------------------------------------------------
* Modify the secret for joining a party.
*/
DpActivitySecrets & ApplyJoin(StackStrF & join) { SetJoin(join); return *this; }
/* --------------------------------------------------------------------------------------------
* Retrieve the secret for spectating a game.
*/
SQMOD_NODISCARD const std::string & GetSpectate() const { return Valid().spectate; }
/* --------------------------------------------------------------------------------------------
* Modify the secret for spectating a game.
*/
void SetSpectate(StackStrF & spectate) const { Valid().spectate = spectate.ToStr(); }
/* --------------------------------------------------------------------------------------------
* Modify the secret for spectating a game.
*/
DpActivitySecrets & ApplySpectate(StackStrF & spectate) { SetSpectate(spectate); return *this; }
/* --------------------------------------------------------------------------------------------
* Retrieve the secret for a specific instanced match.
*/
SQMOD_NODISCARD const std::string & GetMatch() const { return Valid().match; }
/* --------------------------------------------------------------------------------------------
* Modify the secret for a specific instanced match.
*/
void SetMatch(StackStrF & match) const { Valid().match = match.ToStr(); }
/* --------------------------------------------------------------------------------------------
* Modify the secret for a specific instanced match.
*/
DpActivitySecrets & ApplyMatch(StackStrF & match) { SetMatch(match); return *this; }
};
/* ------------------------------------------------------------------------------------------------
* An activity is a representation of what a user is doing. It might be a game, or a website, or a movie. Whatever.
*/
struct DpActivity
{
using Ptr = std::unique_ptr< dpp::activity >;
/* --------------------------------------------------------------------------------------------
* Referenced activity instance.
*/
Ptr mPtr{nullptr};
/* --------------------------------------------------------------------------------------------
* Whether the referenced pointer is owned.
*/
bool mOwned{false};
// --------------------------------------------------------------------------------------------
using Buttons = DpVectorProxy< dpp::activity_button, DpActivityButton >;
// --------------------------------------------------------------------------------------------
LightObj mSqAssets{};
LightObj mSqButtons{};
LightObj mSqEmoji{};
LightObj mSqSecrets{};
/* --------------------------------------------------------------------------------------------
* Default constructor.
*/
DpActivity() noexcept
: DpActivity(new Ptr::element_type(), true)
{ }
/* --------------------------------------------------------------------------------------------
* Explicit constructor.
*/
explicit DpActivity(Ptr::pointer ptr, bool owned = false) noexcept
: mPtr(ptr), mOwned(owned)
{ }
/* --------------------------------------------------------------------------------------------
* Copy constructor.
*/
explicit DpActivity(const Ptr::element_type & o) noexcept
: DpActivity(new Ptr::element_type(o), true)
{ }
/* --------------------------------------------------------------------------------------------
* Move constructor.
*/
explicit DpActivity(Ptr::element_type && o) noexcept
: DpActivity(new Ptr::element_type(std::forward< Ptr::element_type >(o)), true)
{ }
/* --------------------------------------------------------------------------------------------
* Explicit constructor.
*/
DpActivity(SQInteger type, StackStrF & name, StackStrF & state, StackStrF & url)
: DpActivity(new Ptr::element_type(static_cast< dpp::activity_type >(type), name.ToStr(), state.ToStr(), url.ToStr()), true)
{ }
/* --------------------------------------------------------------------------------------------
* Copy constructor (disabled).
*/
DpActivity(const DpActivity & o) = delete;
/* --------------------------------------------------------------------------------------------
* Move constructor.
*/
DpActivity(DpActivity && o) noexcept = default;
/* --------------------------------------------------------------------------------------------
* Destructor.
*/
~DpActivity() noexcept { Cleanup(); }
/* --------------------------------------------------------------------------------------------
* Copy assignment operator (disabled).
*/
DpActivity & operator = (const DpActivity & o) = delete;
/* --------------------------------------------------------------------------------------------
* Move assignment operator.
*/
DpActivity & operator = (DpActivity && o) noexcept
{
if (this != &o) {
Cleanup();
// Transfer members values
mPtr = std::move(o.mPtr);
mOwned = o.mOwned;
}
return *this;
}
/* --------------------------------------------------------------------------------------------
* Release any referenced resources and default to an empty/invalid state.
*/
void Cleanup()
{
// Cleanup activity assets, if any
if (!mSqAssets.IsNull())
{
mSqAssets.CastI< DpActivityAssets >()->Cleanup();
// Release script resources
mSqAssets.Release();
}
// Cleanup activity buttons, if any
if (!mSqButtons.IsNull())
{
mSqButtons.CastI< Buttons >()->Cleanup();
// Release script resources
mSqButtons.Release();
}
// Cleanup activity emoji, if any
if (!mSqEmoji.IsNull())
{
mSqEmoji.CastI< DpEmoji >()->Cleanup();
// Release script resources
mSqEmoji.Release();
}
// Cleanup activity secrets, if any
if (!mSqSecrets.IsNull())
{
mSqSecrets.CastI< DpActivitySecrets >()->Cleanup();
// Release script resources
mSqSecrets.Release();
}
// Do we own this to try delete it?
if (!mOwned && mPtr) {
// Not our job, simply forget about it
[[maybe_unused]] auto p = mPtr.release();
} else mPtr.reset(); // We own this so delete the instance
}
/* --------------------------------------------------------------------------------------------
* Validate the managed handle.
*/
void Validate() const { if (!mPtr) STHROWF("Invalid discord activity handle"); }
/* --------------------------------------------------------------------------------------------
* Validate the managed handle and retrieve a const reference to it.
*/
SQMOD_NODISCARD Ptr::element_type & Valid() const { Validate(); return *mPtr; }
/* --------------------------------------------------------------------------------------------
* Check whether a valid instance is managed.
*/
SQMOD_NODISCARD bool IsValid() const { return static_cast< bool >(mPtr); }
/* --------------------------------------------------------------------------------------------
* Retrieve the name of the activity. e.g. "Vice City"
*/
SQMOD_NODISCARD const std::string & GetName() const { return Valid().name; }
/* --------------------------------------------------------------------------------------------
* Modify the name of the activity.
*/
void SetName(StackStrF & name) const { Valid().name = name.ToStr(); }
/* --------------------------------------------------------------------------------------------
* Modify the name of the activity.
*/
DpActivity & ApplyName(StackStrF & name) { SetName(name); return *this; }
/* --------------------------------------------------------------------------------------------
* Retrieve the state of the activity. e.g. "Waiting in lobby"
*/
SQMOD_NODISCARD const std::string & GetState() const { return Valid().state; }
/* --------------------------------------------------------------------------------------------
* Modify the state of the activity.
*/
void SetState(StackStrF & state) const { Valid().state = state.ToStr(); }
/* --------------------------------------------------------------------------------------------
* Modify the state of the activity.
*/
DpActivity & ApplyState(StackStrF & state) { SetState(state); return *this; }
/* --------------------------------------------------------------------------------------------
* Retrieve the details of the activity. What the player is currently doing.
*/
SQMOD_NODISCARD const std::string & GetDetails() const { return Valid().details; }
/* --------------------------------------------------------------------------------------------
* Modify the details of the activity.
*/
void SetDetails(StackStrF & details) const { Valid().details = details.ToStr(); }
/* --------------------------------------------------------------------------------------------
* Modify the details of the activity.
*/
DpActivity & ApplyDetails(StackStrF & details) { SetDetails(details); return *this; }
/* --------------------------------------------------------------------------------------------
* Retrieve the images for the presence and their hover texts.
*/
SQMOD_NODISCARD LightObj & GetAssets()
{
if (mSqAssets.IsNull())
{
mSqAssets = LightObj{SqTypeIdentity< DpActivityAssets >{}, SqVM(), &Valid().assets, false};
}
// Return the associated script object
return mSqAssets;
}
/* --------------------------------------------------------------------------------------------
* Retrieve the url of the activity. Only applicable for certain sites such a YouTube.
*/
SQMOD_NODISCARD const std::string & GetURL() const { return Valid().url; }
/* --------------------------------------------------------------------------------------------
* Modify the url of the activity.
*/
void SetURL(StackStrF & url) const { Valid().url = url.ToStr(); }
/* --------------------------------------------------------------------------------------------
* Modify the url of the activity.
*/
DpActivity & ApplyURL(StackStrF & url) { SetURL(url); return *this; }
/* --------------------------------------------------------------------------------------------
* Retrieve the custom buttons shown in the Rich Presence (max 2).
*/
SQMOD_NODISCARD LightObj & GetButtons()
{
if (mSqButtons.IsNull())
{
mSqButtons = LightObj{SqTypeIdentity< Buttons >{}, SqVM(), &Valid().buttons, false};
}
// Return the associated script object
return mSqButtons;
}
/* --------------------------------------------------------------------------------------------
* Retrieve the emoji used for the custom status.
*/
SQMOD_NODISCARD LightObj & GetEmoji()
{
if (mSqEmoji.IsNull())
{
mSqEmoji = LightObj{SqTypeIdentity< DpEmoji >{}, SqVM(), &Valid().emoji, false};
}
// Return the associated script object
return mSqEmoji;
}
/* --------------------------------------------------------------------------------------------
* Retrieve the ID of the party.
*/
SQMOD_NODISCARD dpp::snowflake GetPartyID() const { return Valid().party.id; }
/* --------------------------------------------------------------------------------------------
* Retrieve the party's current size. Used to show the party's current size.
*/
SQMOD_NODISCARD SQInteger GetCurrentPartySize() const { return Valid().party.current_size; }
/* --------------------------------------------------------------------------------------------
* Retrieve the party's maximum size. Used to show the party's maximum size.
*/
SQMOD_NODISCARD SQInteger GetMaxPartySize() const { return Valid().party.maximum_size; }
/* --------------------------------------------------------------------------------------------
* Retrieve the secrets for rich presence joining and spectating.
*/
SQMOD_NODISCARD LightObj & GetSecrets()
{
if (mSqSecrets.IsNull())
{
mSqSecrets = LightObj{SqTypeIdentity< DpActivitySecrets >{}, SqVM(), &Valid().secrets, false};
}
// Return the associated script object
return mSqSecrets;
}
/* --------------------------------------------------------------------------------------------
* Retrieve the type for the activity from SqDiscordActivityType.
*/
SQMOD_NODISCARD SQInteger GetType() const { return Valid().type; }
/* --------------------------------------------------------------------------------------------
* Modify the type for the activity from SqDiscordActivityType.
*/
void SetType(SQInteger type) const { Valid().type = static_cast< dpp::activity_type >(type); }
/* --------------------------------------------------------------------------------------------
* Modify the type for the activity from SqDiscordActivityType.
*/
DpActivity & ApplyType(SQInteger type) { SetType(type); return *this; }
/* --------------------------------------------------------------------------------------------
* Retrieve when the activity was created.
*/
SQMOD_NODISCARD SQInteger GetCreatedAt() const
{
return static_cast< SQInteger >(std::chrono::duration_cast< std::chrono::seconds >(std::chrono::system_clock::from_time_t(Valid().created_at).time_since_epoch()).count());
}
/* --------------------------------------------------------------------------------------------
* Modify when the activity was created.
*/
void SetCreatedAt(SQInteger s) const
{
Valid().created_at = std::chrono::system_clock::to_time_t(std::chrono::time_point< std::chrono::system_clock >{std::chrono::seconds{s}});
}
/* --------------------------------------------------------------------------------------------
* Modify when the activity was created.
*/
DpActivity & ApplyCreatedAt(SQInteger s) { SetCreatedAt(s); return *this; }
/* --------------------------------------------------------------------------------------------
* Retrieve when the activity was started.
*/
SQMOD_NODISCARD SQInteger GetStart() const
{
return static_cast< SQInteger >(std::chrono::duration_cast< std::chrono::seconds >(std::chrono::system_clock::from_time_t(Valid().start).time_since_epoch()).count());
}
/* --------------------------------------------------------------------------------------------
* Modify when the activity was started.
*/
void SetStart(SQInteger s) const
{
Valid().start = std::chrono::system_clock::to_time_t(std::chrono::time_point< std::chrono::system_clock >{std::chrono::seconds{s}});
}
/* --------------------------------------------------------------------------------------------
* Modify when the activity was started.
*/
DpActivity & ApplyStart(SQInteger s) { SetStart(s); return *this; }
/* --------------------------------------------------------------------------------------------
* Retrieve when the activity was stopped.
*/
SQMOD_NODISCARD SQInteger GetEnd() const
{
return static_cast< SQInteger >(std::chrono::duration_cast< std::chrono::seconds >(std::chrono::system_clock::from_time_t(Valid().end).time_since_epoch()).count());
}
/* --------------------------------------------------------------------------------------------
* Modify when the activity was stopped.
*/
void SetEnd(SQInteger s) const
{
Valid().end = std::chrono::system_clock::to_time_t(std::chrono::time_point< std::chrono::system_clock >{std::chrono::seconds{s}});
}
/* --------------------------------------------------------------------------------------------
* Modify when the activity was stopped.
*/
DpActivity & ApplyEnd(SQInteger s) { SetEnd(s); return *this; }
/* --------------------------------------------------------------------------------------------
* Retrieve the creating application (e.g. a linked account on the user's client)
*/
SQMOD_NODISCARD dpp::snowflake GetApplicationID() const { return Valid().application_id; }
/* --------------------------------------------------------------------------------------------
* Retrieve the flags for the activity from SqDiscordActivityFlags.
*/
SQMOD_NODISCARD SQInteger GetFlags() const { return Valid().flags; }
/* --------------------------------------------------------------------------------------------
* Modify the flags for the activity from SqDiscordActivityFlags.
*/
void SetFlags(SQInteger flags) const { Valid().flags = static_cast< uint8_t >(flags); }
/* --------------------------------------------------------------------------------------------
* Modify the flags for the activity from SqDiscordActivityFlags.
*/
DpActivity & ApplyFlags(SQInteger flags) { SetFlags(flags); return *this; }
/* --------------------------------------------------------------------------------------------
* Retrieve whether or not the activity is an instanced game session.
*/
SQMOD_NODISCARD bool IsInstance() const { return Valid().is_instance; }
/* --------------------------------------------------------------------------------------------
* Get the assets large image url if they have one, otherwise returns an empty string.
* In case of prefixed image IDs (mp:{image_id}) it returns an empty string.
* See: https://discord.com/developers/docs/topics/gateway-events#activity-object-activity-asset-image
*/
SQMOD_NODISCARD std::string GetLargeAssetURL(SQInteger size, SQInteger format) const
{ return Valid().get_large_asset_url(static_cast< uint16_t >(size), static_cast< dpp::image_type >(format)); }
/* --------------------------------------------------------------------------------------------
* Get the assets small image url if they have one, otherwise returns an empty string.
* In case of prefixed image IDs (mp:{image_id}) it returns an empty string.
* See: https://discord.com/developers/docs/topics/gateway-events#activity-object-activity-asset-image
*/
SQMOD_NODISCARD std::string GetSmallAssetURL(SQInteger size, SQInteger format) const
{ return Valid().get_small_asset_url(static_cast< uint16_t >(size), static_cast< dpp::image_type >(format)); }
};
/* ------------------------------------------------------------------------------------------------
* Represents user presence, e.g. what game they are playing and if they are online.
*/
struct DpPresence
{
using Ptr = std::unique_ptr< dpp::presence >;
/* --------------------------------------------------------------------------------------------
* Referenced presence instance.
*/
Ptr mPtr{nullptr};
/* --------------------------------------------------------------------------------------------
* Whether the referenced pointer is owned.
*/
bool mOwned{false};
// --------------------------------------------------------------------------------------------
using Activities = DpVectorProxy< dpp::activity, DpActivity >;
// --------------------------------------------------------------------------------------------
LightObj mSqActivities{};
/* --------------------------------------------------------------------------------------------
* Default constructor.
*/
DpPresence() noexcept
: DpPresence(new Ptr::element_type(), true)
{ }
/* --------------------------------------------------------------------------------------------
* Explicit constructor.
*/
explicit DpPresence(Ptr::pointer ptr, bool owned = false) noexcept
: mPtr(ptr), mOwned(owned)
{ }
/* --------------------------------------------------------------------------------------------
* Copy constructor.
*/
explicit DpPresence(const Ptr::element_type & o) noexcept
: DpPresence(new Ptr::element_type(o), true)
{ }
/* --------------------------------------------------------------------------------------------
* Move constructor.
*/
explicit DpPresence(Ptr::element_type && o) noexcept
: DpPresence(new Ptr::element_type(std::forward< Ptr::element_type >(o)), true)
{ }
/* --------------------------------------------------------------------------------------------
* Explicit constructor.
*/
DpPresence(SQInteger status, DpActivity & activity)
: DpPresence(new Ptr::element_type(static_cast< dpp::presence_status >(status), activity.Valid()), true)
{ }
/* --------------------------------------------------------------------------------------------
* Explicit constructor.
*/
DpPresence(SQInteger status, SQInteger type, StackStrF & description)
: DpPresence(new Ptr::element_type(static_cast< dpp::presence_status >(status), static_cast< dpp::activity_type >(status), description.ToStr()), true)
{ }
/* --------------------------------------------------------------------------------------------
* Copy constructor (disabled).
*/
DpPresence(const DpPresence & o) = delete;
/* --------------------------------------------------------------------------------------------
* Move constructor.
*/
DpPresence(DpPresence && o) noexcept = default;
/* --------------------------------------------------------------------------------------------
* Destructor.
*/
~DpPresence() noexcept { Cleanup(); }
/* --------------------------------------------------------------------------------------------
* Copy assignment operator (disabled).
*/
DpPresence & operator = (const DpPresence & o) = delete;
/* --------------------------------------------------------------------------------------------
* Move assignment operator.
*/
DpPresence & operator = (DpPresence && o) noexcept
{
if (this != &o) {
Cleanup();
// Transfer members values
mPtr = std::move(o.mPtr);
mOwned = o.mOwned;
}
return *this;
}
/* --------------------------------------------------------------------------------------------
* Release any referenced resources and default to an empty/invalid state.
*/
void Cleanup()
{
// Cleanup presence activities, if any
if (!mSqActivities.IsNull())
{
mSqActivities.CastI< Activities >()->Cleanup();
// Release script resources
mSqActivities.Release();
}
// Do we own this to try delete it?
if (!mOwned && mPtr) {
// Not our job, simply forget about it
[[maybe_unused]] auto p = mPtr.release();
} else mPtr.reset(); // We own this so delete the instance
}
/* --------------------------------------------------------------------------------------------
* Validate the managed handle.
*/
void Validate() const { if (!mPtr) STHROWF("Invalid discord presence handle"); }
/* --------------------------------------------------------------------------------------------
* Validate the managed handle and retrieve a const reference to it.
*/
SQMOD_NODISCARD Ptr::element_type & Valid() const { Validate(); return *mPtr; }
/* --------------------------------------------------------------------------------------------
* Check whether a valid instance is managed.
*/
SQMOD_NODISCARD bool IsValid() const { return static_cast< bool >(mPtr); }
/* --------------------------------------------------------------------------------------------
* Retrieve the user that the presence applies to.
*/
SQMOD_NODISCARD dpp::snowflake GetUserID() const { return Valid().user_id; }
/* --------------------------------------------------------------------------------------------
* Modify the user that the presence applies to.
*/
void SetUserID(dpp::snowflake id) const { Valid().user_id = id; }
/* --------------------------------------------------------------------------------------------
* Modify the user that the presence applies to.
*/
DpPresence & ApplyUserID(dpp::snowflake id) { SetUserID(id); return *this; }
/* --------------------------------------------------------------------------------------------
* Retrieve the guild that the presence applies to.
*/
SQMOD_NODISCARD dpp::snowflake GetGuildID() const { return Valid().guild_id; }
/* --------------------------------------------------------------------------------------------
* Modify the guild that the presence applies to.
*/
void SetGuildID(dpp::snowflake id) const { Valid().guild_id = id; }
/* --------------------------------------------------------------------------------------------
* Modify the guild that the presence applies to.
*/
DpPresence & ApplyGuildID(dpp::snowflake id) { SetGuildID(id); return *this; }
/* --------------------------------------------------------------------------------------------
* Retrieve the presence bit-mask.
*/
SQMOD_NODISCARD SQInteger GetFlags() const { return static_cast< SQInteger >(Valid().flags); }
/* --------------------------------------------------------------------------------------------
* Modify the presence bit-mask.
*/
void SetFlags(SQInteger f) const { Valid().flags = static_cast< uint8_t >(f); }
/* --------------------------------------------------------------------------------------------
* Modify the presence bit-mask.
*/
DpPresence & ApplyFlags(SQInteger f) { SetFlags(f); return *this; }
/* --------------------------------------------------------------------------------------------
* Retrieve the list of activities.
*/
SQMOD_NODISCARD LightObj & GetActivities()
{
if (mSqActivities.IsNull())
{
mSqActivities = LightObj{SqTypeIdentity< Activities >{}, SqVM(), &Valid().activities, false};
}
// Return the associated script object
return mSqActivities;
}
/* --------------------------------------------------------------------------------------------
* Build JSON string from this object.
*/
SQMOD_NODISCARD std::string BuildJSON() const { return Valid().build_json(); }
SQMOD_NODISCARD std::string BuildJSON_(bool with_id) const { return Valid().build_json(with_id); }
/* --------------------------------------------------------------------------------------------
* Retrieve the users status on desktop.
*/
SQMOD_NODISCARD SQInteger GetDesktopStatus() const { return static_cast< SQInteger >(Valid().desktop_status()); }
/* --------------------------------------------------------------------------------------------
* Retrieve the user's status on web.
*/
SQMOD_NODISCARD SQInteger GetWebStatus() const { return static_cast< SQInteger >(Valid().web_status()); }
/* --------------------------------------------------------------------------------------------
* Retrieve the user's status on mobile.
*/
SQMOD_NODISCARD SQInteger GetMobileStatus() const { return static_cast< SQInteger >(Valid().mobile_status()); }
/* --------------------------------------------------------------------------------------------
* Retrieve the user's status as shown to other users.
*/
SQMOD_NODISCARD SQInteger GetStatus() const { return static_cast< SQInteger >(Valid().status()); }
};
} // Namespace:: SqMod
module/Library/Discord/Role.cpp
+9
View File
@@ -0,0 +1,9 @@
// ------------------------------------------------------------------------------------------------
#include "Library/Discord/Role.hpp"
// ------------------------------------------------------------------------------------------------
namespace SqMod {
} // Namespace:: SqMod
module/Library/Discord/Role.hpp
+13
View File
@@ -0,0 +1,13 @@
#pragma once
// ------------------------------------------------------------------------------------------------
#include "Core/Utility.hpp"
// ------------------------------------------------------------------------------------------------
#include <dpp/dpp.h>
// ------------------------------------------------------------------------------------------------
namespace SqMod {
} // Namespace:: SqMod
module/Library/Discord/User.cpp
+9
View File
@@ -0,0 +1,9 @@
// ------------------------------------------------------------------------------------------------
#include "Library/Discord/User.hpp"
// ------------------------------------------------------------------------------------------------
namespace SqMod {
} // Namespace:: SqMod
module/Library/Discord/User.hpp
+13
View File
@@ -0,0 +1,13 @@
#pragma once
// ------------------------------------------------------------------------------------------------
#include "Core/Utility.hpp"
// ------------------------------------------------------------------------------------------------
#include <dpp/dpp.h>
// ------------------------------------------------------------------------------------------------
namespace SqMod {
} // Namespace:: SqMod
module/Library/Discord/Utilities.cpp
+9
View File
@@ -0,0 +1,9 @@
// ------------------------------------------------------------------------------------------------
#include "Library/Discord/Utilities.hpp"
// ------------------------------------------------------------------------------------------------
namespace SqMod {
} // Namespace:: SqMod
module/Library/Discord/Utilities.hpp
+462
View File
@@ -0,0 +1,462 @@
#pragma once
// ------------------------------------------------------------------------------------------------
#include "Core/Utility.hpp"
// ------------------------------------------------------------------------------------------------
#include <dpp/dpp.h>
// ------------------------------------------------------------------------------------------------
#include <memory>
// ------------------------------------------------------------------------------------------------
namespace Sqrat {
// Allow the VM to treat the dpp::snowflake type as a integer.
template<> struct Var<dpp::snowflake>
{
dpp::snowflake value;
Var(HSQUIRRELVM vm, SQInteger idx)
{
sq_getinteger(vm, idx, reinterpret_cast<SQInteger*>(&static_cast<uint64_t&>(value)));
}
inline static void push(HSQUIRRELVM vm, const dpp::snowflake& value) noexcept
{
sq_pushinteger(vm, static_cast<SQInteger>(static_cast<uint64_t>(value)));
}
};
// Allow the VM to treat the dpp::snowflake type as a integer.
template<> struct Var<const dpp::snowflake&>
{
dpp::snowflake value;
Var(HSQUIRRELVM vm, SQInteger idx)
{
sq_getinteger(vm, idx, reinterpret_cast<SQInteger*>(&static_cast<uint64_t&>(value)));
}
inline static void push(HSQUIRRELVM vm, const dpp::snowflake& value) noexcept
{
sq_pushinteger(vm, static_cast<SQInteger>(static_cast<uint64_t>(value)));
}
};
}
// ------------------------------------------------------------------------------------------------
namespace SqMod {
/* ------------------------------------------------------------------------------------------------
* Wrapper around a std::vector of DPP values.
*/
template < class T, class W > struct DpVectorProxy
{
using Ptr = std::unique_ptr< std::vector< T > >;
using Vec = std::vector< std::pair< LightObj, W * > >;
/* --------------------------------------------------------------------------------------------
* Referenced vector instance.
*/
Ptr mPtr{nullptr};
/* --------------------------------------------------------------------------------------------
* Cached script objects vector.
*/
Vec mVec{};
/* --------------------------------------------------------------------------------------------
* Whether the referenced pointer is owned.
*/
bool mOwned{false};
/* --------------------------------------------------------------------------------------------
* Default constructor.
*/
DpVectorProxy() noexcept = default;
/* --------------------------------------------------------------------------------------------
* Explicit constructor.
*/
explicit DpVectorProxy(typename Ptr::pointer ptr, bool owned = false)
: mPtr(ptr), mVec(), mOwned(owned)
{ if (mPtr) mVec.resize(mPtr->size()); }
/* --------------------------------------------------------------------------------------------
* Explicit constructor.
*/
explicit DpVectorProxy(const typename Ptr::element_type & o) noexcept
: DpVectorProxy(new typename Ptr::element_type(o), true)
{ }
/* --------------------------------------------------------------------------------------------
* Move constructor.
*/
explicit DpVectorProxy(typename Ptr::element_type && o) noexcept
: DpVectorProxy(new typename Ptr::element_type(std::forward< Ptr::element_type >(o)), true)
{ }
/* --------------------------------------------------------------------------------------------
* Copy constructor (disabled).
*/
DpVectorProxy(const DpVectorProxy & o) = delete;
/* --------------------------------------------------------------------------------------------
* Move constructor.
*/
DpVectorProxy(DpVectorProxy && o) noexcept = default;
/* --------------------------------------------------------------------------------------------
* Destructor.
*/
~DpVectorProxy() noexcept { Cleanup(); }
/* --------------------------------------------------------------------------------------------
* Copy assignment operator (disabled).
*/
DpVectorProxy & operator = (const DpVectorProxy & o) = delete;
/* --------------------------------------------------------------------------------------------
* Move assignment operator.
*/
DpVectorProxy & operator = (DpVectorProxy && o) noexcept
{
if (this != &o) {
Cleanup();
// Transfer members values
mPtr = std::move(o.mPtr);
mVec = std::move(o.mVec);
mOwned = o.mOwned;
}
return *this;
}
/* --------------------------------------------------------------------------------------------
* Release any referenced resources and default to an empty/invalid state.
*/
void Cleanup()
{
// Invalidate cached instances
ClearCache();
// Do we own this to try delete it?
if (!mOwned && mPtr) {
// Not our job, simply forget about it
[[maybe_unused]] auto p = mPtr.release();
} else mPtr.reset(); // We own this so delete the instance
}
/* --------------------------------------------------------------------------------------------
* Validate the managed handle.
*/
void Validate() const { if (!mPtr) STHROWF("Invalid discord vector handle"); }
/* --------------------------------------------------------------------------------------------
* Validate the managed handle and retrieve a const reference to it.
*/
SQMOD_NODISCARD typename Ptr::element_type & Valid() const { Validate(); return *mPtr; }
/* --------------------------------------------------------------------------------------------
* Check whether a valid instance is managed.
*/
SQMOD_NODISCARD bool IsValid() const { return static_cast< bool >(mPtr); }
/* --------------------------------------------------------------------------------------------
* Make sure an index is within range and return the container. Container must exist.
*/
void ValidIdx_(SQInteger i)
{
if (static_cast< size_t >(i) >= Valid().size())
{
STHROWF("Invalid vector container index({})", i);
}
}
typename Ptr::element_type & ValidIdx(SQInteger i) { ValidIdx_(i); return *mPtr; }
/* --------------------------------------------------------------------------------------------
* Make sure an index is within range and return the container. Container must exist.
*/
void ValidIdx_(SQInteger i) const
{
if (static_cast< size_t >(i) >= Valid().size())
{
STHROWF("Invalid vector container index({})", i);
}
}
const typename Ptr::element_type & ValidIdx(SQInteger i) const { ValidIdx_(i); return *mPtr; }
/* --------------------------------------------------------------------------------------------
* Make sure a container instance is referenced and is populated, then return it.
*/
void ValidPop_()
{
if (Valid().empty())
{
STHROWF("Vector container is empty");
}
}
typename Ptr::element_type & ValidPop() { ValidPop_(); return *mPtr; }
/* --------------------------------------------------------------------------------------------
* Make sure a container instance is referenced and is populated, then return it.
*/
void ValidPop_() const
{
if (Valid().empty())
{
STHROWF("Vector container is empty");
}
}
const typename Ptr::element_type & ValidPop() const { ValidPop_(); return *mPtr; }
/* --------------------------------------------------------------------------------------------
* Check if a container instance is referenced.
*/
SQMOD_NODISCARD bool IsNull() const { return !mPtr; }
/* --------------------------------------------------------------------------------------------
* Retrieve a value from the container.
*/
SQMOD_NODISCARD LightObj & Get_(SQInteger i)
{
// Is the element cached?
if (mVec[static_cast< size_t >(i)].first.IsNull())
{
mVec[static_cast< size_t >(i)] = Obj(&mPtr->at(static_cast< size_t >(i)));
}
// Return the object from the cache
return mVec[static_cast< size_t >(i)].first;
}
SQMOD_NODISCARD LightObj & Get(SQInteger i)
{
// Was the referenced vector modified?
if (mVec.size() < Valid().size())
{
// Synchronize the size
mVec.resize(mPtr->size());
// Synchronize the cache
CacheSync();
}
// Validate index
ValidIdx_(i);
// Perform the request
return Get_(i);
}
/* --------------------------------------------------------------------------------------------
* Modify a value from the container.
*/
void Set(SQInteger i, const W & v) { ValidIdx(i)[static_cast< size_t >(i)] = v.Valid(); }
/* --------------------------------------------------------------------------------------------
* Check if the container has no elements.
*/
SQMOD_NODISCARD bool Empty() const { return Valid().empty(); }
/* --------------------------------------------------------------------------------------------
* Retrieve the number of elements in the container.
*/
SQMOD_NODISCARD SQInteger Size() const { return static_cast< SQInteger >(Valid().size()); }
/* --------------------------------------------------------------------------------------------
* Retrieve the number of elements that the container has currently allocated space for.
*/
SQMOD_NODISCARD SQInteger Capacity() const { return static_cast< SQInteger >(Valid().capacity()); }
/* --------------------------------------------------------------------------------------------
* Synchronize cache container instances.
*/
void CacheSync()
{
// Invalidate cached instances, if any
for (size_t i = 0; i < mVec.size(); ++i)
{
// Is this element cached?
if (mVec[i].second != nullptr)
{
// Discard previous instance, if any
[[maybe_unused]] auto _ = mVec[i].second->mPtr.release();
// Sync to new instance
mVec[i].second->mPtr.reset(&mPtr->at(i));
}
}
}
/* --------------------------------------------------------------------------------------------
* Increase the capacity of the container to a value that's greater or equal to the one specified.
*/
DpVectorProxy & Reserve(SQInteger n)
{
Valid().reserve(ClampL< SQInteger, size_t >(n));
mVec.reserve(mPtr->size());
CacheSync();
return *this;
}
/* --------------------------------------------------------------------------------------------
* Request the removal of unused capacity.
*/
void Compact() { Valid().shrink_to_fit(); CacheSync(); mVec.shrink_to_fit(); }
/* --------------------------------------------------------------------------------------------
* Erase all elements from the cache container.
*/
void ClearCache()
{
// Invalidate cached instances, if any
for (auto & e : mVec)
{
// Is this element cached?
if (e.second != nullptr)
{
// Invalidate the instance
e.second->Cleanup();
// Forget about it
e.second = nullptr;
// Release script object
e.first.Release();
}
}
// Clear the cache vector
mVec.clear();
}
/* --------------------------------------------------------------------------------------------
* Erase all elements from the container.
*/
void Clear() { Validate(); ClearCache(); mPtr->clear(); }
/* --------------------------------------------------------------------------------------------
* Push a value at the back of the container.
*/
void Push(const W & v)
{
Valid().push_back(v.Valid());
mVec.emplace_back();
CacheSync();
}
/* --------------------------------------------------------------------------------------------
* Extends the Container by appending all the items in the given container.
*/
void Extend(DpVectorProxy & v)
{
Valid().insert(Valid().end(), v.Valid().begin(), v.Valid().end());
mVec.resize(mPtr->size());
CacheSync();
}
/* --------------------------------------------------------------------------------------------
* Pop the last element in the container.
*/
void Pop()
{
Validate();
// Is this element cached?
if (mVec.back().second != nullptr)
{
// Invalidate the instance
mVec.back().second->Cleanup();
mVec.back().first.Release();
}
// Safe to remove
mPtr->pop_back();
mVec.pop_back();
}
/* --------------------------------------------------------------------------------------------
* Erase the element at a certain position.
*/
void EraseAt(SQInteger i)
{
ValidIdx_(i);
// Is this element cached?
if (mVec[static_cast< size_t >(i)].second != nullptr)
{
// Invalidate the instance
mVec[static_cast< size_t >(i)].second->Cleanup();
mVec[static_cast< size_t >(i)].first.Release();
}
// Safe to remove
mPtr->erase(mPtr->begin() + static_cast< size_t >(i));
mVec.erase(mVec.begin() + static_cast< size_t >(i));
// Synchronize cache
CacheSync();
}
/* --------------------------------------------------------------------------------------------
* Iterate all values through a functor.
*/
void Each(Function & fn)
{
Validate();
// Iterate referenced vector elements
for (size_t i = 0; i < mVec.size(); ++i)
{
fn.Execute(Get(static_cast< SQInteger >(i)));
}
}
/* --------------------------------------------------------------------------------------------
* Iterate values in range through a functor.
*/
void EachRange(SQInteger p, SQInteger n, Function & fn)
{
ValidIdx_(p);
ValidIdx_(p + n);
// Iterate specified range
for (n += p; p < n; ++p)
{
fn.Execute(Get(static_cast< SQInteger >(p)));
}
}
/* --------------------------------------------------------------------------------------------
* Iterate all values through a functor until stopped (i.e false is returned).
*/
void While(Function & fn)
{
Validate();
// Iterate referenced vector elements
for (size_t i = 0; i < mVec.size(); ++i)
{
auto ret = fn.Eval(Get(static_cast< SQInteger >(i)));
// (null || true) == continue & false == break
if (!ret.IsNull() || !ret.template Cast< bool >())
{
break;
}
}
}
/* --------------------------------------------------------------------------------------------
* Iterate values in range through a functor until stopped (i.e false is returned).
*/
void WhileRange(SQInteger p, SQInteger n, Function & fn)
{
ValidIdx_(p);
ValidIdx_(p + n);
// Iterate specified range
for (n += p; p < n; ++p)
{
auto ret = fn.Eval(Get(static_cast< SQInteger >(p)));
// (null || true) == continue & false == break
if (!ret.IsNull() || !ret.template Cast< bool >())
{
break;
}
}
}
/* --------------------------------------------------------------------------------------------
* Retrieve a wrapped instance as a script object.
*/
SQMOD_NODISCARD static std::pair< LightObj, W * > Obj(T * ptr, bool owned = false)
{
// Create the wrapper instance for given pointer
auto wp = std::make_unique< W >(ptr, false);
// Create script object for wrapper instance
std::pair< LightObj, W * > p{LightObj{wp.get()}, wp.get()};
// Release ownership of the wrapper instance
[[maybe_unused]] auto _ = wp.release();
// Return the script object and wrapper instance
return p;
}
/* --------------------------------------------------------------------------------------------
* Retrieve a wrapped instance as a script object.
*/
SQMOD_NODISCARD static std::pair< LightObj, W * > Obj(const T * ptr, bool owned = false)
{
return Obj(const_cast< T * >(ptr), owned);
}
};
template < class T, class W, class U > inline void Register_Discord_VectorProxy(HSQUIRRELVM vm, Table & ns, const SQChar * name)
{
using Container = DpVectorProxy< T, W >;
// --------------------------------------------------------------------------------------------
ns.Bind(name,
Class< Container, NoConstructor< Container > >(vm, U::Str)
// Meta-methods
.SquirrelFunc(_SC("_typename"), &U::Fn)
// Properties
.Prop(_SC("Null"), &Container::IsNull)
.Prop(_SC("Empty"), &Container::Empty)
.Prop(_SC("Size"), &Container::Size)
.Prop(_SC("Capacity"), &Container::Capacity, &Container::Reserve)
// Member Methods
.Func(_SC("Get"), &Container::Get)
.Func(_SC("Set"), &Container::Set)
.Func(_SC("Reserve"), &Container::Reserve)
.Func(_SC("Compact"), &Container::Compact)
.Func(_SC("Clear"), &Container::Clear)
.Func(_SC("Push"), &Container::Push)
.Func(_SC("Append"), &Container::Push)
.Func(_SC("Extend"), &Container::Extend)
.Func(_SC("Pop"), &Container::Pop)
.Func(_SC("EraseAt"), &Container::EraseAt)
.Func(_SC("Each"), &Container::Each)
.Func(_SC("EachRange"), &Container::EachRange)
.Func(_SC("While"), &Container::While)
.Func(_SC("WhileRange"), &Container::WhileRange)
);
}
} // Namespace:: SqMod
module/Library/IO/Buffer.cpp
+28
View File
@@ -351,6 +351,33 @@ Vector4 SqBuffer::ReadVector4() const
return {value};
}
// ------------------------------------------------------------------------------------------------
extern SQInteger SqFromNativeJSON(HSQUIRRELVM vm, const char * data, size_t size);
// ------------------------------------------------------------------------------------------------
SQInteger SqBuffer::GetJSON(HSQUIRRELVM vm) const
{
// Remember the current stack size
const SQInteger top = sq_gettop(vm);
// Was the JSON string size specified?
if (top < 2)
{
return sq_throwerror(vm, _SC("Please specify the size of the JSON string to parse"));
}
// Do we even point to a valid buffer?
if (!m_Buffer)
{
return sq_throwerror(vm, _SC("Invalid memory buffer reference"));
}
// Validate the buffer itself
else if (!(*m_Buffer))
{
return sq_throwerror(vm, _SC("Invalid memory buffer"));
}
// Attempt to create the JSON object and push it on the stack
return SqFromNativeJSON(vm, &m_Buffer->Cursor< char >(), static_cast< size_t >(Var< SQInteger >{vm, 2}.value));
}
// ------------------------------------------------------------------------------------------------
SQInteger SqBuffer::GetCRC32(SQInteger n) const
{
@@ -500,6 +527,7 @@ void Register_Buffer(HSQUIRRELVM vm)
.Func(_SC("ADLER32"), &SqBuffer::GetADLER32)
.Func(_SC("Base32"), &SqBuffer::GetBase32)
.Func(_SC("Base64"), &SqBuffer::GetBase64)
.SquirrelMethod< SqBuffer, &SqBuffer::GetJSON >(_SC("GetJSON"))
);
}
module/Library/IO/Buffer.hpp
+6
View File
@@ -782,6 +782,12 @@ public:
*/
SQMOD_NODISCARD Vector4 ReadVector4() const;
/* --------------------------------------------------------------------------------------------
* Transform a portion of the data in the buffer to a JSON object.
* This has the benefit that a temporary string doesn't have to be created.
*/
SQMOD_NODISCARD SQInteger GetJSON(HSQUIRRELVM vm) const;
/* --------------------------------------------------------------------------------------------
* Compute the CRC-32 checksums on the data in the buffer.
*/
module/Library/JSON.cpp
+608 -5
View File
@@ -2,6 +2,7 @@
#include "Library/JSON.hpp"
// ------------------------------------------------------------------------------------------------
#include <sajson.h>
#include <sqratConst.h>
// ------------------------------------------------------------------------------------------------
@@ -11,13 +12,10 @@
namespace SqMod {
// ------------------------------------------------------------------------------------------------
static SQInteger SqToJSON(HSQUIRRELVM vm) noexcept
{
return sq_throwerror(vm, _SC("Not implemented yet!"));
}
SQMOD_DECL_TYPENAME(SqCtxJSON, _SC("SqCtxJSON"))
// ------------------------------------------------------------------------------------------------
static SQInteger SqFromJson_Push(HSQUIRRELVM vm, const sajson::value & node) noexcept
static SQInteger SqFromJson_Push(HSQUIRRELVM vm, const sajson::value & node) noexcept // NOLINT(misc-no-recursion)
{
// Operation result
SQInteger r = SQ_OK;
@@ -151,11 +149,616 @@ static SQInteger SqFromJSON(HSQUIRRELVM vm) noexcept
return SQ_SUCCEEDED(r) ? 1 : r;
}
// ------------------------------------------------------------------------------------------------
SQInteger SqFromNativeJSON(HSQUIRRELVM vm, const char * data, size_t size)
{
// Attempt to parse the specified JSON string
const sajson::document & document = sajson::parse(sajson::dynamic_allocation(), sajson::string(data, size));
// See if there was an error
if (!document.is_valid())
{
return sq_throwerror(vm, document.get_error_message_as_cstring());
}
// Process the nodes that were parsed from the string
SQInteger r = SqFromJson_Push(vm, document.get_root());
// We either have a value to return or we propagate some error
return SQ_SUCCEEDED(r) ? 1 : r;
}
// ------------------------------------------------------------------------------------------------
CtxJSON & CtxJSON::OpenArray()
{
// Add the array-begin character
mOutput.push_back('[');
// Go forward one level
Advance();
// Allow chaining
return *this;
}
// ------------------------------------------------------------------------------------------------
CtxJSON & CtxJSON::CloseArray()
{
// If the last character is a comma then replace it
if (mOutput.back() == ',')
{
mOutput.back() = ']';
}
// Append the array-end character
else
{
mOutput.push_back(']');
}
// Move the comma after the closing character
mOutput.push_back(',');
// Go back one level
Retreat();
// Allow chaining
return *this;
}
// ------------------------------------------------------------------------------------------------
CtxJSON & CtxJSON::ReopenArray()
{
// If the last character is a comma then remove it
if (mOutput.back() == ',')
{
mOutput.pop_back();
}
// If the last character is the array-end character then replace it with a comma
if (mOutput.back() == ']')
{
mOutput.back() = ',';
}
// Allow chaining
return *this;
}
// ------------------------------------------------------------------------------------------------
CtxJSON & CtxJSON::OpenObject()
{
// Add the object-begin character
mOutput.push_back('{');
// Go forward one level
Advance();
// Allow chaining
return *this;
}
// ------------------------------------------------------------------------------------------------
CtxJSON & CtxJSON::CloseObject()
{
// If the last character is a comma then replace it
if (mOutput.back() == ',')
{
mOutput.back() = '}';
}
// Append the object-end character
else
{
mOutput.push_back('}');
}
// Move the comma after the closing character
mOutput.push_back(',');
// Go back one level
Retreat();
// Allow chaining
return *this;
}
// ------------------------------------------------------------------------------------------------
CtxJSON & CtxJSON::ReopenObject()
{
// If the last character is a comma then remove it
if (mOutput.back() == ',')
{
mOutput.pop_back();
}
// If the last character is the object-end character then replace it with a comma
if (mOutput.back() == '}')
{
mOutput.back() = ',';
}
// Allow chaining
return *this;
}
// ------------------------------------------------------------------------------------------------
CtxJSON & CtxJSON::MakeKey()
{
// If the last character is a comma then replace it
if (mOutput.back() == ',')
{
mOutput.back() = ':';
}
// Append the array-end character
else
{
mOutput.push_back(':');
}
// Allow the hook to react
if (mKeyHook)
{
mKeyHook(*this);
}
// Allow chaining
return *this;
}
// ------------------------------------------------------------------------------------------------
bool CtxJSON::CheckWeakRefWrap(HSQUIRRELVM vm, SQInteger idx) noexcept
{
SQRESULT r = sq_getweakrefval(vm, idx);
// Whether the type doesn't have to be wrapped
bool w = true;
// Attempt to grab the value pointed by the weak reference
if (SQ_SUCCEEDED(r))
{
// Attempt to serialize the actual value
w = sq_gettype(vm, -1) != OT_TABLE && sq_gettype(vm, -1) != OT_ARRAY && sq_gettype(vm, -1) == OT_INSTANCE;
// Pop the referenced value
sq_poptop(vm);
}
// Wrap the value by default
return w;
}
// ------------------------------------------------------------------------------------------------
SQRESULT CtxJSON::SerializeParams(HSQUIRRELVM vm)
{
bool wrap_everything_in_array = false;
// Clear the output buffer if necessary
mOutput.clear();
mDepth = 0;
// Fetch the number of objects on the stack
const auto top = sq_gettop(vm);
// If there's more than one argument then they all get wrapped inside an array
// If there is one argument and is not an array, table or instance then do the same
if (top > 2 || (sq_gettype(vm, 2) != OT_TABLE &&
sq_gettype(vm, 2) != OT_ARRAY &&
sq_gettype(vm, 2) != OT_INSTANCE &&
CheckWeakRefWrap(vm, 2)))
{
wrap_everything_in_array = true;
// Open an array
OpenArray();
}
// Serialize every specified argument
for (SQInteger i = 2; i <= top; ++i)
{
if (SQRESULT r = SerializeAt(vm, i); SQ_FAILED(r))
{
return r; // Propagate the error
}
}
// Was everything wrapped inside an array?
if (wrap_everything_in_array)
{
CloseArray();
}
// Remove trailing separator, if any
if (mOutput.back() == ',')
{
mOutput.pop_back();
}
// Push the output string on the stack
sq_pushstring(vm, mOutput.c_str(), static_cast< SQInteger >(mOutput.size()));
// Specify that we have a value on the stack
return 1;
}
// ------------------------------------------------------------------------------------------------
SQRESULT CtxJSON::SerializeAt(HSQUIRRELVM vm, SQInteger idx) // NOLINT(misc-no-recursion)
{
// Identify object type
switch (sq_gettype(vm, idx))
{
case OT_NULL: {
PushNull();
} break;
case OT_INTEGER: {
SQInteger v;
// Attempt to retrieve the value from the stack
if (SQRESULT r = sq_getinteger(vm, idx, &v); SQ_FAILED(r))
{
return r; // Propagate the error
}
// Write the value in the output
PushInteger(v);
} break;
case OT_FLOAT: {
SQFloat v;
// Attempt to retrieve the value from the stack
if (SQRESULT r = sq_getfloat(vm, idx, &v); SQ_FAILED(r))
{
return r; // Propagate the error
}
// Write the value in the output
#ifdef SQUSEDOUBLE
PushDouble(v);
#else
PushFloat(v);
#endif
} break;
case OT_BOOL: {
SQBool v;
// Attempt to retrieve the value from the stack
if (SQRESULT r = sq_getbool(vm, idx, &v); SQ_FAILED(r))
{
return r; // Propagate the error
}
// Write the value in the output
PushBool(v != SQFalse);
} break;
case OT_STRING: {
const SQChar * v = nullptr;
SQInteger n = 0;
// Attempt to retrieve and convert the string
if (SQRESULT r = sq_getstringandsize(vm, idx, &v, &n); SQ_FAILED(r))
{
return r; // Propagate the error
}
// Write the value in the output
PushString(v, static_cast< size_t >(n));
} break;
case OT_TABLE: {
if (SQRESULT r = SerializeTable(vm, idx); SQ_FAILED(r))
{
return r; // Propagate the error
}
} break;
case OT_ARRAY: {
if (SQRESULT r = SerializeArray(vm, idx); SQ_FAILED(r))
{
return r; // Propagate the error
}
} break;
case OT_INSTANCE: {
if (SQRESULT r = SerializeInstance(vm, idx); SQ_FAILED(r))
{
return r; // Propagate the error
}
} break;
case OT_WEAKREF: {
if (SQRESULT r = SerializeWeakRef(vm, idx); SQ_FAILED(r))
{
return r; // Propagate the error
}
} break;
case OT_USERDATA:
case OT_CLOSURE:
case OT_NATIVECLOSURE:
case OT_GENERATOR:
case OT_USERPOINTER:
case OT_THREAD:
case OT_FUNCPROTO:
case OT_CLASS:
case OT_OUTER:
return sq_throwerrorf(vm, _SC("Type (%s) is not serializable"), SqTypeName(sq_gettype(vm, 2)));
}
// Serialization was successful
return SQ_OK;
}
// ------------------------------------------------------------------------------------------------
SQRESULT CtxJSON::SerializeArray(HSQUIRRELVM vm, SQInteger idx) // NOLINT(misc-no-recursion)
{
// Begin array scope
OpenArray();
// Push null to initiate iteration
sq_pushnull(vm);
// So we can use absolute stack indexes to avoid errors
const auto top = sq_gettop(vm);
// Start iterating the array at the specified position in the stack
for(SQRESULT r = SQ_OK; SQ_SUCCEEDED(sq_next(vm, idx));)
{
// Attempt serialization of the currently iterated value
r = SerializeAt(vm, top + 2);
// Check for failures
if (SQ_FAILED(r))
{
// Pop the null iterator, key and value from the stack
sq_pop(vm, 3);
// Propagate the error
return r;
}
// Pop the key and value from the stack (i.e. cleanup after `sq_next`)
sq_pop(vm, 2);
}
// Pop the null iterator
sq_poptop(vm);
// Close array scope
CloseArray();
// Serialization was successful
return SQ_OK;
}
// ------------------------------------------------------------------------------------------------
SQRESULT CtxJSON::SerializeTable(HSQUIRRELVM vm, SQInteger idx) // NOLINT(misc-no-recursion)
{
// Begin object scope
OpenObject();
// Push null to initiate iteration
sq_pushnull(vm);
// So we can use absolute stack indexes to avoid errors
const auto top = sq_gettop(vm);
// Start iterating the object at the specified position in the stack
for(SQRESULT r = SQ_OK; SQ_SUCCEEDED(sq_next(vm, idx));)
{
if (sq_gettype(vm, -2) == OT_STRING)
{
// Attempt serialization of the currently iterated element key
r = SerializeAt(vm, top + 1);
// Can we proceed with the value?
if (SQ_SUCCEEDED(r))
{
// Mark the value above as the key of this element and
// attempt serialization of the currently iterated element value
r = MakeKey().SerializeAt(vm, top + 2);
}
}
else
{
r = sq_throwerror(vm, _SC("Only string values are accepted as object keys"));
}
// Check for failures
if (SQ_FAILED(r))
{
// Pop the null iterator, key and value from the stack
sq_pop(vm, 3);
// Propagate the error
return r;
}
// Pop the key and value from the stack (i.e. cleanup after `sq_next`)
sq_pop(vm, 2);
}
// Pop the null iterator
sq_poptop(vm);
// Close object scope
CloseObject();
// Serialization was successful
return SQ_OK;
}
// ------------------------------------------------------------------------------------------------
SQRESULT CtxJSON::SerializeInstance(HSQUIRRELVM vm, SQInteger idx)
{
sq_pushstring(vm, mMetaMethod.c_str(), static_cast< SQInteger >(mMetaMethod.size()));
// Attempt to retrieve the meta-method from the instance
if(SQRESULT r = sq_get(vm, idx); SQ_FAILED(r))
{
return r; // Propagate the error
}
// Make sure this is actually a closure/function that we can invoke
else if (const auto t = sq_gettype(vm, -1); t != OT_CLOSURE && t != OT_NATIVECLOSURE)
{
// Remove whatever is on the stack
sq_poptop(vm);
// Abort the operation as we can't do anything about it
return sq_throwerrorf(vm, _SC("`_tojson` meta-method is not a closure for type (%s)"), SqTypeName(vm, idx).c_str());
}
// Push the instance itself the stack (the environment)
sq_push(vm, idx);
// Push this instance on the stack (the json context)
ClassType< CtxJSON >::PushInstance(vm, this);
// Invoke the function to perform the conversion in this context
SQRESULT r = sq_call(vm, 2, SQFalse, SQFalse);
// Remove the closure from the stack
sq_poptop(vm);
// Propagate the result, whatever that is
return r;
}
// ------------------------------------------------------------------------------------------------
SQRESULT CtxJSON::SerializeWeakRef(HSQUIRRELVM vm, SQInteger idx) // NOLINT(misc-no-recursion)
{
SQRESULT r = sq_getweakrefval(vm, idx);
// Attempt to grab the value pointed by the weak reference
if (SQ_SUCCEEDED(r))
{
// Attempt to serialize the actual value
r = SerializeAt(vm, sq_gettop(vm));
// Pop the referenced value
sq_poptop(vm);
}
// Propagate the error, if any
return r;
}
// ------------------------------------------------------------------------------------------------
SQRESULT CtxJSON::PushValues(HSQUIRRELVM vm)
{
// Fetch the number of objects on the stack
const auto top = sq_gettop(vm);
// Do we have a value?
if (top < 2)
{
return sq_throwerror(vm, _SC("Must specify at least one value to be pushed"));
}
// Serialize every specified argument
for (SQInteger i = 2; i <= top; ++i)
{
if (SQRESULT r = SerializeAt(vm, i); SQ_FAILED(r))
{
return r; // Propagate the error
}
}
// Allow chaining
sq_push(vm, 1);
// Specify that a value was returned
return 1;
}
// ------------------------------------------------------------------------------------------------
SQRESULT CtxJSON::PushElement(HSQUIRRELVM vm)
{
// Fetch the number of objects on the stack
const auto top = sq_gettop(vm);
// Do we have a value?
if (top < 3)
{
return sq_throwerrorf(vm, _SC("Not enough parameters. Received %lld but %lld needed"), top-1, 2);
}
else if (sq_gettype(vm, 2) != OT_STRING)
{
return sq_throwerrorf(vm, _SC("Element key must be a string"));
}
// Attempt serialization of the currently iterated element key
if (SQRESULT r = SerializeAt(vm, 2); SQ_SUCCEEDED(r))
{
// Mark the value above as the key of this element and
// attempt serialization of the currently iterated element value
r = MakeKey().SerializeAt(vm, 3);
// Check for failures
if (SQ_FAILED(r))
{
return r; // Propagate the error
}
}
// Allow chaining
sq_push(vm, 1);
// Specify that a value was returned
return 1;
}
// ------------------------------------------------------------------------------------------------
CtxJSON & CtxJSON::PushKey(StackStrF & key)
{
// Validate the string value
if (key.mLen >= 0 && SQ_SUCCEEDED(key.mRes))
{
PushString(key.mPtr, static_cast< size_t >(key.mLen));
MakeKey();
}
else
{
STHROWF("Invalid object key");
}
// Allow chaining
return *this;
}
// ------------------------------------------------------------------------------------------------
void CtxJSON::PushNull()
{
mOutput.append("null,");
}
// ------------------------------------------------------------------------------------------------
void CtxJSON::PushInteger(SQInteger value)
{
fmt::format_int f(value);
// Append the formatted integer to the buffer
mOutput.append(f.data(), f.size());
mOutput.push_back(',');
}
// ------------------------------------------------------------------------------------------------
void CtxJSON::PushFloat(float value)
{
fmt::format_to(std::back_inserter(mOutput), "{},", value);
}
// ------------------------------------------------------------------------------------------------
void CtxJSON::PushDouble(double value)
{
fmt::format_to(std::back_inserter(mOutput), "{},", value);
}
// ------------------------------------------------------------------------------------------------
void CtxJSON::PushBool(bool value)
{
if (value)
{
mOutput.append("true,", 5);
}
else
{
mOutput.append("false,", 6);
}
}
// ------------------------------------------------------------------------------------------------
void CtxJSON::PushString(const SQChar * str)
{
mOutput.push_back('"');
mOutput.append(str);
mOutput.push_back('"');
mOutput.push_back(',');
// Allow the hook to know
mString.assign(str);
}
// ------------------------------------------------------------------------------------------------
void CtxJSON::PushString(const SQChar * str, size_t length)
{
mOutput.push_back('"');
mOutput.append(str, length);
mOutput.push_back('"');
mOutput.push_back(',');
// Allow the hook to know
mString.assign(str, length);
}
// ------------------------------------------------------------------------------------------------
static SQInteger SqToJSON(HSQUIRRELVM vm) noexcept
{
// Make sure the instance is cleaned up even in the case of exceptions
DeleteGuard< CtxJSON > sq_dg(new CtxJSON());
// Remember the instance, so we don't have to cast the script object back
auto ctx = sq_dg.Get();
// Turn it into a script object because it may be passed as a parameter to `_tojson` meta-methods
LightObj obj(sq_dg, vm);
// Proceed with the serialization
return ctx->SerializeParams(vm);
}
// ------------------------------------------------------------------------------------------------
static SQInteger SqToCompactJSON(HSQUIRRELVM vm) noexcept
{
// Make sure the instance is cleaned up even in the case of exceptions
DeleteGuard< CtxJSON > sq_dg(new CtxJSON(false));
// Remember the instance, so we don't have to cast the script object back
auto ctx = sq_dg.Get();
// Turn it into a script object because it may be passed as a parameter to `_tojson` meta-methods
LightObj obj(sq_dg, vm);
// Proceed with the serialization
return ctx->SerializeParams(vm);
}
// ================================================================================================
void Register_JSON(HSQUIRRELVM vm)
{
RootTable(vm).SquirrelFunc(_SC("SqToJSON"), SqToJSON);
RootTable(vm).SquirrelFunc(_SC("SqToCompactJSON"), SqToCompactJSON);
RootTable(vm).SquirrelFunc(_SC("SqFromJSON"), SqFromJSON);
// --------------------------------------------------------------------------------------------
RootTable(vm).Bind(_SC("SqCtxJSON"),
Class< CtxJSON, NoCopy< CtxJSON > >(vm, SqCtxJSON::Str)
// Constructors
.Ctor()
.Ctor< bool >()
.Ctor< bool, StackStrF & >()
// Meta-methods
.SquirrelFunc(_SC("_typename"), &SqCtxJSON::Fn)
// Properties
.Prop(_SC("Output"), &CtxJSON::GetOutput)
.Prop(_SC("Depth"), &CtxJSON::GetDepth)
.Prop(_SC("OOA"), &CtxJSON::GetObjectOverArray, &CtxJSON::SetObjectOverArray)
.Prop(_SC("ObjectOverArray"), &CtxJSON::GetObjectOverArray, &CtxJSON::SetObjectOverArray)
// Member Methods
.SquirrelMethod< CtxJSON, &CtxJSON::SerializeParams >(_SC("Serialize"))
.SquirrelMethod< CtxJSON, &CtxJSON::PushValues >(_SC("PushValues"))
.SquirrelMethod< CtxJSON, &CtxJSON::PushElement >(_SC("PushElement"))
.Func(_SC("OpenArray"), &CtxJSON::OpenArray)
.Func(_SC("CloseArray"), &CtxJSON::CloseArray)
.Func(_SC("OpenObject"), &CtxJSON::OpenObject)
.Func(_SC("CloseObject"), &CtxJSON::CloseObject)
.Func(_SC("MakeKey"), &CtxJSON::MakeKey)
.FmtFunc(_SC("PushKey"), &CtxJSON::PushKey)
.Func(_SC("SetOOA"), &CtxJSON::SetObjectOverArray)
.Func(_SC("SetObjectOverArray"), &CtxJSON::SetObjectOverArray)
);
}
} // Namespace:: SqMod
module/Library/JSON.hpp
+271 -2
View File
@@ -5,12 +5,281 @@
#include "Library/IO/Buffer.hpp"
// ------------------------------------------------------------------------------------------------
#include <sajson.h>
#include <functional>
// ------------------------------------------------------------------------------------------------
#include <fmt/args.h>
#include <fmt/format.h>
#include <fmt/xchar.h>
// ------------------------------------------------------------------------------------------------
namespace SqMod {
// ------------------------------------------------------------------------------------------------
/* ------------------------------------------------------------------------------------------------
* JSON serializer. The generated JSON output is always minified for efficiency reasons.
*/
struct CtxJSON
{
/* --------------------------------------------------------------------------------------------
* Output string.
*/
String mOutput{};
/* --------------------------------------------------------------------------------------------
* Prefer a table with named members even when a simple array would do the job.
* Take a Vector3 for example. Compact array [x, y, z] or named object {x: #.#, y: #.#, z: #.#}
*/
bool mObjectOverArray{true};
/* --------------------------------------------------------------------------------------------
* How nested are we currently.
*/
uint32_t mDepth{0};
/* --------------------------------------------------------------------------------------------
* The meta-method name to use on objects.
*/
String mMetaMethod{"_tojson"};
/* --------------------------------------------------------------------------------------------
* Last pushed string value. Can be used to heck for key name in the hook.
*/
String mString{};
/* --------------------------------------------------------------------------------------------
* Internal utility used to monitor the existence of certain keys to allow overloading.
*/
std::function< void(CtxJSON&) > mKeyHook{};
/* --------------------------------------------------------------------------------------------
* Default constructor.
*/
CtxJSON() = default;
/* --------------------------------------------------------------------------------------------
* Explicit constructor.
*/
explicit CtxJSON(bool ooa)
: CtxJSON()
{
mObjectOverArray = ooa;
}
/* --------------------------------------------------------------------------------------------
* Explicit constructor.
*/
CtxJSON(bool ooa, StackStrF & mmname)
: CtxJSON()
{
mObjectOverArray = ooa;
// Allow custom metamethod names
mMetaMethod.assign(mmname.mPtr, static_cast< size_t >(mmname.mLen));
}
/* --------------------------------------------------------------------------------------------
* Internal constructor.
*/
explicit CtxJSON(std::function< void(CtxJSON&) > && kh)
: CtxJSON()
{
mKeyHook = std::move(kh);
}
/* --------------------------------------------------------------------------------------------
* Copy constructor.
*/
CtxJSON(const CtxJSON &) = default;
/* --------------------------------------------------------------------------------------------
* Move constructor.
*/
CtxJSON(CtxJSON &&) noexcept = default;
/* --------------------------------------------------------------------------------------------
* Destructor.
*/
~CtxJSON() = default;
/* --------------------------------------------------------------------------------------------
* Copy assignment operator.
*/
CtxJSON & operator = (const CtxJSON &) = default;
/* --------------------------------------------------------------------------------------------
* Move assignment operator.
*/
CtxJSON & operator = (CtxJSON &&) noexcept = default;
/* --------------------------------------------------------------------------------------------
* Retrieve the current depth.
*/
SQMOD_NODISCARD const String & GetOutput() const noexcept
{
return mOutput;
}
/* --------------------------------------------------------------------------------------------
* Retrieve the current depth.
*/
SQMOD_NODISCARD SQInteger GetDepth() const noexcept
{
return mDepth;
}
/* --------------------------------------------------------------------------------------------
* Retrieve whether objects are preferred over arrays.
*/
SQMOD_NODISCARD bool GetObjectOverArray() const noexcept
{
return mObjectOverArray;
}
/* --------------------------------------------------------------------------------------------
* Retrieve whether objects are preferred over arrays.
*/
CtxJSON & SetObjectOverArray(bool toggle) noexcept
{
mObjectOverArray = toggle;
// Allow chaining
return *this;
}
/* --------------------------------------------------------------------------------------------
* Increase indentation by one level.
*/
void Advance() noexcept
{
++mDepth;
}
/* --------------------------------------------------------------------------------------------
* Decrease indentation by one level.
*/
void Retreat() noexcept
{
assert(mDepth > 0);
if (mDepth) --mDepth;
}
/* --------------------------------------------------------------------------------------------
* Begin writing an array.
*/
CtxJSON & OpenArray();
/* --------------------------------------------------------------------------------------------
* Stop writing an array.
*/
CtxJSON & CloseArray();
/* --------------------------------------------------------------------------------------------
* Resume writing an array.
*/
CtxJSON & ReopenArray();
/* --------------------------------------------------------------------------------------------
* Begin writing an object.
*/
CtxJSON & OpenObject();
/* --------------------------------------------------------------------------------------------
* Stop writing an object.
*/
CtxJSON & CloseObject();
/* --------------------------------------------------------------------------------------------
* Resume writing an object.
*/
CtxJSON & ReopenObject();
/* --------------------------------------------------------------------------------------------
* Begin writing a key value.
*/
CtxJSON & MakeKey();
/* --------------------------------------------------------------------------------------------
* Check whether the specified weak-ref points to a type of value that must be wrapped.
*/
SQMOD_NODISCARD static bool CheckWeakRefWrap(HSQUIRRELVM vm, SQInteger idx) noexcept;
/* --------------------------------------------------------------------------------------------
* Serialize given arguments.
*/
SQRESULT SerializeParams(HSQUIRRELVM vm);
/* --------------------------------------------------------------------------------------------
* Serialize the value a specific position in the stack.
*/
SQRESULT SerializeAt(HSQUIRRELVM vm, SQInteger idx);
/* --------------------------------------------------------------------------------------------
* Serialize the array a specific position in the stack. Stack index must be absolute!
*/
SQRESULT SerializeArray(HSQUIRRELVM vm, SQInteger idx);
/* --------------------------------------------------------------------------------------------
* Serialize the table a specific position in the stack. Stack index must be absolute!
*/
SQRESULT SerializeTable(HSQUIRRELVM vm, SQInteger idx);
/* --------------------------------------------------------------------------------------------
* Serialize the instance a specific position in the stack. Stack index must be absolute!
*/
SQRESULT SerializeInstance(HSQUIRRELVM vm, SQInteger idx);
/* --------------------------------------------------------------------------------------------
* Serialize the weak-ref a specific position in the stack. Stack index must be absolute!
*/
SQRESULT SerializeWeakRef(HSQUIRRELVM vm, SQInteger idx);
/* --------------------------------------------------------------------------------------------
* Serialize a value to the current container. It assumes an array or object is currently open.
*/
SQRESULT PushValues(HSQUIRRELVM vm);
/* --------------------------------------------------------------------------------------------
* Serialize a key/value pair to the current object. It assumes an object is currently open.
*/
SQRESULT PushElement(HSQUIRRELVM vm);
/* --------------------------------------------------------------------------------------------
* Push a key in the output. It assumes an object was open and previous element closed properly.
*/
CtxJSON & PushKey(StackStrF & key);
/* --------------------------------------------------------------------------------------------
* Write a null value to the output.
*/
void PushNull();
/* --------------------------------------------------------------------------------------------
* Write an integer value to the output.
*/
void PushInteger(SQInteger value);
/* --------------------------------------------------------------------------------------------
* Write a single precision floating point value to the output.
*/
void PushFloat(float value);
/* --------------------------------------------------------------------------------------------
* Write a double precision floating point value to the output.
*/
void PushDouble(double value);
/* --------------------------------------------------------------------------------------------
* Write a boolean value to the output.
*/
void PushBool(bool value);
/* --------------------------------------------------------------------------------------------
* Write a string value to the output.
*/
void PushString(const SQChar * str);
/* --------------------------------------------------------------------------------------------
* Write a string value to the output.
*/
void PushString(const SQChar * str, size_t length);
};
} // Namespace:: SqMod
module/Library/RegEx.cpp
+126 -126
View File
@@ -13,9 +13,9 @@ SQMOD_DECL_TYPENAME(SqRxMatchesTypename, _SC("SqRxMatches"))
SQMOD_DECL_TYPENAME(SqRxInstanceTypename, _SC("SqRxInstance"))
// ------------------------------------------------------------------------------------------------
bool RxInstance::STUDY = true;
int RxInstance::OPTIONS = 0;
int RxInstance::STUDY_OPTIONS = 0;
// bool RxInstance::STUDY = true;
// int RxInstance::OPTIONS = 0;
// int RxInstance::STUDY_OPTIONS = 0;
// ================================================================================================
void Register_RegEx(HSQUIRRELVM vm)
@@ -61,131 +61,131 @@ void Register_RegEx(HSQUIRRELVM vm)
.Func(_SC("WhileRange"), &RxMatches::WhileRange)
.Func(_SC("SubStr"), &RxMatches::SubStr)
);
RootTable(vm).Bind(_SC("SqRx"),
Class< RxInstance, NoCopy< RxInstance > >(vm, SqRxInstanceTypename::Str)
// Constructors
.Ctor()
.Ctor< StackStrF & >()
.Ctor< int, StackStrF & >()
.Ctor< int, bool, StackStrF & >()
// Meta-methods
.SquirrelFunc(_SC("_typename"), &SqRxInstanceTypename::Fn)
//.Func(_SC("_tostring"), &CPlayer::ToString)
// Static Values
.SetStaticValue(_SC("STUDY"), RxInstance::STUDY)
.SetStaticValue(_SC("OPTIONS"), RxInstance::OPTIONS)
.SetStaticValue(_SC("STUDY_OPTIONS"), RxInstance::STUDY_OPTIONS)
// Properties
.Prop(_SC("Valid"), &RxInstance::IsValid)
.Prop(_SC("Studied"), &RxInstance::IsStudied)
// Member Methods
.FmtFunc(_SC("CompileF"), &RxInstance::Compile1)
.FmtFunc(_SC("CompileExF"), &RxInstance::Compile2)
.FmtFunc(_SC("TryCompileF"), &RxInstance::TryCompile1)
.FmtFunc(_SC("TryCompileExF"), &RxInstance::TryCompile2)
.FmtFunc(_SC("MatchFirst"), &RxInstance::MatchFirst)
.FmtFunc(_SC("MatchFirstEx"), &RxInstance::MatchFirst_)
.FmtFunc(_SC("MatchFirstFrom"), &RxInstance::MatchFirstFrom)
.FmtFunc(_SC("MatchFirstFromEx"), &RxInstance::MatchFirstFrom_)
.FmtFunc(_SC("Match"), &RxInstance::Match)
.FmtFunc(_SC("MatchEx"), &RxInstance::Match_)
.FmtFunc(_SC("MatchFrom"), &RxInstance::MatchFrom)
.FmtFunc(_SC("MatchFromEx"), &RxInstance::MatchFrom_)
.FmtFunc(_SC("Matches"), &RxInstance::Matches)
.FmtFunc(_SC("MatchesEx"), &RxInstance::Matches_)
.FmtFunc(_SC("MatchesEx2"), &RxInstance::MatchesEx)
// Member Overloads
.Overload(_SC("Compile"), &RxInstance::Compile1)
.Overload(_SC("Compile"), &RxInstance::Compile2)
.Overload(_SC("TryCompile"), &RxInstance::TryCompile1)
.Overload(_SC("TryCompile"), &RxInstance::TryCompile2)
.Overload(_SC("Study"), &RxInstance::Study0)
.Overload(_SC("Study"), &RxInstance::Study1)
);
// RootTable(vm).Bind(_SC("SqRx"),
// Class< RxInstance, NoCopy< RxInstance > >(vm, SqRxInstanceTypename::Str)
// // Constructors
// .Ctor()
// .Ctor< StackStrF & >()
// .Ctor< int, StackStrF & >()
// .Ctor< int, bool, StackStrF & >()
// // Meta-methods
// .SquirrelFunc(_SC("_typename"), &SqRxInstanceTypename::Fn)
// //.Func(_SC("_tostring"), &CPlayer::ToString)
// // Static Values
// .SetStaticValue(_SC("STUDY"), RxInstance::STUDY)
// .SetStaticValue(_SC("OPTIONS"), RxInstance::OPTIONS)
// .SetStaticValue(_SC("STUDY_OPTIONS"), RxInstance::STUDY_OPTIONS)
// // Properties
// .Prop(_SC("Valid"), &RxInstance::IsValid)
// .Prop(_SC("Studied"), &RxInstance::IsStudied)
// // Member Methods
// .FmtFunc(_SC("CompileF"), &RxInstance::Compile1)
// .FmtFunc(_SC("CompileExF"), &RxInstance::Compile2)
// .FmtFunc(_SC("TryCompileF"), &RxInstance::TryCompile1)
// .FmtFunc(_SC("TryCompileExF"), &RxInstance::TryCompile2)
// .FmtFunc(_SC("MatchFirst"), &RxInstance::MatchFirst)
// .FmtFunc(_SC("MatchFirstEx"), &RxInstance::MatchFirst_)
// .FmtFunc(_SC("MatchFirstFrom"), &RxInstance::MatchFirstFrom)
// .FmtFunc(_SC("MatchFirstFromEx"), &RxInstance::MatchFirstFrom_)
// .FmtFunc(_SC("Match"), &RxInstance::Match)
// .FmtFunc(_SC("MatchEx"), &RxInstance::Match_)
// .FmtFunc(_SC("MatchFrom"), &RxInstance::MatchFrom)
// .FmtFunc(_SC("MatchFromEx"), &RxInstance::MatchFrom_)
// .FmtFunc(_SC("Matches"), &RxInstance::Matches)
// .FmtFunc(_SC("MatchesEx"), &RxInstance::Matches_)
// .FmtFunc(_SC("MatchesEx2"), &RxInstance::MatchesEx)
// // Member Overloads
// .Overload(_SC("Compile"), &RxInstance::Compile1)
// .Overload(_SC("Compile"), &RxInstance::Compile2)
// .Overload(_SC("TryCompile"), &RxInstance::TryCompile1)
// .Overload(_SC("TryCompile"), &RxInstance::TryCompile2)
// .Overload(_SC("Study"), &RxInstance::Study0)
// .Overload(_SC("Study"), &RxInstance::Study1)
// );
// --------------------------------------------------------------------------------------------
ConstTable(vm).Enum(_SC("SqRxOption"), Enumeration(vm)
.Const(_SC("Caseless"), static_cast< SQInteger >(PCRE_CASELESS))
.Const(_SC("Multiline"), static_cast< SQInteger >(PCRE_MULTILINE))
.Const(_SC("Dotall"), static_cast< SQInteger >(PCRE_DOTALL))
.Const(_SC("Extended"), static_cast< SQInteger >(PCRE_EXTENDED))
.Const(_SC("Anchored"), static_cast< SQInteger >(PCRE_ANCHORED))
.Const(_SC("DollarEndOnly"), static_cast< SQInteger >(PCRE_DOLLAR_ENDONLY))
.Const(_SC("Extra"), static_cast< SQInteger >(PCRE_EXTRA))
.Const(_SC("NotBOL"), static_cast< SQInteger >(PCRE_NOTBOL))
.Const(_SC("NotEOL"), static_cast< SQInteger >(PCRE_NOTEOL))
.Const(_SC("UnGreedy"), static_cast< SQInteger >(PCRE_UNGREEDY))
.Const(_SC("NotEmpty"), static_cast< SQInteger >(PCRE_NOTEMPTY))
.Const(_SC("UTF8"), static_cast< SQInteger >(PCRE_UTF8))
.Const(_SC("UTF16"), static_cast< SQInteger >(PCRE_UTF16))
.Const(_SC("UTF32"), static_cast< SQInteger >(PCRE_UTF32))
.Const(_SC("NoAutoCapture"), static_cast< SQInteger >(PCRE_NO_AUTO_CAPTURE))
.Const(_SC("NoUTF8Check"), static_cast< SQInteger >(PCRE_NO_UTF8_CHECK))
.Const(_SC("NoUTF16Check"), static_cast< SQInteger >(PCRE_NO_UTF16_CHECK))
.Const(_SC("NoUTF32Check"), static_cast< SQInteger >(PCRE_NO_UTF32_CHECK))
.Const(_SC("AutoCallout"), static_cast< SQInteger >(PCRE_AUTO_CALLOUT))
.Const(_SC("PartialSoft"), static_cast< SQInteger >(PCRE_PARTIAL_SOFT))
.Const(_SC("Partial"), static_cast< SQInteger >(PCRE_PARTIAL))
.Const(_SC("NeverUTF"), static_cast< SQInteger >(PCRE_NEVER_UTF))
.Const(_SC("DfaShortest"), static_cast< SQInteger >(PCRE_DFA_SHORTEST))
.Const(_SC("NoAutoPossess"), static_cast< SQInteger >(PCRE_NO_AUTO_POSSESS))
.Const(_SC("DfaRestart"), static_cast< SQInteger >(PCRE_DFA_RESTART))
.Const(_SC("FirstLine"), static_cast< SQInteger >(PCRE_FIRSTLINE))
.Const(_SC("DupNames"), static_cast< SQInteger >(PCRE_DUPNAMES))
.Const(_SC("NewLineCR"), static_cast< SQInteger >(PCRE_NEWLINE_CR))
.Const(_SC("NewLineLF"), static_cast< SQInteger >(PCRE_NEWLINE_LF))
.Const(_SC("NewLineCRLF"), static_cast< SQInteger >(PCRE_NEWLINE_CRLF))
.Const(_SC("NewLineAny"), static_cast< SQInteger >(PCRE_NEWLINE_ANY))
.Const(_SC("NewLineAnyCRLF"), static_cast< SQInteger >(PCRE_NEWLINE_ANYCRLF))
.Const(_SC("BsrAnyCRLF"), static_cast< SQInteger >(PCRE_BSR_ANYCRLF))
.Const(_SC("BsrUnicode"), static_cast< SQInteger >(PCRE_BSR_UNICODE))
.Const(_SC("JavaScriptCompat"), static_cast< SQInteger >(PCRE_JAVASCRIPT_COMPAT))
.Const(_SC("NoStartOptimize"), static_cast< SQInteger >(PCRE_NO_START_OPTIMIZE))
.Const(_SC("NoStartOptimise"), static_cast< SQInteger >(PCRE_NO_START_OPTIMISE))
.Const(_SC("PartialHard"), static_cast< SQInteger >(PCRE_PARTIAL_HARD))
.Const(_SC("NotEmptyAtStart"), static_cast< SQInteger >(PCRE_NOTEMPTY_ATSTART))
.Const(_SC("UCP"), static_cast< SQInteger >(PCRE_UCP))
);
// ConstTable(vm).Enum(_SC("SqRxOption"), Enumeration(vm)
// .Const(_SC("Caseless"), static_cast< SQInteger >(PCRE_CASELESS))
// .Const(_SC("Multiline"), static_cast< SQInteger >(PCRE_MULTILINE))
// .Const(_SC("Dotall"), static_cast< SQInteger >(PCRE_DOTALL))
// .Const(_SC("Extended"), static_cast< SQInteger >(PCRE_EXTENDED))
// .Const(_SC("Anchored"), static_cast< SQInteger >(PCRE_ANCHORED))
// .Const(_SC("DollarEndOnly"), static_cast< SQInteger >(PCRE_DOLLAR_ENDONLY))
// .Const(_SC("Extra"), static_cast< SQInteger >(PCRE_EXTRA))
// .Const(_SC("NotBOL"), static_cast< SQInteger >(PCRE_NOTBOL))
// .Const(_SC("NotEOL"), static_cast< SQInteger >(PCRE_NOTEOL))
// .Const(_SC("UnGreedy"), static_cast< SQInteger >(PCRE_UNGREEDY))
// .Const(_SC("NotEmpty"), static_cast< SQInteger >(PCRE_NOTEMPTY))
// .Const(_SC("UTF8"), static_cast< SQInteger >(PCRE_UTF8))
// .Const(_SC("UTF16"), static_cast< SQInteger >(PCRE_UTF16))
// .Const(_SC("UTF32"), static_cast< SQInteger >(PCRE_UTF32))
// .Const(_SC("NoAutoCapture"), static_cast< SQInteger >(PCRE_NO_AUTO_CAPTURE))
// .Const(_SC("NoUTF8Check"), static_cast< SQInteger >(PCRE_NO_UTF8_CHECK))
// .Const(_SC("NoUTF16Check"), static_cast< SQInteger >(PCRE_NO_UTF16_CHECK))
// .Const(_SC("NoUTF32Check"), static_cast< SQInteger >(PCRE_NO_UTF32_CHECK))
// .Const(_SC("AutoCallout"), static_cast< SQInteger >(PCRE_AUTO_CALLOUT))
// .Const(_SC("PartialSoft"), static_cast< SQInteger >(PCRE_PARTIAL_SOFT))
// .Const(_SC("Partial"), static_cast< SQInteger >(PCRE_PARTIAL))
// .Const(_SC("NeverUTF"), static_cast< SQInteger >(PCRE_NEVER_UTF))
// .Const(_SC("DfaShortest"), static_cast< SQInteger >(PCRE_DFA_SHORTEST))
// .Const(_SC("NoAutoPossess"), static_cast< SQInteger >(PCRE_NO_AUTO_POSSESS))
// .Const(_SC("DfaRestart"), static_cast< SQInteger >(PCRE_DFA_RESTART))
// .Const(_SC("FirstLine"), static_cast< SQInteger >(PCRE_FIRSTLINE))
// .Const(_SC("DupNames"), static_cast< SQInteger >(PCRE_DUPNAMES))
// .Const(_SC("NewLineCR"), static_cast< SQInteger >(PCRE_NEWLINE_CR))
// .Const(_SC("NewLineLF"), static_cast< SQInteger >(PCRE_NEWLINE_LF))
// .Const(_SC("NewLineCRLF"), static_cast< SQInteger >(PCRE_NEWLINE_CRLF))
// .Const(_SC("NewLineAny"), static_cast< SQInteger >(PCRE_NEWLINE_ANY))
// .Const(_SC("NewLineAnyCRLF"), static_cast< SQInteger >(PCRE_NEWLINE_ANYCRLF))
// .Const(_SC("BsrAnyCRLF"), static_cast< SQInteger >(PCRE_BSR_ANYCRLF))
// .Const(_SC("BsrUnicode"), static_cast< SQInteger >(PCRE_BSR_UNICODE))
// .Const(_SC("JavaScriptCompat"), static_cast< SQInteger >(PCRE_JAVASCRIPT_COMPAT))
// .Const(_SC("NoStartOptimize"), static_cast< SQInteger >(PCRE_NO_START_OPTIMIZE))
// .Const(_SC("NoStartOptimise"), static_cast< SQInteger >(PCRE_NO_START_OPTIMISE))
// .Const(_SC("PartialHard"), static_cast< SQInteger >(PCRE_PARTIAL_HARD))
// .Const(_SC("NotEmptyAtStart"), static_cast< SQInteger >(PCRE_NOTEMPTY_ATSTART))
// .Const(_SC("UCP"), static_cast< SQInteger >(PCRE_UCP))
// );
// --------------------------------------------------------------------------------------------
ConstTable(vm).Enum(_SC("SqRxError"), Enumeration(vm)
.Const(_SC("NoMatch"), static_cast< SQInteger >(PCRE_ERROR_NOMATCH))
.Const(_SC("Null"), static_cast< SQInteger >(PCRE_ERROR_NULL))
.Const(_SC("BadOption"), static_cast< SQInteger >(PCRE_ERROR_BADOPTION))
.Const(_SC("BadMagic"), static_cast< SQInteger >(PCRE_ERROR_BADMAGIC))
.Const(_SC("UnknownOpCode"), static_cast< SQInteger >(PCRE_ERROR_UNKNOWN_OPCODE))
.Const(_SC("UnknownNode"), static_cast< SQInteger >(PCRE_ERROR_UNKNOWN_NODE))
.Const(_SC("NoMemory"), static_cast< SQInteger >(PCRE_ERROR_NOMEMORY))
.Const(_SC("NoSubstring"), static_cast< SQInteger >(PCRE_ERROR_NOSUBSTRING))
.Const(_SC("MatchLimit"), static_cast< SQInteger >(PCRE_ERROR_MATCHLIMIT))
.Const(_SC("Callout"), static_cast< SQInteger >(PCRE_ERROR_CALLOUT))
.Const(_SC("BadUTF8"), static_cast< SQInteger >(PCRE_ERROR_BADUTF8))
.Const(_SC("BadUTF16"), static_cast< SQInteger >(PCRE_ERROR_BADUTF16))
.Const(_SC("BadUTF32"), static_cast< SQInteger >(PCRE_ERROR_BADUTF32))
.Const(_SC("BadUTF8Offset"), static_cast< SQInteger >(PCRE_ERROR_BADUTF8_OFFSET))
.Const(_SC("BadUTF16Offset"), static_cast< SQInteger >(PCRE_ERROR_BADUTF16_OFFSET))
.Const(_SC("Partial"), static_cast< SQInteger >(PCRE_ERROR_PARTIAL))
.Const(_SC("BadPartial"), static_cast< SQInteger >(PCRE_ERROR_BADPARTIAL))
.Const(_SC("Internal"), static_cast< SQInteger >(PCRE_ERROR_INTERNAL))
.Const(_SC("BadCount"), static_cast< SQInteger >(PCRE_ERROR_BADCOUNT))
.Const(_SC("DfaUitem"), static_cast< SQInteger >(PCRE_ERROR_DFA_UITEM))
.Const(_SC("DfaUcond"), static_cast< SQInteger >(PCRE_ERROR_DFA_UCOND))
.Const(_SC("DfaUmLimit"), static_cast< SQInteger >(PCRE_ERROR_DFA_UMLIMIT))
.Const(_SC("DfaWsSize"), static_cast< SQInteger >(PCRE_ERROR_DFA_WSSIZE))
.Const(_SC("DfaRecurse"), static_cast< SQInteger >(PCRE_ERROR_DFA_RECURSE))
.Const(_SC("RecursionLimit"), static_cast< SQInteger >(PCRE_ERROR_RECURSIONLIMIT))
.Const(_SC("NullWsLimit"), static_cast< SQInteger >(PCRE_ERROR_NULLWSLIMIT))
.Const(_SC("BadNewLine"), static_cast< SQInteger >(PCRE_ERROR_BADNEWLINE))
.Const(_SC("BadOffset"), static_cast< SQInteger >(PCRE_ERROR_BADOFFSET))
.Const(_SC("ShortUTF8"), static_cast< SQInteger >(PCRE_ERROR_SHORTUTF8))
.Const(_SC("ShortUTF16"), static_cast< SQInteger >(PCRE_ERROR_SHORTUTF16))
.Const(_SC("RecurseLoop"), static_cast< SQInteger >(PCRE_ERROR_RECURSELOOP))
.Const(_SC("JitStackLimit"), static_cast< SQInteger >(PCRE_ERROR_JIT_STACKLIMIT))
.Const(_SC("BadMode"), static_cast< SQInteger >(PCRE_ERROR_BADMODE))
.Const(_SC("BadEndianness"), static_cast< SQInteger >(PCRE_ERROR_BADENDIANNESS))
.Const(_SC("DfaBadRestart"), static_cast< SQInteger >(PCRE_ERROR_DFA_BADRESTART))
.Const(_SC("JitBadOption"), static_cast< SQInteger >(PCRE_ERROR_JIT_BADOPTION))
.Const(_SC("BadLength"), static_cast< SQInteger >(PCRE_ERROR_BADLENGTH))
.Const(_SC("Unset"), static_cast< SQInteger >(PCRE_ERROR_UNSET))
);
// ConstTable(vm).Enum(_SC("SqRxError"), Enumeration(vm)
// .Const(_SC("NoMatch"), static_cast< SQInteger >(PCRE_ERROR_NOMATCH))
// .Const(_SC("Null"), static_cast< SQInteger >(PCRE_ERROR_NULL))
// .Const(_SC("BadOption"), static_cast< SQInteger >(PCRE_ERROR_BADOPTION))
// .Const(_SC("BadMagic"), static_cast< SQInteger >(PCRE_ERROR_BADMAGIC))
// .Const(_SC("UnknownOpCode"), static_cast< SQInteger >(PCRE_ERROR_UNKNOWN_OPCODE))
// .Const(_SC("UnknownNode"), static_cast< SQInteger >(PCRE_ERROR_UNKNOWN_NODE))
// .Const(_SC("NoMemory"), static_cast< SQInteger >(PCRE_ERROR_NOMEMORY))
// .Const(_SC("NoSubstring"), static_cast< SQInteger >(PCRE_ERROR_NOSUBSTRING))
// .Const(_SC("MatchLimit"), static_cast< SQInteger >(PCRE_ERROR_MATCHLIMIT))
// .Const(_SC("Callout"), static_cast< SQInteger >(PCRE_ERROR_CALLOUT))
// .Const(_SC("BadUTF8"), static_cast< SQInteger >(PCRE_ERROR_BADUTF8))
// .Const(_SC("BadUTF16"), static_cast< SQInteger >(PCRE_ERROR_BADUTF16))
// .Const(_SC("BadUTF32"), static_cast< SQInteger >(PCRE_ERROR_BADUTF32))
// .Const(_SC("BadUTF8Offset"), static_cast< SQInteger >(PCRE_ERROR_BADUTF8_OFFSET))
// .Const(_SC("BadUTF16Offset"), static_cast< SQInteger >(PCRE_ERROR_BADUTF16_OFFSET))
// .Const(_SC("Partial"), static_cast< SQInteger >(PCRE_ERROR_PARTIAL))
// .Const(_SC("BadPartial"), static_cast< SQInteger >(PCRE_ERROR_BADPARTIAL))
// .Const(_SC("Internal"), static_cast< SQInteger >(PCRE_ERROR_INTERNAL))
// .Const(_SC("BadCount"), static_cast< SQInteger >(PCRE_ERROR_BADCOUNT))
// .Const(_SC("DfaUitem"), static_cast< SQInteger >(PCRE_ERROR_DFA_UITEM))
// .Const(_SC("DfaUcond"), static_cast< SQInteger >(PCRE_ERROR_DFA_UCOND))
// .Const(_SC("DfaUmLimit"), static_cast< SQInteger >(PCRE_ERROR_DFA_UMLIMIT))
// .Const(_SC("DfaWsSize"), static_cast< SQInteger >(PCRE_ERROR_DFA_WSSIZE))
// .Const(_SC("DfaRecurse"), static_cast< SQInteger >(PCRE_ERROR_DFA_RECURSE))
// .Const(_SC("RecursionLimit"), static_cast< SQInteger >(PCRE_ERROR_RECURSIONLIMIT))
// .Const(_SC("NullWsLimit"), static_cast< SQInteger >(PCRE_ERROR_NULLWSLIMIT))
// .Const(_SC("BadNewLine"), static_cast< SQInteger >(PCRE_ERROR_BADNEWLINE))
// .Const(_SC("BadOffset"), static_cast< SQInteger >(PCRE_ERROR_BADOFFSET))
// .Const(_SC("ShortUTF8"), static_cast< SQInteger >(PCRE_ERROR_SHORTUTF8))
// .Const(_SC("ShortUTF16"), static_cast< SQInteger >(PCRE_ERROR_SHORTUTF16))
// .Const(_SC("RecurseLoop"), static_cast< SQInteger >(PCRE_ERROR_RECURSELOOP))
// .Const(_SC("JitStackLimit"), static_cast< SQInteger >(PCRE_ERROR_JIT_STACKLIMIT))
// .Const(_SC("BadMode"), static_cast< SQInteger >(PCRE_ERROR_BADMODE))
// .Const(_SC("BadEndianness"), static_cast< SQInteger >(PCRE_ERROR_BADENDIANNESS))
// .Const(_SC("DfaBadRestart"), static_cast< SQInteger >(PCRE_ERROR_DFA_BADRESTART))
// .Const(_SC("JitBadOption"), static_cast< SQInteger >(PCRE_ERROR_JIT_BADOPTION))
// .Const(_SC("BadLength"), static_cast< SQInteger >(PCRE_ERROR_BADLENGTH))
// .Const(_SC("Unset"), static_cast< SQInteger >(PCRE_ERROR_UNSET))
// );
}
} // Namespace:: SqMod
module/Library/RegEx.hpp
+461 -461
View File
@@ -7,8 +7,8 @@
#ifdef POCO_UNBUNDLED
#include <pcre.h>
#else
#include "pcre_config.h"
#include "pcre.h"
#include "pcre2_config.h"
#include "pcre2.h"
#endif
// ------------------------------------------------------------------------------------------------
@@ -31,6 +31,7 @@ struct RxMatch
*
*/
SQInteger mLength{0};
/* --------------------------------------------------------------------------------------------
* Default constructor.
*/
@@ -386,500 +387,499 @@ struct RxMatches
}
};
/* ------------------------------------------------------------------------------------------------
*
*/
struct RxInstance
{
/* --------------------------------------------------------------------------------------------
* Whether to analyze and optimize the pattern by default for evey new instance (true).
*/
static bool STUDY;
// /* ------------------------------------------------------------------------------------------------
// *
// */
// struct RxInstance
// {
// /* --------------------------------------------------------------------------------------------
// * Whether to analyze and optimize the pattern by default for evey new instance (true).
// */
// static bool STUDY;
/* --------------------------------------------------------------------------------------------
* Default options for every new instance (0).
*/
static int OPTIONS;
// /* --------------------------------------------------------------------------------------------
// * Default options for every new instance (0).
// */
// static int OPTIONS;
/* --------------------------------------------------------------------------------------------
* Default study options for every new instance (0).
*/
static int STUDY_OPTIONS;
// /* --------------------------------------------------------------------------------------------
// * Default study options for every new instance (0).
// */
// static int STUDY_OPTIONS;
/* --------------------------------------------------------------------------------------------
* Default offset vector size (must be multiple of 3).
*/
static constexpr int OVEC_SIZE = 63;
// /* --------------------------------------------------------------------------------------------
// * Default offset vector size (must be multiple of 3).
// */
// static constexpr int OVEC_SIZE = 63;
/* --------------------------------------------------------------------------------------------
* Internal vector type used for offsets buffer.
*/
using OVEC_t = std::vector< int >;
// /* --------------------------------------------------------------------------------------------
// * Internal vector type used for offsets buffer.
// */
// using OVEC_t = std::vector< int >;
/* --------------------------------------------------------------------------------------------
* Internal RegularExpression instance.
*/
pcre * mPCRE{nullptr};
// /* --------------------------------------------------------------------------------------------
// * Internal RegularExpression instance.
// */
// pcre * mPCRE{nullptr};
/* --------------------------------------------------------------------------------------------
* Internal RegularExpression instance.
*/
pcre_extra * mExtra{nullptr};
// /* --------------------------------------------------------------------------------------------
// * Internal RegularExpression instance.
// */
// pcre_extra * mExtra{nullptr};
/* --------------------------------------------------------------------------------------------
* Internal buffer used for offsets.
*/
OVEC_t mOVEC{};
// /* --------------------------------------------------------------------------------------------
// * Internal buffer used for offsets.
// */
// OVEC_t mOVEC{};
/* --------------------------------------------------------------------------------------------
* Default constructor.
*/
RxInstance() noexcept = default;
// /* --------------------------------------------------------------------------------------------
// * Default constructor.
// */
// RxInstance() noexcept = default;
/* --------------------------------------------------------------------------------------------
* Copy constructor (disabled).
*/
RxInstance(const RxInstance &) = delete;
// /* --------------------------------------------------------------------------------------------
// * Copy constructor (disabled).
// */
// RxInstance(const RxInstance &) = delete;
/* --------------------------------------------------------------------------------------------
* Move constructor.
*/
RxInstance(RxInstance && o) noexcept
: mPCRE(o.mPCRE), mExtra(o.mExtra), mOVEC(std::move(o.mOVEC)) // Replicate it
{
o.mPCRE = nullptr; // Take ownership
o.mExtra = nullptr; // Take ownership
}
// /* --------------------------------------------------------------------------------------------
// * Move constructor.
// */
// RxInstance(RxInstance && o) noexcept
// : mPCRE(o.mPCRE), mExtra(o.mExtra), mOVEC(std::move(o.mOVEC)) // Replicate it
// {
// o.mPCRE = nullptr; // Take ownership
// o.mExtra = nullptr; // Take ownership
// }
/* --------------------------------------------------------------------------------------------
* Basic constructor.
*/
explicit RxInstance(StackStrF & pattern)
: RxInstance(OPTIONS, STUDY, pattern)
{
}
// /* --------------------------------------------------------------------------------------------
// * Basic constructor.
// */
// explicit RxInstance(StackStrF & pattern)
// : RxInstance(OPTIONS, STUDY, pattern)
// {
// }
/* --------------------------------------------------------------------------------------------
* Basic constructor. With specific options.
*/
explicit RxInstance(int options, StackStrF & pattern)
: RxInstance(options, STUDY, pattern)
{
}
// /* --------------------------------------------------------------------------------------------
// * Basic constructor. With specific options.
// */
// explicit RxInstance(int options, StackStrF & pattern)
// : RxInstance(options, STUDY, pattern)
// {
// }
/* --------------------------------------------------------------------------------------------
* Basic constructor. With specific options.
*/
explicit RxInstance(int options, bool study, StackStrF & pattern)
: mPCRE(Compile_(pattern.mPtr, options)), mExtra(nullptr)
{
if (study)
{
Study0();
}
}
// /* --------------------------------------------------------------------------------------------
// * Basic constructor. With specific options.
// */
// explicit RxInstance(int options, bool study, StackStrF & pattern)
// : mPCRE(Compile_(pattern.mPtr, options)), mExtra(nullptr)
// {
// if (study)
// {
// Study0();
// }
// }
/* --------------------------------------------------------------------------------------------
* Internal constructor.
*/
RxInstance(const char * pattern, int options, bool study)
: mPCRE(Compile_(pattern, options)), mExtra(nullptr)
{
if (study)
{
Study0();
}
}
// /* --------------------------------------------------------------------------------------------
// * Internal constructor.
// */
// RxInstance(const char * pattern, int options, bool study)
// : mPCRE(Compile_(pattern, options)), mExtra(nullptr)
// {
// if (study)
// {
// Study0();
// }
// }
/* --------------------------------------------------------------------------------------------
* Destructor.
*/
~RxInstance()
{
Destroy();
}
// /* --------------------------------------------------------------------------------------------
// * Destructor.
// */
// ~RxInstance()
// {
// Destroy();
// }
/* --------------------------------------------------------------------------------------------
* Copy assignment operator (disabled).
*/
RxInstance & operator = (const RxInstance &) = delete;
// /* --------------------------------------------------------------------------------------------
// * Copy assignment operator (disabled).
// */
// RxInstance & operator = (const RxInstance &) = delete;
/* --------------------------------------------------------------------------------------------
* Move assignment operator.
*/
RxInstance & operator = (RxInstance && o) noexcept
{
// Prevent self assignment
if (this != &o)
{
// Release current instance, if any
Destroy();
// Replicate it
mPCRE = o.mPCRE;
mExtra = o.mExtra;
mOVEC = std::move(o.mOVEC);
// Take ownership
o.mPCRE = nullptr;
o.mExtra = nullptr;
}
return *this;
}
// /* --------------------------------------------------------------------------------------------
// * Move assignment operator.
// */
// RxInstance & operator = (RxInstance && o) noexcept
// {
// // Prevent self assignment
// if (this != &o)
// {
// // Release current instance, if any
// Destroy();
// // Replicate it
// mPCRE = o.mPCRE;
// mExtra = o.mExtra;
// mOVEC = std::move(o.mOVEC);
// // Take ownership
// o.mPCRE = nullptr;
// o.mExtra = nullptr;
// }
// return *this;
// }
/* --------------------------------------------------------------------------------------------
* Estimate the size necessary for the offsets vector buffer.
*/
void EstimateOVEC(bool force = false)
{
if (mOVEC.empty() || force)
{
int size = 0;
// Attempt to estimate the size of the offsets vector buffer
const int r = pcre_fullinfo(ValidPCRE(), mExtra, PCRE_INFO_CAPTURECOUNT, &size);
// Check for errors
if (r != 0)
{
STHROWF("Rx: Offsets vector buffer estimation failed ({})", r);
}
// Attempt to scale the vector (must be multiple of 3)
mOVEC.resize((size + 1) * 3);
}
}
// /* --------------------------------------------------------------------------------------------
// * Estimate the size necessary for the offsets vector buffer.
// */
// void EstimateOVEC(bool force = false)
// {
// if (mOVEC.empty() || force)
// {
// int size = 0;
// // Attempt to estimate the size of the offsets vector buffer
// const int r = pcre_fullinfo(ValidPCRE(), mExtra, PCRE_INFO_CAPTURECOUNT, &size);
// // Check for errors
// if (r != 0)
// {
// STHROWF("Rx: Offsets vector buffer estimation failed ({})", r);
// }
// // Attempt to scale the vector (must be multiple of 3)
// mOVEC.resize((size + 1) * 3);
// }
// }
/* --------------------------------------------------------------------------------------------
* Return a valid `pcre` instance pointer or throw an exception.
*/
SQMOD_NODISCARD pcre * ValidPCRE() const
{
// Do we manage a valid instance?
if (mPCRE == nullptr)
{
STHROWF("Uninitialized Regular Expression instance.");
}
// Return it
return mPCRE;
}
// /* --------------------------------------------------------------------------------------------
// * Return a valid `pcre` instance pointer or throw an exception.
// */
// SQMOD_NODISCARD pcre * ValidPCRE() const
// {
// // Do we manage a valid instance?
// if (mPCRE == nullptr)
// {
// STHROWF("Uninitialized Regular Expression instance.");
// }
// // Return it
// return mPCRE;
// }
/* --------------------------------------------------------------------------------------------
* Return a valid `pcre_extra` instance pointer or throw an exception.
*/
SQMOD_NODISCARD pcre_extra * ValidExtra() const
{
// Do we manage a valid instance?
if (mExtra == nullptr)
{
STHROWF("Regular Expression was not studied and optimized.");
}
// Return it
return mExtra;
}
// /* --------------------------------------------------------------------------------------------
// * Return a valid `pcre_extra` instance pointer or throw an exception.
// */
// SQMOD_NODISCARD pcre_extra * ValidExtra() const
// {
// // Do we manage a valid instance?
// if (mExtra == nullptr)
// {
// STHROWF("Regular Expression was not studied and optimized.");
// }
// // Return it
// return mExtra;
// }
/* --------------------------------------------------------------------------------------------
* Compile the specified pattern.
*/
SQMOD_NODISCARD static pcre * Compile_(const char * pattern, int options = OPTIONS)
{
const char * error_msg = nullptr;
int error_code, error_offset = 0;
// Attempt to compile the specified pattern
pcre * ptr = pcre_compile2(pattern, options, &error_code, &error_msg, &error_offset, nullptr);
// Did the compilation failed?
if (ptr == nullptr)
{
STHROWF("Rx: {s} (code {}) (at offset {})", error_msg, error_code, error_offset);
}
// Return the `pcre` instance
return ptr;
}
// /* --------------------------------------------------------------------------------------------
// * Compile the specified pattern.
// */
// SQMOD_NODISCARD static pcre * Compile_(const char * pattern, int options = OPTIONS)
// {
// const char * error_msg = nullptr;
// int error_code, error_offset = 0;
// // Attempt to compile the specified pattern
// pcre * ptr = pcre_compile2(pattern, options, &error_code, &error_msg, &error_offset, nullptr);
// // Did the compilation failed?
// if (ptr == nullptr)
// {
// STHROWF("Rx: {s} (code {}) (at offset {})", error_msg, error_code, error_offset);
// }
// // Return the `pcre` instance
// return ptr;
// }
/* --------------------------------------------------------------------------------------------
* Attempt to compile the specified pattern. Error information is returned instead of thrown.
*/
SQMOD_NODISCARD static std::pair< pcre *, Table > TryCompile_(const char * pattern, int options = OPTIONS)
{
const char * error_msg = nullptr;
int error_code, error_offset = 0;
// Attempt to compile the specified pattern
pcre * ptr = pcre_compile2(pattern, options, &error_code, &error_msg, &error_offset, nullptr);
// Did the compilation failed?
if (ptr == nullptr)
{
Table t;
t.SetValue("message", error_msg);
t.SetValue("code", error_code);
t.SetValue("offset", error_offset);
// Return the table with error information
return std::make_pair(ptr, std::move(t));
}
// Return the `pcre` instance with no error information
return std::make_pair(ptr, Table{});
}
// /* --------------------------------------------------------------------------------------------
// * Attempt to compile the specified pattern. Error information is returned instead of thrown.
// */
// SQMOD_NODISCARD static std::pair< pcre *, Table > TryCompile_(const char * pattern, int options = OPTIONS)
// {
// const char * error_msg = nullptr;
// int error_code, error_offset = 0;
// // Attempt to compile the specified pattern
// pcre * ptr = pcre_compile2(pattern, options, &error_code, &error_msg, &error_offset, nullptr);
// // Did the compilation failed?
// if (ptr == nullptr)
// {
// Table t;
// t.SetValue("message", error_msg);
// t.SetValue("code", error_code);
// t.SetValue("offset", error_offset);
// // Return the table with error information
// return std::make_pair(ptr, std::move(t));
// }
// // Return the `pcre` instance with no error information
// return std::make_pair(ptr, Table{});
// }
/* --------------------------------------------------------------------------------------------
* Compile the specified pattern.
*/
RxInstance & Compile1(StackStrF & pattern)
{
return Compile2(OPTIONS, pattern);
}
// /* --------------------------------------------------------------------------------------------
// * Compile the specified pattern.
// */
// RxInstance & Compile1(StackStrF & pattern)
// {
// return Compile2(OPTIONS, pattern);
// }
/* --------------------------------------------------------------------------------------------
* Compile the specified pattern. With specific options.
*/
RxInstance & Compile2(int options, StackStrF & pattern)
{
// Release current instance, if any
Destroy();
// Attempt to compile
mPCRE = Compile_(pattern.mPtr, options);
// Allocate offsets vector buffer
EstimateOVEC();
// Allow chaining
return *this;
}
// /* --------------------------------------------------------------------------------------------
// * Compile the specified pattern. With specific options.
// */
// RxInstance & Compile2(int options, StackStrF & pattern)
// {
// // Release current instance, if any
// Destroy();
// // Attempt to compile
// mPCRE = Compile_(pattern.mPtr, options);
// // Allocate offsets vector buffer
// EstimateOVEC();
// // Allow chaining
// return *this;
// }
/* --------------------------------------------------------------------------------------------
* Compile the specified pattern.
*/
Table TryCompile1(StackStrF & pattern)
{
return TryCompile2(OPTIONS, pattern);
}
// /* --------------------------------------------------------------------------------------------
// * Compile the specified pattern.
// */
// Table TryCompile1(StackStrF & pattern)
// {
// return TryCompile2(OPTIONS, pattern);
// }
/* --------------------------------------------------------------------------------------------
* Compile the specified pattern. With specific options.
*/
Table TryCompile2(int options, StackStrF & pattern)
{
// Release current instance, if any
Destroy();
// Attempt to compile
auto p = TryCompile_(pattern.mPtr, options);
// Were there any compilation errors?
if (p.first != nullptr)
{
mPCRE = p.first;
}
// Return compilation info
return p.second;
}
// /* --------------------------------------------------------------------------------------------
// * Compile the specified pattern. With specific options.
// */
// Table TryCompile2(int options, StackStrF & pattern)
// {
// // Release current instance, if any
// Destroy();
// // Attempt to compile
// auto p = TryCompile_(pattern.mPtr, options);
// // Were there any compilation errors?
// if (p.first != nullptr)
// {
// mPCRE = p.first;
// }
// // Return compilation info
// return p.second;
// }
/* --------------------------------------------------------------------------------------------
* Analyze the managed pattern and optimized it.
*/
RxInstance & Study0()
{
return Study1(STUDY_OPTIONS);
}
// /* --------------------------------------------------------------------------------------------
// * Analyze the managed pattern and optimized it.
// */
// RxInstance & Study0()
// {
// return Study1(STUDY_OPTIONS);
// }
/* --------------------------------------------------------------------------------------------
* Analyze the managed pattern and optimized it. With specific options.
*/
RxInstance & Study1(int options)
{
if (mExtra != nullptr)
{
STHROWF("Regular Expression was already analyzed and optimized");
}
const char * error = nullptr;
// Study and optimize the expression
mExtra = pcre_study(ValidPCRE(), options, &error);
// If there was an error studying the expression then throw it
if (mExtra == nullptr && error != nullptr)
{
STHROWF("Rx: {s}", error);
}
// Allow chaining
return *this;
}
// /* --------------------------------------------------------------------------------------------
// * Analyze the managed pattern and optimized it. With specific options.
// */
// RxInstance & Study1(int options)
// {
// if (mExtra != nullptr)
// {
// STHROWF("Regular Expression was already analyzed and optimized");
// }
// const char * error = nullptr;
// // Study and optimize the expression
// mExtra = pcre_study(ValidPCRE(), options, &error);
// // If there was an error studying the expression then throw it
// if (mExtra == nullptr && error != nullptr)
// {
// STHROWF("Rx: {s}", error);
// }
// // Allow chaining
// return *this;
// }
/* --------------------------------------------------------------------------------------------
* Release managed resources and revert to uninitialized instance.
*/
SQMOD_NODISCARD bool IsValid() const
{
return (mPCRE != nullptr);
}
// /* --------------------------------------------------------------------------------------------
// * Release managed resources and revert to uninitialized instance.
// */
// SQMOD_NODISCARD bool IsValid() const
// {
// return (mPCRE != nullptr);
// }
/* --------------------------------------------------------------------------------------------
* Release managed resources and revert to uninitialized instance.
*/
SQMOD_NODISCARD bool IsStudied() const
{
return (mExtra != nullptr);
}
// /* --------------------------------------------------------------------------------------------
// * Release managed resources and revert to uninitialized instance.
// */
// SQMOD_NODISCARD bool IsStudied() const
// {
// return (mExtra != nullptr);
// }
/* --------------------------------------------------------------------------------------------
* Release managed resources and revert to uninitialized instance.
*/
void Destroy()
{
// Do we manage any instance?
if (mPCRE != nullptr)
{
pcre_free(mPCRE);
mPCRE = nullptr;
}
// Is the expression optimized?
if (mExtra != nullptr)
{
pcre_free(mExtra);
mExtra = nullptr;
}
}
// /* --------------------------------------------------------------------------------------------
// * Release managed resources and revert to uninitialized instance.
// */
// void Destroy()
// {
// // Do we manage any instance?
// if (mPCRE != nullptr)
// {
// pcre_free(mPCRE);
// mPCRE = nullptr;
// }
// // Is the expression optimized?
// if (mExtra != nullptr)
// {
// pcre_free(mExtra);
// mExtra = nullptr;
// }
// }
/* --------------------------------------------------------------------------------------------
* Matches the given subject string against the pattern.
* Returns the position of the first captured sub-string in m.
* If no part of the subject matches the pattern, m.mOffset is -1 and m.mLength is 0.
* Returns the number of matches. Throws a exception in case of an error.
*/
SQMOD_NODISCARD int MatchFirstFrom(SQInteger o, RxMatch & m, StackStrF & s)
{
return MatchFirstFrom_(OPTIONS, o, m, s);
}
SQMOD_NODISCARD int MatchFirstFrom_(int f, SQInteger o, RxMatch & m, StackStrF & s)
{
if (o > s.mLen)
{
STHROWF("Rx: Offset is out of range");
}
EstimateOVEC();
// Attempt to execute the expression on the specified subject
const int rc = pcre_exec(ValidPCRE(), mExtra, s.mPtr, static_cast< int >(s.mLen), static_cast< int >(o), f & 0xFFFF, mOVEC.data(), static_cast< int >(mOVEC.size()));
// Was there a match?
if (rc == PCRE_ERROR_NOMATCH)
{
m.mOffset = -1;
m.mLength = 0;
// No match found
return 0;
}
// Bad options/flags?
else if (rc == PCRE_ERROR_BADOPTION)
{
STHROWF("Rx: Bad option");
}
// Overflow?
else if (rc == 0)
{
STHROWF("Rx: too many captured sub-strings");
}
// Some other error?
else if (rc < 0)
{
STHROWF("Rx: error {}", rc);
}
// Store match
m.mOffset = mOVEC[0];
m.mLength = mOVEC[1] - mOVEC[0];
// Yield result back to script
return rc;
}
// /* --------------------------------------------------------------------------------------------
// * Matches the given subject string against the pattern.
// * Returns the position of the first captured sub-string in m.
// * If no part of the subject matches the pattern, m.mOffset is -1 and m.mLength is 0.
// * Returns the number of matches. Throws a exception in case of an error.
// */
// SQMOD_NODISCARD int MatchFirstFrom(SQInteger o, RxMatch & m, StackStrF & s)
// {
// return MatchFirstFrom_(OPTIONS, o, m, s);
// }
// SQMOD_NODISCARD int MatchFirstFrom_(int f, SQInteger o, RxMatch & m, StackStrF & s)
// {
// if (o > s.mLen)
// {
// STHROWF("Rx: Offset is out of range");
// }
// EstimateOVEC();
// // Attempt to execute the expression on the specified subject
// const int rc = pcre_exec(ValidPCRE(), mExtra, s.mPtr, static_cast< int >(s.mLen), static_cast< int >(o), f & 0xFFFF, mOVEC.data(), static_cast< int >(mOVEC.size()));
// // Was there a match?
// if (rc == PCRE_ERROR_NOMATCH)
// {
// m.mOffset = -1;
// m.mLength = 0;
// // No match found
// return 0;
// }
// // Bad options/flags?
// else if (rc == PCRE_ERROR_BADOPTION)
// {
// STHROWF("Rx: Bad option");
// }
// // Overflow?
// else if (rc == 0)
// {
// STHROWF("Rx: too many captured sub-strings");
// }
// // Some other error?
// else if (rc < 0)
// {
// STHROWF("Rx: error {}", rc);
// }
// // Store match
// m.mOffset = mOVEC[0];
// m.mLength = mOVEC[1] - mOVEC[0];
// // Yield result back to script
// return rc;
// }
/* --------------------------------------------------------------------------------------------
* Matches the given subject string against the pattern.
* Returns the position of the first captured sub-string in m.
* If no part of the subject matches the pattern, m.mOffset is -1 and m.mLength is 0.
* Returns the number of matches. Throws a exception in case of an error.
*/
SQMOD_NODISCARD int MatchFirst(RxMatch & m, StackStrF & s)
{
return MatchFirstFrom_(OPTIONS, 0, m, s);
}
SQMOD_NODISCARD int MatchFirst_(int f, RxMatch & m, StackStrF & s)
{
return MatchFirstFrom_(f, 0, m, s);
}
// /* --------------------------------------------------------------------------------------------
// * Matches the given subject string against the pattern.
// * Returns the position of the first captured sub-string in m.
// * If no part of the subject matches the pattern, m.mOffset is -1 and m.mLength is 0.
// * Returns the number of matches. Throws a exception in case of an error.
// */
// SQMOD_NODISCARD int MatchFirst(RxMatch & m, StackStrF & s)
// {
// return MatchFirstFrom_(OPTIONS, 0, m, s);
// }
// SQMOD_NODISCARD int MatchFirst_(int f, RxMatch & m, StackStrF & s)
// {
// return MatchFirstFrom_(f, 0, m, s);
// }
/* --------------------------------------------------------------------------------------------
* Matches the given subject string against the pattern.
* The first entry in m contains the position of the captured sub-string.
* The following entries identify matching sub-patterns. See the PCRE documentation for a more detailed explanation.
* If no part of the subject matches the pattern, m is empty.
* Returns the number of matches. Throws an exception in case of an error.
*/
SQMOD_NODISCARD int MatchFrom(SQInteger o, RxMatches & m, StackStrF & s)
{
return MatchFrom_(OPTIONS, o, m, s);
}
SQMOD_NODISCARD int MatchFrom_(int f, SQInteger o, RxMatches & m, StackStrF & s)
{
if (o > s.mLen)
{
STHROWF("Rx: Offset is out of range");
}
EstimateOVEC();
// Clear previous matches, if any
m.mList.clear();
// Attempt to execute the expression on the specified subject
const int rc = pcre_exec(ValidPCRE(), mExtra, s.mPtr, static_cast< int >(s.mLen), static_cast< int >(o), f & 0xFFFF, mOVEC.data(), static_cast< int >(mOVEC.size()));
// Was there a match?
if (rc == PCRE_ERROR_NOMATCH)
{
return 0; // No match found
}
// Bad options/flags?
else if (rc == PCRE_ERROR_BADOPTION)
{
STHROWF("Rx: Bad option");
}
// Overflow?
else if (rc == 0)
{
STHROWF("Rx: too many captured sub-strings");
}
// Some other error?
else if (rc < 0)
{
STHROWF("Rx: error {}", rc);
}
// Reserve space in advance
m.mList.reserve(static_cast< size_t >(rc));
// Transfer matches to match-list
for (int i = 0; i < rc; ++i)
{
m.mList.emplace_back(mOVEC[i*2], mOVEC[i*2+1] - mOVEC[i*2]);
}
// Yield result back to script
return rc;
}
// /* --------------------------------------------------------------------------------------------
// * Matches the given subject string against the pattern.
// * The first entry in m contains the position of the captured sub-string.
// * The following entries identify matching sub-patterns. See the PCRE documentation for a more detailed explanation.
// * If no part of the subject matches the pattern, m is empty.
// * Returns the number of matches. Throws an exception in case of an error.
// */
// SQMOD_NODISCARD int MatchFrom(SQInteger o, RxMatches & m, StackStrF & s)
// {
// return MatchFrom_(OPTIONS, o, m, s);
// }
// SQMOD_NODISCARD int MatchFrom_(int f, SQInteger o, RxMatches & m, StackStrF & s)
// {
// if (o > s.mLen)
// {
// STHROWF("Rx: Offset is out of range");
// }
// EstimateOVEC();
// // Clear previous matches, if any
// m.mList.clear();
// // Attempt to execute the expression on the specified subject
// const int rc = pcre_exec(ValidPCRE(), mExtra, s.mPtr, static_cast< int >(s.mLen), static_cast< int >(o), f & 0xFFFF, mOVEC.data(), static_cast< int >(mOVEC.size()));
// // Was there a match?
// if (rc == PCRE_ERROR_NOMATCH)
// {
// return 0; // No match found
// }
// // Bad options/flags?
// else if (rc == PCRE_ERROR_BADOPTION)
// {
// STHROWF("Rx: Bad option");
// }
// // Overflow?
// else if (rc == 0)
// {
// STHROWF("Rx: too many captured sub-strings");
// }
// // Some other error?
// else if (rc < 0)
// {
// STHROWF("Rx: error {}", rc);
// }
// // Reserve space in advance
// m.mList.reserve(static_cast< size_t >(rc));
// // Transfer matches to match-list
// for (int i = 0; i < rc; ++i)
// {
// m.mList.emplace_back(mOVEC[i*2], mOVEC[i*2+1] - mOVEC[i*2]);
// }
// // Yield result back to script
// return rc;
// }
/* --------------------------------------------------------------------------------------------
* Matches the given subject string against the pattern.
* The first entry in m contains the position of the captured sub-string.
* The following entries identify matching sub-patterns. See the PCRE documentation for a more detailed explanation.
* If no part of the subject matches the pattern, m is empty.
* Returns the number of matches. Throws an exception in case of an error.
*/
SQMOD_NODISCARD int Match(RxMatches & m, StackStrF & s)
{
return MatchFrom_(OPTIONS, 0, m, s);
}
SQMOD_NODISCARD int Match_(int f, RxMatches & m, StackStrF & s)
{
return MatchFrom_(f, 0, m, s);
}
/* --------------------------------------------------------------------------------------------
* Returns true if and only if the subject matches the regular expression.
* Internally, this method sets the RE_ANCHORED and RE_NOTEMPTY options for matching,
* which means that the empty string will never match and the pattern is treated as if it starts with a ^.
*/
SQMOD_NODISCARD bool Matches(StackStrF & s)
{
return Matches_(PCRE_ANCHORED | PCRE_NOTEMPTY, s);
}
SQMOD_NODISCARD bool Matches_(SQInteger o, StackStrF & s)
{
return MatchesEx(PCRE_ANCHORED | PCRE_NOTEMPTY, 0, s);
}
SQMOD_NODISCARD bool MatchesEx(int f, SQInteger o, StackStrF & s)
{
RxMatch m;
const int rc = MatchFirstFrom_(f, o, m, s);
return (rc > 0) && (m.mOffset == o) && (m.mLength == (s.mLen - o));
}
};
// /* --------------------------------------------------------------------------------------------
// * Matches the given subject string against the pattern.
// * The first entry in m contains the position of the captured sub-string.
// * The following entries identify matching sub-patterns. See the PCRE documentation for a more detailed explanation.
// * If no part of the subject matches the pattern, m is empty.
// * Returns the number of matches. Throws an exception in case of an error.
// */
// SQMOD_NODISCARD int Match(RxMatches & m, StackStrF & s)
// {
// return MatchFrom_(OPTIONS, 0, m, s);
// }
// SQMOD_NODISCARD int Match_(int f, RxMatches & m, StackStrF & s)
// {
// return MatchFrom_(f, 0, m, s);
// }
// /* --------------------------------------------------------------------------------------------
// * Returns true if and only if the subject matches the regular expression.
// * Internally, this method sets the RE_ANCHORED and RE_NOTEMPTY options for matching,
// * which means that the empty string will never match and the pattern is treated as if it starts with a ^.
// */
// SQMOD_NODISCARD bool Matches(StackStrF & s)
// {
// return Matches_(PCRE_ANCHORED | PCRE_NOTEMPTY, s);
// }
// SQMOD_NODISCARD bool Matches_(SQInteger o, StackStrF & s)
// {
// return MatchesEx(PCRE_ANCHORED | PCRE_NOTEMPTY, 0, s);
// }
// SQMOD_NODISCARD bool MatchesEx(int f, SQInteger o, StackStrF & s)
// {
// RxMatch m;
// const int rc = MatchFirstFrom_(f, o, m, s);
// return (rc > 0) && (m.mOffset == o) && (m.mLength == (s.mLen - o));
// }
// };
} // Namespace:: SqMod
module/Library/SQLite.cpp
+53 -13
View File
@@ -918,15 +918,23 @@ int32_t SQLiteStmtHnd::ExErrNo() const
}
// ------------------------------------------------------------------------------------------------
void SQLiteConnection::TraceOutput(void * /*ptr*/, const char * sql)
int SQLiteConnection::InternalTrace(unsigned t, void * c, void * p, void * x)
{
LogInf("SQLite Trace: %s", sql);
}
if (t == SQLITE_TRACE_STMT)
{
auto xs = reinterpret_cast< const char * >(x);
if (xs[0] == '-' && xs[1] == '-') {
LogInf("SQLite Trace: %s", xs);
} else {
LogInf("SQLite Trace: %s", sqlite3_expanded_sql(reinterpret_cast< sqlite3_stmt * >(p)));
}
}
else
{
LogInf("SQLite profile (time: %llu): %s", time, *reinterpret_cast< sqlite3_uint64 * >(x));
}
// ------------------------------------------------------------------------------------------------
void SQLiteConnection::ProfileOutput(void * /*ptr*/, const char * sql, sqlite3_uint64 time)
{
LogInf("SQLite profile (time: %llu): %s", time, sql);
return 0;
}
// ------------------------------------------------------------------------------------------------
@@ -1133,7 +1141,7 @@ bool SQLiteConnection::TableExists(StackStrF & name) const
// ------------------------------------------------------------------------------------------------
void SQLiteConnection::SetTracing(bool SQ_UNUSED_ARG(toggle)) // NOLINT(readability-convert-member-functions-to-static)
{
#if defined(SQLITE_OMIT_TRACE) || defined(SQLITE_OMIT_DEPRECATED)
#if defined(SQLITE_OMIT_TRACE)
STHROWF("The module was compiled without this feature");
#else
// Check whether changes are necessary
@@ -1144,12 +1152,28 @@ void SQLiteConnection::SetTracing(bool SQ_UNUSED_ARG(toggle)) // NOLINT(readabil
// Do we have to disable it?
else if (m_Handle->mTrace)
{
sqlite3_trace(m_Handle->Access(), nullptr, nullptr);
// Is profiling active?
if (m_Handle->mProfile)
{
sqlite3_trace_v2(m_Handle->Access(), SQLITE_TRACE_PROFILE, &SQLiteConnection::InternalTrace, nullptr);
}
else
{
sqlite3_trace_v2(m_Handle->Access(), 0, nullptr, nullptr);
}
}
// Go ahead and enable tracing
else
{
sqlite3_trace(m_Handle->Access(), &SQLiteConnection::TraceOutput, nullptr);
// Is profiling active?
if (m_Handle->mProfile)
{
sqlite3_trace_v2(m_Handle->Access(), SQLITE_TRACE_STMT|SQLITE_TRACE_PROFILE, &SQLiteConnection::InternalTrace, nullptr);
}
else
{
sqlite3_trace_v2(m_Handle->Access(), SQLITE_TRACE_STMT, &SQLiteConnection::InternalTrace, nullptr);
}
}
#endif
}
@@ -1157,7 +1181,7 @@ void SQLiteConnection::SetTracing(bool SQ_UNUSED_ARG(toggle)) // NOLINT(readabil
// ------------------------------------------------------------------------------------------------
void SQLiteConnection::SetProfiling(bool SQ_UNUSED_ARG(toggle)) // NOLINT(readability-convert-member-functions-to-static)
{
#if defined(SQLITE_OMIT_TRACE) || defined(SQLITE_OMIT_DEPRECATED)
#if defined(SQLITE_OMIT_TRACE)
STHROWF("The module was compiled without this feature");
#else
// Check whether changes are necessary
@@ -1168,12 +1192,28 @@ void SQLiteConnection::SetProfiling(bool SQ_UNUSED_ARG(toggle)) // NOLINT(readab
// Do we have to disable it?
else if (m_Handle->mProfile)
{
sqlite3_profile(m_Handle->Access(), nullptr, nullptr);
// Is tracing active?
if (m_Handle->mTrace)
{
sqlite3_trace_v2(m_Handle->Access(), SQLITE_TRACE_STMT, &SQLiteConnection::InternalTrace, nullptr);
}
else
{
sqlite3_trace_v2(m_Handle->Access(), 0, nullptr, nullptr);
}
}
// Go ahead and enable profiling
else
{
sqlite3_profile(m_Handle->Access(), &SQLiteConnection::ProfileOutput, nullptr);
// Is tracing active?
if (m_Handle->mTrace)
{
sqlite3_trace_v2(m_Handle->Access(), SQLITE_TRACE_STMT|SQLITE_TRACE_PROFILE, &SQLiteConnection::InternalTrace, nullptr);
}
else
{
sqlite3_trace_v2(m_Handle->Access(), SQLITE_TRACE_PROFILE, &SQLiteConnection::InternalTrace, nullptr);
}
}
#endif
}
module/Library/SQLite.hpp
+2 -7
View File
@@ -436,14 +436,9 @@ private:
protected:
/* --------------------------------------------------------------------------------------------
* Callback function for ActivateTracing()
* Callback function for ActivateTracing() and ActivateProfiling()
*/
static void TraceOutput(void * ptr, const char * sql);
/* --------------------------------------------------------------------------------------------
* Callback function for ActivateProfiling()
*/
static void ProfileOutput(void * ptr, const char * sql, sqlite3_uint64 time);
static int InternalTrace(unsigned t, void * c, void * p, void * x);
/* --------------------------------------------------------------------------------------------
* Validate the managed connection handle and throw an error if invalid.
module/Library/Utils.cpp
+38
View File
@@ -8,6 +8,9 @@
// ------------------------------------------------------------------------------------------------
namespace SqMod {
// ------------------------------------------------------------------------------------------------
SQMOD_DECL_TYPENAME(SqIdPoolTypename, _SC("SqIdPool"))
/* ------------------------------------------------------------------------------------------------
* Probably not the best implementation but should cover all sorts of weird cases.
*/
@@ -83,16 +86,21 @@ static SQInteger SqExtractIPv4(HSQUIRRELVM vm)
}
// ------------------------------------------------------------------------------------------------
extern void Register_IdPool(HSQUIRRELVM vm, Table & ns);
extern void Register_Vector(HSQUIRRELVM vm, Table & ns);
extern void Register_Template(HSQUIRRELVM vm, Table & ns);
extern void Register_Native_String(HSQUIRRELVM vm, Table & ns);
extern void Register_ServerAnnouncer(HSQUIRRELVM vm, Table & ns);
// ================================================================================================
void Register_Utils(HSQUIRRELVM vm)
{
Table ns(vm);
Register_IdPool(vm, ns);
Register_Vector(vm, ns);
Register_Template(vm, ns);
Register_Native_String(vm, ns);
Register_ServerAnnouncer(vm, ns);
@@ -101,4 +109,34 @@ void Register_Utils(HSQUIRRELVM vm)
RootTable(vm).Bind(_SC("SqUtils"), ns);
}
// ------------------------------------------------------------------------------------------------
void Register_IdPool(HSQUIRRELVM vm, Table & ns)
{
ns.Bind(_SC("IdPool"),
Class< SqIdPool, NoCopy< SqIdPool > >(vm, SqIdPoolTypename::Str)
// Constructors
.Ctor()
.template Ctor< SqIdPool::Type >()
.template Ctor< SqIdPool::Type, SqIdPool::Type >()
// Meta-methods
.SquirrelFunc(_SC("_typename"), &SqIdPoolTypename::Fn)
// Member Variables
.ConstVar(_SC("Next"), &SqIdPool::mNext)
.ConstVar(_SC("Step"), &SqIdPool::mStep)
.ConstVar(_SC("Start"), &SqIdPool::mStart)
// Properties
.Prop(_SC("FreeCount"), &SqIdPool::FreeCount)
.Prop(_SC("UsedCount"), &SqIdPool::UsedCount)
// Member Methods
.Func(_SC("Reset"), &SqIdPool::Reset)
.Func(_SC("Acquire"), &SqIdPool::Acquire)
.Func(_SC("Release"), &SqIdPool::Release)
.Func(_SC("Using"), &SqIdPool::Using)
.Func(_SC("EachUsed"), &SqIdPool::EachUsed)
.Func(_SC("WhileUsed"), &SqIdPool::WhileUsed)
.Func(_SC("EachFree"), &SqIdPool::EachFree)
.Func(_SC("WhileFree"), &SqIdPool::WhileFree)
);
}
} // Namespace:: SqMod
module/Library/Utils.hpp
+183
View File
@@ -6,4 +6,187 @@
// ------------------------------------------------------------------------------------------------
namespace SqMod {
/* ------------------------------------------------------------------------------------------------
* Helper utility used to provide reusable unique IDs of signed integer type.
* It is not thread-safe since the script runs in single-threaded mode.
*/
struct SqIdPool
{
using Type = SQInteger; // Type that is used to represent an ID.
using Pool = std::vector< Type >; // Container for both used and unused IDs.
// --------------------------------------------------------------------------------------------
// Pool of available IDs.
Pool mPool{};
// Pool of currently used IDs.
Pool mUsed{};
// The ID that will be generated next time the pool is empty.
Type mNext{0};
// How much to increment with each ID.
Type mStep{1};
// Where to start generating IDs.
Type mStart{0};
/* --------------------------------------------------------------------------------------------
* Base constructors.
*/
SqIdPool() noexcept = default;
SqIdPool(Type start) noexcept
: SqIdPool(start, 1)
{
}
SqIdPool(Type start, Type step) noexcept
: mPool(), mUsed(), mNext(start), mStep(step), mStart(start)
{
}
/* --------------------------------------------------------------------------------------------
* Copy/Move constructors (disabled).
*/
SqIdPool(const SqIdPool &) noexcept = delete;
SqIdPool(SqIdPool &&) noexcept = delete;
/* --------------------------------------------------------------------------------------------
* Copy/Move assignment operators (disabled).
*/
SqIdPool & operator = (const SqIdPool &) noexcept = delete;
SqIdPool & operator = (SqIdPool &&) noexcept = delete;
/* --------------------------------------------------------------------------------------------
* Discard all current IDs (free and used) and reset the start to the specified start.
* This invalidates all IDs that are currently left in use.
*/
void Reset()
{
mNext = mStart;
mPool.clear();
mUsed.clear();
}
/* --------------------------------------------------------------------------------------------
* Acquire a unique ID from the pool.
*/
SQMOD_NODISCARD Type Acquire()
{
Type id = mNext;
// Do we have some reusable IDs?
if (mPool.empty())
{
mNext += mStep; // Create a new one and update the next one
}
else
{
id = mPool.back(); // Get one from the back of the pool
mPool.pop_back(); // Remove it from the free pool
}
// Store it in the list of active IDs
mUsed.push_back(id);
// Return this ID
return id;
}
/* --------------------------------------------------------------------------------------------
* Release a unique ID back to the pool.
*/
bool Release(Type id)
{
// Find the specified ID into
for (Pool::size_type i = 0; i < mUsed.size(); ++i)
{
// Is this the ID we're looking for?
if (mUsed[i] == id)
{
// Swap the element with the last one
std::swap(mUsed[i], mUsed.back());
// Remove the last element
mUsed.pop_back();
// Make this ID available, again
mPool.push_back(id);
// We actually found this ID
return true;
}
}
// This ID does not belong to this pool
return false;
}
/* --------------------------------------------------------------------------------------------
* Check if the pool has the specified ID currently in use.
*/
SQMOD_NODISCARD bool Using(Type id)
{
return std::find(mUsed.begin(), mUsed.end(), id) != mUsed.end();
}
/* --------------------------------------------------------------------------------------------
* Retrieve the number of IDs that are currently available in the free pool.
*/
SQMOD_NODISCARD SQInteger FreeCount() const
{
return mPool.size();
}
/* --------------------------------------------------------------------------------------------
* Retrieve the number of IDs that are currently in use.
*/
SQMOD_NODISCARD SQInteger UsedCount() const
{
return mUsed.size();
}
/* --------------------------------------------------------------------------------------------
* Iterate all used IDs through a functor.
*/
void EachUsed(Function & fn) const
{
for (const auto & id : mUsed)
{
fn.Execute(id);
}
}
/* --------------------------------------------------------------------------------------------
* Iterate all used IDs through a functor until stopped (i.e false is returned).
*/
void WhileUsed(Function & fn) const
{
for (const auto & id : mUsed)
{
auto ret = fn.Eval(id);
// (null || true) == continue & false == break
if (!ret.IsNull() || !ret.template Cast< bool >())
{
break;
}
}
}
/* --------------------------------------------------------------------------------------------
* Iterate all free IDs through a functor.
*/
void EachFree(Function & fn) const
{
for (const auto & id : mPool)
{
fn.Execute(id);
}
}
/* --------------------------------------------------------------------------------------------
* Iterate all free IDs through a functor until stopped (i.e false is returned).
*/
void WhileFree(Function & fn) const
{
for (const auto & id : mPool)
{
auto ret = fn.Eval(id);
// (null || true) == continue & false == break
if (!ret.IsNull() || !ret.template Cast< bool >())
{
break;
}
}
}
};
} // Namespace:: SqMod
module/Library/Utils/JSON.cpp → module/Library/Utils/Template.cpp
+2 -2
View File
@@ -1,11 +1,11 @@
// ------------------------------------------------------------------------------------------------
#include "Library/Utils/JSON.hpp"
#include "Library/Utils/Template.hpp"
// ------------------------------------------------------------------------------------------------
namespace SqMod {
// ================================================================================================
void Register_JSON(HSQUIRRELVM vm, Table & ns)
void Register_Template(HSQUIRRELVM vm, Table & ns)
{
}
module/Library/Utils/Template.hpp
+50
View File
@@ -0,0 +1,50 @@
#pragma once
// ------------------------------------------------------------------------------------------------
#include "Core/Utility.hpp"
// ------------------------------------------------------------------------------------------------
#include <inja/inja.hpp>
// ------------------------------------------------------------------------------------------------
namespace SqMod {
/* ------------------------------------------------------------------------------------------------
*
*/
struct SqTemplateData
{
/* --------------------------------------------------------------------------------------------
* JSON data.
*/
nlohmann::json mData{};
};
/* ------------------------------------------------------------------------------------------------
*
*/
struct SqTemplateEnvironment
{
/* --------------------------------------------------------------------------------------------
* Environment instance.
*/
inja::Environment mEnv{};
};
/* ------------------------------------------------------------------------------------------------
* Template engine loosely inspired by jinja for python.
*/
struct SqTemplateInstance
{
/* --------------------------------------------------------------------------------------------
* Template instance.
*/
inja::Template mTpl{};
};
} // Namespace:: SqMod
module/Main.cpp
+10 -3
View File
@@ -17,13 +17,16 @@ namespace SqMod {
static bool g_Reload = false;
// ------------------------------------------------------------------------------------------------
//extern void InitExports();
extern void InitExports();
extern void InitializeNet();
extern void InitializePocoDataConnectors();
extern void ProcessRoutines();
extern void ProcessTasks();
extern void ProcessThreads();
extern void ProcessNet();
#ifdef SQMOD_DISCORD
extern void ProcessDiscord();
#endif
/* ------------------------------------------------------------------------------------------------
* Will the scripts be reloaded at the end of the current event?
@@ -97,7 +100,7 @@ static uint8_t OnServerInitialise()
{
SQMOD_SV_EV_TRACEBACK("[TRACE<] OnServerInitialise")
// Signal outside plug-ins to do fetch our proxies
//_Func->SendPluginCommand(0xDABBAD00, "%d", 1);
_Func->SendPluginCommand(SQMOD_INITIALIZE_CMD, "%d", 1);
// Attempt to load the module core
if (Core::Get().Execute())
{
@@ -172,6 +175,10 @@ static void OnServerFrame(float elapsed_time)
ProcessThreads();
// Process network
ProcessNet();
// Process Discord
#ifdef SQMOD_DISCORD
ProcessDiscord();
#endif
// Process log messages from other threads
Logger::Get().ProcessQueue();
// See if a reload was requested
@@ -1083,7 +1090,7 @@ SQMOD_API_EXPORT unsigned int VcmpPluginInit(PluginFuncs * funcs, PluginCallback
_Clbk->OnEntityStreamingChange = OnEntityStreamingChange;
#endif
// Attempt to initialize the plug-in exports
//InitExports();
InitExports();
// Dummy spacing
puts("");
// Initialization was successful
module/Misc/Official.cpp
+84 -64
View File
@@ -55,40 +55,60 @@ SQMOD_DECL_TYPENAME(CVehicleTn, _SC("CVehicle"))
/* ------------------------------------------------------------------------------------------------
* Used to fetch the legacy entity instance even if a native one was specified.
*/
template < class T, class U > inline T & GetLgEnt(LightObj & o)
template < class LEGACY, class NATIVE > inline LEGACY & GetLgEnt(LightObj & o)
{
auto type = static_cast< AbstractStaticClassData * >(o.GetTypeTag());
const auto type = static_cast< AbstractStaticClassData * >(o.GetTypeTag());
// Legacy entity type?
if (type == StaticClassTypeTag< T >::Get())
if (type == StaticClassTypeTag< LEGACY >::Get())
{
return *o.CastI< T >();
return *o.CastI< LEGACY >();
}
// Native entity type?
if (type == StaticClassTypeTag< U >::Get())
if (type == StaticClassTypeTag< NATIVE >::Get())
{
return *EntityInstSelect< U >(o.CastI< U >()->GetID()).mLgInst;
return *EntityInstSelect< NATIVE >::Get(o.CastI< NATIVE >()->GetID()).mLgInst;
}
STHROWF("Invalid entity type");
STHROWF("Invalid entity type: {}", SqTypeName(SqVM(), o));
SQ_UNREACHABLE
}
/* ------------------------------------------------------------------------------------------------
* Used to fetch the native entity instance even if a legacy one was specified.
*/
template < class LEGACY, class NATIVE > inline NATIVE & GetNativeEnt(LightObj & o)
{
const auto type = static_cast< AbstractStaticClassData * >(o.GetTypeTag());
// Legacy entity type?
if (type == StaticClassTypeTag< LEGACY >::Get())
{
return o.CastI< LEGACY >()->Get();
}
// Native entity type?
if (type == StaticClassTypeTag< NATIVE >::Get())
{
return *EntityInstSelect< NATIVE >::Get(o.CastI< NATIVE >()->GetID()).mInst;
}
STHROWF("Invalid entity type: {}", SqTypeName(SqVM(), o));
SQ_UNREACHABLE
}
/* ------------------------------------------------------------------------------------------------
* Used to fetch the legacy entity identifier even if a native one was specified.
*/
template < class T, class U > SQMOD_NODISCARD inline int32_t GetLgEntID(LightObj & o)
template < class LEGACY, class NATIVE > SQMOD_NODISCARD inline int32_t GetLgEntID(LightObj & o)
{
auto type = static_cast< AbstractStaticClassData * >(o.GetTypeTag());
const auto type = static_cast< AbstractStaticClassData * >(o.GetTypeTag());
// Legacy entity type?
if (type == StaticClassTypeTag< T >::Get())
if (type == StaticClassTypeTag< LEGACY >::Get())
{
return o.CastI< T >()->mID;
return o.CastI< LEGACY >()->mID;
}
// Native entity type?
if (type == StaticClassTypeTag< U >::Get())
if (type == StaticClassTypeTag< NATIVE >::Get())
{
return o.CastI< U >()->GetID();
return o.CastI< NATIVE >()->GetID();
}
STHROWF("Invalid entity type");
STHROWF("Invalid entity type: {}", SqTypeName(SqVM(), o));
SQ_UNREACHABLE
}
@@ -478,14 +498,14 @@ struct LgCheckpoint
SQMOD_NODISCARD int GetWorld() const { return Get().GetWorld(); }
SQMOD_NODISCARD LgARGB GetColor() const { const Color4 c = Get().GetColor(); return LgARGB{c.a, c.r, c.g, c.b}; }
SQMOD_NODISCARD LgEntityVector GetPos() const
{ return LgEntityVector(mID, LgEntityType::Checkpoint, 0, Get().GetPosition()); }
{ return {mID, LgEntityType::Checkpoint, 0, Get().GetPosition()}; }
SQMOD_NODISCARD float GetRadius() const { return Get().GetRadius(); }
SQMOD_NODISCARD int GetID() const { return mID; }
SQMOD_NODISCARD LgPlayer * GetOwner() const
{ const int id = Get().GetOwnerID(); return VALID_ENTITYEX(id, SQMOD_PLAYER_POOL) ? Core::Get().GetPlayer(id).mLgInst : nullptr; }
// --------------------------------------------------------------------------------------------
void Delete() const { _Func->DeleteCheckPoint(GetIdentifier()); }
SQMOD_NODISCARD bool StreamedToPlayer(LgPlayer & player) const;
SQMOD_NODISCARD bool StreamedToPlayer(LightObj & player) const;
};
/* ------------------------------------------------------------------------------------------------
@@ -546,11 +566,11 @@ struct LgObject
SQMOD_NODISCARD int GetAlpha() const { return Get().GetAlpha(); }
SQMOD_NODISCARD int GetWorld() const { return Get().GetWorld(); }
SQMOD_NODISCARD LgEntityVector GetPos() const
{ return LgEntityVector(mID, LgEntityType::Object, LgObjectVectorFlag::Pos, Get().GetPosition()); }
{ return {mID, LgEntityType::Object, LgObjectVectorFlag::Pos, Get().GetPosition()}; }
SQMOD_NODISCARD LgEntityQuaternion GetRotation() const
{ return LgEntityQuaternion(mID, LgEntityType::Object, 0, Get().GetRotation()); }
{ return {mID, LgEntityType::Object, 0, Get().GetRotation()}; }
SQMOD_NODISCARD LgEntityVector GetRotationEuler() const
{ return LgEntityVector(mID, LgEntityType::Object, LgObjectVectorFlag::Rotation, Get().GetRotationEuler()); }
{ return {mID, LgEntityType::Object, LgObjectVectorFlag::Rotation, Get().GetRotationEuler()}; }
SQMOD_NODISCARD int GetID() const { return mID; }
SQMOD_NODISCARD bool GetReportingShots() const { return Get().GetShotReport(); }
SQMOD_NODISCARD bool GetReportingBumps() const { return Get().GetTouchedReport(); }
@@ -563,7 +583,7 @@ struct LgObject
void RotateToEuler(const Vector3 & rotation, int time) const { Get().RotateToEuler(rotation, static_cast< uint32_t >(time)); }
void RotateByEuler(const Vector3 & rotOffset, int time) const { Get().RotateByEuler(rotOffset, static_cast< uint32_t >(time)); }
void SetAlpha(int alpha, int fadeTime) const { Get().SetAlphaEx(alpha, static_cast< uint32_t >(fadeTime)); }
SQMOD_NODISCARD bool StreamedToPlayer(LgPlayer & player) const;
SQMOD_NODISCARD bool StreamedToPlayer(LightObj & player) const;
};
/* ------------------------------------------------------------------------------------------------
@@ -627,7 +647,7 @@ struct LgPickup
SQMOD_NODISCARD bool GetAuto() const { return Get().GetAutomatic(); }
SQMOD_NODISCARD int GetAutoTimer() const { return Get().GetAutoTimer(); }
SQMOD_NODISCARD LgEntityVector GetPos() const
{ return LgEntityVector(mID, LgEntityType::Pickup, 0, Get().GetPosition()); }
{ return {mID, LgEntityType::Pickup, 0, Get().GetPosition()}; }
SQMOD_NODISCARD int GetModel() const { return Get().GetModel(); }
SQMOD_NODISCARD int GetQuantity() const { return Get().GetQuantity(); }
SQMOD_NODISCARD int GetID() const { return mID; }
@@ -635,7 +655,7 @@ struct LgPickup
// --------------------------------------------------------------------------------------------
void Delete() const { _Func->DeletePickup(GetIdentifier()); }
void Respawn() const { Get().Refresh(); }
SQMOD_NODISCARD bool StreamedToPlayer(LgPlayer & player) const;
SQMOD_NODISCARD bool StreamedToPlayer(LightObj & player) const;
};
/* ------------------------------------------------------------------------------------------------
@@ -703,7 +723,7 @@ struct LgPlayer
void SetScore(int score) const { Get().SetScore(score); }
void SetImmunity(uint32_t immunity) const { Get().SetImmunity(immunity); }
void SetHeading(float heading) const { Get().SetHeading(heading); }
void SetVehicle(LgVehicle & vehicle) const;
void SetVehicle(LightObj & vehicle) const;
void SetFrozen(bool toggle) const { _Func->SetPlayerOption(GetIdentifier(), vcmpPlayerOptionControllable, static_cast< uint8_t >(!toggle)); }
void SetDriveByEnabled(bool toggle) const { _Func->SetPlayerOption(GetIdentifier(), vcmpPlayerOptionDriveBy, static_cast< uint8_t >(toggle)); }
void SetWhiteScanLines(bool toggle) const { _Func->SetPlayerOption(GetIdentifier(), vcmpPlayerOptionWhiteScanlines, static_cast< uint8_t >(toggle)); }
@@ -720,7 +740,7 @@ struct LgPlayer
void SetWantedLevel(int level) const { Get().SetWantedLevel(level); }
// --------------------------------------------------------------------------------------------
SQMOD_NODISCARD LgEntityVector GetPosition() const
{ return LgEntityVector(mID, LgEntityType::Player, LgPlayerVectorFlag::Pos, Get().GetPosition()); }
{ return {mID, LgEntityType::Player, LgPlayerVectorFlag::Pos, Get().GetPosition()}; }
SQMOD_NODISCARD int GetClass() const { return Get().GetClass(); }
SQMOD_NODISCARD bool GetAdmin() const { return Get().GetAdmin(); }
SQMOD_NODISCARD const SQChar * GetIP() const { return Get().GetIP(); }
@@ -732,7 +752,7 @@ struct LgPlayer
SQMOD_NODISCARD const SQChar * GetName() const { return Get().GetName(); }
SQMOD_NODISCARD int GetTeam() const { return Get().GetTeam(); }
SQMOD_NODISCARD int GetSkin() const { return Get().GetSkin(); }
SQMOD_NODISCARD LgEntityRGB GetColour() const { return LgEntityRGB(mID, LgEntityType::Player, 0, Get().GetColor()); }
SQMOD_NODISCARD LgEntityRGB GetColour() const { return {mID, LgEntityType::Player, 0, Get().GetColor()}; }
SQMOD_NODISCARD int GetMoney() const { return Get().GetMoney(); }
SQMOD_NODISCARD int GetScore() const { return Get().GetScore(); }
SQMOD_NODISCARD int GetPing() const { return Get().GetPing(); }
@@ -764,7 +784,7 @@ struct LgPlayer
SQMOD_NODISCARD LgPlayer * GetSpectateTarget() const
{ const int id = _Func->GetPlayerSpectateTarget(GetIdentifier()); return VALID_ENTITYEX(id, SQMOD_PLAYER_POOL) ? Core::Get().GetPlayer(id).mLgInst : nullptr; }
SQMOD_NODISCARD LgEntityVector GetSpeed() const
{ return LgEntityVector(mID, LgEntityType::Player, LgPlayerVectorFlag::Speed, Get().GetSpeed()); }
{ return {mID, LgEntityType::Player, LgPlayerVectorFlag::Speed, Get().GetSpeed()}; }
SQMOD_NODISCARD bool GetCanUseColors() const { return _Func->GetPlayerOption(GetIdentifier(), vcmpPlayerOptionChatTagsEnabled) >= 1; }
SQMOD_NODISCARD bool GetMarkerVisible() const { return _Func->GetPlayerOption(GetIdentifier(), vcmpPlayerOptionHasMarker) >= 1; }
SQMOD_NODISCARD bool GetDrunkStatus() const { return _Func->GetPlayerOption(GetIdentifier(), vcmpPlayerOptionDrunkEffects) >= 1; }
@@ -801,8 +821,8 @@ struct LgPlayer
SQMOD_NODISCARD int GetWeaponAtSlot(int slot) const { return Get().GetWeaponAtSlot(slot); }
SQMOD_NODISCARD int GetAmmoAtSlot(int slot) const { return Get().GetAmmoAtSlot(slot); }
void SetAlpha(int alpha, int fadeTime) const { Get().SetAlphaEx(alpha, fadeTime); }
SQMOD_NODISCARD bool StreamedToPlayer(const LgPlayer & player) const { return Get().IsStreamedFor(player.Get()); }
void SetVehicleSlot(const LgVehicle & vehicle, int slot) const;
SQMOD_NODISCARD bool StreamedToPlayer(LightObj & player) const { return Get().IsStreamedFor(GetNativeEnt< LgPlayer, CPlayer >(player)); }
void SetVehicleSlot(LightObj & vehicle, int slot) const;
void Select() const { Get().ForceSelect(); }
void RestoreCamera() const { Get().RestoreCamera(); }
void RemoveMarker() const { _Func->SetPlayerOption(GetIdentifier(), vcmpPlayerOptionHasMarker, 0); }
@@ -915,13 +935,13 @@ struct LgVehicle
SQMOD_NODISCARD int GetModel() const { return Get().GetModel(); }
SQMOD_NODISCARD uint32_t GetImmunity() const { return Get().GetImmunity(); }
SQMOD_NODISCARD LgEntityVector GetPosition() const
{ return LgEntityVector(mID, LgEntityType::Vehicle, LgVehicleVectorFlag::Pos, Get().GetPosition()); }
{ return {mID, LgEntityType::Vehicle, LgVehicleVectorFlag::Pos, Get().GetPosition()}; }
SQMOD_NODISCARD LgEntityVector GetSpawnPos() const
{ return LgEntityVector(mID, LgEntityType::Vehicle, LgVehicleVectorFlag::SpawnPos, Get().GetSpawnPosition()); }
{ return {mID, LgEntityType::Vehicle, LgVehicleVectorFlag::SpawnPos, Get().GetSpawnPosition()}; }
SQMOD_NODISCARD LgEntityQuaternion GetSpawnAngle() const
{ return LgEntityQuaternion(mID, LgEntityType::Vehicle, LgVehicleQuaternionFlag::SpawnAngle, Get().GetSpawnRotation()); }
{ return {mID, LgEntityType::Vehicle, LgVehicleQuaternionFlag::SpawnAngle, Get().GetSpawnRotation()}; }
SQMOD_NODISCARD LgEntityVector GetSpawnAngleEuler() const
{ return LgEntityVector(mID, LgEntityType::Vehicle, LgVehicleVectorFlag::SpawnAngle, Get().GetSpawnRotationEuler()); }
{ return {mID, LgEntityType::Vehicle, LgVehicleVectorFlag::SpawnAngle, Get().GetSpawnRotationEuler()}; }
SQMOD_NODISCARD uint32_t GetIdleRespawnTimer() const { return Get().GetIdleRespawnTimer(); }
SQMOD_NODISCARD float GetHealth() const { return Get().GetHealth(); }
SQMOD_NODISCARD int GetColour1() const { return Get().GetPrimaryColor(); }
@@ -939,21 +959,21 @@ struct LgVehicle
SQMOD_NODISCARD int GetSyncType() const { return Get().GetSyncType(); }
SQMOD_NODISCARD bool GetWrecked() const { return Get().IsWrecked(); }
SQMOD_NODISCARD LgEntityQuaternion GetRotation() const
{ return LgEntityQuaternion(mID, LgEntityType::Vehicle, LgVehicleQuaternionFlag::Angle, Get().GetRotation()); }
{ return {mID, LgEntityType::Vehicle, LgVehicleQuaternionFlag::Angle, Get().GetRotation()}; }
SQMOD_NODISCARD LgEntityVector GetEulerRotation() const
{ return LgEntityVector(mID, LgEntityType::Vehicle, LgVehicleVectorFlag::Angle, Get().GetRotationEuler()); }
{ return {mID, LgEntityType::Vehicle, LgVehicleVectorFlag::Angle, Get().GetRotationEuler()}; }
SQMOD_NODISCARD LgEntityVector GetSpeed() const
{ return LgEntityVector(mID, LgEntityType::Vehicle, LgVehicleVectorFlag::Speed, Get().GetSpeed()); }
{ return {mID, LgEntityType::Vehicle, LgVehicleVectorFlag::Speed, Get().GetSpeed()}; }
SQMOD_NODISCARD LgEntityVector GetRelativeSpeed() const
{ return LgEntityVector(mID, LgEntityType::Vehicle, LgVehicleVectorFlag::RelSpeed, Get().GetRelativeSpeed()); }
{ return {mID, LgEntityType::Vehicle, LgVehicleVectorFlag::RelSpeed, Get().GetRelativeSpeed()}; }
SQMOD_NODISCARD LgEntityVector GetTurnSpeed() const
{ return LgEntityVector(mID, LgEntityType::Vehicle, LgVehicleVectorFlag::TurnSpeed, Get().GetTurnSpeed()); }
{ return {mID, LgEntityType::Vehicle, LgVehicleVectorFlag::TurnSpeed, Get().GetTurnSpeed()}; }
SQMOD_NODISCARD LgEntityVector GetRelativeTurnSpeed() const
{ return LgEntityVector(mID, LgEntityType::Vehicle, LgVehicleVectorFlag::RelTurnSpeed, Get().GetRelativeTurnSpeed()); }
{ return {mID, LgEntityType::Vehicle, LgVehicleVectorFlag::RelTurnSpeed, Get().GetRelativeTurnSpeed()}; }
SQMOD_NODISCARD int GetRadio() const { return Get().GetRadio(); }
SQMOD_NODISCARD bool GetRadioLockStatus() const { return _Func->GetVehicleOption(GetIdentifier(), vcmpVehicleOptionRadioLocked) >= 1; }
SQMOD_NODISCARD bool GetGhost() const { return _Func->GetVehicleOption(GetIdentifier(), vcmpVehicleOptionGhost) >= 1; }
SQMOD_NODISCARD LgVector GetTurretRotation() const { const Vector2 v = Get().GetTurretRotation(); return LgVector(v.x, v.y, 0); }
SQMOD_NODISCARD LgVector GetTurretRotation() const { const Vector2 v = Get().GetTurretRotation(); return {v.x, v.y, 0}; }
SQMOD_NODISCARD bool GetSingleUse() const { return _Func->GetVehicleOption(GetIdentifier(), vcmpVehicleOptionSingleUse) >= 1; }
SQMOD_NODISCARD bool GetTaxiLight() const { return (_Func->GetVehicleLightsData(GetIdentifier()) & (1 << 8)) != 0; }
// --------------------------------------------------------------------------------------------
@@ -966,7 +986,7 @@ struct LgVehicle
void SetPartStatus(int part, int status) const { Get().SetPartStatus(part, status); }
SQMOD_NODISCARD int GetTyreStatus(int tyre) const { return Get().GetTyreStatus(tyre); }
void SetTyreStatus(int part, int status) const { Get().SetTyreStatus(part, status); }
SQMOD_NODISCARD bool GetStreamedForPlayer(LgPlayer & player) const { return Get().IsStreamedFor(player.Get()); }
SQMOD_NODISCARD bool GetStreamedForPlayer(LightObj & player) const { return Get().IsStreamedFor(GetNativeEnt< LgPlayer, CPlayer >(player)); }
SQMOD_NODISCARD LgPlayer * GetOccupant(int slot) const
{ const int id = _Func->GetVehicleOccupant(GetIdentifier(), slot); return VALID_ENTITYEX(id, SQMOD_PLAYER_POOL) ? Core::Get().GetPlayer(id).mLgInst : nullptr; }
void SetHandlingData(int rule, float value) const { Get().SetHandlingRule(rule, value); }
@@ -982,11 +1002,11 @@ struct LgVehicle
};
// ------------------------------------------------------------------------------------------------
inline bool LgCheckpoint::StreamedToPlayer(LgPlayer & player) const { return Get().IsStreamedFor(player.Get()); }
inline bool LgObject::StreamedToPlayer(LgPlayer & player) const { return Get().IsStreamedFor(player.Get()); }
inline bool LgPickup::StreamedToPlayer(LgPlayer & player) const { return Get().IsStreamedFor(player.Get()); }
inline void LgPlayer::SetVehicle(LgVehicle & vehicle) const { Get().Embark(vehicle.Get()); }
inline void LgPlayer::SetVehicleSlot(const LgVehicle & vehicle, int slot) const { Get().EmbarkEx(vehicle.Get(), slot, true, false); }
inline bool LgCheckpoint::StreamedToPlayer(LightObj & player) const { return Get().IsStreamedFor(GetNativeEnt< LgPlayer, CPlayer >(player)); }
inline bool LgObject::StreamedToPlayer(LightObj & player) const { return Get().IsStreamedFor(GetNativeEnt< LgPlayer, CPlayer >(player)); }
inline bool LgPickup::StreamedToPlayer(LightObj & player) const { return Get().IsStreamedFor(GetNativeEnt< LgPlayer, CPlayer >(player)); }
inline void LgPlayer::SetVehicle(LightObj & vehicle) const { Get().Embark(GetNativeEnt< LgVehicle, CVehicle >(vehicle)); }
inline void LgPlayer::SetVehicleSlot(LightObj & vehicle, int slot) const { Get().EmbarkEx(GetNativeEnt< LgVehicle, CVehicle >(vehicle), slot, true, false); }
// ------------------------------------------------------------------------------------------------
void LgCheckpointSetID(LgCheckpoint * inst, int32_t id) { assert(inst); if (inst) inst->mID = id; }
@@ -1434,8 +1454,8 @@ static void LgUnbanIP(StackStrF & ip) { _Func->UnbanIP(const_cast< SQChar * >(ip
SQMOD_NODISCARD static bool LgIsIPBanned(StackStrF & ip) { return _Func->IsIPBanned(const_cast< SQChar * >(ip.mPtr)) >= 1; }
// ------------------------------------------------------------------------------------------------
SQMOD_NODISCARD static int LgGetPlayerIDFromName(StackStrF & name) { return _Func->GetPlayerIdFromName(name.mPtr); }
SQMOD_NODISCARD static bool LgIsWorldCompatibleWithPlayer (LgPlayer & player, int world)
{ return _Func->IsPlayerWorldCompatible(player.GetIdentifier(), world) >= 1; }
SQMOD_NODISCARD static bool LgIsWorldCompatibleWithPlayer(LightObj & player, int world)
{ return _Func->IsPlayerWorldCompatible(GetLgEntID< LgPlayer, CPlayer >(player), world) >= 1; }
// ------------------------------------------------------------------------------------------------
static LightObj & LgCreatePickupCompat(int model, const Vector3 & pos)
{ return Core::Get().NewPickup(model, 1, 0, pos.x, pos.y, pos.z, 255, false, SQMOD_CREATE_DEFAULT, NullLightObj()).mLgObj; }
@@ -1449,7 +1469,7 @@ static LightObj & LgCreatePickup(int model, int world, int quantity, const Vecto
static LightObj & LgCreateObject(int model, int world, const Vector3 & pos, int alpha)
{ return Core::Get().NewObject(model, world, pos.x, pos.y, pos.z, alpha, SQMOD_CREATE_DEFAULT, NullLightObj()).mLgObj; }
static LightObj & LgCreateCheckpoint(LightObj & player, int world, bool sphere, const Vector3 & pos, const Color4 & col, float radius) {
const int32_t id = player.IsNull() ? -1 : player.CastI< LgPlayer >()->GetIdentifier();
const int32_t id = player.IsNull() ? -1 : GetLgEntID< LgPlayer, CPlayer >(player);
return Core::Get().NewCheckpoint(id, world, sphere, pos.x, pos.y, pos.z, col.r, col.g, col.b, col.a, radius, SQMOD_CREATE_DEFAULT, NullLightObj()).mLgObj;
}
// ------------------------------------------------------------------------------------------------
@@ -1507,30 +1527,30 @@ SQMOD_NODISCARD static int LgBindKey(bool down, int key1, int key2, int key3)
SQMOD_NODISCARD static bool LgRemoveKeybind(int id) { return _Func->RemoveKeyBind(id) == vcmpErrorNone; }
static void LgRemoveAllKeybinds() { _Func->RemoveAllKeyBinds(); }
// ------------------------------------------------------------------------------------------------
SQMOD_NODISCARD static bool LgGetCinematicBorder(LgPlayer & player) { return _Func->GetPlayerOption(player.GetIdentifier(), vcmpPlayerOptionWidescreen) >= 1; }
SQMOD_NODISCARD static bool LgGetGreenScanLines(LgPlayer & player) { return _Func->GetPlayerOption(player.GetIdentifier(), vcmpPlayerOptionGreenScanlines) >= 1; }
SQMOD_NODISCARD static bool LgGetWhiteScanLines(LgPlayer & player) { return _Func->GetPlayerOption(player.GetIdentifier(), vcmpPlayerOptionWhiteScanlines) >= 1; }
static void LgSetCinematicBorder(LgPlayer & player, bool toggle) { _Func->SetPlayerOption(player.GetIdentifier(), vcmpPlayerOptionWidescreen, static_cast< uint8_t >(toggle)); }
static void LgSetGreenScanLines(LgPlayer & player, bool toggle) { _Func->SetPlayerOption(player.GetIdentifier(), vcmpPlayerOptionGreenScanlines, static_cast< uint8_t >(toggle)); }
static void LgSetWhiteScanLines(LgPlayer & player, bool toggle) { _Func->SetPlayerOption(player.GetIdentifier(), vcmpPlayerOptionWhiteScanlines, static_cast< uint8_t >(toggle)); }
SQMOD_NODISCARD static bool LgGetCinematicBorder(LightObj & player) { return _Func->GetPlayerOption(GetLgEntID< LgPlayer, CPlayer >(player), vcmpPlayerOptionWidescreen) >= 1; }
SQMOD_NODISCARD static bool LgGetGreenScanLines(LightObj & player) { return _Func->GetPlayerOption(GetLgEntID< LgPlayer, CPlayer >(player), vcmpPlayerOptionGreenScanlines) >= 1; }
SQMOD_NODISCARD static bool LgGetWhiteScanLines(LightObj & player) { return _Func->GetPlayerOption(GetLgEntID< LgPlayer, CPlayer >(player), vcmpPlayerOptionWhiteScanlines) >= 1; }
static void LgSetCinematicBorder(LightObj & player, bool toggle) { _Func->SetPlayerOption(GetLgEntID< LgPlayer, CPlayer >(player), vcmpPlayerOptionWidescreen, static_cast< uint8_t >(toggle)); }
static void LgSetGreenScanLines(LightObj & player, bool toggle) { _Func->SetPlayerOption(GetLgEntID< LgPlayer, CPlayer >(player), vcmpPlayerOptionGreenScanlines, static_cast< uint8_t >(toggle)); }
static void LgSetWhiteScanLines(LightObj & player, bool toggle) { _Func->SetPlayerOption(GetLgEntID< LgPlayer, CPlayer >(player), vcmpPlayerOptionWhiteScanlines, static_cast< uint8_t >(toggle)); }
// ------------------------------------------------------------------------------------------------
static void LgKickPlayer(LgPlayer & player) { _Func->KickPlayer(player.GetIdentifier()); }
static void LgBanPlayer(LgPlayer & player) { _Func->BanPlayer(player.GetIdentifier()); }
static void LgKickPlayer(LightObj & player) { _Func->KickPlayer(GetLgEntID< LgPlayer, CPlayer >(player)); }
static void LgBanPlayer(LightObj & player) { _Func->BanPlayer(GetLgEntID< LgPlayer, CPlayer >(player)); }
// ------------------------------------------------------------------------------------------------
static void LgMessage(StackStrF & msg) { _Func->SendClientMessage(-1, 0x0b5fa5ff, "%s", msg.mPtr); }
static void LgMessagePlayer(StackStrF & msg, LgPlayer & player) { _Func->SendClientMessage(player.GetIdentifier(), 0x0b5fa5ff, "%s", msg.mPtr); }
static void LgMessageAllExcept(StackStrF & msg, LgPlayer & player) {
const int32_t p = player.GetIdentifier();
static void LgMessagePlayer(StackStrF & msg, LightObj & player) { _Func->SendClientMessage(GetLgEntID< LgPlayer, CPlayer >(player), 0x0b5fa5ff, "%s", msg.mPtr); }
static void LgMessageAllExcept(StackStrF & msg, LightObj & player) {
const auto p = GetLgEntID< LgPlayer, CPlayer >(player);
const SQChar * m = msg.mPtr;
ForeachConnectedPlayer([=](int32_t id) { if (id != p) _Func->SendClientMessage(id, 0x0b5fa5ff, "%s", m); });
}
static void LgPrivMessage(LgPlayer & player, StackStrF & msg) { _Func->SendClientMessage(player.GetIdentifier(), 0x007f16ff, "** pm >> %s", msg.mPtr); }
static void LgPrivMessage(LightObj & player, StackStrF & msg) { _Func->SendClientMessage(GetLgEntID< LgPlayer, CPlayer >(player), 0x007f16ff, "** pm >> %s", msg.mPtr); }
static void LgPrivMessageAll(StackStrF & msg) {
const SQChar * m = msg.mPtr;
ForeachConnectedPlayer([=](int32_t id) { _Func->SendClientMessage(id, 0x007f16ff, "** pm >> %s", m); });
}
static void LgSendPlayerMessage(LgPlayer & source, LgPlayer & target, StackStrF & msg) {
_Func->SendClientMessage(target.GetIdentifier(), 0x007f16ff, "** pm from %s >> %s", source.Get().GetName(), msg.mPtr);
static void LgSendPlayerMessage(LightObj & source, LightObj & target, StackStrF & msg) {
_Func->SendClientMessage(GetLgEntID< LgPlayer, CPlayer >(target), 0x007f16ff, "** pm from %s >> %s",GetNativeEnt< LgPlayer, CPlayer >(source).GetName(), msg.mPtr);
}
// ------------------------------------------------------------------------------------------------
SQMOD_NODISCARD static const SQChar * LgGetWeaponName(int id) { return GetWeaponName(static_cast< uint32_t >(id)); }
@@ -2302,8 +2322,8 @@ struct LgStream {
int32_t id;
if (target.IsNull()) id = -1;
else if (target.GetType() == OT_INTEGER || target.GetType() == OT_FLOAT) id = target.Cast< int32_t >();
else if (static_cast< AbstractStaticClassData * >(target.GetTypeTag()) == StaticClassTypeTag< LgPlayer >::Get()) {
id = target.CastI< LgPlayer >()->GetIdentifier();
else if (target.GetType() == OT_INSTANCE) {
id = GetLgEntID< LgPlayer, CPlayer >(target);
} else STHROWF("Invalid target type");
if (id >= SQMOD_PLAYER_POOL) STHROWF("Invalid player ID");
_Func->SendClientScriptData(id, m_OutputStreamData, m_OutputStreamEnd);
module/PocoLib/Data.hpp
+2 -2
View File
@@ -2146,12 +2146,12 @@ struct SqDataAsyncBuilder
SqDataAsyncBuilder & operator = (SqDataAsyncBuilder && o) = default;
/* --------------------------------------------------------------------------------------------
* Create the task with the suplied information and submit it to the worker pool.
* Create the task with the supplied information and submit it to the worker pool.
*/
void Submit() { Submit_(NullLightObj()); }
/* --------------------------------------------------------------------------------------------
* Create the task with the suplied information and submit it to the worker pool.
* Create the task with the supplied information and submit it to the worker pool.
*/
void Submit_(LightObj & ctx);
module/Register.cpp
+6 -5
View File
@@ -1,6 +1,3 @@
#ifndef _REGISTER_HPP_
#define _REGISTER_HPP_
// ------------------------------------------------------------------------------------------------
#include <squirrelex.h>
@@ -33,6 +30,9 @@ extern void Register_CVehicle(HSQUIRRELVM vm);
// ------------------------------------------------------------------------------------------------
extern void Register_Chrono(HSQUIRRELVM vm);
extern void Register_CURL(HSQUIRRELVM vm);
#ifdef SQMOD_DISCORD
extern void Register_Discord(HSQUIRRELVM vm);
#endif
extern void Register_Format(HSQUIRRELVM vm);
extern void Register_IO(HSQUIRRELVM vm);
extern void Register_JSON(HSQUIRRELVM vm);
@@ -101,6 +101,9 @@ bool RegisterAPI(HSQUIRRELVM vm)
Register_Chrono(vm);
Register_CURL(vm);
#ifdef SQMOD_DISCORD
Register_Discord(vm);
#endif
Register_Format(vm);
Register_IO(vm);
Register_JSON(vm);
@@ -144,5 +147,3 @@ bool RegisterAPI(HSQUIRRELVM vm)
}
} // Namespace:: SqMod
#endif // _REGISTER_HPP_
module/SDK/sqmod.h
+75
View File
@@ -0,0 +1,75 @@
#if !defined(_SQ_MOD_API_H_)
#define _SQ_MOD_API_H_
#include <stdint.h>
#include <stdlib.h>
#ifdef __cplusplus
extern "C" {
#endif // __cplusplus
#ifndef SQMOD_API_EXPORT
#if defined(_MSC_VER)
#define SQMOD_API_EXPORT extern "C" __declspec(dllexport)
#elif defined(__GNUC__)
#define SQMOD_API_EXPORT extern "C"
#else
#define SQMOD_API_EXPORT extern "C"
#endif
#endif
#define SQMOD_HOST_NAME "SqModHost"
#define SQMOD_INITIALIZE_CMD 0xDABBAD00 // host plug-in was initialized
#define SQMOD_LOAD_CMD 0xDEADBABE // API is being registered
#define SQMOD_TERMINATE_CMD 0xDEADC0DE // release your resources
#define SQMOD_CLOSING_CMD 0xBAAAAAAD // virtual machine is closing
#define SQMOD_RELEASED_CMD 0xDEADBEAF // virtual machine was closed
#define SQMOD_API_VER 1
// --------------------------------------------------------------------------------------------
typedef int32_t(*ExtPluginCommand_t)(int32_t, int32_t, int32_t, const uint8_t *, size_t);
/* --------------------------------------------------------------------------------------------
* The structure exported by the host plug-in to import the module and squirrel API.
*/
typedef struct
{
uint32_t StructSize;
/* Register a pointer to a function used to processes commands from script.
This is like the functionality offered by SendPluginCommand but offers interaction from
script side without interfering with other native plugins. And also offers a few extra
methods of identification to provide back and forth communication.
It offers a bare minimum, primitive way of interacting with the script from native plug-ins.
return : -1 it failed (no free slot), 0 if it was already registered and 1 if it succeeded.
*/
int32_t (*RegisterCommand) (ExtPluginCommand_t fn);
/* Remove a pointer to a function used to processes commands from script.
return : -1 it failed (no free slot) and 1 if it succeeded.
*/
int32_t (*UnregisterCommand) (ExtPluginCommand_t fn);
/* Send a command to all functions currently registered to receive them. This is mostly used by the script.
target - ideally a unique value that can be used to identify the intended audience for the command.
req : ideally a unique value that can be used to identify the requested information from the command.
tag : ideally a unique value that can be used to identify a later response if one is generated.
data : binary data that represents the command payload. the command is free to interpret it however it wants.
size : size of the binary data. most likely in bytes but the command is free to interpret it however it wants.
*/
int32_t (*SendCommand) (int32_t target, int32_t req, int32_t tag, const uint8_t * data, size_t size);
/* Send a response to the script that may have resulted from a previous command. This is mostly by the native plug-ins.
sender : ideally a unique value that can be used to identify the intended who generated the response.
tag : ideally a unique value that can be used to identify what the generated response might contain/provide.
data : binary data that represents the command payload. the command is free to interpret it however it wants.
size : size of the binary data. most likely in bytes but the command is free to interpret it however it wants.
*/
int32_t (*SendCommandReply) (int32_t sender, int32_t tag, const uint8_t * data, size_t size);
/* Forward an event to the script from an external plug-in. This is mostly by the native plug-ins.
Similar to SendCommandReply but may not have been the result of a previous command.
*/
int32_t (*SendCommandEvent) (int32_t sender, int32_t tag, const uint8_t * data, size_t size);
} sq_mod_exports, SQ_MOD_EXPORTS, *HSQ_MOD_EXPORTS;
#ifdef __cplusplus
} /*extern "C"*/
#endif // __cplusplus
#endif /*_SQ_MOD_API_H_*/
module/Sqrat/sqratLightObj.h
+16 -16
View File
@@ -195,21 +195,7 @@ struct LightObj {
///
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
template<class T, class... A>
LightObj(SqTypeIdentity< T > SQ_UNUSED_ARG(t), HSQUIRRELVM vm, A&&... a) {
// Create the instance and guard it to make sure it gets deleted in case of exceptions
DeleteGuard< T > instance(new T(std::forward< A >(a)...));
// Preserve the stack state
const StackGuard sg(vm);
// Push the instance on the stack
ClassType<T>::PushInstance(vm, instance);
// Attempt to retrieve it
if (SQ_FAILED(sq_getstackobj(vm, -1, &mObj))) {
sq_resetobject(&mObj);
} else {
sq_addref(vm, &mObj);
}
// Stop guarding the instance
instance.Release();
LightObj(SqTypeIdentity< T > SQ_UNUSED_ARG(t), HSQUIRRELVM vm, A&&... a) : LightObj(DeleteGuard< T >(new T(std::forward< A >(a)...))) {
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -246,7 +232,21 @@ struct LightObj {
///
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
template<class T>
LightObj(DeleteGuard<T> guard, HSQUIRRELVM v = SqVM()) : LightObj(guard.Get(), v) {
LightObj(DeleteGuard<T> && guard, HSQUIRRELVM v = SqVM()) : LightObj(guard.Get(), v) {
guard.Release();
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Constructs an LightObj from a C++ instance wrapped inside a DeleteGuard
///
/// \param instance Pointer to a C++ class instance that has been bound already
/// \param v VM that the object will exist in
///
/// \tparam T Type of instance
///
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
template<class T>
LightObj(DeleteGuard<T> & guard, HSQUIRRELVM v = SqVM()) : LightObj(guard.Get(), v) {
guard.Release();
}
module/Sqrat/sqratUtil.h
+166 -42
View File
@@ -35,6 +35,7 @@
#include <string>
#include <utility>
#include <exception>
#include <type_traits>
#include <unordered_map>
#include <Poco/Exception.h>
@@ -1580,12 +1581,31 @@ public:
}
};
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Helper structure for one element from the top of stack. Uses default global VM instead.
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct SqPopTopGuardLite
{
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Base constructor.
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
SqPopTopGuardLite() noexcept = default;
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Destructor. Pops the specified elements from the stack.
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
~SqPopTopGuardLite()
{
sq_poptop(SqVM());
}
};
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Helper structure for one element from the top of stack.
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct SqPopTopGuard
{
HSQUIRRELVM mVM; // The VM from which the elements must be popped.
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Base constructor.
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -1603,13 +1623,70 @@ struct SqPopTopGuard
}
};
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Helper structure for popping elements from the stack. Uses default global VM instead.
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct SqPopGuardLite
{
SQInteger mNum{0}; // The number of elements to be popped.
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Base constructor.
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
explicit SqPopGuardLite(SQInteger num) noexcept
: mNum(num)
{
//...
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Destructor. Pops the specified elements from the stack.
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
~SqPopGuardLite()
{
sq_pop(SqVM(), mNum);
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Increment the number of elements to be popped.
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
SqPopGuardLite & operator ++ ()
{
++mNum;
return *this;
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Decrement the number of elements to be popped.
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
SqPopGuardLite & operator -- ()
{
--mNum;
return *this;
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Increase the number of elements to be popped.
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
SqPopGuardLite & operator += (SQInteger n)
{
mNum += n;
return *this;
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Decrease the number of elements to be popped.
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
SqPopGuardLite & operator -= (SQInteger n)
{
mNum -= n;
return *this;
}
};
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Helper structure for popping elements from the stack.
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct SqPopGuard
{
HSQUIRRELVM mVM; // The VM from which the elements must be popped.
SQInteger mNum; // The number of elements to be popped.
HSQUIRRELVM mVM{nullptr}; // The VM from which the elements must be popped.
SQInteger mNum{0}; // The number of elements to be popped.
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Base constructor.
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -1659,17 +1736,79 @@ struct SqPopGuard
}
};
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Implements RAII to restore the VM stack to it's initial size on function exit. Uses default global VM instead.
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct StackGuardLite
{
SQInteger mTop{0}; ///< The top of the stack when this instance was created.
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Default constructor.
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
StackGuardLite() noexcept
: mTop(sq_gettop(SqVM()))
{
/* ... */
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Copy constructor. (disabled)
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
StackGuardLite(const StackGuardLite &) = delete;
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Move constructor. (disabled)
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
StackGuardLite(StackGuardLite &&) = delete;
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Destructor.
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
~StackGuardLite()
{
Restore();
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Copy assignment operator. (disabled)
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
StackGuardLite & operator = (const StackGuardLite &) = delete;
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Move assignment operator. (disabled)
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
StackGuardLite & operator = (StackGuardLite &&) = delete;
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Restore the stack to what was known to be.
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void Restore() const
{
auto vm = SqVM();
// Retrieve the new stack top
const SQInteger top = sq_gettop(vm);
// Did the stack size change?
if (top > mTop)
{
sq_pop(vm, top - mTop); // Trim the stack
}
}
};
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Implements RAII to restore the VM stack to it's initial size on function exit.
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct StackGuard
{
HSQUIRRELVM mVM{nullptr}; ///< The VM where the stack should be restored.
SQInteger mTop{0}; ///< The top of the stack when this instance was created.
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Default constructor.
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
StackGuard()
: m_VM(SqVM()), m_Top(sq_gettop(m_VM))
: mVM(SqVM()), mTop(sq_gettop(mVM))
{
/* ... */
}
@@ -1677,8 +1816,8 @@ struct StackGuard
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Base constructor.
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
StackGuard(HSQUIRRELVM vm)
: m_VM(vm), m_Top(sq_gettop(vm))
explicit StackGuard(HSQUIRRELVM vm)
: mVM(vm), mTop(sq_gettop(vm))
{
/* ... */
}
@@ -1717,18 +1856,13 @@ struct StackGuard
void Restore() const
{
// Retrieve the new stack top
const SQInteger top = sq_gettop(m_VM);
const SQInteger top = sq_gettop(mVM);
// Did the stack size change?
if (top > m_Top)
if (top > mTop)
{
sq_pop(m_VM, top - m_Top); // Trim the stack
sq_pop(mVM, top - mTop); // Trim the stack
}
}
private:
HSQUIRRELVM m_VM; ///< The VM where the stack should be restored.
SQInteger m_Top; ///< The top of the stack when this instance was created.
};
@@ -2131,18 +2265,13 @@ inline void ErrorToException(HSQUIRRELVM vm, bool keep = false) {
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
template < typename T > struct DeleteGuard
{
private:
// --------------------------------------------------------------------------------------------
T * m_Ptr; // Pointer to the instance to manage.
public:
T * mPtr; // Pointer to the instance to manage.
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Default constructor.
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
explicit DeleteGuard(T * ptr)
: m_Ptr(ptr)
: mPtr(ptr)
{
/* ... */
}
@@ -2152,7 +2281,7 @@ public:
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
template<class... A>
explicit DeleteGuard(SqInPlace SQ_UNUSED_ARG(t), A&&... a)
: m_Ptr(new T(std::forward< A >(a)...))
: mPtr(new T(std::forward< A >(a)...))
{
/* ... */
}
@@ -2166,9 +2295,9 @@ public:
/// Move constructor.
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
DeleteGuard(DeleteGuard && o) noexcept
: m_Ptr(o.m_Ptr)
: mPtr(o.mPtr)
{
o.m_Ptr = nullptr;
o.mPtr = nullptr;
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -2176,9 +2305,9 @@ public:
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
~DeleteGuard()
{
if (m_Ptr)
if (mPtr)
{
delete m_Ptr;
delete mPtr;
}
}
@@ -2197,7 +2326,7 @@ public:
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
operator T * () const
{
return m_Ptr;
return mPtr;
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -2205,7 +2334,7 @@ public:
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
T * Get() const
{
return m_Ptr;
return mPtr;
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -2213,7 +2342,7 @@ public:
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void Release()
{
m_Ptr = nullptr;
mPtr = nullptr;
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -2221,8 +2350,8 @@ public:
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
T * Grab()
{
T * ptr = m_Ptr;
m_Ptr = nullptr;
T * ptr = mPtr;
mPtr = nullptr;
return ptr;
}
};
@@ -2320,18 +2449,13 @@ template < typename T > T * SqChainedInstances< T >::sHead = nullptr;
/// @cond DEV
/// Used internally to get and manipulate the underlying type of variables - retrieved from cppreference.com
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
template<class T> struct remove_const {typedef T type;};
template<class T> struct remove_const<const T> {typedef T type;};
template<class T> struct remove_volatile {typedef T type;};
template<class T> struct remove_volatile<volatile T> {typedef T type;};
template<class T> struct remove_cv {typedef typename remove_volatile<typename remove_const<T>::type>::type type;};
template<class T> struct is_pointer_helper {static constexpr bool value = false;};
template<class T> struct is_pointer_helper<T*> {static constexpr bool value = true;};
template<class T,class D> struct is_pointer_helper<SharedPtr<T,D> > {static constexpr bool value = true;};
template<class T,class D> struct is_pointer_helper<WeakPtr<T,D> > {static constexpr bool value = true;};
template<class T> struct is_pointer : is_pointer_helper<typename remove_cv<T>::type> {};
template<class T> struct is_reference {static constexpr bool value = false;};
template<class T> struct is_reference<T&> {static constexpr bool value = true;};
template<class T> using remove_const = std::remove_const< T >;
template<class T> using remove_volatile = std::remove_volatile< T >;
template<class T> using remove_cv = std::remove_cv< T >;
template<class T> struct is_pointer : public std::is_pointer< T > { };
template<class T,class D> struct is_pointer<SharedPtr<T,D> > : public std::true_type { };
template<class T,class D> struct is_pointer<WeakPtr<T,D> > : public std::true_type { };
template<class T> using is_reference = std::is_lvalue_reference< T >;
/// @endcond
vendor/CMakeLists.txt
Vendored
+25
View File
@@ -8,6 +8,8 @@ add_subdirectory(TinyDir)
add_subdirectory(SAJSON)
add_subdirectory(CPR)
add_subdirectory(UTF8)
add_subdirectory(JSON)
add_subdirectory(Inja)
add_subdirectory(PUGIXML)
add_subdirectory(CivetWeb)
if (ENABLE_BUILTIN_MYSQL_C)
@@ -71,3 +73,26 @@ if (WIN32 OR MINGW)
set(ZMQ_HAVE_IPC OFF CACHE INTERNAL "" FORCE)
endif()
add_subdirectory(ZMQ)
if(ENABLE_DISCORD)
set(BUILD_TESTING OFF CACHE INTERNAL "" FORCE)
set(BUILD_VOICE_SUPPORT OFF CACHE INTERNAL "" FORCE)
set(DPP_INSTALL OFF CACHE INTERNAL "" FORCE)
set(DPP_BUILD_TEST OFF CACHE INTERNAL "" FORCE)
set(DPP_NO_VCPKG ON CACHE INTERNAL "" FORCE)
set(DPP_CORO OFF CACHE INTERNAL "" FORCE)
set(DPP_USE_EXTERNAL_JSON ON CACHE INTERNAL "" FORCE)
if (WIN32 OR MINGW)
set(BUILD_SHARED_LIBS ON CACHE INTERNAL "" FORCE)
endif()
add_subdirectory(DPP)
target_link_libraries(dpp PRIVATE nlohmann_json)
set(BUILD_SHARED_LIBS OFF CACHE INTERNAL "" FORCE)
# We don't care about DPP warnings
if ("${CMAKE_CXX_COMPILER_ID}" MATCHES "GNU")
target_compile_options(dpp PRIVATE -w)
elseif ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
target_compile_options(dpp PRIVATE -w)
elseif ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC")
target_compile_options(dpp PRIVATE /w)
endif()
endif()
vendor/CPR/CMakeLists.txt
Vendored
+4
View File
@@ -51,6 +51,10 @@ add_library(CPR STATIC
# Library includes
target_include_directories(CPR PRIVATE ${CMAKE_CURRENT_LIST_DIR}/cpr)
target_include_directories(CPR PUBLIC ${CMAKE_CURRENT_LIST_DIR}/include)
# Disable deprecated warnings
if (NOT MSVC)
target_compile_options(CPR PRIVATE -Wno-deprecated-declarations)
endif()
# Find CURK
find_package(CURL REQUIRED)
if (CURL_FOUND)
vendor/CivetWeb/CMakeLists.txt
Vendored
+3 -3
View File
@@ -10,7 +10,7 @@ add_library(CivetWeb STATIC
wolfssl_extras.inl
handle_form.inl
md5.inl
mod_http2.inl
http2.inl
)
# Configure include folders
target_include_directories(CivetWeb PRIVATE ${CMAKE_CURRENT_LIST_DIR})
@@ -25,14 +25,14 @@ target_compile_definitions(CivetWeb PUBLIC USE_TIMERS=1 USE_WEBSOCKET=1 USE_IPV6
find_package(OpenSSL)
# Check SSL status
if (OPENSSL_FOUND)
message(STATUS "CivetWeb: OpenSSL was found")
message(STATUS "CivetWeb: OpenSSL was found ${OPENSSL_VERSION}")
target_link_libraries(CivetWeb PUBLIC OpenSSL::Crypto OpenSSL::SSL)
string(REPLACE "." ";" OPENSSL_VERSION_LIST ${OPENSSL_VERSION})
list(GET OPENSSL_VERSION_LIST 0 OPENSSL_VERSION_MAJOR)
list(GET OPENSSL_VERSION_LIST 1 OPENSSL_VERSION_MINOR)
list(GET OPENSSL_VERSION_LIST 2 OPENSSL_VERSION_PATCH)
# Tell the library what SSL version to expect
target_compile_definitions(CivetWeb PUBLIC "OPENSSL_API_${OPENSSL_VERSION_MAJOR}_${OPENSSL_VERSION_MINOR}")
target_compile_definitions(CivetWeb PRIVATE "OPENSSL_API_${OPENSSL_VERSION_MAJOR}_${OPENSSL_VERSION_MINOR}")
message(STATUS "CivetWeb: OPENSSL_API_${OPENSSL_VERSION_MAJOR}_${OPENSSL_VERSION_MINOR}")
else()
target_compile_definitions(CivetWeb PUBLIC NO_SSL=1)
vendor/CivetWeb/civetweb.c
Vendored
+1710 -672
View File
File diff suppressed because it is too large Load Diff
vendor/CivetWeb/handle_form.inl
Vendored
+1 -1
View File
@@ -220,7 +220,7 @@ mg_handle_form_request(struct mg_connection *conn,
}
/* GET request: form data is in the query string. */
/* The entire data has already been loaded, so there is no nead to
/* The entire data has already been loaded, so there is no need to
* call mg_read. We just need to split the query string into key-value
* pairs. */
data = conn->request_info.query_string;
vendor/CivetWeb/mod_http2.inl → vendor/CivetWeb/http2.inl
Vendored
+53 -21
View File
@@ -654,7 +654,7 @@ hpack_getnum(const uint8_t *buf,
* the encoded string.
*/
static char *
hpack_decode(const uint8_t *buf, int *i, struct mg_context *ctx)
hpack_decode(const uint8_t *buf, int *i, int max_i, struct mg_context *ctx)
{
uint64_t byte_len64;
int byte_len;
@@ -670,6 +670,11 @@ hpack_decode(const uint8_t *buf, int *i, struct mg_context *ctx)
byte_len = (int)byte_len64;
bit_len = byte_len * 8;
/* check size */
if ((*i) + byte_len > max_i) {
return NULL;
}
/* Now read the string */
if (!is_huff) {
/* Not huffman encoded: Copy directly */
@@ -718,6 +723,10 @@ hpack_decode(const uint8_t *buf, int *i, struct mg_context *ctx)
break;
}
}
if (bytesStored == sizeof(str)) {
/* too long */
return 0;
}
}
}
}
@@ -820,7 +829,7 @@ hpack_encode(uint8_t *store, const char *load, int lower)
static const char http2_pri[] = "PRI * HTTP/2.0\r\n\r\nSM\r\n\r\n";
static unsigned char http2_pri_len = 24; /* = strlen(http2_pri) */
static const unsigned char http2_pri_len = 24; /* = strlen(http2_pri) */
/* Read and check the HTTP/2 primer/preface:
@@ -829,17 +838,19 @@ static int
is_valid_http2_primer(struct mg_connection *conn)
{
size_t pri_len = http2_pri_len;
char buf[32];
char buf[32]; /* Buffer must hold 24 bytes primer */
if (pri_len > sizeof(buf)) {
/* Should never be reached - the RFC primer has 24 bytes */
return 0;
}
int read_pri_len = mg_read(conn, buf, pri_len);
if ((read_pri_len != (int)pri_len)
|| (0 != memcmp(buf, http2_pri, pri_len))) {
if (read_pri_len != (int)pri_len) {
/* Size does not match.
* This includes cases where mg_read returns error codes */
return 0;
}
if (0 != memcmp(buf, http2_pri, pri_len)) {
/* Primer does not match */
return 0;
}
/* Primer does match */
return 1;
}
@@ -850,7 +861,7 @@ is_valid_http2_primer(struct mg_connection *conn)
(conn)->client.sock, \
(conn)->ssl, \
(const char *)(data), \
(int)(len));
(int)(len))
static void
@@ -949,7 +960,7 @@ http2_send_response_headers(struct mg_connection *conn)
uint16_t header_len = 0;
int has_date = 0;
int has_connection_header = 0;
int i;
int i, ok;
if ((conn->status_code < 100) || (conn->status_code > 999)) {
/* Invalid status: Set status to "Internal Server Error" */
@@ -1058,16 +1069,23 @@ http2_send_response_headers(struct mg_connection *conn)
http2_header_frame[8] = (conn->http2.stream_id & 0xFFu);
/* Send header frame */
mg_xwrite(conn, http2_header_frame, 9);
mg_xwrite(conn, header_bin, header_len);
DEBUG_TRACE("HTTP2 response header sent: stream %u", conn->http2.stream_id);
ok = 1;
if (mg_xwrite(conn, http2_header_frame, 9) != 9) {
ok = 0;
} else if (mg_xwrite(conn, header_bin, header_len) != header_len) {
ok = 0;
}
if (ok) {
DEBUG_TRACE("HTTP2 response header sent: stream %u",
conn->http2.stream_id);
} else {
DEBUG_TRACE("HTTP2 response header sending error: stream %u",
conn->http2.stream_id);
}
(void)has_connection_header; /* ignore for the moment */
return 42; /* TODO */
return ok;
}
@@ -1420,8 +1438,13 @@ handle_http2(struct mg_connection *conn)
/* Get Header name "key" */
if (idx == 0) {
/* Index 0: Header name encoded in following bytes */
key = hpack_decode(buf, &i, conn->phys_ctx);
key =
hpack_decode(buf, &i, (int)bytes_read, conn->phys_ctx);
CHECK_LEAK_HDR_ALLOC(key);
if (!key) {
DEBUG_TRACE("HTTP2 key decoding error");
goto clean_http2;
}
} else if (/*(idx >= 15) &&*/ (idx <= 61)) {
/* Take key name from predefined header table */
key = mg_strdup_ctx(hpack_predefined[idx].name,
@@ -1480,8 +1503,16 @@ handle_http2(struct mg_connection *conn)
} else {
/* Read value from HTTP2 stream */
val = hpack_decode(buf, &i, conn->phys_ctx); /* leak? */
val = hpack_decode(buf,
&i,
(int)bytes_read,
conn->phys_ctx); /* leak? */
CHECK_LEAK_HDR_ALLOC(val);
if (!val) {
DEBUG_TRACE("HTTP2 value decoding error");
mg_free((void *)key);
goto clean_http2;
}
if (indexing) {
/* Add to index */
@@ -1546,6 +1577,7 @@ handle_http2(struct mg_connection *conn)
} else if (!strcmp(":path", key)) {
conn->request_info.local_uri = val;
conn->request_info.request_uri = val;
conn->request_info.local_uri_raw = val;
} else if (!strcmp(":status", key)) {
conn->status_code = atoi(val);
}
@@ -1803,7 +1835,7 @@ HPACK_TABLE_TEST()
for (i = 0; i < 256; i++) {
if (reverse_map[i] == -1) {
ck_abort_msg("reverse map at %i mising", i);
ck_abort_msg("reverse map at %i missing", i);
}
}
vendor/CivetWeb/include/civetweb.h
Vendored
+129 -8
View File
@@ -23,9 +23,9 @@
#ifndef CIVETWEB_HEADER_INCLUDED
#define CIVETWEB_HEADER_INCLUDED
#define CIVETWEB_VERSION "1.15"
#define CIVETWEB_VERSION "1.16"
#define CIVETWEB_VERSION_MAJOR (1)
#define CIVETWEB_VERSION_MINOR (15)
#define CIVETWEB_VERSION_MINOR (16)
#define CIVETWEB_VERSION_PATCH (0)
#ifndef CIVETWEB_API
@@ -654,7 +654,7 @@ CIVETWEB_API void *mg_get_thread_pointer(const struct mg_connection *conn);
or write to the connection. */
/* Note: An alternative is to use the init_connection callback
instead to initialize the user connection data pointer. It is
reccomended to supply a pointer to some user defined data structure
recommended to supply a pointer to some user defined data structure
as conn_data initializer in init_connection. In case it is required
to change some data after the init_connection call, store another
data pointer in the user defined data structure and modify that
@@ -1128,7 +1128,7 @@ CIVETWEB_API int mg_get_var2(const char *data,
required to increase this value at compile time.
Parameters:
data: form encoded iput string. Will be modified by this function.
data: form encoded input string. Will be modified by this function.
form_fields: output list of name/value-pairs. A buffer with a size
specified by num_form_fields must be provided by the
caller.
@@ -1341,6 +1341,22 @@ CIVETWEB_API int mg_url_decode(const char *src,
CIVETWEB_API int mg_url_encode(const char *src, char *dst, size_t dst_len);
/* BASE64-encode input buffer into destination buffer.
returns -1 on OK. */
CIVETWEB_API int mg_base64_encode(const unsigned char *src,
size_t src_len,
char *dst,
size_t *dst_len);
/* BASE64-decode input buffer into destination buffer.
returns -1 on OK. */
CIVETWEB_API int mg_base64_decode(const char *src,
size_t src_len,
unsigned char *dst,
size_t *dst_len);
/* MD5 hash given strings.
Buffer 'buf' must be 33 bytes long. Varargs is a NULL terminated list of
ASCIIz strings. When function returns, buf will contain human-readable
@@ -1350,6 +1366,40 @@ CIVETWEB_API int mg_url_encode(const char *src, char *dst, size_t dst_len);
CIVETWEB_API char *mg_md5(char buf[33], ...);
#if !defined(MG_MATCH_CONTEXT_MAX_MATCHES)
#define MG_MATCH_CONTEXT_MAX_MATCHES (32)
#endif
struct mg_match_element {
const char *str; /* First character matching wildcard */
size_t len; /* Number of character matching wildcard */
};
struct mg_match_context {
int case_sensitive; /* Input: 1 (case sensitive) or 0 (insensitive) */
size_t num_matches; /* Output: Number of wildcard matches returned. */
struct mg_match_element match[MG_MATCH_CONTEXT_MAX_MATCHES]; /* Output */
};
#if defined(MG_EXPERIMENTAL_INTERFACES)
/* Pattern matching and extraction function.
Parameters:
pat: Pattern string (see UserManual.md)
str: String to search for match patterns.
mcx: Match context (optional, can be NULL).
Return:
Number of characters matched.
-1 if no valid match was found.
Note: 0 characters might be a valid match for some patterns.
*/
CIVETWEB_API ptrdiff_t mg_match(const char *pat,
const char *str,
struct mg_match_context *mcx);
#endif
/* Print error message to the opened error log stream.
This utilizes the provided logging configuration.
conn: connection (not used for sending data, but to get perameters)
@@ -1505,6 +1555,7 @@ CIVETWEB_API int mg_get_response(struct mg_connection *conn,
* -1: parameter error
* -2: invalid connection type
* -3: invalid connection status
* -4: network error (only if built with NO_RESPONSE_BUFFERING)
*/
CIVETWEB_API int mg_response_header_start(struct mg_connection *conn,
int status);
@@ -1557,6 +1608,7 @@ CIVETWEB_API int mg_response_header_add_lines(struct mg_connection *conn,
* -1: parameter error
* -2: invalid connection type
* -3: invalid connection status
* -4: sending failed (network error)
*/
CIVETWEB_API int mg_response_header_send(struct mg_connection *conn);
@@ -1600,7 +1652,7 @@ CIVETWEB_API unsigned mg_check_feature(unsigned feature);
buffer: Store system information as string here.
buflen: Length of buffer (including a byte required for a terminating 0).
Return:
Available size of system information, exluding a terminating 0.
Available size of system information, excluding a terminating 0.
The information is complete, if the return value is smaller than buflen.
The result is a JSON formatted string, the exact content may vary.
Note:
@@ -1617,7 +1669,7 @@ CIVETWEB_API int mg_get_system_info(char *buffer, int buflen);
buffer: Store context information here.
buflen: Length of buffer (including a byte required for a terminating 0).
Return:
Available size of system information, exluding a terminating 0.
Available size of system information, excluding a terminating 0.
The information is complete, if the return value is smaller than buflen.
The result is a JSON formatted string, the exact content may vary.
Note:
@@ -1646,7 +1698,7 @@ CIVETWEB_API void mg_disable_connection_keep_alive(struct mg_connection *conn);
buffer: Store context information here.
buflen: Length of buffer (including a byte required for a terminating 0).
Return:
Available size of system information, exluding a terminating 0.
Available size of system information, excluding a terminating 0.
The information is complete, if the return value is smaller than buflen.
The result is a JSON formatted string, the exact content may vary.
Note:
@@ -1669,11 +1721,80 @@ CIVETWEB_API int mg_get_connection_info(const struct mg_context *ctx,
Note: Experimental interfaces may change
*/
struct mg_error_data {
unsigned *code; /* error code (number) */
unsigned code; /* error code (number) */
unsigned code_sub; /* error sub code (number) */
char *text; /* buffer for error text */
size_t text_buffer_size; /* size of buffer of "text" */
};
/* Values for error "code" in mg_error_data */
enum {
/* No error */
MG_ERROR_DATA_CODE_OK = 0u,
/* Caller provided invalid parameter */
MG_ERROR_DATA_CODE_INVALID_PARAM = 1u,
/* "configuration_option" contains invalid element */
MG_ERROR_DATA_CODE_INVALID_OPTION = 2u,
/* Initializen TLS / SSL library failed */
MG_ERROR_DATA_CODE_INIT_TLS_FAILED = 3u,
/* Mandatory "configuration_option" missing */
MG_ERROR_DATA_CODE_MISSING_OPTION = 4u,
/* Duplicate "authentication_domain" option */
MG_ERROR_DATA_CODE_DUPLICATE_DOMAIN = 5u,
/* Not enough memory */
MG_ERROR_DATA_CODE_OUT_OF_MEMORY = 6u,
/* Server already stopped */
MG_ERROR_DATA_CODE_SERVER_STOPPED = 7u,
/* mg_init_library must be called first */
MG_ERROR_DATA_CODE_INIT_LIBRARY_FAILED = 8u,
/* Operating system function failed */
MG_ERROR_DATA_CODE_OS_ERROR = 9u,
/* Failed to bind to server ports */
MG_ERROR_DATA_CODE_INIT_PORTS_FAILED = 10u,
/* Failed to switch user (option "run_as_user") */
MG_ERROR_DATA_CODE_INIT_USER_FAILED = 11u,
/* Access Control List error */
MG_ERROR_DATA_CODE_INIT_ACL_FAILED = 12u,
/* Global password file error */
MG_ERROR_DATA_CODE_INVALID_PASS_FILE = 13u,
/* Lua background script init error */
MG_ERROR_DATA_CODE_SCRIPT_ERROR = 14u,
/* Client: Host not found, invalid IP to connect */
MG_ERROR_DATA_CODE_HOST_NOT_FOUND = 15u,
/* Client: TCP connect timeout */
MG_ERROR_DATA_CODE_CONNECT_TIMEOUT = 16u,
/* Client: TCP connect failed */
MG_ERROR_DATA_CODE_CONNECT_FAILED = 17u,
/* Error using TLS client certificate */
MG_ERROR_DATA_CODE_TLS_CLIENT_CERT_ERROR = 18u,
/* Error setting trusted TLS server certificate for client connection */
MG_ERROR_DATA_CODE_TLS_SERVER_CERT_ERROR = 19u,
/* Error establishing TLS connection to HTTPS server */
MG_ERROR_DATA_CODE_TLS_CONNECT_ERROR = 20u
};
struct mg_init_data {
const struct mg_callbacks *callbacks; /* callback function pointer */
void *user_data; /* data */
vendor/CivetWeb/match.inl
Vendored
+262
View File
@@ -0,0 +1,262 @@
/* Reimplementation of pattern matching */
/* This file is part of the CivetWeb web server.
* See https://github.com/civetweb/civetweb/
*/
/* Initialize structure with 0 matches */
static void
match_context_reset(struct mg_match_context *mcx)
{
mcx->num_matches = 0;
memset(mcx->match, 0, sizeof(mcx->match));
}
/* Add a new match to the list of matches */
static void
match_context_push(const char *str, size_t len, struct mg_match_context *mcx)
{
if (mcx->num_matches < MG_MATCH_CONTEXT_MAX_MATCHES) {
mcx->match[mcx->num_matches].str = str;
mcx->match[mcx->num_matches].len = len;
mcx->num_matches++;
}
}
static ptrdiff_t
mg_match_impl(const char *pat,
size_t pat_len,
const char *str,
struct mg_match_context *mcx)
{
/* Parse string */
size_t i_pat = 0; /* Pattern index */
size_t i_str = 0; /* Pattern index */
int case_sensitive = ((mcx != NULL) ? mcx->case_sensitive : 0); /* 0 or 1 */
while (i_pat < pat_len) {
/* Pattern ? matches one character, except / and NULL character */
if ((pat[i_pat] == '?') && (str[i_str] != '\0')
&& (str[i_str] != '/')) {
size_t i_str_start = i_str;
do {
/* Advance as long as there are ? */
i_pat++;
i_str++;
} while ((pat[i_pat] == '?') && (str[i_str] != '\0')
&& (str[i_str] != '/') && (i_pat < pat_len));
/* If we have a match context, add the substring we just found */
if (mcx) {
match_context_push(str + i_str_start, i_str - i_str_start, mcx);
}
/* Reached end of pattern ? */
if (i_pat == pat_len) {
return (ptrdiff_t)i_str;
}
}
/* Pattern $ matches end of string */
if (pat[i_pat] == '$') {
return (str[i_str] == '\0') ? (ptrdiff_t)i_str : -1;
}
/* Pattern * or ** matches multiple characters */
if (pat[i_pat] == '*') {
size_t len; /* length matched by "*" or "**" */
ptrdiff_t ret;
i_pat++;
if ((pat[i_pat] == '*') && (i_pat < pat_len)) {
/* Pattern ** matches all */
i_pat++;
len = strlen(str + i_str);
} else {
/* Pattern * matches all except / character */
len = strcspn(str + i_str, "/");
}
if (i_pat == pat_len) {
/* End of pattern reached. Add all to match context. */
if (mcx) {
match_context_push(str + i_str, len, mcx);
}
return (i_str + len);
}
/* This loop searches for the longest possible match */
do {
ret = mg_match_impl(pat + i_pat,
(pat_len - (size_t)i_pat),
str + i_str + len,
mcx);
} while ((ret == -1) && (len-- > 0));
/* If we have a match context, add the substring we just found */
if (ret >= 0) {
if (mcx) {
match_context_push(str + i_str, len, mcx);
}
return (i_str + ret + len);
}
return -1;
}
/* Single character compare */
if (case_sensitive) {
if (pat[i_pat] != str[i_str]) {
/* case sensitive compare: mismatch */
return -1;
}
} else if (lowercase(&pat[i_pat]) != lowercase(&str[i_str])) {
/* case insensitive compare: mismatch */
return -1;
}
i_pat++;
i_str++;
}
return (ptrdiff_t)i_str;
}
static ptrdiff_t
mg_match_alternatives(const char *pat,
size_t pat_len,
const char *str,
struct mg_match_context *mcx)
{
const char *match_alternative = (const char *)memchr(pat, '|', pat_len);
if (mcx != NULL) {
match_context_reset(mcx);
}
while (match_alternative != NULL) {
/* Split at | for alternative match */
size_t left_size = (size_t)(match_alternative - pat);
/* Try left string first */
ptrdiff_t ret = mg_match_impl(pat, left_size, str, mcx);
if (ret >= 0) {
/* A 0-byte match is also valid */
return ret;
}
/* Reset possible incomplete match data */
if (mcx != NULL) {
match_context_reset(mcx);
}
/* If no match: try right side */
pat += left_size + 1;
pat_len -= left_size + 1;
match_alternative = (const char *)memchr(pat, '|', pat_len);
}
/* Handled all | operators. This is the final string. */
return mg_match_impl(pat, pat_len, str, mcx);
}
static int
match_compare(const void *p1, const void *p2, void *user)
{
const struct mg_match_element *e1 = (const struct mg_match_element *)p1;
const struct mg_match_element *e2 = (const struct mg_match_element *)p2;
/* unused */
(void)user;
if (e1->str > e2->str) {
return +1;
}
if (e1->str < e2->str) {
return -1;
}
return 0;
}
#if defined(MG_EXPERIMENTAL_INTERFACES)
CIVETWEB_API
#else
static
#endif
ptrdiff_t
mg_match(const char *pat, const char *str, struct mg_match_context *mcx)
{
size_t pat_len = strlen(pat);
ptrdiff_t ret = mg_match_alternatives(pat, pat_len, str, mcx);
if (mcx != NULL) {
if (ret < 0) {
/* Remove possible incomplete data */
match_context_reset(mcx);
} else {
/* Join "?*" to one pattern. */
size_t i, j;
/* Use difference of two array elements instead of sizeof, since
* there may be some additional padding bytes. */
size_t elmsize =
(size_t)(&mcx->match[1]) - (size_t)(&mcx->match[0]);
/* First sort the matches by address ("str" begin to end) */
mg_sort(mcx->match, mcx->num_matches, elmsize, match_compare, NULL);
/* Join consecutive matches */
i = 1;
while (i < mcx->num_matches) {
if ((mcx->match[i - 1].str + mcx->match[i - 1].len)
== mcx->match[i].str) {
/* Two matches are consecutive. Join length. */
mcx->match[i - 1].len += mcx->match[i].len;
/* Shift all list elements. */
for (j = i + 1; j < mcx->num_matches; j++) {
mcx->match[j - 1].len = mcx->match[j].len;
mcx->match[j - 1].str = mcx->match[j].str;
}
/* Remove/blank last list element. */
mcx->num_matches--;
mcx->match[mcx->num_matches].str = NULL;
mcx->match[mcx->num_matches].len = 0;
} else {
i++;
}
}
}
}
return ret;
}
static ptrdiff_t
match_prefix(const char *pattern, size_t pattern_len, const char *str)
{
if (pattern == NULL) {
return -1;
}
return mg_match_alternatives(pattern, pattern_len, str, NULL);
}
static ptrdiff_t
match_prefix_strlen(const char *pattern, const char *str)
{
if (pattern == NULL) {
return -1;
}
return mg_match_alternatives(pattern, strlen(pattern), str, NULL);
}
/* End of match.inl */
vendor/CivetWeb/md5.inl
Vendored
+2 -1
View File
@@ -131,6 +131,7 @@ MD5_STATIC void md5_finish(md5_state_t *pms, md5_byte_t digest[16]);
*/
#if !defined(MD5_STATIC)
#include <stdint.h>
#include <string.h>
#endif
@@ -239,7 +240,7 @@ md5_process(md5_state_t *pms, const md5_byte_t *data /*[64]*/)
* On little-endian machines, we can process properly aligned
* data without copying it.
*/
if (!((data - (const md5_byte_t *)0) & 3)) {
if (!(((uintptr_t)data) & 3)) {
/* data are properly aligned, a direct assignment is possible */
/* cast through a (void *) should avoid a compiler warning,
see
vendor/CivetWeb/mod_zlib.inl
Vendored
+1 -1
View File
@@ -12,7 +12,7 @@ zalloc(void *opaque, uInt items, uInt size)
{
struct mg_connection *conn = (struct mg_connection *)opaque;
void *ret = mg_calloc_ctx(items, size, conn->phys_ctx);
(void)conn; /* mg_calloc_ctx makro might not need it */
(void)conn; /* mg_calloc_ctx macro might not need it */
return ret;
}
vendor/CivetWeb/response.inl
Vendored
+22 -6
View File
@@ -37,7 +37,7 @@ free_buffered_response_header_list(struct mg_connection *conn)
/* Send first line of HTTP/1.x response */
static void
static int
send_http1_response_status_line(struct mg_connection *conn)
{
const char *status_txt;
@@ -55,7 +55,13 @@ send_http1_response_status_line(struct mg_connection *conn)
/* mg_get_response_code_text will never return NULL */
status_txt = mg_get_response_code_text(conn, conn->status_code);
mg_printf(conn, "HTTP/%s %i %s\r\n", http_version, status_code, status_txt);
if (mg_printf(
conn, "HTTP/%s %i %s\r\n", http_version, status_code, status_txt)
< 10) {
/* Network sending failed */
return 0;
}
return 1;
}
@@ -68,10 +74,12 @@ send_http1_response_status_line(struct mg_connection *conn)
* -1: parameter error
* -2: invalid connection type
* -3: invalid connection status
* -4: network error (only if built with NO_RESPONSE_BUFFERING)
*/
int
mg_response_header_start(struct mg_connection *conn, int status)
{
int ret = 0;
if ((conn == NULL) || (status < 100) || (status > 999)) {
/* Parameter error */
return -1;
@@ -93,11 +101,13 @@ mg_response_header_start(struct mg_connection *conn, int status)
#if !defined(NO_RESPONSE_BUFFERING)
free_buffered_response_header_list(conn);
#else
send_http1_response_status_line(conn);
if (!send_http1_response_status_line(conn)) {
ret = -4;
};
conn->request_state = 1; /* Reset from 10 to 1 */
#endif
return 0;
return ret;
}
@@ -254,6 +264,7 @@ static int http2_send_response_headers(struct mg_connection *conn);
* -1: parameter error
* -2: invalid connection type
* -3: invalid connection status
* -4: network send failed
*/
int
mg_response_header_send(struct mg_connection *conn)
@@ -285,12 +296,16 @@ mg_response_header_send(struct mg_connection *conn)
#if defined(USE_HTTP2)
if (conn->protocol_type == PROTOCOL_TYPE_HTTP2) {
int ret = http2_send_response_headers(conn);
return ret ? 0 : 0; /* todo */
free_buffered_response_header_list(conn);
return (ret ? 0 : -4);
}
#endif
/* Send */
send_http1_response_status_line(conn);
if (!send_http1_response_status_line(conn)) {
free_buffered_response_header_list(conn);
return -4;
};
for (i = 0; i < conn->response_info.num_headers; i++) {
mg_printf(conn,
"%s: %s\r\n",
@@ -322,5 +337,6 @@ mg_response_header_send(struct mg_connection *conn)
conn->request_state = 3;
/* ok */
free_buffered_response_header_list(conn);
return 0;
}
vendor/CivetWeb/sort.inl
Vendored
+48
View File
@@ -0,0 +1,48 @@
/* Sort function. */
/* from https://github.com/bel2125/sort_r */
static void
mg_sort(void *data,
size_t elemcount,
size_t elemsize,
int (*compfunc)(const void *data1, const void *data2, void *userarg),
void *userarg)
{
/* We cannot use qsort_r here. For a detailed reason, see
* https://github.com/civetweb/civetweb/issues/1048#issuecomment-1047093014
* https://stackoverflow.com/questions/39560773/different-declarations-of-qsort-r-on-mac-and-linux
*/
/* We use ShellSort here with this gap sequence: https://oeis.org/A102549 */
int A102549[9] = {1, 4, 10, 23, 57, 132, 301, 701, 1750};
int Aidx, gap, i, j, k;
void *tmp = alloca(elemsize);
for (Aidx = 8; Aidx >= 0; Aidx--) {
gap = A102549[Aidx];
if (gap > ((int)elemcount / 2)) {
continue;
}
for (i = 0; i < gap; i++) {
for (j = i; j < (int)elemcount; j += gap) {
memcpy(tmp, (void *)((ptrdiff_t)data + elemsize * j), elemsize);
for (k = j; k >= gap; k -= gap) {
void *cmp =
(void *)((ptrdiff_t)data + elemsize * (k - gap));
int cmpres = compfunc(cmp, tmp, userarg);
if (cmpres > 0) {
memcpy((void *)((ptrdiff_t)data + elemsize * k),
cmp,
elemsize);
} else {
break;
}
}
memcpy((void *)((ptrdiff_t)data + elemsize * k), tmp, elemsize);
}
}
}
}
/* end if sort.inl */
vendor/DPP/CMakeLists.txt
Vendored
+93
View File
@@ -0,0 +1,93 @@
#
# D++ (DPP), The Lightweight C++ Discord Library
#
# Copyright 2021 Craig Edwards <support@brainbox.cc>
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
cmake_minimum_required (VERSION 3.16)
option(BUILD_SHARED_LIBS "Build shared libraries" ON)
option(BUILD_VOICE_SUPPORT "Build voice support" ON)
option(RUN_LDCONFIG "Run ldconfig after installation" ON)
option(DPP_INSTALL "Generate the install target" ON)
option(DPP_BUILD_TEST "Build the test program" ON)
option(DPP_NO_VCPKG "No VCPKG" OFF)
option(DPP_CORO "Experimental support for C++20 coroutines" OFF)
option(DPP_USE_EXTERNAL_JSON "Use an external installation of nlohmann::json" OFF)
include(CheckCXXSymbolExists)
set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
add_compile_definitions(DPP_BUILD)
file(READ "${CMAKE_CURRENT_SOURCE_DIR}/include/dpp/version.h" version_h)
if(NOT version_h MATCHES "DPP_VERSION_SHORT ([0-9][0-9])([0-9][0-9])([0-9][0-9])")
message(FATAL_ERROR "Cannot get DPP_VERSION_SHORT from version.h")
endif()
math(EXPR DPP_VERSION_MAJOR "${CMAKE_MATCH_1}")
math(EXPR DPP_VERSION_MINOR "${CMAKE_MATCH_2}")
math(EXPR DPP_VERSION_PATCH "${CMAKE_MATCH_3}")
string(CONCAT DPP_VERSION "${DPP_VERSION_MAJOR}.${DPP_VERSION_MINOR}.${DPP_VERSION_PATCH}")
set(CMAKE_MODULE_PATH "${CMAKE_MODULE_PATH};${CMAKE_SOURCE_DIR}/cmake/")
if (DPP_NO_VCPKG)
message("-- INFO: Explicitly disabling VCPKG as running inside the CI action.")
else()
message("-- INFO: Using VCPKG if detected")
endif()
if (WIN32 AND NOT MINGW AND BUILD_SHARED_LIBS)
message("-- INFO: Configuring .rc resource script")
configure_file("${CMAKE_CURRENT_SOURCE_DIR}/src/dpp/dpp.rc.in" "${CMAKE_CURRENT_SOURCE_DIR}/src/dpp/dpp.rc" NEWLINE_STYLE WIN32)
endif()
if (NOT DPP_NO_VCPKG AND EXISTS "${_VCPKG_ROOT_DIR}")
set(PROJECT_NAME "dpp")
project(
"${PROJECT_NAME}"
VERSION "${DPP_VERSION}"
LANGUAGES CXX
HOMEPAGE_URL "https://dpp.dev/"
DESCRIPTION "An incredibly lightweight C++ Discord library."
)
add_subdirectory(library-vcpkg)
else()
set(PROJECT_NAME "libdpp")
project(
"${PROJECT_NAME}"
VERSION "${DPP_VERSION}"
LANGUAGES CXX
HOMEPAGE_URL "https://dpp.dev/"
DESCRIPTION "An incredibly lightweight C++ Discord library."
)
add_subdirectory(library)
endif()
if(DPP_USE_EXTERNAL_JSON)
# We do nothing here, we just assume it is on the include path.
# nlohmann::json's cmake stuff does all kinds of weird, and is more hassle than it's worth.
# This functionality is here mostly for package maintainers so if you enable it you should
# know what you are doing.
message("-- Using external nlohmann::json")
target_compile_definitions(dpp PUBLIC DPP_USE_EXTERNAL_JSON)
else()
# Add the nlohmann single include to the include path. Note that nlohmann::json is kinda
# fussy, this is an older version because trying to use v3.11.2 gave a bunch of parse errors
# that made no sense, it seems they may have changed their parsing rules somehow.
message("-- Using bundled nlohmann::json")
endif()
vendor/DPP/CMakeSettings.json
Vendored
+15
View File
@@ -0,0 +1,15 @@
{
"configurations": [
{
"name": "x64-Debug",
"generator": "Ninja",
"configurationType": "Release",
"inheritEnvironments": [ "msvc_x64_x64" ],
"buildRoot": "${projectDir}\\out\\build\\${name}",
"installRoot": "${projectDir}\\out\\install\\${name}",
"cmakeCommandArgs": "",
"buildCommandArgs": "",
"ctestCommandArgs": ""
}
]
}

Some files were not shown because too many files have changed in this diff Show More