#include <algorithm>
#include <array>
#include <bit>
#include <bitset>
#include <cassert>
#include <cmath>
#include <concepts>
#include <cstdarg>
#include <cstddef>
#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <cwchar>
#include <cwctype>
#include <exception>
#include <execution>
#include <filesystem>
#include <format>
#include <fstream>
#include <functional>
#include <iomanip>
#include <ios>
#include <istream>
#include <iterator>
#include <limits>
#include <locale>
#include <map>
#include <memory>
#include <mutex>
#include <new>
#include <numeric>
#include <optional>
#include <random>
#include <regex>
#include <set>
#include <source_location>
#include <span>
#include <sstream>
#include <stack>
#include <stdexcept>
#include <string>
#include <string_view>
#include <system_error>
#include <thread>
#include <tuple>
#include <type_traits>
#include <typeinfo>
#include <utility>
#include <variant>
#include <vector>
#include <fmt/format.h>
#include <spdlog/spdlog.h>
#include "SKSE/Impl/DInputAPI.h"
#include "SKSE/Impl/WinAPI.h"
#include "SKSE/Impl/XInputAPI.h"
#include "REL/Relocation.h"
#include "RE/Offsets.h"
#include "RE/Offsets_NiRTTI.h"
#include "RE/Offsets_RTTI.h"
#include "RE/Offsets_VTABLE.h"
#include "RE/B/BSCoreTypes.h"
#include "RE/S/SFTypes.h"

Classes
struct	SKSE::stl::nttp::string< CharT, N >

class	SKSE::stl::scope_exit< EF >

class	SKSE::stl::enumeration< Enum, Underlying >

class	SKSE::stl::atomic_ref< T >

struct	SKSE::stl::ssizeof< T >

Namespaces
namespace	SKSE

namespace	SKSE::stl

namespace	SKSE::stl::nttp

namespace	RE

namespace	REL

Macros
#define	SKSE_MAKE_LOGICAL_OP(a_op, a_result)

#define	SKSE_MAKE_ARITHMETIC_OP(a_op)

#define	SKSE_MAKE_ENUMERATION_OP(a_op)

#define	SKSE_MAKE_INCREMENTER_OP(a_op)

#define	RELOCATION_ID(a_se, a_ae) REL::RelocationID(a_se, a_ae)

Typedefs
template<class CharT >
using	SKSE::stl::basic_zstring = std::basic_string_view< CharT >

using	SKSE::stl::zstring = basic_zstring< char >

using	SKSE::stl::zwstring = basic_zstring< wchar_t >

template<class T , class = std::enable_if_t< std::is_pointer_v<T>>>
using	SKSE::stl::owner = T

template<class T , class = std::enable_if_t< std::is_pointer_v<T>>>
using	SKSE::stl::observer = T

template<class T , class = std::enable_if_t< std::is_pointer_v<T>>>
using	SKSE::stl::not_null = T

using	SKSE::stl::source_location = std::source_location

Functions
template<class CharT , std::size_t N>
	SKSE::stl::nttp::string (const CharT(&)[N]) -> string< CharT, N - 1 >

template<class EF >
	SKSE::stl::scope_exit (EF) -> scope_exit< EF >

template<class... Args>
	SKSE::stl::enumeration (Args...) -> enumeration< std::common_type_t< Args... >, std::underlying_type_t< std::common_type_t< Args... > > >

template<class E , class U >
constexpr auto	SKSE::stl::operator~ (enumeration< E, U > a_enum) noexcept -> enumeration< E, U >

	SKSE::stl::SKSE_MAKE_LOGICAL_OP (==, bool)

	SKSE::stl::SKSE_MAKE_LOGICAL_OP (<=>, std::strong_ordering)

	SKSE::stl::SKSE_MAKE_ARITHMETIC_OP (<<)

	SKSE::stl::SKSE_MAKE_ENUMERATION_OP (<<)

	SKSE::stl::SKSE_MAKE_ARITHMETIC_OP (> >)

	SKSE::stl::SKSE_MAKE_ENUMERATION_OP (> >)

	SKSE::stl::SKSE_MAKE_ENUMERATION_OP (\|)

