CommonLibSSE (Parapets fork)
Classes | Namespaces | Macros | Typedefs | Functions | Variables
PCH.h File Reference
#include <algorithm>
#include <array>
#include <bit>
#include <bitset>
#include <cassert>
#include <cmath>
#include <concepts>
#include <coroutine>
#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 <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 <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 <binary_io/file_stream.hpp>
#include <boost/stl_interfaces/iterator_interface.hpp>
#include <fmt/format.h>
#include <spdlog/spdlog.h>
#include "SKSE/Impl/WinAPI.h"
#include "REL/Relocation.h"
#include "RE/Offsets.h"
#include "RE/Offsets_NiRTTI.h"
#include "RE/Offsets_RTTI.h"
#include "RE/B/BSCoreTypes.h"
#include "RE/S/SFTypes.h"

Go to the source code of this file.

Classes

struct  SKSE::stl::nttp::string< CharT, N >
 
struct  SKSE::stl::nttp::zstring< CharT, N >
 
class  SKSE::stl::enumeration< Enum, Underlying >
 
class  SKSE::stl::atomic_ref< T >
 
struct  SKSE::stl::ssizeof< T >
 

Namespaces

 SKSE
 
 SKSE::stl
 
 SKSE::stl::nttp
 
 RE
 
 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)
 

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
 

Functions

template<class CharT , std::size_t N>
 SKSE::stl::nttp::string (const CharT(&)[N]) -> string< CharT, N - 1 >
 
template<class EF >
 SKSE::stl::requires (std::invocable< std::remove_reference_t< EF >>) class scope_exit
 
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 >
void SKSE::stl::memzero (volatile T *a_ptr, std::size_t a_size=sizeof(T))
 
template<class... Args>
auto SKSE::stl::pun_bits (Args... a_args) requires(std
 
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 >
 
void SKSE::stl::report_and_fail (std::string_view a_msg, std::source_location a_loc=std::source_location::current())
 
template<class Enum >
constexpr auto SKSE::stl::to_underlying (Enum a_val) noexcept requires(std
 
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

◆ 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; \
}