SKSE_MAKE_ENUMERATION_OP &	SKSE::stl::SKSE_MAKE_ENUMERATION_OP (^);SKSE_MAKE_ENUMERATION_OP(+

	SKSE::stl::SKSE_MAKE_ENUMERATION_OP (-)

	SKSE::stl::SKSE_MAKE_INCREMENTER_OP (+)

	SKSE::stl::SKSE_MAKE_INCREMENTER_OP (-)

template<class T >
	SKSE::stl::atomic_ref (volatile T &) -> atomic_ref< T >

template<class T , class U >
auto	SKSE::stl::adjust_pointer (U *a_ptr, std::ptrdiff_t a_adjust) noexcept

template<class T >
bool	SKSE::stl::emplace_vtable (T *a_ptr)

template<class T >
void	SKSE::stl::memzero (volatile T *a_ptr, std::size_t a_size=sizeof(T))

template<class... Args> requires (std::same_as<std::remove_cv_t<Args>, bool> && ...)
auto	SKSE::stl::pun_bits (Args... a_args)

auto	SKSE::stl::utf8_to_utf16 (std::string_view a_in) noexcept -> std::optional< std::wstring >

auto	SKSE::stl::utf16_to_utf8 (std::wstring_view a_in) noexcept -> std::optional< std::string >

bool	SKSE::stl::report_and_error (std::string_view a_msg, bool a_fail=true, SKSE::stl::source_location a_loc=SKSE::stl::source_location::current())

void	SKSE::stl::report_and_fail (std::string_view a_msg, SKSE::stl::source_location a_loc=SKSE::stl::source_location::current())

template<class Enum > requires (std::is_enum_v<Enum>)
constexpr auto	SKSE::stl::to_underlying (Enum a_val) noexcept

template<class To , class From >
To	SKSE::stl::unrestricted_cast (From a_from) noexcept

Variables
template<class T >
constexpr auto	SKSE::stl::ssizeof_v = ssizeof<T>::value

Macro Definition Documentation

◆ RELOCATION_ID

#define RELOCATION_ID	(	a_se,
		a_ae
	)	REL::RelocationID(a_se, a_ae)

◆ SKSE_MAKE_ARITHMETIC_OP

#define SKSE_MAKE_ARITHMETIC_OP ( a_op )

Value:

    template <class E, class U>                                                              \
    [[nodiscard]] constexpr auto operator a_op(enumeration<E, U> a_enum, U a_shift) noexcept \
        -> enumeration<E, U>                                                                 \
    {                                                                                        \
        return static_cast<E>(static_cast<U>(a_enum.get()) a_op a_shift);                    \
    }                                                                                        \
                                                                                             \
    template <class E, class U>                                                              \
    constexpr auto operator a_op##=(enumeration<E, U>& a_enum, U a_shift) noexcept           \
        -> enumeration<E, U>&                                                                \
    {                                                                                        \
        return a_enum = a_enum a_op a_shift;                                                 \
    }

◆ SKSE_MAKE_ENUMERATION_OP

#define SKSE_MAKE_ENUMERATION_OP ( a_op )

◆ SKSE_MAKE_INCREMENTER_OP

#define SKSE_MAKE_INCREMENTER_OP ( a_op )

Value:

    template <class E, class U>                                                              \
    constexpr auto operator a_op##a_op(enumeration<E, U>& a_lhs) noexcept                    \
        -> enumeration<E, U>&                                                                \
    {                                                                                        \
        return a_lhs a_op## = static_cast<E>(1);                                             \
    }                                                                                        \
                                                                                             \
    template <class E, class U>                                                              \
    [[nodiscard]] constexpr auto operator a_op##a_op(enumeration<E, U>& a_lhs, int) noexcept \
        -> enumeration<E, U>                                                                 \
    {                                                                                        \
        const auto tmp = a_lhs;                                                              \
        a_op##a_op a_lhs;                                                                    \
        return tmp;                                                                          \
    }

◆ SKSE_MAKE_LOGICAL_OP

#define SKSE_MAKE_LOGICAL_OP	(	a_op,
		a_result
	)

Value:

    template <class E, class U1, class U2>                                                                      \
    [[nodiscard]] constexpr a_result operator a_op(enumeration<E, U1> a_lhs, enumeration<E, U2> a_rhs) noexcept \
    {                                                                                                           \
        return a_lhs.get() a_op a_rhs.get();                                                                    \
    }                                                                                                           \
                                                                                                                \
    template <class E, class U>                                                                                 \
    [[nodiscard]] constexpr a_result operator a_op(enumeration<E, U> a_lhs, E a_rhs) noexcept                   \
    {                                                                                                           \
        return a_lhs.get() a_op a_rhs;                                                                          \
    }

Classes

Namespaces

Macros

Typedefs

Functions

Variables

Macro Definition Documentation

◆ RELOCATION_ID

◆ SKSE_MAKE_ARITHMETIC_OP

◆ SKSE_MAKE_ENUMERATION_OP

◆ SKSE_MAKE_INCREMENTER_OP

◆ SKSE_MAKE_LOGICAL_OP