fennec-org/fennec
1
1
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

- More Documentation

Browse Source 
- Vulkan Configuration Implementations
 - Fixed build errors on GCC and Clang
This commit is contained in:
Medusa Slockbower
2026-07-18 23:48:00 -04:00
parent ed381c4178
commit cf909624df
164 changed files with 19857 additions and 5872 deletions
Download Patch File Download Diff File Expand all files Collapse all files

22
CMakeLists.txt
View File

@@ -88,7 +88,6 @@ fennec_add_sources(
include/fennec/core/logger.h source/core/logger.cpp
include/fennec/core/version.h
include/fennec/core/system.h
@@ -150,12 +149,14 @@ fennec_add_sources(
include/fennec/lang/declval.h
include/fennec/lang/function.h
include/fennec/lang/hashing.h
include/fennec/lang/integer.h
include/fennec/lang/intrinsics.h
include/fennec/lang/limits.h
include/fennec/lang/numeric_transforms.h
include/fennec/lang/metasequences.h
include/fennec/lang/ranges.h
include/fennec/lang/static_constructor.h
include/fennec/lang/system.h
include/fennec/lang/type_identity.h
include/fennec/lang/type_operators.h
include/fennec/lang/type_sequences.h
@@ -163,7 +164,6 @@ fennec_add_sources(
include/fennec/lang/type_transforms.h
include/fennec/lang/types.h
include/fennec/lang/utility.h
include/fennec/lang/integer.h
include/fennec/lang/assert.h source/lang/assert.cpp
@@ -179,14 +179,15 @@ fennec_add_sources(
# RTTI =================================================================================================================
include/fennec/rtti/typeid.h
include/fennec/rtti/type_data.h
include/fennec/rtti/type.h
include/fennec/rtti/enable.h
include/fennec/rtti/forward.h
include/fennec/rtti/typelist.h
include/fennec/rtti/type_registry.h
include/fennec/rtti/enable.h
include/fennec/rtti/singleton.h
include/fennec/rtti/this_t.h
include/fennec/rtti/type.h
include/fennec/rtti/type_data.h
include/fennec/rtti/type_registry.h
include/fennec/rtti/typeid.h
include/fennec/rtti/typelist.h
include/fennec/rtti/detail/_constants.h
@@ -268,6 +269,7 @@ fennec_add_sources(
include/fennec/string/locale.h
include/fennec/string/cstring.h
include/fennec/string/string.h
include/fennec/string/string_view.h
include/fennec/string/detail/_ctype.h
@@ -314,7 +316,9 @@ add_subdirectory(test)
add_library(fennec STATIC
${FENNEC_SOURCES}
include/fennec/rtti/this_t.h
include/fennec/renderers/vulkan/lib/logical_device.h
include/fennec/renderers/vulkan/lib/physical_device_properties.h
include/fennec/renderers/vulkan/lib/physical_device_features.h
)
add_dependencies(fennec metaprogramming fennec-dependencies)

1
README.md
View File

@@ -155,7 +155,6 @@ is also a viable IDE but involves some extra setup.
|------------------------------|----------------------------------------------------------------------------------------------------------|
| C/C++ Compiler | GCC/G++ is the compiler that fennec is designed around, however, Clang, MSVC, and MinGW may also be used |
| CMake | The build manager used by the engine |
| Volk<sup>[*](#opt)</sup> | The Vulkan loader Volk, includes necessary headers for Vulkan. |
| A build system | Any build system will work, however, `build.sh` uses Ninja by default. |
| A memory debugger | Any memory debugger will work, however, `test.sh` uses Valgrind by default. |
| Doxygen<sup>[*](#opt)</sup> | Doxygen is required for building the documentation for fennec. |

15
cmake/build.cmake
View File

@@ -18,11 +18,22 @@
# this script handles functionality related to the build process and its info
# Acquire the build name
string(TOLOWER ${CMAKE_BUILD_TYPE} FENNEC_BUILD_NAME)
message(STATUS "Build: ${FENNEC_BUILD_NAME}")
# Add build name to the compile definitions
fennec_add_definitions(FENNEC_BUILD_NAME="${FENNEC_BUILD_NAME}")
# Check if building for debug
if(${FENNEC_BUILD_NAME} MATCHES "debug")
list(APPEND FENNEC_COMPILE_DEFINITIONS FENNEC_RELEASE=false)
fennec_add_definitions(FENNEC_RELEASE=false FENNEC_DEBUG=true)
# Release with debug info
elseif(${FENNEC_BUILD_NAME} MATCHES "relwithdebinfo")
fennec_add_definitions(FENNEC_RELEASE=true FENNEC_DEBUG=true)
# Any others are considered release without debugging
else()
list(APPEND FENNEC_COMPILE_DEFINITIONS FENNEC_RELEASE=true)
fennec_add_definitions(FENNEC_RELEASE=true FENNEC_DEBUG=false)
endif()

38
cmake/clang.cmake Normal file
View File

@@ -0,0 +1,38 @@
# ======================================================================================================================
# fennec, a free and open source game engine
# Copyright © 2025 - 2026 Medusa Slockbower
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <https://www.gnu.org/licenses/>.
# ======================================================================================================================
# this script sets flags and variables for llvm compilers
# Receive all warnings and treat as errors
add_compile_options("-Wall" "-Wextra" "-pedantic" "-Werror" "-fms-extensions")
# Use relative directories to hide the user's directory
fennec_add_compile_options("-ffile-prefix-map=${FENNEC_SOURCE_DIR}=.")
# Disable STDLIB, Exceptions, and RTTI, we implement our own. Also include diagnostics and pthread.
fennec_add_link_options("-nostdlib" "-fno-exceptions" "-fno-rtti" "-fdiagnostics-all-candidates" "-pthread")
# Base definitions for Clang
fennec_add_definitions(
_GLIBCXX_INCLUDE_NEXT_C_HEADERS=1
FENNEC_COMPILER_CLANG=1
FENNEC_GLIBC=1
FENNEC_NO_INLINE=[[clang::noinline]]
FENNEC_FUNCTION_NAME=__PRETTY_FUNCTION__
)

18
cmake/compiler.cmake
View File

@@ -18,13 +18,27 @@
# this script finds the compiler being used
# Send a message letting us know the compiler and its version
message(STATUS "Compiler: ${CMAKE_CXX_COMPILER_ID} ${CMAKE_CXX_COMPILER_VERSION}")
# Add definitions for the compiler
fennec_add_definitions(
FENNEC_LONG_COMPILER_NAME="${CMAKE_CXX_COMPILER_ID} ${CMAKE_SYSTEM_NAME} ${CMAKE_SYSTEM_PROCESSOR}"
)
# GCC
if(${CMAKE_CXX_COMPILER_ID} MATCHES "GNU")
set(FENNEC_COMPILER "GCC")
include("${FENNEC_SOURCE_DIR}/cmake/gcc.cmake")
set(FENNEC_COMPILER "GCC")
include("${FENNEC_SOURCE_DIR}/cmake/gcc.cmake")
endif()
# Clang
if(${CMAKE_CXX_COMPILER_ID} MATCHES "Clang")
set(FENNEC_COMPILER "Clang")
include("${FENNEC_SOURCE_DIR}/cmake/clang.cmake")
endif()
# TODO: MSVC & MinGW

5
cmake/gcc.cmake
View File

@@ -18,15 +18,20 @@
# this script sets flags and variables for gnu and gnu-like compilers
# Receive all warnings and treat as errors
add_compile_options("-Wall" "-Wextra" "-pedantic" "-Werror" "-fms-extensions")
# Use relative directories to hide the user's directory
fennec_add_compile_options("-ffile-prefix-map=${FENNEC_SOURCE_DIR}=.")
# Disable STDLIB, Exceptions, and RTTI, we implement our own. Also include diagnostics and pthread.
fennec_add_link_options("-nostdlib" "-fno-exceptions" "-fno-rtti" "-fdiagnostics-all-candidates" "-pthread")
# Base definitions for GCC
fennec_add_definitions(
_GLIBCXX_INCLUDE_NEXT_C_HEADERS=1
FENNEC_COMPILER_GCC=1
FENNEC_GLIBC=1
FENNEC_NO_INLINE=[[gnu::noinline]]
FENNEC_FUNCTION_NAME=__PRETTY_FUNCTION__
)

2
cmake/linux.cmake
View File

@@ -33,9 +33,11 @@ macro(fennec_check_platform)
include/fennec/platform/linux/platform.h source/platform/linux/platform.cpp
)
# Add display and graphics for client builds.
if(FENNEC_USER_CLIENT)
include("${FENNEC_SOURCE_DIR}/cmake/wayland.cmake")
fennec_init_graphics()
fennec_check_wayland()
fennec_init_graphics()
endif()

12
cmake/opengl.cmake
View File

@@ -18,9 +18,10 @@
find_package(OpenGL)
# Check if EGL is desired
if(FENNEC_GRAPHICS_WANT_EGL)
fennec_add_sources(
include/fennec/platform/opengl/egl/fwd.h
include/fennec/platform/opengl/egl/forward.h
include/fennec/platform/opengl/egl/error.h
include/fennec/platform/opengl/egl/context.h source/platform/opengl/egl/context.cpp
include/fennec/platform/opengl/egl/surface.h source/platform/opengl/egl/surface.cpp
@@ -29,15 +30,24 @@ if(FENNEC_GRAPHICS_WANT_EGL)
)
endif()
# Check that we found OpenGL
if(TARGET OpenGL::GL)
# Link & add definitions for OpenGL
fennec_add_link_libraries(OpenGL::GL)
fennec_add_definitions(FENNEC_GRAPHICS_OPENGL=1)
# Cmake Definition for OpenGL detection
set(FENNEC_FOUND_OPENGL TRUE)
# Add OpenGL sources
fennec_add_sources(
include/fennec/platform/opengl/glad/gl.h source/platform/opengl/glad/gl.c
include/fennec/renderers/opengl/glcontext.h source/renderers/opengl/glcontext.cpp
)
else()
# OpenGL is required if included.
message(FATAL_ERROR "No Suitable OpenGL implementation found.")
endif()

2
cmake/platform.cmake
View File

@@ -28,7 +28,7 @@ if(${CMAKE_SYSTEM_NAME} MATCHES "Linux")
include("${FENNEC_SOURCE_DIR}/cmake/linux.cmake")
endif ()
# Graphics APIs
# Include graphics APIs Second time for any platform specific requirements
macro(fennec_init_graphics)
include("${FENNEC_SOURCE_DIR}/cmake/opengl.cmake")
include("${FENNEC_SOURCE_DIR}/cmake/vulkan.cmake")

3
cmake/version.cmake
View File

@@ -18,12 +18,15 @@
# this script contains the main version
# Fennec Version Definition
# These should only get updated whenever a new release occurs
set(FENNEC_VERSION_MAJOR 0)
set(FENNEC_VERSION_MINOR 1)
set(FENNEC_VERSION_PATCH 0)
set(FENNEC_VERSION_STRING "${FENNEC_VERSION_MAJOR}.${FENNEC_VERSION_MINOR}.${FENNEC_VERSION_PATCH}")
math(EXPR FENNEC_VERSION_NUM "(${FENNEC_VERSION_MAJOR} << 16) | (${FENNEC_VERSION_MINOR} << 8) | ${FENNEC_VERSION_PATCH}")
# Define the versions for compilation
list(APPEND FENNEC_COMPILE_DEFINITIONS
FENNEC_VERSION_MAJOR=${FENNEC_VERSION_MAJOR}
FENNEC_VERSION_MINOR=${FENNEC_VERSION_MINOR}

31
cmake/vulkan.cmake
View File

@@ -16,24 +16,41 @@
# along with this program. If not, see <https://www.gnu.org/licenses/>.
# ======================================================================================================================
find_package(Vulkan COMPONENTS glslang volk)
find_package(Vulkan COMPONENTS glslang)
# MoltenVK for Apple Products
if(FENNEC_GRAPHICS_WANT_MOLTENVK)
find_package(Vulkan COMPONENTS MoltenVK)
endif()
if( TARGET Vulkan::Headers AND TARGET Vulkan::volk # Base Headers and Meta-Loader
# Headers and Loaders
if( TARGET Vulkan::Headers # Base Headers and Meta-Loader
AND TARGET Vulkan::glslang # GLSL Compilation
AND (NOT FENNEC_GRAPHICS_WANT_MOLTENVK OR TARGET Vulkan::MoltenVK)
)
fennec_add_link_libraries(Vulkan::volk Vulkan::glslang)
# Link & Define Vulkan Libraries
fennec_add_link_libraries(Vulkan::glslang)
fennec_add_definitions(FENNEC_GRAPHICS_VULKAN=1)
fennec_add_sources(
include/fennec/renderers/vulkan/lib/app_info.h
include/fennec/renderers/vulkan/lib/instance.h
# Cmake Definition for Vulkan detection
set(FENNEC_FOUND_VULKAN TRUE)
include/fennec/renderers/vulkan/vkcontext.h include/fennec/renderers/vulkan/vkcontext.cpp
# Add Vulkan Sources
fennec_add_sources(
include/fennec/renderers/vulkan/lib/forward.h
include/fennec/renderers/vulkan/lib/app_info.h
include/fennec/renderers/vulkan/lib/debug.h
include/fennec/renderers/vulkan/lib/enum.h
include/fennec/renderers/vulkan/lib/instance.h
include/fennec/renderers/vulkan/lib/physical_device.h
include/fennec/renderers/vulkan/lib/surface.h
include/fennec/platform/vulkan/volk/volk.h source/platform/vulkan/volk/volk.c
include/fennec/renderers/vulkan/vkcontext.h source/renderers/vulkan/vkcontext.cpp
include/fennec/renderers/vulkan/vksurface.h source/renderers/vulkan/vksurface.cpp
)
else()
message(WARNING "No Suitable Vulkan implementation found.")

11
cmake/wayland.cmake
View File

@@ -70,11 +70,12 @@ macro(fennec_check_wayland)
NAMES wayland-egl libwayland-egl
)
# Check that we have found everything needed for Wayland
if( (WAYLAND_CLIENT_INCLUDE_DIR AND WAYLAND_CLIENT_LIBRARY AND WAYLAND_SCANNER)
AND (WAYLAND_EGL_INCLUDE_DIR AND WAYLAND_EGL_LIBRARY))
message(STATUS "Found Wayland: ${WAYLAND_CLIENT_LIBRARY}")
# Wayland Directories
set(WAYLAND_PROTOCOLS_DIR ${FENNEC_SOURCE_DIR}/include/fennec/platform/linux/wayland/lib/protocols)
set(WAYLAND_HEADERS_DIR ${FENNEC_SOURCE_DIR}/include/fennec/platform/linux/wayland/lib/headers)
set(WAYLAND_SOURCES_DIR ${FENNEC_SOURCE_DIR}/source/platform/linux/wayland/lib/sources)
@@ -117,7 +118,7 @@ macro(fennec_check_wayland)
include/fennec/platform/linux/wayland/lib/loader.h source/platform/linux/wayland/lib/loader.cpp
# Fennec Files
include/fennec/platform/linux/wayland/fwd.h
include/fennec/platform/linux/wayland/forward.h
include/fennec/platform/linux/wayland/server.h source/platform/linux/wayland/server.cpp
include/fennec/platform/linux/wayland/window.h source/platform/linux/wayland/window.cpp
@@ -126,6 +127,12 @@ macro(fennec_check_wayland)
include/fennec/platform/linux/wayland/egl/surface.h source/platform/linux/wayland/egl/surface.cpp
)
if(FENNEC_FOUND_VULKAN)
fennec_add_sources(
include/fennec/platform/linux/wayland/vulkan/context.h source/platform/linux/wayland/vulkan/context.cpp
)
endif ()
fennec_add_definitions(
FENNEC_HAS_WAYLAND=1
FENNEC_LIB_WAYLAND="${WAYLAND_CLIENT_LIBRARY}"

3
doxy/Doxyfile.in
View File

@@ -283,7 +283,8 @@ TAB_SIZE = 4
# with the commands \{ and \} for these it is advised to use the version @{ and
# @} or use a double escape (\\{ and \\})
ALIASES =
ALIASES = emph{1}="\f$\textbf{\1}\f$" \
math{1}="\f$\1\f$"
# Set the OPTIMIZE_OUTPUT_FOR_C tag to YES if your project consists of C sources
# only. Doxygen will then generate output that is more tailored for C. For

79
include/fennec/containers/array.h
View File

@@ -44,20 +44,19 @@ namespace fennec
/// \brief Data Structure that defines a compile-time allocated array
///
/// \details
/// | Property | Value |
/// |:-----------:|:----------:|
/// | stable | ✅ |
/// | dynamic | ⛔ |
/// | homogeneous | ✅ |
/// | distinct | ⛔ |
/// | ordered | ⛔ |
/// | space | \f$O(N)\f$ |
/// | linear | ✅ |
/// | access | \f$O(1)\f$ |
/// | find | \f$O(N)\f$ |
/// | insertion | ⛔ |
/// | deletion | ⛔ |
/// | space | \f$O(N)\f$ |
/// | Property | Value |
/// |:-----------:|:-----------:|
/// | stable | ✅ |
/// | dynamic | ⛔ |
/// | homogeneous | ✅ |
/// | distinct | ⛔ |
/// | ordered | ⛔ |
/// | linear | ✅ |
/// | space | \emph{O(N)} |
/// | access | \emph{O(1)} |
/// | find | \emph{O(N)} |
/// | insertion | ⛔ |
/// | deletion | ⛔ |
///
/// \tparam ValueT value type
/// \tparam N number of elements
@@ -70,7 +69,7 @@ public:
/// \name Definitions
/// @{
using value_t = ValueT; //!< Alias for \f$ValueT\f$
using value_t = ValueT; //!< Alias for \emph{ValueT}
/// @}
@@ -96,21 +95,21 @@ public:
///
/// \brief Returns the number of elements in the array.
/// \returns \f$N\f$
/// \returns \emph{N}
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
[[nodiscard]] constexpr size_t size() const { return N; }
constexpr size_t size() const { return N; }
///
/// \brief Returns \f$true\f$ when the array is empty
/// \returns \f$ElemV == 0\f$
/// \brief Returns \emph{true} when the array is empty
/// \returns \math{\textbf{ElemV} == 0}
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
[[nodiscard]] constexpr bool_t is_empty() const { return N == 0; }
constexpr bool_t is_empty() const { return N == 0; }
/// @}
@@ -128,7 +127,7 @@ public:
/// \return reference to the requested element
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr value_t& operator[](size_t i) {
assertd(i < N, "Array Out of Bounds");
@@ -142,7 +141,7 @@ public:
/// \return reference to the requested element
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr const value_t& operator[](size_t i) const {
assertd(i < N, "Array Out of Bounds");
@@ -150,10 +149,10 @@ public:
}
///
/// \returns A reference to \f$data[0]\f$
/// \returns A reference to \math{\textbf{data}[0]}
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr value_t& front() {
return data[0];
@@ -161,20 +160,20 @@ public:
///
/// \brief Access the first element
/// \returns A const-qualified reference to \f$data[0]\f$
/// \returns A const-qualified reference to \math{\textbf{data}[0]}
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr const value_t& front() const {
return data[0];
}
///
/// \returns A reference to \f$data[N - 1]\f$
/// \returns A reference to \math{\textbf{data}[\textbf{N} - 1]}
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr value_t& back() {
return data[N - 1];
@@ -182,10 +181,10 @@ public:
///
/// \brief Access the last element
/// \returns A const-qualified reference to \f$data[N - 1]\f$
/// \returns A const-qualified reference to \math{\textbf{data}[\textbf{N} - 1]}
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr const value_t& back() const {
return data[N - 1];
@@ -205,7 +204,7 @@ public:
/// \brief Checks if all elements in the arrays are equal
///
/// \par Complexity
/// \f$O(N)\f$
/// \emph{O(N)}
///
friend constexpr bool_t operator==(const array& lhs, const array& rhs) {
return array::_compare(lhs, rhs, make_index_metasequence<N>{});
@@ -215,7 +214,7 @@ public:
/// \brief Checks if any element in the arrays is not equal
///
/// \par Complexity
/// \f$O(N)\f$
/// \emph{O(N)}
///
friend constexpr bool_t operator!=(const array& lhs, const array& rhs) {
return not array::_compare(lhs, rhs, make_index_metasequence<N>{});
@@ -234,18 +233,18 @@ public:
/// \returns A pointer to the first element of the array
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr value_t* begin() {
return data;
}
///
/// \brief C++ Iterator Specification \f$begin()\f$
/// \brief C++ Iterator Specification \emph{begin()}
/// \returns A const-qualified pointer to the first element of the array
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr const value_t* begin() const {
return data;
@@ -255,18 +254,18 @@ public:
/// \returns A pointer to one after the end of the array
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr value_t* end() {
return data + N;
}
///
/// \brief C++ Iterator Specification \f$end()\f$
/// \brief C++ Iterator Specification \emph{end()}
/// \returns A const-qualified pointer to one after the end of the array
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr const value_t* end() const {
return data + N;

244
include/fennec/containers/bintree.h
View File

@@ -31,34 +31,34 @@
#ifndef FENNEC_CONTAINERS_BINTREE_H
#define FENNEC_CONTAINERS_BINTREE_H
#include <fennec/memory/allocator.h>
#include <fennec/containers/deque.h>
#include <fennec/containers/list.h>
#include <fennec/containers/optional.h>
#include <fennec/containers/pair.h>
#include <fennec/containers/traversal.h>
#include <fennec/memory/allocator.h>
namespace fennec
{
///
/// \brief Structure defining a binary tree
/// \brief Structure defining an in-array binary tree
///
/// \details
/// | Property | Value |
/// |:-----------:|:----------:|
/// | stable | ⛔ |
/// | dynamic | ✅ |
/// | homogeneous | ✅ |
/// | distinct | ⛔ |
/// | ordered | ⛔ |
/// | space | \f$O(N)\f$ |
/// | linear | ⛔ |
/// | access | \f$O(1)\f$ |
/// | find | \f$O(N)\f$ |
/// | insertion | \f$O(1)\f$ |
/// | deletion | \f$O(1)\f$ |
/// | space | \f$O(N)\f$ |
/// | Property | Value |
/// |:-----------:|:-----------:|
/// | stable | ⛔ |
/// | dynamic | ✅ |
/// | homogeneous | ✅ |
/// | distinct | ⛔ |
/// | ordered | ⛔ |
/// | linear | ⛔ |
/// | space | \emph{O(N)} |
/// | access | \emph{O(1)} |
/// | find | \emph{O(N)} |
/// | insertion | \emph{O(1)} |
/// | deletion | \emph{O(1)} |
///
/// \tparam TypeT The data type
/// \tparam AllocT An allocator class
@@ -107,7 +107,7 @@ public:
/// \details The underlying allocation is not initialized.
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr bintree()
: _table()
@@ -120,10 +120,10 @@ public:
/// \brief Move Constructor, takes ownership of a tree
/// \param tree The tree to take ownership of
///
/// \details Takes ownership of the underlying allocation of \f$tree\f$
/// \details Takes ownership of the underlying allocation of \emph{tree}
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr bintree(bintree&& tree) noexcept
: _table(fennec::move(tree._table))
@@ -136,10 +136,10 @@ public:
/// \brief Copy Constructor, copies a tree
/// \param tree The tree to copy
///
/// \details Copies the contents of \f$tree\f$ into a new tree. Invokes copy constructor.
/// \details Copies the contents of \emph{tree} into a new tree. Invokes copy constructor.
///
/// \par Complexity
/// \f$O(N)\f$
/// \emph{O(N)}
///
constexpr bintree(const bintree& tree)
: _table(tree._table.capacity())
@@ -173,10 +173,10 @@ public:
///
/// \brief Destructor, clears the tree
///
/// \details Clears the contents of \f$tree\f$. Invokes destructor.
/// \details Clears the contents of \emph{tree}. Invokes destructor.
///
/// \par Complexity
/// \f$O(N)\f$
/// \emph{O(N)}
///
constexpr ~bintree() {
clear();
@@ -195,17 +195,17 @@ public:
/// \returns The number of elements in the tree
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr size_t size() const {
return _size;
}
///
/// \returns \f$true\f$ when there are no elements in the tree, \f$false\f$ otherwise.
/// \returns \emph{true} when there are no elements in the tree, \emph{false} otherwise.
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr bool is_empty() const {
return _size == 0;
@@ -215,17 +215,17 @@ public:
/// \returns The capacity of the underlying allocation
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr size_t capacity() const {
return _table.capacity();
}
///
/// \returns The next id to be returned by \f$insert\f$ or \f$emplace\f$.
/// \returns The next id to be returned by `bintree::insert` or `bintree::emplace`.
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr size_t next_id() const {
size_t i = _size;
@@ -236,10 +236,10 @@ public:
}
///
/// \returns The next id to be returned by \f$insert\f$ or \f$emplace\f$.
/// \returns The next id to be returned by `bintree::insert` or `bintree::emplace`.
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr size_t root() const {
return _root;
@@ -257,10 +257,10 @@ public:
///
/// \param i The node id
/// \returns The parent of node \f$i\f$
/// \returns The parent of node \emph{i}
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr size_t parent(size_t i) const {
return i == npos ? npos : _table[i].parent;
@@ -268,10 +268,10 @@ public:
///
/// \param i The node id
/// \returns The grandparent of node \f$i\f$
/// \returns The grandparent of node \emph{i}
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr size_t grandparent(size_t i) const {
return parent(parent(i));
@@ -279,10 +279,10 @@ public:
///
/// \param i The node id
/// \returns The left child of node \f$i\f$
/// \returns The left child of node \emph{i}
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr size_t left(size_t i) const {
return i == npos ? npos : _table[i].child[false];
@@ -290,10 +290,10 @@ public:
///
/// \param i The node id
/// \returns The right child of node \f$i\f$
/// \returns The right child of node \emph{i}
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr size_t right(size_t i) const {
return i == npos ? npos : _table[i].child[true];
@@ -301,11 +301,11 @@ public:
///
/// \param i The node id
/// \param dir The direction to go \f$true\f$ for right, \f$false\f$ for left
/// \returns The child in the direction specified by \f$dir\f$
/// \param dir The direction to go \emph{true} for right, \emph{false} for left
/// \returns The child in the direction specified by \emph{dir}
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr size_t child(size_t i, bool dir) const {
return i == npos ? npos : _table[i].child[dir];
@@ -313,10 +313,10 @@ public:
///
/// \param i The node id
/// \returns \f$true\f$ if \f$i\f$ is the right node of \f$parent(i)\f$, \f$false\f$ otherwise
/// \returns \emph{true} if \emph{i} is the right node of \emph{parent(i)}, \emph{false} otherwise
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr bool side(size_t i) const {
return i == npos ? false : i == right(_parent(i));
@@ -324,10 +324,10 @@ public:
///
/// \param i The id of the node
/// \returns The id of the sibling of \f$i\f$
/// \returns The id of the sibling of \emph{i}
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr size_t sibling(size_t i) const {
if (i == npos) {
@@ -337,16 +337,16 @@ public:
return npos;
}
size_t p = _parent(i);
bool d = i == _right(p);
const bool d = i == _right(p);
return _child(p, !d);
}
///
/// \param i The node id
/// \returns The depth of node \f$i\f$
/// \returns The depth of node \emph{i}
///
/// \par Complexity
/// \f$O(\log n)\f$
/// \emph{O(\log n)}
///
constexpr size_t depth(size_t i) const {
size_t d = 0;
@@ -359,10 +359,10 @@ public:
///
/// \param i The node id
/// \returns The id of the left-most node of \f$i\f$
/// \returns The id of the left-most node of \emph{i}
///
/// \par Complexity
/// \f$O(\log n)\f$
/// \emph{O(\log n)}
///
constexpr size_t left_most(size_t i) const {
if (i >= _table.size()) {
@@ -376,10 +376,10 @@ public:
///
/// \param i The node id
/// \returns The id of the right-most node of \f$i\f$
/// \returns The id of the right-most node of \emph{i}
///
/// \par Complexity
/// \f$O(\log n)\f$
/// \emph{O(\log n)}
///
constexpr size_t right_most(size_t i) const {
if (i >= _table.size()) {
@@ -402,10 +402,10 @@ public:
///
/// \param i The node id
/// \returns a reference to the value of node \f$i\f$
/// \returns a reference to the value of node \emph{i}
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr value_t& operator[](size_t i) {
assertd(i < _table.size(), "Index out of bounds.");
@@ -415,10 +415,10 @@ public:
///
/// \details Node access
/// \param i The node id
/// \returns a reference to the value of node \f$i\f$
/// \returns a reference to the value of node \emph{i}
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr const value_t& operator[](size_t i) const {
assertd(i < _table.size(), "Index out of bounds.");
@@ -435,40 +435,40 @@ public:
/// @{
///
/// \details If the left node of \f$p\f$ already exists, the move assignment operator is used instead
/// \details If the left node of \emph{p} already exists, the move assignment operator is used instead
/// \param p The parent node
/// \param val The object to move into the new node
/// \returns The id of the new node
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr size_t insert_left(size_t p, value_t&& val) {
return this->_insert_left(p, fennec::forward<value_t>(val));
}
///
/// \details If the left node of \f$p\f$ already exists, the copy assignment operator is used instead
/// \details If the left node of \emph{p} already exists, the copy assignment operator is used instead
/// \param p The parent node
/// \param val The object to copy to the new node
/// \returns The id of the new node
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr size_t insert_left(size_t p, const value_t& val) {
return this->_insert_left(p, val);
}
///
/// \brief Left Insertion, constructs a new node as the left child of \f$p\f$
/// \details If the left node of \f$p\f$ already exists, the move assignment operator is used instead
/// \brief Left Insertion, constructs a new node as the left child of \emph{p}
/// \details If the left node of \emph{p} already exists, the move assignment operator is used instead
/// \param p The parent node
/// \param args The arguments to construct the new node with
/// \returns The id of the new node
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
template<typename...ArgsT>
constexpr size_t emplace_left(size_t p, ArgsT&&...args) {
@@ -476,40 +476,40 @@ public:
}
///
/// \details If the right node of \f$p\f$ already exists, the move assignment operator is used instead
/// \details If the right node of \emph{p} already exists, the move assignment operator is used instead
/// \param p The parent node
/// \param val The object to move into the new node
/// \returns The id of the new node
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr size_t insert_right(size_t p, value_t&& val) {
return this->_insert_right(p, fennec::forward<value_t>(val));
}
///
/// \details If the right node of \f$p\f$ already exists, the copy assignment operator is used instead
/// \details If the right node of \emph{p} already exists, the copy assignment operator is used instead
/// \param p The parent node
/// \param val The object to copy to the new node
/// \returns The id of the new node
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr size_t insert_right(size_t p, const value_t& val) {
return this->_insert_right(p, val);
}
///
/// \brief Right Insertion, constructs a new node as the right child of \f$p\f$
/// \details If the right node of \f$p\f$ already exists, the move assignment operator is used instead
/// \brief Right Insertion, constructs a new node as the right child of \emph{p}
/// \details If the right node of \emph{p} already exists, the move assignment operator is used instead
/// \param p The parent node
/// \param args The arguments to construct the new node with
/// \returns The id of the new node
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
template<typename...ArgsT>
constexpr size_t emplace_right(size_t p, ArgsT&&...args) {
@@ -519,21 +519,21 @@ public:
///
/// \brief Perform a Tree Rotation at \f$i\f$ in the specified direction
/// \brief Perform a Tree Rotation at \emph{i} in the specified direction
/// \param sub The root node for the rotation
/// \param dir The direction to rotate, \f$true\f$ for right, \f$false\f$ for left
/// \param dir The direction to rotate, \emph{true} for right, \emph{false} for left
/// \returns the new root node
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr size_t rotate(size_t sub, bool dir) {
if (sub == npos) {
return npos;
}
size_t sub_parent = _parent(sub);
size_t new_root = _child(sub, not dir);
size_t new_child = _child(new_root, dir);
const size_t sub_parent = _parent(sub);
const size_t new_root = _child(sub, not dir);
const size_t new_child = _child(new_root, dir);
_child(sub, not dir) = new_child;
if (new_child != npos) {
@@ -552,43 +552,43 @@ public:
}
///
/// \details If the child of \f$p\f$ already exists, the move assignment operator is used instead
/// \details If the child of \emph{p} already exists, the move assignment operator is used instead
/// \param parent The parent node
/// \param side The side to insert on
/// \param val The object to move into the new node
/// \returns The id of the new node
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr size_t insert(size_t parent, bool side, value_t&& val) {
return this->_insert(parent, side, fennec::forward<value_t>(val));
}
///
/// \details If the child of \f$p\f$ already exists, the copy assignment operator is used instead
/// \details If the child of \emph{p} already exists, the copy assignment operator is used instead
/// \param parent The parent node
/// \param side The side to insert on
/// \param val The object to copy to the new node
/// \returns The id of the new node
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr size_t insert(size_t parent, bool side, const value_t& val) {
return this->_insert(parent, side, val);
}
///
/// \brief Insertion, constructs a new node as the child of \f$p\f$
/// \details If the child of \f$p\f$ already exists, the move assignment operator is used instead
/// \brief Insertion, constructs a new node as the child of \emph{p}
/// \details If the child of \emph{p} already exists, the move assignment operator is used instead
/// \param parent The parent node
/// \param side The side to insert on
/// \param args The arguments to construct the new node with
/// \returns The id of the new node
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
template<typename...ArgsT>
constexpr size_t emplace(size_t parent, bool side, ArgsT&&...args) {
@@ -599,7 +599,7 @@ public:
/// \brief Clears the tree, destroying all elements
///
/// \par Complexity
/// \f$O(N)\f$
/// \emph{O(N)}
///
constexpr void clear() {
list<size_t> queue;
@@ -636,16 +636,16 @@ public:
///
/// \details
/// The visitor should accept a reference to a value of type \f$TypeT\f$ and a \f$size_t\f$ which contains the node's id.
/// The visitor should accept a reference to a value of type \emph{TypeT} and a \emph{size_t} which contains the node's id.
/// The visitor should return one of the following values in the `fennec::traversal_control_` enum
///
/// \tparam OrderT The order with which to traverse the tree.
/// \tparam VisitorT The visitor, should fulfill the signature \f$uint8_t visit(TypeT&, size_t)\f$
/// \tparam VisitorT The visitor, should fulfill the signature \emph{uint8_t visit(TypeT&, size_t)}
/// \param visit The visiting object
/// \param i The node to start at
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
template<typename OrderT, typename VisitorT>
constexpr void traverse(VisitorT&& visit, size_t i) {
@@ -667,16 +667,16 @@ public:
/// \brief Traverse the tree using a specified order and visiting functor
///
/// \details
/// The visitor should accept a reference to a value of type \f$TypeT\f$ and a \f$size_t\f$ which contains the node's id.
/// The visitor should accept a reference to a value of type \emph{TypeT} and a \emph{size_t} which contains the node's id.
/// The visitor should return one of the following values in the `fennec::traversal_control_` enum
///
/// \tparam OrderT The order with which to traverse the tree.
/// \tparam VisitorT The visitor, should fulfill the signature \f$uint8_t visit(TypeT&, size_t)\f$
/// \tparam VisitorT The visitor, should fulfill the signature \emph{uint8_t visit(TypeT&, size_t)}
/// \param visit The visiting object
/// \param i The node to start at
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
template<typename OrderT, typename VisitorT>
constexpr void traverse(VisitorT&& visit, size_t i) const {
@@ -717,9 +717,9 @@ public:
return npos;
}
size_t lft = tree.left(tree.parent(node));
size_t nxt = lft == node ? tree.right(tree.parent(node)) : npos;
size_t chd = tree.left(node);
const size_t lft = tree.left(tree.parent(node));
const size_t nxt = lft == node ? tree.right(tree.parent(node)) : npos;
const size_t chd = tree.left(node);
if (nxt != npos && node != head) {
visit.push_front(nxt);
@@ -769,7 +769,7 @@ public:
}
size_t nxt = tree.right(tree.parent(node));
size_t chd = tree.left(node);
const size_t chd = tree.left(node);
nxt = node == nxt ? npos : nxt;
if (nxt != npos && node != head) {
@@ -792,7 +792,7 @@ public:
private:
list<size_t> visit;
size_t head;
size_t head = { 0 };
};
///
@@ -819,9 +819,9 @@ public:
return npos;
}
size_t parent = tree.parent(node);
size_t pright = tree.right(parent);
size_t next = tree.left_most(tree.right(node));
const size_t parent = tree.parent(node);
const size_t pright = tree.right(parent);
const size_t next = tree.left_most(tree.right(node));
if (node != pright && parent != npos) {
visit.push_front(parent);
@@ -843,7 +843,7 @@ public:
private:
list<size_t> visit;
size_t head;
size_t head = { 0 };
};
///
@@ -870,15 +870,15 @@ public:
return npos;
}
size_t parent = tree.parent(node);
size_t pright = tree.right(parent);
const size_t parent = tree.parent(node);
const size_t right = tree.right(parent);
if (node == pright) {
if (node == right) {
if (parent != npos) {
visit.push_front(parent);
}
} else if (pright != npos) {
visit.push_front(this->_successor(tree, pright));
} else if (right != npos) {
visit.push_front(this->_successor(tree, right));
}
if (not visit.is_empty()) {
@@ -894,7 +894,7 @@ public:
private:
list<size_t> visit;
size_t head;
size_t head = { 0 };
constexpr size_t _successor(const bintree& tree, size_t n) {
size_t s = tree.left_most(n);
@@ -919,7 +919,7 @@ public:
/// @{
///
/// \brief C++ Iterator Specification \f$iterator\f$
/// \brief C++ Iterator Specification \emph{iterator}
/// \details Performs pre-order traversal
class iterator {
@@ -954,7 +954,7 @@ public:
///
/// \brief iterator pre-increment operator
/// \returns A reference to self after having stepped to the next node
/// \returns A reference to \emph{this} after having stepped to the next node
iterator& operator++() {
return _n = _order[*_tree, _n, traversal_control_continue], *this;
}
@@ -988,7 +988,7 @@ public:
///
/// \brief iterator equality operator
/// \param it the iterator to compare with
/// \returns \f$true\f$ if iterators are identical, \f$false\f$ otherwise
/// \returns \emph{true} if iterators are identical, \emph{false} otherwise
constexpr bool operator==(const iterator& it) {
return _tree == it._tree and _n == it._n;
}
@@ -996,7 +996,7 @@ public:
///
/// \brief iterator inequality operator
/// \param it the iterator to compare with
/// \returns \f$true\f$ if iterators are different, \f$false\f$ otherwise
/// \returns \emph{true} if iterators are different, \emph{false} otherwise
constexpr bool operator!=(const iterator& it) {
return _tree != it._tree or _n != it._n;
}
@@ -1009,7 +1009,7 @@ public:
///
/// \brief C++ Iterator Specification \f$iterator\f$
/// \brief C++ Iterator Specification \emph{iterator}
/// \details Performs pre-order traversal
class const_iterator {
@@ -1044,7 +1044,7 @@ public:
///
/// \brief iterator pre-increment operator
/// \returns A reference to self after having stepped to the next node
/// \returns A reference to \emph{this} after having stepped to the next node
const_iterator& operator++() {
return _n = _order[*_tree, _n, traversal_control_continue], *this;
}
@@ -1064,7 +1064,7 @@ public:
///
/// \brief iterator equality operator
/// \param it the iterator to compare with
/// \returns \f$true\f$ if iterators are identical, \f$false\f$ otherwise
/// \returns \emph{true} if iterators are identical, \emph{false} otherwise
constexpr bool operator==(const iterator& it) {
return _tree == it._tree and _n == it._n;
}
@@ -1072,7 +1072,7 @@ public:
///
/// \brief iterator inequality operator
/// \param it the iterator to compare with
/// \returns \f$true\f$ if iterators are different, \f$false\f$ otherwise
/// \returns \emph{true} if iterators are different, \emph{false} otherwise
constexpr bool operator!=(const iterator& it) {
return _tree != it._tree or _n != it._n;
}
@@ -1087,18 +1087,18 @@ public:
/// \returns an iterator at the first element in pre-order traversal
///
/// \par Complexity
/// \f$O(\log N)\f$
/// \emph{O(\log N)}
///
iterator begin() {
return iterator(this, _root);
}
///
/// \brief C++ Iterator Specification \f$begin()\f$
/// \brief C++ Iterator Specification \emph{begin()}
/// \returns an iterator at the first element in pre-order traversal
///
/// \par Complexity
/// \f$O(\log N)\f$
/// \emph{O(\log N)}
///
const_iterator begin() const {
return iterator(this, _root);
@@ -1108,18 +1108,18 @@ public:
/// \returns an iterator at the first element in pre-order traversal
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
iterator end() {
return iterator(this, _root, nullid);
}
///
/// \brief C++ Iterator Specification \f$end()\f$
/// \brief C++ Iterator Specification \emph{end()}
/// \returns an iterator at the first element in pre-order traversal
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
const_iterator end() const {
return iterator(this, _root, nullid);
@@ -1228,8 +1228,8 @@ private:
}
constexpr size_t& _sibling(size_t i) {
size_t p = _parent(i);
bool d = i == _right(p);
const size_t p = _parent(i);
const bool d = i == _right(p);
return _child(p, !d);
}

90
include/fennec/containers/bitfield.h
View File

@@ -31,10 +31,11 @@
#ifndef FENNEC_CONTAINERS_BITFIELD_H
#define FENNEC_CONTAINERS_BITFIELD_H
#include <fennec/containers/array.h>
#include <fennec/lang/types.h>
#include <fennec/lang/utility.h>
#include <fennec/containers/array.h>
namespace fennec
{
@@ -42,20 +43,19 @@ namespace fennec
/// \brief Bitfield Container with basic Bit Ops
///
/// \details
/// | Property | Value |
/// |:-----------:|:----------:|
/// | stable | ⛔ |
/// | dynamic | ⛔ |
/// | homogeneous | ✅ |
/// | distinct | ⛔ |
/// | ordered | ⛔ |
/// | space | \f$O(N)\f$ |
/// | linear | ✅ |
/// | access | \f$O(1)\f$ |
/// | find | \f$O(N)\f$ |
/// | insertion | ⛔ |
/// | deletion | ⛔ |
/// | space | \f$O(N)\f$ |
/// | Property | Value |
/// |:-----------:|:-----------:|
/// | stable | ⛔ |
/// | dynamic | ⛔ |
/// | homogeneous | ✅ |
/// | distinct | ⛔ |
/// | ordered | ⛔ |
/// | linear | ✅ |
/// | space | \emph{O(N)} |
/// | access | \emph{O(1)} |
/// | find | \emph{O(N)} |
/// | insertion | ⛔ |
/// | deletion | ⛔ |
///
/// \tparam N The number of bits in the bitfield
template<size_t N>
@@ -81,10 +81,10 @@ public:
///
/// \brief Default constructor.
/// \details Initializes all bits with \f$0\f$.
/// \details Initializes all bits with \emph{0}.
///
/// \par Complexity
/// \f$O(N)\f$
/// \emph{O(N)}
///
constexpr bitfield()
: _bytes() {
@@ -93,10 +93,10 @@ public:
///
/// \brief Boolean array constructor.
/// \param arr An array of boolean values resembling each bit.
/// \details Initializes each bit with the respective boolean value in \f$arr\f$
/// \details Initializes each bit with the respective boolean value in \emph{arr}
///
/// \par Complexity
/// \f$O(N)\f$
/// \emph{O(N)}
///
explicit constexpr bitfield(const bool (&arr)[N])
: _bytes() {
@@ -108,10 +108,10 @@ public:
///
/// \brief Index array constructor.
/// \param arr An array of indices.
/// \details Sets the bits of each index provided in \f$arr\f$.
/// \details Sets the bits of each index provided in \emph{arr}.
///
/// \par Complexity
/// \f$O(N)\f$
/// \emph{O(N)}
///
template<size_t I>
explicit constexpr bitfield(const size_t (&arr)[I])
@@ -123,11 +123,11 @@ public:
///
/// \param args A set of indices.
/// \details This substitution assumes \f$ArgsT\ldots\f$ can be taken as an array of indices. <br>
/// Sets the bits of each index provided in \f$args\ldots\f$.
/// \details This substitution assumes \emph{ArgsT...} can be taken as an array of indices. <br>
/// Sets the bits of each index provided in \emph{args...}.
///
/// \par Complexity
/// \f$O(N)\f$
/// \emph{O(N)}
///
template<typename...ArgsT>
constexpr bitfield(ArgsT&&...args)
@@ -138,12 +138,12 @@ public:
///
/// \brief Variadic array constructor
/// \param args A set of boolean values.
/// \details This substitution assumes \f$ArgsT\ldots\f$ can be taken as an array of booleans. <br>
/// Initializes each bit with the respective boolean in \f$args\ldots\f$. <br>
/// \details This substitution assumes \emph{ArgsT...} can be taken as an array of booleans. <br>
/// Initializes each bit with the respective boolean in \emph{args...}. <br>
/// Does not necessitate the number of arguments be equal to the number of bits.
///
/// \par Complexity
/// \f$O(N)\f$
/// \emph{O(N)}
///
template<typename...ArgsT> requires((is_bool_v<ArgsT> or is_convertible_v<ArgsT, bool>) and ...)
constexpr bitfield(ArgsT&&...args)
@@ -157,7 +157,7 @@ public:
/// \param bf bitfield to copy
///
/// \par Complexity
/// \f$O(N)\f$
/// \emph{O(N)}
///
bitfield(const bitfield& bf)
: _bytes(bf._bytes) {
@@ -168,7 +168,7 @@ public:
/// \param bf bitfield to move
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
bitfield(bitfield&& bf) noexcept
: _bytes(bf._bytes) {
@@ -190,20 +190,20 @@ public:
///
/// \brief copy assignment
/// \param bf bitfield to copy
/// \returns a reference to self
/// \returns a reference to \emph{this}
///
/// \par Complexity
/// \f$O(N)\f$
/// \emph{O(N)}
///
bitfield& operator=(const bitfield& bf) = default;
///
/// \brief move assignment
/// \param bf bitfield to move
/// \returns a reference to self
/// \returns a reference to \emph{this}
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
bitfield& operator=(bitfield&& bf) noexcept = default;
@@ -222,12 +222,12 @@ public:
/// \returns the value stored in the bit as a boolean
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
bool test(size_t i) const {
assertd(i < bits, "Index out of Bounds!");
size_t b = i / 8;
size_t o = i % 8;
const size_t o = i % 8;
return _bytes[b] & (1 << o);
}
@@ -236,12 +236,12 @@ public:
/// \param i the index of the bit
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
void set(size_t i) {
assertd(i < bits, "Index out of Bounds!");
size_t b = i / 8;
size_t o = i % 8;
const size_t o = i % 8;
_bytes[b] |= (1 << o);
}
@@ -250,12 +250,12 @@ public:
/// \param i the index of the bit
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
void clear(size_t i) {
assertd(i < bits, "Index out of Bounds!");
size_t b = i / 8;
size_t o = i % 8;
const size_t o = i % 8;
_bytes[b] &= ~(1 << o);
}
@@ -264,27 +264,27 @@ public:
/// \param i the index of the bit
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
void toggle(size_t i) {
assertd(i < bits, "Index out of Bounds!");
size_t b = i / 8;
size_t o = i % 8;
const size_t o = i % 8;
_bytes[b] ^= (1 << o);
}
///
/// \brief store \f$v\f$ in bit \f$i\f$
/// \brief store \emph{v} in bit \emph{i}
/// \param i the index of the bit
/// \param v the value to store
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
void store(size_t i, bool v) {
assertd(i < bits, "Index out of Bounds!");
size_t b = i / 8;
size_t o = i % 8;
const size_t o = i % 8;
(_bytes[b] &= ~((1 << o))) |= ((v << o));
}
@@ -293,7 +293,7 @@ public:
/// \returns a bitfield containing the bit-wise inverse
///
/// \par Complexity
/// \f$O(N)\f$
/// \emph{O(N)}
///
bitfield operator~() const {
bitfield res = *this;

27
include/fennec/containers/containers.h
View File

@@ -42,20 +42,19 @@
///
/// \section fennec_containers_container_section_properties Container Properties
///
/// | Property | Meaning |
/// |:----------------|:-----------------------------------------------------------------------------------------------|
/// | **stable** | Any pointer reference to an element remains constant for the lifetime of the container. |
/// | **dynamic** | Memory for this container is allocated on the heap. |
/// | **homogeneous** | The types of all elements are either identical, or inherit the same base type. |
/// | **distinct** | Elements are guaranteed to be unique in their value. |
/// | **ordered** | Elements are guaranteed to be in order, such that for any index \f$i\f$, \f$E_i < E_{i + 1}\f$ |
/// | **space** | The amount of memory allocated with respect to the number of elements, in big-O notation. |
/// | **linear** | Each element is sequential in terms of access. |
/// | **access** | The runtime of the access operators and functions, in big-O notation. |
/// | **find** | The runtime of finding an element in the container, in big-O notation. |
/// | **insertion** | The runtime of inserting an element in the container, in big-O notation. |
/// | **deletion** | The runtime of erasing an element in the container, in big-O notation. |
/// | **space** | The space complexity of the container. |
/// | Property | Meaning |
/// |:----------------|:-------------------------------------------------------------------------------------------------------------------|
/// | **stable** | Any pointer reference to an element remains constant for the lifetime of the container. |
/// | **dynamic** | Memory for this container is allocated on the heap. |
/// | **homogeneous** | The types of all elements are either identical, or inherit the same base type. |
/// | **distinct** | Elements are guaranteed to be unique in their value. |
/// | **ordered** | Elements are guaranteed to be in order, such that for any index \math{i}, \math{\textbf{E}_i < \textbf{E}_{i + 1}} |
/// | **space** | The amount of memory allocated with respect to the number of elements, in big-O notation. |
/// | **linear** | Each element is sequential in terms of access. |
/// | **access** | The runtime of the access operators and functions, in big-O notation. |
/// | **find** | The runtime of finding an element in the container, in big-O notation. |
/// | **insertion** | The runtime of inserting an element in the container, in big-O notation. |
/// | **deletion** | The runtime of erasing an element in the container, in big-O notation. |
///
///
/// \section fennec_containers_section_cppstdlib C++ Standard Template Library

71
include/fennec/containers/deque.h
View File

@@ -33,8 +33,6 @@
#include <fennec/memory/allocator.h>
// TODO: Document
namespace fennec
{
@@ -46,20 +44,19 @@ namespace fennec
/// This behaves the similar to fennec::list, however it does not allow arbitrary access, insertion, or deletion.
/// It is one of the few data structures in this library that is stable, i.e. pointers to elements do not change.
///
/// | Property | Value |
/// |:-----------:|:----------:|
/// | stable | ✅ |
/// | dynamic | ✅ |
/// | homogeneous | ✅ |
/// | distinct | ⛔ |
/// | ordered | ⛔ |
/// | space | \f$O(N)\f$ |
/// | linear | ⛔ |
/// | access | \f$O(1)\f$ |
/// | find | \f$O(N)\f$ |
/// | insertion | \f$O(1)\f$ |
/// | deletion | \f$O(1)\f$ |
/// | space | \f$O(N)\f$ |
/// | Property | Value |
/// |:-----------:|:-----------:|
/// | stable | ✅ |
/// | dynamic | ✅ |
/// | homogeneous | ✅ |
/// | distinct | ⛔ |
/// | ordered | ⛔ |
/// | linear | ⛔ |
/// | space | \emph{O(N)} |
/// | access | \emph{O(1)} |
/// | find | \emph{O(N)} |
/// | insertion | \emph{O(1)} |
/// | deletion | \emph{O(1)} |
///
/// \tparam TypeT value type
template<typename TypeT, typename AllocT = allocator<TypeT>>
@@ -93,7 +90,7 @@ public:
/// \brief Default Constructor, initializes an empty deque
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
deque()
: _alloc()
@@ -107,7 +104,7 @@ public:
/// \param alloc the allocator to copy
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
deque(const alloc_t& alloc)
: _alloc(alloc)
@@ -121,7 +118,7 @@ public:
/// \param deque the deque to copy
///
/// \par Complexity
/// \f$O(N)\f$
/// \emph{O(N)}
///
deque(const deque& deque)
: _alloc(deque._alloc)
@@ -140,7 +137,7 @@ public:
/// \param deque the deque to move
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
deque(deque&& deque) noexcept
: _alloc(deque._alloc)
@@ -155,7 +152,7 @@ public:
/// \brief Destructor, calls deque::clear
///
/// \par Complexity
/// \f$O(N)\f$
/// \emph{O(N)}
///
~deque() {
clear();
@@ -169,10 +166,10 @@ public:
/// @{
///
/// \returns \f$true\f$ when the deque is empty, \f$false\f$ otherwise
/// \returns \emph{true} when the deque is empty, \emph{false} otherwise
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr bool is_empty() const {
return _size == 0;
@@ -182,7 +179,7 @@ public:
/// \returns the number of elements in the deque
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr size_t size() const {
return _size;
@@ -200,7 +197,7 @@ public:
/// \returns a reference to the first element in the deque
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
value_t& front() {
assert(not is_empty(), "Attempted to access an empty deque.");
@@ -211,7 +208,7 @@ public:
/// \returns a const-qualified reference to the first element in the deque
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
const value_t& front() const {
assert(not is_empty(), "Attempted to access an empty deque.");
@@ -222,7 +219,7 @@ public:
/// \returns a reference to the last element in the deque
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
value_t& back() {
assert(not is_empty(), "Attempted to access an empty deque.");
@@ -233,7 +230,7 @@ public:
/// \returns a const-qualified reference to the last element in the deque
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
const value_t& back() const {
assert(not is_empty(), "Attempted to access an empty deque.");
@@ -253,7 +250,7 @@ public:
/// \param elem the value to move
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
void push_front(value_t&& elem) {
this->_push_front(elem);
@@ -264,7 +261,7 @@ public:
/// \param elem the value to copy
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
void push_front(const value_t& elem) {
this->_push_front(elem);
@@ -276,7 +273,7 @@ public:
/// \param args Arguments used to construct the value
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
template<typename...ArgsT>
void emplace_front(ArgsT&&...args) {
@@ -289,7 +286,7 @@ public:
/// \param elem the value to move
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
void push_back(value_t&& elem) {
this->_push_back(elem);
@@ -300,7 +297,7 @@ public:
/// \param elem the value to copy
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
void push_back(const value_t& elem) {
this->_push_back(elem);
@@ -312,7 +309,7 @@ public:
/// \param args Arguments used to construct the value
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
template<typename...ArgsT>
void emplace_back(ArgsT&&...args) {
@@ -323,7 +320,7 @@ public:
/// \brief Clears the contents of the deque
///
/// \par Complexity
/// \f$O(N)\f$
/// \emph{O(N)}
///
void clear() {
elem_t it = _first;
@@ -342,7 +339,7 @@ public:
/// \brief Erase the First Element
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
void pop_front() {
if (_first == nullptr) {
@@ -360,7 +357,7 @@ public:
/// \brief Erase the Last Element
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
void pop_back() {
if (_last == nullptr) {

13
include/fennec/containers/detail/_tuple.h
View File

@@ -18,6 +18,7 @@
#ifndef FENNEC_CONTAINERS_DETAIL_TUPLE_H
#define FENNEC_CONTAINERS_DETAIL_TUPLE_H
#include <fennec/lang/metasequences.h>
#include <fennec/lang/utility.h>
@@ -28,8 +29,11 @@ namespace fennec::detail
template <size_t I, typename T>
struct _tuple_leaf
{
template <typename ArgT>
constexpr _tuple_leaf(ArgT&& arg) : value(fennec::forward<ArgT>(arg)) {}
constexpr _tuple_leaf(_tuple_leaf&&) noexcept = default;
constexpr _tuple_leaf(const _tuple_leaf&) = default;
template <typename ArgT> requires(not is_same_v<remove_cvref_t<ArgT>, _tuple_leaf>)
constexpr explicit _tuple_leaf(ArgT&& arg) : value(fennec::forward<ArgT>(arg)) {}
constexpr ~_tuple_leaf() = default;
@@ -45,8 +49,11 @@ struct _tuple;
template <size_t...IndicesV, typename...TypesT>
struct _tuple<index_metasequence<IndicesV...>, TypesT...> : _tuple_leaf<IndicesV, TypesT>...
{
constexpr _tuple(_tuple&&) noexcept = default;
constexpr _tuple(const _tuple&) = default;
template <typename...ArgsT>
constexpr _tuple(ArgsT&&... args)
constexpr explicit _tuple(ArgsT&&... args)
: _tuple_leaf<IndicesV, TypesT>(fennec::forward<ArgsT>(args))... {
}

187
include/fennec/containers/dynarray.h
View File

@@ -31,10 +31,13 @@
#ifndef FENNEC_CONTAINERS_DYNARRAY_H
#define FENNEC_CONTAINERS_DYNARRAY_H
#include <fennec/containers/initializer_list.h>
#include <fennec/lang/utility.h>
#include <fennec/memory/allocator.h>
#include <fennec/memory/new.h>
#include <fennec/containers/initializer_list.h>
#include <fennec/format/formatter.h>
namespace fennec
{
@@ -43,20 +46,19 @@ namespace fennec
///
/// \brief Wrapper for dynamically sized and allocated arrays
/// \details
/// | Property | Value |
/// |:-----------:|:----------:|
/// | stable | ⛔ |
/// | dynamic | ✅ |
/// | homogeneous | ✅ |
/// | distinct | ⛔ |
/// | ordered | ⛔ |
/// | space | \f$O(N)\f$ |
/// | linear | ✅ |
/// | access | \f$O(1)\f$ |
/// | find | \f$O(N)\f$ |
/// | insertion | \f$O(N)\f$ |
/// | deletion | \f$O(N)\f$ |
/// | space | \f$O(N)\f$ |
/// | Property | Value |
/// |:-----------:|:-----------:|
/// | stable | ⛔ |
/// | dynamic | ✅ |
/// | homogeneous | ✅ |
/// | distinct | ⛔ |
/// | ordered | ⛔ |
/// | linear | ✅ |
/// | space | \emph{O(N)} |
/// | access | \emph{O(1)} |
/// | find | \emph{O(N)} |
/// | insertion | \emph{O(N)} |
/// | deletion | \emph{O(N)} |
///
/// This structure prefers shallow moves and deep copies.
///
@@ -86,7 +88,7 @@ public:
/// \brief Default Constructor, initializes an empty allocation.
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr dynarray()
: _alloc(8)
@@ -99,7 +101,7 @@ public:
/// data.
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
explicit constexpr dynarray(const alloc_t& alloc)
: _alloc(8, alloc)
@@ -107,11 +109,11 @@ public:
}
///
/// \brief Sized Allocation, initializes a dynarray with \f$n\f$ elements using the default constructor.
/// \brief Sized Allocation, initializes a dynarray with \emph{n} elements using the default constructor.
/// \param n The number of elements.
///
/// \par Complexity
/// \f$O(N)\f$
/// \emph{O(N)}
///
explicit constexpr dynarray(size_t n)
: _alloc(n)
@@ -124,13 +126,13 @@ public:
}
///
/// \brief Sized Allocation Alloc Constructor, initializes a dynarray with allocator \f$alloc\f$ and \f$n\f$ elements
/// \brief Sized Allocation Alloc Constructor, initializes a dynarray with allocator \emph{alloc} and \emph{n} elements
/// using the default constructor.
/// \param n The number of elements
/// \param alloc The allocator object to copy
///
/// \par Complexity
/// \f$O(N)\f$
/// \emph{O(N)}
///
constexpr dynarray(size_t n, const alloc_t& alloc)
: _alloc(n, alloc)
@@ -142,13 +144,13 @@ public:
}
///
/// \brief Sized Allocation Copy Constructor, Create an allocation of size \f$n\f$ elements, with each element
/// \brief Sized Allocation Copy Constructor, Create an allocation of size \emph{n} elements, with each element
/// constructed using the copy constructor
/// \param n the number of elements
/// \param val the value to copy
///
/// \par Complexity
/// \f$O(N)\f$
/// \emph{O(N)}
///
constexpr dynarray(size_t n, const TypeT& val)
: _alloc(n)
@@ -166,7 +168,7 @@ public:
/// \param args The arguments to create each object with
///
/// \par Complexity
/// \f$O(N)\f$
/// \emph{O(N)}
///
template<typename...ArgsT>
constexpr explicit dynarray(size_t n, ArgsT&&...args)
@@ -183,7 +185,7 @@ public:
/// \param arr The array to copy
///
/// \par Complexity
/// \f$O(N)\f$
/// \emph{O(N)}
///
template<size_t N>
constexpr dynarray(const TypeT (&arr)[N])
@@ -200,7 +202,7 @@ public:
/// \param arr The array to move
///
/// \par Complexity
/// \f$O(N)\f$
/// \emph{O(N)}
///
template<size_t N>
constexpr dynarray(TypeT (&&arr)[N])
@@ -212,13 +214,13 @@ public:
}
///
/// \brief Conversion Constructor, copies elements of conv as this \f$value_t\f$
/// \brief Conversion Constructor, copies elements of conv as this \emph{value_t}
/// \tparam OTypeT The other value type
/// \tparam OAlloc The other allocator type
/// \param conv The dynarray to convert
///
/// \par Complexity
/// \f$O(N)\f$
/// \emph{O(N)}
///
template<typename OTypeT, class OAlloc>
constexpr dynarray(const dynarray<OTypeT, OAlloc>& conv)
@@ -236,7 +238,7 @@ public:
/// \param alloc An allocator object to copy
///
/// \par Complexity
/// \f$O(N)\f$
/// \emph{O(N)}
///
constexpr dynarray(initializer_list<value_t> l, const alloc_t& alloc = alloc_t())
: _alloc(l.size(), alloc)
@@ -252,7 +254,7 @@ public:
/// \param arr the dynarray to copy
///
/// \par Complexity
/// \f$O(N)\f$
/// \emph{O(N)}
///
constexpr dynarray(const dynarray& arr)
: _alloc(arr._size)
@@ -267,7 +269,7 @@ public:
/// \param arr the dynarray to move
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr dynarray(dynarray&& arr) noexcept
: _alloc(fennec::move(arr._alloc))
@@ -279,7 +281,7 @@ public:
/// \brief Default Destructor, destructs all elements and frees the underlying allocation
///
/// \par Complexity
/// \f$O(N)\f$
/// \emph{O(N)}
///
constexpr ~dynarray() {
value_t* addr = _alloc.data();
@@ -292,10 +294,6 @@ public:
/// @}
private:
// This constructor should not be invokable since moving is a single object operation and will cause undefined
// behaviour when moving to multiple elements
constexpr dynarray(size_t n, TypeT&& val) = delete;
// Assignment ==========================================================================================================
@@ -307,10 +305,10 @@ public:
///
/// \brief Copy Assignment Operator
/// \param arr the array to copy
/// \returns A dynarray after having copied each element of \f$arr\f$
/// \returns A dynarray after having copied each element of \emph{arr}
///
/// \par Complexity
/// \f$O(N)\f$
/// \emph{O(N)}
///
constexpr dynarray& operator=(const dynarray& arr) {
this->clear();
@@ -324,10 +322,10 @@ public:
///
/// \brief Move Assignment Operator
/// \param arr the array to move
/// \returns A dynarray after having taken ownership of the contents of \f$arr\f$
/// \returns A dynarray after having taken ownership of the contents of \emph{arr}
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr dynarray& operator=(dynarray&& arr) noexcept {
this->clear();
@@ -341,10 +339,10 @@ public:
/// \brief Array Copy Assignment Operator
/// \tparam N the length of the array
/// \param arr the array to copy
/// \returns A dynarray after having copied each element of \f$arr\f$
/// \returns A dynarray after having copied each element of \emph{arr}
///
/// \par Complexity
/// \f$O(N)\f$
/// \emph{O(N)}
///
template<size_t N>
constexpr dynarray& operator=(const TypeT (&arr)[N]) {
@@ -360,10 +358,10 @@ public:
/// \brief Array Copy Assignment Operator
/// \tparam N the length of the array
/// \param arr the array to copy
/// \returns A dynarray after having moved each element of \f$arr\f$
/// \returns A dynarray after having moved each element of \emph{arr}
///
/// \par Complexity
/// \f$O(N)\f$
/// \emph{O(N)}
///
template<size_t N>
constexpr dynarray& operator=(TypeT (&&arr)[N]) {
@@ -387,7 +385,7 @@ public:
/// \returns The size of the dynarray in elements
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr size_t size() const {
return _size;
@@ -397,7 +395,7 @@ public:
/// \returns The current capacity, in elements, of the underlying allocation
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr size_t capacity() const {
return _alloc.capacity();
@@ -407,7 +405,7 @@ public:
/// \returns True when there are no elements active, otherwise false
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr bool is_empty() const {
return _size == 0;
@@ -425,10 +423,10 @@ public:
///
/// \brief Array Access Operator
/// \param i The index to access
/// \returns A reference to the element at index \f$i\f$
/// \returns A reference to the element at index \emph{i}
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr TypeT& operator[](size_t i) {
assertd(i < _size, "Array Out of Bounds");
@@ -438,10 +436,10 @@ public:
///
/// \brief Array Access Operator (const)
/// \param i The index to access
/// \returns A const qualified reference to the element at index \f$i\f$
/// \returns A const qualified reference to the element at index \emph{i}
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr const TypeT& operator[](size_t i) const {
assertd(i < _size, "Array Out of Bounds");
@@ -452,7 +450,7 @@ public:
/// \returns Reference to the first element in the dynarray
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr TypeT& front() {
return this->operator[](0);
@@ -462,7 +460,7 @@ public:
/// \returns A const-qualified reference to the first element in the dynarray
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr const TypeT& front() const {
return this->operator[](0);
@@ -472,7 +470,7 @@ public:
/// \returns A reference to the last element in the dynarray
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr TypeT& back() {
return this->operator[](size() - 1);
@@ -482,7 +480,7 @@ public:
/// \returns A const-qualified reference to the last element in the dynarray
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr const TypeT& back() const {
return this->operator[](size() - 1);
@@ -492,7 +490,7 @@ public:
/// \returns A pointer to the underlying allocation
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr TypeT* data() {
return _alloc.data();
@@ -502,7 +500,7 @@ public:
/// \returns A pointer to the underlying allocation
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr const TypeT* data() const {
return _alloc.data();
@@ -523,7 +521,7 @@ public:
/// \param val the value to initialize with
///
/// \par Complexity
/// \f$O(N)\f$
/// \emph{O(N)}
///
constexpr void insert(size_t i, TypeT&& val) {
@@ -535,8 +533,8 @@ public:
// Move the data if we are not inserting at the end of the array
if((i = min(i, _size)) < _size) {
fennec::memmove(
(void*)(_alloc.data() + i + 1)
, (void*)(_alloc.data() + i)
static_cast<void*>(_alloc.data() + i + 1)
, static_cast<void*>(_alloc.data() + i)
, (_size - i) * sizeof(TypeT));
}
@@ -551,7 +549,7 @@ public:
/// \param val the value to initialize with
///
/// \par Complexity
/// \f$O(N)\f$
/// \emph{O(N)}
///
constexpr void insert(size_t i, const TypeT& val) {
@@ -563,8 +561,8 @@ public:
// Move the data if we are not inserting at the end of the array
if((i = min(i, _size)) < _size) {
fennec::memmove(
(void*)(_alloc.data() + i),
(void*)(_alloc.data() + i + 1),
static_cast<void*>(_alloc.data() + i),
static_cast<void*>(_alloc.data() + i + 1),
(_size - i) * sizeof(TypeT)
);
}
@@ -581,7 +579,7 @@ public:
/// \tparam ArgsT Argument types
///
/// \par Complexity
/// \f$O(N)\f$
/// \emph{O(N)}
///
template<typename...ArgsT>
constexpr void emplace(size_t i, ArgsT&&...args) {
@@ -594,8 +592,8 @@ public:
// Move the data if we are not inserting at the end of the array
if((i = min(i, _size)) < _size) {
fennec::memmove(
(void*)(_alloc.data() + i)
, (void*)(_alloc.data() + i + 1)
static_cast<void*>(_alloc.data() + i)
, static_cast<void*>(_alloc.data() + i + 1)
, (_size - i) * sizeof(TypeT));
}
@@ -609,7 +607,7 @@ public:
/// \param val Value to initialize with
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr void push_back(const TypeT& val) {
dynarray::insert(_size, val);
@@ -620,7 +618,7 @@ public:
/// \param val Value to initialize with
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr void push_back(TypeT&& val) {
dynarray::insert(_size, fennec::forward<TypeT>(val));
@@ -632,7 +630,7 @@ public:
/// \param args Arguments to construct with
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
template<typename...ArgsT>
constexpr void emplace_back(ArgsT...args) {
@@ -643,7 +641,7 @@ public:
/// \brief Erase last element
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr void pop_back() {
fennec::destruct(&_alloc[--_size]);
@@ -653,10 +651,10 @@ public:
/// \brief Resize the dynarray, invoking the default constructor for all new elements
/// \param n The new size in elements
///
/// \details if \f$n\f$ is less than the current size, any elements that would be removed are destructed
/// \details if \emph{n} is less than the current size, any elements that would be removed are destructed
///
/// \par Complexity
/// \f$O(N)\f$
/// \emph{O(N)}
///
constexpr void resize(size_t n) {
_reduce(n);
@@ -674,10 +672,10 @@ public:
/// \param n The new size in elements
/// \param val The value to fill with
///
/// \details if \f$n\f$ is less than the current size, any elements that would be removed are destructed
/// \details if \emph{n} is less than the current size, any elements that would be removed are destructed
///
/// \par Complexity
/// \f$O(N)\f$
/// \emph{O(N)}
///
constexpr void resize(size_t n, const TypeT& val) {
_reduce(n);
@@ -694,10 +692,10 @@ public:
/// \brief Reserve the array, allocating new space without initialization
/// \param n The new capacity in elements
///
/// \details if \f$n\f$ is less than the current size, any elements that would be removed are destructed
/// \details if \emph{n} is less than the current size, any elements that would be removed are destructed
///
/// \par Complexity
/// \f$O(N)\f$
/// \emph{O(N)}
///
constexpr void reserve(size_t n) {
_reduce(n);
@@ -708,7 +706,7 @@ public:
/// \brief Clears the contents of the dynarray, destructing all elements and releasing the allocation.
///
/// \par Complexity
/// \f$O(N)\f$
/// \emph{O(N)}
///
constexpr void clear() {
_reduce(0);
@@ -728,16 +726,16 @@ public:
/// \returns A pointer to the first element in the dynarray
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr TypeT* begin() { return _alloc; }
///
/// \brief C++ Iterator Specification \f$begin()\f$
/// \brief C++ Iterator Specification \emph{begin()}
/// \returns A const qualified pointer to the first element in the dynarray
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr const TypeT* begin() const { return _alloc; }
@@ -746,16 +744,16 @@ public:
/// \return A pointer to the address after the last element in the dynarray
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr TypeT* end() { return begin() + _size; }
///
/// \brief C++ Iterator Specification \f$end()\f$
/// \brief C++ Iterator Specification \emph{end()}
/// \return A const qualified pointer to the address after the last element in the dynarray
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr const TypeT* end() const { return begin() + _size; }
@@ -783,6 +781,27 @@ private:
}
};
///
/// \brief Formatter for `fennec::dynarray`
/// \tparam T The element type.
template<typename T>
struct formatter<dynarray<T>> {
///
/// \brief format function
/// \param str the string argument
/// \returns the formatted version of \emph{str}
string operator()(const format_arg& fmt, const dynarray<T>& arr) const {
string res = string("[ ");
for (auto& it : arr) {
res += ' ';
res += base(fmt, it);
}
return res;
}
static constexpr formatter<T> base = {};
};
}
#endif // FENNEC_CONTAINERS_DYNARRAY_H

76
include/fennec/containers/generic.h
View File

@@ -32,6 +32,7 @@
#define FENNEC_CONTAINERS_GENERIC_H
#include <fennec/memory/allocator.h>
#include <fennec/rtti/type.h>
namespace fennec
@@ -40,20 +41,19 @@ namespace fennec
///
/// \brief A struct capable of holding a single object of any type
/// \details
/// | Property | Value |
/// |:-----------:|:----------:|
/// | stable | ✅ |
/// | dynamic | ⛔ |
/// | homogeneous | ⛔ |
/// | distinct | ⛔ |
/// | ordered | ⛔ |
/// | space | \f$O(1)\f$ |
/// | linear | ✅ |
/// | access | \f$O(1)\f$ |
/// | find | ⛔ |
/// | insertion | \f$O(1)\f$ |
/// | deletion | \f$O(1)\f$ |
/// | space | \f$O(1)\f$ |
/// | Property | Value |
/// |:-----------:|:-----------:|
/// | stable | ✅ |
/// | dynamic | ⛔ |
/// | homogeneous | ⛔ |
/// | distinct | ⛔ |
/// | ordered | ⛔ |
/// | linear | ✅ |
/// | space | \emph{O(1)} |
/// | access | \emph{O(1)} |
/// | find | ⛔ |
/// | insertion | \emph{O(1)} |
/// | deletion | \emph{O(1)} |
struct generic {
// Definitions =========================================================================================================
@@ -79,7 +79,7 @@ public:
/// \brief Default Constructor
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
generic()
: _handle(nullptr)
@@ -91,7 +91,7 @@ public:
/// \param gen The generic object to copy
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
generic(const generic& gen)
: _handle(nullptr)
@@ -106,7 +106,7 @@ public:
/// \param gen The generic object to move
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
generic(generic&& gen)
: _handle(gen._handle)
@@ -121,7 +121,7 @@ public:
/// \param x The value
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
template<typename T>
generic(T&& x)
@@ -136,7 +136,7 @@ public:
/// \param args The argument values
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
template<typename T, typename...ArgsT>
generic(type_identity<T>, ArgsT&&...args)
@@ -164,17 +164,17 @@ public:
/// \returns a runtime type struct referencing the held type
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
type type() const {
return *static_cast<fennec::type*>(_manage(op_type, nullptr));
}
///
/// \returns \f$true\f$ if there is a held value, \f$false\f$ otherwise
/// \returns \emph{true} if there is a held value, \emph{false} otherwise
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
bool has_value() const {
return _handle != nullptr;
@@ -192,10 +192,10 @@ public:
///
/// \brief copy assignment
/// \param gen the generic to copy
/// \returns a reference to self after copying the contents of \f$gen\f$
/// \returns a reference to \emph{this} after copying the contents of \emph{gen}
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
generic& operator=(const generic& gen) {
if (this == &gen) { // self-assignment case
@@ -211,10 +211,10 @@ public:
///
/// \brief move assignment
/// \param gen the generic to move
/// \returns a reference to self after swapping contents with \f$gen\f$
/// \returns a reference to \emph{this} after swapping contents with \emph{gen}
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
generic& operator=(generic&& gen) noexcept {
swap(gen);
@@ -225,10 +225,10 @@ public:
/// \brief value assignment
/// \tparam T the type of the value
/// \param x the value to assign
/// \returns a reference to self after having assigned \f$x\f$
/// \returns a reference to \emph{this} after having assigned \emph{x}
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
template<typename T>
generic& operator=(T&& x) {
@@ -250,13 +250,13 @@ public:
///
/// \brief emplace value
///
/// \details constructs a new value of type \f$T\f$ using \f$args\ldots\f$
/// \details constructs a new value of type \emph{T} using \emph{args\ldots}
/// \tparam T the type to construct
/// \tparam ArgsT the argument types
/// \param args the argument values
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
template<typename T, typename...ArgsT>
void emplace(ArgsT&&...args) {
@@ -270,7 +270,7 @@ public:
/// \details clears the held value using the appropriate destructor
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
void reset() {
if (_manage) {
@@ -284,7 +284,7 @@ public:
/// \param gen the generic to swap with
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
void swap(generic& gen) noexcept {
fennec::swap(_handle, gen._handle);
@@ -303,12 +303,12 @@ public:
///
/// \brief cast value
///
/// \details equivalent to \f$reinterpret_cast\f$
/// \details equivalent to \emph{reinterpret_cast}
/// \tparam T The type to cast to
/// \returns The contents of generic after having cast to \f$T\f$
/// \returns The contents of generic after having cast to \emph{T}
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
template<typename T, typename U = remove_cvref_t<T>>
T cast() {
@@ -316,12 +316,12 @@ public:
}
///
/// \details equivalent to \f$reinterpret_cast\f$
/// \details equivalent to \emph{reinterpret_cast}
/// \tparam T The type to cast to
/// \returns The contents of generic after having cast to \f$T\f$
/// \returns The contents of generic after having cast to \emph{T}
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
template<typename T, typename U = remove_cvref_t<T>>
T cast() const {

146
include/fennec/containers/graph.h
View File

@@ -35,7 +35,6 @@
#include <fennec/containers/list.h>
#include <fennec/containers/map.h>
#include <fennec/containers/object_pool.h>
#include <fennec/containers/set.h>
/*
* With the directed tree we were able to cheat a little, the structure has more rules to it which allows
@@ -55,20 +54,19 @@ namespace fennec
/// \brief Graph Data Structure, describes sets of arbitrarily connected vertices
///
/// \details
/// | Property | Value |
/// |:-----------:|:--------------:|
/// | stable | ⛔ |
/// | dynamic | ✅ |
/// | homogeneous | ✅ |
/// | distinct | ⛔ |
/// | ordered | ⛔ |
/// | space | \f$O(N)\f$ |
/// | linear | ✅ |
/// | access | \f$O(1)\f$ |
/// | find | \f$O(1)\f$ |
/// | insertion | \f$O(1)\f$ |
/// | deletion | \f$O(M)\f$ |
/// | space | \f$O(N + M)\f$ |
/// | Property | Value |
/// |:-----------:|:---------------:|
/// | stable | ⛔ |
/// | dynamic | ✅ |
/// | homogeneous | ✅ |
/// | distinct | ⛔ |
/// | ordered | ⛔ |
/// | linear | ✅ |
/// | space | \emph{O(N + M)} |
/// | access | \emph{O(1)} |
/// | find | \emph{O(1)} |
/// | insertion | \emph{O(1)} |
/// | deletion | \emph{O(M)} |
///
/// Graphs contain vertices and edges. Graphs are either directed
/// or undirected. This structure allows the creation of both directed and undirected edges. As
@@ -80,11 +78,11 @@ namespace fennec
/// A directed graph is weakly connected if replacing all of its directed edges with undirected edges would
/// produce a connected graph. We will call this "disjointed"
///
/// A directed graph is semi-connected if there is a directed path p for \f$u\f$ &rarr; \f$v\f$ *or* \f$v\f$ &rarr; \f$u\f$ for every
/// pair of vertices \f$[u, v]\f$. We will call this "unilateral"
/// A directed graph is semi-connected if there is a directed path p for \emph{u} &rarr; \emph{v} *or* \emph{v} &rarr; \emph{u} for every
/// pair of vertices \emph{[u, v]}. We will call this "unilateral"
///
/// A directed graph is strongly-connected if there is a directed path p for \f$u\f$ &rarr; \f$v\f$ *and* \f$v\f$ &rarr; \f$u\f$ for every pair
/// of vertices \f$[u, v]\f$. We will call this "connected"
/// A directed graph is strongly-connected if there is a directed path p for \emph{u} &rarr; \emph{v} *and* \emph{v} &rarr; \emph{u} for every pair
/// of vertices \emph{[u, v]}. We will call this "connected"
///
/// \tparam VertexT The type associated with each vertex
/// \tparam EdgeT The type associated with each edge
@@ -122,7 +120,7 @@ public:
/// \brief Default Constructor, initializes empty graph
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr graph() = default;
@@ -130,7 +128,7 @@ public:
/// \brief Destructor
///
/// \par Complexity
/// \f$O(N + M)\f$
/// \math{\textbf{O(N} + \textbf{M)}}
///
constexpr ~graph() = default;
@@ -146,7 +144,7 @@ public:
/// \returns A reference to this after assigning g
///
/// \par Complexity
/// \f$O(N + M)\f$
/// \math{\textbf{O(N} + \textbf{M)}}
///
constexpr graph& operator=(const graph& g) = default;
@@ -156,7 +154,7 @@ public:
/// \returns A reference to this after assigning g
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr graph& operator=(graph&& g) = default;
@@ -172,7 +170,7 @@ public:
/// \returns The number of vertices in the graph
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr size_t num_vertices() const {
return _vertex_pool.size();
@@ -182,7 +180,7 @@ public:
/// \returns The number of edges in the graph
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr size_t num_edges() const {
return _edge_pool.size();
@@ -192,57 +190,57 @@ public:
/// \returns The capacity of the vertex pool
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr size_t capacity() const {
return _vertex_pool.capacity();
}
///
/// \returns \f$true\f$ when there are no vertices in the graph, \f$false\f$ otherwise
/// \returns \emph{true} when there are no vertices in the graph, \emph{false} otherwise
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr bool is_empty() const {
return num_vertices() == 0;
}
///
/// \brief Checks if there exists an edge \f$e\f$ that starts from \f$a\f$ and ends at \f$b\f$
/// \brief Checks if there exists an edge \math{e} that starts from \emph{a} and ends at \emph{b}
/// \param a The first vertex
/// \param b The second vertex
/// \returns \f$true\f$ if the edge exists, \f$false\f$ otherwise
/// \returns \emph{true} if the edge exists, \emph{false} otherwise
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr bool exists(size_t a, size_t b) const {
return _edge_map[a][b] != nullptr;
}
///
/// \brief Checks if there exists an edge \f$e0\f$ that starts from \f$a\f$ and ends at \f$b\f$ and \f$e1\f$ that starts from \f$b\f$
/// and ends at \f$a\f$
/// \brief Checks if there exists an edge \math{e_0} that starts from \emph{a} and ends at \emph{b} and \math{e_1} that starts from \emph{b}
/// and ends at \emph{a}
/// \param a The first vertex
/// \param b The second vertex
/// \returns \f$true\f$ if both edges exist, \f$false\f$ otherwise
/// \returns \emph{true} if both edges exist, \emph{false} otherwise
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr bool is_symmetric(size_t a, size_t b) const {
return exists(a, b) and exists(b, a);
}
///
/// \brief Checks if there exists an edge \f$e\f$ between \f$a\f$ and \f$b\f$
/// \brief Checks if there exists an edge \math{e} between \emph{a} and \emph{b}
/// \param a The first vertex
/// \param b The second vertex
/// \returns \f$true\f$ if both edges exist, \f$false\f$ otherwise
/// \returns \emph{true} if both edges exist, \emph{false} otherwise
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr bool is_undirected(size_t a, size_t b) const {
const auto* e0 = _edge_map[a][b];
@@ -269,7 +267,7 @@ public:
/// \returns A reference to the value stored in the vertex
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr vertex_t& operator[](size_t vertex) {
return _vertex_pool[vertex];
@@ -281,7 +279,7 @@ public:
/// \returns A reference to the value stored in the vertex
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr const vertex_t& operator[](size_t vertex) const {
return _vertex_pool[vertex];
@@ -291,10 +289,10 @@ public:
/// \brief edge Access Operator
/// \param a The id of the first vertex
/// \param b The id of the second vertex
/// \returns A pointer to the value stored in the edge, \f$nullptr\f$ if not found
/// \returns A pointer to the value stored in the edge, \emph{nullptr} if not found
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr edge_t* operator[](size_t a, size_t b) {
if (is_empty()) {
@@ -311,10 +309,10 @@ public:
/// \brief edge Const Access Operator
/// \param a The id of the first vertex
/// \param b The id of the second vertex
/// \returns A const-qualified pointer to the value stored in the edge, \f$nullptr\f$ if not found
/// \returns A const-qualified pointer to the value stored in the edge, \emph{nullptr} if not found
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr const edge_t* operator[](size_t a, size_t b) const {
if (is_empty()) {
@@ -328,12 +326,12 @@ public:
}
///
/// \brief Getter for a list of vertices \f$x\f$ that \f$vertex\f$ has an edge to \f$x\ldots\f$
/// \brief Getter for a list of vertices \emph{X} that \emph{vertex} has an edge to \emph{X...}
/// \param vertex The id of the vertex
/// \returns A list containing all vertices \f$x\f$ with edges from \f$vertex\f$ to \f$x\ldots\f$
/// \returns A list containing all vertices \emph{X} with edges from \emph{vertex} to \emph{X...}
///
/// \par Complexity
/// \f$O(M)\f$
/// \emph{O(M)}
///
list<size_t> outgoing(size_t vertex) {
list<size_t> res;
@@ -347,12 +345,12 @@ public:
}
///
/// \brief Getter for a list of vertices \f$x\f$ that \f$vertex\f$ has an edge from \f$x\ldots\f$
/// \brief Getter for a list of vertices \emph{X} that \emph{vertex} has an edge from \emph{X...}
/// \param vertex The id of the vertex
/// \returns A list containing all vertices \f$x\f$ with edges from \f$x\ldots\f$ to \f$vertex\f$
/// \returns A list containing all vertices \emph{X} with edges from \emph{X...} to \emph{vertex}
///
/// \par Complexity
/// \f$O(M)\f$
/// \emph{O(M)}
///
list<size_t> incoming(size_t vertex) {
list<size_t> res;
@@ -368,12 +366,12 @@ public:
}
///
/// \brief Getter for a list of vertices \f$x\f$ that \f$vertex\f$ has an edge to and from \f$x\ldots\f$
/// \brief Getter for a list of vertices \emph{X} that \emph{vertex} has an edge to and from \emph{X...}
/// \param vertex The id of the vertex
/// \returns A list containing all vertices \f$x\f$ that have symmetric edges with \f$vertex\f$
/// \returns A list containing all vertices \emph{X} that have symmetric edges with \emph{vertex}
///
/// \par Complexity
/// \f$O(M)\f$
/// \emph{O(M)}
///
list<size_t> symmetric(size_t vertex) {
list<size_t> res;
@@ -389,16 +387,16 @@ public:
}
///
/// \brief Getter for a list of vertices \f$x\f$ that \f$vertex\f$ has an edge to and from \f$x\ldots\f$ and share the same value
/// \brief Getter for a list of vertices \emph{X} that \emph{vertex} has an edge to and from \emph{X...} and share the same value
/// \details
/// "Joined" edges may also be referred to as "undirected." A joined, or undirected, edge may be
/// turned into a directed edge by changing the weight object associated with the edge, or by
/// removing one of the sub-edges.
/// \param vertex The id of the vertex
/// \returns A list containing all vertices \f$x\f$ that have symmetric edges with \f$vertex\f$
/// \returns A list containing all vertices \emph{X} that have symmetric edges with \emph{vertex}
///
/// \par Complexity
/// \f$O(M)\f$
/// \emph{O(M)}
///
list<size_t> undirected(size_t vertex) {
list<size_t> res;
@@ -421,7 +419,7 @@ public:
/// \returns A pointer to a map containing edges mapped from this vertex
///
/// \par Complexity
/// \f$O(M)\f$
/// \emph{O(M)}
///
const auto* edges(size_t vertex) {
if (is_empty() || vertex >= _edge_map.size()) {
@@ -444,7 +442,7 @@ public:
/// \returns The id of the new vertex
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr size_t insert(vertex_t&& vertex) {
return this->_insert(fennec::forward<vertex_t>(vertex));
@@ -456,7 +454,7 @@ public:
/// \returns The id of the new vertex
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr size_t insert(const vertex_t& vertex) {
return this->_insert(vertex);
@@ -469,7 +467,7 @@ public:
/// \returns The id of the new vertex
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
template<typename...ArgsT>
constexpr size_t emplace(ArgsT&&...args) {
@@ -481,7 +479,7 @@ public:
/// \param vertex The id of the vertex to erase
///
/// \par Complexity
/// \f$O(M)\f$
/// \emph{O(M)}
///
constexpr void erase(size_t vertex) {
cut(vertex);
@@ -489,14 +487,14 @@ public:
}
///
/// \brief Form an edge from vertex \f$a\f$ to vertex \f$b\f$
/// \brief Form an edge from vertex \emph{a} to vertex \emph{b}
/// \tparam ArgsT The argument types
/// \param a The first vertex id
/// \param b The second vertex id
/// \param args The arguments to construct the edge with
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
template<typename...ArgsT>
constexpr void make_edge(size_t a, size_t b, ArgsT&&...args) {
@@ -508,7 +506,7 @@ public:
_edge_map.resize(_vertex_pool.capacity());
}
auto it = _edge_map[a][b];
const auto it = _edge_map[a][b];
size_t conn;
if (it != nullptr) {
conn = *it;
@@ -520,14 +518,14 @@ public:
}
///
/// \brief Form an undirected edge between vertex \f$a\f$ and vertex \f$b\f$
/// \brief Form an undirected edge between vertex \emph{a} and vertex \emph{b}
/// \tparam ArgsT The argument types
/// \param a The first vertex id
/// \param b The second vertex id
/// \param args The arguments to construct the edge with
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
template<typename...ArgsT>
constexpr void make_edge2(size_t a, size_t b, ArgsT&&...args) {
@@ -539,7 +537,7 @@ public:
_edge_map.resize(_vertex_pool.capacity());
}
auto it = _edge_map[a][b];
const auto it = _edge_map[a][b];
size_t conn;
if (it != nullptr) {
conn = *it;
@@ -553,12 +551,12 @@ public:
}
///
/// \brief Disconnect an edge from vertex \f$a\f$ to vertex \f$b\f$
/// \brief Disconnect an edge from vertex \emph{a} to vertex \emph{b}
/// \param a The first vertex id
/// \param b The second vertex id
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr void cut_edge(size_t a, size_t b) {
@@ -580,12 +578,12 @@ public:
}
///
/// \brief Disconnect both directed edges between vertices \f$a\f$ and \f$b\f$
/// \brief Disconnect both directed edges between vertices \emph{a} and \emph{b}
/// \param a The first vertex id
/// \param b The second vertex id
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr void cut_edge2(size_t a, size_t b) {
const auto* ita = _edge_map[a][b];
@@ -600,11 +598,11 @@ public:
}
///
/// \brief Break *all* edges connected to \f$n\f$
/// \brief Break *all* edges connected to \emph{n}
/// \param n The vertex id
///
/// \par Complexity
/// \f$O(M)\f$
/// \emph{O(M)}
///
void cut(size_t n) {
for (const auto it : outgoing(n)) {
@@ -619,7 +617,7 @@ public:
/// \brief Clear the graph, destructing all vertices and edges.
///
/// \par Complexity
/// \f$O(N + M)\f$
/// \emph{O(N + M)}
///
void clear() {
_vertex_pool.clear();

4
include/fennec/containers/initializer_list.h
View File

@@ -44,7 +44,7 @@ using std::initializer_list;
///
/// \param inls the initializer list
/// \returns A const qualified pointer to the first element in \f$inls\f$
/// \returns A const qualified pointer to the first element in \emph{inls}
template<typename T>
constexpr const T* begin(initializer_list<T> inls) noexcept {
return inls.begin();
@@ -52,7 +52,7 @@ constexpr const T* begin(initializer_list<T> inls) noexcept {
///
/// \param inls the initializer list
/// \returns A const qualified pointer to one past the last element in \f$inls\f$
/// \returns A const qualified pointer to one past the last element in \emph{inls}
template<typename T>
constexpr const T* end(initializer_list<T> inls) noexcept {
return inls.end();

141
include/fennec/containers/list.h
View File

@@ -48,23 +48,22 @@ namespace fennec
/// This data-structure behaves like a linked list, but does not use pointers. Instead, it is in-array. This creates the
/// following properties:
///
/// | Property | Value |
/// |:-----------:|:----------:|
/// | stable | ⛔ |
/// | dynamic | ✅ |
/// | homogeneous | ✅ |
/// | distinct | ⛔ |
/// | ordered | ⛔ |
/// | space | \f$O(N)\f$ |
/// | linear | ✅ |
/// | access | \f$O(N)\f$ |
/// | find | \f$O(N)\f$ |
/// | insertion | \f$O(N)\f$ |
/// | deletion | \f$O(N)\f$ |
/// | space | \f$O(N)\f$ |
/// | Property | Value |
/// |:-----------:|:-----------:|
/// | stable | ⛔ |
/// | dynamic | ✅ |
/// | homogeneous | ✅ |
/// | distinct | ⛔ |
/// | ordered | ⛔ |
/// | linear | ✅ |
/// | space | \emph{O(N)} |
/// | access | \emph{O(N)} |
/// | find | \emph{O(N)} |
/// | insertion | \emph{O(N)} |
/// | deletion | \emph{O(N)} |
///
/// \note Access, Insertion, and Deletion are \f$O(N)\f$ using the index pattern,
/// using the iterator pattern yields \f$O(1)\f$ runtime.
/// \note Access, Insertion, and Deletion are \emph{O(N)} using the index pattern,
/// using the iterator pattern yields \emph{O(1)} runtime.
///
/// \tparam TypeT value type
template<class TypeT, class Alloc = allocator<TypeT>>
@@ -106,18 +105,18 @@ public:
/// \brief Default Constructor, initializes an empty list.
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr list()
: _table(), _freed(), _root(npos), _last(npos), _size(0) {
}
///
/// \brief Copy Constructor, copies all elements in \f$l\f$ with optimized layout
/// \brief Copy Constructor, copies all elements in \emph{l} with optimized layout
/// \param l The list to copy
///
/// \par Complexity
/// \f$O(N)\f$
/// \emph{O(N)}
///
constexpr list(const list& l)
: list() {
@@ -132,7 +131,7 @@ public:
/// \param l The list to move
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr list(list&& l) noexcept
: _table(fennec::move(l._table))
@@ -146,7 +145,7 @@ public:
/// \brief Destructor, destructs all elements then releases the allocation.
///
/// \par Complexity
/// \f$O(N)\f$
/// \emph{O(N)}
///
constexpr ~list() {
clear();
@@ -163,10 +162,10 @@ public:
///
/// \brief Copy Assignment Operator
/// \param l the list to copy
/// \returns \f$this\f$ after having copied all elements of \f$l\f$
/// \returns \emph{this} after having copied all elements of \emph{l}
///
/// \par Complexity
/// \f$O(N)\f$
/// \emph{O(N)}
///
constexpr list& operator=(const list& l) {
this->clear();
@@ -179,10 +178,10 @@ public:
///
/// \brief Move Assignment Operator
/// \param l the list to copy
/// \returns \f$this\f$ after having taken ownership over the contents of \f$l\f$
/// \returns \emph{this} after having taken ownership over the contents of \emph{l}
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr list& operator=(list&& l) noexcept {
this->clear();
@@ -206,7 +205,7 @@ public:
/// \returns The size of the list in elements.
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr size_t size() const {
return _size;
@@ -216,17 +215,17 @@ public:
/// \returns The capacity of the list in elements.
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr size_t capacity() const {
return _table.size();
}
///
/// \returns \f$true\f$ when the list is empty, \f$false\f$ otherwise.
/// \returns \emph{true} when the list is empty, \emph{false} otherwise.
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr bool is_empty() const {
return _root == npos;
@@ -244,10 +243,10 @@ public:
///
/// \brief Array Access Operator
/// \param i Index to access
/// \returns A reference to the element at \f$i\f$
/// \returns A reference to the element at \emph{i}
///
/// \par Complexity
/// \f$O(N)\f$
/// \emph{O(N)}
///
constexpr value_t& operator[](int i) {
assertd(i >= 0 && size_t(i) < _size, "Index out of Bounds");
@@ -259,10 +258,10 @@ public:
///
/// \brief Const Array Access Operator
/// \param i Index to access
/// \returns A const-qualified reference to the element at \f$i\f$
/// \returns A const-qualified reference to the element at \emph{i}
///
/// \par Complexity
/// \f$O(N)\f$
/// \emph{O(N)}
///
constexpr const value_t& operator[](int i) const {
assertd(i >= 0 && size_t(i) < _size, "Index out of Bounds");
@@ -276,7 +275,7 @@ public:
/// \returns A reference to the first element in the list
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr value_t& front() {
return *_table[_root].value;
@@ -287,7 +286,7 @@ public:
/// \returns A const-qualified reference to the first element in the list
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr const value_t& front() const {
return *_table[_root].value;
@@ -298,7 +297,7 @@ public:
/// \returns A reference to the last element in the list
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr value_t& back() {
return *_table[_last].value;
@@ -309,7 +308,7 @@ public:
/// \returns A const-qualified reference to the last element in the list
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr const value_t& back() const {
return *_table[_last].value;
@@ -331,7 +330,7 @@ public:
/// \returns The id of the inserted node
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr iterator insert(const iterator& it, const value_t& x) {
return this->_insert(it._n, x);
@@ -344,7 +343,7 @@ public:
/// \returns The id of the inserted node
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr iterator insert(const iterator& it, value_t&& x) {
return this->_insert(it._n, fennec::forward<value_t>(x));
@@ -357,7 +356,7 @@ public:
/// \returns The id of the inserted node
///
/// \par Complexity
/// \f$O(N)\f$
/// \emph{O(N)}
///
constexpr iterator insert(size_t i, const value_t& x) {
assert(i <= size(), "Index out of Bounds");
@@ -373,7 +372,7 @@ public:
/// \returns The id of the inserted node
///
/// \par Complexity
/// \f$O(N)\f$
/// \emph{O(N)}
///
constexpr iterator insert(size_t i, value_t&& x) {
assert(i <= size(), "Index out of Bounds");
@@ -390,7 +389,7 @@ public:
/// \returns The id of the inserted node
///
/// \par Complexity
/// \f$O(N)\f$
/// \emph{O(N)}
///
template<typename...ArgsT>
constexpr iterator emplace(size_t i, ArgsT&&...args) {
@@ -408,7 +407,7 @@ public:
/// \returns The id of the inserted node
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
template<typename...ArgsT>
constexpr iterator emplace(const iterator& it, ArgsT&&...args) {
@@ -421,7 +420,7 @@ public:
/// \returns The id of the inserted node
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr iterator push_front(const value_t& x) {
return this->_insert(_root, x);
@@ -433,7 +432,7 @@ public:
/// \returns The id of the inserted node
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr iterator push_front(value_t&& x) {
return this->_insert(_root, fennec::forward<value_t>(x));
@@ -446,7 +445,7 @@ public:
/// \returns The id of the inserted node
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
template<typename...ArgsT>
constexpr iterator emplace_front(ArgsT&&...args) {
@@ -459,7 +458,7 @@ public:
/// \returns The id of the inserted node
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr iterator push_back(const value_t& x) {
return this->_insert(npos, x);
@@ -471,7 +470,7 @@ public:
/// \returns The id of the inserted node
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr iterator push_back(value_t&& x) {
return this->_insert(npos, fennec::forward<value_t>(x));
@@ -484,7 +483,7 @@ public:
/// \returns The id of the inserted node
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
template<typename...ArgsT>
constexpr iterator emplace_back(ArgsT&&...args) {
@@ -496,11 +495,11 @@ public:
/// \param i Index to erase
///
/// \par Complexity
/// \f$O(N)\f$
/// \emph{O(N)}
///
constexpr void erase(size_t i) {
assert(i < size(), "Index out of Bounds!");
size_t n = _walk(i);
const size_t n = _walk(i);
_erase(n);
}
@@ -509,7 +508,7 @@ public:
/// \param it Location to Erase
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr void erase(const iterator& it) {
this->_erase(it._n);
@@ -519,7 +518,7 @@ public:
/// \brief Pop Front, erases first element
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr void pop_front() {
_erase(_root);
@@ -529,7 +528,7 @@ public:
/// \brief Pop Back, erases first element
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr void pop_back() {
_erase(_last);
@@ -539,7 +538,7 @@ public:
/// \brief Clears the list, destructing all elements in order
///
/// \par Complexity
/// \f$O(N)\f$
/// \emph{O(N)}
///
constexpr void clear() {
size_t i = _root;
@@ -564,18 +563,18 @@ public:
/// \returns An iterator for the first element in the list
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr iterator begin() {
return iterator(this, _root);
}
///
/// \brief C++ Iterator Specification \f$begin()\f$
/// \brief C++ Iterator Specification \emph{begin()}
/// \returns A const iterator for the first element in the list
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr const_iterator begin() const {
return const_iterator(this, _root);
@@ -585,25 +584,25 @@ public:
/// \returns An iterator for the end of the list
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr iterator end() {
return iterator(this, npos);
}
///
/// \brief Const C++ Iterator Specification \f$end()\f$
/// \brief Const C++ Iterator Specification \emph{end()}
/// \returns A const iterator for the end of the list
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr const_iterator end() const {
return const_iterator(this, npos);
}
///
/// \brief C++ Iterator Specification \f$iterator\f$
/// \brief C++ Iterator Specification \emph{iterator}
class iterator {
public:
///
@@ -615,7 +614,7 @@ public:
///
/// \brief prefix increment operator
/// \param rhs the iterator to increment
/// \returns \f$rhs\f$ after having moved to the next element in the list
/// \returns \emph{rhs} after having moved to the next element in the list
constexpr friend iterator& operator++(iterator& rhs) {
rhs._n = rhs._list->_next(rhs._n);
return rhs;
@@ -624,7 +623,7 @@ public:
///
/// \brief postfix increment operator
/// \param lhs the iterator to increment
/// \returns \f$lhs\f$ before having moved to the next element in the list
/// \returns \emph{lhs} before having moved to the next element in the list
constexpr friend iterator operator++(iterator& lhs, int) {
iterator prev = lhs;
++lhs;
@@ -648,7 +647,7 @@ public:
///
/// \brief iterator equality operator
/// \param it the iterator to compare with
/// \returns \f$true\f$ if the iterators are identical, \f$false\f$ otherwise
/// \returns \emph{true} if the iterators are identical, \emph{false} otherwise
constexpr bool operator==(const iterator& it) {
return _list == it._list and _n == it._n;
}
@@ -656,7 +655,7 @@ public:
///
/// \brief iterator inequality operator
/// \param it the iterator to compare with
/// \returns \f$true\f$ if the iterators are different, \f$false\f$ otherwise
/// \returns \emph{true} if the iterators are different, \emph{false} otherwise
constexpr bool operator!=(const iterator& it) {
return _list != it._list or _n != it._n;
}
@@ -685,7 +684,7 @@ public:
///
/// \brief prefix increment operator
/// \param rhs the iterator to increment
/// \returns \f$rhs\f$ after having moved to the next element in the list
/// \returns \emph{rhs} after having moved to the next element in the list
constexpr friend const_iterator& operator++(const_iterator& rhs) {
if (rhs._list->_next(rhs._n) < rhs._list->capacity()) {
return rhs;
@@ -697,7 +696,7 @@ public:
///
/// \brief postfix increment operator
/// \param lhs the iterator to increment
/// \returns \f$lhs\f$ before having moved to the next element in the list
/// \returns \emph{lhs} before having moved to the next element in the list
constexpr friend const_iterator operator++(const_iterator& lhs, int) {
const_iterator prev = lhs;
++lhs;
@@ -721,7 +720,7 @@ public:
///
/// \brief iterator equality operator
/// \param it the iterator to compare with
/// \returns \f$true\f$ if the iterators are identical, \f$false\f$ otherwise
/// \returns \emph{true} if the iterators are identical, \emph{false} otherwise
constexpr bool operator==(const const_iterator& it) {
return _list == it._list and _n == it._n;
}
@@ -729,7 +728,7 @@ public:
///
/// \brief iterator inequality operator
/// \param it the iterator to compare with
/// \returns \f$true\f$ if the iterators are different, \f$false\f$ otherwise
/// \returns \emph{true} if the iterators are different, \emph{false} otherwise
constexpr bool operator!=(const const_iterator& it) {
return _list != it._list or _n != it._n;
}
@@ -800,7 +799,7 @@ private:
constexpr size_t _next_free() {
if (not _freed.is_empty()) {
size_t n = _freed.back();
const size_t n = _freed.back();
_freed.pop_back();
return n;
}

77
include/fennec/containers/map.h
View File

@@ -56,24 +56,23 @@ namespace fennec
*/
///
/// \brief Data Structure defining a mapping of \f$key\f$ \f$KeyT\f$ to \f$value\f$ \f$ValueT\f$
/// \brief Data Structure defining a mapping of \emph{key} \emph{KeyT} to \emph{value} \emph{ValueT}
/// \details
/// | Property | Value |
/// |:-----------:|:----------:|
/// | stable | ⛔ |
/// | dynamic | ✅ |
/// | homogeneous | ✅ |
/// | distinct | ✅ |
/// | ordered | ⛔ |
/// | space | \f$O(N)\f$ |
/// | linear | ⛔ |
/// | access | \f$O(1)\f$ |
/// | find | \f$O(1)\f$ |
/// | insertion | \f$O(1)\f$ |
/// | deletion | \f$O(1)\f$ |
/// | space | \f$O(N)\f$ |
/// | Property | Value |
/// |:-----------:|:-----------:|
/// | stable | ⛔ |
/// | dynamic | ✅ |
/// | homogeneous | ✅ |
/// | distinct | ✅ |
/// | ordered | ⛔ |
/// | linear | ⛔ |
/// | space | \emph{O(N)} |
/// | access | \emph{O(1)} |
/// | find | \emph{O(1)} |
/// | insertion | \emph{O(1)} |
/// | deletion | \emph{O(1)} |
///
/// \note These runtimes are amortized, in theory the worst case is \f$O(N)\f$, but that is highly improbable.
/// \note These runtimes are amortized, in theory the worst case is \emph{O(N)}, but that is highly improbable.
///
/// \tparam KeyT The Key Type
/// \tparam ValueT The Value Type
@@ -102,7 +101,7 @@ public:
/// \brief key hash helper
struct key_hash : hash_t {
///
/// \brief C++ 11 Hash Specification \f$operator()\f$
/// \brief C++ 11 Hash Specification \emph{operator()}
/// \param p the pair to hash
/// \returns the hash of the key
constexpr size_t operator()(const elem_t& p) const {
@@ -114,10 +113,10 @@ public:
/// \brief key comparison helper
struct key_equals : equality<KeyT> {
///
/// \brief C++ 11 Compare Specification \f$operator()\f$
/// \brief C++ 11 Compare Specification \emph{operator()}
/// \param a the first pair
/// \param b the second pair
/// \returns \f$true\f$ if the keys are equal, \f$false\f$ otherwise
/// \returns \emph{true} if the keys are equal, \emph{false} otherwise
constexpr bool operator()(const elem_t& a, const elem_t& b) const {
return equality<KeyT>::operator()(a.first, b.first);
}
@@ -156,7 +155,7 @@ public:
}
///
/// \returns \f$true\f$ when there are no elements in the set, \f$false\f$ otherwise
/// \returns \emph{true} when there are no elements in the set, \emph{false} otherwise
constexpr size_t is_empty() const {
return _set.size();
}
@@ -179,10 +178,10 @@ public:
///
/// \brief Key Access Operator
/// \param key Key value to access
/// \returns A pointer to the value associated with \f$key\f$, \f$nullptr\f$ if \f$key\f$ is not present.
/// \returns A pointer to the value associated with \emph{key}, \emph{nullptr} if \emph{key} is not present.
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr value_t* operator[](const KeyT& key) {
auto it = _set.at(this->_find(key));
@@ -192,10 +191,10 @@ public:
///
/// \brief Key Const Access Operator
/// \param key Key value to access
/// \returns A const-qualified pointer to the value associated with \f$key\f$, \f$nullptr\f$ if \f$key\f$ is not present.
/// \returns A const-qualified pointer to the value associated with \emph{key}, \emph{nullptr} if \emph{key} is not present.
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr const value_t* operator[](const KeyT& key) const {
auto it = _set.at(this->_find(key));
@@ -206,10 +205,10 @@ public:
/// \brief Argument Key Access Operator
/// \tparam ArgsT Argument Types
/// \param args Arguments to construct the key with
/// \returns A pointer to the value associated with \f$key\f$, \f$nullptr\f$ if \f$key\f$ is not present.
/// \returns A pointer to the value associated with \emph{key}, \emph{nullptr} if \emph{key} is not present.
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
template<typename...ArgsT>
constexpr value_t* operator[](ArgsT&&...args) {
@@ -221,10 +220,10 @@ public:
/// \brief Argument Key Const Access Operator
/// \tparam ArgsT Argument Type
/// \param args Argument to construct the key with
/// \returns A const-qualified pointer to the value associated with \f$key\f$, \f$nullptr\f$ if \f$key\f$ is not present.
/// \returns A const-qualified pointer to the value associated with \emph{key}, \emph{nullptr} if \emph{key} is not present.
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
template<typename...ArgsT>
constexpr const value_t* operator[](ArgsT&&...args) const {
@@ -246,7 +245,7 @@ public:
/// \param pair a pair containing the key and its value
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr void insert(elem_t&& pair) {
this->_insert(fennec::forward<elem_t>(pair));
@@ -258,7 +257,7 @@ public:
/// \param args Arguments for constructing the key-value pair
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
template<typename...ArgsT>
constexpr void emplace(const KeyT& key, ArgsT&&...args) {
@@ -270,7 +269,7 @@ public:
/// \param args Arguments for constructing the key-value pair
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
template<typename...ArgsT>
constexpr void emplace(ArgsT&&...args) {
@@ -282,7 +281,7 @@ public:
/// \param key key to erase
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr void erase(KeyT&& key) {
_set.erase(this->_find(fennec::forward<KeyT>(key)));
@@ -293,7 +292,7 @@ public:
/// \param key key to erase
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr void erase(const KeyT& key) {
_set.erase(this->_find(key));
@@ -305,7 +304,7 @@ public:
/// \param args Arguments to construct a key to erase
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
template<typename...ArgsT>
constexpr void erase(ArgsT&&...args) {
@@ -316,7 +315,7 @@ public:
/// \brief Clears the map destructing all elements
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
void clear() {
_set.clear();
@@ -332,11 +331,11 @@ public:
/// @{
///
/// \brief C++ Iterator Specification \f$begin()\f$
/// \brief C++ Iterator Specification \emph{begin()}
/// \returns an iterator at the start of the map
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr iterator begin() {
return _set.begin();
@@ -344,11 +343,11 @@ public:
///
/// \brief C++ Iterator Specification \f$end()\f$
/// \brief C++ Iterator Specification \emph{end()}
/// \returns an iterator at the end of the map
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr iterator end() {
return _set.end();

107
include/fennec/containers/object_pool.h
View File

@@ -41,20 +41,19 @@ namespace fennec
///
/// \brief Struct which holds a pool of objects associated with ids
/// \details
/// | Property | Value |
/// |:-----------:|:----------:|
/// | stable | ⛔ |
/// | dynamic | ✅ |
/// | homogeneous | ✅ |
/// | distinct | ⛔ |
/// | ordered | ⛔ |
/// | space | \f$O(N)\f$ |
/// | linear | ⛔ |
/// | access | \f$O(1)\f$ |
/// | find | \f$O(N)\f$ |
/// | insertion | \f$O(1)\f$ |
/// | deletion | \f$O(1)\f$ |
/// | space | \f$O(N)\f$ |
/// | Property | Value |
/// |:-----------:|:-----------:|
/// | stable | ⛔ |
/// | dynamic | ✅ |
/// | homogeneous | ✅ |
/// | distinct | ⛔ |
/// | ordered | ⛔ |
/// | linear | ⛔ |
/// | space | \emph{O(N)} |
/// | access | \emph{O(1)} |
/// | find | \emph{O(N)} |
/// | insertion | \emph{O(1)} |
/// | deletion | \emph{O(1)} |
///
/// \tparam TypeT The value type
/// \tparam AllocT The allocator type
@@ -88,7 +87,7 @@ public:
/// \brief Default Constructor, initializes an empty object pool
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr object_pool()
: _size(0) {
@@ -98,7 +97,7 @@ public:
/// \brief Default Destructor, destructs objects then releases the allocation.
///
/// \par Complexity
/// \f$O(N)\f$
/// \emph{O(N)}
///
constexpr ~object_pool() = default;
@@ -114,7 +113,7 @@ public:
/// \returns The number of active objects in the pool
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr size_t size() const {
return _size;
@@ -124,30 +123,30 @@ public:
/// \returns The capacity of the underlying allocation
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr size_t capacity() const {
return _table.capacity();
}
///
/// \returns \f$true\f$ when there are no objects in the pool, \f$false\f$ otherwise
/// \returns \emph{true} when there are no objects in the pool, \emph{false} otherwise
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr bool is_empty() const {
return size() == 0;
}
///
/// \brief Retrieve the next id \f$i\f$ that would be assigned to an object \f$o\f$ were it added to the object pool
/// \brief Retrieve the next id \emph{i} that would be assigned to an object \math{o} were it added to the object pool
///
/// \details This can be useful if there are constant members that need to be assigned at construction.
/// \returns The id of the next inserted node
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr size_t next_id() const {
size_t next = _size;
@@ -167,10 +166,10 @@ public:
///
/// \brief Array Access Operator
/// \param i id of the object
/// \returns a reference to the object with id \f$i\f$
/// \returns a reference to the object with id \emph{i}
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr value_t& operator[](size_t i) {
assert(i < capacity(), "Index out of Bounds!");
@@ -181,10 +180,10 @@ public:
///
/// \brief Array Const Access Operator
/// \param i id of the object
/// \returns a const-qualified reference to the object with id \f$i\f$
/// \returns a const-qualified reference to the object with id \emph{i}
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr const value_t& operator[](size_t i) const {
assert(i < capacity(), "Index out of Bounds!");
@@ -206,24 +205,24 @@ public:
/// @{
///
/// \brief Move Insertion, inserts \f$x\f$ into the pool
/// \brief Move Insertion, inserts \emph{x} into the pool
/// \param x the object to move
/// \returns An integer corresponding to the id of the node
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr size_t insert(value_t&& x) {
return this->_insert(fennec::forward<value_t>(x));
}
///
/// \brief Move Insertion, inserts a copy of \f$x\f$ into the pool
/// \brief Move Insertion, inserts a copy of \emph{x} into the pool
/// \param x the object to copy
/// \returns An integer corresponding to the id of the node
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr size_t insert(const value_t& x) {
return this->_insert(x);
@@ -231,12 +230,12 @@ public:
///
/// \brief Emplacement, constructs a new object using \f$args\ldots\f$
/// \brief Emplacement, constructs a new object using \emph{args...}
/// \param args The arguments to construct the new object with
/// \returns An integer corresponding to the id of the node
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
template<typename...ArgsT>
constexpr size_t emplace(ArgsT&&...args) {
@@ -248,7 +247,7 @@ public:
/// \param i The id of the object
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr void erase(size_t i) {
_table[i] = nullopt;
@@ -260,7 +259,7 @@ public:
/// \brief Clear the object pool
///
/// \par Complexity
/// \f$O(N)\f$
/// \emph{O(N)}
///
constexpr void clear() {
_table.clear();
@@ -277,18 +276,18 @@ public:
/// \returns an iterator at the start of the object pool
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
iterator begin() {
return iterator(this, 0);
}
///
/// \brief C++ Iterator Specification \f$begin()\f$
/// \brief C++ Iterator Specification \emph{begin()}
/// \returns an iterator at the start of the object pool
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
const_iterator begin() const {
return const_iterator(this, 0);
@@ -298,25 +297,25 @@ public:
/// \returns an iterator at the start of the end of the object pool
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
iterator end() {
return iterator(this, _size);
}
///
/// \brief C++ Iterator Specification \f$end()\f$
/// \brief C++ Iterator Specification \emph{end()}
/// \returns an iterator at the start of the end of the object pool
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
const_iterator end() const {
return const_iterator(this, _size);
}
///
/// \brief C++ Iterator Specification \f$iterator\f$
/// \brief C++ Iterator Specification \emph{iterator}
class iterator {
public:
///
@@ -337,18 +336,18 @@ public:
///
/// \brief copy assignment
/// \param it the iterator to copy
/// \returns a reference to self after having copied \f$it\f$
/// \returns a reference to \emph{this} after having copied \emph{it}
iterator& operator=(const iterator& it) = default;
///
/// \brief move assignment
/// \param it the iterator to move
/// \returns a reference to self after having moved \f$it\f$
/// \returns a reference to \emph{this} after having moved \emph{it}
iterator& operator=(iterator&& it) noexcept = default;
///
/// \brief postfix increment operator
/// \returns \f$it\f$ before having been incremented
/// \returns \emph{it} before having been incremented
friend iterator operator++(iterator& it, int) {
iterator ret = it;
++it.curr;
@@ -358,7 +357,7 @@ public:
///
/// \brief prefix increment operator
/// \returns \f$it\f$ after having moved to the next element
/// \returns \emph{it} after having moved to the next element
friend iterator& operator++(iterator& it) {
++it.curr;
it._fix();
@@ -382,7 +381,7 @@ public:
///
/// \brief iterator equality operator
/// \param it the iterator to compare with
/// \returns \f$true\f$ if the iterators are identical, \f$false\f$ otherwise
/// \returns \emph{true} if the iterators are identical, \emph{false} otherwise
bool operator==(const iterator& it) {
return pool == it.pool and curr == it.curr;
}
@@ -390,7 +389,7 @@ public:
///
/// \brief iterator inequality operator
/// \param it the iterator to compare with
/// \returns \f$true\f$ if the iterators are different, \f$false\f$ otherwise
/// \returns \emph{true} if the iterators are different, \emph{false} otherwise
bool operator!=(const iterator& it) {
return pool != it.pool or curr != it.curr;
}
@@ -414,7 +413,7 @@ public:
};
///
/// \brief C++ Iterator Specification \f$const_iterator\f$
/// \brief C++ Iterator Specification \emph{const_iterator}
class const_iterator {
public:
///
@@ -435,18 +434,18 @@ public:
///
/// \brief copy assignment
/// \param it the iterator to copy
/// \returns a reference to self after having copied \f$it\f$
/// \returns a reference to \emph{this} after having copied \emph{it}
const_iterator& operator=(const const_iterator& it) = default;
///
/// \brief move assignment
/// \param it the iterator to move
/// \returns a reference to self after having moved \f$it\f$
/// \returns a reference to \emph{this} after having moved \emph{it}
const_iterator& operator=(const_iterator&& it) noexcept = default;
///
/// \brief postfix increment operator
/// \returns \f$it\f$ before having been incremented
/// \returns \emph{it} before having been incremented
friend const_iterator operator++(const_iterator& it, int) {
const_iterator ret = it;
++it.curr;
@@ -456,7 +455,7 @@ public:
///
/// \brief prefix increment operator
/// \returns \f$it\f$ after having moved to the next element
/// \returns \emph{it} after having moved to the next element
friend const_iterator& operator++(const_iterator& it) {
++it.curr;
it._fix();
@@ -480,7 +479,7 @@ public:
///
/// \brief iterator equality operator
/// \param it the iterator to compare with
/// \returns \f$true\f$ if the iterators are identical, \f$false\f$ otherwise
/// \returns \emph{true} if the iterators are identical, \emph{false} otherwise
bool operator==(const const_iterator& it) {
return pool == it.pool and curr == it.curr;
}
@@ -488,7 +487,7 @@ public:
///
/// \brief iterator inequality operator
/// \param it the iterator to compare with
/// \returns \f$true\f$ if the iterators are different, \f$false\f$ otherwise
/// \returns \emph{true} if the iterators are different, \emph{false} otherwise
bool operator!=(const const_iterator& it) {
return pool != it.pool or curr != it.curr;
}

101
include/fennec/containers/optional.h
View File

@@ -39,34 +39,33 @@
namespace fennec
{
///
/// \brief struct to represent a \f$null\f$ `fennec::optional`
/// \brief struct to represent a \emph{null} `fennec::optional`
struct nullopt_t {};
///
/// \brief value representing a \f$null\f$ `fennec::optional`
/// \brief value representing a \emph{null} `fennec::optional`
constexpr nullopt_t nullopt_v = {};
///
/// \brief alias for representing a \f$null\f$ `fennec::optional`
/// \brief alias for representing a \emph{null} `fennec::optional`
#define nullopt nullopt_v
///
/// \brief Structure to hold an optional value.
/// \details
/// | Property | Value |
/// |:-----------:|:----------:|
/// | stable | ✅ |
/// | dynamic | ⛔ |
/// | homogeneous | ✅ |
/// | distinct | ⛔ |
/// | ordered | ⛔ |
/// | space | \f$O(N)\f$ |
/// | linear | ⛔ |
/// | access | \f$O(1)\f$ |
/// | find | ⛔ |
/// | insertion | \f$O(1)\f$ |
/// | deletion | \f$O(1)\f$ |
/// | space | \f$O(1)\f$ |
/// | Property | Value |
/// |:-----------:|:-----------:|
/// | stable | ✅ |
/// | dynamic | ⛔ |
/// | homogeneous | ✅ |
/// | distinct | ⛔ |
/// | ordered | ⛔ |
/// | linear | ⛔ |
/// | space | \emph{O(1)} |
/// | access | \emph{O(1)} |
/// | find | ⛔ |
/// | insertion | \emph{O(1)} |
/// | deletion | \emph{O(1)} |
///
/// \tparam T
template<typename T>
@@ -95,7 +94,7 @@ public:
/// \brief Default Constructor
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr optional()
: _root(0)
@@ -106,7 +105,7 @@ public:
/// \brief Default Constructor
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr optional(nullopt_t)
: _root(0)
@@ -118,7 +117,7 @@ public:
/// \param val the value to initialize the underlying object with
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr optional(const T& val)
: _val(val)
@@ -130,7 +129,7 @@ public:
/// \param val the value to initialize the underlying object with
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr optional(T&& val)
: _val(fennec::forward<T>(val))
@@ -142,7 +141,7 @@ public:
/// \param opt the optional to copy
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr optional(const optional& opt) requires is_copy_assignable_v<T>
: optional() {
@@ -157,7 +156,7 @@ public:
/// \param opt the optional to move
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr optional(optional&& opt) noexcept requires is_move_assignable_v<T>
: optional() {
@@ -174,7 +173,7 @@ public:
/// \param args The argument values
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
template<typename...ArgsT>
constexpr optional(ArgsT&&...args)
@@ -186,7 +185,7 @@ public:
/// \brief destructor
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr ~optional() {
if constexpr(is_fundamental_v<T>) {
@@ -207,20 +206,20 @@ public:
///
/// \brief Implicit Boolean Check
/// \returns \f$true\f$ when there is a value contained
/// \returns \emph{true} when there is a value contained
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr operator bool() const {
return _set;
}
///
/// \returns \f$true\f$ when there is no held value, \f$false\f$ otherwise.
/// \returns \emph{true} when there is no held value, \emph{false} otherwise.
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr bool is_empty() const {
return not _set;
@@ -236,10 +235,10 @@ public:
///
/// \brief Null Assignment
/// \returns A reference to self
/// \returns A reference to \emph{this}
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr optional& operator=(nullopt_t) {
if constexpr(not is_fundamental_v<T>) {
@@ -255,10 +254,10 @@ public:
///
/// \brief Type Copy Assignment
/// \param val The value to set with
/// \returns A reference to self
/// \returns A reference to \emph{this}
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr optional& operator=(const T& val) requires is_copy_constructible_v<T> and is_copy_assignable_v<T> {
if (_set) {
@@ -273,10 +272,10 @@ public:
///
/// \brief Type Move Assignment
/// \param val The value to set with
/// \returns A reference to self
/// \returns A reference to \emph{this}
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr optional& operator=(T&& val) requires is_move_constructible_v<T> and is_move_assignable_v<T> {
if (_set) {
@@ -291,10 +290,10 @@ public:
///
/// \brief Copy Assignment
/// \param opt The optional to copy
/// \returns A reference to self
/// \returns A reference to \emph{this}
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr optional& operator=(const optional& opt) requires is_copy_constructible_v<T> and is_copy_assignable_v<T> {
if (_set != opt._set) {
@@ -314,10 +313,10 @@ public:
///
/// \brief Move Assignment
/// \param opt The optional to move
/// \returns A reference to self
/// \returns A reference to \emph{this}
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr optional& operator=(optional&& opt) noexcept requires is_move_constructible_v<T> and is_move_assignable_v<T> {
if (_set != opt._set) {
@@ -343,20 +342,20 @@ public:
/// @{
///
/// \returns A pointer to the value, \f$nullptr\f$ if there is no value
/// \returns A pointer to the value, \emph{nullptr} if there is no value
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr pointer_t operator->() noexcept {
return _set ? &_val : nullptr;
}
///
/// \returns A const-qualified pointer to the value, \f$nullptr\f$ if there is no value
/// \returns A const-qualified pointer to the value, \emph{nullptr} if there is no value
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr const_pointer_t operator->() const noexcept {
return _set ? &_val : nullptr;
@@ -367,7 +366,7 @@ public:
/// \returns A reference to the value
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr T& operator*() & noexcept {
assertd(_set, "Attempted to reference the value of an unset optional");
@@ -379,7 +378,7 @@ public:
/// \returns A const-qualified reference to the value
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr const T& operator*() const& noexcept {
assertd(_set, "Attempted to reference the value of an unset optional");
@@ -391,7 +390,7 @@ public:
/// \returns A reference to the value
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr T&& operator*() && noexcept {
assertd(_set, "Attempted to reference the value of an unset optional");
@@ -403,7 +402,7 @@ public:
/// \returns A const-qualified reference to the value
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr const T&& operator*() const&& noexcept {
assertd(_set, "Attempted to reference the value of an unset optional");
@@ -423,7 +422,7 @@ public:
/// \returns A reference to the held value
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr T& emplace(T&& val) {
if (_set) {
@@ -441,7 +440,7 @@ public:
/// \returns A reference to the held value
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr T& emplace(const T& val) {
if (_set) {
@@ -459,7 +458,7 @@ public:
/// \returns A reference to the held value
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
template<typename...ArgsT>
constexpr T& emplace(ArgsT&&...args) {
@@ -476,7 +475,7 @@ public:
/// \brief Reset the Optional
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
void reset() {
this->operator=(nullopt);

77
include/fennec/containers/pair.h
View File

@@ -43,20 +43,19 @@ namespace fennec
///
/// \brief Struct for holding a pair of values
/// \details
/// | Property | Value |
/// |:-----------:|:----------:|
/// | stable | ✅ |
/// | dynamic | ⛔ |
/// | homogeneous | ⛔ |
/// | distinct | ⛔ |
/// | ordered | ⛔ |
/// | space | \f$O(N)\f$ |
/// | linear | ✅ |
/// | access | \f$O(1)\f$ |
/// | find | ⛔ |
/// | insertion | ⛔ |
/// | deletion | ⛔ |
/// | space | \f$O(1)\f$ |
/// | Property | Value |
/// |:-----------:|:-----------:|
/// | stable | ✅ |
/// | dynamic | ⛔ |
/// | homogeneous | ⛔ |
/// | distinct | ⛔ |
/// | ordered | ⛔ |
/// | linear | ✅ |
/// | space | \emph{O(1)} |
/// | access | \emph{O(1)} |
/// | find | ⛔ |
/// | insertion | ⛔ |
/// | deletion | ⛔ |
///
/// \tparam TypeT0 The type of the first value
/// \tparam TypeT1 The type of the second value
@@ -85,7 +84,7 @@ public:
/// \brief Default Constructor, invokes default constructor for both elements
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr pair() = default;
@@ -93,7 +92,7 @@ public:
/// \brief Destructor, invokes destructor for both elements
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr ~pair() = default;
@@ -103,7 +102,7 @@ public:
/// \param y Value to copy for the first element
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr pair(const TypeT0& x, const TypeT1& y)
: first(x)
@@ -116,7 +115,7 @@ public:
/// \param y Value to move for the first element
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr pair(TypeT0&& x, TypeT1&& y) noexcept
: first(fennec::forward<TypeT0>(x))
@@ -129,7 +128,7 @@ public:
/// \param arg2 Value to initialize the first element
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
template<typename Arg1T, typename Arg2T>
constexpr pair(Arg1T&& arg1, Arg2T&& arg2)
@@ -142,7 +141,7 @@ public:
/// \param pair The pair to copy
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr pair(const pair& pair)
: first(fennec::copy(pair.first))
@@ -154,7 +153,7 @@ public:
/// \param pair The pair to move
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr pair(pair&& pair) noexcept
: first(fennec::move(pair.first))
@@ -164,10 +163,10 @@ public:
///
/// \brief Copy Assignment, copies both elements
/// \param pair The pair to copy
/// \returns A reference to self
/// \returns A reference to \emph{this}
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr pair& operator=(const pair& pair) {
first = fennec::copy(pair.first);
@@ -178,10 +177,10 @@ public:
///
/// \brief Move Assignment, moves both elements
/// \param pair The pair to move
/// \returns A reference to self
/// \returns A reference to \emph{this}
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr pair& operator=(pair&& pair) {
first = fennec::move(pair.first);
@@ -201,10 +200,10 @@ public:
///
/// \brief Equality Operator
/// \param p Pair to compare with
/// \returns \f$true\f$ when both elements of each pair are equal
/// \returns \emph{true} when both elements of each pair are equal
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr bool operator==(const pair& p) const {
return first == p.first and second == p.second;
@@ -213,10 +212,10 @@ public:
///
/// \brief Inequality Operator
/// \param p Pair to compare with
/// \returns \f$true\f$ when either element of each pair are equal
/// \returns \emph{true} when either element of each pair are equal
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr bool operator!=(const pair& p) const {
return first != p.first or second != p.second;
@@ -225,11 +224,11 @@ public:
///
/// \brief Less Than Operator
/// \param p Pair to compare with
/// \returns lexical comparison of both elements, i.e. returns \f$true\f$ when the first element is less, or they are
/// \returns lexical comparison of both elements, i.e. returns \emph{true} when the first element is less, or they are
/// equal and the second element is less
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr bool operator<(const pair& p) const {
return first < p.first or (first == p.first and second < p.second);
@@ -238,11 +237,11 @@ public:
///
/// \brief Less Equal Operator
/// \param p Pair to compare with
/// \returns lexical comparison of both elements, i.e. returns \f$true\f$ when the first element is less, or they are
/// \returns lexical comparison of both elements, i.e. returns \emph{true} when the first element is less, or they are
/// equal and the second element is less or equal
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr bool operator<=(const pair& p) const {
return first < p.first or (first == p.first and second <= p.second);
@@ -251,11 +250,11 @@ public:
///
/// \brief Greater Than Operator
/// \param p Pair to compare with
/// \returns lexical comparison of both elements, i.e. returns \f$true\f$ when the first element is greater, or they are
/// \returns lexical comparison of both elements, i.e. returns \emph{true} when the first element is greater, or they are
/// equal and the second element is greater
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr bool operator>(const pair& p) const {
return first > p.first or (first == p.first and second > p.second);
@@ -264,11 +263,11 @@ public:
///
/// \brief Greater Equal Operator
/// \param p Pair to compare with
/// \returns lexical comparison of both elements, i.e. returns \f$true\f$ when the first element is greater, or they are
/// \returns lexical comparison of both elements, i.e. returns \emph{true} when the first element is greater, or they are
/// equal and the second element is greater or equal
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr bool operator>=(const pair& p) const {
return first > p.first or (first == p.first and second >= p.second);
@@ -284,9 +283,9 @@ public:
template<typename TypeT0, typename TypeT1>
struct hash<pair<TypeT0, TypeT1>> : hash<TypeT0>, hash<TypeT1> {
///
/// \brief C++ 11 Hash Specification \f$operator()\f$
/// \brief C++ 11 Hash Specification \emph{operator()}
/// \param p The pair to hash
/// \returns a pairing of the hashes of both elements of \f$p\f$ using `fennec::pair_hash`
/// \returns a pairing of the hashes of both elements of \emph{p} using `fennec::pair_hash`
constexpr size_t operator()(const pair<TypeT0, TypeT1>& p) const {
return fennec::pair_hash( // pair the hashes of both elements
hash<TypeT0>::operator()(p.first),

50
include/fennec/containers/priority_queue.h
View File

@@ -56,20 +56,20 @@ namespace fennec
///
/// \brief a priority queue data structure implemented using a binary heap
/// \details
/// | Property | Value |
/// |:-----------:|:----------:|
/// | stable | ⛔ |
/// | dynamic | ✅ |
/// | homogeneous | ✅ |
/// | distinct | ⛔ |
/// | ordered | ✅ |
/// | space | \f$O(N)\f$ |
/// | linear | ✅ |
/// | access | \f$O(1)\f$ |
/// | find | ⛔ |
/// | insertion | \f$O(1)\f$ |
/// | deletion | \f$O(1)\f$ |
/// | space | \f$O(N)\f$ |
/// | Property | Value |
/// |:-----------:|:-----------:|
/// | stable | ⛔ |
/// | dynamic | ✅ |
/// | homogeneous | ✅ |
/// | distinct | ⛔ |
/// | ordered | ✅ |
/// | space | \emph{O(N)} |
/// | linear | ✅ |
/// | access | \emph{O(1)} |
/// | find | ⛔ |
/// | insertion | \emph{O(1)} |
/// | deletion | \emph{O(1)} |
/// | space | \emph{O(N)} |
///
/// \tparam ValueT The value type
/// \tparam CompareT The compare type, defaults to `fennec::less`
@@ -115,7 +115,7 @@ public:
/// \details initializes an empty queue
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr priority_queue()
: _size(0) {
@@ -125,7 +125,7 @@ public:
/// \brief destructor
///
/// \par Complexity
/// \f$O(N)\f$
/// \emph{O(N)}
///
constexpr ~priority_queue() {
while (_size > 0) {
@@ -142,7 +142,7 @@ public:
/// \returns the size of the queue
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr size_t size() const {
return _size;
@@ -152,17 +152,17 @@ public:
/// \returns the capacity of the underlying allocation
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr size_t capacity() const {
return _table.capacity();
}
///
/// \returns \f$true\f$ if the queue holds no elements
/// \returns \emph{true} if the queue holds no elements
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr bool is_empty() const {
return size() == 0;
@@ -176,7 +176,7 @@ public:
/// \returns the value at the front of the queue
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr const value_t& front() const {
return _table[0];
@@ -191,7 +191,7 @@ public:
/// \param key the key to insert
///
/// \par Complexity
/// \f$O(\log N)\f$
/// \emph{O(\log N)}
///
constexpr void push(const value_t& key) {
this->_insert(key);
@@ -201,7 +201,7 @@ public:
/// \param key the key to insert
///
/// \par Complexity
/// \f$O(\log N)\f$
/// \emph{O(\log N)}
///
constexpr void push(value_t&& key) {
this->_insert(fennec::forward<value_t>(key));
@@ -213,7 +213,7 @@ public:
/// \param args the argument values
///
/// \par Complexity
/// \f$O(\log N)\f$
/// \emph{O(\log N)}
///
template<typename...ArgsT>
constexpr void emplace(ArgsT&&...args) {
@@ -224,7 +224,7 @@ public:
/// \brief pop the element at the front of the queue
///
/// \par Complexity
/// \f$O(\log N)\f$
/// \emph{O(\log N)}
///
constexpr void pop() {
fennec::swap(_table[0], _table[--_size]);

196
include/fennec/containers/rdtree.h
View File

@@ -32,7 +32,7 @@
#define FENNEC_CONTAINERS_RDTREE_H
#include <fennec/containers/list.h>
#include <fennec/containers/optional.h>
#include <fennec/containers/deque.h>
#include <fennec/containers/traversal.h>
#include <fennec/containers/pair.h>
@@ -44,20 +44,19 @@ namespace fennec
///
/// \brief Rooted-Directed Tree
/// \details
/// | Property | Value |
/// |:-----------:|:----------:|
/// | stable | ⛔ |
/// | dynamic | ✅ |
/// | homogeneous | ✅ |
/// | distinct | ⛔ |
/// | ordered | ⛔ |
/// | space | \f$O(N)\f$ |
/// | linear | ⛔ |
/// | access | \f$O(1)\f$ |
/// | find | \f$O(N)\f$ |
/// | insertion | \f$O(1)\f$ |
/// | deletion | \f$O(1)\f$ |
/// | space | \f$O(N)\f$ |
/// | Property | Value |
/// |:-----------:|:-----------:|
/// | stable | ⛔ |
/// | dynamic | ✅ |
/// | homogeneous | ✅ |
/// | distinct | ⛔ |
/// | ordered | ⛔ |
/// | linear | ⛔ |
/// | space | \emph{O(N)} |
/// | access | \emph{O(1)} |
/// | find | \emph{O(N)} |
/// | insertion | \emph{O(1)} |
/// | deletion | \emph{O(1)} |
///
/// \tparam TypeT Data type
/// \tparam AllocT Allocator Type
@@ -133,7 +132,7 @@ public:
/// \param args The arguments to construct the root with
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
template<typename...ArgsT>
explicit constexpr rdtree(ArgsT&&...args)
@@ -143,23 +142,62 @@ public:
}
///
/// \brief Copy Constructor, copies the contents of \f$tree\f$
/// \brief Copy Constructor, copies the contents of \emph{tree}
/// \param tree the rdtree to copy
///
/// \par Complexity
/// \f$O(N)\f$
/// \emph{O(N)}
///
constexpr rdtree(const rdtree& tree)
: _table(tree._table), _freed(tree._freed), _size(tree._size) {
// TODO: properly invoke copy constructor for all elements
constexpr rdtree(const rdtree& tree) {
_table.reallocate(tree.size());
// Stack used for depth-first traversal
deque<size_t> visit;
deque<size_t> stack;
// Push the root to the visit queue if the tree isn't empty
if (not tree.is_empty()) {
stack.push_back(npos);
visit.push_back(root);
}
// Iterate
while (not visit.is_empty()) {
// Pop the next node
const size_t node = visit.front();
visit.pop_front();
// Get the next node and the child
const size_t next = tree.next(node);
const size_t child = tree.child(node);
// Fix stack
while (tree.depth(node) < stack.size()) {
stack.pop_back();
}
// Add this node
stack.push_back(insert(stack.back(), npos, tree[node]));
// Push the next node
if (next != npos) {
visit.push_front(next);
}
// Push the child
if (child != npos) {
visit.push_front(child);
}
}
}
///
/// \brief Move Constructor, takes ownership over the contents of \f$tree\f$
/// \brief Move Constructor, takes ownership over the contents of \emph{tree}
/// \param tree the rdtree to move
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr rdtree(rdtree&& tree) noexcept
: _table(fennec::move(tree._table)), _freed(fennec::move(tree._freed)), _size(tree._size) {
@@ -176,10 +214,10 @@ public:
///
/// \brief Copy Assignment Operator
/// \param rhs the rdtree to copy
/// \returns \f$this\f$ after copying the contents of \f$rhs\f$
/// \returns \emph{this} after copying the contents of \emph{rhs}
///
/// \par Complexity
/// \f$O(N)\f$
/// \emph{O(N)}
///
constexpr rdtree& operator=(const rdtree& rhs) {
// TODO: properly invoke copy constructor for all elements
@@ -195,10 +233,10 @@ public:
///
/// \brief Move Assignment Operator
/// \param rhs the rdtree to move
/// \returns \f$this\f$ after taking ownership over the contents of \f$rhs\f$
/// \returns \emph{this} after taking ownership over the contents of \emph{rhs}
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr rdtree& operator=(rdtree&& rhs) noexcept {
for (value_t* it : _table) {
@@ -221,7 +259,7 @@ public:
/// \returns The number of nodes in the tree
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr size_t size() const {
return _size;
@@ -231,17 +269,17 @@ public:
/// \returns The capacity of the underlying allocation
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr size_t capacity() const {
return _table.capacity();
}
///
/// \returns \f$true\f$ when there are no nodes in the tree, \f$false\f$ otherwise
/// \returns \emph{true} when there are no nodes in the tree, \emph{false} otherwise
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr bool is_empty() const {
return _size == 0;
@@ -260,7 +298,7 @@ public:
/// \returns The id of the parent node
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr size_t parent(size_t i) const {
if (i >= _table.capacity()) return npos;
@@ -273,11 +311,11 @@ public:
/// \returns The id of the child node
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr size_t child(size_t i, size_t n = 0) const {
if (i >= _table.capacity() && n != npos) return npos;
size_t c = i == npos ? npos : _table[i].child;
const size_t c = i == npos ? npos : _table[i].child;
if (n != 0)
return next(c, n == npos ? npos : n - 1);
return c;
@@ -289,7 +327,7 @@ public:
/// \returns The id of the next node
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr size_t next(size_t i, size_t n = 0) const {
if (i >= _table.capacity() && n != npos) return npos;
@@ -297,7 +335,7 @@ public:
return npos;
}
size_t org = i;
const size_t org = i;
size_t nxt = _table[i].next;
while (nxt != npos) {
i = nxt;
@@ -318,7 +356,7 @@ public:
/// \returns The id of the previous node
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr size_t prev(size_t i, size_t n = 0) const {
if (i >= _table.capacity()) return npos;
@@ -326,7 +364,7 @@ public:
return npos;
}
size_t org = i;
const size_t org = i;
size_t prv = _table[i].prev;
while (prv != npos) {
i = prv;
@@ -343,10 +381,10 @@ public:
///
/// \param i the node to start at
/// \returns the left-most child of node \f$i\f$
/// \returns the left-most child of node \emph{i}
///
/// \par Complexity
/// \f$O(\log N)\f$
/// \emph{O(\log N)}
///
constexpr size_t left_most(size_t i) const {
if (i >= _table.capacity()) return npos;
@@ -355,7 +393,7 @@ public:
return i;
}
while (true) {
size_t p = n;
const size_t p = n;
if ((n = child(n)) == npos) {
return p;
}
@@ -364,10 +402,10 @@ public:
///
/// \param i the node to start at
/// \returns the right-most child of node \f$i\f$
/// \returns the right-most child of node \emph{i}
///
/// \par Complexity
/// \f$O(\log N)\f$
/// \emph{O(\log N)}
///
constexpr size_t right_most(size_t i) const {
if (i >= _table.capacity()) return npos;
@@ -391,7 +429,7 @@ public:
/// \returns The depth of the node
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr size_t depth(size_t i) const {
if (i >= _table.capacity()) return npos;
@@ -403,7 +441,7 @@ public:
/// \returns The number of children the node has
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr size_t num_children(size_t i) const {
if (i >= _table.capacity()) return 0;
@@ -411,10 +449,10 @@ public:
}
///
/// \returns The next node id were \f$insert\f$ or \f$emplace\f$ to be called
/// \returns The next node id were \emph{insert} or \emph{emplace} to be called
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr size_t next_id() const {
size_t i = _size;
@@ -429,7 +467,7 @@ public:
/// \returns A reference to the value of the node wrapped in an optional
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr value_t& operator[](size_t i) {
return _table[i].value;
@@ -440,7 +478,7 @@ public:
/// \returns A const-qualified reference to the value of the node wrapped in an optional
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr const value_t& operator[](size_t i) const {
return _table[i].value;
@@ -455,28 +493,28 @@ public:
/// @{
///
/// \brief Insertion, creates a node in the tree with parent \f$parent\f$
/// \param parent the parent node, if \f$npos\f$ sets the value of the root node
/// \brief Insertion, creates a node in the tree with parent \emph{parent}
/// \param parent the parent node, if \emph{npos} sets the value of the root node
/// \param next the next node, as an index relative to the parent, i.e. parent[0] == parent.child, parent[1] == parent.child.next
/// \param val the value to insert
/// \returns the index of the created node
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr size_t insert(size_t parent, size_t next, const value_t& val) {
return this->_insert(parent, next, val);
}
///
/// \brief Insertion, creates a node in the tree with parent \f$parent\f$
/// \param parent the parent node, if \f$npos\f$ sets the value of the root node
/// \brief Insertion, creates a node in the tree with parent \emph{parent}
/// \param parent the parent node, if \emph{npos} sets the value of the root node
/// \param next the next node, as an index relative to the parent
/// \param val the value to insert
/// \returns the index of the created node
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr size_t insert(size_t parent, size_t next, value_t&& val) {
return this->_insert(parent, next, fennec::forward<value_t>(val));
@@ -484,13 +522,13 @@ public:
///
/// \brief tree insertion, copies the contents of tree into self with the root at the specified node location
/// \param parent the parent node, if \f$npos\f$ sets the value of the root node
/// \param parent the parent node, if \emph{npos} sets the value of the root node
/// \param next the next node, as an index relative to the parent
/// \param tree the tree to insert
/// \returns the index of the inserted root
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr size_t insert(size_t parent, size_t next, const rdtree& tree) {
list<pair<size_t, size_t>> visit;
@@ -516,14 +554,14 @@ public:
}
///
/// \brief Insertion, creates a node in the tree with parent \f$parent\f$
/// \param parent the parent node, if \f$npos\f$ sets the value of the root node
/// \brief Insertion, creates a node in the tree with parent \emph{parent}
/// \param parent the parent node, if \emph{npos} sets the value of the root node
/// \param next the next node, as an index relative to the parent, i.e. parent[0] == parent.child, parent[1] == parent.child.next
/// \param args the args to construct the value to insert
/// \returns the index of the created node
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
template<typename...ArgsT>
constexpr size_t emplace(size_t parent, size_t next, ArgsT&&...args) {
@@ -536,7 +574,7 @@ public:
/// \param i1 The id of the second node
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr void swap(size_t i0, size_t i1) {
assertf(i0 != root and i1 != root, "Cannot Swap With Root");
@@ -575,16 +613,16 @@ public:
/// \brief Traverse the tree using a specified order and visiting functor
///
/// \details
/// The visitor should accept a reference to a value of type \f$TypeT\f$ and a \f$size_t\f$ which contains the node's id.
/// The visitor should accept a reference to a value of type \emph{TypeT} and a \emph{size_t} which contains the node's id.
/// The visitor should return one of the following values in the `fennec::traversal_control_` enum
///
/// \tparam OrderT The order with which to traverse the tree.
/// \tparam VisitorT The visitor, should fulfill the signature \f$uint8_t visit(TypeT&, size_t)\f$
/// \tparam VisitorT The visitor, should fulfill the signature \emph{uint8_t visit(TypeT&, size_t)}
/// \param visit The visiting object
/// \param i The node to start at
///
/// \par Complexity
/// \f$O(N)\f$
/// \emph{O(N)}
///
template<typename OrderT, typename VisitorT>
constexpr void traverse(VisitorT&& visit, size_t i = root) {
@@ -606,16 +644,16 @@ public:
/// \brief Traverse the tree using a specified order and visiting functor
///
/// \details
/// The visitor should accept a reference to a value of type \f$TypeT\f$ and a \f$size_t\f$ which contains the node's id.
/// The visitor should accept a reference to a value of type \emph{TypeT} and a \emph{size_t} which contains the node's id.
/// The visitor should return one of the following values in the `fennec::traversal_control_` enum
///
/// \tparam OrderT The order with which to traverse the tree.
/// \tparam VisitorT The visitor, should fulfill the signature \f$uint8_t visit(TypeT&, size_t)\f$
/// \tparam VisitorT The visitor, should fulfill the signature \emph{uint8_t visit(TypeT&, size_t)}
/// \param visit The visiting object
/// \param i The node to start at
///
/// \par Complexity
/// \f$O(N)\f$
/// \emph{O(N)}
///
template<typename OrderT, typename VisitorT>
constexpr void traverse(VisitorT&& visit, size_t i = root) const {
@@ -657,8 +695,8 @@ public:
return npos;
}
size_t nxt = tree.next(node);
size_t chd = tree.next(node);
const size_t nxt = tree.next(node);
const size_t chd = tree.next(node);
if (nxt != npos && node != head) {
visit.push_front(nxt);
@@ -680,7 +718,7 @@ public:
private:
list<size_t> visit;
size_t head;
size_t head = npos;
};
///
@@ -707,8 +745,8 @@ public:
return npos;
}
size_t nxt = tree.next(node);
size_t chd = tree.child(node);
const size_t nxt = tree.next(node);
const size_t chd = tree.child(node);
if (nxt != npos && node != head) {
visit.push_front(nxt);
@@ -730,7 +768,7 @@ public:
private:
list<size_t> visit;
size_t head;
size_t head = npos;
};
///
@@ -757,8 +795,8 @@ public:
return npos;
}
size_t prnt = tree.parent(node);
size_t next = tree.next(node);
const size_t prnt = tree.parent(node);
const size_t next = tree.next(node);
if (node != head) {
if (tree.child(prnt) == node) {
visit.push_back(prnt);
@@ -782,7 +820,7 @@ public:
private:
list<size_t> visit;
size_t head;
size_t head = npos;
};
///
@@ -809,8 +847,8 @@ public:
return npos;
}
size_t prnt = tree.parent(node);
size_t next = tree.next(node);
const size_t prnt = tree.parent(node);
const size_t next = tree.next(node);
if (node != head) {
if (next != npos) {
@@ -832,7 +870,7 @@ public:
private:
list<size_t> visit;
size_t head;
size_t head = npos;
};
/// @}

105
include/fennec/containers/sequence.h
View File

@@ -56,20 +56,19 @@ namespace fennec
/// \details
/// This data-structure behaves like an ordered-set, but does not use pointers, instead storing the table in-array
///
/// | Property | Value |
/// |:-----------:|:---------------:|
/// | stable | ✅ |
/// | dynamic | ✅ |
/// | homogeneous | ✅ |
/// | distinct | ✅ |
/// | ordered | ✅ |
/// | space | \f$O(N)\f$ |
/// | linear | ✅ |
/// | access | \f$O(\log N)\f$ |
/// | find | \f$O(\log N)\f$ |
/// | insertion | \f$O(\log N)\f$ |
/// | deletion | \f$O(\log N)\f$ |
/// | space | \f$O(N)\f$ |
/// | Property | Value |
/// |:-----------:|:----------------:|
/// | stable | ✅ |
/// | dynamic | ✅ |
/// | homogeneous | ✅ |
/// | distinct | ✅ |
/// | ordered | ✅ |
/// | linear | ✅ |
/// | space | \emph{O(N)} |
/// | access | \emph{O(\log N)} |
/// | find | \emph{O(\log N)} |
/// | insertion | \emph{O(\log N)} |
/// | deletion | \emph{O(\log N)} |
///
/// \tparam TypeT The type to contain
/// \tparam CompareT Function for comparing two values
@@ -141,27 +140,27 @@ private:
// Member Access Helpers
constexpr value_t& _key(node n) {
static constexpr value_t& _key(node n) {
return n->key;
}
constexpr bool& _color(node n) {
static constexpr bool& _color(node n) {
return n->color;
}
constexpr node& _parent(node n) {
static constexpr node& _parent(node n) {
return n->parent;
}
constexpr node& _child(node n, bool dir) {
static constexpr node& _child(node n, bool dir) {
return n->child[dir];
}
constexpr node& _left(node n) {
static constexpr node& _left(node n) {
return n->child[dir_left];
}
constexpr node& _right(node n) {
static constexpr node& _right(node n) {
return n->child[dir_right];
}
@@ -174,7 +173,7 @@ private:
}
constexpr bool color(node n) {
return n ? n->color : (bool)black;
return n ? n->color : bool(black);
}
constexpr node parent(node n) {
@@ -224,7 +223,7 @@ public:
/// \brief Default Constructor, initializes an empty sequence
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr sequence()
: _root(nullptr), _size(0) {
@@ -234,7 +233,7 @@ public:
/// \brief Move Constructor, takes ownership of a sequence
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr sequence(sequence&&) noexcept = default;
@@ -247,7 +246,7 @@ public:
/// \brief Default Destructor, destructs elements *in-order*
///
/// \par Complexity
/// \f$O(N)\f$
/// \emph{O(N)}
///
constexpr ~sequence() {
this->clear();
@@ -261,12 +260,12 @@ public:
/// @{
///
/// \brief Value Find Function, finds the iterator position for \f$val\f$, otherwise returns \f$end()\f$
/// \brief Value Find Function, finds the iterator position for \emph{val}, otherwise returns \emph{end()}
/// \param val The value to find
/// \returns An iterator at the value
///
/// \par Complexity
/// \f$O(\log N)\f$
/// \emph{O(\log N)}
///
constexpr iterator find(const value_t& val) {
node node = _root;
@@ -285,7 +284,7 @@ public:
///
/// \brief Value Contains Function, checks if the sequence contains a value
/// \param val The value to find
/// \returns \f$true\f$ if \f$val\f$ is in the sequence, \f$false\f$ otherwise
/// \returns \emph{true} if \emph{val} is in the sequence, \emph{false} otherwise
bool contains(const value_t& val) {
return find(val) != end();
}
@@ -302,17 +301,17 @@ public:
/// \returns The number of elements in the sequence
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr size_t size() const {
return _size;
}
///
/// \returns \f$true\f$ when there are no elements in the sequence, \f$false\f$ otherwise.
/// \returns \emph{true} when there are no elements in the sequence, \emph{false} otherwise.
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr bool is_empty() const {
return _size == 0;
@@ -326,11 +325,11 @@ public:
/// @{
///
/// \brief Move Insertion, moves \f$val\f$ into the sequence
/// \brief Move Insertion, moves \emph{val} into the sequence
/// \param val The value to insert
///
/// \par Complexity
/// \f$O(\log N)\f$
/// \emph{O(\log N)}
///
constexpr void insert(value_t&& val) {
node i = _insert_bst(fennec::forward<value_t>(val));
@@ -338,11 +337,11 @@ public:
}
///
/// \brief Copy Insertion, inserts a copy of \f$val\f$ into the sequence
/// \brief Copy Insertion, inserts a copy of \emph{val} into the sequence
/// \param val The value to insert
///
/// \par Complexity
/// \f$O(\log N)\f$
/// \emph{O(\log N)}
///
constexpr void insert(const value_t& val) {
node i = _insert_bst(val);
@@ -355,7 +354,7 @@ public:
/// \param args The arguments to construct with
///
/// \par Complexity
/// \f$O(\log N)\f$
/// \emph{O(\log N)}
///
template<typename...ArgsT>
constexpr void emplace(ArgsT&&...args) {
@@ -368,7 +367,7 @@ public:
/// \param val the value to erase
///
/// \par Complexity
/// \f$O(\log N)\f$
/// \emph{O(\log N)}
///
constexpr void erase(const value_t& val) {
_erase(find(val)._node);
@@ -378,7 +377,7 @@ public:
/// \brief Destructs all elements, *in-order*, contained in the sequence
///
/// \par Complexity
/// \f$O(N)\f$
/// \emph{O(N)}
///
constexpr void clear() {
list<node> visit;
@@ -400,18 +399,18 @@ public:
/// \returns An iterator at the smallest element in the sequence
///
/// \par Complexity
/// \f$O(\log N)\f$
/// \emph{O(\log N)}
///
constexpr iterator begin() {
return sequence::iterator(this, _root);
}
///
/// \brief C++ Iterator Specification \f$begin()\f$
/// \brief C++ Iterator Specification \emph{begin()}
/// \returns An iterator at the smallest element in the sequence
///
/// \par Complexity
/// \f$O(\log N)\f$
/// \emph{O(\log N)}
///
constexpr const_iterator begin() const {
return sequence::const_iterator(this, _root);
@@ -421,32 +420,32 @@ public:
/// \returns An iterator after the largest element in the sequence
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr iterator end() {
return sequence::iterator(this, _root, nullptr);
}
///
/// \brief Const C++ Iterator Specification \f$end()\f$
/// \brief Const C++ Iterator Specification \emph{end()}
/// \returns An iterator after the largest element in the sequence
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr const_iterator end() const {
return sequence::const_iterator(this, _root, nullptr);
}
///
/// \brief C++ Iterator Specification \f$iterator\f$
/// \brief C++ Iterator Specification \emph{iterator}
class iterator {
public:
///
/// \brief prefix increment operator
/// \param it the iterator to increment
/// \returns \f$it\f$ after having moved to the next element in the list
/// \returns \emph{it} after having moved to the next element in the list
friend iterator& operator++(iterator& it) {
if (it._node == nullptr) {
return it;
@@ -477,7 +476,7 @@ public:
///
/// \brief postfix increment operator
/// \param it the iterator to increment
/// \returns \f$it\f$ before having moved to the next element in the list
/// \returns \emph{it} before having moved to the next element in the list
friend iterator operator++(iterator& it, int) {
iterator prev = it;
++it;
@@ -502,7 +501,7 @@ public:
/// \brief iterator equality operator
/// \param lhs the iterator
/// \param rhs the iterator to compare with
/// \returns \f$true\f$ if the iterators are identical, \f$false\f$ otherwise
/// \returns \emph{true} if the iterators are identical, \emph{false} otherwise
constexpr friend bool operator==(const iterator& lhs, const iterator& rhs) {
return lhs._seq == rhs._seq and lhs._node == rhs._node;
}
@@ -511,7 +510,7 @@ public:
/// \brief iterator inequality operator
/// \param lhs the iterator
/// \param rhs the iterator to compare with
/// \returns \f$true\f$ if the iterators are different, \f$false\f$ otherwise
/// \returns \emph{true} if the iterators are different, \emph{false} otherwise
constexpr friend bool operator!=(const iterator& lhs, const iterator& rhs) {
return lhs._seq != rhs._seq or lhs._node != rhs._node;
}
@@ -538,14 +537,14 @@ public:
};
///
/// \brief C++ Iterator Specification \f$iterator\f$
/// \brief C++ Iterator Specification \emph{iterator}
class const_iterator {
public:
///
/// \brief prefix increment operator
/// \param it the iterator to increment
/// \returns \f$it\f$ after having moved to the next element in the list
/// \returns \emph{it} after having moved to the next element in the list
friend const_iterator& operator++(const_iterator& it) {
if (it._node == nullptr) {
return it;
@@ -576,7 +575,7 @@ public:
///
/// \brief postfix increment operator
/// \param it the iterator to increment
/// \returns \f$it\f$ before having moved to the next element in the list
/// \returns \emph{it} before having moved to the next element in the list
friend const_iterator operator++(const_iterator& it, int) {
const_iterator prev = it;
++it;
@@ -601,7 +600,7 @@ public:
/// \brief iterator equality operator
/// \param lhs the iterator
/// \param rhs the iterator to compare with
/// \returns \f$true\f$ if the iterators are identical, \f$false\f$ otherwise
/// \returns \emph{true} if the iterators are identical, \emph{false} otherwise
constexpr friend bool operator==(const const_iterator& lhs, const const_iterator& rhs) {
return lhs._seq == rhs._seq and lhs._node == rhs._node;
}
@@ -610,7 +609,7 @@ public:
/// \brief iterator inequality operator
/// \param lhs the iterator
/// \param rhs the iterator to compare with
/// \returns \f$true\f$ if the iterators are different, \f$false\f$ otherwise
/// \returns \emph{true} if the iterators are different, \emph{false} otherwise
constexpr friend bool operator!=(const const_iterator& lhs, const const_iterator& rhs) {
return lhs._seq != rhs._seq or lhs._node != rhs._node;
}

95
include/fennec/containers/set.h
View File

@@ -49,20 +49,19 @@ namespace fennec
/// \details
/// This data-structure behaves like a set, but does not use pointers, instead storing the table in-array
///
/// | Property | Value |
/// |:-----------:|:----------:|
/// | stable | ⛔ |
/// | dynamic | ✅ |
/// | homogeneous | ✅ |
/// | distinct | ✅ |
/// | ordered | ⛔ |
/// | space | \f$O(N)\f$ |
/// | linear | ✅ |
/// | access | \f$O(1)\f$ |
/// | find | \f$O(1)\f$ |
/// | insertion | \f$O(1)\f$ |
/// | deletion | \f$O(1)\f$ |
/// | space | \f$O(N)\f$ |
/// | Property | Value |
/// |:-----------:|:-----------:|
/// | stable | ⛔ |
/// | dynamic | ✅ |
/// | homogeneous | ✅ |
/// | distinct | ✅ |
/// | ordered | ⛔ |
/// | linear | ✅ |
/// | space | \emph{O(N)} |
/// | access | \emph{O(1)} |
/// | find | \emph{O(1)} |
/// | insertion | \emph{O(1)} |
/// | deletion | \emph{O(1)} |
///
/// \tparam TypeT The type to contain
template<typename TypeT, class Hash = hash<TypeT>, class Equals = equality<TypeT>, class Alloc = allocator<TypeT>>
@@ -112,7 +111,7 @@ public:
/// \brief Default Constructor, initializes empty set
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr set()
: _table()
@@ -127,7 +126,7 @@ public:
/// \param hash the hash object
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr set(const hash_t& hash)
: _table()
@@ -142,7 +141,7 @@ public:
/// \param alloc the allocator object
///
/// \par Complexity
/// \f$O(N)\f$
/// \emph{O(N)}
///
constexpr set(const alloc_t& alloc)
: _table(alloc)
@@ -158,7 +157,7 @@ public:
/// \param alloc the allocator object
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr set(const hash_t& hash, const alloc_t& alloc)
: _table(alloc)
@@ -173,7 +172,7 @@ public:
/// \param set Set to copy
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr set(const set& set)
: _table(set._table)
@@ -188,7 +187,7 @@ public:
/// \param set Set to move
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr set(set&& set) noexcept
: _table(fennec::move(set._table))
@@ -202,7 +201,7 @@ public:
/// \brief Destructor, destructs all elements and releases the allocation
///
/// \par Complexity
/// \f$O(N)\f$
/// \emph{O(N)}
///
constexpr ~set() {
for (size_t i = 0; i < capacity(); ++i) {
@@ -222,17 +221,17 @@ public:
/// \returns Size of the set in elements
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr size_t size() const {
return _size;
}
///
/// \returns \f$true\f$ when the set is empty, \f$false\f$ otherwise
/// \returns \emph{true} when the set is empty, \emph{false} otherwise
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr bool is_empty() const {
return _size == 0;
@@ -242,7 +241,7 @@ public:
/// \returns Capacity of the set in elements
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr size_t capacity() const {
return _table.size();
@@ -262,7 +261,7 @@ public:
/// \returns An iterator at the location of the value
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr iterator find(const elem_t& val) const {
if (capacity() == 0) {
@@ -311,10 +310,10 @@ public:
///
/// \brief Check if a set contains a value
/// \param val Value to check
/// \returns \f$true\f$ if \f$val\f$ can be found, \f$false\f$ otherwise
/// \returns \emph{true} if \emph{val} can be found, \emph{false} otherwise
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr bool contains(const elem_t& val) const {
return this->find(val) != end();
@@ -323,11 +322,11 @@ public:
///
/// \brief Iterator Access
/// \param it Location to access
/// \returns A pointer to the element, \f$nullptr\f$ if not found.
/// \returns A pointer to the element, \emph{nullptr} if not found.
/// The value should not be changed in a manner that will change the hash of the element.
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr elem_t* at(const iterator& it) {
if (it == end()) {
@@ -342,10 +341,10 @@ public:
///
/// \brief Iterator Const Access
/// \param it Location to access
/// \returns A const-qualified pointer to the element, \f$nullptr\f$ if not found.
/// \returns A const-qualified pointer to the element, \emph{nullptr} if not found.
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr const elem_t* at(const iterator& it) const {
if (not _table[it._i].value) return nullptr;
@@ -365,7 +364,7 @@ public:
/// \returns An iterator at the held value
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr iterator insert(elem_t&& val) {
return this->_insert(fennec::forward<elem_t>(val));
@@ -377,7 +376,7 @@ public:
/// \returns An iterator at the held value
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr iterator insert(const elem_t& val) {
return this->_insert(val);
@@ -390,7 +389,7 @@ public:
/// \returns An iterator at the held value
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
template<typename...ArgsT>
constexpr iterator emplace(ArgsT&&...args) {
@@ -402,7 +401,7 @@ public:
/// \param it Location to erase
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr void erase(iterator it) {
size_t i = it._i;
@@ -431,7 +430,7 @@ public:
/// \param val Value to erase
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr void erase(const elem_t& val) {
this->erase(this->find(val));
@@ -441,7 +440,7 @@ public:
/// \brief Clear all elements from the set, destructing them
///
/// \par Complexity
/// \f$O(N)\f$
/// \emph{O(N)}
///
constexpr void clear() {
_table.clear();
@@ -456,11 +455,11 @@ public:
/// @{
///
/// \brief C++ Iterator Specification \f$begin()\f$
/// \brief C++ Iterator Specification \emph{begin()}
/// \returns An iterator for all elements of the set in no particular order
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr iterator begin() const {
iterator it(this, 0);
@@ -471,11 +470,11 @@ public:
}
///
/// \brief C++ Iterator Specification \f$end()\f$
/// \brief C++ Iterator Specification \emph{end()}
/// \returns An iterator representing the end of the set
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
constexpr iterator end() const {
return iterator(this, npos);
@@ -484,10 +483,10 @@ public:
/// @}
///
/// \brief C++ Iterator Specification \f$iterator\f$
/// \brief C++ Iterator Specification \emph{iterator}
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
class iterator {
public:
@@ -500,7 +499,7 @@ public:
///
/// \brief prefix increment operator
/// \param it the iterator to increment
/// \returns \f$it\f$ after having moved to the next element in the list
/// \returns \emph{it} after having moved to the next element in the list
constexpr friend iterator& operator++(iterator& it) {
while (++it._i < it._set->capacity()) {
if (it._set->_table[it._i].value) {
@@ -514,7 +513,7 @@ public:
///
/// \brief postfix increment operator
/// \param it the iterator to increment
/// \returns \f$it\f$ before having moved to the next element in the list
/// \returns \emph{it} before having moved to the next element in the list
constexpr friend iterator operator++(iterator& it, int) {
iterator prev = it;
++it;
@@ -539,7 +538,7 @@ public:
///
/// \brief iterator equality operator
/// \param it the iterator to compare with
/// \returns \f$true\f$ if the iterators are identical, \f$false\f$ otherwise
/// \returns \emph{true} if the iterators are identical, \emph{false} otherwise
constexpr bool operator==(const iterator& it) const {
return _set == it._set and _i == it._i;
}
@@ -547,7 +546,7 @@ public:
///
/// \brief iterator inequality operator
/// \param it the iterator to compare with
/// \returns \f$true\f$ if the iterators are different, \f$false\f$ otherwise
/// \returns \emph{true} if the iterators are different, \emph{false} otherwise
constexpr bool operator!=(const iterator& it) const {
return _set != it._set or _i != it._i;
}

39
include/fennec/containers/tuple.h
View File

@@ -42,20 +42,19 @@ namespace fennec
///
/// \brief Tuple, holds a collection of values of different types
/// \details
/// | Property | Value |
/// |:-----------:|:----------:|
/// | stable | ⛔ |
/// | dynamic | ✅ |
/// | homogeneous | ⛔ |
/// | distinct | ⛔ |
/// | ordered | ⛔ |
/// | space | \f$O(N)\f$ |
/// | linear | ✅ |
/// | access | \f$O(1)\f$ |
/// | find | \f$O(1)\f$ |
/// | insertion | ⛔ |
/// | deletion | ⛔ |
/// | space | \f$O(N)\f$ |
/// | Property | Value |
/// |:-----------:|:-----------:|
/// | stable | ⛔ |
/// | dynamic | ✅ |
/// | homogeneous | ⛔ |
/// | distinct | ⛔ |
/// | ordered | ⛔ |
/// | linear | ✅ |
/// | space | \emph{O(N)} |
/// | access | \emph{O(1)} |
/// | find | \emph{O(1)} |
/// | insertion | ⛔ |
/// | deletion | ⛔ |
///
/// \tparam TypesT The types to store
template<typename...TypesT> struct tuple;
@@ -65,7 +64,7 @@ template<typename...TypesT> struct tuple;
/// \tparam i the index
/// \tparam TypesT the types held in the tuple
/// \param x the tuple
/// \returns the \f$i\f$th element of the tuple
/// \returns the \emph{i}th element of the tuple
template<size_t i, typename...TypesT>
constexpr typename tuple<TypesT...>::template elem_t<i>& get(tuple<TypesT...>& x) {
using elem_t = typename tuple<TypesT...>::template elem_t<i>;
@@ -77,7 +76,7 @@ constexpr typename tuple<TypesT...>::template elem_t<i>& get(tuple<TypesT...>& x
/// \tparam i the index
/// \tparam TypesT the types held in the tuple
/// \param x the tuple
/// \returns the \f$i\f$th element of the tuple
/// \returns the \emph{i}th element of the tuple
template<size_t i, typename...TypesT>
constexpr const typename tuple<TypesT...>::template elem_t<i>& get(const tuple<TypesT...>& x) {
using elem_t = typename tuple<TypesT...>::template elem_t<i>;
@@ -98,7 +97,7 @@ public:
using base_t = detail::_tuple<make_index_metasequence_t<sizeof...(TypesT)>, TypesT...>; //!< the base type
template<size_t i>
using elem_t = typename nth_element<i, TypesT...>::type; //!< helper for getting the \f$i\f$th element
using elem_t = typename nth_element<i, TypesT...>::type; //!< helper for getting the \emph{i}th element
static constexpr size_t size = sizeof...(TypesT); //!< the number of elements held by the tuple
@@ -114,7 +113,7 @@ public:
/// \param args The arguments to initialize the tuple with
///
/// \par Complexity
/// \f$O(N)\f$
/// \emph{O(N)}
///
template<typename...ArgsT>
tuple(ArgsT&&...args)
@@ -126,7 +125,7 @@ public:
/// \param cpy the tuple to copy
///
/// \par Complexity
/// \f$O(N)\f$
/// \emph{O(N)}
///
tuple(const tuple& cpy)
: base_t(cpy) {
@@ -137,7 +136,7 @@ public:
/// \param mov the tuple to move
///
/// \par Complexity
/// \f$O(N)\f$
/// \emph{O(N)}
///
tuple(tuple&& mov)
: base_t(fennec::forward<tuple>(mov)) {

75
include/fennec/containers/variant.h
View File

@@ -40,22 +40,21 @@ namespace fennec
{
///
/// \brief A structure that represents a union between \f$TypesT\ldots\f$
/// \brief A structure that represents a union between \emph{TypesT\ldots}
/// \details
/// | Property | Value |
/// |:-----------:|:----------:|
/// | stable | ✅ |
/// | dynamic | ⛔ |
/// | homogeneous | ⛔ |
/// | distinct | ⛔ |
/// | ordered | ⛔ |
/// | space | \f$O(N)\f$ |
/// | linear | ⛔ |
/// | access | \f$O(1)\f$ |
/// | find | ⛔ |
/// | insertion | \f$O(1)\f$ |
/// | deletion | \f$O(1)\f$ |
/// | space | \f$O(1)\f$ |
/// | Property | Value |
/// |:-----------:|:-----------:|
/// | stable | ✅ |
/// | dynamic | ⛔ |
/// | homogeneous | ⛔ |
/// | distinct | ⛔ |
/// | ordered | ⛔ |
/// | linear | ⛔ |
/// | space | \emph{O(1)} |
/// | access | \emph{O(1)} |
/// | find | ⛔ |
/// | insertion | \emph{O(1)} |
/// | deletion | \emph{O(1)} |
///
/// \tparam TypesT The types to hold in the variant
template<typename...TypesT>
@@ -90,10 +89,10 @@ public:
/// @{
///
/// \brief Default Constructor, constructs the first type in \f$TypesT\ldots\f$ that is default constructible
/// \brief Default Constructor, constructs the first type in \emph{TypesT...} that is default constructible
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
variant()
: _bytes {}
@@ -104,13 +103,13 @@ public:
}
///
/// \brief Conversion Constructor, constructs the type in \f$TypesT\ldots\f$ that is identical to \f$T\f$
/// or the first that is constructible with \f$T\f$
/// \brief Conversion Constructor, constructs the type in \emph{TypesT...} that is identical to \emph{T}
/// or the first that is constructible with \emph{T}
/// \tparam T The type of the value
/// \param t The value to forward
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
template<typename T>
variant(T&& t)
@@ -124,12 +123,12 @@ public:
}
///
/// \brief Emplace Constructor, constructs a type \f$T\f$ that is in \f$TypesT\ldots\f$ that is constructible with \f$ArgsT\ldots\f$
/// \brief Emplace Constructor, constructs a type \emph{T} that is in \emph{TypesT...} that is constructible with \emph{ArgsT...}
/// \tparam ArgsT The arguments of the constructor
/// \param args The argument values
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
template<typename T, typename...ArgsT>
variant(type_identity<T>, ArgsT&&...args)
@@ -146,7 +145,7 @@ public:
/// \param v The variant to copy
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
variant(const variant& v)
: _bytes {}
@@ -169,7 +168,7 @@ public:
/// \param v The variant to move
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
variant(variant&& v) noexcept
: _bytes {}
@@ -191,7 +190,7 @@ public:
/// \brief Destructor, if a type is held, destruct it.
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
~variant() {
_clear();
@@ -211,10 +210,10 @@ public:
/// \brief value assignment operator
/// \tparam T The type to assign
/// \param t the value to assign
/// \returns a reference to \f$self\f$ after assigning \f$t\f$
/// \returns a reference to \emph{self} after assigning \emph{t}
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
template<typename T>
variant& operator=(T&& t) {
@@ -259,7 +258,7 @@ public:
/// \param args the argument values
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
template<typename T, typename...ArgsT> requires(contains_element_v<T, TypesT...>)
void emplace(ArgsT&&...args) {
@@ -273,7 +272,7 @@ public:
/// \param args the argument values
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
template<size_t I, typename...ArgsT>
void emplace(ArgsT&&...args) {
@@ -291,12 +290,12 @@ public:
/// @{
///
/// \brief get the value of the variant interpreted as \f$T\f$
/// \brief get the value of the variant interpreted as \emph{T}
/// \tparam T the type to interpret as
/// \returns The value interpreted as \f$T\f$
/// \returns The value interpreted as \emph{T}
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
template<typename T> requires(contains_element_v<T, TypesT...>)
T& get() {
@@ -305,10 +304,10 @@ public:
///
/// \tparam T the type to interpret as
/// \returns The value interpreted as \f$T\f$
/// \returns The value interpreted as \emph{T}
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
template<typename T> requires(contains_element_v<T, TypesT...>)
const T& get() const {
@@ -317,10 +316,10 @@ public:
///
/// \tparam T the type to interpret as
/// \returns The value interpreted as \f$T\f$
/// \returns The value interpreted as \emph{T}
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
template<size_t I, typename T = nth_element_t<I, TypesT...>> requires(contains_element_v<T, TypesT...>)
T& get() {
@@ -329,10 +328,10 @@ public:
///
/// \tparam T the type to interpret as
/// \returns The value interpreted as \f$T\f$
/// \returns The value interpreted as \emph{T}
///
/// \par Complexity
/// \f$O(1)\f$
/// \emph{O(1)}
///
template<size_t I, typename T = nth_element_t<I, TypesT...>> requires(contains_element_v<T, TypesT...>)
const T& get() const {

44
include/fennec/core/logger.h
View File

@@ -32,9 +32,11 @@
#ifndef FENNEC_CORE_LOGGER_H
#define FENNEC_CORE_LOGGER_H
#include <fennec/containers/pair.h>
#include <fennec/filesystem/file.h>
#include <fennec/rtti/singleton.h>
#include <fennec/containers/tuple.h>
#include <fennec/lang/system.h>
namespace fennec
{
@@ -43,6 +45,31 @@ namespace fennec
/// \brief logger class
class logger : public singleton<logger> {
// Definitions =========================================================================================================
public:
///
/// \brief Log Severities
enum severity : uint32_t {
info = 0,
alert,
warning,
error,
fatal,
};
static const pair<cstring, cstring>& severity_color(uint32_t severity) {
static constexpr pair<cstring, cstring> colors[] = {
{ "\033[0m", "\033[0m" }, // severity_info
{ "\033[36m", "\033[0m" }, // severity_alert
{ "\033[33m", "\033[0m" }, // severity_warning
{ "\033[31m", "\033[0m" }, // severity_error
{ "\033[1;31m", "\033[0m" }, // severity_fatal
};
return colors[severity];
}
// Logger System Interface =============================================================================================
public:
@@ -54,7 +81,8 @@ public:
/// \param str the string to log
/// \param _line the line of the log call
/// \param _file the file log was called in
static void log(const cstring& str,
static void log(uint32_t severity,
const cstring& str,
uint32_t _line = FENNEC_BUILTIN_LINE(),
const char* _file = FENNEC_BUILTIN_FILE()
) {
@@ -66,9 +94,12 @@ public:
inst._logfile.println(str);
}
const auto& color = severity_color(severity);
inst._cout->print(color.first);
inst._cout->print(cstring(_file, strlen(_file)));
inst._cout->printf("({}): ", _line);
inst._cout->println(str);
inst._cout->print(str);
inst._cout->println(color.second);
}
///
@@ -76,7 +107,8 @@ public:
/// \param str the string to log
/// \param _line the line of the log call
/// \param _file the file log was called in
static void log(const string& str,
static void log(uint32_t severity,
const string& str,
uint32_t _line = FENNEC_BUILTIN_LINE(),
const char* _file = FENNEC_BUILTIN_FILE()
) {
@@ -88,9 +120,13 @@ public:
inst._logfile.println(str);
}
const auto& color = severity_color(severity);
inst._cout->print(color.first);
inst._cout->print(cstring(_file, strlen(_file)));
inst._cout->printf("({}): ", _line);
inst._cout->println(str);
inst._cout->print(str);
inst._cout->println(color.second);
}
/// @}

12
include/fennec/core/version.h
View File

@@ -37,6 +37,12 @@
#pragma GCC diagnostic ignored "-Wpedantic"
#endif
#if FENNEC_COMPILER_CLANG
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wgnu-anonymous-struct"
#pragma clang diagnostic ignored "-Wnested-anon-types"
#endif
#if FENNEC_COMPILER_MSVC
#pragma warning(push)
#pragma warning(disable:4201)
@@ -59,13 +65,13 @@ public:
/// @{
union {
uint64_t num; //!< long version number
struct {
uint16_t major = { 1 }; //!< the major version
uint16_t minor = { 0 }; //!< the minor version
uint16_t patch = { 0 }; //!< the patch version
uint16_t meta = { 0 }; //!< the meta version, e.g. "rc.1"
};
uint64_t num; //!< long version number
};
/// @}
@@ -114,6 +120,10 @@ public:
#pragma GCC diagnostic pop
#endif
#ifdef FENNEC_COMPILER_CLANG
#pragma clang diagnostic pop
#endif
#if FENNEC_COMPILER_MSVC
#pragma warning(pop)
#endif

74
include/fennec/filesystem/file.h
View File

@@ -39,19 +39,19 @@ namespace fennec
/// <tr><th style="vertical-align: top">Flags
/// <th style="vertical-align: top">Description
///
/// <tr><td style="vertical-align: top">\f$read\f$
/// <tr><td style="vertical-align: top">\emph{read}
/// <td style="vertical-align: top">Opens file as read-only, reading from start
///
/// <tr><td style="vertical-align: top">\f$write\f$
/// <tr><td style="vertical-align: top">\emph{write}
/// <td style="vertical-align: top">Opens file as write-only, writing to end
///
/// <tr><td style="vertical-align: top">\f$read | write\f$
/// <tr><td style="vertical-align: top">\emph{read | write}
/// <td style="vertical-align: top">Opens file as read-write, reading from start
///
/// <tr><td style="vertical-align: top">\f$write | trunc\f$
/// <tr><td style="vertical-align: top">\emph{write | trunc}
/// <td style="vertical-align: top">Opens file as write-only, destroying contents
///
/// <tr><td style="vertical-align: top">\f$read | write | trunc\f$
/// <tr><td style="vertical-align: top">\emph{read | write | trunc}
/// <td style="vertical-align: top">Opens file as read-write, destroying contents
/// </table>
enum fmode_ : uint8_t
@@ -147,7 +147,7 @@ public:
file();
///
/// \details Initializes a stream pointing to \f$path\f$ opened with \f$mode\f$
/// \details Initializes a stream pointing to \emph{path} opened with \emph{mode}
/// \param path the path of the file
/// \param mode the mode to open with
file(const cstring& path, uint8_t mode)
@@ -156,7 +156,7 @@ public:
}
///
/// \details Initializes a stream pointing to \f$path\f$ opened with \f$mode\f$
/// \details Initializes a stream pointing to \emph{path} opened with \emph{mode}
/// \param path the path of the file
/// \param mode the mode to open with
file(const string& path, uint8_t mode)
@@ -166,7 +166,7 @@ public:
///
/// \brief Path constructor
/// \details Initializes a stream pointing to \f$path\f$ opened with \f$mode\f$
/// \details Initializes a stream pointing to \emph{path} opened with \emph{mode}
/// \param path the path of the file
/// \param mode the mode to open with
file(const path& path, uint8_t mode)
@@ -179,23 +179,39 @@ public:
/// \param file the stream to take ownership of
file(file&& file) noexcept;
///
/// \brief Copy Constructor
/// \details Deleted, no semantics for copying a stream. Holding multiple copies of a stream will cause conflicts.
file(const file&) = delete;
///
/// \brief Destructor
/// \details Flushes and closes an open stream
~file();
///@}
// Assignment ==========================================================================================================
public:
/// \name Assignment
/// @{
///
/// \brief Move assignment
/// \param file the stream to take ownership of
file& operator=(file&& file) noexcept;
///@}
private:
// don't allow copying streams
file(const file&) = delete;
///
/// \brief Copy Assignment
/// \details Deleted, no semantics for copying a stream. Holding multiple copies of a stream will cause conflicts.
/// \returns Deleted
file& operator=(const file&) = delete;
/// @}
// Properties ==========================================================================================================
public:
@@ -216,7 +232,7 @@ public:
}
///
/// \returns \f$true\f$ if there is a valid, open stream.
/// \returns \emph{true} if there is a valid, open stream.
bool is_open() const {
return _handle != nullptr;
}
@@ -233,30 +249,30 @@ public:
///
/// \param path the path to the file
/// \param mode the mode flags to open the file with
/// \returns \f$false\f$ on success, \f$true\f$ on error
/// \returns \emph{false} on success, \emph{true} on error
bool open(const cstring& path, uint8_t mode);
///
/// \param path the path to the file
/// \param mode the mode flags to open the file with
/// \returns \f$false\f$ on success, \f$true\f$ on error
/// \returns \emph{false} on success, \emph{true} on error
bool open(const string& path, uint8_t mode);
///
/// \brief Open a file
/// \param path the path to the file
/// \param mode the mode flags to open the file with
/// \returns \f$false\f$ on success, \f$true\f$ on error
/// \returns \emph{false} on success, \emph{true} on error
bool open(const path& path, uint8_t mode);
///
/// \brief Close a stream
/// \returns \f$false\f$ on success, \f$true\f$ on error
/// \returns \emph{false} on success, \emph{true} on error
bool close();
///
/// \brief Commit the streams buffer to the file
/// \returns \f$false\f$ on success, \f$true\f$ on error
/// \returns \emph{false} on success, \emph{true} on error
bool commit();
/// @}
@@ -270,12 +286,12 @@ public:
///
/// \brief closes the stream and erases the file
/// \returns \f$false\f$ on success, \f$true\f$ on error
/// \returns \emph{false} on success, \emph{true} on error
bool erase();
///
/// \param path the new path
/// \returns \f$false\f$ on success, \f$true\f$ on error
/// \returns \emph{false} on success, \emph{true} on error
///
/// \details
/// Copies contents to the new path, and erases the old file.
@@ -288,7 +304,7 @@ public:
///
/// \param path the new path
/// \returns \f$false\f$ on success, \f$true\f$ on error
/// \returns \emph{false} on success, \emph{true} on error
///
/// \details
/// Copies contents to the new path, and erases the old file.
@@ -302,7 +318,7 @@ public:
///
/// \brief Rebind the stream.
/// \param path the new path
/// \returns \f$false\f$ on success, \f$true\f$ on error
/// \returns \emph{false} on success, \emph{true} on error
///
/// \details
/// Copies contents to the new path, and erases the old file.
@@ -366,16 +382,16 @@ public:
///
/// \param i the new index to move to
/// \returns \f$false\f$ on success, \f$true\f$ otherwise
/// \returns \emph{false} on success, \emph{true} otherwise
bool set_pos(size_t i);
///
/// \brief return to the start of the stream
/// \returns \f$false\f$ on success, \f$true\f$ otherwise
/// \returns \emph{false} on success, \emph{true} otherwise
bool rewind();
///
/// \returns \f$true\f$ if the stream has reached the end of the file, \f$false\f$ otherwise
/// \returns \emph{true} if the stream has reached the end of the file, \emph{false} otherwise
bool eof() const;
/// @}
@@ -429,13 +445,13 @@ public:
///
/// \brief put a character at the current position in the stream
/// \param c the character to put
/// \returns \f$false\f$ on success, \f$true\f$ otherwise
/// \returns \emph{false} on success, \emph{true} otherwise
bool putc(char c);
///
/// \brief put a wide character at the current position in the stream
/// \param c the character to put
/// \returns \f$false\f$ on success, \f$true\f$ otherwise
/// \returns \emph{false} on success, \emph{true} otherwise
bool putwc(wchar_t c);
///
@@ -551,7 +567,7 @@ public:
/// \param args the argument values
template<typename...ArgsT>
void printf(const cstring& str, ArgsT&&...args) {
string fmt = fennec::format(str, fennec::forward<ArgsT>(args)...);
const string fmt = fennec::format(str, fennec::forward<ArgsT>(args)...);
this->print(cstring(fmt.cstr(), fmt.length()));
}

40
include/fennec/filesystem/path.h
View File

@@ -115,7 +115,7 @@ public:
///
/// \brief C-String Assignment Operator
/// \param str the cstring to assign
/// \returns a reference to \f$this\f$ after assigning \f$p\f$
/// \returns a reference to \emph{this} after assigning \emph{p}
template<size_t n>
path& operator=(const char (&str)[n]) {
_str = str;
@@ -125,7 +125,7 @@ public:
///
/// \brief C-String Assignment Operator
/// \param p the cstring to assign
/// \returns a reference to \f$this\f$ after assigning \f$p\f$
/// \returns a reference to \emph{this} after assigning \emph{p}
path& operator=(const cstring& p) {
_str = p;
return *this;
@@ -134,7 +134,7 @@ public:
///
/// \brief String Assignment Operator
/// \param p the cstring to assign
/// \returns a reference to \f$this\f$ after assigning \f$p\f$
/// \returns a reference to \emph{this} after assigning \emph{p}
path& operator=(const string& p) {
_str = p;
return *this;
@@ -143,7 +143,7 @@ public:
///
/// \brief Path Copy Assignment Operator
/// \param p the path to copy
/// \returns a reference to \f$this\f$ after copying \f$p\f$
/// \returns a reference to \emph{this} after copying \emph{p}
path& operator=(const path& p) {
_str = p._str;
return *this;
@@ -152,7 +152,7 @@ public:
///
/// \brief Path Move Assignment Operator
/// \param p the path to take ownership of
/// \returns a reference to \f$this\f$ after taking ownership of \f$p\f$
/// \returns a reference to \emph{this} after taking ownership of \emph{p}
path& operator=(path&& p) noexcept {
_str = move(p._str);
return *this;
@@ -170,7 +170,7 @@ public:
///
/// \brief path equality operator
/// \param p the path to compare against
/// \returns \f$true\f$ if the paths are identical, \f$false\f$ otherwise. relative paths are not resolved
/// \returns \emph{true} if the paths are identical, \emph{false} otherwise. relative paths are not resolved
bool operator==(const path& p) const {
return _str == p._str;
}
@@ -187,7 +187,7 @@ public:
///
/// \brief path append operator
/// \param str the filename to append
/// \returns a path containing the current path followed by \f$str\f$
/// \returns a path containing the current path followed by \emph{str}
path operator/(const cstring& str) const {
return path(_str + '/' + str);
}
@@ -195,7 +195,7 @@ public:
///
/// \brief path append operator
/// \param str the filename to append
/// \returns a path containing the current path followed by \f$str\f$
/// \returns a path containing the current path followed by \emph{str}
path operator/(const string& str) const {
return path(_str + '/' + str);
}
@@ -203,7 +203,7 @@ public:
///
/// \brief path append operator
/// \param p the path to append
/// \returns a path containing the current path followed by \f$p\f$
/// \returns a path containing the current path followed by \emph{p}
path operator/(const path& p) const {
return path(_str + '/' + p._str);
}
@@ -214,7 +214,7 @@ public:
/// \brief the filename of the current path
/// \returns a string containing a copy of the filename
string filename() const {
size_t i = _str.rfind('/');
const size_t i = _str.rfind('/');
return _str.substring(i + 1);
}
@@ -227,9 +227,9 @@ public:
const char* cstr() const { return _str.cstr(); }
///
/// \returns \f$true\f$ if the path is empty or points to root
/// \returns \emph{true} if the path is empty or points to root
bool is_empty() {
size_t size = _str.size();
const size_t size = _str.size();
if (size == 0) return true;
#if FENNEC_PLATFORM_WINDOWS
return (_str[1] == ':' && size == 3);
@@ -322,21 +322,21 @@ public:
/// @{
///
/// \brief C++ Iterator Specification \f$begin()\f$
/// \brief C++ Iterator Specification \emph{begin()}
/// \returns an iterator at the first filename in the path
iterator begin() const {
return iterator(this, 0);
}
///
/// \brief C++ Iterator Specification \f$end()\f$
/// \brief C++ Iterator Specification \emph{end()}
/// \returns an iterator to the end of the path
iterator end() const {
return iterator(this, _str.size());
}
///
/// \brief C++ Iterator Specification \f$iterator\f$
/// \brief C++ Iterator Specification \emph{iterator}
class iterator {
public:
///
@@ -363,7 +363,7 @@ public:
///
/// \brief prefix increment operator
/// \returns \f$self\f$ after having moved to the next element in the list
/// \returns \emph{self} after having moved to the next element in the list
constexpr iterator& operator++() {
_pos = min(_str->find('/', _pos) + 1, _str->size());
return *this;
@@ -371,9 +371,9 @@ public:
///
/// \brief postfix increment operator
/// \returns \f$self\f$ before having moved to the next element in the list
/// \returns \emph{self} before having moved to the next element in the list
constexpr iterator operator++(int) {
iterator it = *this;
const iterator it = *this;
this->operator++();
return it;
}
@@ -381,7 +381,7 @@ public:
///
/// \brief iterator equality operator
/// \param rhs the iterator to compare with
/// \returns \f$true\f$ if the iterators are identical, \f$false\f$ otherwise
/// \returns \emph{true} if the iterators are identical, \emph{false} otherwise
constexpr bool operator==(const iterator& rhs) const {
return _str == rhs._str and _pos == rhs._pos;
}
@@ -389,7 +389,7 @@ public:
///
/// \brief iterator inequality operator
/// \param rhs the iterator to compare with
/// \returns \f$true\f$ if the iterators are different, \f$false\f$ otherwise
/// \returns \emph{true} if the iterators are different, \emph{false} otherwise
constexpr bool operator!=(const iterator& rhs) const {
return _str != rhs._str or _pos != rhs._pos;
}

2
include/fennec/format/format.h
View File

@@ -60,6 +60,8 @@ string format(const cstring& str, ArgsT&&...args) {
.type = '\0',
};
static_assert(argc > 0, "fennec::format may not accept 0 arguments");
// empty case
if constexpr(argc == 0) {
return str;

44
include/fennec/format/formatter.h
View File

@@ -48,9 +48,9 @@ struct formatter {
///
/// \brief default format function
///
/// \details throws a static assertion
/// \details Fails an assertion, the formatter is not implemented for the provided type
/// \returns empty string
string operator()(const format_arg&, const T&) {
string operator()(const format_arg&, const T&) const {
static_assert(false, "Formatter not implemented for the provided type.");
return string("");
}
@@ -59,6 +59,8 @@ struct formatter {
// strings =============================================================================================================
// TODO: String formatting
///
/// \brief formatter of a character array
/// \tparam N the number of characters
@@ -67,8 +69,8 @@ struct formatter<char[N]> {
///
/// \brief format function
/// \param str the string argument
/// \returns the formatted version of \f$str\f$
string operator()(const format_arg&, const char (&str)[N]) {
/// \returns the formatted version of \emph{str}
string operator()(const format_arg&, const char (&str)[N]) const {
return string(str);
}
};
@@ -81,8 +83,8 @@ struct formatter<const char[N]> {
///
/// \brief format function
/// \param str the string argument
/// \returns the formatted version of \f$str\f$
string operator()(const format_arg&, const char (&str)[N]) {
/// \returns the formatted version of \emph{str}
string operator()(const format_arg&, const char (&str)[N]) const {
return string(str);
}
};
@@ -94,8 +96,8 @@ struct formatter<cstring> {
///
/// \brief format function
/// \param str the string argument
/// \returns the formatted version of \f$str\f$
string operator()(const format_arg&, const cstring& str) {
/// \returns the formatted version of \emph{str}
string operator()(const format_arg&, const cstring& str) const {
return str;
}
};
@@ -107,8 +109,8 @@ struct formatter<string> {
///
/// \brief format function
/// \param str the string argument
/// \returns the formatted version of \f$str\f$
string operator()(const format_arg&, const string& str) {
/// \returns the formatted version of \emph{str}
string operator()(const format_arg&, const string& str) const {
return str;
}
};
@@ -124,12 +126,12 @@ struct formatter<IntT> {
/// \brief format function
/// \param fmt the format specification
/// \param x the integral argument
/// \returns the formatted version of \f$x\f$
string operator()(const format_arg& fmt, IntT x) {
/// \returns the formatted version of \emph{x}
string operator()(const format_arg& fmt, IntT x) const {
char digits[128] = {};
auto chk = fennec::to_chars(digits, digits + sizeof(digits), fennec::abs(x), fmt.base);
assertf(chk != nullptr, "fennec::format error, to_chars error");
size_t len = chk - digits;
const size_t len = chk - digits;
// handle uppercase
if (fmt.upper) {
@@ -163,8 +165,8 @@ struct formatter<IntT> {
memset(res.data(), fmt.fill, explen - len);
break;
case '^':
size_t bef = fill / 2 + has_sign + prefix;
size_t aft = explen - bef;
const size_t bef = fill / 2 + has_sign + prefix;
const size_t aft = explen - bef;
memcpy(res.data() + bef, digits, len);
sign = fmt.fill == '0' ? 0 : bef - 1 - prefix;
memset(res.data(), fmt.fill, bef);
@@ -200,8 +202,8 @@ struct formatter<BoolT> {
/// \brief format function
/// \param fmt the format specification
/// \param x the boolean argument
/// \returns the formatted version of \f$x\f$
string operator()(const format_arg& fmt, BoolT x) {
/// \returns the formatted version of \emph{x}
string operator()(const format_arg& fmt, BoolT x) const {
if (fmt.type == 's' or fmt.type == '\0') {
return x ? string("true") : string("false");
}
@@ -218,8 +220,8 @@ struct formatter<FloatT> {
/// \brief format function
/// \param fmt the format specification
/// \param x the float argument
/// \returns the formatted version of \f$x\f$
string operator()(const format_arg& fmt, FloatT x) {
/// \returns the formatted version of \emph{x}
string operator()(const format_arg& fmt, FloatT x) const {
// nan & inf cases
if (fennec::isnan(x)) {
@@ -267,8 +269,8 @@ struct formatter<FloatT> {
memset(res.data(), fmt.fill, explen - len);
break;
case '^':
size_t bef = fill / 2 + has_sign + prefix;
size_t aft = explen - bef;
const size_t bef = fill / 2 + has_sign + prefix;
const size_t aft = explen - bef;
memcpy(res.data() + bef, digits, len);
sign = fmt.fill == '0' ? 0 : bef - 1 - prefix;
memset(res.data(), fmt.fill, bef);

4
include/fennec/interpret/tokenizer.h
View File

@@ -94,8 +94,8 @@ private:
list<token> res;
priority_queue<pair<size_t, uint8_t>> idx;
for (char c : delimiter) {
size_t i = 0;
for (const char c : delimiter) {
const size_t i = 0;
while (i != line.size()) {
size_t n = line.find(c, i);
// TODO

10
include/fennec/lang/assert.h
View File

@@ -48,18 +48,18 @@
/// <tr><td width="50%" style="vertical-align: top"> <br>
/// assert(expr, desc)
/// <td width="50%" style="vertical-align: top">
/// Make an assertion with expression \f$expr\f$ and provide a description \f$desc\f$. Only halts in debug mode.
/// Make an assertion with expression \emph{expr} and provide a description \emph{desc}. Only halts in debug mode.
///
/// <tr><td width="50%" style="vertical-align: top"> <br>
/// assertf(expr, desc)
/// <td width="50%" style="vertical-align: top">
/// Make an assertion with expression \f$expr\f$ and provide a description \f$desc\f$. Always halts.
/// Make an assertion with expression \emph{expr} and provide a description \emph{desc}. Always halts.
///
/// <tr><td width="50%" style="vertical-align: top"> <br>
/// assertd(expr, desc)
/// <td width="50%" style="vertical-align: top">
/// Make an assertion, ***only in debug mode***, with expression \f$expr\f$ and provide a description \f$desc\f$.
/// This should be used when the branching caused by \f$assert\f$ would hinder performance in release mode.
/// Make an assertion, ***only in debug mode***, with expression \emph{expr} and provide a description \emph{desc}.
/// This should be used when the branching caused by \emph{assert} would hinder performance in release mode.
///
/// </table>
///
@@ -92,7 +92,7 @@ void _assert(const char (&expr)[ExprL],
/// \param description the description of the assertion
#define assert(expression, description) \
if(not(expression)) [[unlikely]] { \
_assert(#expression, __FILE__, __LINE__, __PRETTY_FUNCTION__, description, not FENNEC_RELEASE); \
_assert(#expression, __FILE__, __LINE__, __PRETTY_FUNCTION__, description, FENNEC_DEBUG); \
}
///

2
include/fennec/lang/bits.h
View File

@@ -116,7 +116,7 @@ constexpr ToT bit_cast(const FromT& from) {
/// \param arr the array of bytes to modify
/// \param mask the mask to and against arr
/// \param n the number of bytes
/// \returns the pointer \f$arr\f$
/// \returns the pointer \emph{arr}
constexpr void* bit_and(void* arr, const void* mask, size_t n) {
if (arr == mask) {
return arr;

88
include/fennec/lang/compare.h
View File

@@ -33,23 +33,23 @@ namespace fennec
template<typename T0, typename T1 = T0> struct equality;
///
/// \brief Implementations for two types that have a common equality operator \f$==\f$
/// \brief Implementations for two types that have a common equality operator \math{=}
/// \tparam T0 The first type
/// \tparam T1 The second type
template<typename T0, typename T1> requires has_equals_v<T0, T1>
struct equality<T0, T1> {
///
/// \brief operator to test the two values
/// \param x the value of type \f$T0\f$
/// \param y the value of type \f$T1\f$
/// \returns \f$true\f$ if equal, \f$false\f$ otherwise
/// \param x the value of type \emph{T0}
/// \param y the value of type \emph{T1}
/// \returns \emph{true} if equal, \emph{false} otherwise
constexpr bool operator()(const T0& x, const T1& y) const {
return x == y;
}
};
///
/// \brief Implementations for two types that have a common less operator \f$<\f$
/// \brief Implementations for two types that have a common less operator \math{<}
/// \tparam T0 The first type
/// \tparam T1 The second type
template<typename T0, typename T1> requires(not has_equals_v<T0, T1>
@@ -57,16 +57,16 @@ template<typename T0, typename T1> requires(not has_equals_v<T0, T1>
struct equality<T0, T1> {
///
/// \brief operator to test the two values
/// \param x the value of type \f$T0\f$
/// \param y the value of type \f$T1\f$
/// \returns \f$true\f$ if equal, \f$false\f$ otherwise
/// \param x the value of type \emph{T0}
/// \param y the value of type \emph{T1}
/// \returns \emph{true} if equal, \emph{false} otherwise
constexpr bool operator()(const T0& x, const T1& y) const {
return not(x < y) and not(y < x);
}
};
///
/// \brief Implementations for two types that have a common greater operator \f$>\f$
/// \brief Implementations for two types that have a common greater operator \math{>}
/// \tparam T0 The first type
/// \tparam T1 The second type
template<typename T0, typename T1> requires(not(has_equals_v<T0, T1>)
@@ -75,9 +75,9 @@ template<typename T0, typename T1> requires(not(has_equals_v<T0, T1>)
struct equality<T0, T1> {
///
/// \brief operator to test the two values
/// \param x the value of type \f$T0\f$
/// \param y the value of type \f$T1\f$
/// \returns \f$true\f$ if equal, \f$false\f$ otherwise
/// \param x the value of type \emph{T0}
/// \param y the value of type \emph{T1}
/// \returns \emph{true} if equal, \emph{false} otherwise
constexpr bool operator()(const T0& x, const T1& y) const {
return not(x > y) and not(y > x);
}
@@ -93,16 +93,16 @@ struct equality<T0, T1> {
template<typename T0, typename T1 = T0> struct inequality;
///
/// \brief Implementations for two types that have a common inequality operator \f$\neq\f$
/// \brief Implementations for two types that have a common inequality operator \math{\neq}
/// \tparam T0 The first type
/// \tparam T1 The second type
template<typename T0, typename T1> requires has_nequals_v<T0, T1>
struct inequality<T0, T1> {
///
/// \brief operator to test the two values
/// \param x the value of type \f$T0\f$
/// \param y the value of type \f$T1\f$
/// \returns \f$true\f$ if not equal, \f$false\f$ otherwise
/// \param x the value of type \emph{T0}
/// \param y the value of type \emph{T1}
/// \returns \emph{true} if not equal, \emph{false} otherwise
constexpr bool operator()(const T0& x, const T1& y) const {
return x != y;
}
@@ -110,48 +110,48 @@ struct inequality<T0, T1> {
///
/// \brief Implementations for two types that have a common equality operator \f$==\f$
/// \brief Implementations for two types that have a common equality operator \math{=}
/// \tparam T0 The first type
/// \tparam T1 The second type
template<typename T0, typename T1> requires has_equals_v<T0, T1>
struct inequality<T0, T1> {
///
/// \brief operator to test the two values
/// \param x the value of type \f$T0\f$
/// \param y the value of type \f$T1\f$
/// \returns \f$true\f$ if not equal, \f$false\f$ otherwise
/// \param x the value of type \emph{T0}
/// \param y the value of type \emph{T1}
/// \returns \emph{true} if not equal, \emph{false} otherwise
constexpr bool operator()(const T0& x, const T1& y) const {
return not (x == y);
}
};
///
/// \brief Implementations for two types that have a common less operator \f$<\f$
/// \brief Implementations for two types that have a common less operator \math{<}
/// \tparam T0 The first type
/// \tparam T1 The second type
template<typename T0, typename T1> requires has_less_v<T0, T1> and has_less_v<T1, T0>
struct inequality<T0, T1> {
///
/// \brief operator to test the two values
/// \param x the value of type \f$T0\f$
/// \param y the value of type \f$T1\f$
/// \returns \f$true\f$ if not equal, \f$false\f$ otherwise
/// \param x the value of type \emph{T0}
/// \param y the value of type \emph{T1}
/// \returns \emph{true} if not equal, \emph{false} otherwise
constexpr bool operator()(const T0& x, const T1& y) const {
return (x < y) or (y < x);
}
};
///
/// \brief Implementations for two types that have a common greater operator \f$>\f$
/// \brief Implementations for two types that have a common greater operator \math{>}
/// \tparam T0 The first type
/// \tparam T1 The second type
template<typename T0, typename T1> requires has_greater_v<T0, T1> and has_greater_v<T1, T0>
struct inequality<T0, T1> {
///
/// \brief operator to test the two values
/// \param x the value of type \f$T0\f$
/// \param y the value of type \f$T1\f$
/// \returns \f$true\f$ if not equal, \f$false\f$ otherwise
/// \param x the value of type \emph{T0}
/// \param y the value of type \emph{T1}
/// \returns \emph{true} if not equal, \emph{false} otherwise
constexpr bool operator()(const T0& x, const T1& y) const {
return (x > y) or (y > x);
}
@@ -161,16 +161,16 @@ struct inequality<T0, T1> {
// less ================================================================================================================
///
/// \brief Struct to test if a value of type \f$T0\f$ is less than a value of type \f$T1\f$
/// \brief Struct to test if a value of type \emph{T0} is less than a value of type \emph{T1}
/// \tparam T0 The first type
/// \tparam T1 The second type
template<typename T0, typename T1 = T0> requires has_less_v<T0, T1>
struct less {
///
/// \brief operator to test the two values
/// \param x the value of type \f$T0\f$
/// \param y the value of type \f$T1\f$
/// \returns \f$true\f$ if less, \f$false\f$ otherwise
/// \param x the value of type \emph{T0}
/// \param y the value of type \emph{T1}
/// \returns \emph{true} if less, \emph{false} otherwise
constexpr bool operator()(const T0& x, const T1& y) const {
return x < y;
}
@@ -180,16 +180,16 @@ struct less {
// less_equal ==========================================================================================================
///
/// \brief Struct to test if a value of type \f$T0\f$ is less than or equal to a value of type \f$T1\f$
/// \brief Struct to test if a value of type \emph{T0} is less than or equal to a value of type \emph{T1}
/// \tparam T0 The first type
/// \tparam T1 The second type
template<typename T0, typename T1 = T0> requires has_less_equals_v<T0, T1>
struct less_equals {
///
/// \brief operator to test the two values
/// \param x the value of type \f$T0\f$
/// \param y the value of type \f$T1\f$
/// \returns \f$true\f$ if less than or equal, \f$false\f$ otherwise
/// \param x the value of type \emph{T0}
/// \param y the value of type \emph{T1}
/// \returns \emph{true} if less than or equal, \emph{false} otherwise
constexpr bool operator()(const T0& x, const T1& y) const {
return x <= y;
}
@@ -199,16 +199,16 @@ struct less_equals {
// greater =============================================================================================================
///
/// \brief Struct to test if a value of type \f$T0\f$ is greater than a value of type \f$T1\f$
/// \brief Struct to test if a value of type \emph{T0} is greater than a value of type \emph{T1}
/// \tparam T0 The first type
/// \tparam T1 The second type
template<typename T0, typename T1 = T0> requires has_greater_v<T0, T1>
struct greater {
///
/// \brief operator to test the two values
/// \param x the value of type \f$T0\f$
/// \param y the value of type \f$T1\f$
/// \returns \f$true\f$ if greater, \f$false\f$ otherwise
/// \param x the value of type \emph{T0}
/// \param y the value of type \emph{T1}
/// \returns \emph{true} if greater, \emph{false} otherwise
constexpr bool operator()(const T0& x, const T1& y) const {
return x > y;
}
@@ -218,16 +218,16 @@ struct greater {
// less_equal ==========================================================================================================
///
/// \brief Struct to test if a value of type \f$T0\f$ is greater than or equal to a value of type \f$T1\f$
/// \brief Struct to test if a value of type \emph{T0} is greater than or equal to a value of type \emph{T1}
/// \tparam T0 The first type
/// \tparam T1 The second type
template<typename T0, typename T1 = T0> requires has_greater_equals_v<T0, T1>
struct greater_equals {
///
/// \brief operator to test the two values
/// \param x the value of type \f$T0\f$
/// \param y the value of type \f$T1\f$
/// \returns \f$true\f$ if greater than or equal, \f$false\f$ otherwise
/// \param x the value of type \emph{T0}
/// \param y the value of type \emph{T1}
/// \returns \emph{true} if greater than or equal, \emph{false} otherwise
constexpr bool operator()(const T0& x, const T1& y) const {
return x >= y;
}

18
include/fennec/lang/conditional_types.h
View File

@@ -77,8 +77,8 @@ namespace fennec
/// \details Selects between \p TrueT and \p FalseT based on the boolean value \p b.
/// The chosen type is stored in `fennec::conditional::type`.
/// \tparam B the value of the condition
/// \tparam TrueT type to use when \f$B == true\f$
/// \tparam FalseT type to use when \f$B == false\f$
/// \tparam TrueT type to use when \math{\textbf{B} = \textbf{true}}
/// \tparam FalseT type to use when \math{\textbf{B} = \textbf{false}}
template<bool B, typename TrueT, typename FalseT>
struct conditional;
@@ -90,12 +90,12 @@ using conditional_t
= typename conditional<B, TrueT, FalseT>::type;
#ifndef FENNEC_DOXYGEN
// specialization of fennec::conditional for \f$true\f$ case
// specialization of fennec::conditional for \emph{true} case
template<typename T, typename F>
struct conditional<true, T, F> : type_identity<T>{};
// specialization of fennec::conditional for \f$false\f$ case
// specialization of fennec::conditional for \emph{false} case
template<typename T, typename F>
struct conditional<false, T, F> : type_identity<F>{};
#endif
@@ -103,13 +103,13 @@ struct conditional<false, T, F> : type_identity<F>{};
// fennec::detect ======================================================================================================
///
/// \brief Detect whether \f$DetectT<ArgsT...>\f$ is a valid type
/// \brief Detect whether \emph{DetectT<ArgsT...>} is a valid type
///
/// \details Selects \f$DetectT<ArgsT...>\f$ if it exists, otherwise selects \f$DefaultT\f$ The chosen type is stored in `fennec::detect::type` and
/// a boolean value is stored in `fennec::detect::is_detected` representing whether \f$DetectT<ArgsT...>\f$ is found.
/// \details Selects \emph{DetectT<ArgsT...>} if it exists, otherwise selects \emph{DefaultT} The chosen type is stored in `fennec::detect::type` and
/// a boolean value is stored in `fennec::detect::is_detected` representing whether \emph{DetectT<ArgsT...>} is found.
/// \tparam DefaultT Default type
/// \tparam DetectT Type to detect
/// \tparam ArgsT Any template arguments for \f$DetectT<ArgsT>\f$
/// \tparam ArgsT Any template arguments for \emph{DetectT<ArgsT>}
template<typename DefaultT, template<typename...> typename DetectT, typename...ArgsT>
struct detect
{
@@ -140,7 +140,7 @@ struct detect<DefaultT, DetectT, ArgsT...>
///
/// \brief Leverage SFINAE to conditionally enable a function or class at compile-time
///
/// \details If \f$B\f$ is \f$true\f$, define a public member type \f$type\f$. Otherwise, there is no member. <br>
/// \details If \emph{B} is \emph{true}, define a public member type \emph{type}. Otherwise, there is no member. <br>
/// **Example Usage**
/// \code{.cpp}
/// template<typename TypeT,

2
include/fennec/lang/declval.h
View File

@@ -41,7 +41,7 @@ namespace fennec
///
/// \brief Metaprogramming helper for testing values of type T
/// \tparam T the type
/// \returns a metavalue of type \f$T\f$
/// \returns a metavalue of type \emph{T}
template<typename T> auto declval() noexcept -> decltype(detail::_declval<T>(0)) {
static_assert(detail::_declval_protector<T>{}, "declval must not be used");
return detail::_declval<T>(0);

51
include/fennec/lang/detail/_type_traits.h
View File

@@ -19,7 +19,6 @@
#ifndef FENNEC_LANG_DETAIL_TYPE_TRAITS_H
#define FENNEC_LANG_DETAIL_TYPE_TRAITS_H
#include <fennec/lang/ranges.h>
#include <fennec/lang/constants.h>
#include <fennec/lang/declval.h>
@@ -82,6 +81,12 @@ namespace fennec::detail
template<typename> struct _is_rvalue_reference : false_type {};
template<typename T> struct _is_rvalue_reference<T&&> : true_type {};
template<typename> struct _is_bounded_array : false_type {};
template<typename T, size_t N> struct _is_bounded_array<T[N]> : true_type {};
template<typename> struct _is_unbounded_array : false_type {};
template<typename T> struct _is_unbounded_array<T[]> : true_type {};
template<typename T> struct _is_complete {
template<typename U>
static auto test(U*) -> bool_constant<sizeof(U) == sizeof(U)>;
@@ -105,13 +110,37 @@ namespace fennec::detail
using type = decltype(test<T>(0));
};
template<typename ContainerT>
auto _begin(ContainerT& c) noexcept(noexcept(c.begin())) -> decltype(c.begin()) {
return c.begin();
}
template<typename T, size_t N>
auto _begin(T (&arr)[N]) -> T* {
return arr[0];
}
void _begin(...);
template<typename ContainerT>
auto _end(ContainerT& c) noexcept(noexcept(c.end())) -> decltype(c.end()) {
return c.end();
}
template<typename T, size_t N>
auto _end(T (&arr)[N]) -> T* {
return arr[N - 1];
}
void _end(...);
// https://stackoverflow.com/questions/13830158/how-to-write-a-trait-which-checks-whether-a-type-is-iterable
template<typename T>
auto _is_iterable(int) -> decltype(
fennec::begin(declval<T&>()) != fennec::end(declval<T&>()),
detail::_begin(declval<T&>()) != detail::_end(declval<T&>()),
void(),
++declval<decltype(fennec::begin(declval<T&>()))&>(),
void(*fennec::begin(declval<T&>())),
++declval<decltype(detail::_begin(declval<T&>()))&>(),
void(*detail::_begin(declval<T&>())),
true_type{}
);
@@ -130,6 +159,20 @@ namespace fennec::detail
auto _is_indexable(...) -> false_type;
// https://stackoverflow.com/a/31409532
template<typename T>
auto _is_iterator(...) -> decltype(
declval<T>() != declval<T>(),
void(),
++declval<T>(),
*declval<T>(),
true_type{}
);
template<typename T>
auto _is_iterator(...) -> false_type;
template<typename T>
auto _is_mappable(int) -> decltype(

102
include/fennec/lang/float.h
View File

@@ -23,7 +23,7 @@
///
/// \details This file is automatically generated for the current build environment.
///
/// Environment for this build: GNU Linux x86_64
/// Environment for this build: Clang Linux x86_64
///
/// \copyright Copyright © 2025 - 2026 Medusa Slockbower ([GPLv3](https://www.gnu.org/licenses/gpl-3.0.en.html))
///
@@ -60,55 +60,55 @@
#undef FLT_DENORM_MIN
#undef FLT_ROUND_ERR
/// \brief Does \f$float\f$ have an infinity?
/// \brief Does \emph{float} have an infinity?
#define FLT_HAS_INFINITY 1
/// \brief Does \f$float\f$ have a quiet NaN?
/// \brief Does \emph{float} have a quiet NaN?
#define FLT_HAS_QUIET_NAN 1
/// \brief Does \f$float\f$ have a signaling NaN?
/// \brief Does \emph{float} have a signaling NaN?
#define FLT_HAS_SIGNALING_NAN 1
/// \brief Does \f$float\f$ use denormalization?
/// \brief Does \emph{float} use denormalization?
#define FLT_HAS_DENORM 1
/// \brief Does \f$float\f$ have loss with denormalization?
/// \brief Does \emph{float} have loss with denormalization?
#define FLT_HAS_DENORM_LOSS 0
/// \brief What rounding style does \f$float\f$ use?
/// \brief What rounding style does \emph{float} use?
#define FLT_ROUNDS 1
/// \brief Does \f$float\f$ use the IEEE floating point specification?
/// \brief Does \emph{float} use the IEEE floating point specification?
#define FLT_IS_IEC559 1
/// \brief The number of mantissa bits in \f$float\f$.
/// \brief The number of mantissa bits in \emph{float}.
#define FLT_MANT_DIG 24
/// \brief The number of decimal digits guaranteed to be preserved in a \f$float\f$ &rarr; \f$text\f$ &rarr; \f$float\f$.
/// \brief The number of decimal digits guaranteed to be preserved in a \emph{float} &rarr; \emph{text} &rarr; \emph{float}.
#define FLT_DIG 6
/// \brief The decimal precision required to serialize and deserialize a \f$float\f$.
/// \brief The decimal precision required to serialize and deserialize a \emph{float}.
#define FLT_DECIMAL_DIG 9
/// \brief The radix, or integer base, used to represent a \f$float\f$.
/// \brief The radix, or integer base, used to represent a \emph{float}.
#define FLT_RADIX 2
/// \brief The minimum negative integer such that \f${FLT_RADIX}^{FLT_MIN_EXP}\f$ results in a normalized \f$float\f$.
/// \brief The minimum negative integer such that \math{\textbf{FLT_RADIX}^\textbf{FLT_MIN_EXP}} results in a normalized \emph{float}.
#define FLT_MIN_EXP -125
/// \brief The maximum positive integer such that \f${FLT_RADIX}^{FLT_MAX_EXP}\f$ results in a non-infinite \f$float\f$.
/// \brief The maximum positive integer such that \math{\textbf{FLT_RADIX}^\textbf{FLT_MAX_EXP}} results in a non-infinite \emph{float}.
#define FLT_MAX_EXP 128
/// \brief The minimum negative integer such that \f${10}^{FLT_MIN_EXP}\f$ results in a normalized \f$float\f$.
/// \brief The minimum negative integer such that \math{{10}^\textbf{FLT_MIN_EXP}} results in a normalized \emph{float}.
#define FLT_MIN_10_EXP -37
/// \brief The maximum positive integer such that \f${10}^{FLT_MAX_EXP}\f$ results in a non-infinite \f$float\f$.
/// \brief The maximum positive integer such that \math{{10}^\textbf{FLT_MAX_EXP}} results in a non-infinite \emph{float}.
#define FLT_MAX_10_EXP 38
/// \brief Do arithmetics operations with \f$float\f$ trap?
/// \brief Do arithmetics operations with \emph{float} trap?
#define FLT_TRAPS 0
/// \brief Do arithmetics operations with \f$float\f$ check for underflow?
/// \brief Do arithmetics operations with \emph{float} check for underflow?
#define FLT_TINYNESS_BEFORE 0
/// \brief Smallest positive, finite, normal value of \f$float\f$.
/// \brief Smallest positive, finite, normal value of \emph{float}.
#define FLT_MIN fennec::bit_cast<float>(0x800000)
/// \brief Largest positive, finite value of \f$float\f$.
/// \brief Largest positive, finite value of \emph{float}.
#define FLT_MAX fennec::bit_cast<float>(0x7f7fffff)
/// \brief The difference between \f$1.0\f$ and the next representable value of \f$float\f$.
/// \brief The difference between \emph{1.0} and the next representable value of \emph{float}.
#define FLT_EPSILON fennec::bit_cast<float>(0x34000000)
/// \brief A value representing \f$\inf\f$ of type \f$float\f$.
/// \brief A value representing \emph{\inf} of type \emph{float}.
#define FLT_INF fennec::bit_cast<float>(0x7f800000)
/// \brief A value representing \f$NaN\f$ of type \f$float\f$ that does not trap.
/// \brief A value representing \emph{NaN} of type \emph{float} that does not trap.
#define FLT_QUIET_NAN fennec::bit_cast<float>(0x7fc00000)
/// \brief A value representing \f$NaN\f$ of type \f$float\f$ that traps.
/// \brief A value representing \emph{NaN} of type \emph{float} that traps.
#define FLT_SIGNALING_NAN fennec::bit_cast<float>(0x7fa00000)
/// \brief Smallest positive, finite, subnormal value of \f$float\f$.
/// \brief Smallest positive, finite, subnormal value of \emph{float}.
#define FLT_DENORM_MIN fennec::bit_cast<float>(0x1)
/// \brief Maximum rounding error of type \f$float\f$.
/// \brief Maximum rounding error of type \emph{float}.
#define FLT_ROUND_ERR fennec::bit_cast<float>(0x3f000000)
#undef DBL_HAS_INFINITY
@@ -137,55 +137,55 @@
#undef DBL_DENORM_MIN
#undef DBL_ROUND_ERR
/// \brief Does \f$double\f$ have an infinity?
/// \brief Does \emph{double} have an infinity?
#define DBL_HAS_INFINITY 1
/// \brief Does \f$double\f$ have a quiet NaN?
/// \brief Does \emph{double} have a quiet NaN?
#define DBL_HAS_QUIET_NAN 1
/// \brief Does \f$double\f$ have a signaling NaN?
/// \brief Does \emph{double} have a signaling NaN?
#define DBL_HAS_SIGNALING_NAN 1
/// \brief Does \f$double\f$ use denormalization?
/// \brief Does \emph{double} use denormalization?
#define DBL_HAS_DENORM 1
/// \brief Does \f$double\f$ have loss with denormalization?
/// \brief Does \emph{double} have loss with denormalization?
#define DBL_HAS_DENORM_LOSS 0
/// \brief What rounding style does \f$double\f$ use?
/// \brief What rounding style does \emph{double} use?
#define DBL_ROUNDS 1
/// \brief Does \f$double\f$ use the IEEE doubleing point specification?
/// \brief Does \emph{double} use the IEEE doubleing point specification?
#define DBL_IS_IEC559 1
/// \brief The number of mantissa bits in \f$double\f$.
/// \brief The number of mantissa bits in \emph{double}.
#define DBL_MANT_DIG 53
/// \brief The number of decimal digits guaranteed to be preserved in a \f$double\f$ &rarr; \f$text\f$ &rarr; \f$double\f$.
/// \brief The number of decimal digits guaranteed to be preserved in a \emph{double} &rarr; \emph{text} &rarr; \emph{double}.
#define DBL_DIG 15
/// \brief The decimal precision required to serialize and deserialize a \f$double\f$.
/// \brief The decimal precision required to serialize and deserialize a \emph{double}.
#define DBL_DECIMAL_DIG 17
/// \brief The radix, or integer base, used to represent a \f$double\f$.
/// \brief The radix, or integer base, used to represent a \emph{double}.
#define DBL_RADIX 2
/// \brief The minimum negative integer such that \f${DBL_RADIX}^{DBL_MIN_EXP}\f$ results in a normalized \f$double\f$.
/// \brief The minimum negative integer such that \math{\textbf{DBL_RADIX}^\textbf{DBL_MIN_EXP}} results in a normalized \emph{double}.
#define DBL_MIN_EXP -1021
/// \brief The maximum positive integer such that \f${DBL_RADIX}^{DBL_MAX_EXP}\f$ results in a non-infinite \f$double\f$.
/// \brief The maximum positive integer such that \math{\textbf{DBL_RADIX}^\textbf{DBL_MAX_EXP}} results in a non-infinite \emph{double}.
#define DBL_MAX_EXP 1024
/// \brief The minimum negative integer such that \f${10}^{DBL_MIN_EXP}\f$ results in a normalized \f$double\f$.
/// \brief The minimum negative integer such that \math{{10}^\textbf{DBL_MIN_EXP}} results in a normalized \emph{double}.
#define DBL_MIN_10_EXP -307
/// \brief The maximum positive integer such that \f${10}^{DBL_MAX_EXP}\f$ results in a non-infinite \f$double\f$.
/// \brief The maximum positive integer such that \math{{10}^\textbf{DBL_MAX_EXP}} results in a non-infinite \emph{double}.
#define DBL_MAX_10_EXP 308
/// \brief Do arithmetics operations with \f$double\f$ trap?
/// \brief Do arithmetics operations with \emph{double} trap?
#define DBL_TRAPS 0
/// \brief Do arithmetics operations with \f$double\f$ check for underflow?
/// \brief Do arithmetics operations with \emph{double} check for underflow?
#define DBL_TINYNESS_BEFORE 0
/// \brief Smallest positive, finite, normal value of \f$double\f$.
/// \brief Smallest positive, finite, normal value of \emph{double}.
#define DBL_MIN fennec::bit_cast<double>(0x10000000000000ll)
/// \brief Largest positive, finite value of \f$double\f$.
/// \brief Largest positive, finite value of \emph{double}.
#define DBL_MAX fennec::bit_cast<double>(0x7fefffffffffffffll)
/// \brief The difference between \f$1.0\f$ and the next representable value of \f$double\f$.
/// \brief The difference between \emph{1.0} and the next representable value of \emph{double}.
#define DBL_EPSILON fennec::bit_cast<double>(0x3cb0000000000000ll)
/// \brief A value representing \f$\inf\f$ of type \f$double\f$.
/// \brief A value representing \emph{\inf} of type \emph{double}.
#define DBL_INF fennec::bit_cast<double>(0x7ff0000000000000ll)
/// \brief A value representing \f$NaN\f$ of type \f$double\f$ that does not trap.
/// \brief A value representing \emph{NaN} of type \emph{double} that does not trap.
#define DBL_QUIET_NAN fennec::bit_cast<double>(0x7ff8000000000000ll)
/// \brief A value representing \f$NaN\f$ of type \f$double\f$ that traps.
/// \brief A value representing \emph{NaN} of type \emph{double} that traps.
#define DBL_SIGNALING_NAN fennec::bit_cast<double>(0x7ff4000000000000ll)
/// \brief Smallest positive, finite, subnormal value of \f$double\f$.
/// \brief Smallest positive, finite, subnormal value of \emph{double}.
#define DBL_DENORM_MIN fennec::bit_cast<double>(0x1ll)
/// \brief Maximum rounding error of type \f$double\f$.
/// \brief Maximum rounding error of type \emph{double}.
#define DBL_ROUND_ERR fennec::bit_cast<double>(0x3fe0000000000000ll)
#endif // FENNEC_LANG_FLOAT_H

10
include/fennec/lang/function.h
View File

@@ -85,18 +85,18 @@ public:
///
/// \brief copy assignment
/// \param func the function to copy
/// \returns a reference to self
/// \returns a reference to \emph{this}
constexpr function& operator=(const function& func) = default;
///
/// \brief move assignment
/// \param func the function to capture
/// \returns a reference to self
/// \returns a reference to \emph{this}
constexpr function& operator=(function&& func) = default;
///
/// \brief null assignment
/// \returns a reference to self
/// \returns a reference to \emph{this}
constexpr function& operator=(nullptr_t) {
call = nullptr;
return *this;
@@ -105,7 +105,7 @@ public:
///
/// \brief function assignment
/// \param func the function to capture
/// \returns a reference to self
/// \returns a reference to \emph{this}
constexpr function& operator=(ReturnT (*func)(ArgsT...)) {
call = func;
return *this;
@@ -113,7 +113,7 @@ public:
///
/// \brief implicit bool check
/// \returns \f$true\f$ if a function is captured, \f$false\f$ otherwise
/// \returns \emph{true} if a function is captured, \emph{false} otherwise
constexpr operator bool() const noexcept {
return call != nullptr;
}

5
include/fennec/lang/hashing.h
View File

@@ -66,11 +66,11 @@ struct hash<PtrT*> : hash<uintptr_t> {
/// \param ptr the pointer to hash
/// \returns an integer hash for the value
constexpr size_t operator()(PtrT* ptr) const {
return hash<uintptr_t>::operator()((uintptr_t)(const void*)ptr);
return hash<uintptr_t>::operator()(fennec::bit_cast<uintptr_t>(ptr));
}
};
// Float
/// \brief Hashing for `float`
template<>
struct hash<float> : hash<uint32_t> {
using type_t = float; //!< the type of the hash
@@ -82,6 +82,7 @@ struct hash<float> : hash<uint32_t> {
}
};
/// \brief Hashing for `double`
template<>
struct hash<double> : hash<uint64_t> {
using type_t = double; //!< the type of the hash

288
include/fennec/lang/integer.h
View File

@@ -23,7 +23,7 @@
///
/// \details This file is automatically generated for the current build environment.
///
/// Environment for this build: GNU Linux x86_64
/// Environment for this build: Clang Linux x86_64
///
/// \copyright Copyright © 2025 - 2026 Medusa Slockbower ([GPLv3](https://www.gnu.org/licenses/gpl-3.0.en.html))
///
@@ -53,212 +53,212 @@
#undef ULLONG_MIN
#undef ULLONG_MAX
/// \brief Is \f$char\f$ signed?
/// \brief Is \emph{char} signed?
#define CHAR_IS_SIGNED true
/// \brief Rounding style of type \f$char\f$.
#define CHAR_ROUNDS 0x0
/// \brief Number of radix digits represented by \f$char\f$.
/// \brief Rounding style of type \emph{char}.
#define CHAR_ROUNDS 0
/// \brief Number of radix digits represented by \emph{char}.
#define CHAR_RADIX_DIG 0x7
/// \brief Number of decimal digits represented by \f$char\f$.
/// \brief Number of decimal digits represented by \emph{char}.
#define CHAR_DIG 0x2
/// \brief Number of decimal digits necessary to differentiate all values of type \f$char\f$.
#define CHAR_DECIMAL_DIG 0x0
/// \brief The radix, or integer base, used to represent a \f$char\f$.
/// \brief Number of decimal digits necessary to differentiate all values of type \emph{char}.
#define CHAR_DECIMAL_DIG 0
/// \brief The radix, or integer base, used to represent a \emph{char}.
#define CHAR_RADIX 0x2
/// \brief Do arithmetics operations with \f$char\f$ trap?
#define CHAR_TRAPS 0xtrue
/// \brief Smallest finite value of \f$char\f$.
#define CHAR_MIN 0x80
/// \brief Largest finite value of \f$char\f$.
/// \brief Do arithmetics operations with \emph{char} trap?
#define CHAR_TRAPS true
/// \brief Smallest finite value of \emph{char}.
#define CHAR_MIN -0x80
/// \brief Largest finite value of \emph{char}.
#define CHAR_MAX 0x7f
/// \brief Is \f$wchar_t\f$ signed?
/// \brief Is \emph{wchar_t} signed?
#define WCHAR_IS_SIGNED true
/// \brief Rounding style of type \f$wchar_t\f$.
#define WCHAR_ROUNDS 0x0
/// \brief Number of radix digits represented by \f$wchar_t\f$.
/// \brief Rounding style of type \emph{wchar_t}.
#define WCHAR_ROUNDS 0
/// \brief Number of radix digits represented by \emph{wchar_t}.
#define WCHAR_RADIX_DIG 0x1f
/// \brief Number of decimal digits represented by \f$wchar_t\f$.
/// \brief Number of decimal digits represented by \emph{wchar_t}.
#define WCHAR_DIG 0x9
/// \brief Number of decimal digits necessary to differentiate all values of type \f$wchar_t\f$.
#define WCHAR_DECIMAL_DIG 0x0
/// \brief The radix, or integer base, used to represent a \f$wchar_t\f$.
/// \brief Number of decimal digits necessary to differentiate all values of type \emph{wchar_t}.
#define WCHAR_DECIMAL_DIG 0
/// \brief The radix, or integer base, used to represent a \emph{wchar_t}.
#define WCHAR_RADIX 0x2
/// \brief Do arithmetics operations with \f$wchar_t\f$ trap?
#define WCHAR_TRAPS 0xtrue
/// \brief Smallest finite value of \f$wchar_t\f$.
#define WCHAR_MIN 0x80000000
/// \brief Largest finite value of \f$wchar_t\f$.
#define WCHAR_MAX 0x7fffffff
/// \brief Do arithmetics operations with \emph{wchar_t} trap?
#define WCHAR_TRAPS true
/// \brief Smallest finite value of \emph{wchar_t}.
#define WCHAR_MIN - 0x0
/// \brief Largest finite value of \emph{wchar_t}.
#define WCHAR_MAX 0xffff
/// \brief Is \f$signed char\f$ signed?
#define SCHAR_ROUNDS 0x0
/// \brief Rounding style of type \f$signed char\f$.
/// \brief Rounding style of type \emph{signed char}.
#define SCHAR_ROUNDS 0
/// \brief Number of radix digits represented by \emph{signed char}.
#define SCHAR_RADIX_DIG 0x7
/// \brief Number of radix digits represented by \f$signed char\f$.
/// \brief Number of decimal digits represented by \emph{signed char}.
#define SCHAR_DIG 0x2
/// \brief Number of decimal digits represented by \f$signed char\f$.
#define SCHAR_DECIMAL_DIG 0x0
/// \brief Number of decimal digits necessary to differentiate all values of type \f$signed char\f$.
/// \brief Number of decimal digits necessary to differentiate all values of type \emph{signed char}.
#define SCHAR_DECIMAL_DIG 0
/// \brief The radix, or integer base, used to represent a \emph{signed char}.
#define SCHAR_RADIX 0x2
/// \brief Do arithmetics operations with \f$signed char\f$ trap?
#define SCHAR_TRAPS 0xtrue
/// \brief Smallest finite value of \f$signed char\f$.
#define SCHAR_MIN 0x80
/// \brief Largest finite value of \f$signed char\f$.
/// \brief Do arithmetics operations with \emph{signed char} trap?
#define SCHAR_TRAPS true
/// \brief Smallest finite value of \emph{signed char}.
#define SCHAR_MIN -0x80
/// \brief Largest finite value of \emph{signed char}.
#define SCHAR_MAX 0x7f
/// \brief Is \f$unsigned char\f$ unsigned?
#define UCHAR_ROUNDS 0x0
/// \brief Rounding style of type \f$unsigned char\f$.
/// \brief Rounding style of type \emph{unsigned char}.
#define UCHAR_ROUNDS 0
/// \brief Number of radix digits represented by \emph{unsigned char}.
#define UCHAR_RADIX_DIG 0x8
/// \brief Number of radix digits represented by \f$unsigned char\f$.
/// \brief Number of decimal digits represented by \emph{unsigned char}.
#define UCHAR_DIG 0x2
/// \brief Number of decimal digits represented by \f$unsigned char\f$.
#define UCHAR_DECIMAL_DIG 0x0
/// \brief Number of decimal digits necessary to differentiate all values of type \f$unsigned char\f$.
/// \brief Number of decimal digits necessary to differentiate all values of type \emph{unsigned char}.
#define UCHAR_DECIMAL_DIG 0
/// \brief The radix, or integer base, used to represent an \emph{unsigned char}.
#define UCHAR_RADIX 0x2
/// \brief Do arithmetics operations with \f$unsigned char\f$ trap?
#define UCHAR_TRAPS 0xtrue
/// \brief Smallest finite value of \f$unsigned char\f$.
/// \brief Do arithmetics operations with \emph{unsigned char} trap?
#define UCHAR_TRAPS true
/// \brief Smallest finite value of \emph{unsigned char}.
#define UCHAR_MIN 0x0
/// \brief Largest finite value of \f$unsigned char\f$.
/// \brief Largest finite value of \emph{unsigned char}.
#define UCHAR_MAX 0xff
/// \brief Rounding style of type \f$short\f$.
#define SHORT_ROUNDS 0x0
/// \brief Number of radix digits represented by \f$short\f$.
/// \brief Rounding style of type \emph{short}.
#define SHORT_ROUNDS 0
/// \brief Number of radix digits represented by \emph{short}.
#define SHORT_RADIX_DIG 0xf
/// \brief Number of decimal digits represented by \f$short\f$.
/// \brief Number of decimal digits represented by \emph{short}.
#define SHORT_DIG 0x4
/// \brief Number of decimal digits necessary to differentiate all values of type \f$short\f$.
#define SHORT_DECIMAL_DIG 0x0
/// \brief The radix, or integer base, used to represent a \f$short\f$.
/// \brief Number of decimal digits necessary to differentiate all values of type \emph{short}.
#define SHORT_DECIMAL_DIG 0
/// \brief The radix, or integer base, used to represent a \emph{short}.
#define SHORT_RADIX 0x2
/// \brief Do arithmetics operations with \f$short\f$ trap?
#define SHORT_TRAPS 0xtrue
/// \brief Smallest finite value of \f$short\f$.
#define SHORT_MIN 0xffff8000
/// \brief Largest finite value of \f$short\f$.
/// \brief Do arithmetics operations with \emph{short} trap?
#define SHORT_TRAPS true
/// \brief Smallest finite value of \emph{short}.
#define SHORT_MIN 0x8000
/// \brief Largest finite value of \emph{short}.
#define SHORT_MAX 0x7fff
/// \brief Rounding style of type \f$unsigned short\f$.
#define USHORT_ROUNDS 0x0
/// \brief Number of radix digits represented by \f$unsigned short\f$.
/// \brief Rounding style of type \emph{unsigned short}.
#define USHORT_ROUNDS 0
/// \brief Number of radix digits represented by \emph{unsigned short}.
#define USHORT_RADIX_DIG 0x10
/// \brief Number of decimal digits represented by \f$unsigned short\f$.
/// \brief Number of decimal digits represented by \emph{unsigned short}.
#define USHORT_DIG 0x4
/// \brief Number of decimal digits necessary to differentiate all values of type \f$unsigned short\f$.
#define USHORT_DECIMAL_DIG 0x0
/// \brief The radix, or integer base, used to represent a \f$unsigned short\f$.
/// \brief Number of decimal digits necessary to differentiate all values of type \emph{unsigned short}.
#define USHORT_DECIMAL_DIG 0
/// \brief The radix, or integer base, used to represent an \emph{unsigned short}.
#define USHORT_RADIX 0x2
/// \brief Do arithmetics operations with \f$unsigned short\f$ trap?
#define USHORT_TRAPS 0xtrue
/// \brief Smallest finite value of \f$unsigned short\f$.
#define USHORT_MIN 0x0
/// \brief Largest finite value of \f$unsigned short\f$.
/// \brief Do arithmetics operations with \emph{unsigned short} trap?
#define USHORT_TRAPS true
/// \brief Smallest finite value of \emph{unsigned short}.
#define USHORT_MIN 0
/// \brief Largest finite value of \emph{unsigned short}.
#define USHORT_MAX 0xffff
/// \brief Rounding style of type \f$int\f$.
#define INT_ROUNDS 0x0
/// \brief Number of radix digits represented by \f$int\f$.
/// \brief Rounding style of type \emph{int}.
#define INT_ROUNDS 0
/// \brief Number of radix digits represented by \emph{int}.
#define INT_RADIX_DIG 0x1f
/// \brief Number of decimal digits represented by \f$int\f$.
/// \brief Number of decimal digits represented by \emph{int}.
#define INT_DIG 0x9
/// \brief Number of decimal digits necessary to differentiate all values of type \f$int\f$.
#define INT_DECIMAL_DIG 0x0
/// \brief The radix, or integer base, used to represent a \f$int\f$.
/// \brief Number of decimal digits necessary to differentiate all values of type \emph{int}.
#define INT_DECIMAL_DIG 0
/// \brief The radix, or integer base, used to represent an \emph{int}.
#define INT_RADIX 0x2
/// \brief Do arithmetics operations with \f$int\f$ trap?
#define INT_TRAPS 0xtrue
/// \brief Smallest finite value of \f$int\f$.
/// \brief Do arithmetics operations with \emph{int} trap?
#define INT_TRAPS true
/// \brief Smallest finite value of \emph{int}.
#define INT_MIN 0x80000000
/// \brief Largest finite value of \f$int\f$.
/// \brief Largest finite value of \emph{int}.
#define INT_MAX 0x7fffffff
/// \brief Rounding style of type \f$unsigned int\f$.
#define UINT_ROUNDS 0x0
/// \brief Number of radix digits represented by \f$unsigned int\f$.
/// \brief Rounding style of type \emph{unsigned int}.
#define UINT_ROUNDS 0
/// \brief Number of radix digits represented by \emph{unsigned int}.
#define UINT_RADIX_DIG 0x20
/// \brief Number of decimal digits represented by \f$unsigned int\f$.
/// \brief Number of decimal digits represented by \emph{unsigned int}.
#define UINT_DIG 0x9
/// \brief Number of decimal digits necessary to differentiate all values of type \f$unsigned int\f$.
#define UINT_DECIMAL_DIG 0x0
/// \brief The radix, or unsigned integer base, used to represent a \f$unsigned int\f$.
/// \brief Number of decimal digits necessary to differentiate all values of type \emph{unsigned int}.
#define UINT_DECIMAL_DIG 0
/// \brief The radix, or integer base, used to represent an \emph{unsigned int}.
#define UINT_RADIX 0x2
/// \brief Do arithmetics operations with \f$unsigned int\f$ trap?
#define UINT_TRAPS 0xtrue
/// \brief Smallest finite value of \f$unsigned int\f$.
#define UINT_MIN 0x0
/// \brief Largest finite value of \f$unsigned int\f$.
/// \brief Do arithmetics operations with \emph{unsigned int} trap?
#define UINT_TRAPS true
/// \brief Smallest finite value of \emph{unsigned int}.
#define UINT_MIN 0
/// \brief Largest finite value of \emph{unsigned int}.
#define UINT_MAX 0xffffffff
/// \brief Rounding style of type \f$long int\f$.
#define LONG_ROUNDS 0x0
/// \brief Number of radix digits represented by \f$long int\f$.
/// \brief Rounding style of type \emph{long int}.
#define LONG_ROUNDS 0
/// \brief Number of radix digits represented by \emph{long int}.
#define LONG_RADIX_DIG 0x3f
/// \brief Number of decimal digits represented by \f$long int\f$.
/// \brief Number of decimal digits represented by \emph{long int}.
#define LONG_DIG 0x12
/// \brief Number of decimal digits necessary to differentiate all values of type \f$long int\f$.
#define LONG_DECIMAL_DIG 0x0
/// \brief The radix, or long integer base, used to represent a \f$long int\f$.
/// \brief Number of decimal digits necessary to differentiate all values of type \emph{long int}.
#define LONG_DECIMAL_DIG 0
/// \brief The radix, or integer base, used to represent a \emph{long int}.
#define LONG_RADIX 0x2
/// \brief Do arithmetics operations with \f$long int\f$ trap?
#define LONG_TRAPS 0xtrue
/// \brief Smallest finite value of \f$long int\f$.
/// \brief Do arithmetics operations with \emph{long int} trap?
#define LONG_TRAPS true
/// \brief Smallest finite value of \emph{long int}.
#define LONG_MIN 0x8000000000000000
/// \brief Largest finite value of \f$long int\f$.
/// \brief Largest finite value of \emph{long int}.
#define LONG_MAX 0x7fffffffffffffff
/// \brief Rounding style of type \f$unsigned long int\f$.
#define ULONG_ROUNDS 0x0
/// \brief Number of radix digits represented by \f$unsigned long int\f$.
/// \brief Rounding style of type \emph{unsigned long int}.
#define ULONG_ROUNDS 0
/// \brief Number of radix digits represented by \emph{unsigned long int}.
#define ULONG_RADIX_DIG 0x40
/// \brief Number of decimal digits represented by \f$unsigned long int\f$.
/// \brief Number of decimal digits represented by \emph{unsigned long int}.
#define ULONG_DIG 0x13
/// \brief Number of decimal digits necessary to differentiate all values of type \f$unsigned long int\f$.
#define ULONG_DECIMAL_DIG 0x0
/// \brief The radix, or unsigned long integer base, used to represent a \f$unsigned long int\f$.
/// \brief Number of decimal digits necessary to differentiate all values of type \emph{unsigned long int}.
#define ULONG_DECIMAL_DIG 0
/// \brief The radix, or integer base, used to represent an \emph{unsigned long int}.
#define ULONG_RADIX 0x2
/// \brief Do arithmetics operations with \f$unsigned long int\f$ trap?
#define ULONG_TRAPS 0xtrue
/// \brief Smallest finite value of \f$unsigned long int\f$.
#define ULONG_MIN 0x0
/// \brief Largest finite value of \f$unsigned long int\f$.
/// \brief Do arithmetics operations with \emph{unsigned long int} trap?
#define ULONG_TRAPS true
/// \brief Smallest finite value of \emph{unsigned long int}.
#define ULONG_MIN 0
/// \brief Largest finite value of \emph{unsigned long int}.
#define ULONG_MAX 0xffffffffffffffff
/// \brief Rounding style of type \f$long long\f$.
#define LLONG_ROUNDS 0x0
/// \brief Number of radix digits represented by \f$long long\f$.
/// \brief Rounding style of type \emph{long long}.
#define LLONG_ROUNDS 0
/// \brief Number of radix digits represented by \emph{long long}.
#define LLONG_RADIX_DIG 0x3f
/// \brief Number of decimal digits represented by \f$long long\f$.
/// \brief Number of decimal digits represented by \emph{long long}.
#define LLONG_DIG 0x12
/// \brief Number of decimal digits necessary to differentiate all values of type \f$long long\f$.
#define LLONG_DECIMAL_DIG 0x0
/// \brief The radix, or long longeger base, used to represent a \f$long long\f$.
/// \brief Number of decimal digits necessary to differentiate all values of type \emph{long long}.
#define LLONG_DECIMAL_DIG 0
/// \brief The radix, or integer base, used to represent a \emph{long long}.
#define LLONG_RADIX 0x2
/// \brief Do arithmetics operations with \f$long long\f$ trap?
#define LLONG_TRAPS 0xtrue
/// \brief Smallest finite value of \f$long long\f$.
/// \brief Do arithmetics operations with \emph{long long} trap?
#define LLONG_TRAPS true
/// \brief Smallest finite value of \emph{long long}.
#define LLONG_MIN 0x8000000000000000
/// \brief Largest finite value of \f$long long\f$.
/// \brief Largest finite value of \emph{long long}.
#define LLONG_MAX 0x7fffffffffffffff
/// \brief Rounding style of type \f$unsigned long long\f$.
#define ULLONG_ROUNDS 0x0
/// \brief Number of radix digits represented by \f$unsigned long long\f$.
/// \brief Rounding style of type \emph{unsigned long long}.
#define ULLONG_ROUNDS 0
/// \brief Number of radix digits represented by \emph{unsigned long long}.
#define ULLONG_RADIX_DIG 0x40
/// \brief Number of decimal digits represented by \f$unsigned long long\f$.
/// \brief Number of decimal digits represented by \emph{unsigned long long}.
#define ULLONG_DIG 0x13
/// \brief Number of decimal digits necessary to differentiate all values of type \f$unsigned long long\f$.
#define ULLONG_DECIMAL_DIG 0x0
/// \brief The radix, or unsigned long longeger base, used to represent a \f$unsigned long long\f$.
/// \brief Number of decimal digits necessary to differentiate all values of type \emph{unsigned long long}.
#define ULLONG_DECIMAL_DIG 0
/// \brief The radix, or integer base, used to represent an \emph{unsigned long long}.
#define ULLONG_RADIX 0x2
/// \brief Do arithmetics operations with \f$unsigned long long\f$ trap?
#define ULLONG_TRAPS 0xtrue
/// \brief Smallest finite value of \f$unsigned long long\f$.
#define ULLONG_MIN 0x0
/// \brief Largest finite value of \f$unsigned long long\f$.
/// \brief Do arithmetics operations with \emph{unsigned long long} trap?
#define ULLONG_TRAPS true
/// \brief Smallest finite value of \emph{unsigned long long}.
#define ULLONG_MIN 0
/// \brief Largest finite value of \emph{unsigned long long}.
#define ULLONG_MAX 0xffffffffffffffff
#endif // FENNEC_LANG_INTEGER_H

64
include/fennec/lang/intrinsics.h
View File

@@ -40,59 +40,59 @@
/// <tr><th style="vertical-align: top">Syntax
/// <th style="vertical-align: top">Description
/// <tr><td width="50%" style="vertical-align: top"> <br>
/// \f$FENNEC_HAS_BUILTIN_BIT_CAST\f$ <br>
/// \f$Y FENNEC_BUILTIN_BIT_CAST(X)\f$
/// \emph{FENNEC_HAS_BUILTIN_BIT_CAST} <br>
/// \emph{Y FENNEC_BUILTIN_BIT_CAST(X)}
/// <td width="50%" style="vertical-align: top">
/// An intrinsic for doing a bitwise cast without using \f$reinterpret_cast\f$.
/// An intrinsic for doing a bitwise cast without using \emph{reinterpret_cast}.
///
/// <tr><td width="50%" style="vertical-align: top"> <br>
/// \f$FENNEC_HAS_BUILTIN_ADDRESSOF\f$ <br>
/// \f$Y FENNEC_BUILTIN_ADDRESSOF(X)\f$
/// \emph{FENNEC_HAS_BUILTIN_ADDRESSOF} <br>
/// \emph{Y FENNEC_BUILTIN_ADDRESSOF(X)}
/// <td width="50%" style="vertical-align: top">
/// Obtains the true address of an object in circumstances where \f$operator&\f$ is overloaded.
/// Obtains the true address of an object in circumstances where \emph{operator&} is overloaded.
///
/// <tr><td width="50%" style="vertical-align: top"> <br>
/// \f$FENNEC_HAS_BUILTIN_IS_CONVERTIBLE\f$ <br>
/// \f$B FENNEC_BUILTIN_IS_CONVERTIBLE(X, Y)\f$
/// \emph{FENNEC_HAS_BUILTIN_IS_CONVERTIBLE} <br>
/// \emph{B FENNEC_BUILTIN_IS_CONVERTIBLE(X, Y)}
/// <td width="50%" style="vertical-align: top">
/// Checks if type \f$X\f$ can be converted to type \f$Y\f$.
/// Checks if type \emph{X} can be converted to type \emph{Y}.
///
/// <tr><td width="50%" style="vertical-align: top"> <br>
/// \f$FENNEC_HAS_BUILTIN_IS_EMPTY\f$ <br>
/// \f$B FENNEC_BUILTIN_IS_EMPTY(X)\f$
/// \emph{FENNEC_HAS_BUILTIN_IS_EMPTY} <br>
/// \emph{B FENNEC_BUILTIN_IS_EMPTY(X)}
/// <td width="50%" style="vertical-align: top">
/// Checks if type \f$X\f$ stores no data.
/// Checks if type \emph{X} stores no data.
///
/// <tr><td width="50%" style="vertical-align: top"> <br>
/// \f$FENNEC_HAS_BUILTIN_IS_POLYMORPHIC\f$ <br>
/// \f$B FENNEC_BUILTIN_IS_POLYMORPHIC(X)\f$
/// \emph{FENNEC_HAS_BUILTIN_IS_POLYMORPHIC} <br>
/// \emph{B FENNEC_BUILTIN_IS_POLYMORPHIC(X)}
/// <td width="50%" style="vertical-align: top">
/// Checks if type \f$X\f$ is polymorphic, this is for classes only thus checks only for subtyping
/// Checks if type \emph{X} is polymorphic, this is for classes only thus checks only for subtyping
///
/// <tr><td width="50%" style="vertical-align: top"> <br>
/// \f$FENNEC_HAS_BUILTIN_IS_FINAL\f$ <br>
/// \f$B FENNEC_BUILTIN_IS_FINAL(X)\f$
/// \emph{FENNEC_HAS_BUILTIN_IS_FINAL} <br>
/// \emph{B FENNEC_BUILTIN_IS_FINAL(X)}
/// <td width="50%" style="vertical-align: top">
/// Checks if type \f$X\f$ is final, meaning a function or class cannot be derived from.
/// Checks if type \emph{X} is final, meaning a function or class cannot be derived from.
///
/// <tr><td width="50%" style="vertical-align: top"> <br>
/// \f$FENNEC_HAS_BUILTIN_IS_ABSTRACT\f$ <br>
/// \f$B FENNEC_BUILTIN_IS_ABSTRACT(X)\f$
/// \emph{FENNEC_HAS_BUILTIN_IS_ABSTRACT} <br>
/// \emph{B FENNEC_BUILTIN_IS_ABSTRACT(X)}
/// <td width="50%" style="vertical-align: top">
/// Opposite of \f$FENNEC_BUILTIN_IS_FINAL\f$, checks if abstract, meaning \f$X\f$ has at least one pure virtual function.
/// Opposite of \emph{FENNEC_BUILTIN_IS_FINAL}, checks if abstract, meaning \emph{X} has at least one pure virtual function.
///
/// <tr><td width="50%" style="vertical-align: top"> <br>
/// \f$FENNEC_HAS_BUILTIN_IS_STANDARD_LAYOUT\f$ <br>
/// \f$B FENNEC_BUILTIN_IS_STANDARD_LAYOUT(X)\f$
/// \emph{FENNEC_HAS_BUILTIN_IS_STANDARD_LAYOUT} <br>
/// \emph{B FENNEC_BUILTIN_IS_STANDARD_LAYOUT(X)}
/// <td width="50%" style="vertical-align: top">
/// Checks if \f$X\f$ has a standard layout, here is [full criteria](https://www.cppreference.com/w/cpp/language/classes.html#Standard-layout_class)
/// Checks if \emph{X} has a standard layout, here is [full criteria](https://www.cppreference.com/w/cpp/language/classes.html#Standard-layout_class)
/// for this trait
///
/// <tr><td width="50%" style="vertical-align: top"> <br>
/// \f$FENNEC_HAS_BUILTIN_IS_CONSTRUCTIBLE\f$ <br>
/// \f$B FENNEC_BUILTIN_IS_CONSTRUCTIBLE(X, ...)\f$
/// \emph{FENNEC_HAS_BUILTIN_IS_CONSTRUCTIBLE} <br>
/// \emph{B FENNEC_BUILTIN_IS_CONSTRUCTIBLE(X, ...)}
/// <td width="50%" style="vertical-align: top">
/// Checks if type \f$X\f$ is constructible with args \f$\ldots\f$, such that \f$X::X(...)\f$ exists.
/// Checks if type \emph{X} is constructible with args \emph{\ldots}, such that \emph{X::X(...)} exists.
///
/// </table>
///
@@ -242,8 +242,16 @@
// Difficult and Inconsistent without intrinsics
#if __has_builtin(__has_trivial_destructor)
# define FENNEC_HAS_BUILTIN_HAS_TRIVIAL_DESTRUCTOR 1
# define FENNEC_BUILTIN_HAS_TRIVIAL_DESTRUCTOR(type) __has_trivial_destructor(type)
#else
# define FENNEC_HAS_BUILTIN_HAS_TRIVIAL_DESTRUCTOR 0
#endif
// Difficult and Inconsistent without intrinsics
#if __has_builtin(__is_trivially_destructible)
# define FENNEC_HAS_BUILTIN_IS_TRIVIALLY_DESTRUCTIBLE 1
# define FENNEC_BUILTIN_IS_TRIVIALLY_DESTRUCTIBLE(type) __has_trivial_destructor(type)
# define FENNEC_BUILTIN_IS_TRIVIALLY_DESTRUCTIBLE(type) __is_trivially_destructible(type)
#else
# define FENNEC_HAS_BUILTIN_IS_TRIVIALLY_DESTRUCTIBLE 0
#endif

851
include/fennec/lang/limits.h
View File

@@ -231,7 +231,7 @@ template<typename TypeT> struct numeric_limits
static constexpr bool has_signaling_nan = false; //!< Check if TypeT can hold a signaling nan
static constexpr bool has_denorm = false; //!< Check if TypeT denormalizes
static constexpr bool has_denorm_loss = false; //!< Check if TypeT has precision loss when denormalized
static constexpr bool is_iec559 = false; //!< Check if a TypeT representing a float is IEC 559 or IEEE 754
static constexpr bool is_iec559 = false; //!< Check if TypeT represents an IEC 559 or IEEE 754
static constexpr bool is_bounded = false; //!< Check if TypeT represents a finite set of values
static constexpr bool is_modulo = false; //!< Check if TypeT can handle modulo arithmetic
static constexpr bool tinyness_before = false; //!< Check if TypeT checks for tinyness before rounding
@@ -260,500 +260,515 @@ template<typename TypeT> struct numeric_limits
static constexpr TypeT denorm_min() { return TypeT(); } //!< \returns a value of TypeT holding the smallest positive subnormal
};
// Overload definitions for basic types
// Overload for the builtin floating point type
// Overloads ===========================================================================================================
///
/// \brief Definition for type \emph{float}.
template<> struct numeric_limits<float>
{
static constexpr bool is_specialized = true;
static constexpr bool is_signed = true;
static constexpr bool is_integer = false;
static constexpr bool is_exact = false;
static constexpr bool has_infinity = FLT_HAS_INFINITY;
static constexpr bool has_quiet_nan = FLT_HAS_QUIET_NAN;
static constexpr bool has_signaling_nan = FLT_HAS_SIGNALING_NAN;
static constexpr bool has_denorm = FLT_HAS_DENORM;
static constexpr bool has_denorm_loss = FLT_HAS_DENORM_LOSS;
static constexpr bool is_iec559 = FLT_IS_IEC559;
static constexpr bool is_bounded = true;
static constexpr bool is_modulo = false;
static constexpr bool tinyness_before = FLT_TINYNESS_BEFORE;
static constexpr bool traps = FLT_TRAPS;
static constexpr bool is_specialized = true; //!< Check if the template is specialized for float
static constexpr bool is_signed = true; //!< Check if float is signed
static constexpr bool is_integer = false; //!< Check if float is of an integral type
static constexpr bool is_exact = false; //!< Check if float is exact in its precision
static constexpr bool has_infinity = FLT_HAS_INFINITY; //!< Check if float can hold a value representing infinity
static constexpr bool has_quiet_nan = FLT_HAS_QUIET_NAN; //!< Check if float can hold a non-signaling nan
static constexpr bool has_signaling_nan = FLT_HAS_SIGNALING_NAN; //!< Check if float can hold a signaling nan
static constexpr bool has_denorm = FLT_HAS_DENORM; //!< Check if float denormalizes
static constexpr bool has_denorm_loss = FLT_HAS_DENORM_LOSS; //!< Check if float has precision loss when denormalized
static constexpr bool is_iec559 = FLT_IS_IEC559; //!< Check if float represents an IEC 559 or IEEE 754
static constexpr bool is_bounded = true; //!< Check if float represents a finite set of values
static constexpr bool is_modulo = false; //!< Check if float can handle modulo arithmetic
static constexpr bool tinyness_before = FLT_TINYNESS_BEFORE; //!< Check if float checks for tinyness before rounding
static constexpr bool traps = FLT_TRAPS; //!< Check if float can cause operations to trap
static constexpr int digits = FLT_MANT_DIG;
static constexpr int digits10 = FLT_DIG;
static constexpr int max_digits10 = FLT_DECIMAL_DIG;
static constexpr int radix = FLT_RADIX;
static constexpr int min_exponent = FLT_MIN_EXP;
static constexpr int min_exponent10 = FLT_MIN_10_EXP;
static constexpr int max_exponent = FLT_MAX_EXP;
static constexpr int max_exponent10 = FLT_MAX_10_EXP;
static constexpr int digits = FLT_MANT_DIG; //!< Get the base representation of the type
static constexpr int digits10 = FLT_DIG; //!< Get the number of radix digits float represents
static constexpr int max_digits10 = FLT_DECIMAL_DIG; //!< Get the number of decimal digits float represents
static constexpr int radix = FLT_RADIX; //!< Get the maximum number of decimal digits float represents
static constexpr int min_exponent = FLT_MIN_EXP; //!< Get the minimum number of radix digits that represent the exponent of float
static constexpr int min_exponent10 = FLT_MIN_10_EXP; //!< Get the minimum number of decimal digits that represent the exponent of float
static constexpr int max_exponent = FLT_MAX_EXP; //!< Get the maximum number of radix digits that represent the exponent of float
static constexpr int max_exponent10 = FLT_MAX_10_EXP; //!< Get the maximum number of decimal digits that represent the exponent of float
static constexpr float min() { return -FLT_MAX; }
static constexpr float max() { return FLT_MAX; }
static constexpr float lowest() { return FLT_MIN; }
static constexpr float epsilon() { return FLT_EPSILON; }
static constexpr float round_error() { return FLT_ROUND_ERR; }
static constexpr float infinity() { return FLT_INF; }
static constexpr float quiet_NaN() { return FLT_QUIET_NAN; }
static constexpr float signaling_NaN() { return FLT_SIGNALING_NAN; }
static constexpr float denorm_min() { return FLT_DENORM_MIN; }
static constexpr float min() { return -FLT_MAX; } //!< \returns the minimum finite value of float
static constexpr float max() { return FLT_MAX; } //!< \returns the maximum finite value of float
static constexpr float lowest() { return FLT_MIN; } //!< \returns the smallest positive value of float
static constexpr float epsilon() { return FLT_EPSILON; } //!< \returns the difference between 1.0 and the next representable value
static constexpr float round_error() { return FLT_ROUND_ERR; } //!< \returns the max rounding error of float
static constexpr float infinity() { return FLT_INF; } //!< \returns a value of float holding a positive infinity
static constexpr float quiet_NaN() { return FLT_QUIET_NAN; } //!< \returns a value of float holding a quiet NaN
static constexpr float signaling_NaN() { return FLT_SIGNALING_NAN; } //!< \returns a value of float holding a signaling NaN
static constexpr float denorm_min() { return FLT_DENORM_MIN; } //!< \returns a value of float holding the smallest positive subnormal
};
// Overload for the bultin double precision floating point type
///
/// \brief Definition for type \emph{double}.
template<> struct numeric_limits<double>
{
static constexpr bool is_specialized = true;
static constexpr bool is_signed = true;
static constexpr bool is_integer = false;
static constexpr bool is_exact = false;
static constexpr bool has_infinity = DBL_HAS_INFINITY;
static constexpr bool has_quiet_nan = DBL_HAS_QUIET_NAN;
static constexpr bool has_signaling_nan = DBL_HAS_SIGNALING_NAN;
static constexpr bool has_denorm = DBL_HAS_DENORM;
static constexpr bool has_denorm_loss = DBL_HAS_DENORM_LOSS;
static constexpr bool is_iec559 = DBL_IS_IEC559;
static constexpr bool is_bounded = true;
static constexpr bool is_modulo = false;
static constexpr bool tinyness_before = DBL_TINYNESS_BEFORE;
static constexpr bool traps = DBL_TRAPS;
static constexpr bool is_specialized = true; //!< Check if the template is specialized for double
static constexpr bool is_signed = true; //!< Check if double is signed
static constexpr bool is_integer = false; //!< Check if double is of an integral type
static constexpr bool is_exact = false; //!< Check if double is exact in its precision
static constexpr bool has_infinity = DBL_HAS_INFINITY; //!< Check if double can hold a value representing infinity
static constexpr bool has_quiet_nan = DBL_HAS_QUIET_NAN; //!< Check if double can hold a non-signaling nan
static constexpr bool has_signaling_nan = DBL_HAS_SIGNALING_NAN; //!< Check if double can hold a signaling nan
static constexpr bool has_denorm = DBL_HAS_DENORM; //!< Check if double denormalizes
static constexpr bool has_denorm_loss = DBL_HAS_DENORM_LOSS; //!< Check if double has precision loss when denormalized
static constexpr bool is_iec559 = DBL_IS_IEC559; //!< Check if double represents an IEC 559 or IEEE 754
static constexpr bool is_bounded = true; //!< Check if double represents a finite set of values
static constexpr bool is_modulo = false; //!< Check if double can handle modulo arithmetic
static constexpr bool tinyness_before = DBL_TINYNESS_BEFORE; //!< Check if double checks for tinyness before rounding
static constexpr bool traps = DBL_TRAPS; //!< Check if double can cause operations to trap
static constexpr int digits = DBL_MANT_DIG;
static constexpr int digits10 = DBL_DIG;
static constexpr int max_digits10 = DBL_DECIMAL_DIG;
static constexpr int radix = DBL_RADIX;
static constexpr int min_exponent = DBL_MIN_EXP;
static constexpr int min_exponent10 = DBL_MIN_10_EXP;
static constexpr int max_exponent = DBL_MAX_EXP;
static constexpr int max_exponent10 = DBL_MAX_10_EXP;
static constexpr int digits = DBL_MANT_DIG; //!< Get the base representation of the type
static constexpr int digits10 = DBL_DIG; //!< Get the number of radix digits double represents
static constexpr int max_digits10 = DBL_DECIMAL_DIG; //!< Get the number of decimal digits double represents
static constexpr int radix = DBL_RADIX; //!< Get the maximum number of decimal digits double represents
static constexpr int min_exponent = DBL_MIN_EXP; //!< Get the minimum number of radix digits that represent the exponent of double
static constexpr int min_exponent10 = DBL_MIN_10_EXP; //!< Get the minimum number of decimal digits that represent the exponent of double
static constexpr int max_exponent = DBL_MAX_EXP; //!< Get the maximum number of radix digits that represent the exponent of double
static constexpr int max_exponent10 = DBL_MAX_10_EXP; //!< Get the maximum number of decimal digits that represent the exponent of double
static constexpr double min() { return -DBL_MAX; }
static constexpr double max() { return DBL_MAX; }
static constexpr double lowest() { return DBL_MIN; }
static constexpr double epsilon() { return DBL_EPSILON; }
static constexpr double round_error() { return DBL_ROUND_ERR; }
static constexpr double infinity() { return DBL_INF; }
static constexpr double quiet_NaN() { return DBL_QUIET_NAN; }
static constexpr double signaling_NaN() { return DBL_SIGNALING_NAN; }
static constexpr double denorm_min() { return DBL_DENORM_MIN; }
static constexpr double min() { return -DBL_MAX; } //!< \returns the minimum finite value of double
static constexpr double max() { return DBL_MAX; } //!< \returns the maximum finite value of double
static constexpr double lowest() { return DBL_MIN; } //!< \returns the smallest positive value of double
static constexpr double epsilon() { return DBL_EPSILON; } //!< \returns the difference between 1.0 and the next representable value
static constexpr double round_error() { return DBL_ROUND_ERR; } //!< \returns the max rounding error of double
static constexpr double infinity() { return DBL_INF; } //!< \returns a value of double holding a positive infinity
static constexpr double quiet_NaN() { return DBL_QUIET_NAN; } //!< \returns a value of double holding a quiet NaN
static constexpr double signaling_NaN() { return DBL_SIGNALING_NAN; } //!< \returns a value of double holding a signaling NaN
static constexpr double denorm_min() { return DBL_DENORM_MIN; } //!< \returns a value of double holding the smallest positive subnormal
};
// Overload for the builtin char type
///
/// \brief Definition for type \emph{char}.
template<> struct numeric_limits<char>
{
static constexpr bool is_specialized = true;
static constexpr bool is_signed = CHAR_IS_SIGNED;
static constexpr bool is_integer = true;
static constexpr bool is_exact = true;
static constexpr bool has_infinity = false;
static constexpr bool has_quiet_nan = false;
static constexpr bool has_signaling_nan = false;
static constexpr bool has_denorm = false;
static constexpr bool has_denorm_loss = false;
static constexpr bool is_iec559 = false;
static constexpr bool is_bounded = true;
static constexpr bool is_modulo = true;
static constexpr bool tinyness_before = false;
static constexpr bool traps = true;
static constexpr bool is_specialized = true; //!< Check if the template is specialized for char
static constexpr bool is_signed = CHAR_IS_SIGNED; //!< Check if char is signed
static constexpr bool is_integer = true; //!< Check if char is of an integral type
static constexpr bool is_exact = true; //!< Check if char is exact in its precision
static constexpr bool has_infinity = false; //!< Check if char can hold a value representing infinity
static constexpr bool has_quiet_nan = false; //!< Check if char can hold a non-signaling nan
static constexpr bool has_signaling_nan = false; //!< Check if char can hold a signaling nan
static constexpr bool has_denorm = false; //!< Check if char denormalizes
static constexpr bool has_denorm_loss = false; //!< Check if char has precision loss when denormalized
static constexpr bool is_iec559 = false; //!< Check if char represents an IEC 559 or IEEE 754
static constexpr bool is_bounded = true; //!< Check if char represents a finite set of values
static constexpr bool is_modulo = true; //!< Check if char can handle modulo arithmetic
static constexpr bool tinyness_before = false; //!< Check if char checks for tinyness before rounding
static constexpr bool traps = true; //!< Check if char can cause operations to trap
static constexpr int digits = CHAR_RADIX_DIG;
static constexpr int digits10 = CHAR_DIG;
static constexpr int max_digits10 = CHAR_DECIMAL_DIG;
static constexpr int radix = CHAR_RADIX;
static constexpr int min_exponent = 0;
static constexpr int min_exponent10 = 0;
static constexpr int max_exponent = 0;
static constexpr int max_exponent10 = 0;
static constexpr int digits = CHAR_RADIX_DIG; //!< Get the base representation of the type
static constexpr int digits10 = CHAR_DIG; //!< Get the number of radix digits char represents
static constexpr int max_digits10 = CHAR_DECIMAL_DIG; //!< Get the number of decimal digits char represents
static constexpr int radix = CHAR_RADIX; //!< Get the maximum number of decimal digits char represents
static constexpr int min_exponent = 0; //!< Get the minimum number of radix digits that represent the exponent of char
static constexpr int min_exponent10 = 0; //!< Get the minimum number of decimal digits that represent the exponent of char
static constexpr int max_exponent = 0; //!< Get the maximum number of radix digits that represent the exponent of char
static constexpr int max_exponent10 = 0; //!< Get the maximum number of decimal digits that represent the exponent of char
static constexpr char min() { return static_cast<char>(CHAR_MIN); }
static constexpr char max() { return CHAR_MAX; }
static constexpr char lowest() { return 1; }
static constexpr char epsilon() { return 1; }
static constexpr char round_error() { return 0; }
static constexpr char infinity() { return 0; }
static constexpr char quiet_NaN() { return 0; }
static constexpr char signaling_NaN() { return 0; }
static constexpr char denorm_min() { return 0; }
static constexpr char min() { return CHAR_MIN; } //!< \returns the minimum finite value of char
static constexpr char max() { return CHAR_MAX; } //!< \returns the maximum finite value of char
static constexpr char lowest() { return 1; } //!< \returns the smallest positive value of char
static constexpr char epsilon() { return 1; } //!< \returns the difference between 1.0 and the next representable value
static constexpr char round_error() { return 0; } //!< \returns the max rounding error of char
static constexpr char infinity() { return 0; } //!< \returns a value of char holding a positive infinity
static constexpr char quiet_NaN() { return 0; } //!< \returns a value of char holding a quiet NaN
static constexpr char signaling_NaN() { return 0; } //!< \returns a value of char holding a signaling NaN
static constexpr char denorm_min() { return 0; } //!< \returns a value of char holding the smallest positive subnormal
};
// Overload for the builtin signed char type
///
/// \brief Definition for type \emph{signed char}.
template<> struct numeric_limits<signed char>
{
static constexpr bool is_specialized = true;
static constexpr bool is_signed = true;
static constexpr bool is_integer = true;
static constexpr bool is_exact = true;
static constexpr bool has_infinity = false;
static constexpr bool has_quiet_nan = false;
static constexpr bool has_signaling_nan = false;
static constexpr bool has_denorm = false;
static constexpr bool has_denorm_loss = false;
static constexpr bool is_iec559 = false;
static constexpr bool is_bounded = true;
static constexpr bool is_modulo = true;
static constexpr bool tinyness_before = false;
static constexpr bool traps = true;
static constexpr bool is_specialized = true; //!< Check if the template is specialized for signed char
static constexpr bool is_signed = true; //!< Check if signed char is signed
static constexpr bool is_integer = true; //!< Check if signed char is of an integral type
static constexpr bool is_exact = true; //!< Check if signed char is exact in its precision
static constexpr bool has_infinity = false; //!< Check if signed char can hold a value representing infinity
static constexpr bool has_quiet_nan = false; //!< Check if signed char can hold a non-signaling nan
static constexpr bool has_signaling_nan = false; //!< Check if signed char can hold a signaling nan
static constexpr bool has_denorm = false; //!< Check if signed char denormalizes
static constexpr bool has_denorm_loss = false; //!< Check if signed char has precision loss when denormalized
static constexpr bool is_iec559 = false; //!< Check if signed char represents an IEC 559 or IEEE 754
static constexpr bool is_bounded = true; //!< Check if signed char represents a finite set of values
static constexpr bool is_modulo = true; //!< Check if signed char can handle modulo arithmetic
static constexpr bool tinyness_before = false; //!< Check if signed char checks for tinyness before rounding
static constexpr bool traps = true; //!< Check if signed char can cause operations to trap
static constexpr int digits = SCHAR_RADIX_DIG;
static constexpr int digits10 = SCHAR_DIG;
static constexpr int max_digits10 = SCHAR_DECIMAL_DIG;
static constexpr int radix = SCHAR_RADIX;
static constexpr int min_exponent = 0;
static constexpr int min_exponent10 = 0;
static constexpr int max_exponent = 0;
static constexpr int max_exponent10 = 0;
static constexpr int digits = SCHAR_RADIX_DIG; //!< Get the base representation of the type
static constexpr int digits10 = SCHAR_DIG; //!< Get the number of radix digits signed char represents
static constexpr int max_digits10 = SCHAR_DECIMAL_DIG; //!< Get the number of decimal digits signed char represents
static constexpr int radix = SCHAR_RADIX; //!< Get the maximum number of decimal digits signed char represents
static constexpr int min_exponent = 0; //!< Get the minimum number of radix digits that represent the exponent of signed char
static constexpr int min_exponent10 = 0; //!< Get the minimum number of decimal digits that represent the exponent of signed char
static constexpr int max_exponent = 0; //!< Get the maximum number of radix digits that represent the exponent of signed char
static constexpr int max_exponent10 = 0; //!< Get the maximum number of decimal digits that represent the exponent of signed char
static constexpr signed char min() { return static_cast<signed char>(SCHAR_MIN); }
static constexpr signed char max() { return SCHAR_MAX; }
static constexpr signed char lowest() { return 1; }
static constexpr signed char epsilon() { return 1; }
static constexpr signed char round_error() { return 0; }
static constexpr signed char infinity() { return 0; }
static constexpr signed char quiet_NaN() { return 0; }
static constexpr signed char signaling_NaN() { return 0; }
static constexpr signed char denorm_min() { return 0; }
static constexpr signed char min() { return SCHAR_MIN; } //!< \returns the minimum finite value of signed char
static constexpr signed char max() { return SCHAR_MAX; } //!< \returns the maximum finite value of signed char
static constexpr signed char lowest() { return 1; } //!< \returns the smallest positive value of signed char
static constexpr signed char epsilon() { return 1; } //!< \returns the difference between 1.0 and the next representable value
static constexpr signed char round_error() { return 0; } //!< \returns the max rounding error of signed char
static constexpr signed char infinity() { return 0; } //!< \returns a value of signed char holding a positive infinity
static constexpr signed char quiet_NaN() { return 0; } //!< \returns a value of signed char holding a quiet NaN
static constexpr signed char signaling_NaN() { return 0; } //!< \returns a value of signed char holding a signaling NaN
static constexpr signed char denorm_min() { return 0; } //!< \returns a value of signed char holding the smallest positive subnormal
};
// Overload for the builtin signed char type
///
/// \brief Definition for type \emph{unsigned char}.
template<> struct numeric_limits<unsigned char>
{
static constexpr bool is_specialized = true;
static constexpr bool is_signed = false;
static constexpr bool is_integer = true;
static constexpr bool is_exact = true;
static constexpr bool has_infinity = false;
static constexpr bool has_quiet_nan = false;
static constexpr bool has_signaling_nan = false;
static constexpr bool has_denorm = false;
static constexpr bool has_denorm_loss = false;
static constexpr bool is_iec559 = false;
static constexpr bool is_bounded = true;
static constexpr bool is_modulo = true;
static constexpr bool tinyness_before = false;
static constexpr bool traps = true;
static constexpr bool is_specialized = true; //!< Check if the template is specialized for unsigned char
static constexpr bool is_signed = false; //!< Check if unsigned char is unsigned
static constexpr bool is_integer = true; //!< Check if unsigned char is of an integral type
static constexpr bool is_exact = true; //!< Check if unsigned char is exact in its precision
static constexpr bool has_infinity = false; //!< Check if unsigned char can hold a value representing infinity
static constexpr bool has_quiet_nan = false; //!< Check if unsigned char can hold a non-signaling nan
static constexpr bool has_signaling_nan = false; //!< Check if unsigned char can hold a signaling nan
static constexpr bool has_denorm = false; //!< Check if unsigned char denormalizes
static constexpr bool has_denorm_loss = false; //!< Check if unsigned char has precision loss when denormalized
static constexpr bool is_iec559 = false; //!< Check if unsigned char represents an IEC 559 or IEEE 754
static constexpr bool is_bounded = true; //!< Check if unsigned char represents a finite set of values
static constexpr bool is_modulo = true; //!< Check if unsigned char can handle modulo arithmetic
static constexpr bool tinyness_before = false; //!< Check if unsigned char checks for tinyness before rounding
static constexpr bool traps = true; //!< Check if unsigned char can cause operations to trap
static constexpr int digits = UCHAR_RADIX_DIG;
static constexpr int digits10 = UCHAR_DIG;
static constexpr int max_digits10 = UCHAR_DECIMAL_DIG;
static constexpr int radix = UCHAR_RADIX;
static constexpr int min_exponent = 0;
static constexpr int min_exponent10 = 0;
static constexpr int max_exponent = 0;
static constexpr int max_exponent10 = 0;
static constexpr int digits = UCHAR_RADIX_DIG; //!< Get the base representation of the type
static constexpr int digits10 = UCHAR_DIG; //!< Get the number of radix digits unsigned char represents
static constexpr int max_digits10 = UCHAR_DECIMAL_DIG; //!< Get the number of decimal digits unsigned char represents
static constexpr int radix = UCHAR_RADIX; //!< Get the maximum number of decimal digits unsigned char represents
static constexpr int min_exponent = 0; //!< Get the minimum number of radix digits that represent the exponent of unsigned char
static constexpr int min_exponent10 = 0; //!< Get the minimum number of decimal digits that represent the exponent of unsigned char
static constexpr int max_exponent = 0; //!< Get the maximum number of radix digits that represent the exponent of unsigned char
static constexpr int max_exponent10 = 0; //!< Get the maximum number of decimal digits that represent the exponent of unsigned char
static constexpr unsigned char min() { return UCHAR_MIN; }
static constexpr unsigned char max() { return UCHAR_MAX; }
static constexpr unsigned char lowest() { return 1; }
static constexpr unsigned char epsilon() { return 1; }
static constexpr unsigned char round_error() { return 0; }
static constexpr unsigned char infinity() { return 0; }
static constexpr unsigned char quiet_NaN() { return 0; }
static constexpr unsigned char signaling_NaN() { return 0; }
static constexpr unsigned char denorm_min() { return 0; }
static constexpr unsigned char min() { return UCHAR_MIN; } //!< \returns the minimum finite value of unsigned char
static constexpr unsigned char max() { return UCHAR_MAX; } //!< \returns the maximum finite value of unsigned char
static constexpr unsigned char lowest() { return 1; } //!< \returns the smallest positive value of unsigned char
static constexpr unsigned char epsilon() { return 1; } //!< \returns the difference between 1.0 and the next representable value
static constexpr unsigned char round_error() { return 0; } //!< \returns the max rounding error of unsigned char
static constexpr unsigned char infinity() { return 0; } //!< \returns a value of unsigned char holding a positive infinity
static constexpr unsigned char quiet_NaN() { return 0; } //!< \returns a value of unsigned char holding a quiet NaN
static constexpr unsigned char signaling_NaN() { return 0; } //!< \returns a value of unsigned char holding a signaling NaN
static constexpr unsigned char denorm_min() { return 0; } //!< \returns a value of unsigned char holding the smallest positive subnormal
};
// Overload for the builtin signed char type
///
/// \brief Definition for type \emph{short}.
template<> struct numeric_limits<short>
{
static constexpr bool is_specialized = true;
static constexpr bool is_signed = true;
static constexpr bool is_integer = true;
static constexpr bool is_exact = true;
static constexpr bool has_infinity = false;
static constexpr bool has_quiet_nan = false;
static constexpr bool has_signaling_nan = false;
static constexpr bool has_denorm = false;
static constexpr bool has_denorm_loss = false;
static constexpr bool is_iec559 = false;
static constexpr bool is_bounded = true;
static constexpr bool is_modulo = true;
static constexpr bool tinyness_before = false;
static constexpr bool traps = true;
static constexpr bool is_specialized = true; //!< Check if the template is specialized for short
static constexpr bool is_signed = true; //!< Check if short is signed
static constexpr bool is_integer = true; //!< Check if short is of an integral type
static constexpr bool is_exact = true; //!< Check if short is exact in its precision
static constexpr bool has_infinity = false; //!< Check if short can hold a value representing infinity
static constexpr bool has_quiet_nan = false; //!< Check if short can hold a non-signaling nan
static constexpr bool has_signaling_nan = false; //!< Check if short can hold a signaling nan
static constexpr bool has_denorm = false; //!< Check if short denormalizes
static constexpr bool has_denorm_loss = false; //!< Check if short has precision loss when denormalized
static constexpr bool is_iec559 = false; //!< Check if short represents an IEC 559 or IEEE 754
static constexpr bool is_bounded = true; //!< Check if short represents a finite set of values
static constexpr bool is_modulo = true; //!< Check if short can handle modulo arithmetic
static constexpr bool tinyness_before = false; //!< Check if short checks for tinyness before rounding
static constexpr bool traps = true; //!< Check if short can cause operations to trap
static constexpr int digits = SHORT_RADIX_DIG;
static constexpr int digits10 = SHORT_DIG;
static constexpr int max_digits10 = SHORT_DECIMAL_DIG;
static constexpr int radix = SHORT_RADIX;
static constexpr int min_exponent = 0;
static constexpr int min_exponent10 = 0;
static constexpr int max_exponent = 0;
static constexpr int max_exponent10 = 0;
static constexpr int digits = SHORT_RADIX_DIG; //!< Get the base representation of the type
static constexpr int digits10 = SHORT_DIG; //!< Get the number of radix digits short represents
static constexpr int max_digits10 = SHORT_DECIMAL_DIG; //!< Get the number of decimal digits short represents
static constexpr int radix = SHORT_RADIX; //!< Get the maximum number of decimal digits short represents
static constexpr int min_exponent = 0; //!< Get the minimum number of radix digits that represent the exponent of short
static constexpr int min_exponent10 = 0; //!< Get the minimum number of decimal digits that represent the exponent of short
static constexpr int max_exponent = 0; //!< Get the maximum number of radix digits that represent the exponent of short
static constexpr int max_exponent10 = 0; //!< Get the maximum number of decimal digits that represent the exponent of short
static constexpr short min() { return static_cast<short>(SHORT_MIN); }
static constexpr short max() { return SHORT_MAX; }
static constexpr short lowest() { return 1; }
static constexpr short epsilon() { return 1; }
static constexpr short round_error() { return 0; }
static constexpr short infinity() { return 0; }
static constexpr short quiet_NaN() { return 0; }
static constexpr short signaling_NaN() { return 0; }
static constexpr short denorm_min() { return 0; }
static constexpr short min() { return static_cast<short>(SHORT_MIN); } //!< \returns the minimum finite value of short
static constexpr short max() { return SHORT_MAX; } //!< \returns the maximum finite value of short
static constexpr short lowest() { return 1; } //!< \returns the smallest positive value of short
static constexpr short epsilon() { return 1; } //!< \returns the difference between 1.0 and the next representable value
static constexpr short round_error() { return 0; } //!< \returns the max rounding error of short
static constexpr short infinity() { return 0; } //!< \returns a value of short holding a positive infinity
static constexpr short quiet_NaN() { return 0; } //!< \returns a value of short holding a quiet NaN
static constexpr short signaling_NaN() { return 0; } //!< \returns a value of short holding a signaling NaN
static constexpr short denorm_min() { return 0; } //!< \returns a value of short holding the smallest positive subnormal
};
// Overload for the builtin signed char type
///
/// \brief Definition for type \emph{unsigned short}.
template<> struct numeric_limits<unsigned short>
{
static constexpr bool is_specialized = true;
static constexpr bool is_signed = false;
static constexpr bool is_integer = true;
static constexpr bool is_exact = true;
static constexpr bool has_infinity = false;
static constexpr bool has_quiet_nan = false;
static constexpr bool has_signaling_nan = false;
static constexpr bool has_denorm = false;
static constexpr bool has_denorm_loss = false;
static constexpr bool is_iec559 = false;
static constexpr bool is_bounded = true;
static constexpr bool is_modulo = true;
static constexpr bool tinyness_before = false;
static constexpr bool traps = true;
static constexpr bool is_specialized = true; //!< Check if the template is specialized for signed short
static constexpr bool is_signed = false; //!< Check if unsigned short is signed
static constexpr bool is_integer = true; //!< Check if unsigned short is of an integral type
static constexpr bool is_exact = true; //!< Check if unsigned short is exact in its precision
static constexpr bool has_infinity = false; //!< Check if unsigned short can hold a value representing infinity
static constexpr bool has_quiet_nan = false; //!< Check if unsigned short can hold a non-signaling nan
static constexpr bool has_signaling_nan = false; //!< Check if unsigned short can hold a signaling nan
static constexpr bool has_denorm = false; //!< Check if unsigned short denormalizes
static constexpr bool has_denorm_loss = false; //!< Check if unsigned short has precision loss when denormalized
static constexpr bool is_iec559 = false; //!< Check if unsigned short represents an IEC 559 or IEEE 754
static constexpr bool is_bounded = true; //!< Check if unsigned short represents a finite set of values
static constexpr bool is_modulo = true; //!< Check if unsigned short can handle modulo arithmetic
static constexpr bool tinyness_before = false; //!< Check if unsigned short checks for tinyness before rounding
static constexpr bool traps = true; //!< Check if unsigned short can cause operations to trap
static constexpr int digits = USHORT_RADIX_DIG;
static constexpr int digits10 = USHORT_DIG;
static constexpr int max_digits10 = USHORT_DECIMAL_DIG;
static constexpr int radix = USHORT_RADIX;
static constexpr int min_exponent = 0;
static constexpr int min_exponent10 = 0;
static constexpr int max_exponent = 0;
static constexpr int max_exponent10 = 0;
static constexpr int digits = USHORT_RADIX_DIG; //!< Get the base representation of the type
static constexpr int digits10 = USHORT_DIG; //!< Get the number of radix digits unsigned short represents
static constexpr int max_digits10 = USHORT_DECIMAL_DIG; //!< Get the number of decimal digits unsigned short represents
static constexpr int radix = USHORT_RADIX; //!< Get the maximum number of decimal digits unsigned short represents
static constexpr int min_exponent = 0; //!< Get the minimum number of radix digits that represent the exponent of unsigned short
static constexpr int min_exponent10 = 0; //!< Get the minimum number of decimal digits that represent the exponent of unsigned short
static constexpr int max_exponent = 0; //!< Get the maximum number of radix digits that represent the exponent of unsigned short
static constexpr int max_exponent10 = 0; //!< Get the maximum number of decimal digits that represent the exponent of unsigned short
static constexpr unsigned short min() { return USHORT_MIN; }
static constexpr unsigned short max() { return USHORT_MAX; }
static constexpr unsigned short lowest() { return 1; }
static constexpr unsigned short epsilon() { return 1; }
static constexpr unsigned short round_error() { return 0; }
static constexpr unsigned short infinity() { return 0; }
static constexpr unsigned short quiet_NaN() { return 0; }
static constexpr unsigned short signaling_NaN() { return 0; }
static constexpr unsigned short denorm_min() { return 0; }
static constexpr unsigned short min() { return USHORT_MIN; } //!< \returns the minimum finite value of unsigned short
static constexpr unsigned short max() { return USHORT_MAX; } //!< \returns the maximum finite value of unsigned short
static constexpr unsigned short lowest() { return 1; } //!< \returns the smallest positive value of unsigned short
static constexpr unsigned short epsilon() { return 1; } //!< \returns the difference between 1.0 and the next representable value
static constexpr unsigned short round_error() { return 0; } //!< \returns the max rounding error of unsigned short
static constexpr unsigned short infinity() { return 0; } //!< \returns a value of unsigned short holding a positive infinity
static constexpr unsigned short quiet_NaN() { return 0; } //!< \returns a value of unsigned short holding a quiet NaN
static constexpr unsigned short signaling_NaN() { return 0; } //!< \returns a value of unsigned short holding a signaling NaN
static constexpr unsigned short denorm_min() { return 0; } //!< \returns a value of unsigned short holding the smallest positive subnormal
};
// Overload for the builtin signed char type
///
/// \brief Definition for type \emph{int}.
template<> struct numeric_limits<int>
{
static constexpr bool is_specialized = true;
static constexpr bool is_signed = true;
static constexpr bool is_integer = true;
static constexpr bool is_exact = true;
static constexpr bool has_infinity = false;
static constexpr bool has_quiet_nan = false;
static constexpr bool has_signaling_nan = false;
static constexpr bool has_denorm = false;
static constexpr bool has_denorm_loss = false;
static constexpr bool is_iec559 = false;
static constexpr bool is_bounded = true;
static constexpr bool is_modulo = true;
static constexpr bool tinyness_before = false;
static constexpr bool traps = true;
static constexpr bool is_specialized = true; //!< Check if the template is specialized for int
static constexpr bool is_signed = true; //!< Check if int is signed
static constexpr bool is_integer = true; //!< Check if int is of an integral type
static constexpr bool is_exact = true; //!< Check if int is exact in its precision
static constexpr bool has_infinity = false; //!< Check if int can hold a value representing infinity
static constexpr bool has_quiet_nan = false; //!< Check if int can hold a non-signaling nan
static constexpr bool has_signaling_nan = false; //!< Check if int can hold a signaling nan
static constexpr bool has_denorm = false; //!< Check if int denormalizes
static constexpr bool has_denorm_loss = false; //!< Check if int has precision loss when denormalized
static constexpr bool is_iec559 = false; //!< Check if int represents an IEC 559 or IEEE 754
static constexpr bool is_bounded = true; //!< Check if int represents a finite set of values
static constexpr bool is_modulo = true; //!< Check if int can handle modulo arithmetic
static constexpr bool tinyness_before = false; //!< Check if int checks for tinyness before rounding
static constexpr bool traps = true; //!< Check if int can cause operations to trap
static constexpr int digits = INT_RADIX_DIG;
static constexpr int digits10 = INT_DIG;
static constexpr int max_digits10 = INT_DECIMAL_DIG;
static constexpr int radix = INT_RADIX;
static constexpr int min_exponent = 0;
static constexpr int min_exponent10 = 0;
static constexpr int max_exponent = 0;
static constexpr int max_exponent10 = 0;
static constexpr int digits = INT_RADIX_DIG; //!< Get the base representation of the type
static constexpr int digits10 = INT_DIG; //!< Get the number of radix digits int represents
static constexpr int max_digits10 = INT_DECIMAL_DIG; //!< Get the number of decimal digits int represents
static constexpr int radix = INT_RADIX; //!< Get the maximum number of decimal digits int represents
static constexpr int min_exponent = 0; //!< Get the minimum number of radix digits that represent the exponent of int
static constexpr int min_exponent10 = 0; //!< Get the minimum number of decimal digits that represent the exponent of int
static constexpr int max_exponent = 0; //!< Get the maximum number of radix digits that represent the exponent of int
static constexpr int max_exponent10 = 0; //!< Get the maximum number of decimal digits that represent the exponent of int
static constexpr int min() { return INT_MIN; }
static constexpr int max() { return INT_MAX; }
static constexpr int lowest() { return 1; }
static constexpr int epsilon() { return 1; }
static constexpr int round_error() { return 0; }
static constexpr int infinity() { return 0; }
static constexpr int quiet_NaN() { return 0; }
static constexpr int signaling_NaN() { return 0; }
static constexpr int denorm_min() { return 0; }
static constexpr int min() { return INT_MIN; } //!< \returns the minimum finite value of int
static constexpr int max() { return INT_MAX; } //!< \returns the maximum finite value of int
static constexpr int lowest() { return 1; } //!< \returns the smallest positive value of int
static constexpr int epsilon() { return 1; } //!< \returns the difference between 1.0 and the next representable value
static constexpr int round_error() { return 0; } //!< \returns the max rounding error of int
static constexpr int infinity() { return 0; } //!< \returns a value of int holding a positive infinity
static constexpr int quiet_NaN() { return 0; } //!< \returns a value of int holding a quiet NaN
static constexpr int signaling_NaN() { return 0; } //!< \returns a value of int holding a signaling NaN
static constexpr int denorm_min() { return 0; } //!< \returns a value of int holding the smallest positive subnormal
};
// Overload for the builtin signed char type
///
/// \brief Definition for type \emph{unsigned int}.
template<> struct numeric_limits<unsigned int>
{
static constexpr bool is_specialized = true;
static constexpr bool is_signed = false;
static constexpr bool is_integer = true;
static constexpr bool is_exact = true;
static constexpr bool has_infinity = false;
static constexpr bool has_quiet_nan = false;
static constexpr bool has_signaling_nan = false;
static constexpr bool has_denorm = false;
static constexpr bool has_denorm_loss = false;
static constexpr bool is_iec559 = false;
static constexpr bool is_bounded = true;
static constexpr bool is_modulo = true;
static constexpr bool tinyness_before = false;
static constexpr bool traps = true;
static constexpr bool is_specialized = true; //!< Check if the template is specialized for unsigned int
static constexpr bool is_signed = false; //!< Check if unsigned int is signed
static constexpr bool is_integer = true; //!< Check if unsigned int is of an integral type
static constexpr bool is_exact = true; //!< Check if unsigned int is exact in its precision
static constexpr bool has_infinity = false; //!< Check if unsigned int can hold a value representing infinity
static constexpr bool has_quiet_nan = false; //!< Check if unsigned int can hold a non-signaling nan
static constexpr bool has_signaling_nan = false; //!< Check if unsigned int can hold a signaling nan
static constexpr bool has_denorm = false; //!< Check if unsigned int denormalizes
static constexpr bool has_denorm_loss = false; //!< Check if unsigned int has precision loss when denormalized
static constexpr bool is_iec559 = false; //!< Check if unsigned int represents an IEC 559 or IEEE 754
static constexpr bool is_bounded = true; //!< Check if unsigned int represents a finite set of values
static constexpr bool is_modulo = true; //!< Check if unsigned int can handle modulo arithmetic
static constexpr bool tinyness_before = false; //!< Check if unsigned int checks for tinyness before rounding
static constexpr bool traps = true; //!< Check if unsigned int can cause operations to trap
static constexpr int digits = UINT_RADIX_DIG;
static constexpr int digits10 = UINT_DIG;
static constexpr int max_digits10 = UINT_DECIMAL_DIG;
static constexpr int radix = UINT_RADIX;
static constexpr int min_exponent = 0;
static constexpr int min_exponent10 = 0;
static constexpr int max_exponent = 0;
static constexpr int max_exponent10 = 0;
static constexpr int digits = UINT_RADIX_DIG; //!< Get the base representation of the type
static constexpr int digits10 = UINT_DIG; //!< Get the number of radix digits unsigned int represents
static constexpr int max_digits10 = UINT_DECIMAL_DIG; //!< Get the number of decimal digits unsigned int represents
static constexpr int radix = UINT_RADIX; //!< Get the maximum number of decimal digits unsigned int represents
static constexpr int min_exponent = 0; //!< Get the minimum number of radix digits that represent the exponent of unsigned int
static constexpr int min_exponent10 = 0; //!< Get the minimum number of decimal digits that represent the exponent of unsigned int
static constexpr int max_exponent = 0; //!< Get the maximum number of radix digits that represent the exponent of unsigned int
static constexpr int max_exponent10 = 0; //!< Get the maximum number of decimal digits that represent the exponent of unsigned int
static constexpr unsigned int min() { return UINT_MIN; }
static constexpr unsigned int max() { return UINT_MAX; }
static constexpr unsigned int lowest() { return 1; }
static constexpr unsigned int epsilon() { return 1; }
static constexpr unsigned int round_error() { return 0; }
static constexpr unsigned int infinity() { return 0; }
static constexpr unsigned int quiet_NaN() { return 0; }
static constexpr unsigned int signaling_NaN() { return 0; }
static constexpr unsigned int denorm_min() { return 0; }
static constexpr unsigned int min() { return UINT_MIN; } //!< \returns the minimum finite value of unsigned int
static constexpr unsigned int max() { return UINT_MAX; } //!< \returns the maximum finite value of unsigned int
static constexpr unsigned int lowest() { return 1; } //!< \returns the smallest positive value of unsigned int
static constexpr unsigned int epsilon() { return 1; } //!< \returns the difference between 1.0 and the next representable value
static constexpr unsigned int round_error() { return 0; } //!< \returns the max rounding error of unsigned int
static constexpr unsigned int infinity() { return 0; } //!< \returns a value of unsigned int holding a positive infinity
static constexpr unsigned int quiet_NaN() { return 0; } //!< \returns a value of unsigned int holding a quiet NaN
static constexpr unsigned int signaling_NaN() { return 0; } //!< \returns a value of unsigned int holding a signaling NaN
static constexpr unsigned int denorm_min() { return 0; } //!< \returns a value of unsigned int holding the smallest positive subnormal
};
// Overload for the builtin signed char type
///
/// \brief Definition for type \emph{long int}.
template<> struct numeric_limits<long int>
{
static constexpr bool is_specialized = true;
static constexpr bool is_signed = true;
static constexpr bool is_integer = true;
static constexpr bool is_exact = true;
static constexpr bool has_infinity = false;
static constexpr bool has_quiet_nan = false;
static constexpr bool has_signaling_nan = false;
static constexpr bool has_denorm = false;
static constexpr bool has_denorm_loss = false;
static constexpr bool is_iec559 = false;
static constexpr bool is_bounded = true;
static constexpr bool is_modulo = true;
static constexpr bool tinyness_before = false;
static constexpr bool traps = true;
static constexpr bool is_specialized = true; //!< Check if the template is specialized for long int
static constexpr bool is_signed = true; //!< Check if long int is signed
static constexpr bool is_integer = true; //!< Check if long int is of an integral type
static constexpr bool is_exact = true; //!< Check if long int is exact in its precision
static constexpr bool has_infinity = false; //!< Check if long int can hold a value representing infinity
static constexpr bool has_quiet_nan = false; //!< Check if long int can hold a non-signaling nan
static constexpr bool has_signaling_nan = false; //!< Check if long int can hold a signaling nan
static constexpr bool has_denorm = false; //!< Check if long int denormalizes
static constexpr bool has_denorm_loss = false; //!< Check if long int has precision loss when denormalized
static constexpr bool is_iec559 = false; //!< Check if long int represents an IEC 559 or IEEE 754
static constexpr bool is_bounded = true; //!< Check if long int represents a finite set of values
static constexpr bool is_modulo = true; //!< Check if long int can handle modulo arithmetic
static constexpr bool tinyness_before = false; //!< Check if long int checks for tinyness before rounding
static constexpr bool traps = true; //!< Check if long int can cause operations to trap
static constexpr int digits = LONG_RADIX_DIG;
static constexpr int digits10 = LONG_DIG;
static constexpr int max_digits10 = LONG_DECIMAL_DIG;
static constexpr int radix = LONG_RADIX;
static constexpr int min_exponent = 0;
static constexpr int min_exponent10 = 0;
static constexpr int max_exponent = 0;
static constexpr int max_exponent10 = 0;
static constexpr int digits = LONG_RADIX_DIG; //!< Get the base representation of the type
static constexpr int digits10 = LONG_DIG; //!< Get the number of radix digits long int represents
static constexpr int max_digits10 = LONG_DECIMAL_DIG; //!< Get the number of decimal digits long int represents
static constexpr int radix = LONG_RADIX; //!< Get the maximum number of decimal digits long int represents
static constexpr int min_exponent = 0; //!< Get the minimum number of radix digits that represent the exponent of long int
static constexpr int min_exponent10 = 0; //!< Get the minimum number of decimal digits that represent the exponent of long int
static constexpr int max_exponent = 0; //!< Get the maximum number of radix digits that represent the exponent of long int
static constexpr int max_exponent10 = 0; //!< Get the maximum number of decimal digits that represent the exponent of long int
static constexpr long int min() { return LONG_MIN; }
static constexpr long int max() { return LONG_MAX; }
static constexpr long int lowest() { return 1; }
static constexpr long int epsilon() { return 1; }
static constexpr long int round_error() { return 0; }
static constexpr long int infinity() { return 0; }
static constexpr long int quiet_NaN() { return 0; }
static constexpr long int signaling_NaN() { return 0; }
static constexpr long int denorm_min() { return 0; }
static constexpr long int min() { return LONG_MIN; } //!< \returns the minimum finite value of long int
static constexpr long int max() { return LONG_MAX; } //!< \returns the maximum finite value of long int
static constexpr long int lowest() { return 1; } //!< \returns the smallest positive value of long int
static constexpr long int epsilon() { return 1; } //!< \returns the difference between 1.0 and the next representable value
static constexpr long int round_error() { return 0; } //!< \returns the max rounding error of long int
static constexpr long int infinity() { return 0; } //!< \returns a value of long int holding a positive infinity
static constexpr long int quiet_NaN() { return 0; } //!< \returns a value of long int holding a quiet NaN
static constexpr long int signaling_NaN() { return 0; } //!< \returns a value of long int holding a signaling NaN
static constexpr long int denorm_min() { return 0; } //!< \returns a value of long int holding the smallest positive subnormal
};
// Overload for the builtin signed char type
///
/// \brief Definition for type \emph{unsigned long int}.
template<> struct numeric_limits<unsigned long int>
{
static constexpr bool is_specialized = true;
static constexpr bool is_signed = false;
static constexpr bool is_integer = true;
static constexpr bool is_exact = true;
static constexpr bool has_infinity = false;
static constexpr bool has_quiet_nan = false;
static constexpr bool has_signaling_nan = false;
static constexpr bool has_denorm = false;
static constexpr bool has_denorm_loss = false;
static constexpr bool is_iec559 = false;
static constexpr bool is_bounded = true;
static constexpr bool is_modulo = true;
static constexpr bool tinyness_before = false;
static constexpr bool traps = true;
static constexpr bool is_specialized = true; //!< Check if the template is specialized for unsigned long int
static constexpr bool is_signed = false; //!< Check if unsigned long int is signed
static constexpr bool is_integer = true; //!< Check if unsigned long int is of an integral type
static constexpr bool is_exact = true; //!< Check if unsigned long int is exact in its precision
static constexpr bool has_infinity = false; //!< Check if unsigned long int can hold a value representing infinity
static constexpr bool has_quiet_nan = false; //!< Check if unsigned long int can hold a non-signaling nan
static constexpr bool has_signaling_nan = false; //!< Check if unsigned long int can hold a signaling nan
static constexpr bool has_denorm = false; //!< Check if unsigned long int denormalizes
static constexpr bool has_denorm_loss = false; //!< Check if unsigned long int has precision loss when denormalized
static constexpr bool is_iec559 = false; //!< Check if unsigned long int represents an IEC 559 or IEEE 754
static constexpr bool is_bounded = true; //!< Check if unsigned long int represents a finite set of values
static constexpr bool is_modulo = true; //!< Check if unsigned long int can handle modulo arithmetic
static constexpr bool tinyness_before = false; //!< Check if unsigned long int checks for tinyness before rounding
static constexpr bool traps = true; //!< Check if unsigned long int can cause operations to trap
static constexpr int digits = ULONG_RADIX_DIG;
static constexpr int digits10 = ULONG_DIG;
static constexpr int max_digits10 = ULONG_DECIMAL_DIG;
static constexpr int radix = ULONG_RADIX;
static constexpr int min_exponent = 0;
static constexpr int min_exponent10 = 0;
static constexpr int max_exponent = 0;
static constexpr int max_exponent10 = 0;
static constexpr int digits = ULONG_RADIX_DIG; //!< Get the base representation of the type
static constexpr int digits10 = ULONG_DIG; //!< Get the number of radix digits unsigned long int represents
static constexpr int max_digits10 = ULONG_DECIMAL_DIG; //!< Get the number of decimal digits unsigned long int represents
static constexpr int radix = ULONG_RADIX; //!< Get the maximum number of decimal digits unsigned long int represents
static constexpr int min_exponent = 0; //!< Get the minimum number of radix digits that represent the exponent of unsigned long int
static constexpr int min_exponent10 = 0; //!< Get the minimum number of decimal digits that represent the exponent of unsigned long int
static constexpr int max_exponent = 0; //!< Get the maximum number of radix digits that represent the exponent of unsigned long int
static constexpr int max_exponent10 = 0; //!< Get the maximum number of decimal digits that represent the exponent of unsigned long int
static constexpr unsigned long min() { return ULONG_MIN; }
static constexpr unsigned long max() { return ULONG_MAX; }
static constexpr unsigned long lowest() { return 1; }
static constexpr unsigned long epsilon() { return 1; }
static constexpr unsigned long round_error() { return 0; }
static constexpr unsigned long infinity() { return 0; }
static constexpr unsigned long quiet_NaN() { return 0; }
static constexpr unsigned long signaling_NaN() { return 0; }
static constexpr unsigned long denorm_min() { return 0; }
static constexpr unsigned long min() { return ULONG_MIN; } //!< \returns the minimum finite value of unsigned long int
static constexpr unsigned long max() { return ULONG_MAX; } //!< \returns the maximum finite value of unsigned long int
static constexpr unsigned long lowest() { return 1; } //!< \returns the smallest positive value of unsigned long int
static constexpr unsigned long epsilon() { return 1; } //!< \returns the difference between 1.0 and the next representable value
static constexpr unsigned long round_error() { return 0; } //!< \returns the max rounding error of unsigned long int
static constexpr unsigned long infinity() { return 0; } //!< \returns a value of unsigned long int holding a positive infinity
static constexpr unsigned long quiet_NaN() { return 0; } //!< \returns a value of unsigned long int holding a quiet NaN
static constexpr unsigned long signaling_NaN() { return 0; } //!< \returns a value of unsigned long int holding a signaling NaN
static constexpr unsigned long denorm_min() { return 0; } //!< \returns a value of unsigned long int holding the smallest positive subnormal
};
// Overload for the builtin signed char type
///
/// \brief Definition for type \emph{long long}.
template<> struct numeric_limits<long long>
{
static constexpr bool is_specialized = true;
static constexpr bool is_signed = true;
static constexpr bool is_integer = true;
static constexpr bool is_exact = true;
static constexpr bool has_infinity = false;
static constexpr bool has_quiet_nan = false;
static constexpr bool has_signaling_nan = false;
static constexpr bool has_denorm = false;
static constexpr bool has_denorm_loss = false;
static constexpr bool is_iec559 = false;
static constexpr bool is_bounded = true;
static constexpr bool is_modulo = true;
static constexpr bool tinyness_before = false;
static constexpr bool traps = true;
static constexpr bool is_specialized = true; //!< Check if the template is specialized for long long
static constexpr bool is_signed = true; //!< Check if long long is signed
static constexpr bool is_integer = true; //!< Check if long long is of an integral type
static constexpr bool is_exact = true; //!< Check if long long is exact in its precision
static constexpr bool has_infinity = false; //!< Check if long long can hold a value representing infinity
static constexpr bool has_quiet_nan = false; //!< Check if long long can hold a non-signaling nan
static constexpr bool has_signaling_nan = false; //!< Check if long long can hold a signaling nan
static constexpr bool has_denorm = false; //!< Check if long long denormalizes
static constexpr bool has_denorm_loss = false; //!< Check if long long has precision loss when denormalized
static constexpr bool is_iec559 = false; //!< Check if long long represents an IEC 559 or IEEE 754
static constexpr bool is_bounded = true; //!< Check if long long represents a finite set of values
static constexpr bool is_modulo = true; //!< Check if long long can handle modulo arithmetic
static constexpr bool tinyness_before = false; //!< Check if long long checks for tinyness before rounding
static constexpr bool traps = true; //!< Check if long long can cause operations to trap
static constexpr int digits = LLONG_RADIX_DIG;
static constexpr int digits10 = LLONG_DIG;
static constexpr int max_digits10 = LLONG_DECIMAL_DIG;
static constexpr int radix = LLONG_RADIX;
static constexpr int min_exponent = 0;
static constexpr int min_exponent10 = 0;
static constexpr int max_exponent = 0;
static constexpr int max_exponent10 = 0;
static constexpr int digits = LLONG_RADIX_DIG; //!< Get the base representation of the type
static constexpr int digits10 = LLONG_DIG; //!< Get the number of radix digits long long represents
static constexpr int max_digits10 = LLONG_DECIMAL_DIG; //!< Get the number of decimal digits long long represents
static constexpr int radix = LLONG_RADIX; //!< Get the maximum number of decimal digits long long represents
static constexpr int min_exponent = 0; //!< Get the minimum number of radix digits that represent the exponent of long long
static constexpr int min_exponent10 = 0; //!< Get the minimum number of decimal digits that represent the exponent of long long
static constexpr int max_exponent = 0; //!< Get the maximum number of radix digits that represent the exponent of long long
static constexpr int max_exponent10 = 0; //!< Get the maximum number of decimal digits that represent the exponent of long long
static constexpr long long min() { return LLONG_MIN; }
static constexpr long long max() { return LLONG_MAX; }
static constexpr long long lowest() { return 1; }
static constexpr long long epsilon() { return 1; }
static constexpr long long round_error() { return 0; }
static constexpr long long infinity() { return 0; }
static constexpr long long quiet_NaN() { return 0; }
static constexpr long long signaling_NaN() { return 0; }
static constexpr long long denorm_min() { return 0; }
static constexpr long long min() { return LLONG_MIN; } //!< \returns the minimum finite value of long long
static constexpr long long max() { return LLONG_MAX; } //!< \returns the maximum finite value of long long
static constexpr long long lowest() { return 1; } //!< \returns the smallest positive value of long long
static constexpr long long epsilon() { return 1; } //!< \returns the difference between 1.0 and the next representable value
static constexpr long long round_error() { return 0; } //!< \returns the max rounding error of long long
static constexpr long long infinity() { return 0; } //!< \returns a value of long long holding a positive infinity
static constexpr long long quiet_NaN() { return 0; } //!< \returns a value of long long holding a quiet NaN
static constexpr long long signaling_NaN() { return 0; } //!< \returns a value of long long holding a signaling NaN
static constexpr long long denorm_min() { return 0; } //!< \returns a value of long long holding the smallest positive subnormal
};
// Overload for the builtin signed char type
///
/// \brief Definition for type \emph{unsigned long long}.
template<> struct numeric_limits<unsigned long long>
{
static constexpr bool is_specialized = true;
static constexpr bool is_signed = false;
static constexpr bool is_integer = true;
static constexpr bool is_exact = true;
static constexpr bool has_infinity = false;
static constexpr bool has_quiet_nan = false;
static constexpr bool has_signaling_nan = false;
static constexpr bool has_denorm = false;
static constexpr bool has_denorm_loss = false;
static constexpr bool is_iec559 = false;
static constexpr bool is_bounded = true;
static constexpr bool is_modulo = true;
static constexpr bool tinyness_before = false;
static constexpr bool traps = true;
static constexpr bool is_specialized = true; //!< Check if the template is specialized for unsigned long long
static constexpr bool is_signed = false; //!< Check if unsigned long long is signed
static constexpr bool is_integer = true; //!< Check if unsigned long long is of an integral type
static constexpr bool is_exact = true; //!< Check if unsigned long long is exact in its precision
static constexpr bool has_infinity = false; //!< Check if unsigned long long can hold a value representing infinity
static constexpr bool has_quiet_nan = false; //!< Check if unsigned long long can hold a non-signaling nan
static constexpr bool has_signaling_nan = false; //!< Check if unsigned long long can hold a signaling nan
static constexpr bool has_denorm = false; //!< Check if unsigned long long denormalizes
static constexpr bool has_denorm_loss = false; //!< Check if unsigned long long has precision loss when denormalized
static constexpr bool is_iec559 = false; //!< Check if unsigned long long represents an IEC 559 or IEEE 754
static constexpr bool is_bounded = true; //!< Check if unsigned long long represents a finite set of values
static constexpr bool is_modulo = true; //!< Check if unsigned long long can handle modulo arithmetic
static constexpr bool tinyness_before = false; //!< Check if unsigned long long checks for tinyness before rounding
static constexpr bool traps = true; //!< Check if unsigned long long can cause operations to trap
static constexpr int digits = ULLONG_RADIX_DIG;
static constexpr int digits10 = ULLONG_DIG;
static constexpr int max_digits10 = ULLONG_DECIMAL_DIG;
static constexpr int radix = ULLONG_RADIX;
static constexpr int min_exponent = 0;
static constexpr int min_exponent10 = 0;
static constexpr int max_exponent = 0;
static constexpr int max_exponent10 = 0;
static constexpr int digits = ULLONG_RADIX_DIG; //!< Get the base representation of the type
static constexpr int digits10 = ULLONG_DIG; //!< Get the number of radix digits unsigned long long represents
static constexpr int max_digits10 = ULLONG_DECIMAL_DIG; //!< Get the number of decimal digits unsigned long long represents
static constexpr int radix = ULLONG_RADIX; //!< Get the maximum number of decimal digits unsigned long long represents
static constexpr int min_exponent = 0; //!< Get the minimum number of radix digits that represent the exponent of unsigned long long
static constexpr int min_exponent10 = 0; //!< Get the minimum number of decimal digits that represent the exponent of unsigned long long
static constexpr int max_exponent = 0; //!< Get the maximum number of radix digits that represent the exponent of unsigned long long
static constexpr int max_exponent10 = 0; //!< Get the maximum number of decimal digits that represent the exponent of unsigned long long
static constexpr unsigned long long min() { return ULLONG_MIN; }
static constexpr unsigned long long max() { return ULLONG_MAX; }
static constexpr unsigned long long lowest() { return 1; }
static constexpr unsigned long long epsilon() { return 1; }
static constexpr unsigned long long round_error() { return 0; }
static constexpr unsigned long long infinity() { return 0; }
static constexpr unsigned long long quiet_NaN() { return 0; }
static constexpr unsigned long long signaling_NaN() { return 0; }
static constexpr unsigned long long denorm_min() { return 0; }
static constexpr unsigned long long min() { return ULLONG_MIN; } //!< \returns the minimum finite value of unsigned long long
static constexpr unsigned long long max() { return ULLONG_MAX; } //!< \returns the maximum finite value of unsigned long long
static constexpr unsigned long long lowest() { return 1; } //!< \returns the smallest positive value of unsigned long long
static constexpr unsigned long long epsilon() { return 1; } //!< \returns the difference between 1.0 and the next representable value
static constexpr unsigned long long round_error() { return 0; } //!< \returns the max rounding error of unsigned long long
static constexpr unsigned long long infinity() { return 0; } //!< \returns a value of unsigned long long holding a positive infinity
static constexpr unsigned long long quiet_NaN() { return 0; } //!< \returns a value of unsigned long long holding a quiet NaN
static constexpr unsigned long long signaling_NaN() { return 0; } //!< \returns a value of unsigned long long holding a signaling NaN
static constexpr unsigned long long denorm_min() { return 0; } //!< \returns a value of unsigned long long holding the smallest positive subnormal
};
}

6
include/fennec/lang/metasequences.h
View File

@@ -80,7 +80,7 @@ namespace fennec
///
/// \brief metaprogramming sequence
///
/// \details Stores a sequence of values of type \f$ValueT\f$ as a template pack.
/// \details Stores a sequence of values of type \emph{ValueT} as a template pack.
/// You can access the parameter pack in another template function, i.e.
/// \code{cpp}
/// template<typename TypeT, TypeT...Values>
@@ -138,7 +138,7 @@ struct integer_metasequence : metasequence<IntT, Values...>
///
/// \brief generate a fennec::integer_metasequence \f$\left[\,0\,\ldots\,N\,\right)\f$
/// \brief generate a fennec::integer_metasequence \math{\left[\,0\,\ldots\,N\,\right)}
///
/// \details
/// \tparam IntT type of the values, must satisfy `fennec::is_integral<T>`
@@ -177,7 +177,7 @@ template<size_t...Indices> struct index_metasequence : integer_metasequence<size
///
/// \brief generate a fennec::index_metasequence \f$\left[\,0\,\ldots\,N\,\right)\f$
/// \brief generate a fennec::index_metasequence \math{\left[\,0\,\ldots\,N\,\right)}
///
/// \details
/// \tparam T type of the values, must satisfy `fennec::is_integral<T>`

136
include/fennec/lang/ranges.h
View File

@@ -32,12 +32,13 @@
#define FENNEC_LANG_RANGES_H
#include <fennec/lang/types.h>
#include <fennec/lang/type_traits.h>
namespace fennec
{
///
/// \brief C++ Iterator Specification \f$begin()\f$
/// \brief C++ Iterator Specification \emph{begin()}
/// \tparam ContainerT the container type
/// \param c the container to iterate on
/// \returns an iterator at the start of the container
@@ -47,7 +48,7 @@ inline constexpr auto begin(ContainerT& c) noexcept(noexcept(c.begin())) -> decl
}
///
/// \brief C++ Iterator Specification \f$begin()\f$
/// \brief C++ Iterator Specification \emph{begin()}
/// \tparam ContainerT the container type
/// \param c the container to iterate on
/// \returns an iterator at the start of the container
@@ -57,7 +58,7 @@ inline constexpr auto begin(const ContainerT& c) noexcept(noexcept(c.begin())) -
}
///
/// \brief C++ Iterator Specification \f$begin()\f$
/// \brief C++ Iterator Specification \emph{begin()}
/// \tparam T the element type
/// \tparam N the bounds of the array
/// \param arr a bounded array to iterate on
@@ -69,7 +70,7 @@ inline constexpr T* begin(T (&arr)[N]) noexcept {
///
/// \brief C++ Iterator Specification \f$end()\f$
/// \brief C++ Iterator Specification \emph{end()}
/// \tparam ContainerT the container type
/// \param c the container to iterate on
/// \returns an iterator at the end of the container
@@ -79,7 +80,7 @@ inline constexpr auto end(ContainerT& c) noexcept(noexcept(c.end())) -> decltype
}
///
/// \brief C++ Iterator Specification \f$end()\f$
/// \brief C++ Iterator Specification \emph{end()}
/// \tparam ContainerT the container type
/// \param c the container to iterate on
/// \returns an iterator at the end of the container
@@ -89,7 +90,7 @@ inline constexpr auto end(const ContainerT& c) noexcept(noexcept(c.end())) -> de
}
///
/// \brief C++ Iterator Specification \f$end()\f$
/// \brief C++ Iterator Specification \emph{end()}
/// \tparam T the element type
/// \tparam N the bounds of the array
/// \param arr a bounded array to iterate on
@@ -99,6 +100,129 @@ inline constexpr T* end(T (&arr)[N]) noexcept {
return arr + N;
}
///
/// \brief Range for array types.
/// \tparam TypeT The base type.
///
/// \note Operates on the range \emph{[first, last)}.
template<typename TypeT>
struct range {
TypeT* first; //!< The first element
TypeT* last; //!< The last element
///
/// \brief C++ Iterator Specification \emph{begin()}
/// \returns A pointer to the start of the array
TypeT* begin() const {
return first;
}
///
/// \brief C++ Iterator Specification \emph{end()}
/// \returns A pointer to the start of the array
TypeT* end() const {
return last;
}
};
///
/// \brief Range for iterators.
/// \tparam IteratorT The iterator type.
///
/// \note Operates on the range \emph{[first, last)}.
template<typename IteratorT> requires(is_iterable_v<IteratorT>)
struct range<IteratorT> {
IteratorT first; //!< The first element
IteratorT last; //!< The last element
///
/// \brief C++ Iterator Specification \emph{begin()}
/// \returns A pointer to the start of the array
IteratorT& begin() const {
return first;
}
///
/// \brief C++ Iterator Specification \emph{end()}
/// \returns A pointer to the start of the array
IteratorT& end() const {
return last;
}
};
///
/// \brief Proxy Struct for fulfilling the C++ 11 Iterator Specification
template<typename ScalarT>
struct counter {
ScalarT val; //!< The held value
///
/// \brief Pre-Increment
/// \returns A reference to \emph{this} after incrementing \emph{val}.
counter& operator++() {
++val;
return *this;
}
///
/// \brief Post-Increment
/// \returns A counter with the previously held value.
counter operator++(int) {
++val;
return { val - 1 };
}
///
/// \brief Equality Operator
/// \param ctr The counter to compare with
/// \returns \math{{val}_{this} = {val}_{ctr}}
bool operator==(const counter& ctr) const {
return val == ctr.val;
}
///
/// \brief Equality Operator
/// \param ctr The counter to compare with
/// \returns \math{{val}_{this} \neq {val}_{ctr}}
bool operator!=(const counter& ctr) const {
return val != ctr.val;
}
///
/// \brief Dereference Operator
/// \returns \emph{val}
ScalarT operator*() const {
return val;
}
};
///
/// \brief Range for scalar types.
/// \tparam ScalarT The scalar type.
///
/// \note Operates on the range \emph{[first, last)}.
template<typename ScalarT> requires(is_scalar_v<ScalarT>)
struct range<ScalarT> {
ScalarT first; //!< The starting value
ScalarT last; //!< The last value
///
/// \brief C++ Iterator Specification \emph{begin()}
/// \returns A `fennec::counter` containing \emph{first}
counter<ScalarT> begin() const {
return { first };
}
///
/// \brief C++ Iterator Specification \emph{begin()}
/// \returns A `fennec::counter` containing \emph{last}
counter<ScalarT> end() const {
return { last };
}
};
}
#endif // FENNEC_LANG_RANGES_H

43
include/fennec/core/system.h → include/fennec/lang/system.h
View File

@@ -1,6 +1,6 @@
// =====================================================================================================================
// fennec, a free and open source game engine
// Copyright © 2025 - 2026 Medusa Slockbower
// Copyright © 2025 Medusa Slockbower
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
@@ -16,32 +16,29 @@
// along with this program. If not, see <https://www.gnu.org/licenses/>.
// =====================================================================================================================
#ifndef FENNEC_CORE_SYSTEM_H
#define FENNEC_CORE_SYSTEM_H
#include <fennec/string/string.h>
///
/// \file system.h
/// \brief
///
///
/// \details
/// \author Medusa Slockbower
///
/// \copyright Copyright © 2025 - 2026 Medusa Slockbower ([GPLv3](https://www.gnu.org/licenses/gpl-3.0.en.html))
///
///
#ifndef FENNEC_LANG_SYSTEM_H
#define FENNEC_LANG_SYSTEM_H
#include <fennec/lang/detail/_stdlib.h>
namespace fennec
{
class system {
public:
using tick_f = void (*)(system*, double);
using frame_f = void (*)(system*, size_t);
const string name;
const tick_f tick;
const frame_f frame;
system(const cstring& name, tick_f tick, frame_f frame)
: name(name), tick(tick), frame(frame) {
}
virtual ~system() = default;
virtual void init() = 0;
virtual void shutdown() = 0;
};
using ::system;
}
#endif // FENNEC_CORE_SYSTEM_H
#endif // FENNEC_LANG_SYSTEM_H

6
include/fennec/lang/type_sequences.h
View File

@@ -102,7 +102,7 @@ template<size_t n, typename...TypesT> using nth_element_t = nth_element<n, Types
// fennec::replace_first_element =======================================================================================
///
/// \brief Take a Template with a Pack `ClassT<ArgsT...>` and replace the first \f$ArgT\f$ of `ArgsT...` with \f$SubT\f$
/// \brief Take a Template with a Pack `ClassT<ArgsT...>` and replace the first \emph{ArgT} of \emph{ArgsT...} with \emph{SubT}
template<typename ClassT, typename SubT> struct replace_first_element { };
#ifndef FENNEC_DOXYGEN
@@ -134,7 +134,7 @@ template<typename...Ts> constexpr size_t max_element_size_v = max_element_size<T
// fennec::find_element ================================================================================================
///
/// \brief Finds the index of \f$T\f$ in \f$Ts\f$, if \f$T\f$ is not found, results in `sizeof...(Ts)`
/// \brief Finds the index of \emph{T} in \emph{Ts}, if \emph{T} is not found, results in `sizeof...(Ts)`
/// \tparam T The type to find
/// \tparam Ts The type sequence to check
template<typename T, typename...Ts> struct find_element : detail::_find_element<0, T, Ts...> {};
@@ -180,7 +180,7 @@ struct search_element_args<SearchT, type_sequence<ArgsT...>, TypesT...>
// fennec::contains_element ============================================================================================
///
/// \brief Checks if the type sequence `Ts...` contains \f$T\f$
/// \brief Checks if the type sequence \emph{Ts...} contains \emph{T}
/// \tparam T The type to find
/// \tparam Ts The type sequence to check
template<typename T, typename...Ts> struct contains_element : bool_constant<(is_same_v<T, Ts> or ...)> {};

240
include/fennec/lang/type_traits.h
View File

@@ -436,7 +436,7 @@ namespace fennec
///
/// \brief metaprogramming helper for determining if a function is consteval
/// \returns \f$true\f$ if under `consteval`, \f$false\f$ otherwise
/// \returns \emph{true} if under `consteval`, \emph{false} otherwise
constexpr inline bool is_constant_evaluated() noexcept {
if consteval {
return true;
@@ -461,7 +461,7 @@ template<typename T> struct is_void
: detail::_is_void<remove_cvref_t<T>>{};
///
/// \brief Shorthand for ```is_void<T>::value```
/// \brief Shorthand for `(.*?)`
/// \tparam T type to check
template<typename T> constexpr bool_t is_void_v = is_void<T>::value;
@@ -478,7 +478,7 @@ template<typename T> struct is_null_pointer
: detail::_is_null_pointer<remove_cvref_t<T>>{};
///
/// \brief Shorthand for ```is_null_pointer<T>::value```
/// \brief Shorthand for `(.*?)`
/// \tparam T type to check
template<typename T> constexpr bool_t is_null_pointer_v = is_null_pointer<T>::value;
@@ -495,7 +495,7 @@ template<typename T> struct is_bool
: detail::_is_bool<remove_cvref_t<T>>{};
///
/// \brief Shorthand for ```is_bool<T>::value```
/// \brief Shorthand for `(.*?)`
/// \tparam T type to check
template<typename T> constexpr bool_t is_bool_v = is_bool<T>::value;
@@ -512,7 +512,7 @@ template<typename T> struct is_integral
: detail::_is_integral<remove_cvref_t<T>> {};
///
/// \brief Shorthand for ```is_integral<T>::value```
/// \brief Shorthand for `(.*?)`
/// \tparam T type to check
template<typename T> constexpr bool_t is_integral_v = is_integral<T>::value;
@@ -529,7 +529,7 @@ template<typename T> struct is_floating_point
: detail::_is_floating_point<remove_cvref_t<T>>{};
///
/// \brief Shorthand for ```is_floating_point<T>::value```
/// \brief Shorthand for `(.*?)`
/// \tparam T type to check
template<typename T> constexpr bool_t is_floating_point_v = is_floating_point<T> {};
@@ -564,7 +564,7 @@ template<typename T> struct is_array<T[]>
#endif
///
/// \brief Shorthand for ```is_array<T>::value```
/// \brief Shorthand for `(.*?)`
/// \tparam T type to check
template<typename T> constexpr bool_t is_array_v = is_array<T>::value;
@@ -641,7 +641,7 @@ template<typename T> struct is_pointer
: detail::_is_pointer<remove_cvref_t<T>>{};
///
/// \brief Shorthand for ```is_pointer<T>::value```
/// \brief Shorthand for `(.*?)`
/// \tparam T type to check
template<typename T> constexpr bool_t is_pointer_v = is_pointer<T> {};
@@ -652,13 +652,13 @@ template<typename T> constexpr bool_t is_pointer_v = is_pointer<T> {};
///
/// \brief Check if \p T is of a floating point type
///
/// \details Checks if type \f$T\f$ is a floating point type and store it in `is_same::value`.
/// \details Checks if type \emph{T} is a floating point type and store it in `is_same::value`.
/// \tparam T type to check
template<typename T> struct is_lvalue_reference
: detail::_is_lvalue_reference<T>{};
///
/// \brief Shorthand for ```is_floating_point<T>::value```
/// \brief Shorthand for `(.*?)`
/// \tparam T type to check
template<typename T> constexpr bool_t is_lvalue_reference_v = is_lvalue_reference<T> {};
@@ -669,13 +669,13 @@ template<typename T> constexpr bool_t is_lvalue_reference_v = is_lvalue_referenc
///
/// \brief Check if \p T is of a floating point type
///
/// \details Checks if type \f$T\f$ is a floating point type and store it in `is_same::value`.
/// \details Checks if type \emph{T} is a floating point type and store it in `is_same::value`.
/// \tparam T type to check
template<typename T> struct is_rvalue_reference
: detail::_is_rvalue_reference<T>{};
///
/// \brief Shorthand for ```is_floating_point<T>::value```
/// \brief Shorthand for `(.*?)`
/// \tparam T type to check
template<typename T> constexpr bool_t is_rvalue_reference_v = is_rvalue_reference<T> {};
@@ -686,13 +686,13 @@ template<typename T> constexpr bool_t is_rvalue_reference_v = is_rvalue_referenc
///
/// \brief Check if \p T is a pointer to a member function
///
/// \details Checks if type \f$T\f$ is pointer to a member function and store it in `is_member_function_pointer::value`.
/// \details Checks if type \emph{T} is pointer to a member function and store it in `is_member_function_pointer::value`.
/// \tparam T type to check
template<typename T> struct is_member_function_pointer
: bool_constant<FENNEC_BUILTIN_IS_MEMBER_FUNCTION_POINTER(T)> {};
///
/// \brief Shorthand for ```is_member_function_pointer<T>::value```
/// \brief Shorthand for `(.*?)`
/// \tparam T type to check
template<typename T> constexpr bool_t is_member_function_pointer_v = is_member_function_pointer<T> {};
@@ -703,13 +703,13 @@ template<typename T> constexpr bool_t is_member_function_pointer_v = is_member_f
///
/// \brief Check if \p T is a pointer to a member object
///
/// \details Checks if type \f$T\f$ is pointer to a member object and store it in `is_member_object_pointer::value`.
/// \details Checks if type \emph{T} is pointer to a member object and store it in `is_member_object_pointer::value`.
/// \tparam T type to check
template<typename T> struct is_member_object_pointer
: bool_constant<FENNEC_BUILTIN_IS_MEMBER_OBJECT_POINTER(T)> {};
///
/// \brief Shorthand for ```is_member_object_pointer<T>::value```
/// \brief Shorthand for `(.*?)`
/// \tparam T type to check
template<typename T> constexpr bool_t is_member_object_pointer_v = is_member_object_pointer<T> {};
@@ -725,13 +725,13 @@ template<typename T> constexpr bool_t is_member_object_pointer_v = is_member_obj
///
/// \brief Check if \p T is an arithmetic type
///
/// \details Checks if type \f$T\f$ is a built-in type with arithmetic operators and store it in `is_same::value`.
/// \details Checks if type \emph{T} is a built-in type with arithmetic operators and store it in `is_same::value`.
/// \tparam T type to check
template<typename T> struct is_arithmetic
: bool_constant<is_integral_v<T> or is_floating_point_v<T>>{};
///
/// \brief Shorthand for ```is_arithmetic<T>::value```
/// \brief Shorthand for `(.*?)`
/// \tparam T type to check
template<typename T> constexpr bool_t is_arithmetic_v = is_arithmetic<T>::value;
@@ -745,7 +745,7 @@ template<typename T> struct is_fundamental
: bool_constant<is_arithmetic_v<T> or is_void_v<T> or is_null_pointer_v<T>>{};
///
/// \brief Shorthand for ```is_fundamental<T>::value```
/// \brief Shorthand for `(.*?)`
/// \tparam T type to check
template<typename T> constexpr bool_t is_fundamental_v = is_fundamental<T>::value;
@@ -756,13 +756,13 @@ template<typename T> constexpr bool_t is_fundamental_v = is_fundamental<T>::valu
///
/// \brief Check if \p T is an arithmetic type
///
/// \details Checks if type \f$T\f$ is a built-in type with arithmetic operators and store it in `is_scalar::value`.
/// \details Checks if type \emph{T} is a built-in type with arithmetic operators and store it in `is_scalar::value`.
/// \tparam T type to check
template<typename T> struct is_scalar
: bool_constant<is_arithmetic_v<T> or is_enum_v<T> or is_pointer_v<T>>{};
///
/// \brief Shorthand for ```is_scalar<T>::value```
/// \brief Shorthand for `(.*?)`
/// \tparam T type to check
template<typename T> constexpr bool_t is_scalar_v = is_scalar<T>::value;
@@ -773,12 +773,12 @@ template<typename T> constexpr bool_t is_scalar_v = is_scalar<T>::value;
///
/// \brief Check if \p T is an object
///
/// \details Checks if type \f$T\f$ is an object and store it in `is_object::value`.
/// \details Checks if type \emph{T} is an object and store it in `is_object::value`.
/// \tparam T type to check
template<typename T> struct is_object : bool_constant<FENNEC_BUILTIN_IS_OBJECT(T)> {};
///
/// \brief Shorthand for ```is_object<T>::value```
/// \brief Shorthand for `(.*?)`
/// \tparam T type to check
template<typename T> constexpr bool_t is_object_v = is_object<T>::value;
@@ -789,12 +789,12 @@ template<typename T> constexpr bool_t is_object_v = is_object<T>::value;
///
/// \brief Check if \p T is a object compound type
///
/// \details Checks if type \f$T\f$ is an object and store it in `is_compound::value`.
/// \details Checks if type \emph{T} is an object and store it in `is_compound::value`.
/// \tparam T type to check
template<typename T> struct is_compound : bool_constant<not is_fundamental_v<T>> {};
///
/// \brief Shorthand for ```is_compound<T>::value```
/// \brief Shorthand for `(.*?)`
/// \tparam T type to check
template<typename T> constexpr bool_t is_compound_v = is_compound<T>::value;
@@ -805,13 +805,13 @@ template<typename T> constexpr bool_t is_compound_v = is_compound<T>::value;
///
/// \brief Check if \p T is of a reference type
///
/// \details Checks if type \f$T\f$ is a reference type and store it in `is_reference::value`.
/// \details Checks if type \emph{T} is a reference type and store it in `is_reference::value`.
/// \tparam T type to check
template<typename T> struct is_reference
: detail::_is_reference<T>{};
///
/// \brief Shorthand for ```is_reference<T>::value```
/// \brief Shorthand for `(.*?)`
/// \tparam T type to check
template<typename T> constexpr bool_t is_reference_v = is_reference<T> {};
@@ -822,13 +822,13 @@ template<typename T> constexpr bool_t is_reference_v = is_reference<T> {};
///
/// \brief Check if \p T is a pointer to a member
///
/// \details Checks if type \f$T\f$ is pointer to a member and store it in `is_member_function_pointer::value`.
/// \details Checks if type \emph{T} is pointer to a member and store it in `is_member_function_pointer::value`.
/// \tparam T type to check
template<typename T> struct is_member_pointer
: bool_constant<FENNEC_BUILTIN_IS_MEMBER_POINTER(T)> {};
///
/// \brief Shorthand for ```is_member_function_pointer<T>::value```
/// \brief Shorthand for `(.*?)`
/// \tparam T type to check
template<typename T> constexpr bool_t is_member_pointer_v = is_member_pointer<T> {};
@@ -844,13 +844,13 @@ template<typename T> constexpr bool_t is_member_pointer_v = is_member_pointer<T>
///
/// \brief Check if \p T is of a const type
///
/// \details Checks if type \f$T\f$ is a const type and store it in `is_same::value`.
/// \details Checks if type \emph{T} is a const type and store it in `is_same::value`.
/// \tparam T type to check
template<typename T> struct is_const
: detail::_is_const<T>{};
///
/// \brief Shorthand for ```is_const<T>::value```
/// \brief Shorthand for `(.*?)`
/// \tparam T type to check
template<typename T> constexpr bool_t is_const_v = is_const<T> {};
@@ -861,13 +861,13 @@ template<typename T> constexpr bool_t is_const_v = is_const<T> {};
///
/// \brief Check if \p T is of a volatile type
///
/// \details Checks if type \f$T\f$ is a volatile type and store it in `is_same::value`.
/// \details Checks if type \emph{T} is a volatile type and store it in `is_same::value`.
/// \tparam T type to check
template<typename T> struct is_volatile
: detail::_is_volatile<T>{};
///
/// \brief Shorthand for ```is_volatile<T>::value```
/// \brief Shorthand for `(.*?)`
/// \tparam T type to check
template<typename T> constexpr bool_t is_volatile_v = is_volatile<T> {};
@@ -876,9 +876,9 @@ template<typename T> constexpr bool_t is_volatile_v = is_volatile<T> {};
// fennec::is_trivial --------------------------------------------------------------------------------------------------
///
/// \brief Check if type \f$T\f$ is trivial
/// \brief Check if type \emph{T} is trivial
///
/// \details Checks if \f$T\f$
/// \details Checks if \emph{T}
/// \tparam T type to check
template<typename T> struct is_trivial : bool_constant<FENNEC_BUILTIN_IS_TRIVIAL(T)> {};
@@ -892,9 +892,9 @@ template<typename T> constexpr bool_t is_trivial_v = is_trivial<T>{};
// fennec::is_trivially_copyable ---------------------------------------------------------------------------------------
///
/// \brief Check if type \f$T\f$ is trivially_copyable
/// \brief Check if type \emph{T} is trivially_copyable
///
/// \details Checks if \f$T\f$
/// \details Checks if \emph{T}
/// \tparam T type to check
template<typename T> struct is_trivially_copyable : bool_constant<FENNEC_BUILTIN_IS_TRIVIALLY_COPYABLE(T)> {};
@@ -908,9 +908,9 @@ template<typename T> constexpr bool_t is_trivially_copyable_v = is_trivially_cop
// fennec::is_standard_layout ------------------------------------------------------------------------------------------
///
/// \brief Check if type \f$T\f$ is standard_layout
/// \brief Check if type \emph{T} is standard_layout
///
/// \details Checks if \f$T\f$
/// \details Checks if \emph{T}
/// \tparam T type to check
template<typename T> struct is_standard_layout : bool_constant<FENNEC_BUILTIN_IS_STANDARD_LAYOUT(T)> {};
@@ -924,9 +924,9 @@ template<typename T> constexpr bool_t is_standard_layout_v = is_standard_layout<
// fennec::has_unique_object_representations ---------------------------------------------------------------------------
///
/// \brief Check if type \f$T\f$ has unique object representations
/// \brief Check if type \emph{T} has unique object representations
///
/// \details Checks if \f$T\f$
/// \details Checks if \emph{T}
/// \tparam T type to check
template<typename T> struct has_unique_object_representations
: bool_constant<FENNEC_BUILTIN_HAS_UNIQUE_OBJECT_REPRESENTATIONS(remove_cv_t<T>)> {};
@@ -941,9 +941,9 @@ template<typename T> constexpr bool_t has_unique_object_representations_v = has_
// fennec::is_empty ----------------------------------------------------------------------------------------------------
///
/// \brief Check if type \f$T\f$ is empty
/// \brief Check if type \emph{T} is empty
///
/// \details Checks if \f$T\f$
/// \details Checks if \emph{T}
/// \tparam T type to check
template<typename T> struct is_empty : bool_constant<FENNEC_BUILTIN_IS_EMPTY(T)> {};
@@ -957,9 +957,9 @@ template<typename T> constexpr bool_t is_empty_v = is_empty<T>{};
// fennec::is_polymorphic ----------------------------------------------------------------------------------------------
///
/// \brief Check if type \f$T\f$ is polymorphic
/// \brief Check if type \emph{T} is polymorphic
///
/// \details Checks if \f$T\f$
/// \details Checks if \emph{T}
/// \tparam T type to check
template<typename T> struct is_polymorphic : bool_constant<FENNEC_BUILTIN_IS_POLYMORPHIC(T)> {};
@@ -973,9 +973,9 @@ template<typename T> constexpr bool_t is_polymorphic_v = is_polymorphic<T>{};
// fennec::is_abstract -------------------------------------------------------------------------------------------------
///
/// \brief Check if type \f$T\f$ is abstract
/// \brief Check if type \emph{T} is abstract
///
/// \details Checks if \f$T\f$
/// \details Checks if \emph{T}
/// \tparam T type to check
template<typename T> struct is_abstract : bool_constant<FENNEC_BUILTIN_IS_ABSTRACT(T)> {};
@@ -989,9 +989,9 @@ template<typename T> constexpr bool_t is_abstract_v = is_abstract<T>{};
// fennec::is_complete -------------------------------------------------------------------------------------------------
///
/// \brief Check if type \f$T\f$ is complete
/// \brief Check if type \emph{T} is complete
///
/// \details Checks if \f$T\f$
/// \details Checks if \emph{T}
/// \tparam T type to check
template<typename T> struct is_complete : detail::_is_complete<T>::type {};
@@ -1005,9 +1005,9 @@ template<typename T> constexpr bool_t is_complete_v = is_complete<T>{};
// fennec::is_final -------------------------------------------------------------------------------------------------
///
/// \brief Check if type \f$T\f$ is final
/// \brief Check if type \emph{T} is final
///
/// \details Checks if \f$T\f$
/// \details Checks if \emph{T}
/// \tparam T type to check
template<typename T> struct is_final : bool_constant<FENNEC_BUILTIN_IS_FINAL(T)> {};
@@ -1021,9 +1021,9 @@ template<typename T> constexpr bool_t is_final_v = is_final<T>{};
// fennec::is_aggregate -------------------------------------------------------------------------------------------------
///
/// \brief Check if type \f$T\f$ is aggregate
/// \brief Check if type \emph{T} is aggregate
///
/// \details Checks if \f$T\f$
/// \details Checks if \emph{T}
/// \tparam T type to check
template<typename T> struct is_aggregate : bool_constant<FENNEC_BUILTIN_IS_AGGREGATE(T)> {};
@@ -1040,13 +1040,13 @@ template<typename T> constexpr bool_t is_aggregate_v = is_aggregate<T>{};
///
/// \brief Check if \p T is of a signed integral
///
/// \details Checks if type \f$T\f$ is a signed type i.e. `T(-1) < T(0)` and stores it in `is_same::value`.
/// \details Checks if type \emph{T} is a signed type i.e. \math{\textbf{T(-1)} < \textbf{T(0)}} and stores it in `is_same::value`.
/// \tparam T type to check
template<typename T> struct is_signed
: detail::_is_signed<remove_cvref_t<T>> {};
///
/// \brief Shorthand for ```is_signed<T>::value```
/// \brief Shorthand for `(.*?)`
/// \tparam T type to check
template<typename T> constexpr bool_t is_signed_v = is_signed<T>::value;
@@ -1058,13 +1058,13 @@ template<typename T> constexpr bool_t is_signed_v = is_signed<T>::value;
///
/// \brief Check if \p T is of an unsigned integral
///
/// \details Checks if type \f$T\f$ is an unsigned type i.e. `T(-1) > T(0)` and stores it in `is_same::value`.
/// \details Checks if type \emph{T} is an unsigned type i.e. \math{\textbf{T(-1)} > \textbf{T(0)}} and stores it in `is_same::value`.
/// \tparam T type to check
template<typename T> struct is_unsigned
: detail::_is_unsigned<remove_cvref_t<T>> {};
///
/// \brief Shorthand for ```is_unsigned<T>::value```
/// \brief Shorthand for `(.*?)`
/// \tparam T type to check
template<typename T> constexpr bool_t is_unsigned_v = is_unsigned<T>::value;
@@ -1072,16 +1072,6 @@ template<typename T> struct is_unsigned
// fennec::is_bounded_array --------------------------------------------------------------------------------------------
#if FENNEC_HAS_BUILTIN_BOUNDED_ARRAY
///
/// \brief Check if \p T is of a bounded array type
/// \tparam T type to check
template<typename T> struct is_bounded_array
: bool_constant<FENNEC_BUILTIN_IS_BOUNDED_ARRAY(T)> {};
#else
///
/// \brief Check if \p T is of an bounded type
/// \tparam T type to check
@@ -1092,10 +1082,8 @@ template<typename T> struct is_bounded_array
template<typename T, size_t N> struct is_bounded_array<T[N]>
: true_type {};
#endif
///
/// \brief Shorthand for ```is_bounded_array<T>::value```
/// \brief Shorthand for `(.*?)`
/// \tparam T type to check
template<typename T> constexpr bool_t is_bounded_array_v = is_bounded_array<T>::value;
@@ -1103,16 +1091,6 @@ template<typename T> constexpr bool_t is_bounded_array_v = is_bounded_array<T>::
// fennec::is_unbounded_array ------------------------------------------------------------------------------------------
#if FENNEC_HAS_BUILTIN_UNBOUNDED_ARRAY
///
/// \brief Check if \p T is of a unbounded array type
/// \tparam T type to check
template<typename T> struct is_unbounded_array
: bool_constant<FENNEC_BUILTIN_IS_UNBOUNDED_ARRAY(T)> {};
#else
///
/// \brief Check if \p T is of an unbounded type
/// \tparam T type to check
@@ -1123,10 +1101,8 @@ template<typename T> struct is_unbounded_array
template<typename T> struct is_unbounded_array<T[]>
: true_type {};
#endif
///
/// \brief Shorthand for ```is_unbounded_array<T>::value```
/// \brief Shorthand for `(.*?)`
/// \tparam T type to check
template<typename T> constexpr bool_t is_unbounded_array_v = is_unbounded_array<T>::value;
@@ -1163,7 +1139,7 @@ struct is_scoped_enum<T>
#endif
///
/// \brief Shorthand for ```is_scoped_enum<T>::value```
/// \brief Shorthand for `(.*?)`
/// \tparam T type to check
template<typename T> constexpr bool_t is_scoped_enum_v = is_scoped_enum<T>::value;
@@ -1177,9 +1153,9 @@ template<typename T> constexpr bool_t is_scoped_enum_v = is_scoped_enum<T>::valu
// fennec::is_convertible ----------------------------------------------------------------------------------------------
///
/// \brief Check if type \f$T0\f$ can be converted \f$T1\f$
/// \brief Check if type \emph{T0} can be converted \emph{T1}
///
/// \details Checks if \f$TypeT0\f$
/// \details Checks if \emph{TypeT0}
/// \tparam FromT First type
/// \tparam ToT Second type
template<typename FromT, typename ToT> struct is_convertible
@@ -1196,8 +1172,8 @@ template<typename FromT, typename ToT> constexpr bool_t is_convertible_v = is_co
// fennec::is_constructible --------------------------------------------------------------------------------------------
///
/// \brief Check if \f$ClassT\f$ can be constructed with `ArgsT,` i.e. `ClassT(ArgsT...)`.
/// This may be read as "is \f$ClassT\f$ constructible with \f$ArgsT\f$"
/// \brief Check if \emph{ClassT} can be constructed with \emph{ArgsT...}, i.e. `ClassT(ArgsT...)`.
/// This may be read as "is \emph{ClassT} constructible with \emph{ArgsT}"
/// \tparam ClassT The class type to test
/// \tparam ArgsT The arguments for the specific constructor
template<typename ClassT, typename...ArgsT> struct is_constructible
@@ -1212,7 +1188,7 @@ template<typename ClassT, typename...ArgsT> constexpr bool_t is_constructible_v
// fennec::is_trivially_constructible ----------------------------------------------------------------------------------
///
/// \brief Check if \f$ClassT\f$ is trivially constructible
/// \brief Check if \emph{ClassT} is trivially constructible
/// \tparam ClassT The class type to test
/// \tparam ArgsT The arguments for the specific constructor
template<typename ClassT, typename...ArgsT> struct is_trivially_constructible
@@ -1227,7 +1203,7 @@ template<typename ClassT> constexpr bool_t is_trivially_constructible_v = is_tri
// fennec::is_nothrow_constructible ------------------------------------------------------------------------------------
///
/// \brief Check if \f$ClassT\f$ is nothrow constructible
/// \brief Check if \emph{ClassT} is nothrow constructible
/// \tparam ClassT The class type to test
/// \tparam ArgsT The arguments for the specific constructor
template<typename ClassT, typename...ArgsT> struct is_nothrow_constructible
@@ -1242,7 +1218,7 @@ template<typename ClassT> constexpr bool_t is_nothrow_constructible_v = is_nothr
// fennec::is_default_constructible ------------------------------------------------------------------------------------
///
/// \brief Check if \f$ClassT\f$ is default constructible
/// \brief Check if \emph{ClassT} is default constructible
/// \tparam ClassT The class type to test
template<typename ClassT> struct is_default_constructible
: bool_constant<FENNEC_BUILTIN_IS_CONSTRUCTIBLE(ClassT)> {};
@@ -1256,7 +1232,7 @@ template<typename ClassT> constexpr bool_t is_default_constructible_v = is_defau
// fennec::is_trivially_default_constructible --------------------------------------------------------------------------
///
/// \brief Check if \f$ClassT\f$ is trivially default constructible
/// \brief Check if \emph{ClassT} is trivially default constructible
/// \tparam ClassT The class type to test
template<typename ClassT> struct is_trivially_default_constructible
: bool_constant<FENNEC_BUILTIN_IS_TRIVIALLY_CONSTRUCTIBLE(ClassT)> {};
@@ -1270,7 +1246,7 @@ template<typename ClassT> constexpr bool_t is_trivially_default_constructible_v
// fennec::is_nothrow_default_constructible --------------------------------------------------------------------------
///
/// \brief Check if \f$ClassT\f$ is nothrow default constructible
/// \brief Check if \emph{ClassT} is nothrow default constructible
/// \tparam ClassT The class type to test
template<typename ClassT> struct is_nothrow_default_constructible
: bool_constant<FENNEC_BUILTIN_IS_NOTHROW_CONSTRUCTIBLE(ClassT)> {};
@@ -1284,7 +1260,7 @@ template<typename ClassT> constexpr bool_t is_nothrow_default_constructible_v =
// fennec::is_copy_constructible ---------------------------------------------------------------------------------------
///
/// \brief Check if \f$ClassT\f$ is copy constructible
/// \brief Check if \emph{ClassT} is copy constructible
/// \tparam ClassT The class type to test
template<typename ClassT> struct is_copy_constructible
: bool_constant<FENNEC_BUILTIN_IS_CONSTRUCTIBLE(ClassT, add_lvalue_reference_t<const ClassT>)> {};
@@ -1298,7 +1274,7 @@ template<typename ClassT, typename...ArgsT> constexpr bool_t is_copy_constructib
// fennec::is_trivially_copy_constructible -----------------------------------------------------------------------------
///
/// \brief Check if \f$ClassT\f$ is trivially copy constructible
/// \brief Check if \emph{ClassT} is trivially copy constructible
/// \tparam ClassT The class type to test
template<typename ClassT> struct is_trivially_copy_constructible
: bool_constant<FENNEC_BUILTIN_IS_CONSTRUCTIBLE(ClassT, add_lvalue_reference_t<const ClassT>)> {};
@@ -1312,7 +1288,7 @@ template<typename ClassT> struct is_trivially_copy_constructible
// fennec::is_nothrow_copy_constructible -------------------------------------------------------------------------------
///
/// \brief Check if \f$ClassT\f$ is nothrow copy constructible
/// \brief Check if \emph{ClassT} is nothrow copy constructible
/// \tparam ClassT The class type to test
template<typename ClassT> struct is_nothrow_copy_constructible
: bool_constant<FENNEC_BUILTIN_IS_CONSTRUCTIBLE(ClassT, add_lvalue_reference_t<const ClassT>)> {};
@@ -1326,7 +1302,7 @@ template<typename ClassT, typename...ArgsT> constexpr bool_t is_nothrow_copy_con
// fennec::is_move_constructible ---------------------------------------------------------------------------------------
///
/// \brief Check if \f$ClassT\f$ is move constructible
/// \brief Check if \emph{ClassT} is move constructible
/// \tparam ClassT The class type to test
template<typename ClassT> struct is_move_constructible
: bool_constant<FENNEC_BUILTIN_IS_CONSTRUCTIBLE(ClassT, add_rvalue_reference_t<ClassT>)> {};
@@ -1340,7 +1316,7 @@ template<typename ClassT, typename...ArgsT> constexpr bool_t is_move_constructib
// fennec::is_trivially_move_constructible -----------------------------------------------------------------------------
///
/// \brief Check if \f$ClassT\f$ is trivially move constructible
/// \brief Check if \emph{ClassT} is trivially move constructible
/// \tparam ClassT The class type to test
template<typename ClassT> struct is_trivially_move_constructible
: bool_constant<FENNEC_BUILTIN_IS_CONSTRUCTIBLE(ClassT, add_lvalue_reference_t<const ClassT>)> {};
@@ -1354,7 +1330,7 @@ template<typename ClassT> struct is_trivially_move_constructible
// fennec::is_nothrow_move_constructible -------------------------------------------------------------------------------
///
/// \brief Check if \f$ClassT\f$ is nothrow move constructible
/// \brief Check if \emph{ClassT} is nothrow move constructible
/// \tparam ClassT The class type to test
template<typename ClassT> struct is_nothrow_move_constructible
: bool_constant<FENNEC_BUILTIN_IS_CONSTRUCTIBLE(ClassT, add_lvalue_reference_t<const ClassT>)> {};
@@ -1368,7 +1344,7 @@ template<typename ClassT, typename...ArgsT> constexpr bool_t is_nothrow_move_con
// fennec::is_assignable -----------------------------------------------------------------------------------------------
///
/// \brief Check if \f$ClassT\f$ is assignable
/// \brief Check if \emph{ClassT} is assignable
/// \tparam ClassAT The class type to test
/// \tparam ClassBT The arguments for the specific constructor
template<typename ClassAT, typename ClassBT> struct is_assignable
@@ -1383,7 +1359,7 @@ template<typename ClassAT, typename ClassBT> constexpr bool_t is_assignable_v =
// fennec::is_trivially_assignable -------------------------------------------------------------------------------------
///
/// \brief Check if \f$ClassT\f$ is trivially assignable
/// \brief Check if \emph{ClassT} is trivially assignable
/// \tparam ClassAT The class type to test
/// \tparam ClassBT The arguments for the specific constructor
template<typename ClassAT, typename ClassBT> struct is_trivially_assignable
@@ -1399,7 +1375,7 @@ template<typename ClassAT, typename ClassBT> constexpr bool_t is_trivially_assig
// fennec::is_nothrow_assignable ---------------------------------------------------------------------------------------
///
/// \brief Check if \f$ClassT\f$ is nothrow assignable
/// \brief Check if \emph{ClassT} is nothrow assignable
/// \tparam ClassAT The class type to test
/// \tparam ClassBT The arguments for the specific constructor
template<typename ClassAT, typename ClassBT> struct is_nothrow_assignable
@@ -1414,7 +1390,7 @@ template<typename ClassAT, typename ClassBT> constexpr bool_t is_nothrow_assigna
// fennec::is_copy_assignable ------------------------------------------------------------------------------------------
///
/// \brief Check if \f$ClassT\f$ is copy assignable
/// \brief Check if \emph{ClassT} is copy assignable
/// \tparam ClassT The class type to test
template<typename ClassT> struct is_copy_assignable
: bool_constant<FENNEC_BUILTIN_IS_ASSIGNABLE(add_lvalue_reference_t<ClassT>, add_lvalue_reference_t<const ClassT>)> {};
@@ -1428,7 +1404,7 @@ template<typename ClassT> constexpr bool_t is_copy_assignable_v = is_copy_assign
// fennec::is_trivially_copy_assignable --------------------------------------------------------------------------------
///
/// \brief Check if \f$ClassT\f$ is trivially_copy assignable
/// \brief Check if \emph{ClassT} is trivially_copy assignable
/// \tparam ClassT The class type to test
template<typename ClassT> struct is_trivially_copy_assignable
: bool_constant<FENNEC_BUILTIN_IS_TRIVIALLY_ASSIGNABLE(add_lvalue_reference_t<ClassT>, add_lvalue_reference_t<const ClassT>)> {};
@@ -1442,7 +1418,7 @@ template<typename ClassT> constexpr bool_t is_trivially_copy_assignable_v = is_t
// fennec::is_nothrow_copy_assignable ----------------------------------------------------------------------------------
///
/// \brief Check if \f$ClassT\f$ is nothrow_copy assignable
/// \brief Check if \emph{ClassT} is nothrow_copy assignable
/// \tparam ClassT The class type to test
template<typename ClassT> struct is_nothrow_copy_assignable
: bool_constant<FENNEC_BUILTIN_IS_NOTHROW_ASSIGNABLE(add_lvalue_reference_t<ClassT>, add_lvalue_reference_t<const ClassT>)> {};
@@ -1456,7 +1432,7 @@ template<typename ClassT> constexpr bool_t is_nothrow_copy_assignable_v = is_not
// fennec::is_move_assignable ------------------------------------------------------------------------------------------
///
/// \brief Check if \f$ClassT\f$ is move assignable
/// \brief Check if \emph{ClassT} is move assignable
/// \tparam ClassT The class type to test
template<typename ClassT> struct is_move_assignable
: bool_constant<FENNEC_BUILTIN_IS_ASSIGNABLE(add_lvalue_reference_t<ClassT>, add_rvalue_reference_t<ClassT>)> {};
@@ -1470,7 +1446,7 @@ template<typename ClassT> constexpr bool_t is_move_assignable_v = is_move_assign
// fennec::is_trivially_move_assignable --------------------------------------------------------------------------------
///
/// \brief Check if \f$ClassT\f$ is trivially_move assignable
/// \brief Check if \emph{ClassT} is trivially_move assignable
/// \tparam ClassT The class type to test
template<typename ClassT> struct is_trivially_move_assignable
: bool_constant<FENNEC_BUILTIN_IS_TRIVIALLY_ASSIGNABLE(add_lvalue_reference_t<ClassT>, add_rvalue_reference_t<ClassT>)> {};
@@ -1484,7 +1460,7 @@ template<typename ClassT> constexpr bool_t is_trivially_move_assignable_v = is_t
// fennec::is_nothrow_move_assignable --------------------------------------------------------------------------------
///
/// \brief Check if \f$ClassT\f$ is nothrow_move assignable
/// \brief Check if \emph{ClassT} is nothrow_move assignable
/// \tparam ClassT The class type to test
template<typename ClassT> struct is_nothrow_move_assignable
: bool_constant<FENNEC_BUILTIN_IS_NOTHROW_ASSIGNABLE(add_lvalue_reference_t<ClassT>, add_rvalue_reference_t<ClassT>)> {};
@@ -1498,7 +1474,7 @@ template<typename ClassT> constexpr bool_t is_nothrow_move_assignable_v = is_not
// fennec::is_destructible ---------------------------------------------------------------------------------------------
///
/// \brief Check if \f$ClassT\f$ is destructible
/// \brief Check if \emph{ClassT} is destructible
/// \tparam ClassT The class type to test
template<typename ClassT> struct is_destructible
: detail::_is_destructible<ClassT>::type {};
@@ -1512,10 +1488,14 @@ template<typename ClassT> constexpr bool_t is_destructible_v = is_destructible<C
// fennec::is_trivially_destructible -----------------------------------------------------------------------------------
///
/// \brief Check if \f$ClassT\f$ is trivially destructible
/// \brief Check if \emph{ClassT} is trivially destructible
/// \tparam ClassT The class type to test
template<typename ClassT> struct is_trivially_destructible
#if FENNEC_HAS_BUILTIN_IS_TRIVIALLY_DESTRUCTIBLE
: bool_constant<FENNEC_BUILTIN_IS_TRIVIALLY_DESTRUCTIBLE(ClassT)> {};
#else
: bool_constant<FENNEC_BUILTIN_HAS_TRIVIAL_DESTRUCTOR(ClassT)> {};
#endif
///
/// \brief Shorthand for `is_trivially_destructible<ClassT, ArgsT...>::value`
@@ -1526,7 +1506,7 @@ template<typename ClassT> constexpr bool_t is_trivially_destructible_v = is_triv
// fennec::is_nothrow_destructible -------------------------------------------------------------------------------------
///
/// \brief Check if \f$ClassT\f$ is nothrow destructible
/// \brief Check if \emph{ClassT} is nothrow destructible
/// \tparam ClassT The class type to test
template<typename ClassT> struct is_nothrow_destructible
: detail::_is_nothrow_destructible<ClassT>::type {};
@@ -1547,7 +1527,7 @@ template<typename ClassT> constexpr bool_t is_nothrow_destructible_v = is_nothro
///
/// \brief Check if the two types are identical
///
/// \details Checks if \f$T0\f$ and \f$T1\f$ are identical and store it in `is_same::value`
/// \details Checks if \emph{T0} and \emph{T1} are identical and store it in `is_same::value`
/// \tparam T0 first type to check
/// \tparam T1 second type to check
template<typename T0, typename T1> struct is_same : false_type {};
@@ -1556,7 +1536,7 @@ template<typename T0, typename T1> struct is_same : false_type {};
template<typename T> struct is_same<T, T> : true_type {};
///
/// \brief Shorthand for ```is_same<T0, T1>::value```
/// \brief Shorthand for `(.*?)`
/// \tparam T0 first type to check
/// \tparam T1 second type to check
template<typename T0, typename T1> constexpr bool_t is_same_v = is_same<T0, T1> {};
@@ -1566,9 +1546,9 @@ template<typename T0, typename T1> constexpr bool_t is_same_v = is_same<T0, T1>
// fennec::is_base_of --------------------------------------------------------------------------------------------------
///
/// \brief Check if \f$Derived\f$ has a base type of \f$Base\f$
/// \brief Check if \emph{Derived} has a base type of \emph{Base}
///
/// \details Checks if \f$Base\f$ is a base type of \f$Derived\f$ and stores it in `is_base_of::value`
/// \details Checks if \emph{Base} is a base type of \emph{Derived} and stores it in `is_base_of::value`
/// \tparam Base base type to check
/// \tparam Derived derived type to check
template<typename Base, typename Derived> struct is_base_of : bool_constant<
@@ -1576,7 +1556,7 @@ template<typename Base, typename Derived> struct is_base_of : bool_constant<
> {};
///
/// \brief Shorthand for ```is_base_of<T0, T1>::value```
/// \brief Shorthand for `(.*?)`
/// \tparam Base base type to check
/// \tparam Derived derived type to check
template<typename Base, typename Derived> constexpr bool_t is_base_of_v = is_base_of<Base, Derived> {};
@@ -1586,9 +1566,9 @@ template<typename Base, typename Derived> constexpr bool_t is_base_of_v = is_bas
// fennec::is_iterable -------------------------------------------------------------------------------------------------
///
/// \brief Check if type \f$T\f$ is iterable
/// \brief Check if type \emph{T} is iterable
///
/// \details Checks if \f$T\f$
/// \details Checks if \emph{Base} is iterable and stores it in `is_base_of::value`
/// \tparam T type to check
template<typename T> struct is_iterable : decltype(detail::_is_iterable<T>(0)) {};
@@ -1599,12 +1579,28 @@ template<typename T> constexpr bool_t is_iterable_v = is_iterable<T>{};
// fennec::is_iterator -------------------------------------------------------------------------------------------------
///
/// \brief Check if type \emph{T} is an iterator
///
/// \details Checks if \emph{T} is an iterator and stores it in `is_base_of::value`
/// \tparam T type to check
template<typename T> struct is_iterator : decltype(detail::_is_iterator<T>(0)) {};
///
/// \brief Shorthand for `is_iterator<TypeT0, TypeT1>::value`
/// \tparam T type to check
template<typename T> constexpr bool_t is_iterator_v = is_iterator<T>{};
// fennec::is_indexable ------------------------------------------------------------------------------------------------
///
/// \brief Check if type \f$T\f$ is indexable
/// \brief Check if type \emph{T} is indexable
///
/// \details Checks if \f$T\f$
/// \details Checks if \emph{T}
/// \tparam T type to check
template<typename T> struct is_indexable : decltype(detail::_is_indexable<T>(0)) {};
@@ -1618,9 +1614,9 @@ template<typename T> constexpr bool_t is_indexable_v = is_indexable<T>{};
// fennec::is_mappable -------------------------------------------------------------------------------------------------
///
/// \brief Check if type \f$T\f$ is mappable
/// \brief Check if type \emph{T} is mappable
///
/// \details Checks if \f$T\f$
/// \details Checks if \emph{T}
/// \tparam T type to check
template<typename T> struct is_mappable : decltype(detail::_is_mappable<T>(0)) {};

62
include/fennec/lang/type_transforms.h
View File

@@ -194,9 +194,9 @@ template<typename T> using decay_t = typename decay<T>::type;
// Pointer Conversions =================================================================================================
///
/// \brief adds a pointer level to \f$T\f$
/// \brief adds a pointer level to \emph{T}
///
/// \details adds a pointer to the provided type such that \f$T\f$ becomes \f$T*\f$
/// \details adds a pointer to the provided type such that \emph{T} becomes \emph{T*}
/// \tparam T Resultant Type
template<typename T> struct add_pointer : detail::_add_pointer<T>{};
@@ -206,9 +206,9 @@ template<typename T> using add_pointer_t = typename add_pointer<T>::type;
///
/// \brief removes a pointer level from \f$T\f$
/// \brief removes a pointer level from \emph{T}
///
/// \details removes a pointer from the provided type such that \f$T*\f$ becomes \f$T\f$
/// \details removes a pointer from the provided type such that \emph{T*} becomes \emph{T}
/// \tparam T Resultant Type
template<typename T> struct remove_pointer : detail::_remove_pointer<T> {};
@@ -218,9 +218,9 @@ template<typename T> using remove_pointer_t = typename remove_pointer<T>::type;
///
/// \brief removes all pointer levels from \f$T\f$
/// \brief removes all pointer levels from \emph{T}
///
/// \details removes all pointers from the provided type such that \f$T*\f$, \f$T**\f$, etc. becomes \f$T\f$
/// \details removes all pointers from the provided type such that \emph{T*}, \emph{T**}, etc. becomes \emph{T}
/// \tparam T Resultant Type
template<typename T> struct strip_pointers : conditional_t<
detail::_is_pointer<T>::value,
@@ -237,9 +237,9 @@ template<typename T> using strip_pointers_t = strip_pointers<T>::type;
// Reference Conversions ===============================================================================================
///
/// \brief add a reference to \f$T\f$
/// \brief add a reference to \emph{T}
///
/// \details adds a pointer to the provided type such that \f$T\f$ becomes \f$T\&\f$
/// \details adds a pointer to the provided type such that \emph{T} becomes \emph{T\&}
/// \tparam T Resultant Type
template<typename T> struct add_reference : type_identity<T&> {};
@@ -249,9 +249,9 @@ template<typename T> using add_reference_t = typename add_reference<T>::type;
///
/// \brief add a lvalue reference to \f$T\f$
/// \brief add a lvalue reference to \emph{T}
///
/// \details adds a lvalue reference to the provided type such that \f$T\f$ becomes \f$T\&\f$
/// \details adds a lvalue reference to the provided type such that \emph{T} becomes \emph{T\&}
/// \tparam T Reference Type
template<typename T> struct add_lvalue_reference : detail::_add_lvalue_reference<T> {};
@@ -261,9 +261,9 @@ template<typename T> using add_lvalue_reference_t = typename add_lvalue_referen
///
/// \brief add a rvalue reference to \f$T\f$
/// \brief add a rvalue reference to \emph{T}
///
/// \details adds a rvalue reference to the provided type such that \f$T\f$ becomes \f$T\&\&\f$
/// \details adds a rvalue reference to the provided type such that \emph{T} becomes \emph{T\&\&}
/// \tparam T Reference Type
template<typename T> struct add_rvalue_reference : detail::_add_rvalue_reference<T> {};
@@ -273,9 +273,9 @@ template<typename T> using add_rvalue_reference_t = typename add_rvalue_referen
///
/// \brief remove a reference from \f$T\f$
/// \brief remove a reference from \emph{T}
///
/// \details removes references from the provided type such that \f$T\&\f$ and \f$T\&\&\f$ become \f$T\f$
/// \details removes references from the provided type such that \emph{T\&} and \emph{T\&\&} become \emph{T}
/// \tparam T Reference Type
template<typename T> struct remove_reference : type_identity<T> {};
@@ -294,9 +294,9 @@ template<typename T> using remove_reference_t = typename remove_reference<T>::t
// Const & Volatile Conversions ========================================================================================
///
/// \brief add the const qualifier to the provided type \f$T\f$
/// \brief add the const qualifier to the provided type \emph{T}
///
/// \details adds const qualification to the provided type such that \f$T\f$ becomes \f$const\quad T\f$
/// \details adds const qualification to the provided type such that \emph{T} becomes \emph{const\quad T}
/// \tparam T Reference Type
template<typename T> struct add_const : detail::_add_const<T> {};
@@ -306,9 +306,9 @@ template<typename T> using add_const_t = typename add_const<T>::type;
///
/// \brief remove the const qualifier from the provided type \f$T\f$
/// \brief remove the const qualifier from the provided type \emph{T}
///
/// \details removes const qualification from the provided type such that \f$const\quad T\f$ becomes \f$T\f$
/// \details removes const qualification from the provided type such that \emph{const\quad T} becomes \emph{T}
/// \tparam T Reference Type
template<typename T> struct remove_const : detail::_remove_const<T> {};
@@ -319,9 +319,9 @@ template<typename T> using remove_const_t = typename remove_const<T>::type;
///
/// \brief add the volatile qualifier to the provided type \f$T\f$
/// \brief add the volatile qualifier to the provided type \emph{T}
///
/// \details removes references from the provided type such that \f$T\f$ becomes \f$volatile\quad T\f$
/// \details removes references from the provided type such that \emph{T} becomes \emph{volatile\quad T}
/// \tparam T Reference Type
template<typename T> struct add_volatile : detail::_add_volatile<T> {};
@@ -331,9 +331,9 @@ template<typename T> using add_volatile_t = typename add_volatile<T>::type;
///
/// \brief remove the volatile qualifier from the provided type \f$T\f$
/// \brief remove the volatile qualifier from the provided type \emph{T}
///
/// \details removes references from the provided type such that \f$volatile\quad T\f$ becomes \f$T\f$
/// \details removes references from the provided type such that \emph{volatile\quad T} becomes \emph{T}
/// \tparam T Reference Type
template<typename T> struct remove_volatile : detail::_remove_volatile<T> {};
@@ -344,10 +344,10 @@ template<typename T> using remove_volatile_t = typename remove_volatile<T>::type
///
/// \brief remove the volatile qualifier from the provided type \f$T\f$
/// \brief remove the volatile qualifier from the provided type \emph{T}
///
/// \details removes references from the provided type such that \f$T\f$, \f$const\quad T\f$, and \f$volatile\quad T\f$
/// become \f$const volatile T\f$
/// \details removes references from the provided type such that \emph{T}, \emph{const\quad T}, and \emph{volatile\quad T}
/// become \emph{const volatile T}
/// \tparam T Reference Type
template<typename T> struct add_cv : detail::_add_cv<T> {};
@@ -358,10 +358,10 @@ template<typename T> using add_cv_t = typename add_cv<T>::type;
///
/// \brief remove the const and volatile qualifiers from the provided type \f$T\f$
/// \brief remove the const and volatile qualifiers from the provided type \emph{T}
///
/// \details removes const and volatile from the provided type such that \f$const\quad T\f$, \f$volatile\quad T\f$, and
/// \f$const\quad volatile\quad T\f$ become \f$T\f$
/// \details removes const and volatile from the provided type such that \emph{const\quad T}, \emph{volatile\quad T}, and
/// \emph{const\quad volatile\quad T} become \emph{T}
/// \tparam T Reference Type
template<typename T> struct remove_cv : detail::_remove_cv<T> {};
@@ -372,7 +372,7 @@ template<typename T> using remove_cv_t = typename remove_cv<T>::type;
///
/// \brief add a reference and the const volatile qualifiers from the provided type \f$T\f$
/// \brief add a reference and the const volatile qualifiers from the provided type \emph{T}
///
/// \details adds references and const volatile qualifiers to the provided type.
/// \tparam T Reference Type
@@ -385,7 +385,7 @@ template<typename T> using add_cvref_t = typename add_cvref<T>::type;
///
/// \brief removes references as well as the const and volatile qualifiers from the provided type \f$T\f$
/// \brief removes references as well as the const and volatile qualifiers from the provided type \emph{T}
///
/// \details removes const and volatile from the provided type such that
/// \tparam T Reference Type
@@ -399,7 +399,7 @@ template<typename T> using remove_cvref_t = typename remove_cvref<T>::type;
///
/// \brief removes references and pointers as well as the const and volatile qualifiers from the provided type \f$T\f$
/// \brief removes references and pointers as well as the const and volatile qualifiers from the provided type \emph{T}
///
/// \details removes const and volatile from the provided type such that
/// \tparam T Reference Type

4
include/fennec/lang/utility.h
View File

@@ -84,10 +84,10 @@ template<typename T> constexpr T&& forward(remove_reference_t<T>&& x) noexcept {
#endif
/// \brief Copies \f$v\f$ to a new object of `decay_t<T>`
/// \brief Copies \emph{v} to a new object of `decay_t<T>`
/// \tparam T The type
/// \param v The object
/// \returns A stack allocated copy of \f$v\f$ in `decay_t<T>`
/// \returns A stack allocated copy of \emph{v} in `decay_t<T>`
template<typename T> constexpr decay_t<T> decay_copy(T&& v) {
return fennec::forward<T>(v);
}

186
include/fennec/math/common.h
View File

@@ -295,11 +295,11 @@ namespace fennec
// Sign ================================================================================================================
///
/// \brief Returns \f$1\f$ if \f$x > 0\f$, \f$0\f$ if \f$x = 0\f$, or \f$-1\f$ if \f$x<0\f$
/// \brief Returns \math{1} if \math{x > 0}, \math{0} if \math{x = 0}, or \math{-1} if \math{x<0}
///
/// \returns \f$1\f$ if \f$x > 0\f$, \f$0\f$ if \f$x = 0\f$, or \f$-1\f$ if \f$x<0\f$ <br><br>
/// \returns \math{1} if \math{x > 0}, \math{0} if \math{x = 0}, or \math{-1} if \math{x<0} <br><br>
/// \details We can express this as, <br><br>
/// \f$\text{sign}(x) = \text{sgn}(x) = \left\{\begin{array}{lr} -1 & x < 0, \\ 0 & x = 0, \\ 1 & x > 0.\end{array}\right.\f$ <br><br>
/// \math{\text{sign}(x) = \text{sgn}(x) = \left\{\begin{array}{lr} -1 & x < 0, \\ 0 & x = 0, \\ 1 & x > 0.\end{array}\right.} <br><br>
///
/// \param x input value
template<typename genType>
@@ -311,11 +311,11 @@ constexpr genType sign(genType x) {
// Absolute Value ======================================================================================================
///
/// \brief Returns \f$x\f$ if \f$x \ge 0\f$, otherwise it returns \f$-x\f$
/// \brief Returns \math{x} if \math{x \ge 0}, otherwise returns \math{-x}
///
/// \returns \f$x\f$ if \f$x \ge 0\f$, otherwise it returns \f$-x\f$. <br> <br>
/// \returns \math{x} if \math{x \ge 0}, otherwise it returns \math{-x}. <br> <br>
/// \details We can express this as, <br> <br>
/// \f$\text{abs}(x)=\left|x\right|\f$.<br> <br>
/// \math{\text{abs}(x)=\left|x\right|}.<br> <br>
///
/// \param x input value
template<typename genType>
@@ -337,11 +337,11 @@ constexpr genType abs(genType x) {
// Floor ===============================================================================================================
///
/// \brief Returns a value equal to the nearest integer that is less than or equal to \f$x\f$
/// \brief Returns a value equal to the nearest integer that is less than or equal to \math{x}
///
/// \returns a value equal to the nearest integer that is less than or equal to \f$x\f$ <br> <br>
/// \returns a value equal to the nearest integer that is less than or equal to \math{x} <br> <br>
/// \details We can express this as,<br> <br>
/// \f$\text{floor}(x)=\lfloor x\rfloor\f$<br> <br>
/// \math{\text{floor}(x)=\lfloor x\rfloor}<br> <br>
///
/// \param x input value
template<typename genType>
@@ -354,11 +354,11 @@ constexpr genType floor(genType x) {
// Ceil ================================================================================================================
///
/// \brief Returns a value equal to the nearest integer that is greater than or equal to \f$x\f$
/// \brief Returns a value equal to the nearest integer that is greater than or equal to \math{x}
///
/// \returns a value equal to the nearest integer that is greater than or equal to \f$x\f$ <br> <br>
/// \returns a value equal to the nearest integer that is greater than or equal to \math{x} <br> <br>
/// \details We can express this as, <br> <br>
/// \f$\text{ceil}(x)=\lceil{x}\rceil\f$ <br> <br>
/// \math{\text{ceil}(x)=\lceil{x}\rceil} <br> <br>
///
/// \param x input value
template<typename genType>
@@ -371,12 +371,12 @@ constexpr genType ceil(genType x) {
// Round ===============================================================================================================
///
/// \brief Returns a value equal to the nearest integer. In C++, a fractional part of \f$0.5\f$ will always round up.
/// \brief Returns a value equal to the nearest integer. In C++, a fractional part of \math{0.5} will always round up.
///
/// \returns a value equal to the nearest integer.<br> <br>
/// \details In C++, a fractional part of \f$0.5\f$ will always round up.<br> <br>
/// \details In C++, a fractional part of \math{0.5} will always round up.<br> <br>
/// We can express this as, <br> <br>
/// \f$\text{round}(x) = \text{sgn}(x) \cdot \lfloor \left| x \right| + 0.5 \rfloor\f$<br> <br>
/// \math{\text{round}(x) = \text{sgn}(x) \cdot \lfloor \left| x \right| + 0.5 \rfloor}<br> <br>
///
/// \param x input value
template<typename genType> constexpr genType round(genType x) {
@@ -388,11 +388,11 @@ template<typename genType> constexpr genType round(genType x) {
// Trunc ===============================================================================================================
///
/// \brief Returns a value equal to the nearest integer that is less than or equal to \f$x\f$
/// \brief Returns a value equal to the nearest integer that is less than or equal to \math{x}
///
/// \returns a value equal to the nearest integer that is less than or equal to \f$x\f$ <br> <br>
/// \returns a value equal to the nearest integer that is less than or equal to \math{x} <br> <br>
/// \details We can express this as, <br> <br>
/// \f$\text{trunc}(x) = \text{sgn}(x) \cdot \lceil \left| x \right| - 0.5 \rceil\f$<br> <br>
/// \math{\text{trunc}(x) = \text{sgn}(x) \cdot \lceil \left| x \right| - 0.5 \rceil}<br> <br>
///
/// \param x input value
template<typename genType>
@@ -405,13 +405,13 @@ constexpr genType trunc(genType x) {
// Round Even ==========================================================================================================
///
/// \brief Returns a value equal to the nearest integer. In C++, a fractional part of \f$0.5\f$ will always
/// \brief Returns a value equal to the nearest integer. In C++, a fractional part of \math{0.5} will always
/// round to the nearest even integer.
///
/// \returns a value equal to the nearest integer.<br> <br>
/// \details In C++, a fractional part of \f$0.5\f$ will always round to the nearest even integer.<br> <br>
/// \details In C++, a fractional part of \math{0.5} will always round to the nearest even integer.<br> <br>
/// We can express this as,<br> <br>
/// \f$\text{roundEven}() = \begin{cases}\lfloor{x}\rfloor + \text{mod}(\lfloor{x}\rfloor, 2.0) & \text{fract}(x) = 0.5, \\ \text{round}(x) \end{cases}\f$<br> <br>
/// \math{\text{roundEven}() = \begin{cases}\lfloor{x}\rfloor + \text{mod}(\lfloor{x}\rfloor, 2.0) & \text{fract}(x) = 0.5, \\ \text{round}(x) \end{cases}}<br> <br>
///
/// \param x input value
template<typename genType>
@@ -451,11 +451,11 @@ constexpr genType roundEven(genType x) {
// Fract ===============================================================================================================
///
/// \brief Returns \f$x - floor(x)\f$
/// \brief Returns \math{x - floor(x)}
///
/// \returns \f$x - \text{floor}(x)\f$ <br> <br>
/// \returns \math{x - \text{floor}(x)} <br> <br>
/// \details We can express this as, <br> <br>
/// \f$\text{fract}(x)=x-\text{floor}\f$<br> <br>
/// \math{\text{fract}(x)=x-\text{floor}}<br> <br>
///
/// \param x input value
template<typename genType>
@@ -467,11 +467,11 @@ constexpr genType fract(genType x) {
// Mod =================================================================================================================
///
/// \brief Modulus. Returns \f$x-y\cdot floor (x/y)\f$
/// \brief Modulus. Returns \math{x-y\cdot floor (x/y)}
///
/// \returns \f$x-y\cdot\text{floor}(x/y)\f$ <br> <br>
/// \returns \math{x-y\cdot\text{floor}(x/y)} <br> <br>
/// \details We can express this as, <br> <br>
/// \f$\text{fract}(x)=x-\text{floor}(\frac{x}{y})\f$<br> <br>
/// \math{\text{fract}(x)=x-\text{floor}(\frac{x}{y})}<br> <br>
///
/// \param x dividend
/// \param y divisor
@@ -484,11 +484,11 @@ constexpr genType mod(genType x, genType y) {
// ModF ================================================================================================================
///
/// \brief Returns the fractional part of \f$x\f$ and stores the integral part in \f$i\f$.
/// \brief Returns the fractional part of \math{x} and stores the integral part in \math{i}.
///
/// \returns the fractional part of \f$x\f$ and stores the integral part in \f$i\f$. <br> <br>
/// \returns the fractional part of \math{x} and stores the integral part in \math{i}. <br> <br>
/// \details We can express this as, <br> <br>
/// \f$\text{modf}(x) = \text{trunc}(x),\, i := \text{fract}(x)\f$ <br> <br>
/// \math{\text{modf}(x) = \text{trunc}(x),\, i := \text{fract}(x)} <br> <br>
///
/// \param x input value
/// \param i integral out
@@ -501,14 +501,14 @@ constexpr genType modf(genType x, genType& i) {
// Is NaN ==============================================================================================================
///
/// \brief Returns **true** if \f$x\f$ holds a NaN. Returns **false** otherwise.
/// \brief Returns **true** if \math{x} holds a NaN. Returns **false** otherwise.
///
/// \returns **true** if \f$x\f$ holds a NaN. Returns **false** otherwise. <br> <br>
/// \details \f$NaN\f$ is a concept unique to computing. It strictly means, and more specifically,
/// \returns **true** if \math{x} holds a NaN. Returns **false** otherwise. <br> <br>
/// \details \math{NaN} is a concept unique to computing. It strictly means, and more specifically,
/// floating point values can only represent *real* numbers. This is why some functions,
/// like \ref fennec::sqrt "sqrt()", return \f$NaN\f$ when an expression would return
/// a value in a different coordinate space. There are other cases, such as \f$\frac{1}{x}\f$,
/// where \f$x=0\f$ is undefined, and respectively the return value is also \f$NaN\f$. <br> <br>
/// like \ref fennec::sqrt "sqrt()", return \math{NaN} when an expression would return
/// a value in a different coordinate space. There are other cases, such as \math{\frac{1}{x}},
/// where \math{x=0} is undefined, and respectively the return value is also \math{NaN}. <br> <br>
///
/// To learn more, see [IEEE 754](https://en.wikipedia.org/wiki/IEEE_754) <br> <br>
///
@@ -522,10 +522,10 @@ constexpr genBType isnan(genType x) {
// Is Inf ==============================================================================================================
///
/// \brief Returns **true** if \f$x\f$ holds a positive or negative infinity. Returns **false** otherwise. <br> <br>
/// \brief Returns **true** if \math{x} holds a positive or negative infinity. Returns **false** otherwise. <br> <br>
///
/// \returns **true** if \f$x\f$ holds a positive or negative infinity. Returns **false** otherwise.
/// \details \f$\inf\f$, or \f$\infty\f$, is used to express any function that is boundless, endless, or larger
/// \returns **true** if \math{x} holds a positive or negative infinity. Returns **false** otherwise.
/// \details \math{\inf}, or \math{\infty}, is used to express any function that is boundless, endless, or larger
/// than any natural number. This function has applications in Set Theory and Mathematical Analysis. <br> <br>
///
/// \param x input value
@@ -553,13 +553,13 @@ constexpr genIType floatBitsToInt(genType x) {
/// \returns a signed or unsigned integer value representing the encoding of a floating-point value.
/// The float value's bit-level representation is preserved. <br> <br>
/// \details we can express this in set theory, i.e. <br> <br>
/// let \f$B\f$ be a set, such that, \f$B=\left\lbrace{b_{0},...b_{32}}\right\rbrace\f$ and \f$b_{i} \in S\f$ where \f$S=\left\lbrace{0, 1}\right\rbrace\f$<br>
/// let \f$m_B=\frac{b_{0}}{2^1}+\cdots +\frac{b_{i}}{2^{i+1}}+\cdots +\frac{b_{22}}{2^{23}}\begin{cases}1&\end{cases}\f$<br>
/// let \f$p_B=b_{23}\cdot 2^0+\cdots +b_i\cdot 2^{i-23}+\cdots +b_{30}\cdot 2^7-127\f$<br>
/// let \f$s_B=\begin{cases}-1,&b_{31}=1 \\ 1\end{cases}\f$<br> <br>
/// then, \f$x_B=s_B m_B 2^{p_B}\f$<br>
/// and, \f$i_B=-b_{31} 2^{31}+\sum_{i=0}^{30}{a_i 2^i}\f$<br>
/// and, \f$u_B=\sum_{i=0}^{31}{a_i 2^i}\f$<br> <br>
/// let \math{B} be a set, such that, \math{B=\left\lbrace{b_{0},...b_{32}}\right\rbrace} and \math{b_{i} \in S} where \math{S=\left\lbrace{0, 1}\right\rbrace}<br>
/// let \math{m_B=\frac{b_{0}}{2^1}+\cdots +\frac{b_{i}}{2^{i+1}}+\cdots +\frac{b_{22}}{2^{23}}\begin{cases}1&\end{cases}}<br>
/// let \math{p_B=b_{23}\cdot 2^0+\cdots +b_i\cdot 2^{i-23}+\cdots +b_{30}\cdot 2^7-127}<br>
/// let \math{s_B=\begin{cases}-1,&b_{31}=1 \\ 1\end{cases}}<br> <br>
/// then, \math{x_B=s_B m_B 2^{p_B}}<br>
/// and, \math{i_B=-b_{31} 2^{31}+\sum_{i=0}^{30}{a_i 2^i}}<br>
/// and, \math{u_B=\sum_{i=0}^{31}{a_i 2^i}}<br> <br>
///
/// \param x value to convert
template<typename genType, typename genUType = uint_t> requires(is_floating_point_v<genType> and is_integral_v<genUType> and is_unsigned_v<genUType> and sizeof(genType) == sizeof(genUType))
@@ -581,13 +581,13 @@ constexpr genType intBitsToFloat(genIType x) {
///
/// \returns a floating-point value corresponding to a signed or unsigned integer encoding of a floating-point value. <br> <br>
/// \details we can express this in set theory, i.e. <br> <br>
/// let \f$B\f$ be a set, such that, \f$B=\left\lbrace{b_{0},...b_{32}}\right\rbrace\f$ and \f$b_{i} \in S\f$ where \f$S=\left\lbrace{0, 1}\right\rbrace\f$<br>
/// let \f$m_B=\frac{b_{0}}{2^1}+\cdots +\frac{b_{i}}{2^{i+1}}+\cdots +\frac{b_{22}}{2^{23}}\begin{cases}1&\end{cases}\f$<br>
/// let \f$p_B=b_{23}\cdot 2^0+\cdots +b_i\cdot 2^{i-23}+\cdots +b_{30}\cdot 2^7-127\f$<br>
/// let \f$s_B=\begin{cases}-1,&b_{31}=1 \\ 1\end{cases}\f$<br> <br>
/// then, \f$x_B=s_B m_B 2^{p_B}\f$<br>
/// and, \f$i_B=-b_{31} 2^31+\sum_{i=0}^{30}{a_i 2^i}\f$<br>
/// and, \f$u_B=\sum_{i=0}^{31}{a_i 2^i}\f$<br> <br>
/// let \math{B} be a set, such that, \math{B=\left\lbrace{b_{0},...b_{32}}\right\rbrace} and \math{b_{i} \in S} where \math{S=\left\lbrace{0, 1}\right\rbrace}<br>
/// let \math{m_B=\frac{b_{0}}{2^1}+\cdots +\frac{b_{i}}{2^{i+1}}+\cdots +\frac{b_{22}}{2^{23}}\begin{cases}1&\end{cases}}<br>
/// let \math{p_B=b_{23}\cdot 2^0+\cdots +b_i\cdot 2^{i-23}+\cdots +b_{30}\cdot 2^7-127}<br>
/// let \math{s_B=\begin{cases}-1,&b_{31}=1 \\ 1\end{cases}}<br> <br>
/// then, \math{x_B=s_B m_B 2^{p_B}}<br>
/// and, \math{i_B=-b_{31} 2^31+\sum_{i=0}^{30}{a_i 2^i}}<br>
/// and, \math{u_B=\sum_{i=0}^{31}{a_i 2^i}}<br> <br>
///
/// \param x value to convert
template<typename genType = float_t, typename genUType = uint_t> requires(is_floating_point_v<genType> and is_integral_v<genUType> and is_unsigned_v<genUType> and sizeof(genType) == sizeof(genUType))
@@ -600,9 +600,9 @@ constexpr genType uintBitsToFloat(genUType x) {
// fma =================================================================================================================
///
/// \brief Computes and returns \f$a \cdot b + c\f$. <br> <br>
/// \brief Computes and returns \math{a \cdot b + c}. <br> <br>
///
/// \returns \f$a \cdot b + c\f$.
/// \returns \math{a \cdot b + c}.
/// \details In C++, this function will use the [fused multiply-add](https://en.wikipedia.org/wiki/Multiply%E2%80%93accumulate_operation),
/// when the instruction is present on the target architecture. <br> <br>
///
@@ -619,16 +619,16 @@ constexpr genType fma(genType a, genType b, genType c) {
// frexp ===============================================================================================================
///
/// \brief Splits \f$x\f$ into a floating-point significand in the range \f$[0.5,1.0]\f$, and an integral exponent of two,
/// such that \f$x=sig \cdot 2^{exp}\f$.
/// \brief Splits \math{x} into a floating-point significand in the range \math{[0.5,1.0]}, and an integral exponent of two,
/// such that \math{x=sig \cdot 2^{exp}}.
///
/// \returns The significand of the expression.<br> <br>
/// \details The significand is returned by the function and the exponent is returned in the parameter \f$exp\f$.
/// \details The significand is returned by the function and the exponent is returned in the parameter \math{exp}.
/// For a floating-point value of zero, the significand and exponent are both zero. If an implementation
/// supports signed zero, an input value of minus zero should return a significand of minus zero. For a
/// floating-point value that is an infinity or is not a number, the results are undefined. If the input
/// \f$x\f$ is a vector, this operation is performed in a component-wise manner; the value returned by the
/// function and the value written to \f$exp\f$ are vectors with the same number of components as \f$x\f$. <br> <br>
/// \math{x} is a vector, this operation is performed in a component-wise manner; the value returned by the
/// function and the value written to \math{exp} are vectors with the same number of components as \math{x}. <br> <br>
///
/// \param x The floating-point value to split
/// \param exp The variable to store the exponent in
@@ -642,11 +642,11 @@ constexpr genType frexp(genType x, genIType& exp) {
// ldexp ===============================================================================================================
///
/// \brief Builds a floating-point number from \f$x\f$ and the corresponding integral exponent of two in \f$exp\f$
/// \brief Builds a floating-point number from \math{x} and the corresponding integral exponent of two in \math{exp}
///
/// \returns \f${x}\cdot{2^{exp}}\f$
/// \returns \math{{x}\cdot{2^{exp}}}
/// \details Builds a floating-point number from x and the corresponding integral exponent of two in exp,
/// returning: \f${x}\cdot{2^{exp}}\f$. If this product is too large to be represented in the floating-point
/// returning: \math{{x}\cdot{2^{exp}}}. If this product is too large to be represented in the floating-point
/// type, the result is undefined. If exp is greater than +128 (single-precision) or +1024 (double-precision),
/// the value returned is undefined. If exp is less than -126 (single-precision) or -1022 (double-precision),
/// the value returned may be flushed to zero. Additionally, splitting the value into a significand and
@@ -676,14 +676,14 @@ constexpr genType ldexp(genType x, genIType exp) {
// Min =================================================================================================================
///
/// \brief Returns \f$y\f$ if \f$x<y;\f$ otherwise it returns \f$x\f$
/// \brief Returns \math{y} if \math{x<y;} otherwise it returns \math{x}
///
/// \returns \f$y\f$ if \f$x<y\f$, otherwise it returns \f$x\f$<br> <br>
/// \returns \math{y} if \math{x<y}, otherwise it returns \math{x}<br> <br>
/// \details We can express this as,<br> <br>
/// \f$\text{min}(x, y)=\begin{cases}y, & y < x \\ x\end{cases}\f$<br> <br>
/// \math{\text{min}(x, y)=\begin{cases}y, & y < x \\ x\end{cases}}<br> <br>
///
/// \param x input value \f$x\f$
/// \param y input value \f$y\f$
/// \param x input value \math{x}
/// \param y input value \math{y}
template<typename genType>
constexpr genType min(genType x, genType y) {
return (y < x) ? y : x;
@@ -693,11 +693,11 @@ constexpr genType min(genType x, genType y) {
// Max =================================================================================================================
///
/// \brief Returns \f$y\f$ if \f$y<x\f$, otherwise it returns \f$x\f$
/// \brief Returns \math{y} if \math{y<x}, otherwise it returns \math{x}
///
/// \returns \f$y\f$ if \f$y<x\f$, otherwise it returns \f$x\f$<br> <br>
/// \returns \math{y} if \math{y<x}, otherwise it returns \math{x}<br> <br>
/// \details We can express this as,<br> <br>
/// \f$\text{max}(x, y)=\begin{cases}y, & x < y \\ x\end{cases}\f$<br> <br>
/// \math{\text{max}(x, y)=\begin{cases}y, & x < y \\ x\end{cases}}<br> <br>
///
/// \param x first input value
/// \param y second input value
@@ -710,11 +710,11 @@ constexpr genType max(genType x, genType y) {
// Clamp ===============================================================================================================
///
/// \brief Returns \f$min (max (x, minVal), maxVal)\f$
/// \brief Returns \math{min (max (x, minVal), maxVal)}
///
/// \returns \f$\text{min}(\text{max}(x, minVal), maxVal)\f$. Results are undefined if \f$minVal > maxVal\f$<br> <br>
/// \returns \math{\text{min}(\text{max}(x, minVal), maxVal)}. Results are undefined if \math{minVal > maxVal}<br> <br>
/// \details We can express this as, <br> <br>
/// \f$\text{clamp}(x, min, max)=\begin{cases}min, & x < min \\ x \\ max, & x > max\end{cases}\f$<br> <br>
/// \math{\text{clamp}(x, min, max)=\begin{cases}min, & x < min \\ x \\ max, & x > max\end{cases}}<br> <br>
///
/// \param x input value
/// \param minVal minimum value
@@ -738,13 +738,13 @@ constexpr genType clamp(genType x, genType minVal, genType maxVal) {
// Step ================================================================================================================
///
/// \brief Returns \f$0.0\f$ if \f$x<edge\f$, otherwise, it returns \f$1.0\f$
/// \brief Returns \math{0.0} if \math{x<edge}, otherwise, it returns \math{1.0}
///
/// \returns \f$0.0\f$ if \f$x<edge\f$, otherwise, it returns \f$1.0\f$<br> <br>
/// \returns \math{0.0} if \math{x<edge}, otherwise, it returns \math{1.0}<br> <br>
/// \details We can express this as, <br> <br>
/// \f$\text{step}(edge, x)=\begin{cases}0.0 & x < edge \\ 1.0 \end{cases}\f$<br> <br>
/// \math{\text{step}(edge, x)=\begin{cases}0.0 & x < edge \\ 1.0 \end{cases}}<br> <br>
///
/// \param edge The \f$x\f$ coordinate of the discontinuity
/// \param edge The \math{x} coordinate of the discontinuity
/// \param x The coordinate of the sample location
template<typename genType> requires(is_floating_point_v<genType>)
constexpr genType step(genType edge, genType x) {
@@ -755,11 +755,11 @@ constexpr genType step(genType edge, genType x) {
// Smoothstep ==========================================================================================================
///
/// \brief Returns \f$0.0\f$ if \f$x\le edge0\f$ and \f$1.0\f$ if \f$x\ge edge1\f$, and performs smooth Hermite
/// interpolation between \f$0\f$ and \f$1\f$ when \f$edge0<x<edge1\f$.
/// \brief Returns \math{0.0} if \math{x\le edge0} and \math{1.0} if \math{x\ge edge1}, and performs smooth Hermite
/// interpolation between \math{0} and \math{1} when \math{edge0<x<edge1}.
///
/// \returns \f$0.0\f$ if \f$x\le edge0\f$ and \f$1.0\f$ if \f$x\ge edge1\f$, and performs smooth Hermite
/// interpolation between \f$0\f$ and \f$1\f$ when \f$edge0<x<edge1\f$. <br> <br>
/// \returns \math{0.0} if \math{x\le edge0} and \math{1.0} if \math{x\ge edge1}, and performs smooth Hermite
/// interpolation between \math{0} and \math{1} when \math{edge0<x<edge1}. <br> <br>
/// \details This is useful in cases where you would want a threshold function with a smooth transition.<br> <br>
/// This is equivalent to: <br> <br>
/// \code{.glsl}
@@ -767,13 +767,13 @@ constexpr genType step(genType edge, genType x) {
/// t = clamp((x - edge0) / (edge1 - edge0), 0, 1);
/// return t * t * (3 - 2 * t);
/// \endcode<br>
/// Results are undefined if \f$edge0\ge edge1\f$. <br> <br>
/// Results are undefined if \math{edge0\ge edge1}. <br> <br>
/// We can express this as,<br> <br>
/// \f$\text{smoothstep}(e_0, e_1, x)=\begin{cases}0, & {x}\le{e_0} \\ 3{\frac{x-e_0}{e_1-e_0}}^{2} - 2{\frac{x-e_0}{e_1-e_0}}^{3}, & {e_0}\le{x}\le{e_1} \\ 1, & {1}\le{e_x}\end{cases}\f$<br> <br>
/// \math{\text{smoothstep}(e_0, e_1, x)=\begin{cases}0, & {x}\le{e_0} \\ 3{\frac{x-e_0}{e_1-e_0}}^{2} - 2{\frac{x-e_0}{e_1-e_0}}^{3}, & {e_0}\le{x}\le{e_1} \\ 1, & {1}\le{e_x}\end{cases}}<br> <br>
///
/// \param edge0 \f$x\f$ value where the function returns \f$0.0\f$
/// \param edge1 \f$x\f$ value where the function returns \f$1.0\f$
/// \param x \f$x\f$ coordinate input
/// \param edge0 \math{x} value where the function returns \math{0.0}
/// \param edge1 \math{x} value where the function returns \math{1.0}
/// \param x \math{x} coordinate input
template<typename genType> requires(is_floating_point_v<genType>)
constexpr genType smoothstep(genType edge0, genType edge1, genType x) {
genType t = fennec::clamp((x - edge0) / (edge1 - edge0), 0.0f, 1.0f); return t * t * (3 - 2 * t);
@@ -783,13 +783,13 @@ constexpr genType smoothstep(genType edge0, genType edge1, genType x) {
// Mix =================================================================================================================
///
/// \brief Returns the linear blend of \f$x\f$ and \f$y\f$, i.e., \f$x \cdot (1-a) + y \cdot a\f$
/// \brief Returns the linear blend of \math{x} and \math{y}, i.e., \math{x \cdot (1-a) + y \cdot a}
///
/// \returns the linear blend of \f$x\f$ and \f$y\f$, i.e., \f$x \cdot (1-a) + y \cdot a\f$<br> <br>
/// \returns the linear blend of \math{x} and \math{y}, i.e., \math{x \cdot (1-a) + y \cdot a}<br> <br>
/// \details We can express this as,<br> <br>
/// \f$\text{mix}(x, y, a)=x+a \cdot (y - x)\f$<br> <br>
/// \math{\text{mix}(x, y, a)=x+a \cdot (y - x)}<br> <br>
/// The reason for the difference between the mathematical definition and the glsl definition is
/// due to floating-point precision errors. Multiplying \f$x\f$ and \f$y\f$ separately preserves
/// due to floating-point precision errors. Multiplying \math{x} and \math{y} separately preserves
/// their precision before the addition happens.
///
/// \param x First value
@@ -806,14 +806,14 @@ constexpr genType mix(genType x, genType y, genType a) {
///
/// \brief Selects which value to return. For Vectors, when the boolean is a scalar, it selects the vector, otherwise, each component is selected.
///
/// \returns \f$x\f$ when \f$a=T\f$, otherwise returns \f$y\f$
/// \returns \math{x} when \math{a=T}, otherwise returns \math{y}
/// \details Selects which value to return. For Vectors, when the boolean is a scalar,
/// it selects the vector, otherwise, each component is selected. <br> <br>
/// This implementation uses the ternary operator:<br>
/// \code{.cpp}return a ? x : y;\endcode
/// Which will get reduced down to a conditional move instruction over branching.<br> <br>
/// We can express this as,<br> <br>
/// \f$\text{mix}(x, y, A) = \begin{cases} x, & A=T \\ y & A=F \end{cases}\f$<br> <br>
/// \math{\text{mix}(x, y, A) = \begin{cases} x, & A=T \\ y & A=F \end{cases}}<br> <br>
///
/// \param x True Value
/// \param y False Value

27
include/fennec/math/detail/_math.h
View File

@@ -19,10 +19,37 @@
#ifndef FENNEC_MATH_DETAIL_MATH_H
#define FENNEC_MATH_DETAIL_MATH_H
// Handle including C math.h
// Unfortunately, each compiler needs its own if case in the macro chain below
#if FENNEC_COMPILER_CLANG // Clang
// Temporarily disable macro redefinition warning
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wbuiltin-macro-redefined"
// Undefine __cpluscplus macro to force using the C header
#pragma push_macro("__cplusplus")
#undef __cplusplus
// Include math.h
#include <math.h>
// Restore __cpluscplus definition and macro redefinition warning
#pragma pop_macro("__cplusplus")
#pragma clang diagnostic pop
#elif FENNEC_COMPILER_GCC // GCC
// This definition tells GCC to just use the C header, thanks GCC!!!
#ifndef _GLIBCXX_INCLUDE_NEXT_C_HEADERS
#define _GLIBCXX_INCLUDE_NEXT_C_HEADERS
#endif
#include <math.h>
#endif
#undef div
#undef acos

40
include/fennec/math/exponential.h
View File

@@ -97,10 +97,10 @@ namespace fennec
// pow =================================================================================================================
///
/// \brief Returns \f$x\f$ raised to the \f$y\f$ power, i.e., \f$x^y\f$.
/// \brief Returns \math{x} raised to the \math{y} power, i.e., \math{x^y}.
///
/// \returns \f$x\f$ raised to the \f$y\f$ power, i.e., \f$x^y\f$.<br><br>
/// \details Results are undefined if \f$x<0\f$. <br><br>Results are undefined if \f$x=0\f$ and \f${y}\le{0}\f$.<br><br>
/// \returns \math{x} raised to the \math{y} power, i.e., \math{x^y}.<br><br>
/// \details Results are undefined if \math{x<0}. <br><br>Results are undefined if \math{x=0} and \math{{y}\le{0}}.<br><br>
///
/// \param x the base
/// \param y the exponent
@@ -113,9 +113,9 @@ constexpr genType pow(genType x, genType y) {
// exp =================================================================================================================
///
/// \brief Returns the natural exponentiation of \f$x\f$, i.e., \f$e^x\f$
/// \brief Returns the natural exponentiation of \math{x}, i.e., \math{e^x}
///
/// \returns the natural exponentiation of \f$x\f$, i.e., \f$e^x\f$.<br><br>
/// \returns the natural exponentiation of \math{x}, i.e., \math{e^x}.<br><br>
///
/// \param x the exponent
template<typename genType>
@@ -127,9 +127,9 @@ constexpr genType exp(genType x) {
// exp2 ================================================================================================================
///
/// \brief Returns 2 raised to the \f$x\f$ power, i.e., \f$e^x\f$
/// \brief Returns 2 raised to the \math{x} power, i.e., \math{e^x}
///
/// \returns 2 raised to the \f$x\f$ power, i.e., \f$e^x\f$<br><br>
/// \returns 2 raised to the \math{x} power, i.e., \math{e^x}<br><br>
///
/// \param x the exponent
template<typename genType> constexpr genType exp2(genType x) {
@@ -140,10 +140,10 @@ template<typename genType> constexpr genType exp2(genType x) {
// log =================================================================================================================
///
/// \brief Returns the natural logarithm of \f$x\f$.
/// \brief Returns the natural logarithm of \math{x}.
///
/// \returns the natural logarithm of \f$x\f$, i.e., returns the value \f$y\f$ which satisfies the equation \f$x=e^y\f$.<br><br>
/// \details Results are undefined if \f${x}\le{0}\f$.<br><br>
/// \returns the natural logarithm of \math{x}, i.e., returns the value \math{y} which satisfies the equation \math{x=e^y}.<br><br>
/// \details Results are undefined if \math{{x}\le{0}}.<br><br>
///
/// \param x the input value
template<typename genType> constexpr genType log(genType x) {
@@ -154,11 +154,11 @@ template<typename genType> constexpr genType log(genType x) {
// log2 ================================================================================================================
///
/// \brief Returns the base 2 logarithm of \f$x\f$.
/// \brief Returns the base 2 logarithm of \math{x}.
///
/// \returns the base 2 logarithm of \f$x\f$, i.e., returns the value \f$y\f$ which satisfies the equation
/// \f$x=2^y\f$. <br><br>
/// \details Results are undefined if \f${x}\le{0}\f$. <br><br>
/// \returns the base 2 logarithm of \math{x}, i.e., returns the value \math{y} which satisfies the equation
/// \math{x=2^y}. <br><br>
/// \details Results are undefined if \math{{x}\le{0}}. <br><br>
///
/// \param x the input value
template<typename genType> constexpr genType log2(genType x) {
@@ -169,10 +169,10 @@ template<typename genType> constexpr genType log2(genType x) {
// sqrt ================================================================================================================
///
/// \brief Returns \f$\sqrt{x}\f$.
/// \brief Returns \math{\sqrt{x}}.
///
/// \returns \f$\sqrt{x}\f$. <br><br>
/// \details Results are undefined if \f$x<0\f$<br><br>
/// \returns \math{\sqrt{x}}. <br><br>
/// \details Results are undefined if \math{x<0}<br><br>
///
/// \param x the input value
template<typename genType> constexpr genType sqrt(genType x) {
@@ -183,10 +183,10 @@ template<typename genType> constexpr genType sqrt(genType x) {
// inversesqrt =========================================================================================================
///
/// \brief Returns \f$\frac{1}{\sqrt{x}}\f$.
/// \brief Returns \math{\frac{1}{\sqrt{x}}}.
///
/// \returns \f$\frac{1}{\sqrt{x}}\f$.<br><br>
/// \details Results are undefined if \f$x<0\f$.<br><br>
/// \returns \math{\frac{1}{\sqrt{x}}}.<br><br>
/// \details Results are undefined if \math{x<0}.<br><br>
///
/// \param x the input value
template<typename genType> constexpr genType inversesqrt(genType x) {

176
include/fennec/math/ext/constants.h
View File

@@ -546,148 +546,148 @@ namespace fennec
// Rational Constants ==================================================================================================
template<typename genType> constexpr genType zero() { return genType(0); } //!< \returns The value of \f$0\f$
template<typename genType> constexpr genType one() { return genType(1); } //!< \returns The value of \f$1\f$
template<typename genType> constexpr genType one_half() { return genType(0.5); } //!< \returns The value of \f$\frac{1}{2}\f$
template<typename genType> constexpr genType three_over_two() { return genType(1.5); } //!< \returns The value of \f$\frac{3}{2}\f$
template<typename genType> constexpr genType zero() { return genType(0); } //!< \returns The value of \math{0}
template<typename genType> constexpr genType one() { return genType(1); } //!< \returns The value of \math{1}
template<typename genType> constexpr genType one_half() { return genType(0.5); } //!< \returns The value of \math{\frac{1}{2}}
template<typename genType> constexpr genType three_over_two() { return genType(1.5); } //!< \returns The value of \math{\frac{3}{2}}
// Irrational Constants ================================================================================================
template<typename genType> constexpr genType one_third() { return 0.33333333333333333333333333333333333333333333333333; } //!< \returns The value of \f$\frac{1}{3}\f$ with the highest precision for \f$genType\f$
template<typename genType> constexpr genType two_thirds() { return 0.66666666666666666666666666666666666666666666666666; } //!< \returns The value of \f$\frac{2}{3}\f$ with the highest precision for \f$genType\f$
template<typename genType> constexpr genType sqrt_two() { return 1.41421356237309504880168872420969807856967187537694; } //!< \returns The value of \f$\sqrt{2}\f$ with the highest precision for \f$genType\f$
template<typename genType> constexpr genType sqrt_three() { return 1.73205080756887729352744634150587236694280525381038; } //!< \returns The value of \f$\sqrt{3}\f$ with the highest precision for \f$genType\f$
template<typename genType> constexpr genType sqrt_five() { return 2.23606797749978969640917366873127623544061835961152; } //!< \returns The value of \f$\sqrt{5}\f$ with the highest precision for \f$genType\f$
template<typename genType> constexpr genType sqrt_seven() { return 2.64575131106459059050161575363926042571025918308245; } //!< \returns The value of \f$\sqrt{7}\f$ with the highest precision for \f$genType\f$
template<typename genType> constexpr genType sqrt_ten() { return 3.16227766016837933199889354443271853371955513932521; } //!< \returns The value of \f$\sqrt{10}\f$ with the highest precision for \f$genType\f$
template<typename genType> constexpr genType one_over_sqrt_two() { return 0.70710678118654752440084436210484903928483593768847; } //!< \returns The value of \f$\frac{1}{\sqrt{2}}\f$ with the highest precision for \f$genType\f$
template<typename genType> constexpr genType one_over_sqrt_three() { return 0.57735026918962576450914878050195745564760175127012; } //!< \returns The value of \f$\frac{1}{\sqrt{3}}\f$ with the highest precision for \f$genType\f$
template<typename genType> constexpr genType one_over_sqrt_five() { return 0.44721359549995793928183473374625524708812367192230; } //!< \returns The value of \f$\frac{1}{\sqrt{5}}\f$ with the highest precision for \f$genType\f$
template<typename genType> constexpr genType cbrt_two() { return 1.25992104989487316476721060727822835057025146470150; } //!< \returns The value of \f$\sqrt[3]{2}\f$ with the highest precision for \f$genType\f$
template<typename genType> constexpr genType qdrt_two() { return 1.18920711500272106671749997056047591529297209246381; } //!< \returns The value of \f$\sqrt[4]{2}\f$ with the highest precision for \f$genType\f$
template<typename genType> constexpr genType two_raised_sqrt_two() { return 2.66514414269022518865029724987313984827421131371465; } //!< \returns The value of \f${2}^{\sqrt{2}}\f$ with the highest precision for \f$genType\f$
template<typename genType> constexpr genType one_third() { return 0.33333333333333333333333333333333333333333333333333; } //!< \returns The value of \math{\frac{1}{3}} with the highest precision for \emph{genType}
template<typename genType> constexpr genType two_thirds() { return 0.66666666666666666666666666666666666666666666666666; } //!< \returns The value of \math{\frac{2}{3}} with the highest precision for \emph{genType}
template<typename genType> constexpr genType sqrt_two() { return 1.41421356237309504880168872420969807856967187537694; } //!< \returns The value of \math{\sqrt{2}} with the highest precision for \emph{genType}
template<typename genType> constexpr genType sqrt_three() { return 1.73205080756887729352744634150587236694280525381038; } //!< \returns The value of \math{\sqrt{3}} with the highest precision for \emph{genType}
template<typename genType> constexpr genType sqrt_five() { return 2.23606797749978969640917366873127623544061835961152; } //!< \returns The value of \math{\sqrt{5}} with the highest precision for \emph{genType}
template<typename genType> constexpr genType sqrt_seven() { return 2.64575131106459059050161575363926042571025918308245; } //!< \returns The value of \math{\sqrt{7}} with the highest precision for \emph{genType}
template<typename genType> constexpr genType sqrt_ten() { return 3.16227766016837933199889354443271853371955513932521; } //!< \returns The value of \math{\sqrt{10}} with the highest precision for \emph{genType}
template<typename genType> constexpr genType one_over_sqrt_two() { return 0.70710678118654752440084436210484903928483593768847; } //!< \returns The value of \math{\frac{1}{\sqrt{2}}} with the highest precision for \emph{genType}
template<typename genType> constexpr genType one_over_sqrt_three() { return 0.57735026918962576450914878050195745564760175127012; } //!< \returns The value of \math{\frac{1}{\sqrt{3}}} with the highest precision for \emph{genType}
template<typename genType> constexpr genType one_over_sqrt_five() { return 0.44721359549995793928183473374625524708812367192230; } //!< \returns The value of \math{\frac{1}{\sqrt{5}}} with the highest precision for \emph{genType}
template<typename genType> constexpr genType cbrt_two() { return 1.25992104989487316476721060727822835057025146470150; } //!< \returns The value of \math{\sqrt[3]{2}} with the highest precision for \emph{genType}
template<typename genType> constexpr genType qdrt_two() { return 1.18920711500272106671749997056047591529297209246381; } //!< \returns The value of \math{\sqrt[4]{2}} with the highest precision for \emph{genType}
template<typename genType> constexpr genType two_raised_sqrt_two() { return 2.66514414269022518865029724987313984827421131371465; } //!< \returns The value of \math{{2}^{\sqrt{2}}} with the highest precision for \emph{genType}
// Pi ==================================================================================================================
// Pi & Tau
template<typename genType> constexpr genType pi() { return 3.14159265358979323846264338327950288419716939937510; } //!< \returns The value of \f$\pi\f$ with the highest precision for \f$genType\f$
template<typename genType> constexpr genType tau() { return 6.28318530717958647692528676655900576839433879875021; } //!< \returns The value of \f$\tau\f$ with the highest precision for \f$genType\f$
template<typename genType> constexpr genType pi() { return 3.14159265358979323846264338327950288419716939937510; } //!< \returns The value of \math{\pi} with the highest precision for \emph{genType}
template<typename genType> constexpr genType tau() { return 6.28318530717958647692528676655900576839433879875021; } //!< \returns The value of \math{\tau} with the highest precision for \emph{genType}
// Multiples of Pi
template<typename genType> constexpr genType two_pi() { return 6.28318530717958647692528676655900576839433879875021; } //!< \returns The value of \f$2\pi\f$ with the highest precision for \f$genType\f$
template<typename genType> constexpr genType three_pi() { return 9.42477796076937971538793014983850865259150819812531; } //!< \returns The value of \f$3\pi\f$ with the highest precision for \f$genType\f$
template<typename genType> constexpr genType four_pi() { return 12.56637061435917295385057353311801153678867759750042; } //!< \returns The value of \f$4\pi\f$ with the highest precision for \f$genType\f$
template<typename genType> constexpr genType two_pi() { return 6.28318530717958647692528676655900576839433879875021; } //!< \returns The value of \math{2\pi} with the highest precision for \emph{genType}
template<typename genType> constexpr genType three_pi() { return 9.42477796076937971538793014983850865259150819812531; } //!< \returns The value of \math{3\pi} with the highest precision for \emph{genType}
template<typename genType> constexpr genType four_pi() { return 12.56637061435917295385057353311801153678867759750042; } //!< \returns The value of \math{4\pi} with the highest precision for \emph{genType}
// Fractions of Pi
template<typename genType> constexpr genType half_pi() { return 1.57079632679489661923132169163975144209858469968755; } //!< \returns The value of \f$\frac{\pi}{2}\f$ with the highest precision for \f$genType\f$
template<typename genType> constexpr genType three_halves_pi() { return 4.71238898038468985769396507491925432629575409906265; } //!< \returns The value of \f$\frac{3\pi}{2}\f$ with the highest precision for \f$genType\f$
template<typename genType> constexpr genType half_pi() { return 1.57079632679489661923132169163975144209858469968755; } //!< \returns The value of \math{\frac{\pi}{2}} with the highest precision for \emph{genType}
template<typename genType> constexpr genType three_halves_pi() { return 4.71238898038468985769396507491925432629575409906265; } //!< \returns The value of \math{\frac{3\pi}{2}} with the highest precision for \emph{genType}
template<typename genType> constexpr genType third_pi() { return 1.04719755119659774615421446109316762806572313312503; } //!< \returns The value of \f$\frac{\pi}{3}\f$ with the highest precision for \f$genType\f$
template<typename genType> constexpr genType two_thirds_pi() { return 2.09439510239319549230842892218633525613144626625007; } //!< \returns The value of \f$\frac{2\pi}{3}\f$ with the highest precision for \f$genType\f$
template<typename genType> constexpr genType four_thirds_pi() { return 4.18879020478639098461685784437267051226289253250014; } //!< \returns The value of \f$\frac{4\pi}{3}\f$ with the highest precision for \f$genType\f$
template<typename genType> constexpr genType five_thirds_pi() { return 5.23598775598298873077107230546583814032861566562517; } //!< \returns The value of \f$\frac{5\pi}{3}\f$ with the highest precision for \f$genType\f$
template<typename genType> constexpr genType third_pi() { return 1.04719755119659774615421446109316762806572313312503; } //!< \returns The value of \math{\frac{\pi}{3}} with the highest precision for \emph{genType}
template<typename genType> constexpr genType two_thirds_pi() { return 2.09439510239319549230842892218633525613144626625007; } //!< \returns The value of \math{\frac{2\pi}{3}} with the highest precision for \emph{genType}
template<typename genType> constexpr genType four_thirds_pi() { return 4.18879020478639098461685784437267051226289253250014; } //!< \returns The value of \math{\frac{4\pi}{3}} with the highest precision for \emph{genType}
template<typename genType> constexpr genType five_thirds_pi() { return 5.23598775598298873077107230546583814032861566562517; } //!< \returns The value of \math{\frac{5\pi}{3}} with the highest precision for \emph{genType}
template<typename genType> constexpr genType quarter_pi() { return 0.78539816339744830961566084581987572104929234984377; } //!< \returns The value of \f$\frac{\pi}{4}\f$ with the highest precision for \f$genType\f$
template<typename genType> constexpr genType three_quarters_pi() { return 2.35619449019234492884698253745962716314787704953132; } //!< \returns The value of \f$\frac{3\pi}{4}\f$ with the highest precision for \f$genType\f$
template<typename genType> constexpr genType five_quarters_pi() { return 3.92699081698724154807830422909937860524646174921888; } //!< \returns The value of \f$\frac{5\pi}{4}\f$ with the highest precision for \f$genType\f$
template<typename genType> constexpr genType seven_quarters_pi() { return 5.49778714378213816730962592073913004734504644890643; } //!< \returns The value of \f$\frac{7\pi}{4}\f$ with the highest precision for \f$genType\f$
template<typename genType> constexpr genType quarter_pi() { return 0.78539816339744830961566084581987572104929234984377; } //!< \returns The value of \math{\frac{\pi}{4}} with the highest precision for \emph{genType}
template<typename genType> constexpr genType three_quarters_pi() { return 2.35619449019234492884698253745962716314787704953132; } //!< \returns The value of \math{\frac{3\pi}{4}} with the highest precision for \emph{genType}
template<typename genType> constexpr genType five_quarters_pi() { return 3.92699081698724154807830422909937860524646174921888; } //!< \returns The value of \math{\frac{5\pi}{4}} with the highest precision for \emph{genType}
template<typename genType> constexpr genType seven_quarters_pi() { return 5.49778714378213816730962592073913004734504644890643; } //!< \returns The value of \math{\frac{7\pi}{4}} with the highest precision for \emph{genType}
template<typename genType> constexpr genType fifth_pi() { return 0.62831853071795864769252867665590057683943387987502; } //!< \returns The value of \f$\frac{\pi}{5}\f$ with the highest precision for \f$genType\f$
template<typename genType> constexpr genType two_fifths_pi() { return 1.25663706143591729538505735331180115367886775975004; } //!< \returns The value of \f$\frac{2\pi}{5}\f$ with the highest precision for \f$genType\f$
template<typename genType> constexpr genType three_fifths_pi() { return 1.88495559215387594307758602996770173051830163962506; } //!< \returns The value of \f$\frac{3\pi}{5}\f$ with the highest precision for \f$genType\f$
template<typename genType> constexpr genType four_fifths_pi() { return 2.51327412287183459077011470662360230735773551950008; } //!< \returns The value of \f$\frac{4\pi}{5}\f$ with the highest precision for \f$genType\f$
template<typename genType> constexpr genType six_fifths_pi() { return 3.76991118430775188615517205993540346103660327925012; } //!< \returns The value of \f$\frac{6\pi}{5}\f$ with the highest precision for \f$genType\f$
template<typename genType> constexpr genType seven_fifths_pi() { return 4.39822971502571053384770073659130403787603715912514; } //!< \returns The value of \f$\frac{7\pi}{5}\f$ with the highest precision for \f$genType\f$
template<typename genType> constexpr genType eight_fifths_pi() { return 5.02654824574366918154022941324720461471547103900016; } //!< \returns The value of \f$\frac{8\pi}{5}\f$ with the highest precision for \f$genType\f$
template<typename genType> constexpr genType nine_fifths_pi() { return 5.65486677646162782923275808990310519155490491887519; } //!< \returns The value of \f$\frac{9\pi}{5}\f$ with the highest precision for \f$genType\f$
template<typename genType> constexpr genType fifth_pi() { return 0.62831853071795864769252867665590057683943387987502; } //!< \returns The value of \math{\frac{\pi}{5}} with the highest precision for \emph{genType}
template<typename genType> constexpr genType two_fifths_pi() { return 1.25663706143591729538505735331180115367886775975004; } //!< \returns The value of \math{\frac{2\pi}{5}} with the highest precision for \emph{genType}
template<typename genType> constexpr genType three_fifths_pi() { return 1.88495559215387594307758602996770173051830163962506; } //!< \returns The value of \math{\frac{3\pi}{5}} with the highest precision for \emph{genType}
template<typename genType> constexpr genType four_fifths_pi() { return 2.51327412287183459077011470662360230735773551950008; } //!< \returns The value of \math{\frac{4\pi}{5}} with the highest precision for \emph{genType}
template<typename genType> constexpr genType six_fifths_pi() { return 3.76991118430775188615517205993540346103660327925012; } //!< \returns The value of \math{\frac{6\pi}{5}} with the highest precision for \emph{genType}
template<typename genType> constexpr genType seven_fifths_pi() { return 4.39822971502571053384770073659130403787603715912514; } //!< \returns The value of \math{\frac{7\pi}{5}} with the highest precision for \emph{genType}
template<typename genType> constexpr genType eight_fifths_pi() { return 5.02654824574366918154022941324720461471547103900016; } //!< \returns The value of \math{\frac{8\pi}{5}} with the highest precision for \emph{genType}
template<typename genType> constexpr genType nine_fifths_pi() { return 5.65486677646162782923275808990310519155490491887519; } //!< \returns The value of \math{\frac{9\pi}{5}} with the highest precision for \emph{genType}
template<typename genType> constexpr genType sixth_pi() { return 0.52359877559829887307710723054658381403286156656251; } //!< \returns The value of \f$\frac{\pi}{6}\f$ with the highest precision for \f$genType\f$
template<typename genType> constexpr genType five_sixths_pi() { return 2.61799387799149436538553615273291907016430783281258; } //!< \returns The value of \f$\frac{5\pi}{6}\f$ with the highest precision for \f$genType\f$
template<typename genType> constexpr genType seven_sixths_pi() { return 3.66519142918809211153975061382608669823003096593762; } //!< \returns The value of \f$\frac{7\pi}{6}\f$ with the highest precision for \f$genType\f$
template<typename genType> constexpr genType eleven_sixths_pi() { return 5.75958653158128760384817953601242195436147723218769; } //!< \returns The value of \f$\frac{11\pi}{6}\f$ with the highest precision for \f$genType\f$
template<typename genType> constexpr genType sixth_pi() { return 0.52359877559829887307710723054658381403286156656251; } //!< \returns The value of \math{\frac{\pi}{6}} with the highest precision for \emph{genType}
template<typename genType> constexpr genType five_sixths_pi() { return 2.61799387799149436538553615273291907016430783281258; } //!< \returns The value of \math{\frac{5\pi}{6}} with the highest precision for \emph{genType}
template<typename genType> constexpr genType seven_sixths_pi() { return 3.66519142918809211153975061382608669823003096593762; } //!< \returns The value of \math{\frac{7\pi}{6}} with the highest precision for \emph{genType}
template<typename genType> constexpr genType eleven_sixths_pi() { return 5.75958653158128760384817953601242195436147723218769; } //!< \returns The value of \math{\frac{11\pi}{6}} with the highest precision for \emph{genType}
// Reciprocals of Pi
template<typename genType> constexpr genType one_over_pi() { return 0.31830988618379067153776752674502872406891929148091; } //!< \returns The value of \f$\frac{1}{\pi}\f$ with the highest precision for \f$genType\f$
template<typename genType> constexpr genType two_over_pi() { return 0.63661977236758134307553505349005744813783858296182; } //!< \returns The value of \f$\frac{2}{\pi}\f$ with the highest precision for \f$genType\f$
template<typename genType> constexpr genType one_over_pi() { return 0.31830988618379067153776752674502872406891929148091; } //!< \returns The value of \math{\frac{1}{\pi}} with the highest precision for \emph{genType}
template<typename genType> constexpr genType two_over_pi() { return 0.63661977236758134307553505349005744813783858296182; } //!< \returns The value of \math{\frac{2}{\pi}} with the highest precision for \emph{genType}
// Exponentiations Pi
template<typename genType> constexpr genType pi_sq() { return 9.86960440108935861883449099987615113531369940724079; } //!< \returns The value of \f${\pi}^{2}\f$ with the highest precision for \f$genType\f$
template<typename genType> constexpr genType pi_cb() { return 31.00627668029982017547631506710139520222528856588510; } //!< \returns The value of \f${\pi}^{2}\f$ with the highest precision for \f$genType\f$
template<typename genType> constexpr genType sqrt_pi() { return 1.77245385090551602729816748334114518279754945612238; } ///< \returns The value of \f$\sqrt{\pi}\f$ with the highest precision for \f$genType\f$
template<typename genType> constexpr genType one_over_sqrt_pi() { return 0.56418958354775628694807945156077258584405062932899; } ///< \returns The value of \f$\frac{1}{\sqrt{\pi}}\f$ with the highest precision for \f$genType\f$
template<typename genType> constexpr genType sqrt_two_pi() { return 1.77245385090551602729816748334114518279754945612238; } ///< \returns The value of \f$\sqrt{2\pi}\f$ with the highest precision for \f$genType\f$
template<typename genType> constexpr genType one_over_sqrt_two_pi() { return 0.39894228040143267793994605993438186847585863116493; } ///< \returns The value of \f$\frac{1}{\sqrt{2\pi}}\f$ with the highest precision for \f$genType\f$
template<typename genType> constexpr genType cbrt_pi() { return 1.46459188756152326302014252726379039173859685562793; } ///< \returns The value of \f$\sqrt[3]{\pi}\f$ with the highest precision for \f$genType\f$
template<typename genType> constexpr genType pi_sq() { return 9.86960440108935861883449099987615113531369940724079; } //!< \returns The value of \math{{\pi}^{2}} with the highest precision for \emph{genType}
template<typename genType> constexpr genType pi_cb() { return 31.00627668029982017547631506710139520222528856588510; } //!< \returns The value of \math{{\pi}^{2}} with the highest precision for \emph{genType}
template<typename genType> constexpr genType sqrt_pi() { return 1.77245385090551602729816748334114518279754945612238; } ///< \returns The value of \math{\sqrt{\pi}} with the highest precision for \emph{genType}
template<typename genType> constexpr genType one_over_sqrt_pi() { return 0.56418958354775628694807945156077258584405062932899; } ///< \returns The value of \math{\frac{1}{\sqrt{\pi}}} with the highest precision for \emph{genType}
template<typename genType> constexpr genType sqrt_two_pi() { return 1.77245385090551602729816748334114518279754945612238; } ///< \returns The value of \math{\sqrt{2\pi}} with the highest precision for \emph{genType}
template<typename genType> constexpr genType one_over_sqrt_two_pi() { return 0.39894228040143267793994605993438186847585863116493; } ///< \returns The value of \math{\frac{1}{\sqrt{2\pi}}} with the highest precision for \emph{genType}
template<typename genType> constexpr genType cbrt_pi() { return 1.46459188756152326302014252726379039173859685562793; } ///< \returns The value of \math{\sqrt[3]{\pi}} with the highest precision for \emph{genType}
// e ===================================================================================================================
// Multiples and Reciprocal
template<typename genType> constexpr genType e() { return 2.71828182845904523536028747135266249775724709369995; } ///< \returns The value of \f$e\f$ with the highest precision for \f$genType\f$
template<typename genType> constexpr genType half_e() { return 1.35914091422952261768014373567633124887862354684997; } ///< \returns The value of \f$\frac{e}{2}\f$ with the highest precision for \f$genType\f$
template<typename genType> constexpr genType two_e() { return 5.43656365691809047072057494270532499551449418739991; } ///< \returns The value of \f$2e\f$ with the highest precision for \f$genType\f$
template<typename genType> constexpr genType one_over_e() { return 0.36787944117144232159552377016146086744581113103176; } ///< \returns The value of \f$\frac{1}{e}\f$ with the highest precision for \f$genType\f$
template<typename genType> constexpr genType e() { return 2.71828182845904523536028747135266249775724709369995; } ///< \returns The value of \math{e} with the highest precision for \emph{genType}
template<typename genType> constexpr genType half_e() { return 1.35914091422952261768014373567633124887862354684997; } ///< \returns The value of \math{\frac{e}{2}} with the highest precision for \emph{genType}
template<typename genType> constexpr genType two_e() { return 5.43656365691809047072057494270532499551449418739991; } ///< \returns The value of \math{2e} with the highest precision for \emph{genType}
template<typename genType> constexpr genType one_over_e() { return 0.36787944117144232159552377016146086744581113103176; } ///< \returns The value of \math{\frac{1}{e}} with the highest precision for \emph{genType}
// Exponentiations of e
template<typename genType> constexpr genType e_sq() { return 7.38905609893065022723042746057500781318031557055184; } ///< \returns The value of \f$e^2\f$ with the highest precision for \f$genType\f$
template<typename genType> constexpr genType e_cb() { return 20.08553692318766774092852965458171789698790783855415; } ///< \returns The value of \f$e^3\f$ with the highest precision for \f$genType\f$
template<typename genType> constexpr genType sqrt_e() { return 1.64872127070012814684865078781416357165377610071014; } ///< \returns The value of \f$\sqrt{e}\f$ with the highest precision for \f$genType\f$
template<typename genType> constexpr genType one_over_sqrt_e() { return 0.60653065971263342360379953499118045344191813548718; } ///< \returns The value of \f$\frac{1}{\sqrt{e}}\f$ with the highest precision for \f$genType\f$
template<typename genType> constexpr genType e_raised_two() { return 7.38905609893065022723042746057500781318031557055184; } ///< \returns The value of \f$e^e\f$ with the highest precision for \f$genType\f$
template<typename genType> constexpr genType e_raised_e() { return 15.15426224147926418976043027262991190552854853685613; } ///< \returns The value of \f$e^e\f$ with the highest precision for \f$genType\f$
template<typename genType> constexpr genType e_raised_neg_e() { return 0.065988035845312537076790187596846424938577048252796; } ///< \returns The value of \f$e^-e\f$ with the highest precision for \f$genType\f$
template<typename genType> constexpr genType e_sq() { return 7.38905609893065022723042746057500781318031557055184; } ///< \returns The value of \math{e^2} with the highest precision for \emph{genType}
template<typename genType> constexpr genType e_cb() { return 20.08553692318766774092852965458171789698790783855415; } ///< \returns The value of \math{e^3} with the highest precision for \emph{genType}
template<typename genType> constexpr genType sqrt_e() { return 1.64872127070012814684865078781416357165377610071014; } ///< \returns The value of \math{\sqrt{e}} with the highest precision for \emph{genType}
template<typename genType> constexpr genType one_over_sqrt_e() { return 0.60653065971263342360379953499118045344191813548718; } ///< \returns The value of \math{\frac{1}{\sqrt{e}}} with the highest precision for \emph{genType}
template<typename genType> constexpr genType e_raised_two() { return 7.38905609893065022723042746057500781318031557055184; } ///< \returns The value of \math{e^e} with the highest precision for \emph{genType}
template<typename genType> constexpr genType e_raised_e() { return 15.15426224147926418976043027262991190552854853685613; } ///< \returns The value of \math{e^e} with the highest precision for \emph{genType}
template<typename genType> constexpr genType e_raised_neg_e() { return 0.065988035845312537076790187596846424938577048252796; } ///< \returns The value of \math{e^-e} with the highest precision for \emph{genType}
// Exponentiations of e by Pi
template<typename genType> constexpr genType e_raised_pi() { return 23.14069263277926900572908636794854738026610624260021; } ///< \returns The value of \f${e}^{ \pi}\f$ with the highest precision for \f$genType\f$
template<typename genType> constexpr genType e_raised_neg_pi() { return 0.04321391826377224977441773717172801127572810981063; } ///< \returns The value of \f${e}^{-\pi}\f$ with the highest precision for \f$genType\f$
template<typename genType> constexpr genType e_raised_half_pi() { return 4.81047738096535165547303566670383312639017087466453; } ///< \returns The value of \f${e}^{\frac{ \pi}{2}}\f$ with the highest precision for \f$genType\f$
template<typename genType> constexpr genType e_raised_neg_half_pi() { return 0.20787957635076190854695561983497877003387784163176; } ///< \returns The value of \f${e}^{\frac{-\pi}{2}}\f$ with the highest precision for \f$genType\f$
template<typename genType> constexpr genType e_raised_pi() { return 23.14069263277926900572908636794854738026610624260021; } ///< \returns The value of \math{{e}^{ \pi}} with the highest precision for \emph{genType}
template<typename genType> constexpr genType e_raised_neg_pi() { return 0.04321391826377224977441773717172801127572810981063; } ///< \returns The value of \math{{e}^{-\pi}} with the highest precision for \emph{genType}
template<typename genType> constexpr genType e_raised_half_pi() { return 4.81047738096535165547303566670383312639017087466453; } ///< \returns The value of \math{{e}^{\frac{ \pi}{2}}} with the highest precision for \emph{genType}
template<typename genType> constexpr genType e_raised_neg_half_pi() { return 0.20787957635076190854695561983497877003387784163176; } ///< \returns The value of \math{{e}^{\frac{-\pi}{2}}} with the highest precision for \emph{genType}
// Exponentiations of e by Gamma
template<typename genType> constexpr genType e_raised_gamma() { return 1.78107241799019798523650410310717954916964521430343; } ///< \returns The value of \f${e}^{ \gamma}\f$ with the highest precision for \f$genType\f$
template<typename genType> constexpr genType e_raised_neg_gamma() { return 0.56145948356688516982414321479088078676571038692515; } ///< \returns The value of \f${e}^{-\gamma}\f$ with the highest precision for \f$genType\f$
template<typename genType> constexpr genType e_raised_gamma() { return 1.78107241799019798523650410310717954916964521430343; } ///< \returns The value of \math{{e}^{ \gamma}} with the highest precision for \emph{genType}
template<typename genType> constexpr genType e_raised_neg_gamma() { return 0.56145948356688516982414321479088078676571038692515; } ///< \returns The value of \math{{e}^{-\gamma}} with the highest precision for \emph{genType}
// Catalan's Constant ==================================================================================================
template<typename genType> constexpr genType G() { return 0.91596559417721901505460351493238411077414937428167; } ///< \returns The value of \f$G\f$ with the highest precision for \f$genType\f$
template<typename genType> constexpr genType one_over_G() { return 1.09174406370390610145415947333389232498605012140824; } ///< \returns The value of \f$\frac{1}{G}\f$ with the highest precision for \f$genType\f$
template<typename genType> constexpr genType G_over_pi() { return 0.29156090403081878013838445646839491886406615398583; } ///< \returns The value of \f$\frac{G}{\pi}\f$ with the highest precision for \f$genType\f$
template<typename genType> constexpr genType pi_over_G() { return 3.42981513013245864263455323784799901211670795530093; } ///< \returns The value of \f$\frac{\pi}{G}\f$ with the highest precision for \f$genType\f$
template<typename genType> constexpr genType G() { return 0.91596559417721901505460351493238411077414937428167; } ///< \returns The value of \math{G} with the highest precision for \emph{genType}
template<typename genType> constexpr genType one_over_G() { return 1.09174406370390610145415947333389232498605012140824; } ///< \returns The value of \math{\frac{1}{G}} with the highest precision for \emph{genType}
template<typename genType> constexpr genType G_over_pi() { return 0.29156090403081878013838445646839491886406615398583; } ///< \returns The value of \math{\frac{G}{\pi}} with the highest precision for \emph{genType}
template<typename genType> constexpr genType pi_over_G() { return 3.42981513013245864263455323784799901211670795530093; } ///< \returns The value of \math{\frac{\pi}{G}} with the highest precision for \emph{genType}
// Gamma ===============================================================================================================
template<typename genType> constexpr genType y() { return 0.57721566490153286060651209008240243104215933593992; } ///< \returns The value of \f$\gamma\f$ with the highest precision for \f$genType\f$
template<typename genType> constexpr genType one_over_y() { return 1.73245471460063347358302531586082968115577655226680; } ///< \returns The value of \f$\frac{1}{\gamma}\f$ with the highest precision for \f$genType\f$
template<typename genType> constexpr genType y() { return 0.57721566490153286060651209008240243104215933593992; } ///< \returns The value of \math{\gamma} with the highest precision for \emph{genType}
template<typename genType> constexpr genType one_over_y() { return 1.73245471460063347358302531586082968115577655226680; } ///< \returns The value of \math{\frac{1}{\gamma}} with the highest precision for \emph{genType}
// Logarithms ==========================================================================================================
template<typename genType> constexpr genType log_two() { return 0.69314718055994530941723212145817656807550013436025; } ///< \returns The value of \f$\log{2}\f$ with the highest precision for \f$genType\f$
template<typename genType> constexpr genType log_three() { return 1.09861228866810969139524523692252570464749055782274; } ///< \returns The value of \f$\log{3}\f$ with the highest precision for \f$genType\f$
template<typename genType> constexpr genType log_five() { return 1.60943791243410037460075933322618763952560135426851; } ///< \returns The value of \f$\log{5}\f$ with the highest precision for \f$genType\f$
template<typename genType> constexpr genType log_seven() { return 1.94591014905531330510535274344317972963708472958186; } ///< \returns The value of \f$\log{7}\f$ with the highest precision for \f$genType\f$
template<typename genType> constexpr genType log_ten() { return 2.30258509299404568401799145468436420760110148862877; } ///< \returns The value of \f$\log{10}\f$ with the highest precision for \f$genType\f$
template<typename genType> constexpr genType one_over_log_ten() { return 0.43429448190325182765112891891660508229439700580366; } ///< \returns The value of \f$\frac{1}{\log{10}}\f$ with the highest precision for \f$genType\f$
template<typename genType> constexpr genType log_two_over_log_three() { return 0.63092975357145743709952711434276085429958564013188; } ///< \returns The value of \f$\frac{\log{2}}{\log{3}}\f$ with the highest precision for \f$genType\f$
template<typename genType> constexpr genType log_log_two() { return -0.36651292058166432701243915823266946945426344783711; } ///< \returns The value of \f$\log{\log{2}}\f$ with the highest precision for \f$genType\f$
template<typename genType> constexpr genType log_pi() { return 1.14472988584940017414342735135305871164729481291531; } ///< \returns The value of \f$\log{\pi}\f$ with the highest precision for \f$genType\f$
template<typename genType> constexpr genType log_sqrt_two() { return 0.91893853320467274178032973640561763986139747363778; } ///< \returns The value of \f$\log{\sqrt{2}}\f$ with the highest precision for \f$genType\f$
template<typename genType> constexpr genType log_gamma() { return -0.54953931298164482233766176880290778833069898126306; } ///< \returns The value of \f$\log{\gamma}\f$ with the highest precision for \f$genType\f$
template<typename genType> constexpr genType log_phi() { return 0.48121182505960344749775891342436842313518433438566; } ///< \returns The value of \f$\log{\phi}\f$ with the highest precision for \f$genType\f$
template<typename genType> constexpr genType log_two() { return 0.69314718055994530941723212145817656807550013436025; } ///< \returns The value of \math{\log{2}} with the highest precision for \emph{genType}
template<typename genType> constexpr genType log_three() { return 1.09861228866810969139524523692252570464749055782274; } ///< \returns The value of \math{\log{3}} with the highest precision for \emph{genType}
template<typename genType> constexpr genType log_five() { return 1.60943791243410037460075933322618763952560135426851; } ///< \returns The value of \math{\log{5}} with the highest precision for \emph{genType}
template<typename genType> constexpr genType log_seven() { return 1.94591014905531330510535274344317972963708472958186; } ///< \returns The value of \math{\log{7}} with the highest precision for \emph{genType}
template<typename genType> constexpr genType log_ten() { return 2.30258509299404568401799145468436420760110148862877; } ///< \returns The value of \math{\log{10}} with the highest precision for \emph{genType}
template<typename genType> constexpr genType one_over_log_ten() { return 0.43429448190325182765112891891660508229439700580366; } ///< \returns The value of \math{\frac{1}{\log{10}}} with the highest precision for \emph{genType}
template<typename genType> constexpr genType log_two_over_log_three() { return 0.63092975357145743709952711434276085429958564013188; } ///< \returns The value of \math{\frac{\log{2}}{\log{3}}} with the highest precision for \emph{genType}
template<typename genType> constexpr genType log_log_two() { return -0.36651292058166432701243915823266946945426344783711; } ///< \returns The value of \math{\log{\log{2}}} with the highest precision for \emph{genType}
template<typename genType> constexpr genType log_pi() { return 1.14472988584940017414342735135305871164729481291531; } ///< \returns The value of \math{\log{\pi}} with the highest precision for \emph{genType}
template<typename genType> constexpr genType log_sqrt_two() { return 0.91893853320467274178032973640561763986139747363778; } ///< \returns The value of \math{\log{\sqrt{2}}} with the highest precision for \emph{genType}
template<typename genType> constexpr genType log_gamma() { return -0.54953931298164482233766176880290778833069898126306; } ///< \returns The value of \math{\log{\gamma}} with the highest precision for \emph{genType}
template<typename genType> constexpr genType log_phi() { return 0.48121182505960344749775891342436842313518433438566; } ///< \returns The value of \math{\log{\phi}} with the highest precision for \emph{genType}
}

58
include/fennec/math/ext/quaternion.h
View File

@@ -52,7 +52,7 @@ constexpr genType sqnorm(const qua<genType>& q) {
///
/// \brief Norm Function
/// \param q The Quaternion
/// \returns The Hamilton Tensor of \f$q\f$
/// \returns The Hamilton Tensor of \emph{q}
template<typename genType>
constexpr genType norm(const qua<genType>& q) {
return fennec::sqrt(sqnorm(q));
@@ -61,7 +61,7 @@ constexpr genType norm(const qua<genType>& q) {
///
/// \brief Unit Function (Versor)
/// \param q The Quaternion
/// \returns A Quaternion of \f$q\f$ with norm \f$1\f$
/// \returns A Quaternion of \emph{q} with norm \math{1}
template<typename genType>
constexpr qua<genType> unit(const qua<genType>& q) {
genType n = fennec::norm(q);
@@ -71,7 +71,7 @@ constexpr qua<genType> unit(const qua<genType>& q) {
///
/// \brief Reciprocal Function
/// \param q The Quaternion
/// \returns The quaternion \f${q}^{-1}\f$
/// \returns The quaternion \math{\textbf{q}^{-1}}
template<typename genType>
constexpr qua<genType> reciprocal(const qua<genType>& q) {
return ~q / fennec::sqnorm(q);
@@ -99,7 +99,7 @@ public:
// Constructors ========================================================================================================
///
/// \brief Default Constructor, creates a quaternion such that the real part is \f$1\f$ and all others are \f$0\f$
/// \brief Default Constructor, creates a quaternion such that the real part is \math{1} and all others are \math{0}
constexpr quaternion() {
data = { 0, 0, 0, 1 };
}
@@ -107,9 +107,9 @@ public:
///
/// \brief Component Constructor
/// \param w The scalar component
/// \param x The coefficient of the \f$i\f$ component
/// \param y The coefficient of the \f$j\f$ component
/// \param z The coefficient of the \f$k\f$ component
/// \param x The coefficient of the \emph{i} component
/// \param y The coefficient of the \emph{j} component
/// \param z The coefficient of the \emph{k} component
constexpr quaternion(scalar_t w, scalar_t x, scalar_t y, scalar_t z) {
data = { x, y, z, w };
}
@@ -160,7 +160,7 @@ public:
///
/// \brief Copy Assignment Operator
/// \param q The quaternion to copy
/// \returns a reference to self
/// \returns a reference to \emph{this}
constexpr quat_t& operator=(const quat_t& q) {
data = q.data;
return *this;
@@ -169,7 +169,7 @@ public:
///
/// \brief Move Assignment Operator
/// \param q The quaternion to move
/// \returns a reference to self
/// \returns a reference to \emph{this}
constexpr quat_t& operator=(quat_t&& q) noexcept {
data = q.data;
return *this;
@@ -182,7 +182,7 @@ public:
/// \brief Equality Operator
/// \param lhs the left hand side of the expression
/// \param rhs the right hand side of the expression
/// \returns \f$true\f$ when all components of \f$lhs\f$ and \f$rhs\f$ are equal, false otherwise
/// \returns \emph{true} when all components of \emph{lhs} and \emph{rhs} are equal, false otherwise
constexpr friend bool operator==(const quat_t& lhs, const quat_t& rhs) {
return lhs.data == rhs.data;
}
@@ -191,7 +191,7 @@ public:
/// \brief Inequality Operator
/// \param lhs the left hand side of the expression
/// \param rhs the right hand side of the expression
/// \returns \f$true\f$ when any component of \f$lhs\f$ and \f$rhs\f$ are not equal, false otherwise
/// \returns \emph{true} when any component of \emph{lhs} and \emph{rhs} are not equal, false otherwise
constexpr friend bool operator!=(const quat_t& lhs, const quat_t& rhs) {
return lhs.data != rhs.data;
}
@@ -202,7 +202,7 @@ public:
///
/// \brief Unary Negation Operator
/// \param rhs The quaternion to negate
/// \returns A quaternion with each component of \f$rhs\f$ negated.
/// \returns A quaternion with each component of \emph{rhs} negated.
constexpr friend quat_t operator-(const quat_t& rhs) {
return quat_t(-rhs.w, -rhs.x, -rhs.y, -rhs.z);
}
@@ -210,7 +210,7 @@ public:
///
/// \brief Unary Conjugation Operator
/// \param rhs The quaternion to conjugate
/// \returns A quaternion with each vector component of \f$rhs\f$ negated.
/// \returns A quaternion with each vector component of \emph{rhs} negated.
constexpr friend quat_t operator~(const quat_t& rhs) {
return quat_t(rhs.w, -rhs.x, -rhs.y, -rhs.z);
}
@@ -222,7 +222,7 @@ public:
/// \brief Quaternion-Scalar Multiplication Operator
/// \param lhs The quaternion
/// \param rhs The scalar
/// \returns A quaternion with each component of \f$lhs\f$ multiplied by \f$rhs\f$
/// \returns A quaternion with each component of \emph{lhs} multiplied by \emph{rhs}
constexpr friend quat_t operator*(const quat_t& lhs, scalar_t rhs) {
return quat_t(lhs.w * rhs, lhs.x * rhs, lhs.y * rhs, lhs.z * rhs);
}
@@ -231,7 +231,7 @@ public:
/// \brief Scalar-Quaternion Multiplication Operator
/// \param lhs The scalar
/// \param rhs The quaternion
/// \returns A quaternion with each component of \f$rhs\f$ multiplied by \f$lhs\f$
/// \returns A quaternion with each component of \emph{rhs} multiplied by \emph{lhs}
constexpr friend quat_t operator*(scalar_t lhs, const quat_t& rhs) {
return quat_t(lhs * rhs.w, lhs * rhs.x, lhs * rhs.y, lhs * rhs.z);
}
@@ -240,7 +240,7 @@ public:
/// \brief Quaternion-Scalar Division Operator
/// \param lhs The quaternion
/// \param rhs The scalar
/// \returns A quaternion with each component of \f$lhs\f$ divided by \f$rhs\f$
/// \returns A quaternion with each component of \emph{lhs} divided by \emph{rhs}
constexpr friend quat_t operator/(const quat_t& lhs, scalar_t rhs) {
return quat_t(lhs.w / rhs, lhs.x / rhs, lhs.y / rhs, lhs.z / rhs);
}
@@ -249,7 +249,7 @@ public:
/// \brief Scalar-Quaternion Division Operator
/// \param lhs The scalar
/// \param rhs The quaternion
/// \returns A quaternion with each component of \f$rhs\f$ divided by \f$lhs\f$
/// \returns A quaternion with each component of \emph{rhs} divided by \emph{lhs}
constexpr friend quat_t operator/(scalar_t lhs, const quat_t& rhs) {
return quat_t(lhs / rhs.w, lhs / rhs.x, lhs / rhs.y, lhs / rhs.z);
}
@@ -261,7 +261,7 @@ public:
/// \brief Quaternion-Scalar Multiplication Assignment Operator
/// \param lhs The quaternion
/// \param rhs The scalar
/// \returns \f$lhs\f$ with each component multiplied by \f$rhs\f$
/// \returns \emph{lhs} with each component multiplied by \emph{rhs}
constexpr friend quat_t& operator*=(quat_t& lhs, scalar_t rhs) {
lhs.x *= rhs;
lhs.y *= rhs;
@@ -274,7 +274,7 @@ public:
/// \brief Quaternion-Scalar Division Assignment Operator
/// \param lhs The quaternion
/// \param rhs The scalar
/// \returns \f$lhs\f$ with each component divided by \f$rhs\f$
/// \returns \emph{lhs} with each component divided by \emph{rhs}
constexpr friend quat_t& operator/=(const quat_t& lhs, scalar_t rhs) {
lhs.x /= rhs;
lhs.y /= rhs;
@@ -290,7 +290,7 @@ public:
/// \brief Quaternion-Vector Multiplication Operator
/// \param q the quaternion
/// \param v the vector
/// \returns the linear algebraic product of \f$q\f$ and \f$v\f$
/// \returns the linear algebraic product of \emph{q} and \emph{v}
constexpr friend vec3_t operator*(const quat_t& q, const vec3_t& v) {
const vec3_t u = q.xyz;
const vec3_t uv = fennec::cross(u, v);
@@ -302,7 +302,7 @@ public:
/// \brief Vector-Quaternion Multiplication Operator
/// \param v the vector
/// \param q the quaternion
/// \returns the linear algebraic product of \f$v\f$ and \f$q\f$
/// \returns the linear algebraic product of \emph{v} and \emph{q}
constexpr friend vec3_t operator*(const vec3_t& v, const quat_t& q) {
return fennec::reciprocal(q) * v;
}
@@ -311,7 +311,7 @@ public:
/// \brief Quaternion-Vector Multiplication Operator
/// \param q the quaternion
/// \param v the vector
/// \returns the linear algebraic product of \f$q\f$ and \f$v\f$
/// \returns the linear algebraic product of \emph{q} and \emph{v}
constexpr friend vec4_t operator*(const quat_t& q, const vec4_t& v) {
return vec4_t(q * v.xyz, v.w);
}
@@ -320,7 +320,7 @@ public:
/// \brief Vector-Quaternion Multiplication Operator
/// \param v the vector
/// \param q the quaternion
/// \returns the linear algebraic product of \f$v\f$ and \f$q\f$
/// \returns the linear algebraic product of \emph{v} and \emph{q}
constexpr friend vec4_t operator*(const vec4_t& v, const quat_t& q) {
return fennec::reciprocal(q) * v;
}
@@ -332,7 +332,7 @@ public:
/// \brief Quaternion-Quaternion Addition Operator
/// \param lhs the left hand side
/// \param rhs the right hand side
/// \returns the component-wise sum of \f$lhs\f$ and \f$rhs\f$
/// \returns the component-wise sum of \emph{lhs} and \emph{rhs}
constexpr friend quat_t operator+(const quat_t& lhs, const quat_t& rhs) {
return quat_t(
lhs.w + rhs.w,
@@ -346,7 +346,7 @@ public:
/// \brief Quaternion-Quaternion Subtraction Operator
/// \param lhs the left hand side
/// \param rhs the right hand side
/// \returns the component-wise difference of \f$lhs\f$ and \f$rhs\f$
/// \returns the component-wise difference of \emph{lhs} and \emph{rhs}
constexpr friend quat_t operator-(const quat_t& lhs, const quat_t& rhs) {
return quat_t(
lhs.w - rhs.w,
@@ -360,7 +360,7 @@ public:
/// \brief Quaternion-Quaternion Multiplication Operator
/// \param lhs the left hand side
/// \param rhs the right hand side
/// \returns the linear algebraic product of \f$lhs\f$ and \f$rhs\f$
/// \returns the linear algebraic product of \emph{lhs} and \emph{rhs}
constexpr friend quat_t operator*(const quat_t& lhs, const quat_t& rhs) {
return quat_t(
lhs.w*rhs.w - lhs.x*rhs.x - lhs.y*rhs.y - lhs.z * rhs.z,
@@ -377,7 +377,7 @@ public:
/// \brief Quaternion-Quaternion Addition Assignment Operator
/// \param lhs the left hand side
/// \param rhs the right hand side
/// \returns the component-wise sum of \f$lhs\f$ and \f$rhs\f$ stored in \f$lhs\f$
/// \returns the component-wise sum of \emph{lhs} and \emph{rhs} stored in \emph{lhs}
constexpr friend quat_t& operator+=(quat_t& lhs, const quat_t& rhs) {
lhs.w += rhs.w;
lhs.x += rhs.x;
@@ -390,7 +390,7 @@ public:
/// \brief Quaternion-Quaternion Subtraction Assignment Operator
/// \param lhs the left hand side
/// \param rhs the right hand side
/// \returns the component-wise difference of \f$lhs\f$ and \f$rhs\f$ stored in \f$lhs\f$
/// \returns the component-wise difference of \emph{lhs} and \emph{rhs} stored in \emph{lhs}
constexpr friend quat_t& operator-=(quat_t& lhs, const quat_t& rhs) {
lhs.w -= rhs.w;
lhs.x -= rhs.x;
@@ -403,7 +403,7 @@ public:
/// \brief Quaternion-Quaternion Multiplication Assignment Operator
/// \param lhs the left hand side
/// \param rhs the right hand side
/// \returns the linear algebraic product of \f$lhs\f$ and \f$rhs\f$ stored in \f$lhs\f$
/// \returns the linear algebraic product of \emph{lhs} and \emph{rhs} stored in \emph{lhs}
constexpr friend quat_t& operator*=(quat_t& lhs, const quat_t& rhs) {
return lhs = lhs * rhs;
}

76
include/fennec/math/geometric.h
View File

@@ -118,14 +118,14 @@ namespace fennec
// dot -----------------------------------------------------------------------------------------------------------------
///
/// \brief Returns the dot product of \f$x\f$ and \f$y\f$, i.e., \f$x_0 \cdot y_0 + x_1 \cdot y_1 + \ldots\f$
/// \brief Returns the dot product of \math{x} and \math{y}, i.e., \math{x_0 \cdot y_0 + x_1 \cdot y_1 + \ldots}
///
/// \returns the dot product of \f$x\f$ and \f$y\f$, i.e., \f$x_0 \cdot y_0 + x_0 \cdot y_0 + \ldots\f$ <br><br>
/// \returns the dot product of \math{x} and \math{y}, i.e., \math{x_0 \cdot y_0 + x_0 \cdot y_0 + \ldots} <br><br>
/// \details we can represent this in linear algebra as the following, <br><br>
/// let \f$X=\left[\begin{array}\\ x_0 \\ x_1 \\ \vdots \\ x_N \end{array}\right]\f$ <br>
/// let \f$Y=\left[\begin{array}\\ y_0 \\ y_1 \\ \vdots \\ y_N \end{array}\right]\f$ <br><br>
/// let \math{X=\left[\begin{array}\\ x_0 \\ x_1 \\ \vdots \\ x_N \end{array}\right]} <br>
/// let \math{Y=\left[\begin{array}\\ y_0 \\ y_1 \\ \vdots \\ y_N \end{array}\right]} <br><br>
///
/// then \f$\text{dot}(X, Y)=X \cdot Y^T\f$ <br><br>
/// then \math{\text{dot}(X, Y)=X \cdot Y^T} <br><br>
///
/// \param x first vector
/// \param y second vector
@@ -138,13 +138,13 @@ constexpr genType dot(const vector<genType, i...>& x, const vector<genType, i...
// length2 -------------------------------------------------------------------------------------------------------------
///
/// \brief Returns the squared length of vector \f$x\f$, i.e., \f$x_0^2 + x_1^2 + \ldots\f$
/// \brief Returns the squared length of vector \math{x}, i.e., \math{x_0^2 + x_1^2 + \ldots}
///
/// \returns the squared length of vector \f$x\f$, i.e., \f$x_0^2 + x_1^2 + \ldots\f$ <br><br>
/// \returns the squared length of vector \math{x}, i.e., \math{x_0^2 + x_1^2 + \ldots} <br><br>
/// \details we can represent this in linear algebra as the following, <br><br>
/// let \f$X=\left[\begin{array}\\ x_0 \\ x_1 \\ \vdots \\ x_N \end{array}\right]\f$ <br><br>
/// let \math{X=\left[\begin{array}\\ x_0 \\ x_1 \\ \vdots \\ x_N \end{array}\right]} <br><br>
///
/// then \f$\text{length2}(X)=X \cdot X^T\f$ <br><br>
/// then \math{\text{length2}(X)=X \cdot X^T} <br><br>
///
/// \param x the vector
template<typename genType, size_t...i>
@@ -156,13 +156,13 @@ constexpr genType length2(const vector<genType, i...>& x) {
// length --------------------------------------------------------------------------------------------------------------
///
/// \brief Returns the length of vector \f$x\f$, i.e., \f$\sqrt{x_0^2 + x_1^2 + \ldots}\f$
/// \brief Returns the length of vector \math{x}, i.e., \math{\sqrt{x_0^2 + x_1^2 + \ldots}}
///
/// \returns the length of vector \f$x\f$, i.e., \f$\sqrt{x_0^2 + x_1^2 + \ldots}\f$<br><br>
/// \returns the length of vector \math{x}, i.e., \math{\sqrt{x_0^2 + x_1^2 + \ldots}}<br><br>
/// \details we can represent this in linear algebra as the following, <br><br>
/// let \f$X=\left[\begin{array}\\ x_0 \\ x_1 \\ \vdots \\ x_N \end{array}\right]\f$ <br><br>
/// let \math{X=\left[\begin{array}\\ x_0 \\ x_1 \\ \vdots \\ x_N \end{array}\right]} <br><br>
///
/// then, \f$\text{length}(X)=\left|\left|X\right|\right|\f$ <br><br>
/// then, \math{\text{length}(X)=\left|\left|X\right|\right|} <br><br>
///
/// \param x the vector
template<typename genType, size_t...i>
@@ -174,14 +174,14 @@ constexpr genType length(const vector<genType, i...>& x) {
// distance ------------------------------------------------------------------------------------------------------------
///
/// \brief Returns the length of vector \f$x\f$, i.e., \f$\sqrt{x_0^2 + x_1^2 + \ldots}\f$
/// \brief Returns the length of vector \math{x}, i.e., \math{\sqrt{x_0^2 + x_1^2 + \ldots}}
///
/// \returns the distance between \f$p_0\f$ and \f$p_1\f$, i.e., \f$\left|{p_1-p_0}\right|\f$
/// \returns the distance between \math{p_0} and \math{p_1}, i.e., \math{\left|{p_1-p_0}\right|}
/// \details we can represent this in linear algebra as the following, <br><br>
/// let \f$X=\left[\begin{array}\\ x_0 \\ x_1 \\ \vdots \\ x_N \end{array}\right]\f$ <br>
/// let \f$Y=\left[\begin{array}\\ y_0 \\ y_1 \\ \vdots \\ y_N \end{array}\right]\f$ <br><br>
/// let \math{X=\left[\begin{array}\\ x_0 \\ x_1 \\ \vdots \\ x_N \end{array}\right]} <br>
/// let \math{Y=\left[\begin{array}\\ y_0 \\ y_1 \\ \vdots \\ y_N \end{array}\right]} <br><br>
///
/// then \f$\text{distance}(X, Y)=\left|\left|Y-X\right|\right|\f$ <br><br>
/// then \math{\text{distance}(X, Y)=\left|\left|Y-X\right|\right|} <br><br>
///
/// \param p0 first vector
/// \param p1 second vector
@@ -194,16 +194,16 @@ constexpr genType distance(const vector<genType, i...>& p0, const vector<genType
// cross ---------------------------------------------------------------------------------------------------------------
///
/// \brief Returns the cross product of \f$x\f$ and \f$y\f$, i.e.,
/// \f$\left({x_1 \cdot y_2 - y_1 \cdot x_2, x_2 \cdot y_0 - y_2 \cdot x_0, x_0 \cdot y_1 - y_0 \cdot x_1}\right)\f$
/// \brief Returns the cross product of \math{x} and \math{y}, i.e.,
/// \math{\left({x_1 \cdot y_2 - y_1 \cdot x_2, x_2 \cdot y_0 - y_2 \cdot x_0, x_0 \cdot y_1 - y_0 \cdot x_1}\right)}
///
/// \returns the cross product of \f$x\f$ and \f$y\f$, i.e.,
/// \f$\left({x_1 \cdot y_2 - y_1 \cdot x_2, x_2 \cdot y_0 - y_2 \cdot x_0, x_0 \cdot y_1 - y_0 \cdot x_1}\right)\f$ <br><br>
/// \returns the cross product of \math{x} and \math{y}, i.e.,
/// \math{\left({x_1 \cdot y_2 - y_1 \cdot x_2, x_2 \cdot y_0 - y_2 \cdot x_0, x_0 \cdot y_1 - y_0 \cdot x_1}\right)} <br><br>
/// \details we can represent this in linear algebra as the following, <br><br>
/// let \f$X=\left[\begin{array}\\ x_0 \\ x_1 \\ \vdots \\ x_N \end{array}\right]\f$ <br>
/// let \f$Y=\left[\begin{array}\\ y_0 \\ y_1 \\ \vdots \\ y_N \end{array}\right]\f$ <br><br>
/// let \math{X=\left[\begin{array}\\ x_0 \\ x_1 \\ \vdots \\ x_N \end{array}\right]} <br>
/// let \math{Y=\left[\begin{array}\\ y_0 \\ y_1 \\ \vdots \\ y_N \end{array}\right]} <br><br>
///
/// then \f$\text{cross}(X, Y)=X \times Y\f$ <br><br>
/// then \math{\text{cross}(X, Y)=X \times Y} <br><br>
///
/// \param x first vector
/// \param y second vector
@@ -216,13 +216,13 @@ constexpr vector<genType, i...> cross(const vector<genType, i...>& x, const vect
// normalize -----------------------------------------------------------------------------------------------------------
///
/// \brief Returns a vector in the same direction as \f$x\f$, but with a length of \f$1\f$, i.e.
/// \brief Returns a vector in the same direction as \math{x}, but with a length of \math{1}, i.e.
///
/// \returns a vector in the same direction as \f$x\f$, but with a length of \f$1\f$, i.e.\f$\frac{x}{||x||}\f$<br><br>
/// \returns a vector in the same direction as \math{x}, but with a length of \math{1}, i.e.\math{\frac{x}{||x||}}<br><br>
/// \details we can represent this in linear algebra as the following, <br><br>
/// let \f$X=\left[\begin{array}\\ x_0 \\ x_1 \\ \vdots \\ x_N \end{array}\right]\f$ <br><br>
/// let \math{X=\left[\begin{array}\\ x_0 \\ x_1 \\ \vdots \\ x_N \end{array}\right]} <br><br>
///
/// then, \f$\text{length}(X)=\frac{X}{\left|\left|X\right|\right|}\f$ <br><br>
/// then, \math{\text{length}(X)=\frac{X}{\left|\left|X\right|\right|}} <br><br>
///
/// \param x
template<typename genType, size_t...i>
@@ -234,9 +234,9 @@ constexpr vector<genType, i...> normalize(const vector<genType, i...>& x) {
// faceforward ---------------------------------------------------------------------------------------------------------
///
/// \brief If \f$\text{dot}(Nref, I)<0\f$ return \f$N\f$, otherwise return \f$-N\f$.
/// \brief If \math{\text{dot}(Nref, I)<0} return \math{N}, otherwise return \math{-N}.
///
/// \returns \f$N\f$ if \f$\text{dot}(Nref,I)<0\f$, otherwise, returns \f$-N\f$.<br><br>
/// \returns \math{N} if \math{\text{dot}(Nref,I)<0}, otherwise, returns \math{-N}.<br><br>
///
/// \param N the vector
/// \param I the incident
@@ -250,11 +250,11 @@ constexpr vector<genType, i...> faceforward(const vector<genType, i...>& N, cons
// reflect -------------------------------------------------------------------------------------------------------------
///
/// \brief For the incident vector \f$I\f$ and surface orientation \f$N\f$, returns the reflection direction.
/// \brief For the incident vector \math{I} and surface orientation \math{N}, returns the reflection direction.
///
/// \returns The reflection direction, given the incident vector \f$I\f$ and surface orientation \f$N\f$ <br><br>
/// \returns The reflection direction, given the incident vector \math{I} and surface orientation \math{N} <br><br>
/// \details We can express this as, <br><br>
/// \f$\text{reflect}(I, N) = I - 2 N \cdot \text{dot}(N, I)\f$ <br><br>
/// \math{\text{reflect}(I, N) = I - 2 N \cdot \text{dot}(N, I)} <br><br>
///
/// \param I the incident
/// \param N the surface orientation
@@ -266,13 +266,13 @@ constexpr vector<genType, i...> reflect(const vector<genType, i...>& I, const ve
// refract -------------------------------------------------------------------------------------------------------------
///
/// \brief For the incident vector \f$I\f$ and surface normal \f$N\f$, and the ratio of indices of refraction \f$eta\f$,
/// \brief For the incident vector \math{I} and surface normal \math{N}, and the ratio of indices of refraction \math{eta},
/// return the refraction vector.
///
/// \returns The refraction vector, given the incident vector \f$I\f$, surface normal \f$N\f$, and ratio \f$eta\f$.<br><br>
/// \returns The refraction vector, given the incident vector \math{I}, surface normal \math{N}, and ratio \math{eta}.<br><br>
/// \details The result is computed by the refraction equation, <br><br>
/// let \f$k=1.0-eta^2 \cdot (1.0 - \text{dot}(N, I)^2)\f$ <br>
/// then, \f$\text{refract}(I, N, eta)=\begin{cases} 0.0 & k<0.0, \\ eta \cdot I - N \cdot (eta \cdot \text{dot}(N, I) + \sqrt{k}) \end{cases}\f$ <br><br>
/// let \math{k=1.0-eta^2 \cdot (1.0 - \text{dot}(N, I)^2)} <br>
/// then, \math{\text{refract}(I, N, eta)=\begin{cases} 0.0 & k<0.0, \\ eta \cdot I - N \cdot (eta \cdot \text{dot}(N, I) + \sqrt{k}) \end{cases}} <br><br>
///
/// \param I the incident
/// \param N the surface normal

56
include/fennec/math/matrix.h
View File

@@ -56,10 +56,10 @@ namespace fennec
///
/// \brief returns a **copy** of the column \f$i\f$ of matrix \f$m\f$
/// \brief returns a **copy** of the column \emph{i} of matrix \emph{m}
/// \param m the matrix
/// \param i the index of the row
/// \returns a **copy** of the column at index \f$i\f$
/// \returns a **copy** of the column at index \emph{i}
template<typename scalar, size_t rows, size_t...cols>
constexpr vec<scalar, rows> column(const matrix<scalar, rows, cols...>& m, size_t i) noexcept {
return m[i];
@@ -67,10 +67,10 @@ constexpr vec<scalar, rows> column(const matrix<scalar, rows, cols...>& m, size_
///
/// \brief returns a **copy** of the row \f$i\f$ of matrix \f$m\f$
/// \brief returns a **copy** of the row \emph{i} of matrix \emph{m}
/// \param m the matrix
/// \param i the index of the row
/// \returns a **copy** of the row at index \f$i\f$
/// \returns a **copy** of the row at index \emph{i}
template<typename scalar, size_t rows, size_t...cols>
constexpr vec<scalar, sizeof...(cols)> row(const matrix<scalar, rows, cols...>& m, size_t i) noexcept {
return vec<scalar, sizeof...(cols)>(m[cols][i]...);
@@ -118,7 +118,7 @@ using dmat4x4 = tmat4x4<double_t>; //!< Specification for size glsl double matri
///
/// \brief Multiply matrix \f$x\f$ by matrix \f$y\f$ component-wise.
/// \brief Multiply matrix \emph{x} by matrix \emph{y} component-wise.
/// \details Multiply matrix x by matrix y component-wise, i.e., result[i][j] is the scalar product of x[i][j] and y[i][j].<br><br>
/// Note: to get linear algebraic matrix multiplication, use
/// the multiply operator (*)
@@ -131,14 +131,14 @@ constexpr matrix<scalar, rows, cols...> matrixCompMult(const matrix<scalar, rows
}
///
/// \brief Performs a linear algebraic multiply, multiplying \f$c\f$ by the components of \f$r\f$, producing a matrix.
/// \brief Performs a linear algebraic multiply, multiplying \emph{c} by the components of \emph{r}, producing a matrix.
///
/// \details Treats the first parameter \f$c\f$ as a column vector (matrix
/// with one column) and the second parameter \f$r\f$ as a row
/// \details Treats the first parameter \emph{c} as a column vector (matrix
/// with one column) and the second parameter \emph{r} as a row
/// vector (matrix with one row) and does a linear algebraic
/// matrix multiply \f$c \cross r\f$, yielding a matrix whose number of
/// rows is the number of components in \f$c\f$ and whose
/// number of columns is the number of components in \f$r\f$.
/// matrix multiply \emph{c \cross r}, yielding a matrix whose number of
/// rows is the number of components in \emph{c} and whose
/// number of columns is the number of components in \emph{r}.
/// \param c the column vector
/// \param r the row vector
/// \returns the resulting matrix produced by the linear algebraic product
@@ -150,9 +150,9 @@ constexpr matrix<scalar, sizeof...(s0), s1...> outerProduct(const vector<scalar,
}
///
/// \brief get the transpose of \f$m\f$
/// \brief get the transpose of \emph{m}
/// \param m the matrix to transpose
/// \returns a matrix that is the transpose of \f$m\f$
/// \returns a matrix that is the transpose of \emph{m}
/// \details The input matrix m is not modified.
template<typename scalar, size_t rows, size_t...cols>
constexpr mat<scalar, rows, sizeof...(cols)> transpose(const matrix<scalar, rows, cols...>& m) noexcept {
@@ -160,7 +160,7 @@ constexpr mat<scalar, rows, sizeof...(cols)> transpose(const matrix<scalar, rows
}
///
/// \brief Returns the determinant of \f$m\f$.
/// \brief Returns the determinant of \emph{m}.
/// \returns the determinant of m.
template<typename scalar, size_t rows, size_t...cols>
constexpr scalar determinant(const matrix<scalar, rows, cols...>&) noexcept {
@@ -169,8 +169,8 @@ constexpr scalar determinant(const matrix<scalar, rows, cols...>&) noexcept {
}
///
/// \brief Returns the determinant of \f$m\f$.
/// \returns \f$m^{-1}\f$
/// \brief Returns the determinant of \emph{m}.
/// \returns \math{\textbf{m}^{-1}}
template<typename scalar, size_t rows, size_t...cols>
constexpr matrix<scalar, rows, cols...> inverse(const matrix<scalar, rows, cols...>&) noexcept {
static_assert(false, "implementation undefined");
@@ -295,7 +295,7 @@ struct matrix
/// \brief scalar constructor, initializes a diagonal matrix with a scale of \p s
///
/// \details
/// This function creates a diagonal matrix such that ```vec3(2.0f)``` would result in a matrix
/// This function creates a diagonal matrix such that `(.*?)` would result in a matrix
/// <table>
/// <caption id="fennec_table_matrix_diagonal"></caption>
/// <tr><th> <th> 0 <th> 1 <th> 2
@@ -359,17 +359,17 @@ struct matrix
///
/// \details
/// \param i the index
/// \returns the column at index \f$i\f$
/// \returns the column at index \emph{i}
constexpr column_t& operator[](size_t i) {
return data[i];
}
///
/// \brief returns the column at index \f$i\f$
/// \brief returns the column at index \emph{i}
///
/// \details
/// \param i the index
/// \returns the column at index \f$i\f$
/// \returns the column at index \emph{i}
constexpr const column_t& operator[](size_t i) const {
return data[i];
}
@@ -378,7 +378,7 @@ struct matrix
/// \details
/// \param i the column
/// \param j the row
/// \returns the element in column \f$i\f$, row \f$j\f$
/// \returns the element in column \emph{i}, row \emph{j}
constexpr scalar_t& operator[](size_t i, size_t j) {
return data[i][j];
}
@@ -389,7 +389,7 @@ struct matrix
/// \details
/// \param i the column
/// \param j the row
/// \returns the element in column \f$i\f$, row \f$j\f$
/// \returns the element in column \emph{i}, row \emph{j}
constexpr scalar_t operator[](size_t i, size_t j) const {
return data[i][j];
}
@@ -610,7 +610,7 @@ struct matrix
/// \brief performs a linear algebraic multiply
/// \param lhs the matrix
/// \param rhs the vector
/// \returns a vector containing the dot products of \f$rhs\f$ with each row of \f$lhs\f$
/// \returns a vector containing the dot products of \emph{rhs} with each row of \emph{lhs}
constexpr friend column_t operator*(const matrix_t& lhs, const row_t& rhs) {
return _mul(lhs, rhs);
}
@@ -619,7 +619,7 @@ struct matrix
/// \brief performs a linear algebraic multiply
/// \param lhs the vector
/// \param rhs the matrix
/// \returns a vector containing the dot products of \f$lhs\f$ with each column of \f$rhs\f$
/// \returns a vector containing the dot products of \emph{lhs} with each column of \emph{rhs}
constexpr friend row_t operator*(const column_t& lhs, const matrix_t& rhs) {
return row_t(fennec::dot(fennec::column(rhs, ColIndicesV), lhs) ...);
}
@@ -637,7 +637,7 @@ struct matrix
/// \brief matrix comparison operator
/// \param lhs the first matrix
/// \param rhs the second matrix
/// \returns a boolean value that contains \f$true\f$ when all components of \f$lhs\f$ and \f$rhs\f$ are equal and \f$false\f$ otherwise
/// \returns a boolean value that contains \emph{true} when all components of \emph{lhs} and \emph{rhs} are equal and \emph{false} otherwise
constexpr friend bool operator==(const matrix_t& lhs, const matrix_t& rhs) {
return lhs.data == rhs.data;
}
@@ -646,7 +646,7 @@ struct matrix
/// \brief matrix comparison operator
/// \param lhs the first matrix
/// \param rhs the second matrix
/// \returns a boolean value that contains \f$true\f$ when all components of \f$lhs\f$ and \f$rhs\f$ are not equal and \f$false\f$ otherwise
/// \returns a boolean value that contains \emph{true} when all components of \emph{lhs} and \emph{rhs} are not equal and \emph{false} otherwise
constexpr friend bool operator!=(const matrix_t& lhs, const matrix_t& rhs) {
return lhs.data != rhs.data;
}
@@ -666,7 +666,7 @@ struct matrix
///
/// \brief performs a linear algebraic matrix multiplication assignment
/// \param rhs the columns to multiply with
/// \returns a reference to self
/// \returns a reference to \emph{this}
template<size_t ORowsV, size_t...OColIndicesV> requires(columns == ORowsV)
constexpr matrix<scalar_t, RowsV, OColIndicesV...>& operator*=(const matrix<scalar_t, ORowsV, OColIndicesV...>& rhs) {
return *this = *this * rhs;
@@ -682,7 +682,7 @@ public:
///
/// \param mat the matrix to transpose
/// \returns \f$m^T\f$
/// \returns \math{\textbf{m}^T}
static constexpr matrix_t transpose(const transpose_t& mat) {
return matrix_t(fennec::row(mat, ColIndicesV)...);
}

14
include/fennec/math/relational.h
View File

@@ -103,7 +103,7 @@
/// \ref fennec_vector_not "bool not(bvec x)"<br>
/// <td width="50%" style="vertical-align: top">
/// \details
/// \returns the component-wise logical complement of \f$x\f$. <br>
/// \returns the component-wise logical complement of \math{x}. <br>
/// \param x the boolean vector to inverse <br>
///
/// </table>
@@ -189,9 +189,9 @@ constexpr vector<genBType, i...> notEqual(const vector<genType, i...>& x, const
///
/// \brief Returns \f$true\f$ if any component of \f$x\f$ is \f$true\f$
/// \brief Returns \math{true} if any component of \math{x} is \math{true}
///
/// \returns \f$true\f$ if any component of \f$x\f$ is \f$true\f$
/// \returns \math{true} if any component of \math{x} is \math{true}
/// \param x the boolean vector to test
template<typename genBType = bool_t, size_t...i>
constexpr genBType any(const vector<genBType, i...>& x) {
@@ -199,9 +199,9 @@ constexpr genBType any(const vector<genBType, i...>& x) {
}
///
/// \brief Returns \f$true\f$ if all components of \f$x\f$ are \f$true\f$
/// \brief Returns \math{true} if all components of \math{x} are \math{true}
///
/// \returns \f$true\f$ if all components of \f$x\f$ are \f$true\f$
/// \returns \math{true} if all components of \math{x} are \math{true}
/// \param x the boolean vector to test
template<typename genBType = bool_t, size_t...i>
constexpr genBType all(const vector<genBType, i...>& x) {
@@ -210,10 +210,10 @@ constexpr genBType all(const vector<genBType, i...>& x) {
///
/// \anchor fennec_vector_not
/// \brief Returns the component-wise logical complement of \f$x\f$.
/// \brief Returns the component-wise logical complement of \math{x}.
///
/// \details
/// \returns the component-wise logical complement of \f$x\f$.
/// \returns the component-wise logical complement of \math{x}.
/// \param x the boolean vector to inverse
template<typename genBType = bool_t, size_t...i>
constexpr vector<genBType, i...> operator not(const vector<genBType, i...>& x) {

2
include/fennec/math/scalar.h
View File

@@ -41,7 +41,7 @@
///
/// \code #include <fennec/math/scalar.h> \endcode
///
/// The fennecLibrary considers any type that passes ```is_arithmetic<T>``` to be a \ref scalar "Scalar." Bools are
/// The fennecLibrary considers any type that passes `(.*?)` to be a \ref scalar "Scalar." Bools are
/// supported as a logical type.
///
/// The GLSL Specification, and fennecrespectively, defines the following scalar types:

92
include/fennec/math/trigonometric.h
View File

@@ -157,13 +157,13 @@ namespace fennec
/// @{
///
/// \brief Converts \f$degrees\f$ to \f$radians\f$, i.e., \f$degrees\cdot\frac{180}{\pi}\f$
/// \brief Converts \emph{degrees} to \emph{radians}, i.e., \math{degrees\cdot\frac{180}{\pi}}
///
/// \returns the angle \f$\theta\f$ in \f$radians\f$ <br><br>
/// \details Converts \f$degrees\f$ to \f$radians\f$, i.e., \f$degrees\cdot\frac{180}{\pi}\f$ <br><br>
/// \returns the angle \math{\theta} in \math{radians} <br><br>
/// \details Converts \emph{degrees} to \emph{radians}, i.e., \math{degrees\cdot\frac{180}{\pi}} <br><br>
///
/// \tparam genType floating point type
/// \param degrees the angle \f$\theta\f$ in \f$degrees\f$
/// \param degrees the angle \math{\theta} in \math{degrees}
template<typename genType>
constexpr genType radians(genType degrees) {
return genType(degrees * 0.01745329251994329576923690768489);
@@ -171,13 +171,13 @@ constexpr genType radians(genType degrees) {
///
/// \brief Converts \f$radians\f$ to \f$degrees\f$, i.e., \f$radians\cdot\frac{\pi}{180}\f$
/// \brief Converts \emph{radians} to \emph{degrees}, i.e., \math{radians\cdot\frac{\pi}{180}}
///
/// \returns the angle \f$\theta\f$ in \f$degrees\f$ <br><br>
/// \details Converts \f$radians\f$ to \f$degrees\f$, i.e., \f$radians\cdot\frac{\pi}{180}\f$ <br><br>
/// \returns the angle \math{\theta} in \emph{degrees} <br><br>
/// \details Converts \emph{radians} to \emph{degrees}, i.e., \math{radians\cdot\frac{\pi}{180}} <br><br>
///
/// \tparam genType floating point type
/// \param radians the angle \f$\theta\f$ in \f$radians\f$
/// \param radians the angle \math{\theta} in \emph{radians}
template<typename genType>
constexpr genType degrees(genType radians) {
return genType(radians * 57.29577951308232087679815481410517);
@@ -195,11 +195,11 @@ constexpr genType degrees(genType radians) {
///
/// \brief The standard trigonometric sine
///
/// \returns the sine of \f$\theta\f$ in the range \f$\left[-1,\,1\right]\f$ <br><br>
/// \returns the sine of \math{\theta} in the range \math{\left[-1,\,1\right]} <br><br>
/// \details The standard trigonometric sine <br><br>
///
/// \tparam genType floating point type
/// \param x the angle \f$\theta\f$ in \f$radians\f$
/// \param x the angle \math{\theta} in \math{radians}
template<typename genType>
constexpr genType sin(genType x) {
return ::sin(x);
@@ -209,11 +209,11 @@ constexpr genType sin(genType x) {
///
/// \brief The Standard Trigonometric Cosine
///
/// \returns the cosine of \f$\theta\f$ in the range \f$\left[-1,\,1\right]\f$ <br><br>
/// \returns the cosine of \math{\theta} in the range \math{\left[-1,\,1\right]} <br><br>
/// \details The Standard Trigonometric Cosine <br><br>
///
/// \tparam genType floating point type
/// \param x the angle \f$\theta\f$ in \f$radians\f$
/// \param x the angle \math{\theta} in \emph{radians}
template<typename genType>
constexpr genType cos(genType x) {
return ::cos(x);
@@ -223,11 +223,11 @@ constexpr genType cos(genType x) {
///
/// \brief The Standard Trigonometric Tangent
///
/// \returns The Tangent of \f$\theta\f$ in the Range \f$\left[-\inf,\,\inf\right]\f$<br><br>
/// \returns The Tangent of \math{\theta} in the Range \math{\left[-\inf,\,\inf\right]}<br><br>
/// \details The Standard Trigonometric Tangent <br><br>
///
/// \tparam genType floating point type
/// \param x The Angle \f$\theta\f$ in \f$radians\f$
/// \param x The Angle \math{\theta} in \math{radians}
template<typename genType>
constexpr genType tan(genType x) {
return ::tan(x);
@@ -241,14 +241,14 @@ constexpr genType tan(genType x) {
/// @{
///
/// \brief Arc Sine. Returns an angle \f$\theta\f$ whose sine is /a x.
/// \brief Arc Sine. Returns an angle \math{\theta} whose sine is /a x.
///
/// \returns an angle \f$\theta\f$ whose sine is /a x. <br><br>
/// \returns an angle \math{\theta} whose sine is /a x. <br><br>
/// \details Arc Sine. The range of values returned by this functions is
/// \f$\left[-\pi/2,\pi/2\right]\f$. Results are undefined if \f$\left|x\right|\,>\,1\f$. <br><br>
/// \math{\left[-\pi/2,\pi/2\right]}. Results are undefined if \math{\left|x\right|\,>\,1}. <br><br>
///
/// \tparam genType floating point type
/// \param x The Sine Value produced by \f$\theta\f$
/// \param x The Sine Value produced by \math{\theta}
template<typename genType>
constexpr genType asin(genType x) {
return ::asin(x);
@@ -256,14 +256,14 @@ constexpr genType asin(genType x) {
///
/// \brief Arc Cosine. Returns an angle \f$\theta\f$ whose cosine is /a x.
/// \brief Arc Cosine. Returns an angle \math{\theta} whose cosine is /a x.
///
/// \returns an angle \f$\theta\f$ whose cosine is /a x.
/// \returns an angle \math{\theta} whose cosine is /a x.
/// \details Arc Cosine. The range of values returned by this functions is
/// \f$\left[0,\pi\right]\f$. Results are undefined if \f$\left|x\right|\,>\,1\f$.
/// \math{\left[0,\pi\right]}. Results are undefined if \math{\left|x\right|\,>\,1}.
///
/// \tparam genType floating point type
/// \param x The Cosine Value produced by \f$\theta\f$
/// \param x The Cosine Value produced by \math{\theta}
template<typename genType>
constexpr genType acos(genType x) {
return ::acos(x);
@@ -271,14 +271,14 @@ constexpr genType acos(genType x) {
///
/// \brief Arc Tangent. Returns an angle \f$\theta\f$ whose tangent is /a y_over_x.
/// \brief Arc Tangent. Returns an angle \math{\theta} whose tangent is /a y_over_x.
///
/// \returns an angle \f$\theta\f$ whose tangent is /a y_over_x.
/// \returns an angle \math{\theta} whose tangent is /a y_over_x.
/// \details Arc Tangent. The range of values returned by this functions is
/// \f$\left[\frac{-\pi}{2},\frac{\pi}{2}\right]\f$. Results are undefined if \f$\left|x\right|\,>\,1\f$.
/// \math{\left[\frac{-\pi}{2},\frac{\pi}{2}\right]}. Results are undefined if \math{\left|x\right|\,>\,1}.
///
/// \tparam genType floating point type
/// \param y_over_x The Cosine Value produced by \f$\theta\f$
/// \param y_over_x The Cosine Value produced by \math{\theta}
template<typename genType>
constexpr genType atan(genType y_over_x) {
return ::atan(y_over_x);
@@ -286,15 +286,15 @@ constexpr genType atan(genType y_over_x) {
///
/// \brief Arc Tangent. Returns an angle whose tangent is \f$\frac{y}{x}\f$.
/// \brief Arc Tangent. Returns an angle whose tangent is \math{\frac{y}{x}}.
///
/// \returns an angle whose tangent is \f$\frac{y}{x}\f$. <br><br>
/// \returns an angle whose tangent is \math{\frac{y}{x}}. <br><br>
/// \details Arc Tangent. The signs of \a x and \a y are used to determine what quadrant the angle is in.
/// The range of values returned by this functions is \f$\left[-\pi,\pi\right]\f$ <br><br>
/// The range of values returned by this functions is \math{\left[-\pi,\pi\right]} <br><br>
///
/// \tparam genType floating point type
/// \param y The Sine Value produced by \f$\theta\f$
/// \param x The Cosine Value produced by \f$\theta\f$
/// \param y The Sine Value produced by \math{\theta}
/// \param x The Cosine Value produced by \math{\theta}
template<typename genType>
constexpr genType atan(genType y, genType x) {
return ::atan2(y, x);
@@ -310,12 +310,12 @@ constexpr genType atan(genType y, genType x) {
/// @{
///
/// \brief Returns the Hyperbolic Sine Function, \f$\frac{{e}^{x}-{e}^{-x}}{2}\f$
/// \brief Returns the Hyperbolic Sine Function, \math{\frac{{e}^{x}-{e}^{-x}}{2}}
///
/// \returns The Hyperbolic Sine of \f$x\f$, \f$\frac{{e}^{x}-{e}^{-x}}{2}\f$ <br><br>
/// \returns The Hyperbolic Sine of \math{x}, \math{\frac{{e}^{x}-{e}^{-x}}{2}} <br><br>
///
/// \tparam genType floating point type
/// \param x The Hyperbolic Angle \f$\alpha\f$
/// \param x The Hyperbolic Angle \math{\alpha}
template<typename genType>
constexpr genType sinh(genType x) {
return ::sinh(x);
@@ -323,11 +323,11 @@ constexpr genType sinh(genType x) {
///
/// \brief Returns the Hyperbolic Cosine Function, \f$\frac{{e}^{x}+{e}^{-x}}{2}\f$
/// \brief Returns the Hyperbolic Cosine Function, \math{\frac{{e}^{x}+{e}^{-x}}{2}}
///
/// \returns The Hyperbolic Cosine of \f$x\f$, \f$\frac{{e}^{x}+{e}^{-x}}{2}\f$ <br><br>
/// \returns The Hyperbolic Cosine of \math{x}, \math{\frac{{e}^{x}+{e}^{-x}}{2}} <br><br>
///
/// \param x The Hyperbolic Angle \f$\alpha\f$
/// \param x The Hyperbolic Angle \math{\alpha}
template<typename genType>
constexpr genType cosh(genType x) {
return ::cosh(x);
@@ -335,11 +335,11 @@ constexpr genType cosh(genType x) {
///
/// \brief Returns the Hyperbolic Tangent Function, \f$\frac{\text{sinh}(x)}{\text{cosh}(x)}\f$
/// \brief Returns the Hyperbolic Tangent Function, \math{\frac{\text{sinh}(x)}{\text{cosh}(x)}}
///
/// \returns The Hyperbolic Tangent of \f$x\f$, \f$\frac{{e}^{x}+{e}^{-x}}{2}\f$ <br><br>
/// \returns The Hyperbolic Tangent of \math{x}, \math{\frac{{e}^{x}+{e}^{-x}}{2}} <br><br>
///
/// \param x The Hyperbolic Angle \f$\alpha\f$
/// \param x The Hyperbolic Angle \math{\alpha}
template<typename genType, size_t...i>
constexpr genType tanh(genType x) {
return ::tanh(x);
@@ -355,10 +355,10 @@ constexpr genType tanh(genType x) {
///
/// \brief The Inverse Hyperbolic Sine Function
///
/// \returns the value \f$y\f$ that fulfills \f$x=\text{sinh}(y)\f$ <br><br>
/// \returns the value \math{y} that fulfills \math{x=\text{sinh}(y)} <br><br>
/// \details The Inverse Hyperbolic Sine Function <br><br>
///
/// \param x the hyperbolic angle \f$\alpha\f$
/// \param x the hyperbolic angle \math{\alpha}
template<typename genType, size_t...i>
constexpr genType asinh(genType x) {
return ::asinh(x);
@@ -368,10 +368,10 @@ constexpr genType asinh(genType x) {
///
/// \brief The Inverse Hyperbolic Cosine Function
///
/// \returns the value \f$y\f$ that fulfills \f$x=\text{cosh}(y)\f$ <br><br>
/// \returns the value \math{y} that fulfills \math{x=\text{cosh}(y)} <br><br>
/// \details The Inverse Hyperbolic Cosine Function <br><br>
///
/// \param x the hyperbolic angle \f$\alpha\f$
/// \param x the hyperbolic angle \math{\alpha}
template<typename genType, size_t...i>
constexpr genType acosh(genType x) {
return ::acosh(x);
@@ -381,10 +381,10 @@ constexpr genType acosh(genType x) {
///
/// \brief The Inverse Hyperbolic Tangent Function
///
/// \returns the value \f$y\f$ that fulfills \f$x=\text{atanh}(y)\f$ <br><br>
/// \returns the value \math{y} that fulfills \math{x=\text{atanh}(y)} <br><br>
/// \details The Inverse Hyperbolic Tangent Function <br><br>
///
/// \param x The Hyperbolic Angle \f$\alpha\f$
/// \param x The Hyperbolic Angle \math{\alpha}
template<typename genType, size_t...i>
constexpr genType atanh(genType x) {
return ::atanh(x);

170
include/fennec/math/vector.h
View File

@@ -46,33 +46,33 @@
/// <table width="100%" class="fieldtable" id="table_fennec_math_vector_types">
/// <tr><th>Type <th>Corresponding Type <th>Brief
/// <tr><th colspan=3 style="text-align: center;">Floats
/// <tr><td>``\f$vec2\f$`` <td>\ref fennec::vec2 <td>\copybrief fennec::vec2
/// <tr><td>``\f$vec3\f$`` <td>\ref fennec::vec3 <td>\copybrief fennec::vec3
/// <tr><td>``\f$vec4\f$`` <td>\ref fennec::vec4 <td>\copybrief fennec::vec4
/// <tr><td>``\emph{vec2}`` <td>\ref fennec::vec2 <td>\copybrief fennec::vec2
/// <tr><td>``\emph{vec3}`` <td>\ref fennec::vec3 <td>\copybrief fennec::vec3
/// <tr><td>``\emph{vec4}`` <td>\ref fennec::vec4 <td>\copybrief fennec::vec4
/// <tr><th colspan=3 style="text-align: center;">Doubles
/// <tr><td>``\f$dvec2\f$``<td>\ref fennec::dvec2 <td>\copybrief fennec::dvec2
/// <tr><td>``\f$dvec3\f$``<td>\ref fennec::dvec3 <td>\copybrief fennec::dvec3
/// <tr><td>``\f$dvec4\f$``<td>\ref fennec::dvec4 <td>\copybrief fennec::dvec4
/// <tr><td>``\emph{dvec2}``<td>\ref fennec::dvec2 <td>\copybrief fennec::dvec2
/// <tr><td>``\emph{dvec3}``<td>\ref fennec::dvec3 <td>\copybrief fennec::dvec3
/// <tr><td>``\emph{dvec4}``<td>\ref fennec::dvec4 <td>\copybrief fennec::dvec4
/// <tr><th colspan=3 style="text-align: center;">Booleans
/// <tr><td>``\f$bvec2\f$`` <td>\ref fennec::bvec2 <td>\copybrief fennec::bvec2
/// <tr><td>``\f$bvec3\f$`` <td>\ref fennec::bvec3 <td>\copybrief fennec::bvec3
/// <tr><td>``\f$bvec4\f$`` <td>\ref fennec::bvec4 <td>\copybrief fennec::bvec4
/// <tr><td>``\emph{bvec2}`` <td>\ref fennec::bvec2 <td>\copybrief fennec::bvec2
/// <tr><td>``\emph{bvec3}`` <td>\ref fennec::bvec3 <td>\copybrief fennec::bvec3
/// <tr><td>``\emph{bvec4}`` <td>\ref fennec::bvec4 <td>\copybrief fennec::bvec4
/// <tr><th colspan=3 style="text-align: center;">Integers
/// <tr><td>``\f$ivec2\f$`` <td>\ref fennec::ivec2 <td>\copybrief fennec::ivec2
/// <tr><td>``\f$ivec3\f$`` <td>\ref fennec::ivec3 <td>\copybrief fennec::ivec3
/// <tr><td>``\f$ivec4\f$`` <td>\ref fennec::ivec4 <td>\copybrief fennec::ivec4
/// <tr><td>``\emph{ivec2}`` <td>\ref fennec::ivec2 <td>\copybrief fennec::ivec2
/// <tr><td>``\emph{ivec3}`` <td>\ref fennec::ivec3 <td>\copybrief fennec::ivec3
/// <tr><td>``\emph{ivec4}`` <td>\ref fennec::ivec4 <td>\copybrief fennec::ivec4
/// <tr><th colspan=3 style="text-align: center;">Unsigned Integers
/// <tr><td>``\f$uvec2\f$`` <td>\ref fennec::uvec2 <td>\copybrief fennec::uvec2
/// <tr><td>``\f$uvec3\f$`` <td>\ref fennec::uvec3 <td>\copybrief fennec::uvec3
/// <tr><td>``\f$uvec4\f$`` <td>\ref fennec::uvec4 <td>\copybrief fennec::uvec4
/// <tr><td>``\emph{uvec2}`` <td>\ref fennec::uvec2 <td>\copybrief fennec::uvec2
/// <tr><td>``\emph{uvec3}`` <td>\ref fennec::uvec3 <td>\copybrief fennec::uvec3
/// <tr><td>``\emph{uvec4}`` <td>\ref fennec::uvec4 <td>\copybrief fennec::uvec4
/// </table>
///
///
///
/// \section vector_components Components
///
/// Vectors are usually made up of one to four components, named ``\f$x\f$``, ``\f$y\f$``, ``\f$z\f$``, and ``\f$w\f$``.
/// Each component also has aliases for usage in colors ``\f$rgba\f$``, and texture coordinates ``\f$stpq\f$``. Accessing a
/// Vectors are usually made up of one to four components, named \math{x}, \math{y}, \math{z}, and \math{w}.
/// Each component also has aliases for usage in colors \math{rgba}, and texture coordinates \math{stpq}. Accessing a
/// component outside the vector will cause an error at compile time, for example:
///
/// \code{.cpp}
@@ -93,9 +93,9 @@
/// The fennec \ref fennec_math_vector allows for the "swizzling" of vectors. Each component in the vector can be
/// used in any combination, with up to 4 components, to create another vector. For example, <br><br>
///
/// let \f$V = (0, 1, 2)\f$
/// then \f$V.xy = (0, 1)\f$
/// and \f$V.zy = (2, 1)\f$
/// let \math{V = (0, 1, 2)}
/// then \math{V.xy = (0, 1)}
/// and \math{V.zy = (2, 1)}
///
/// \section section_vectors_more More Info
/// - \subpage fennec_math_vector_traits
@@ -125,22 +125,22 @@ using vec = decltype(detail::_gen_vector<vector, ScalarT>(make_index_metasequenc
///
/// \brief Shorthand for creating a 2-element \ref fennec::vector, ```vec<ScalarT, 2>```
/// \details Shorthand for creating a 2-element \ref fennec::vector, ```vec<ScalarT, 2>```
/// \brief Shorthand for creating a 2-element \ref fennec::vector, `(.*?)`
/// \details Shorthand for creating a 2-element \ref fennec::vector, `(.*?)`
/// \tparam ScalarT The type of the Components
template<typename ScalarT>
using tvec2 = vec<ScalarT, 2>;
///
/// \brief Shorthand for creating a 3-element \ref fennec::vector, ```vec<ScalarT, 3>```
/// \details Shorthand for creating a 3-element \ref fennec::vector, ```vec<ScalarT, 3>```
/// \brief Shorthand for creating a 3-element \ref fennec::vector, `(.*?)`
/// \details Shorthand for creating a 3-element \ref fennec::vector, `(.*?)`
/// \tparam ScalarT The type of the Components
template<typename ScalarT>
using tvec3 = vec<ScalarT, 3>;
///
/// \brief Shorthand for creating a 4-element \ref fennec::vector, ```vec<ScalarT, 4>```
/// \details Shorthand for creating a 4-element \ref fennec::vector, ```vec<ScalarT, 4>```
/// \brief Shorthand for creating a 4-element \ref fennec::vector, `(.*?)`
/// \details Shorthand for creating a 4-element \ref fennec::vector, `(.*?)`
/// \tparam ScalarT The type of the Components
template<typename ScalarT>
using tvec4 = vec<ScalarT, 4>;
@@ -377,7 +377,7 @@ struct vector : detail::vector_base_type<ScalarT, sizeof...(IndicesV)>
/// \brief decay implementation
///
/// \details
/// \returns scalar if \f$N==1\f$, otherwise, \ref fennec_math_vector "vector"
/// \returns scalar if \math{N==1}, otherwise, \ref fennec_math_vector "vector"
decay_t decay() {
return static_cast<const decay_t&>(*this);
}
@@ -418,7 +418,7 @@ struct vector : detail::vector_base_type<ScalarT, sizeof...(IndicesV)>
/// \brief copy assignment
///
/// \details
/// \returns A reference to \c this, after having set \p lhs, such that \f$lhs_i=rhs_i\f$
/// \returns A reference to \c this, after having set \p lhs, such that \math{lhs_i=rhs_i}
/// \param rhs vector to copy
constexpr vector_t& operator=(const vector_t& rhs) {
return ((data[IndicesV] = rhs[IndicesV]), ..., *this);
@@ -428,7 +428,7 @@ struct vector : detail::vector_base_type<ScalarT, sizeof...(IndicesV)>
/// \brief move assignment
///
/// \details
/// \returns A reference to \c this, after having set \p lhs, such that \f$lhs_i=rhs_i\f$
/// \returns A reference to \c this, after having set \p lhs, such that \math{lhs_i=rhs_i}
/// \param rhs vector to move
constexpr vector_t& operator=(vector_t&& rhs) noexcept {
return ((data[IndicesV] = fennec::move(rhs[IndicesV])), ..., *this);
@@ -474,7 +474,7 @@ struct vector : detail::vector_base_type<ScalarT, sizeof...(IndicesV)>
/// \brief \ref fennec_math_scalar "scalar" - \ref fennec_math_vector "vector" addition operator
///
/// \details
/// \returns A \ref fennec_math_vector "vector" \a v such that, \f$v_i=lhs_i+rhs_i\f$
/// \returns A \ref fennec_math_vector "vector" \a v such that, \math{v_i=lhs_i+rhs_i}
/// \param lhs left hand side
/// \param rhs right hand side
constexpr friend vector_t operator+(scalar_t lhs, const vector_t& rhs) {
@@ -485,7 +485,7 @@ struct vector : detail::vector_base_type<ScalarT, sizeof...(IndicesV)>
/// \brief \ref fennec_math_scalar "scalar" - \ref fennec_math_vector "vector" subtraction operator
///
/// \details
/// \returns A \ref fennec_math_vector "vector" \a v such that, \f$v_i=lhs_i-rhs_i\f$
/// \returns A \ref fennec_math_vector "vector" \a v such that, \math{v_i=lhs_i-rhs_i}
/// \param lhs left hand side
/// \param rhs right hand side
constexpr friend vector_t operator-(scalar_t lhs, const vector_t& rhs) {
@@ -496,7 +496,7 @@ struct vector : detail::vector_base_type<ScalarT, sizeof...(IndicesV)>
/// \brief \ref fennec_math_scalar "scalar" - \ref fennec_math_vector "vector" multiplication operator
///
/// \details
/// \returns A \ref fennec_math_vector "vector" \a v such that, \f$v_i={lhs_i}\cdot{rhs_i}\f$
/// \returns A \ref fennec_math_vector "vector" \a v such that, \math{v_i={lhs_i}\cdot{rhs_i}}
/// \param lhs left hand side
/// \param rhs right hand side
constexpr friend vector_t operator*(scalar_t lhs, const vector_t& rhs) {
@@ -507,7 +507,7 @@ struct vector : detail::vector_base_type<ScalarT, sizeof...(IndicesV)>
/// \brief \ref fennec_math_scalar "scalar" - \ref fennec_math_vector "vector" division operator
///
/// \details
/// \returns A \ref fennec_math_vector "vector" \a v such that, \f$v_i=\frac{lhs_i}{rhs_i}\f$
/// \returns A \ref fennec_math_vector "vector" \a v such that, \math{v_i=\frac{lhs_i}{rhs_i}}
/// \param lhs left hand side
/// \param rhs right hand side
constexpr friend vector_t operator/(scalar_t lhs, const vector_t& rhs) {
@@ -518,7 +518,7 @@ struct vector : detail::vector_base_type<ScalarT, sizeof...(IndicesV)>
/// \brief \ref fennec_math_scalar "scalar" - \ref fennec_math_vector "vector" integer modulus operator
///
/// \details
/// \returns A \ref fennec_math_vector "vector" \a v such that, \f$v_i=lhs_i\%rhs_i\f$
/// \returns A \ref fennec_math_vector "vector" \a v such that, \math{v_i=lhs_i\%rhs_i}
/// \param lhs left hand side
/// \param rhs right hand side
constexpr friend vector_t operator%(scalar_t lhs, const vector_t& rhs) requires(is_integral_v<scalar_t>) {
@@ -536,7 +536,7 @@ struct vector : detail::vector_base_type<ScalarT, sizeof...(IndicesV)>
/// \brief \ref fennec_math_vector "vector" - \ref fennec_math_scalar "scalar" addition operator
///
/// \details
/// \returns A \ref fennec_math_vector "vector" \a v such that, \f$v_i=lhs_i+rhs_i\f$
/// \returns A \ref fennec_math_vector "vector" \a v such that, \math{v_i=lhs_i+rhs_i}
/// \param lhs left hand side
/// \param rhs right hand side
constexpr friend vector_t operator+(const vector_t& lhs, scalar_t rhs) {
@@ -549,7 +549,7 @@ struct vector : detail::vector_base_type<ScalarT, sizeof...(IndicesV)>
/// \details
/// \param lhs left hand side
/// \param rhs right hand side
/// \returns A \ref fennec_math_vector "vector" \a v such that, \f$v_i=lhs_i-rhs_i\f$
/// \returns A \ref fennec_math_vector "vector" \a v such that, \math{v_i=lhs_i-rhs_i}
constexpr friend vector_t operator-(const vector_t& lhs, scalar_t rhs) {
return vector_t((lhs[IndicesV] - rhs)...);
}
@@ -560,7 +560,7 @@ struct vector : detail::vector_base_type<ScalarT, sizeof...(IndicesV)>
/// \details
/// \param lhs left hand side
/// \param rhs right hand side
/// \returns A \ref fennec_math_vector "vector" \a v such that, \f$v_i={lhs_i}\cdot{rhs_i}\f$
/// \returns A \ref fennec_math_vector "vector" \a v such that, \math{v_i={lhs_i}\cdot{rhs_i}}
constexpr friend vector_t operator*(const vector_t& lhs, scalar_t rhs) {
return vector_t((lhs[IndicesV] * rhs)...);
}
@@ -571,7 +571,7 @@ struct vector : detail::vector_base_type<ScalarT, sizeof...(IndicesV)>
/// \details
/// \param lhs left hand side
/// \param rhs right hand side
/// \returns A \ref fennec_math_vector "vector" \a v such that, \f$v_i=\frac{lhs_i}{rhs_i}\f$
/// \returns A \ref fennec_math_vector "vector" \a v such that, \math{v_i=\frac{lhs_i}{rhs_i}}
constexpr friend vector_t operator/(const vector_t& lhs, scalar_t rhs) {
return vector((lhs[IndicesV] / rhs)...);
}
@@ -582,7 +582,7 @@ struct vector : detail::vector_base_type<ScalarT, sizeof...(IndicesV)>
/// \details
/// \param lhs left hand side
/// \param rhs right hand side
/// \returns A \ref fennec_math_vector "vector" \a v such that, \f$v_i=lhs_i\%rhs_i\f$
/// \returns A \ref fennec_math_vector "vector" \a v such that, \math{v_i=lhs_i\%rhs_i}
constexpr friend vector_t operator%(const vector_t& lhs, scalar_t rhs) requires(is_integral_v<scalar_t>) {
return vector((lhs[IndicesV] % rhs)...);
}
@@ -600,7 +600,7 @@ struct vector : detail::vector_base_type<ScalarT, sizeof...(IndicesV)>
/// \details
/// \param lhs Left Hand Side of the Expression
/// \param rhs Right Hand Side of the Expression
/// \returns A \ref fennec_math_vector "vector" \a v such that, \f$v_i=lhs_i+rhs_i\f$
/// \returns A \ref fennec_math_vector "vector" \a v such that, \math{v_i=lhs_i+rhs_i}
constexpr friend vector_t& operator+=(vector_t& lhs, scalar_t rhs) {
return ((lhs[IndicesV] += rhs), ..., lhs);
}
@@ -611,7 +611,7 @@ struct vector : detail::vector_base_type<ScalarT, sizeof...(IndicesV)>
/// \details
/// \param lhs Left Hand Side of the Expression
/// \param rhs Right Hand Side of the Expression
/// \returns A \ref fennec_math_vector "vector" \a v such that, \f$v_i=lhs_i-rhs_i\f$
/// \returns A \ref fennec_math_vector "vector" \a v such that, \math{v_i=lhs_i-rhs_i}
constexpr friend vector_t& operator-=(vector_t& lhs, scalar_t rhs) {
return ((lhs[IndicesV] -= rhs), ..., lhs);
}
@@ -622,7 +622,7 @@ struct vector : detail::vector_base_type<ScalarT, sizeof...(IndicesV)>
/// \details
/// \param lhs Left Hand Side of the Expression
/// \param rhs Right Hand Side of the Expression
/// \returns A \ref fennec_math_vector "vector" \a v such that, \f$v_i={lhs_i}\cdot{rhs_i}\f$
/// \returns A \ref fennec_math_vector "vector" \a v such that, \math{v_i={lhs_i}\cdot{rhs_i}}
constexpr friend vector_t& operator*=(vector_t& lhs, scalar_t rhs) {
return ((lhs[IndicesV] *= rhs), ..., lhs);
}
@@ -633,7 +633,7 @@ struct vector : detail::vector_base_type<ScalarT, sizeof...(IndicesV)>
/// \details
/// \param lhs Left Hand Side of the Expression
/// \param rhs Right Hand Side of the Expression
/// \returns A \ref fennec_math_vector "vector" \a v such that, \f$v_i=\frac{lhs_i}{rhs_i}\f$
/// \returns A \ref fennec_math_vector "vector" \a v such that, \math{v_i=\frac{lhs_i}{rhs_i}}
constexpr friend vector_t& operator/=(vector_t& lhs, scalar_t rhs) {
return ((lhs[IndicesV] /= rhs), ..., lhs);
}
@@ -644,7 +644,7 @@ struct vector : detail::vector_base_type<ScalarT, sizeof...(IndicesV)>
/// \details
/// \param lhs Left Hand Side of the Expression
/// \param rhs Right Hand Side of the Expression
/// \returns A \ref fennec_math_vector "vector" \a v such that, \f$v_i=lhs_i\%rhs_i\f$
/// \returns A \ref fennec_math_vector "vector" \a v such that, \math{v_i=lhs_i\%rhs_i}
constexpr friend vector_t& operator%=(vector_t& lhs, scalar_t rhs) requires(is_integral_v<scalar_t>) {
return ((lhs[IndicesV] %= rhs), ..., lhs);
}
@@ -661,7 +661,7 @@ struct vector : detail::vector_base_type<ScalarT, sizeof...(IndicesV)>
///
/// \details
/// \param x the vector
/// \returns A \ref fennec_math_vector "vector" \a v such that, \f$v_i=-x_i\f$
/// \returns A \ref fennec_math_vector "vector" \a v such that, \math{v_i=-x_i}
constexpr friend vector_t operator-(const vector_t& x) {
return vector((-x[IndicesV])...);
}
@@ -672,7 +672,7 @@ struct vector : detail::vector_base_type<ScalarT, sizeof...(IndicesV)>
/// \details
/// \param lhs Left Hand Side of the Expression
/// \param rhs Right Hand Side of the Expression
/// \returns A \ref fennec_math_vector "vector" \a v such that, \f$v_i=lhs_i+rhs_i\f$
/// \returns A \ref fennec_math_vector "vector" \a v such that, \math{v_i=lhs_i+rhs_i}
constexpr friend vector_t operator+(const vector_t& lhs, const vector_t& rhs) {
return vector((lhs[IndicesV] + rhs[IndicesV])...);
}
@@ -683,7 +683,7 @@ struct vector : detail::vector_base_type<ScalarT, sizeof...(IndicesV)>
/// \details
/// \param lhs Left Hand Side of the Expression
/// \param rhs Right Hand Side of the Expression
/// \returns A \ref fennec_math_vector "vector" \a v such that, \f$v_i=lhs_i-rhs_i\f$
/// \returns A \ref fennec_math_vector "vector" \a v such that, \math{v_i=lhs_i-rhs_i}
constexpr friend vector_t operator-(const vector_t& lhs, const vector_t& rhs) {
return vector((lhs[IndicesV] - rhs[IndicesV])...);
}
@@ -694,7 +694,7 @@ struct vector : detail::vector_base_type<ScalarT, sizeof...(IndicesV)>
/// \details
/// \param lhs Left Hand Side of the Expression
/// \param rhs Right Hand Side of the Expression
/// \returns A \ref fennec_math_vector "vector" \a v such that, \f$v_i={lhs_i}\cdot{rhs_i}\f$
/// \returns A \ref fennec_math_vector "vector" \a v such that, \math{v_i={lhs_i}\cdot{rhs_i}}
constexpr friend vector_t operator*(const vector_t& lhs, const vector_t& rhs) {
return vector((lhs[IndicesV] * rhs[IndicesV])...);
}
@@ -703,7 +703,7 @@ struct vector : detail::vector_base_type<ScalarT, sizeof...(IndicesV)>
/// \brief \ref fennec_math_vector "vector" - \ref fennec_math_vector "vector" division operator
/// \param lhs Left Hand Side of the Expression
/// \param rhs Right Hand Side of the Expression
/// \returns A \ref fennec_math_vector "vector" \a v such that, \f$v_i=\frac{lhs_i}{rhs_i}\f$
/// \returns A \ref fennec_math_vector "vector" \a v such that, \math{v_i=\frac{lhs_i}{rhs_i}}
constexpr friend vector_t operator/(const vector_t& lhs, const vector_t& rhs) {
return vector((lhs[IndicesV] / rhs[IndicesV])...);
}
@@ -714,7 +714,7 @@ struct vector : detail::vector_base_type<ScalarT, sizeof...(IndicesV)>
/// \details
/// \param lhs Left Hand Side of the Expression
/// \param rhs Right Hand Side of the Expression
/// \returns A \ref fennec_math_vector "vector" \a v such that, \f$v_i=lhs_i\%rhs_i\f$
/// \returns A \ref fennec_math_vector "vector" \a v such that, \math{v_i=lhs_i\%rhs_i}
constexpr friend vector_t operator%(const vector_t& lhs, const vector_t& rhs) requires(is_integral_v<scalar_t>) {
return vector((lhs[IndicesV] % rhs[IndicesV])...);
}
@@ -732,7 +732,7 @@ struct vector : detail::vector_base_type<ScalarT, sizeof...(IndicesV)>
/// \details
/// \param lhs Left Hand Side of the Expression
/// \param rhs Right Hand Side of the Expression
/// \returns A \ref fennec_math_vector "vector" \a v such that, \f$v_i=lhs_i+rhs_i\f$
/// \returns A \ref fennec_math_vector "vector" \a v such that, \math{v_i=lhs_i+rhs_i}
constexpr friend vector_t& operator+=(vector_t& lhs, const vector_t& rhs) {
return ((lhs[IndicesV] += rhs[IndicesV]), ..., lhs);
}
@@ -743,7 +743,7 @@ struct vector : detail::vector_base_type<ScalarT, sizeof...(IndicesV)>
/// \details
/// \param lhs Left Hand Side of the Expression
/// \param rhs Right Hand Side of the Expression
/// \returns A \ref fennec_math_vector "vector" \a v such that, \f$v_i=lhs_i-rhs_i\f$
/// \returns A \ref fennec_math_vector "vector" \a v such that, \math{v_i=lhs_i-rhs_i}
constexpr friend vector_t& operator-=(vector_t& lhs, const vector_t& rhs) {
return ((lhs[IndicesV] -= rhs[IndicesV]), ..., lhs);
}
@@ -754,7 +754,7 @@ struct vector : detail::vector_base_type<ScalarT, sizeof...(IndicesV)>
/// \details
/// \param lhs Left Hand Side of the Expression
/// \param rhs Right Hand Side of the Expression
/// \returns A \ref fennec_math_vector "vector" \a v such that, \f$v_i={lhs_i}\cdot{rhs_i}\f$
/// \returns A \ref fennec_math_vector "vector" \a v such that, \math{v_i={lhs_i}\cdot{rhs_i}}
constexpr friend vector_t& operator*=(vector_t& lhs, const vector_t& rhs) {
return ((lhs[IndicesV] *= rhs[IndicesV]), ..., lhs);
}
@@ -765,7 +765,7 @@ struct vector : detail::vector_base_type<ScalarT, sizeof...(IndicesV)>
/// \details
/// \param lhs Left Hand Side of the Expression
/// \param rhs Right Hand Side of the Expression
/// \returns A \ref fennec_math_vector "vector" \a v such that, \f$v_i=\frac{lhs_i}{rhs_i}\f$
/// \returns A \ref fennec_math_vector "vector" \a v such that, \math{v_i=\frac{lhs_i}{rhs_i}}
constexpr friend vector_t& operator/=(vector_t& lhs, const vector_t& rhs) {
return ((lhs[IndicesV] /= rhs[IndicesV]), ..., lhs);
}
@@ -776,7 +776,7 @@ struct vector : detail::vector_base_type<ScalarT, sizeof...(IndicesV)>
/// \details
/// \param lhs Left Hand Side of the Expression
/// \param rhs Right Hand Side of the Expression
/// \returns A \ref fennec_math_vector "vector" \a v such that, \f$v_i=lhs_i\%rhs_i\f$
/// \returns A \ref fennec_math_vector "vector" \a v such that, \math{v_i=lhs_i\%rhs_i}
constexpr friend vector_t& operator%=(vector_t& lhs, const vector_t& rhs) requires(is_integral_v<scalar_t>) {
return ((lhs[IndicesV] %= rhs[IndicesV]), ..., lhs);
}
@@ -793,7 +793,7 @@ struct vector : detail::vector_base_type<ScalarT, sizeof...(IndicesV)>
///
/// \details
/// \param x the vector
/// \returns A \ref fennec_math_vector "vector" \a v such that, \f$v_i=!x_i\f$
/// \returns A \ref fennec_math_vector "vector" \a v such that, \math{v_i=!x_i}
constexpr friend vector_t operator!(const vector_t& x) {
return vector_t(!x[IndicesV]...);
}
@@ -804,7 +804,7 @@ struct vector : detail::vector_base_type<ScalarT, sizeof...(IndicesV)>
/// \details
/// \param lhs Left Hand Side of the Expression
/// \param rhs Right Hand Side of the Expression
/// \returns A \ref fennec_math_vector "vector" \a v such that, \f$v_i=lhs_i\&\&rhs_i\f$
/// \returns A \ref fennec_math_vector "vector" \a v such that, \math{v_i=lhs_i\&\&rhs_i}
constexpr friend vector_t operator&&(const vector_t& lhs, scalar_t rhs) requires(is_bool_v<scalar_t>) {
return vector_t((lhs[IndicesV] && rhs)...);
}
@@ -813,7 +813,7 @@ struct vector : detail::vector_base_type<ScalarT, sizeof...(IndicesV)>
/// \brief \ref fennec_math_vector "vector" - \ref fennec_math_vector "vector" logical and operator
/// \param lhs Left Hand Side of the Expression
/// \param rhs Right Hand Side of the Expression
/// \returns A \ref fennec_math_vector "vector" \a v such that, \f$v_i=lhs_i\&\&rhs_i\f$
/// \returns A \ref fennec_math_vector "vector" \a v such that, \math{v_i=lhs_i\&\&rhs_i}
constexpr friend vector_t operator&&(const vector_t& lhs, const vector_t& rhs) requires(is_bool_v<scalar_t>) {
return vector_t((lhs[IndicesV] && rhs[IndicesV])...);
}
@@ -824,7 +824,7 @@ struct vector : detail::vector_base_type<ScalarT, sizeof...(IndicesV)>
/// \details
/// \param lhs Left Hand Side of the Expression
/// \param rhs Right Hand Side of the Expression
/// \returns A \ref fennec_math_vector "vector" \a v such that, \f$v_i=lhs_i\|\|rhs_i\f$
/// \returns A \ref fennec_math_vector "vector" \a v such that, \math{v_i=lhs_i\|\|rhs_i}
constexpr friend vector_t operator||(const vector_t& lhs, scalar_t rhs) requires(is_bool_v<scalar_t>) {
return vector_t((lhs[IndicesV] || rhs)...);
}
@@ -835,7 +835,7 @@ struct vector : detail::vector_base_type<ScalarT, sizeof...(IndicesV)>
/// \details
/// \param lhs Left Hand Side of the Expression
/// \param rhs Right Hand Side of the Expression
/// \returns A \ref fennec_math_vector "vector" \a v such that, \f$v_i=lhs_i\|\|rhs_i\f$
/// \returns A \ref fennec_math_vector "vector" \a v such that, \math{v_i=lhs_i\|\|rhs_i}
constexpr friend vector_t operator||(const vector_t& lhs, const vector_t& rhs) requires(is_bool_v<scalar_t>) {
return vector_t((lhs[IndicesV] || rhs[IndicesV])...);
}
@@ -853,7 +853,7 @@ struct vector : detail::vector_base_type<ScalarT, sizeof...(IndicesV)>
/// \details
/// \param lhs Left Hand Side of the Expression
/// \param rhs Right Hand Side of the Expression
/// \returns A \ref fennec_math_vector "vector" \a v such that, \f$v_i=lhs_i\&rhs_i\f$
/// \returns A \ref fennec_math_vector "vector" \a v such that, \math{v_i=lhs_i\&rhs_i}
constexpr friend vector_t operator&(scalar_t rhs, const vector_t& lhs) requires(is_integral_v<scalar_t>) {
return vector_t((lhs[IndicesV] & rhs)...);
}
@@ -864,7 +864,7 @@ struct vector : detail::vector_base_type<ScalarT, sizeof...(IndicesV)>
/// \details
/// \param lhs Left Hand Side of the Expression
/// \param rhs Right Hand Side of the Expression
/// \returns A \ref fennec_math_vector "vector" \a v such that, \f$v_i=lhs_i\&rhs_i\f$
/// \returns A \ref fennec_math_vector "vector" \a v such that, \math{v_i=lhs_i\&rhs_i}
constexpr friend vector_t operator&(const vector_t& lhs, scalar_t rhs) requires(is_integral_v<scalar_t>) {
return vector_t((lhs[IndicesV] & rhs)...);
}
@@ -875,7 +875,7 @@ struct vector : detail::vector_base_type<ScalarT, sizeof...(IndicesV)>
/// \details
/// \param lhs Left Hand Side of the Expression
/// \param rhs Right Hand Side of the Expression
/// \returns A \ref fennec_math_vector "vector" \a v such that, \f$v_i=lhs_i\&rhs_i\f$
/// \returns A \ref fennec_math_vector "vector" \a v such that, \math{v_i=lhs_i\&rhs_i}
constexpr friend vector_t operator&=(vector_t& lhs, scalar_t rhs) requires(is_integral_v<scalar_t>) {
return ((lhs[IndicesV] &= rhs), ..., lhs);
}
@@ -886,7 +886,7 @@ struct vector : detail::vector_base_type<ScalarT, sizeof...(IndicesV)>
/// \details
/// \param lhs Left Hand Side of the Expression
/// \param rhs Right Hand Side of the Expression
/// \returns A \ref fennec_math_vector "vector" \a v such that, \f$v_i=lhs_i\&rhs_i\f$
/// \returns A \ref fennec_math_vector "vector" \a v such that, \math{v_i=lhs_i\&rhs_i}
constexpr friend vector_t operator&(const vector_t& lhs, const vector_t& rhs) requires(is_integral_v<
scalar_t>) {
return vector_t((lhs[IndicesV] & rhs[IndicesV])...);
@@ -898,7 +898,7 @@ struct vector : detail::vector_base_type<ScalarT, sizeof...(IndicesV)>
/// \details
/// \param lhs Left Hand Side of the Expression
/// \param rhs Right Hand Side of the Expression
/// \returns A \ref fennec_math_vector "vector" \a v such that, \f$v_i=lhs_i\&rhs_i\f$
/// \returns A \ref fennec_math_vector "vector" \a v such that, \math{v_i=lhs_i\&rhs_i}
constexpr friend vector_t operator&=(vector_t& lhs, const vector_t& rhs) requires(is_integral_v<scalar_t>) {
return ((lhs[IndicesV] &= rhs[IndicesV]), ..., lhs);
}
@@ -910,7 +910,7 @@ struct vector : detail::vector_base_type<ScalarT, sizeof...(IndicesV)>
/// \details
/// \param lhs Left Hand Side of the Expression
/// \param rhs Right Hand Side of the Expression
/// \returns A \ref fennec_math_vector "vector" \a v such that, \f$v_i=lhs_i|rhs_i\f$
/// \returns A \ref fennec_math_vector "vector" \a v such that, \math{v_i=lhs_i|rhs_i}
constexpr friend vector_t operator|(scalar_t rhs, const vector_t& lhs) requires(is_integral_v<scalar_t>) {
return vector_t((lhs[IndicesV] | rhs)...);
}
@@ -921,7 +921,7 @@ struct vector : detail::vector_base_type<ScalarT, sizeof...(IndicesV)>
/// \details
/// \param lhs Left Hand Side of the Expression
/// \param rhs Right Hand Side of the Expression
/// \returns A \ref fennec_math_vector "vector" \a v such that, \f$v_i=lhs_i|rhs_i\f$
/// \returns A \ref fennec_math_vector "vector" \a v such that, \math{v_i=lhs_i|rhs_i}
constexpr friend vector_t operator|(const vector_t& lhs, scalar_t rhs) requires(is_integral_v<scalar_t>) {
return vector_t((lhs[IndicesV] | rhs)...);
}
@@ -932,7 +932,7 @@ struct vector : detail::vector_base_type<ScalarT, sizeof...(IndicesV)>
/// \details
/// \param lhs Left Hand Side of the Expression
/// \param rhs Right Hand Side of the Expression
/// \returns A \ref fennec_math_vector "vector" \a v such that, \f$v_i=lhs_i|rhs_i\f$
/// \returns A \ref fennec_math_vector "vector" \a v such that, \math{v_i=lhs_i|rhs_i}
constexpr friend vector_t operator|=(vector_t& lhs, scalar_t rhs) requires(is_integral_v<scalar_t>) {
return ((lhs[IndicesV] |= rhs), ..., lhs);
}
@@ -943,7 +943,7 @@ struct vector : detail::vector_base_type<ScalarT, sizeof...(IndicesV)>
/// \details
/// \param lhs Left Hand Side of the Expression
/// \param rhs Right Hand Side of the Expression
/// \returns A \ref fennec_math_vector "vector" \a v such that, \f$v_i=lhs_i|rhs_i\f$
/// \returns A \ref fennec_math_vector "vector" \a v such that, \math{v_i=lhs_i|rhs_i}
constexpr friend vector_t operator|(const vector_t& lhs, const vector_t& rhs) requires(is_integral_v<
scalar_t>) {
return vector_t((lhs[IndicesV] | rhs[IndicesV])...);
@@ -955,7 +955,7 @@ struct vector : detail::vector_base_type<ScalarT, sizeof...(IndicesV)>
/// \details
/// \param lhs Left Hand Side of the Expression
/// \param rhs Right Hand Side of the Expression
/// \returns A \ref fennec_math_vector "vector" \a v such that, \f$v_i=lhs_i|rhs_i\f$
/// \returns A \ref fennec_math_vector "vector" \a v such that, \math{v_i=lhs_i|rhs_i}
constexpr friend vector_t operator|=(vector_t& lhs, const vector_t& rhs) requires(is_integral_v<scalar_t>) {
return ((lhs[IndicesV] |= rhs[IndicesV]), ..., lhs);
}
@@ -965,7 +965,7 @@ struct vector : detail::vector_base_type<ScalarT, sizeof...(IndicesV)>
/// \ref fennec_math_scalar "scalar" - \ref fennec_math_vector "vector" bitwise xor operator
/// \param lhs Left Hand Side of the Expression
/// \param rhs Right Hand Side of the Expression
/// \returns A \ref fennec_math_vector "vector" \a v such that, \f$v_i=lhs_i\^rhs_i\f$
/// \returns A \ref fennec_math_vector "vector" \a v such that, \math{v_i=lhs_i\^rhs_i}
constexpr friend vector_t operator^(scalar_t lhs, const vector_t& rhs) requires(is_integral_v<scalar_t>) {
return vector_t((lhs ^ rhs[IndicesV])...);
}
@@ -974,7 +974,7 @@ struct vector : detail::vector_base_type<ScalarT, sizeof...(IndicesV)>
/// \ref fennec_math_vector "vector" - \ref fennec_math_scalar "scalar" bitwise xor operator
/// \param lhs Left Hand Side of the Expression
/// \param rhs Right Hand Side of the Expression
/// \returns A \ref fennec_math_vector "vector" \a v such that, \f$v_i=lhs_i\^rhs_i\f$
/// \returns A \ref fennec_math_vector "vector" \a v such that, \math{v_i=lhs_i\^rhs_i}
constexpr friend vector_t operator^(const vector_t& lhs, scalar_t rhs) requires(is_integral_v<scalar_t>) {
return vector_t((lhs[IndicesV] ^ rhs)...);
}
@@ -983,7 +983,7 @@ struct vector : detail::vector_base_type<ScalarT, sizeof...(IndicesV)>
/// \ref fennec_math_vector "vector" - \ref fennec_math_scalar "scalar" bitwise xor assignment operator
/// \param lhs Left Hand Side of the Expression
/// \param rhs Right Hand Side of the Expression
/// \returns A \ref fennec_math_vector "vector" \a v such that, \f$v_i=lhs_i\^rhs_i\f$
/// \returns A \ref fennec_math_vector "vector" \a v such that, \math{v_i=lhs_i\^rhs_i}
constexpr friend vector_t operator^=(vector_t& lhs, scalar_t rhs) requires(is_integral_v<scalar_t>) {
return ((lhs[IndicesV] ^= rhs), ..., lhs);
}
@@ -992,7 +992,7 @@ struct vector : detail::vector_base_type<ScalarT, sizeof...(IndicesV)>
/// \ref fennec_math_vector "vector" - \ref fennec_math_vector "vector" bitwise xor operator
/// \param lhs Left Hand Side of the Expression
/// \param rhs Right Hand Side of the Expression
/// \returns A \ref fennec_math_vector "vector" \a v such that, \f$v_i=lhs_i\^rhs_i\f$
/// \returns A \ref fennec_math_vector "vector" \a v such that, \math{v_i=lhs_i\^rhs_i}
constexpr friend vector_t operator^(const vector_t& lhs, const vector_t& rhs) requires(is_integral_v<
scalar_t>) {
return vector_t((lhs[IndicesV] ^ rhs[IndicesV])...);
@@ -1002,7 +1002,7 @@ struct vector : detail::vector_base_type<ScalarT, sizeof...(IndicesV)>
/// \ref fennec_math_vector "vector" - \ref fennec_math_vector "vector" bitwise xor assignment operator
/// \param lhs Left Hand Side of the Expression
/// \param rhs Right Hand Side of the Expression
/// \returns A \ref fennec_math_vector "vector" \a v such that, \f$v_i=lhs_i\^rhs_i\f$
/// \returns A \ref fennec_math_vector "vector" \a v such that, \math{v_i=lhs_i\^rhs_i}
constexpr friend vector_t operator^=(vector_t& lhs, const vector_t& rhs) requires(is_integral_v<scalar_t>) {
return ((lhs[IndicesV] ^= rhs[IndicesV]), ..., lhs);
}
@@ -1012,7 +1012,7 @@ struct vector : detail::vector_base_type<ScalarT, sizeof...(IndicesV)>
/// \ref fennec_math_scalar "scalar" - \ref fennec_math_vector "vector" bitwise left-shift operator
/// \param lhs Left Hand Side of the Expression
/// \param rhs Right Hand Side of the Expression
/// \returns A \ref fennec_math_vector "vector" \a v such that, \f$v_i=lhs_i<<rhs_i\f$
/// \returns A \ref fennec_math_vector "vector" \a v such that, \math{v_i=lhs_i<<rhs_i}
constexpr friend vector_t operator<<(scalar_t lhs, const vector_t& rhs) requires(is_integral_v<scalar_t>) {
return vector_t((lhs << rhs[IndicesV])...);
}
@@ -1021,7 +1021,7 @@ struct vector : detail::vector_base_type<ScalarT, sizeof...(IndicesV)>
/// \ref fennec_math_vector "vector" - \ref fennec_math_scalar "scalar" bitwise left-shift operator
/// \param lhs Left Hand Side of the Expression
/// \param rhs Right Hand Side of the Expression
/// \returns A \ref fennec_math_vector "vector" \a v such that, \f$v_i=lhs_i<<rhs_i\f$
/// \returns A \ref fennec_math_vector "vector" \a v such that, \math{v_i=lhs_i<<rhs_i}
constexpr friend vector_t operator<<(const vector_t& lhs, scalar_t rhs) requires(is_integral_v<scalar_t>) {
return vector_t((lhs[IndicesV] << rhs)...);
}
@@ -1030,7 +1030,7 @@ struct vector : detail::vector_base_type<ScalarT, sizeof...(IndicesV)>
/// \ref fennec_math_vector "vector" - \ref fennec_math_scalar "scalar" bitwise left-shift assignment operator
/// \param lhs Left Hand Side of the Expression
/// \param rhs Right Hand Side of the Expression
/// \returns A \ref fennec_math_vector "vector" \a v such that, \f$v_i=lhs_i<<=rhs_i\f$
/// \returns A \ref fennec_math_vector "vector" \a v such that, \math{v_i=lhs_i<<=rhs_i}
constexpr friend vector_t operator<<=(vector_t& lhs, scalar_t rhs) requires(is_integral_v<scalar_t>) {
return ((lhs[IndicesV] <<= rhs), ..., lhs);
}
@@ -1039,7 +1039,7 @@ struct vector : detail::vector_base_type<ScalarT, sizeof...(IndicesV)>
/// \ref fennec_math_vector "vector" - \ref fennec_math_vector "vector" bitwise or operator
/// \param lhs Left Hand Side of the Expression
/// \param rhs Right Hand Side of the Expression
/// \returns A \ref fennec_math_vector "vector" \a v such that, \f$v_i=lhs_i<<rhs_i\f$
/// \returns A \ref fennec_math_vector "vector" \a v such that, \math{v_i=lhs_i<<rhs_i}
constexpr friend vector_t operator<<(const vector_t& lhs, const vector_t& rhs) requires(is_integral_v<scalar_t>) {
return vector_t((lhs[IndicesV] << rhs[IndicesV])...);
}
@@ -1048,7 +1048,7 @@ struct vector : detail::vector_base_type<ScalarT, sizeof...(IndicesV)>
/// \ref fennec_math_vector "vector" - \ref fennec_math_vector "vector" bitwise or assignment operator
/// \param lhs Left Hand Side of the Expression
/// \param rhs Right Hand Side of the Expression
/// \returns A \ref fennec_math_vector "vector" \a v such that, \f$v_i=lhs_i<<=rhs_i\f$
/// \returns A \ref fennec_math_vector "vector" \a v such that, \math{v_i=lhs_i<<=rhs_i}
constexpr friend vector_t operator<<=(vector_t& lhs, const vector_t& rhs) requires(is_integral_v<scalar_t>) {
return ((lhs[IndicesV] <<= rhs[IndicesV]), ..., lhs);
}
@@ -1058,7 +1058,7 @@ struct vector : detail::vector_base_type<ScalarT, sizeof...(IndicesV)>
/// \ref fennec_math_scalar "scalar" - \ref fennec_math_vector "vector" bitwise or operator
/// \param lhs Left Hand Side of the Expression
/// \param rhs Right Hand Side of the Expression
/// \returns A \ref fennec_math_vector "vector" \a v such that, \f$v_i=lhs_i>>rhs_i\f$
/// \returns A \ref fennec_math_vector "vector" \a v such that, \math{v_i=lhs_i>>rhs_i}
constexpr friend vector_t operator>>(scalar_t lhs, const vector_t& rhs) requires(is_integral_v<scalar_t>) {
return vector_t((lhs >> rhs[IndicesV])...);
}
@@ -1067,7 +1067,7 @@ struct vector : detail::vector_base_type<ScalarT, sizeof...(IndicesV)>
/// \ref fennec_math_vector "vector" - \ref fennec_math_scalar "scalar" bitwise or operator
/// \param lhs Left Hand Side of the Expression
/// \param rhs Right Hand Side of the Expression
/// \returns A \ref fennec_math_vector "vector" \a v such that, \f$v_i=lhs_i>>rhs_i\f$
/// \returns A \ref fennec_math_vector "vector" \a v such that, \math{v_i=lhs_i>>rhs_i}
constexpr friend vector_t operator>>(const vector_t& lhs, scalar_t rhs) requires(is_integral_v<scalar_t>) {
return vector_t((lhs[IndicesV] >> rhs)...);
}
@@ -1076,7 +1076,7 @@ struct vector : detail::vector_base_type<ScalarT, sizeof...(IndicesV)>
/// \ref fennec_math_vector "vector" - \ref fennec_math_scalar "scalar" bitwise left-shift assignment operator
/// \param lhs Left Hand Side of the Expression
/// \param rhs Right Hand Side of the Expression
/// \returns A \ref fennec_math_vector "vector" \a v such that, \f$v_i=lhs_i>>=rhs_i\f$
/// \returns A \ref fennec_math_vector "vector" \a v such that, \math{v_i=lhs_i>>=rhs_i}
constexpr friend vector_t operator>>=(vector_t& lhs, scalar_t rhs) requires(is_integral_v<scalar_t>) {
return ((lhs[IndicesV] >>= rhs), ..., lhs);
}
@@ -1085,7 +1085,7 @@ struct vector : detail::vector_base_type<ScalarT, sizeof...(IndicesV)>
/// \ref fennec_math_vector "vector" - \ref fennec_math_vector "vector" bitwise or operator
/// \param lhs Left Hand Side of the Expression
/// \param rhs Right Hand Side of the Expression
/// \returns A \ref fennec_math_vector "vector" \a v such that, \f$v_i=lhs_i>>rhs_i\f$
/// \returns A \ref fennec_math_vector "vector" \a v such that, \math{v_i=lhs_i>>rhs_i}
constexpr friend vector_t operator>>(const vector_t& lhs, const vector_t& rhs) requires(is_integral_v<scalar_t>) {
return vector_t((lhs[IndicesV] >> rhs[IndicesV])...);
}
@@ -1094,7 +1094,7 @@ struct vector : detail::vector_base_type<ScalarT, sizeof...(IndicesV)>
/// \ref fennec_math_vector "vector" - \ref fennec_math_vector "vector" bitwise or assignment operator
/// \param lhs Left Hand Side of the Expression
/// \param rhs Right Hand Side of the Expression
/// \returns A \ref fennec_math_vector "vector" \a v such that, \f$v_i=lhs_i>>=rhs_i\f$
/// \returns A \ref fennec_math_vector "vector" \a v such that, \math{v_i=lhs_i>>=rhs_i}
constexpr friend vector_t operator>>=(vector_t& lhs, const vector_t& rhs) requires(is_integral_v<scalar_t>) {
return ((lhs[IndicesV] >>= rhs[IndicesV]), ..., lhs);
}

14
include/fennec/math/vector_storage.h
View File

@@ -25,6 +25,12 @@
#pragma GCC diagnostic ignored "-Wpedantic"
#endif
#if FENNEC_COMPILER_CLANG
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wgnu-anonymous-struct"
#pragma clang diagnostic ignored "-Wnested-anon-types"
#endif
#if FENNEC_COMPILER_MSVC
#pragma warning(push)
#pragma warning(disable:4201)
@@ -617,4 +623,12 @@ namespace fennec::detail
#pragma GCC diagnostic pop
#endif
#ifdef FENNEC_COMPILER_CLANG
#pragma clang diagnostic pop
#endif
#if FENNEC_COMPILER_MSVC
#pragma warning(pop)
#endif
#endif // FENNEC_MATH_VECTOR_STORAGE_H

8
include/fennec/math/vector_traits.h
View File

@@ -74,17 +74,17 @@ namespace fennec
template<typename T> struct is_vector : detail::_is_vector_helper<remove_cvref_t<T>>{};
///
/// \brief shorthand for ```is_vector<T>::value```
/// \brief shorthand for `(.*?)`
/// \tparam T type to check
template<typename T> constexpr bool is_vector_v = is_vector<T>::value;
///
/// \brief Get the number of Components in \p T, returns 1 for types that pass ```is_arithmetic<T>```, returns \ref vector::N for \ref vector "Vector" Types, and returns 0 for all other cases
/// \brief Get the number of Components in \p T, returns 1 for types that pass `(.*?)`, returns \ref vector::N for \ref vector "Vector" Types, and returns 0 for all other cases
/// \tparam T type to check
template<typename T> struct component_count : detail::_component_count_helper<remove_cvref_t<T>>{};
///
/// \brief shorthand for ```component_count<T>::value```
/// \brief shorthand for `(.*?)`
/// \tparam T type to get the component count of
template<typename T> constexpr size_t component_count_v = component_count<T>::value;
@@ -97,7 +97,7 @@ template<typename...Ts> struct total_component_count : integral_constant<size_t,
template<> struct total_component_count<> : integral_constant<size_t, 0>{};
///
/// \brief shorthand for ```component_count<T>::value```
/// \brief shorthand for `(.*?)`
/// \tparam Ts types to accumulate the count of
template<typename...Ts> constexpr size_t total_component_count_v = total_component_count<Ts...>::value;

86
include/fennec/memory/allocator.h
View File

@@ -122,15 +122,10 @@ public:
/// \brief Alias for the size of allocations. Will use `Alloc::size_t` if present
using size_t = typename _size<Alloc, pointer_t>::type;
// TODO: Document propagation
using propagate_on_container_copy_assignment = detect_t<false_type, _propagate_on_containter_copy_assignment, Alloc>;
using propagate_on_container_move_assignment = detect_t<false_type, _propagate_on_containter_move_assignment, Alloc>;
using propagate_on_container_swap = detect_t<false_type, _propagate_on_containter_swap, Alloc>;
/// \brief Checks if this allocator type is always equal to another allocator of similar type
using is_always_equal = detect_t<false_type, _is_always_equal, Alloc>;
/// \brief Rebinds the allocator type to produce an element type of type \f$TypeT\f$
/// \brief Rebinds the allocator type to produce an element type of type \emph{TypeT}
template<typename TypeT> using rebind = typename _rebind<Alloc, TypeT>::type;
// TODO: allocator_traits static functions
@@ -138,7 +133,7 @@ public:
///
/// \brief Allocator implementation, uses \f$new\f$ and \f$delete\f$ operators.
/// \brief Allocator implementation, uses \emph{new} and \emph{delete} operators.
/// \tparam T The data type to allocate
template<typename T>
class allocator
@@ -166,39 +161,39 @@ public:
///
/// \brief Copy Assignment
/// \returns A reference to self
/// \returns A reference to \emph{this}
constexpr allocator& operator=(const allocator&) = default;
///
/// \brief Equality operator
/// \returns \f$true\f$
/// \returns \emph{true}
constexpr bool_t operator==(const allocator&) {
return true;
}
///
/// \brief Inequality operator
/// \returns \f$false\f$
/// \returns \emph{false}
constexpr bool_t operator!=(const allocator&) {
return false;
}
///
/// \brief Equality operator for allocators of same type but with different data type
/// \returns \f$false\f$
/// \returns \emph{false}
template<typename U> constexpr bool_t operator==(const allocator<U>&) {
return false;
}
///
/// \brief Inequality operator for allocators of same type but with different data type
/// \returns \f$true\f$
/// \returns \emph{true}
template<typename U> constexpr bool_t operator!=(const allocator<U>&) {
return true;
}
///
/// \brief Allocate a block of memory large enough to hold \f$n\f$ elements of type \f$T\f$
/// \brief Allocate a block of memory large enough to hold \emph{n} elements of type \emph{T}
/// \param n The number of elements
/// \returns A pointer to the allocated block
constexpr T* allocate(size_t n) {
@@ -206,7 +201,7 @@ public:
}
///
/// \brief Allocate a block of memory large enough to hold \f$n\f$ elements of type \f$T\f$
/// \brief Allocate a block of memory large enough to hold \emph{n} elements of type \emph{T}
/// \param n The number of elements
/// \param align The alignment
/// \returns A pointer to the allocated block
@@ -215,14 +210,14 @@ public:
}
///
/// \brief Deallocate a block of memory with type \f$T\f$
/// \brief Deallocate a block of memory with type \emph{T}
/// \param ptr The block to release
constexpr void deallocate(T* ptr) {
return ::operator delete(ptr);
}
///
/// \brief Deallocate a block of memory with type \f$T\f$
/// \brief Deallocate a block of memory with type \emph{T}
/// \param ptr The block to release
/// \param align The alignment
constexpr void deallocate(T* ptr, align_t align) {
@@ -232,7 +227,7 @@ public:
///
/// \brief Allocator implementation, uses \f$new\f$ and \f$delete\f$ operators.
/// \brief Allocator implementation, uses \emph{new} and \emph{delete} operators.
/// \tparam T The data type to allocate
template<typename T>
class allocator<T[]>
@@ -260,40 +255,40 @@ public:
///
/// \brief Copy Assignment
/// \returns A reference to self
/// \returns A reference to \emph{this}
constexpr allocator& operator=(const allocator&) = default;
///
/// \brief Equality operator
/// \returns \f$true\f$
/// \returns \emph{true}
constexpr bool_t operator==(const allocator&) {
return true;
}
///
/// \brief Inequality operator
/// \returns \f$false\f$
/// \returns \emph{false}
constexpr bool_t operator!=(const allocator&) {
return false;
}
///
/// \brief Equality operator for allocators of same type but with different data type
/// \returns \f$false\f$
/// \returns \emph{false}
template<typename U> constexpr bool_t operator==(const allocator<U>&) {
return false;
}
///
/// \brief Inequality operator for allocators of same type but with different data type
/// \returns \f$true\f$
/// \returns \emph{true}
template<typename U> constexpr bool_t operator!=(const allocator<U>&) {
return true;
}
///
/// \brief Allocate a block of memory large enough to hold \f$n\f$ elements of type \f$T\f$
/// \brief Allocate a block of memory large enough to hold \emph{n} elements of type \emph{T}
/// \param n The number of elements
/// \returns A pointer to the allocated block
constexpr T* allocate(size_t n) {
@@ -301,7 +296,7 @@ public:
}
///
/// \brief Allocate a block of memory large enough to hold \f$n\f$ elements of type \f$T\f$
/// \brief Allocate a block of memory large enough to hold \emph{n} elements of type \emph{T}
/// \param n The number of elements
/// \param align The alignment
/// \returns A pointer to the allocated block
@@ -310,14 +305,14 @@ public:
}
///
/// \brief Deallocate a block of memory with type \f$T\f$
/// \brief Deallocate a block of memory with type \emph{T}
/// \param ptr The block to release
constexpr void deallocate(T* ptr) {
return ::operator delete[](ptr);
}
///
/// \brief Deallocate a block of memory with type \f$T\f$
/// \brief Deallocate a block of memory with type \emph{T}
/// \param ptr The block to release
/// \param align The alignment
constexpr void deallocate(T* ptr, align_t align) {
@@ -364,14 +359,14 @@ public:
/// @{
///
/// \brief Default Constructor, initializes internal data to \f$null\f$ and the capacity to \f$0\f$
/// \brief Default Constructor, initializes internal data to \emph{null} and the capacity to \emph{0}
constexpr allocation() noexcept
: _data(nullptr), _capacity(0), _alignment(zero<align_t>()) {
}
///
/// \brief Sized Constructor, initializes the allocation with a block of size `n * sizeof(T)` bytes
/// \param n The number of elements of type \f$T\f$ to allocate for
/// \param n The number of elements of type \emph{T} to allocate for
explicit constexpr allocation(size_t n) noexcept
: _data(nullptr), _capacity(0), _alignment(zero<align_t>()) {
allocate(n);
@@ -389,7 +384,7 @@ public:
///
/// \brief Sized Constructor, initializes the allocation with a block of size `n * sizeof(T)` bytes
/// \param n The number of elements of type \f$T\f$ to allocate for
/// \param n The number of elements of type \emph{T} to allocate for
/// \param align The alignment of the allocation
constexpr allocation(size_t n, align_t align) noexcept
: _data(nullptr)
@@ -413,7 +408,7 @@ public:
/// \brief Allocator Constructor
/// \param alloc The allocation object to copy.
///
/// \details This constructor should be used when the type \f$AllocT\f$ needs internal data.
/// \details This constructor should be used when the type \emph{AllocT} needs internal data.
explicit constexpr allocation(const alloc_t& alloc) noexcept
: _alloc(alloc)
, _data(nullptr)
@@ -423,10 +418,10 @@ public:
///
/// \brief Sized Allocator Constructor
/// \param n The number of elements of type \f$T\f$ to allocate for
/// \param n The number of elements of type \emph{T} to allocate for
/// \param alloc The allocation object to copy.
///
/// \details This constructor should be used when the type \f$AllocT\f$ needs internal data.
/// \details This constructor should be used when the type \emph{AllocT} needs internal data.
constexpr allocation(size_t n, const alloc_t& alloc) noexcept
: _alloc(alloc)
, _data(nullptr)
@@ -442,7 +437,7 @@ public:
/// \param n the number of elements
/// \param alloc The allocation object to copy.
///
/// \details This constructor should be used when the type \f$AllocT\f$ needs internal data.
/// \details This constructor should be used when the type \emph{AllocT} needs internal data.
constexpr allocation(const T* data, size_t n, const alloc_t& alloc)
: allocation(n, alloc) {
fennec::memmove(static_cast<void*>(_data), data, n);
@@ -450,11 +445,11 @@ public:
///
/// \brief Sized Allocator Constructor
/// \param n The number of elements of type \f$T\f$ to allocate for
/// \param n The number of elements of type \emph{T} to allocate for
/// \param align The alignment of the allocation
/// \param alloc The allocation object to copy.
///
/// \details This constructor should be used when the type \f$AllocT\f$ needs internal data.
/// \details This constructor should be used when the type \emph{AllocT} needs internal data.
constexpr allocation(size_t n, align_t align, const alloc_t& alloc) noexcept
: _alloc(alloc)
, _data(nullptr)
@@ -471,7 +466,7 @@ public:
/// \param align The alignment of the allocation
/// \param alloc The allocation object to copy.
///
/// \details This constructor should be used when the type \f$AllocT\f$ needs internal data.
/// \details This constructor should be used when the type \emph{AllocT} needs internal data.
constexpr allocation(const T* data, size_t n, align_t align, const alloc_t& alloc)
: allocation(n, align, alloc) {
fennec::memmove(_data, data, n);
@@ -489,7 +484,7 @@ public:
}
///
/// \brief Move Constructor, moves the data in \f$alloc\f$ to the new object and cleans \f$alloc\f$ so that it
/// \brief Move Constructor, moves the data in \emph{alloc} to the new object and cleans \emph{alloc} so that it
/// can safely destruct
/// \param alloc The allocation to move
constexpr allocation(allocation&& alloc) noexcept
@@ -522,7 +517,7 @@ public:
///
/// \brief Copy Assignment Operator
/// \param alloc the allocation to copy
/// \returns a reference to \f$this\f$
/// \returns a reference to \emph{this}
constexpr allocation& operator=(const allocation& alloc) {
allocation::allocate(alloc.capacity(), alloc.alignment());
fennec::memmove(_data, alloc, size());
@@ -532,7 +527,7 @@ public:
///
/// \brief Move Assignment Operator
/// \param alloc the allocation to copy
/// \returns a reference to \f$this\f$
/// \returns a reference to \emph{this}
constexpr allocation& operator=(allocation&& alloc) noexcept {
// Copy contents
@@ -561,7 +556,7 @@ public:
}
///
/// \brief Getter for the number of elements \f$n\f$ of type \f$T\f$ that the allocation can hold.
/// \brief Getter for the number of elements \emph{n} of type \emph{T} that the allocation can hold.
/// \returns the size of the allocation in elements
constexpr size_t capacity() const {
return _capacity;
@@ -588,7 +583,7 @@ public:
/// \details If there is already an allocated block of memory, the previous allocation is released.
///
///
/// \param n The number of elements of type \f$T\f$ to allocate for
/// \param n The number of elements of type \emph{T} to allocate for
/// \param align The alignment to use
constexpr void allocate(size_t n, align_t align = zero<align_t>()) noexcept {
deallocate();
@@ -620,7 +615,7 @@ public:
/// \brief Reallocate the block with a new size.
/// Contents are copied to the new allocation.
///
/// \param n The number of elements of type \f$T\f$ to allocate for
/// \param n The number of elements of type \emph{T} to allocate for
/// \param align The alignment to use
constexpr void reallocate(size_t n, align_t align = zero<align_t>()) noexcept {
if (_data == nullptr) {
@@ -628,7 +623,8 @@ public:
return;
}
value_t* old = _data; size_t old_cap = _capacity;
value_t* old = _data;
const size_t old_cap = _capacity;
_data = nullptr;
allocate(n, align);
@@ -655,7 +651,7 @@ public:
///
/// \param i The index to access
/// \returns a reference to the value at position \f$i\f$ in the allocation
/// \returns a reference to the value at position \emph{i} in the allocation
constexpr value_t& operator[](size_t i) {
assertd(i < capacity(), "Array Out of Bounds");
return _data[i];
@@ -664,7 +660,7 @@ public:
///
/// \brief Array Access Operator
/// \param i The index to access
/// \returns a reference to the value at position \f$i\f$ in the allocation
/// \returns a reference to the value at position \emph{i} in the allocation
constexpr const value_t& operator[](size_t i) const {
assertd(i < capacity(), "Array Out of Bounds");
return _data[i];

16
include/fennec/memory/bytes.h
View File

@@ -89,27 +89,27 @@ public:
///
/// \brief Array Access Operator
/// \param i the index to access
/// \returns a reference to the byte at \f$i\f$
/// \returns a reference to the byte at \emph{i}
constexpr byte_t& operator[](int i) {
assertd(not _const, "Attempted to Access Const-Qualified Memory as Non-Const");
assertd(i >= 0 && (size_t)i < _size, "Array Out of Bounds");
assertd(i >= 0 && size_t(i) < _size, "Array Out of Bounds");
return _arr[i];
}
///
/// \brief Const Array Access Operator
/// \param i the index to access
/// \returns a copy of the byte at \f$i\f$
/// \returns a copy of the byte at \emph{i}
constexpr byte_t operator[](int i) const {
assertd(not _const, "Attempted to Access Const-Qualified Memory as Non-Const");
assertd(i >= 0 && (size_t)i < _size, "Array Out of Bounds");
assertd(i >= 0 && size_t(i) < _size, "Array Out of Bounds");
return _carr[i];
}
///
/// \brief Cast Function
/// \tparam T type to cast to
/// \returns a pointer to the underlying buffer interpreted as an array of \f$T\f$
/// \returns a pointer to the underlying buffer interpreted as an array of \emph{T}
template<typename T>
constexpr T* cast() {
void* temp = _arr;
@@ -119,7 +119,7 @@ public:
///
/// \brief Const Cast Function
/// \tparam T type to cast to
/// \returns a pointer to the underlying buffer interpreted as an array of \f$T\f$
/// \returns a pointer to the underlying buffer interpreted as an array of \emph{T}
template<typename T>
constexpr const T* cast() const {
const void* temp = _carr;
@@ -166,8 +166,8 @@ struct hash<byte_array> {
h *= m;
}
const uint8_t* b = (const uint8_t*)x;
switch (n & 7) {
const uint8_t* b = reinterpret_cast<const uint8_t*>(x);
switch (n & 0x7) {
case 7: h ^= uint64_t(b[6]) << 48; __attribute__((fallthrough));
case 6: h ^= uint64_t(b[5]) << 40; __attribute__((fallthrough));
case 5: h ^= uint64_t(b[4]) << 32; __attribute__((fallthrough));

199
include/fennec/memory/common.h
View File

@@ -38,6 +38,8 @@
namespace fennec
{
// addressof ===========================================================================================================
///
/// \brief Returns the address of an object regardless of whether the `&` operators is implemented.
/// \tparam TypeT The type of the objects
@@ -48,24 +50,45 @@ constexpr TypeT* addressof(TypeT& obj) {
return FENNEC_BUILTIN_ADDRESSOF(obj);
}
// memchr ==============================================================================================================
///
/// \brief Finds the first occurence of ```static_cast<uint8_t>(ch)``` in the first \f$n\f$ bytes
/// \brief Finds the first occurrence of `static_cast<uint8_t>(ch)` in the first \emph{n} bytes
/// \param arr Pointer to the object, interpreted as an array of bytes
/// \param ch The byte to search for
/// \param n The number of bytes to search
/// \returns A pointer to the location of \f$ch\f$, otherwise \f$nullptr\f$ if \f$ch\f$ is not found.
using ::memchr;
using ::wmemchr;
/// \returns A pointer to the location of \emph{ch}, otherwise \emph{nullptr} if \emph{ch} is not found.
constexpr const void* memchr(const void* arr, int ch, size_t n) {
return ::memchr(arr, ch, n);
}
///
/// \brief Compares the bytes of \f$lhs\f$ with \f$rhs\f$.
/// \brief Finds the first occurrence of `static_cast<wchar_t>(ch)` in the first \emph{n} characters
/// \param arr Pointer to the object, interpreted as an array of \emph{wchar_t}
/// \param ch The byte to search for
/// \param n The number of characters to search
/// \returns A pointer to the location of \emph{ch}, otherwise \emph{nullptr} if \emph{ch} is not found.
constexpr const wchar_t* wmemchr(const wchar_t* arr, wchar_t ch, size_t n) {
return ::wmemchr(arr, ch, n);
}
// memcmp ==============================================================================================================
///
/// \brief Compares the bytes of \emph{lhs} with \emph{rhs}.
/// \param lhs The first object, interpreted as an array of bytes
/// \param rhs The second object, interpreted as an array of bytes
/// \param n The number of bytes to parse
/// \returns \f$0\f$ if the first \f$n\f$ bytes of \f$lhs\f$ and \f$rhs\f$ are equivalent. Otherwise, returns \f$1\f$
/// for the first byte \f$b\f$ where \f$lhs[b] > \f$ rhs[b]\f$, and \f$-1\f$ for \f$
using ::memcmp;
using ::wmemcmp;
/// \returns \math{0} if the first \emph{n} bytes of \emph{lhs} and \emph{rhs} are equivalent. Otherwise, returns a positive value
/// for the first byte \math{b} where \math{\textbf{lhs}[b] > \textbf{rhs}[b]}, and a negative value
/// for the first byte \math{b} where \math{\textbf{lhs}[b] < \textbf{rhs}[b]}
constexpr int memcmp(const void* lhs, const void* rhs, size_t n) {
return ::memcmp(lhs, rhs, n);
}
///
/// \brief Safe version of memcmp
@@ -73,26 +96,58 @@ using ::wmemcmp;
/// \param rhs The second object, interpreted as an array of bytes
/// \param n0 The size, in bytes, of lhs
/// \param n1 The size, in bytes, of rhs
/// \returns \f$0\f$ if the first \f$min(n0, n1)\f$ bytes of \f$lhs\f$ and \f$rhs\f$ are equivalent. Otherwise, returns \f$1\f$
/// for the first byte \f$b\f$ where \f$lhs[b] > \f$ rhs[b]\f$, and \f$-1\f$ for \f$
/// \returns \math{0} if the first \emph{min(n0, n1)} bytes of \emph{lhs} and \emph{rhs} are equivalent. Otherwise, returns a positive value
/// for the first byte \math{b} where \math{\textbf{lhs}[b] > \textbf{rhs}[b]}, and a negative value
/// for the first byte \math{b} where \math{\textbf{lhs}[b] < \textbf{rhs}[b]}
constexpr int memcmp_s(const void* lhs, size_t n0, const void* rhs, size_t n1) {
return memcmp(lhs, rhs, n0 < n1 ? n0 : n1);
return ::memcmp(lhs, rhs, n0 < n1 ? n0 : n1);
}
///
/// \brief Compares the characters of \emph{lhs} with \emph{rhs}.
/// \param lhs The first object, interpreted as an array of \emph{wchar_t}
/// \param rhs The second object, interpreted as an array of \emph{wchar_t}
/// \param n The number of characters to parse
/// \returns \emph{0} if the first \emph{n} characters of \emph{lhs} and \emph{rhs} are equivalent. Otherwise, returns a positive value
/// for the first character \math{c} where \math{\textbf{lhs}[c] > \textbf{rhs}[c]}, and a negative value
/// for the first character \math{c} where \math{\textbf{lhs}[c] < \textbf{rhs}[c]}
constexpr int wmemcmp(const wchar_t* lhs, const wchar_t* rhs, size_t n) {
return ::wmemcmp(lhs, rhs, n);
}
///
/// \brief Copies the first \f$n\f$ bytes of \f$src\f$ to \f$dst\f$.
/// \brief Safe version of memcmp
/// \param lhs The first object, interpreted as an array of \emph{wchar_t}
/// \param rhs The second object, interpreted as an array of \emph{wchar_t}
/// \param n0 The size, in characters, of lhs
/// \param n1 The size, in characters, of rhs
/// \returns \emph{0} if the first \emph{min(n0, n1)} character of \emph{lhs} and \emph{rhs} are equivalent. Otherwise, returns a positive value
/// for the first character \math{c} where \math{\textbf{lhs}[c] > \textbf{rhs}[c]}, and a negative value
/// for the first character \math{c} where \math{\textbf{lhs}[c] < \textbf{rhs}[c]}
constexpr int wmemcmp_s(const wchar_t* lhs, size_t n0, const wchar_t* rhs, size_t n1) {
return ::wmemcmp(lhs, rhs, n0 < n1 ? n0 : n1);
}
// memcmp ==============================================================================================================
///
/// \brief Copies the first \emph{n} bytes of \emph{src} to \emph{dst}.
/// \param dst The destination object, interpreted as an array of bytes
/// \param src The source object, interpreted as an array of bytes
/// \param n The number of bytes to copy
/// \returns \f$dst\f$
/// \returns \emph{dst}
///
/// \details memcpy does not do any checking for whether \f$dst\f$ and \f$src\f$ overlap. Let \f$k\f$ be the number of
/// bytes of which \f$dst\f$ and \f$src\f$. If \f$k > 0 & src < dst\f$ then the first \f$k\f$ elements of
/// \f$src\f$ will be repeated in \f$dst\f$ with a period of \f$k\f$.
/// \details memcpy does not do any checking for whether \emph{dst} and \emph{src} overlap. Let \math{k} be the offset
/// by which \emph{dst} and \emph{src} overlap. If \math{k > 0 & \textbf{src} < \textbf{dst}} then the first \math{k} elements of
/// \emph{src} will be repeated in \emph{dst} with a period of \math{k}.
///
/// A full mathematical proof of this function is possible in Set Theory.
using ::memcpy;
using ::wmemcpy;
constexpr void* memcpy(void* dst, const void* src, size_t n) {
return ::memcpy(dst, src, n);
}
///
/// \brief Safe version of memcpy
@@ -100,19 +155,64 @@ using ::wmemcpy;
/// \param src The source object, interpreted as an array of bytes
/// \param n0 The size, in bytes, of dst
/// \param n1 The size, in bytes, of src
/// \returns \f$dst\f$
/// \returns \emph{dst}
///
/// \details memcpy does not do any checking for whether \emph{dst} and \emph{src} overlap. Let \math{k} be the offset
/// by which \emph{dst} and \emph{src} overlap. If \math{k > 0 & \textbf{src} < \textbf{dst}} then the first \math{k} elements of
/// \emph{src} will be repeated in \emph{dst} with a period of \math{k}.
///
/// A full mathematical proof of this function is possible in Set Theory.
constexpr void* memcpy_s(void* dst, size_t n0, const void* src, size_t n1) {
return memcpy(dst, src, n0 < n1 ? n0 : n1);
return ::memcpy(dst, src, n0 < n1 ? n0 : n1);
}
///
/// \brief Copies the first \emph{n} characters of \emph{src} to \emph{dst}.
/// \param dst The destination object, interpreted as an array of \emph{wchar_t}
/// \param src The source object, interpreted as an array of \emph{wchar_t}
/// \param n The number of characters to copy
/// \returns \emph{dst}
///
/// \details wmemcpy does not do any checking for whether \emph{dst} and \emph{src} overlap. Let \math{k} be the offset
/// by which \emph{dst} and \emph{src} overlap. If \math{k > 0 & \textbf{src} < \textbf{dst}} then the first \math{k} elements of
/// \emph{src} will be repeated in \emph{dst} with a period of \math{k}.
///
/// A full mathematical proof of this function is possible in Set Theory.
constexpr void* wmemcpy(wchar_t* dst, const wchar_t* src, size_t n) {
return ::wmemcpy(dst, src, n);
}
///
/// \brief Copies the first \f$n\f$ bytes of \f$src\f$ to \f$dst\f$, with overlap correction..
/// \brief Safe version of wmemcpy
/// \param dst The destination object, interpreted as an array of \emph{wchar_t}
/// \param src The source object, interpreted as an array of \emph{wchar_t}
/// \param n0 The size, in characters, of dst
/// \param n1 The size, in characters, of src
/// \returns \emph{dst}
///
/// \details wmemcpy does not do any checking for whether \emph{dst} and \emph{src} overlap. Let \math{k} be the offset
/// by which \emph{dst} and \emph{src} overlap. If \math{k > 0 & \textbf{src} < \textbf{dst}} then the first \math{k} elements of
/// \emph{src} will be repeated in \emph{dst} with a period of \math{k}.
///
/// A full mathematical proof of this function is possible in Set Theory.
constexpr void* wmemcpy_s(wchar_t* dst, size_t n0, const wchar_t* src, size_t n1) {
return ::wmemcpy(dst, src, n0 < n1 ? n0 : n1);
}
// memmove =============================================================================================================
///
/// \brief Copies the first \emph{n} bytes of \emph{src} to \emph{dst}, with overlap correction.
/// \param dst The destination object, interpreted as an array of bytes
/// \param src The source object, interpreted as an array of bytes
/// \param n The number of bytes to copy
/// \returns \f$dst\f$
using ::memmove;
using ::wmemmove;
/// \returns \emph{dst}
constexpr void* memmove(void* dst, const void* src, size_t n) {
return ::memmove(dst, src, n);
}
///
/// \brief Safe version of memmove
@@ -120,19 +220,54 @@ using ::wmemmove;
/// \param src The source object, interpreted as an array of bytes
/// \param n0 The size, in bytes, of dst
/// \param n1 The size, in bytes, of src
/// \returns \f$dst\f$
/// \returns \emph{dst}
constexpr void* memmove_s(void* dst, size_t n0, const void* src, size_t n1) {
return memmove(dst, src, n0 < n1 ? n0 : n1);
return ::memmove(dst, src, n0 < n1 ? n0 : n1);
}
///
/// \brief Copies the first \emph{n} characters of \emph{src} to \emph{dst}, with overlap correction.
/// \param dst The destination object, interpreted as an array of \emph{wchar_t}
/// \param src The source object, interpreted as an array of \emph{wchar_t}
/// \param n The number of characters to copy
/// \returns \emph{dst}
constexpr void* wmemmove(wchar_t* dst, const wchar_t* src, size_t n) {
return ::wmemmove(dst, src, n);
}
///
/// \brief Sets all bytes of \f$dst\f$ to \f$ch\f$, interpreted as an \f$uint8_t\f$
/// \brief Safe version of wmemmove
/// \param dst The destination object, interpreted as an array of \emph{wchar_t}
/// \param src The source object, interpreted as an array of \emph{wchar_t}
/// \param n0 The size, in characters, of dst
/// \param n1 The size, in characters, of src
/// \returns \emph{dst}
constexpr wchar_t* wmemmove_s(wchar_t* dst, size_t n0, const wchar_t* src, size_t n1) {
return ::wmemmove(dst, src, n0 < n1 ? n0 : n1);
}
// memset ==============================================================================================================
///
/// \brief Sets all bytes of \emph{dst} to \emph{ch}, interpreted as an \emph{uint8_t}
/// \param dst The destination object, interpreted as an array of bytes
/// \param ch The value, interpreted as an \f$uint8\_t\f$
/// \param ch The value, interpreted as an \emph{uint8_t}
/// \param n The number of bytes to set
/// \returns \f$dst\f$
using ::memset;
using ::wmemset;
constexpr void memset(void* dst, int ch, size_t n) {
::memset(dst, ch, n);
}
///
/// \brief Sets all characters of \emph{dst} to \emph{ch}
/// \param dst The destination object, interpreted as an array of \emph{wchar_t}
/// \param ch The value, interpreted as an \emph{uint8_t}
/// \param n The number of characters to set
constexpr void wmemset(wchar_t* dst, wchar_t ch, size_t n) {
::wmemset(dst, ch, n);
}
}

4
include/fennec/memory/detail/_string.h
View File

@@ -23,7 +23,7 @@
// see https://git.mslockbo.org/mslockbo/fennec/src/commit/0eeb7ae3cff9d78e98dc5d9fc09bcb98b10986b9 for previous
// implementation
#if FENNEC_COMPILER_GCC
#if FENNEC_GLIBC
#ifndef __OPTIMIZE__
# define __OPTIMIZE__
#else
@@ -34,7 +34,7 @@
#include <string.h>
#include <wchar.h>
#if FENNEC_COMPILER_GCC
#if FENNEC_GLIBC
#ifndef FENNEC_OPTIMIZE_FOUND
#undef __OPTIMIZE__
#endif

10
include/fennec/memory/new.h
View File

@@ -54,7 +54,7 @@ struct nothrow_t
size_t pagesize();
///
/// \brief Default construct the object of type \f$TypeT\f$ at \f$ptr\f$
/// \brief Default construct the object of type \emph{TypeT} at \emph{ptr}
/// \tparam TypeT the type to construct
/// \param ptr the pointer to the object to construct
template<typename TypeT> void construct(TypeT* ptr) {
@@ -62,7 +62,7 @@ template<typename TypeT> void construct(TypeT* ptr) {
}
///
/// \brief Copy construct the object of type \f$TypeT\f$ at \f$ptr\f$
/// \brief Copy construct the object of type \emph{TypeT} at \emph{ptr}
/// \tparam TypeT the type to construct
/// \param ptr the pointer to the object to construct
/// \param val the value to copy
@@ -71,7 +71,7 @@ template<typename TypeT> void construct(TypeT* ptr, const TypeT& val) {
}
///
/// \brief Move construct the object of type \f$TypeT\f$ at \f$ptr\f$
/// \brief Move construct the object of type \emph{TypeT} at \emph{ptr}
/// \tparam TypeT the type to construct
/// \param ptr the pointer to the object to construct
/// \param val the value to take ownership of
@@ -80,7 +80,7 @@ template<typename TypeT> void construct(TypeT* ptr, TypeT&& val) {
}
///
/// \brief Variadic construct the object of type \f$TypeT\f$ at \f$ptr\f$
/// \brief Variadic construct the object of type \emph{TypeT} at \emph{ptr}
/// \tparam TypeT the type to construct
/// \tparam ArgsT the argument types
/// \param ptr the pointer to the object to construct
@@ -90,7 +90,7 @@ template<typename TypeT, typename...ArgsT> void construct(TypeT* ptr, ArgsT&&...
}
///
/// \brief Destruct the object of type \f$TypeT\f$ at \f$ptr\f$
/// \brief Destruct the object of type \emph{TypeT} at \emph{ptr}
/// \tparam TypeT the type to destruct
/// \param ptr the pointer to the object to destruct
template<typename TypeT> void destruct(TypeT* ptr) {

33
include/fennec/memory/pointers.h
View File

@@ -26,7 +26,7 @@ namespace fennec
{
///
/// \brief Struct for wrapping C++ \f$delete\f$
/// \brief Struct for wrapping C++ \emph{delete}
/// \tparam TypeT The type of the buffer to be deleted
template<typename TypeT>
struct default_delete
@@ -42,7 +42,7 @@ struct default_delete
constexpr default_delete(const default_delete<ConvT>&) noexcept {}
///
/// \brief Function Call Operator, calls \f$delete\f$ on \f$ptr\f$
/// \brief Function Call Operator, calls \emph{delete} on \emph{ptr}
/// \param ptr Memory resource to delete
constexpr void operator()(TypeT* ptr) const noexcept {
static_assert(not is_void_v<TypeT>, "cannot delete a pointer to an incomplete type");
@@ -67,7 +67,7 @@ struct default_delete<TypeT[]>
constexpr default_delete(const default_delete<ConvT(*)[]>&) noexcept {}
///
/// \brief Function Call Operator, calls \f$delete\f$ on \f$ptr\f$
/// \brief Function Call Operator, calls \emph{delete} on \emph{ptr}
/// \param ptr Memory resource to delete
template<class ArrT> requires requires { is_convertible_v<ArrT(*)[], TypeT(*)[]> == true; }
constexpr void operator()(TypeT* ptr) const noexcept {
@@ -122,7 +122,7 @@ public:
constexpr unique_ptr(nullptr_t) noexcept : unique_ptr(nullptr, delete_t()) {}
///
/// \brief Pointer Constructor, creates a unique_ptr that owns \f$ptr\f$ with deleter \f$del\f$
/// \brief Pointer Constructor, creates a unique_ptr that owns \emph{ptr} with deleter \emph{del}
/// \param ptr The resource to own
/// \param del The deleter
explicit constexpr unique_ptr(pointer_t ptr, const delete_t& del = delete_t())
@@ -138,14 +138,16 @@ public:
}
///
/// \brief Move Constructor, transfers ownership from \f$other\f$
/// \brief Move Constructor, transfers ownership from \emph{other}
/// \param other The unique_ptr to take ownership from
template<typename DerivedT> requires(is_base_of_v<TypeT, DerivedT>)
constexpr unique_ptr(unique_ptr<DerivedT>&& other)
: _handle(other.release()) {
}
// Delete copy constructor
///
/// \brief Copy Constructor
/// \details Deleted
constexpr unique_ptr(const unique_ptr&) = delete;
///
@@ -166,18 +168,21 @@ public:
///
/// \brief move constructor
/// \param r the pointer to take ownership of
/// \returns a reference to self
/// \returns a reference to \emph{this}
constexpr unique_ptr& operator=(unique_ptr&& r) noexcept {
_delete = r._delete;
fennec::swap(_handle, r._handle);
return *this;
}
/// @}
private:
///
/// \brief Copy Assignment
/// \details Deleted
/// \returns Deleted
constexpr unique_ptr& operator=(const unique_ptr&) = delete;
/// @}
// Properties ==========================================================================================================
public:
@@ -186,14 +191,14 @@ public:
/// @{
///
/// \returns \f$true\f$ if there is not a held pointer, \f$false\f$ otherwise
/// \returns \emph{true} if there is not a held pointer, \emph{false} otherwise
bool is_empty() {
return _handle == nullptr;
}
///
/// \brief implicit boolean conversion
/// \returns \f$true\f$ if there is a held pointer, \f$false\f$ otherwise
/// \returns \emph{true} if there is a held pointer, \emph{false} otherwise
operator bool() const {
return _handle != nullptr;
}
@@ -278,11 +283,11 @@ private:
};
///
/// \brief Creates a unique pointer holding an object of type \f$TypeT\f$
/// \brief Creates a unique pointer holding an object of type \emph{TypeT}
/// \tparam TypeT The type
/// \tparam ArgsT The constructor arguments, automatically deduced
/// \param args The constructor arguments
/// \returns A unique pointer holding a heap allocated object of type \f$TypeT\f$ constructed with arguments \f$args\f$
/// \returns A unique pointer holding a heap allocated object of type \emph{TypeT} constructed with arguments \emph{args}
template<typename TypeT, typename...ArgsT>
unique_ptr<TypeT> make_unique(ArgsT&&...args) {
return unique_ptr<TypeT>(new TypeT(fennec::forward<ArgsT>(args)...));

10
include/fennec/platform/interface/display_server.h
View File

@@ -51,9 +51,9 @@ class display_server;
///
/// \details An implementation for a display server should inherit `display_server_base` and note the following:
///
/// For a server type \f$DisplayT\f$; any \f$gfxcontext\f$ implementation that wishes to implement \f$DisplayT\f$
/// must provide a constructor that accepts a `DisplayT*`. `DisplayT::ctx_registry::register_type` must then be
/// called for the \f$gfxcontext\f$ implementation.
/// For a server type \emph{DisplayT}; any `gfxcontext` implementation that wishes to implement \emph{DisplayT}
/// must provide a constructor that accepts a \emph{DisplayT*}. `DisplayT::ctx_registry::register_type()` must then be
/// called for the `gfxcontext` implementation.
class display_server : public type_registry<display_server, platform*> {
// Definitions & Constants =============================================================================================
public:
@@ -136,13 +136,13 @@ public:
///
/// \brief feature support checking function
/// \param feature the feature to check
/// \returns \f$true\f$ if the feature is supported, \f$false\f$ otherwise
/// \returns \emph{true} if the feature is supported, \emph{false} otherwise
bool has_feature(uint32_t feature) const {
return features.test(feature);
}
///
/// \returns \f$true\f$ if connected to the display server, \f$false\f$ otherwise
/// \returns \emph{true} if connected to the display server, \emph{false} otherwise
virtual bool connected() const = 0;
/// @}

8
include/fennec/platform/interface/platform.h
View File

@@ -87,14 +87,16 @@ public:
/// \brief constructor
platform();
///
/// \brief Copy Constructor
/// \details Deleted, no semantics for copying a platform
platform(const platform&) = delete;
///
/// \brief destructor
virtual ~platform() = default;
private:
platform(const platform&) = delete;
/// @}

82
include/fennec/platform/interface/window.h
View File

@@ -164,15 +164,21 @@ public:
///
/// \returns the current configuration of the window
const config& get_config() const { return cfg; }
const config& get_config() const {
return cfg;
}
///
/// \returns the parent window
window* get_parent() const { return parent; }
window* get_parent() const {
return parent;
}
///
/// \returns the nearest top-level window in the hierarchy
window* get_root() const { return root; }
window* get_root() const {
return root;
}
///
/// \returns the underlying handle of the window
@@ -208,19 +214,29 @@ public:
///
/// \returns the width of the window
int get_width() const { return state.rect.size.x; }
int get_width() const {
return state.rect.size.x;
}
///
/// \returns the height of the window
int get_height() const { return state.rect.size.y; }
int get_height() const {
return state.rect.size.y;
}
///
/// \returns the x position of the window
int get_pos_x() const { return state.rect.position.x; }
int get_pos_x() const {
return state.rect.position.x;
}
///
/// \returns the y position of the window
int get_pos_y() const { return state.rect.position.y; }
int get_pos_y() const {
return state.rect.position.y;
}
virtual void set_size(const ivec2& size) = 0;
/// @}
@@ -234,22 +250,22 @@ public:
///
/// \brief tests if the window is visible
/// \returns \f$true\f$ if the window is visible, \f$false\f$ otherwise
/// \returns \emph{true} if the window is visible, \emph{false} otherwise
bool is_visible() const { return state.flags.test(state_visible); }
///
/// \brief tests if the window is a child
/// \returns \f$true\f$ if the window is a child, \f$false\f$ otherwise
/// \returns \emph{true} if the window is a child, \emph{false} otherwise
bool is_child() const { return state.flags.test(state_child); }
///
/// \brief tests if the window is running
/// \returns \f$true\f$ if the window is running, \f$false\f$ otherwise
/// \returns \emph{true} if the window is running, \emph{false} otherwise
bool is_running() const { return state.flags.test(state_running); }
///
/// \brief tests if the window is suspended
/// \returns \f$true\f$ if the window is suspended, \f$false\f$ otherwise
/// \returns \emph{true} if the window is suspended, \emph{false} otherwise
bool is_suspended() const { return state.flags.test(state_suspended); }
/// @}
@@ -265,48 +281,48 @@ public:
///
/// \brief tests a specific flag
/// \param flag the flag from `window::flag_`
/// \returns \f$true\f$ if the flag is set, \f$false\f$ otherwise
/// \returns \emph{true} if the flag is set, \emph{false} otherwise
bool get_flag(uint8_t flag) const { return cfg.flags.test(flag); }
///
/// \brief check if the window is flagged to always be on top of other windows
/// \returns \f$true\f$ if set, \f$false\f$ otherwise
/// \returns \emph{true} if set, \emph{false} otherwise
bool is_always_on_top() const { return get_flag(flag_always_on_top); }
///
/// \brief check if the window is flagged to have no window decorations
/// \returns \f$true\f$ if set, \f$false\f$ otherwise
/// \returns \emph{true} if set, \emph{false} otherwise
bool is_borderless() const { return get_flag(flag_borderless); }
///
/// \brief check if the window is flagged to be modal
/// \returns \f$true\f$ if set, \f$false\f$ otherwise
/// \returns \emph{true} if set, \emph{false} otherwise
bool is_modal() const { return get_flag(flag_modal); }
///
/// \brief check if the window is flagged to pass mouse input to windows underneath from the same application
/// \returns \f$true\f$ if set, \f$false\f$ otherwise
/// \returns \emph{true} if set, \emph{false} otherwise
bool is_passing_mouse() const { return get_flag(flag_pass_mouse); }
///
/// \brief check if the window is flagged as a popup
/// \returns \f$true\f$ if set, \f$false\f$ otherwise
/// \returns \emph{true} if set, \emph{false} otherwise
bool is_popup() const { return get_flag(flag_popup); }
///
/// \brief check if the window is flagged to be resizable
/// \returns \f$true\f$ if set, \f$false\f$ otherwise
/// \returns \emph{true} if set, \emph{false} otherwise
bool is_resizable() const { return get_flag(flag_resizable); }
///
/// \brief check if the window is flagged to be transparent
/// \returns \f$true\f$ if set, \f$false\f$ otherwise
/// \returns \emph{true} if set, \emph{false} otherwise
bool is_transparent() const { return get_flag(flag_transparent); }
///
/// \brief check if the window is flagged to be unfocusable
/// \returns \f$true\f$ if set, \f$false\f$ otherwise
/// \returns \emph{true} if set, \emph{false} otherwise
bool is_no_focus() const { return get_flag(flag_no_focus); }
@@ -314,55 +330,55 @@ public:
/// \brief sets a specific flag
/// \param flag the flag from `window::flag_`
/// \param val the value to set the flag to
/// \returns \f$true\f$ on success, \f$false\f$ otherwise
/// \returns \emph{true} on success, \emph{false} otherwise
virtual bool set_flag(uint8_t flag, bool val) = 0;
///
/// \brief sets whether to always be on top of other windows
/// \param val the value to set the flag to
/// \returns \f$true\f$ on success, \f$false\f$ otherwise
/// \returns \emph{true} on success, \emph{false} otherwise
bool set_always_on_top(bool val) { return set_flag(flag_always_on_top, val); }
///
/// \brief sets whether to have no window decorations
/// \param val the value to set the flag to
/// \returns \f$true\f$ on success, \f$false\f$ otherwise
/// \returns \emph{true} on success, \emph{false} otherwise
bool set_borderless(bool val) { return set_flag(flag_borderless, val); }
///
/// \brief sets whether to be modal
/// \param val the value to set the flag to
/// \returns \f$true\f$ on success, \f$false\f$ otherwise
/// \returns \emph{true} on success, \emph{false} otherwise
bool set_modal(bool val) { return set_flag(flag_modal, val); }
///
/// \brief sets whether to pass mouse input to windows underneath from the same application
/// \param val the value to set the flag to
/// \returns \f$true\f$ on success, \f$false\f$ otherwise
/// \returns \emph{true} on success, \emph{false} otherwise
bool set_passing_mouse(bool val) { return set_flag(flag_pass_mouse, val); }
///
/// \brief sets whether the window is a popup
/// \param val the value to set the flag to
/// \returns \f$true\f$ on success, \f$false\f$ otherwise
/// \returns \emph{true} on success, \emph{false} otherwise
bool set_popup(bool val) { return set_flag(flag_popup, val); }
///
/// \brief sets whether to be resizable
/// \param val the value to set the flag to
/// \returns \f$true\f$ on success, \f$false\f$ otherwise
/// \returns \emph{true} on success, \emph{false} otherwise
bool set_resizable(bool val) { return set_flag(flag_resizable, val); }
///
/// \brief sets whetherto be transparent
/// \param val the value to set the flag to
/// \returns \f$true\f$ on success, \f$false\f$ otherwise
/// \returns \emph{true} on success, \emph{false} otherwise
bool set_transparent(bool val) { return set_flag(flag_transparent, val); }
///
/// \brief sets whether to be unfocusable
/// \param val the value to set the flag to
/// \returns \f$true\f$ on success, \f$false\f$ otherwise
/// \returns \emph{true} on success, \emph{false} otherwise
bool set_no_focus(bool val) { return set_flag(flag_no_focus, val); }
/// @}
@@ -385,10 +401,12 @@ public:
// Protected Member Variables ==========================================================================================
public:
display_server* const server; //!< the display server the window belongs to
window* const parent; //!< the parent window
window* const root; //!< the nearest top-level window in the hierarchy
protected:
display_server* const server; //!< the display server the window belongs to
window* const parent; //!< the parent window
window* root; //!< the nearest top-level window in the hierarchy
config cfg; //!< the current configuration
state state; //!< the current state
unique_ptr<gfxsurface> gfx_surface; //!< the corresponding graphics surface

13
include/fennec/platform/linux/platform.h
View File

@@ -23,6 +23,8 @@
namespace fennec
{
///
/// \brief Platform Implementation for Linux-Based Operating Systems
class linux_platform : public unix_platform {
// Constructors & Destructor ===========================================================================================
@@ -31,7 +33,7 @@ public:
/// \name Constructors & Destructor ================================================================================
/// @{
/// \brief constructor
/// \brief Linux Platform Constructor
linux_platform()
: unix_platform() {
}
@@ -39,11 +41,18 @@ public:
/// @}
//
// Initialization ======================================================================================================
/// \name Initialization
/// @{
void initialize() override; //!< platform initialization
void shutdown() override; //!< platform shutdown
/// @}
private:
FENNEC_RTTI_CLASS_ENABLE(unix_platform) {
}
};

337
include/fennec/platform/linux/wayland/lib/headers/wayland-client-protocols.h
View File

@@ -1,4 +1,4 @@
/* Generated by wayland-scanner 1.24.0 */
/* Generated by wayland-scanner 1.25.0 */
#ifndef WAYLAND_CLIENT_PROTOCOL_H
#define WAYLAND_CLIENT_PROTOCOL_H
@@ -841,23 +841,9 @@ extern const struct wl_interface wl_subcompositor_interface;
* hidden, or if a NULL wl_buffer is applied. These rules apply
* recursively through the tree of surfaces.
*
* The behaviour of a wl_surface.commit request on a sub-surface
* depends on the sub-surface's mode. The possible modes are
* synchronized and desynchronized, see methods
* wl_subsurface.set_sync and wl_subsurface.set_desync. Synchronized
* mode caches the wl_surface state to be applied when the parent's
* state gets applied, and desynchronized mode applies the pending
* wl_surface state directly. A sub-surface is initially in the
* synchronized mode.
*
* Sub-surfaces also have another kind of state, which is managed by
* wl_subsurface requests, as opposed to wl_surface requests. This
* state includes the sub-surface position relative to the parent
* surface (wl_subsurface.set_position), and the stacking order of
* the parent and its sub-surfaces (wl_subsurface.place_above and
* .place_below). This state is applied when the parent surface's
* wl_surface state is applied, regardless of the sub-surface's mode.
* As the exception, set_sync and set_desync are effective immediately.
* A sub-surface can be in one of two modes. The possible modes are
* synchronized and desynchronized, see methods wl_subsurface.set_sync and
* wl_subsurface.set_desync.
*
* The main surface can be thought to be always in desynchronized mode,
* since it does not have a parent in the sub-surfaces sense.
@@ -869,6 +855,15 @@ extern const struct wl_interface wl_subcompositor_interface;
* synchronized mode, and then assume that all its child and grand-child
* sub-surfaces are synchronized, too, without explicitly setting them.
*
* If a surface behaves as in synchronized mode, it is effectively
* synchronized, otherwise it is effectively desynchronized.
*
* A sub-surface is initially in the synchronized mode.
*
* The wl_subsurface interface has requests which modify double-buffered
* state of the parent surface (wl_subsurface.set_position, .place_above and
* .place_below).
*
* Destroying a sub-surface takes effect immediately. If you need to
* synchronize the removal of a sub-surface to the parent surface update,
* unmap the sub-surface first by attaching a NULL wl_buffer, update parent,
@@ -899,23 +894,9 @@ extern const struct wl_interface wl_subcompositor_interface;
* hidden, or if a NULL wl_buffer is applied. These rules apply
* recursively through the tree of surfaces.
*
* The behaviour of a wl_surface.commit request on a sub-surface
* depends on the sub-surface's mode. The possible modes are
* synchronized and desynchronized, see methods
* wl_subsurface.set_sync and wl_subsurface.set_desync. Synchronized
* mode caches the wl_surface state to be applied when the parent's
* state gets applied, and desynchronized mode applies the pending
* wl_surface state directly. A sub-surface is initially in the
* synchronized mode.
*
* Sub-surfaces also have another kind of state, which is managed by
* wl_subsurface requests, as opposed to wl_surface requests. This
* state includes the sub-surface position relative to the parent
* surface (wl_subsurface.set_position), and the stacking order of
* the parent and its sub-surfaces (wl_subsurface.place_above and
* .place_below). This state is applied when the parent surface's
* wl_surface state is applied, regardless of the sub-surface's mode.
* As the exception, set_sync and set_desync are effective immediately.
* A sub-surface can be in one of two modes. The possible modes are
* synchronized and desynchronized, see methods wl_subsurface.set_sync and
* wl_subsurface.set_desync.
*
* The main surface can be thought to be always in desynchronized mode,
* since it does not have a parent in the sub-surfaces sense.
@@ -927,6 +908,15 @@ extern const struct wl_interface wl_subcompositor_interface;
* synchronized mode, and then assume that all its child and grand-child
* sub-surfaces are synchronized, too, without explicitly setting them.
*
* If a surface behaves as in synchronized mode, it is effectively
* synchronized, otherwise it is effectively desynchronized.
*
* A sub-surface is initially in the synchronized mode.
*
* The wl_subsurface interface has requests which modify double-buffered
* state of the parent surface (wl_subsurface.set_position, .place_above and
* .place_below).
*
* Destroying a sub-surface takes effect immediately. If you need to
* synchronize the removal of a sub-surface to the parent surface update,
* unmap the sub-surface first by attaching a NULL wl_buffer, update parent,
@@ -1307,6 +1297,7 @@ wl_callback_destroy(struct wl_callback *wl_callback)
#define WL_COMPOSITOR_CREATE_SURFACE 0
#define WL_COMPOSITOR_CREATE_REGION 1
#define WL_COMPOSITOR_RELEASE 2
/**
@@ -1317,6 +1308,10 @@ wl_callback_destroy(struct wl_callback *wl_callback)
* @ingroup iface_wl_compositor
*/
#define WL_COMPOSITOR_CREATE_REGION_SINCE_VERSION 1
/**
* @ingroup iface_wl_compositor
*/
#define WL_COMPOSITOR_RELEASE_SINCE_VERSION 7
/** @ingroup iface_wl_compositor */
static inline void
@@ -1377,6 +1372,18 @@ wl_compositor_create_region(struct wl_compositor *wl_compositor)
return (struct wl_region *) id;
}
/**
* @ingroup iface_wl_compositor
*
* This request destroys the wl_compositor. This has no effect on any other objects.
*/
static inline void
wl_compositor_release(struct wl_compositor *wl_compositor)
{
wl_proxy_marshal_flags((struct wl_proxy *) wl_compositor,
WL_COMPOSITOR_RELEASE, NULL, wl_proxy_get_version((struct wl_proxy *) wl_compositor), WL_MARSHAL_FLAG_DESTROY);
}
#define WL_SHM_POOL_CREATE_BUFFER 0
#define WL_SHM_POOL_DESTROY 1
#define WL_SHM_POOL_RESIZE 2
@@ -1516,7 +1523,8 @@ enum wl_shm_error {
*
* The drm format codes match the macros defined in drm_fourcc.h, except
* argb8888 and xrgb8888. The formats actually supported by the compositor
* will be reported by the format event.
* will be reported by the format event. See drm_fourcc.h for more detailed
* format descriptions.
*
* For all wl_shm formats and unless specified in another protocol
* extension, pre-multiplied alpha is used for pixel values.
@@ -1978,6 +1986,86 @@ enum wl_shm_format {
* 2x2 subsampled Cr:Cb plane 10 bits per channel packed
*/
WL_SHM_FORMAT_P030 = 0x30333050,
/**
* [47:0] R:G:B 16:16:16 little endian
*/
WL_SHM_FORMAT_RGB161616 = 0x38344752,
/**
* [47:0] B:G:R 16:16:16 little endian
*/
WL_SHM_FORMAT_BGR161616 = 0x38344742,
/**
* [15:0] R 16 little endian
*/
WL_SHM_FORMAT_R16F = 0x48202052,
/**
* [31:0] G:R 16:16 little endian
*/
WL_SHM_FORMAT_GR1616F = 0x48205247,
/**
* [47:0] B:G:R 16:16:16 little endian
*/
WL_SHM_FORMAT_BGR161616F = 0x48524742,
/**
* [31:0] R 32 little endian
*/
WL_SHM_FORMAT_R32F = 0x46202052,
/**
* [63:0] R:G 32:32 little endian
*/
WL_SHM_FORMAT_GR3232F = 0x46205247,
/**
* [95:0] R:G:B 32:32:32 little endian
*/
WL_SHM_FORMAT_BGR323232F = 0x46524742,
/**
* [127:0] R:G:B:A 32:32:32:32 little endian
*/
WL_SHM_FORMAT_ABGR32323232F = 0x46384241,
/**
* 2x1 subsampled Cr:Cb plane
*/
WL_SHM_FORMAT_NV20 = 0x3032564e,
/**
* non-subsampled Cr:Cb plane
*/
WL_SHM_FORMAT_NV30 = 0x3033564e,
/**
* 2x2 subsampled Cb (1) and Cr (2) planes 10 bits per channel
*/
WL_SHM_FORMAT_S010 = 0x30313053,
/**
* 2x1 subsampled Cb (1) and Cr (2) planes 10 bits per channel
*/
WL_SHM_FORMAT_S210 = 0x30313253,
/**
* non-subsampled Cb (1) and Cr (2) planes 10 bits per channel
*/
WL_SHM_FORMAT_S410 = 0x30313453,
/**
* 2x2 subsampled Cb (1) and Cr (2) planes 12 bits per channel
*/
WL_SHM_FORMAT_S012 = 0x32313053,
/**
* 2x1 subsampled Cb (1) and Cr (2) planes 12 bits per channel
*/
WL_SHM_FORMAT_S212 = 0x32313253,
/**
* non-subsampled Cb (1) and Cr (2) planes 12 bits per channel
*/
WL_SHM_FORMAT_S412 = 0x32313453,
/**
* 2x2 subsampled Cb (1) and Cr (2) planes 16 bits per channel
*/
WL_SHM_FORMAT_S016 = 0x36313053,
/**
* 2x1 subsampled Cb (1) and Cr (2) planes 16 bits per channel
*/
WL_SHM_FORMAT_S216 = 0x36313253,
/**
* non-subsampled Cb (1) and Cr (2) planes 16 bits per channel
*/
WL_SHM_FORMAT_S416 = 0x36313453,
};
#endif /* WL_SHM_FORMAT_ENUM */
@@ -1991,6 +2079,11 @@ struct wl_shm_listener {
*
* Informs the client about a valid pixel format that can be used
* for buffers. Known formats include argb8888 and xrgb8888.
*
* Extensions to drm_fourcc.h (or the format enum) do not require
* increasing the wl_shm version; as a result, clients may receive
* format codes which were not in the list at the time the client
* was made.
* @param format buffer pixel format
*/
void (*format)(void *data,
@@ -3056,6 +3149,7 @@ enum wl_data_device_manager_dnd_action {
#define WL_DATA_DEVICE_MANAGER_CREATE_DATA_SOURCE 0
#define WL_DATA_DEVICE_MANAGER_GET_DATA_DEVICE 1
#define WL_DATA_DEVICE_MANAGER_RELEASE 2
/**
@@ -3066,6 +3160,10 @@ enum wl_data_device_manager_dnd_action {
* @ingroup iface_wl_data_device_manager
*/
#define WL_DATA_DEVICE_MANAGER_GET_DATA_DEVICE_SINCE_VERSION 1
/**
* @ingroup iface_wl_data_device_manager
*/
#define WL_DATA_DEVICE_MANAGER_RELEASE_SINCE_VERSION 4
/** @ingroup iface_wl_data_device_manager */
static inline void
@@ -3126,6 +3224,19 @@ wl_data_device_manager_get_data_device(struct wl_data_device_manager *wl_data_de
return (struct wl_data_device *) id;
}
/**
* @ingroup iface_wl_data_device_manager
*
* This request destroys the wl_data_device_manager. This has no effect on any other
* objects.
*/
static inline void
wl_data_device_manager_release(struct wl_data_device_manager *wl_data_device_manager)
{
wl_proxy_marshal_flags((struct wl_proxy *) wl_data_device_manager,
WL_DATA_DEVICE_MANAGER_RELEASE, NULL, wl_proxy_get_version((struct wl_proxy *) wl_data_device_manager), WL_MARSHAL_FLAG_DESTROY);
}
#ifndef WL_SHELL_ERROR_ENUM
#define WL_SHELL_ERROR_ENUM
enum wl_shell_error {
@@ -3691,6 +3802,10 @@ enum wl_surface_error {
* surface was destroyed before its role object
*/
WL_SURFACE_ERROR_DEFUNCT_ROLE_OBJECT = 4,
/**
* no buffer was attached
*/
WL_SURFACE_ERROR_NO_BUFFER = 5,
};
#endif /* WL_SURFACE_ERROR_ENUM */
@@ -3795,6 +3910,7 @@ wl_surface_add_listener(struct wl_surface *wl_surface,
#define WL_SURFACE_SET_BUFFER_SCALE 8
#define WL_SURFACE_DAMAGE_BUFFER 9
#define WL_SURFACE_OFFSET 10
#define WL_SURFACE_GET_RELEASE 11
/**
* @ingroup iface_wl_surface
@@ -3857,6 +3973,10 @@ wl_surface_add_listener(struct wl_surface *wl_surface,
* @ingroup iface_wl_surface
*/
#define WL_SURFACE_OFFSET_SINCE_VERSION 5
/**
* @ingroup iface_wl_surface
*/
#define WL_SURFACE_GET_RELEASE_SINCE_VERSION 7
/** @ingroup iface_wl_surface */
static inline void
@@ -3937,9 +4057,11 @@ wl_surface_destroy(struct wl_surface *wl_surface)
* If a pending wl_buffer has been committed to more than one wl_surface,
* the delivery of wl_buffer.release events becomes undefined. A well
* behaved client should not rely on wl_buffer.release events in this
* case. Alternatively, a client could create multiple wl_buffer objects
* from the same backing storage or use a protocol extension providing
* per-commit release notifications.
* case. Instead, clients hitting this case should use
* wl_surface.get_release or use a protocol extension providing per-commit
* release notifications (if none of these options are available, a
* fallback can be implemented by creating multiple wl_buffer objects from
* the same backing storage).
*
* Destroying the wl_buffer after wl_buffer.release does not change
* the surface contents. Destroying the wl_buffer before wl_buffer.release
@@ -4120,21 +4242,48 @@ wl_surface_set_input_region(struct wl_surface *wl_surface, struct wl_region *reg
* etc.) is double-buffered. Protocol requests modify the pending state,
* as opposed to the active state in use by the compositor.
*
* A commit request atomically creates a content update from the pending
* state, even if the pending state has not been touched. The content
* update is placed in a queue until it becomes active. After commit, the
* new pending state is as documented for each related request.
*
* When the content update is applied, the wl_buffer is applied before all
* other state. This means that all coordinates in double-buffered state
* are relative to the newly attached wl_buffers, except for
* wl_surface.attach itself. If there is no newly attached wl_buffer, the
* coordinates are relative to the previous content update.
*
* All requests that need a commit to become effective are documented
* to affect double-buffered state.
*
* Other interfaces may add further double-buffered surface state.
*
* A commit request atomically creates a Content Update (CU) from the
* pending state, even if the pending state has not been touched. The
* content update is placed at the end of a per-surface queue until it
* becomes active. After commit, the new pending state is as documented for
* each related request.
*
* A CU is either a Desync Content Update (DCU) or a Sync Content Update
* (SCU). If the surface is effectively synchronized at the commit request,
* it is a SCU, otherwise a DCU.
*
* When a surface transitions from effectively synchronized to effectively
* desynchronized, all SCUs in its queue which are not reachable by any
* DCU become DCUs and dependency edges from outside the queue to these CUs
* are removed.
*
* See wl_subsurface for the definition of 'effectively synchronized' and
* 'effectively desynchronized'.
*
* When a CU is placed in the queue, the CU has a dependency on the CU in
* front of it and to the SCU at end of the queue of every direct child
* surface if that SCU exists and does not have another dependent. This can
* form a directed acyclic graph of CUs with dependencies as edges.
*
* In addition to surface state, the CU can have constraints that must be
* satisfied before it can be applied. Other interfaces may add CU
* constraints.
*
* All DCUs which do not have a SCU in front of themselves in their queue,
* are candidates. If the graph that's reachable by a candidate does not
* have any unsatisfied constraints, the entire graph must be applied
* atomically.
*
* When a CU is applied, the wl_buffer is applied before all other state.
* This means that all coordinates in double-buffered state are relative to
* the newly attached wl_buffers, except for wl_surface.attach itself. If
* there is no newly attached wl_buffer, the coordinates are relative to
* the previous content update.
*/
static inline void
wl_surface_commit(struct wl_surface *wl_surface)
@@ -4288,6 +4437,39 @@ wl_surface_offset(struct wl_surface *wl_surface, int32_t x, int32_t y)
WL_SURFACE_OFFSET, NULL, wl_proxy_get_version((struct wl_proxy *) wl_surface), 0, x, y);
}
/**
* @ingroup iface_wl_surface
*
* Create a callback for the release of the buffer attached by the client
* with wl_surface.attach.
*
* The compositor will release the buffer when it has finished its usage of
* the underlying storage for the relevant commit. Once the client receives
* this event, and assuming the associated buffer is not pending release
* from other wl_surface.commit requests, the client can safely re-use the
* buffer.
*
* Release callbacks are double-buffered state, and will be associated
* with the pending buffer at wl_surface.commit time.
*
* The callback_data passed in the wl_callback.done event is unused and
* is always zero.
*
* Sending this request without attaching a non-null buffer in the same
* content update is a protocol error. The compositor will send the
* no_buffer error in this case.
*/
static inline struct wl_callback *
wl_surface_get_release(struct wl_surface *wl_surface)
{
struct wl_proxy *callback;
callback = wl_proxy_marshal_flags((struct wl_proxy *) wl_surface,
WL_SURFACE_GET_RELEASE, &wl_callback_interface, wl_proxy_get_version((struct wl_proxy *) wl_surface), 0, NULL);
return (struct wl_callback *) callback;
}
#ifndef WL_SEAT_CAPABILITY_ENUM
#define WL_SEAT_CAPABILITY_ENUM
/**
@@ -6344,20 +6526,18 @@ wl_subsurface_destroy(struct wl_subsurface *wl_subsurface)
/**
* @ingroup iface_wl_subsurface
*
* This schedules a sub-surface position change.
* This sets the position of the sub-surface, relative to the parent
* surface.
*
* The sub-surface will be moved so that its origin (top left
* corner pixel) will be at the location x, y of the parent surface
* coordinate system. The coordinates are not restricted to the parent
* surface area. Negative values are allowed.
*
* The scheduled coordinates will take effect whenever the state of the
* parent surface is applied.
*
* If more than one set_position request is invoked by the client before
* the commit of the parent surface, the position of a new request always
* replaces the scheduled position from any previous request.
*
* The initial position is 0, 0.
*
* Position is double-buffered state on the parent surface, see
* wl_subsurface and wl_surface.commit for more information.
*/
static inline void
wl_subsurface_set_position(struct wl_subsurface *wl_subsurface, int32_t x, int32_t y)
@@ -6375,13 +6555,11 @@ wl_subsurface_set_position(struct wl_subsurface *wl_subsurface, int32_t x, int32
* parent surface. Using any other surface, including this sub-surface,
* will cause a protocol error.
*
* The z-order is double-buffered. Requests are handled in order and
* applied immediately to a pending state. The final pending state is
* copied to the active state the next time the state of the parent
* surface is applied.
*
* A new sub-surface is initially added as the top-most in the stack
* of its siblings and parent.
*
* Z-order is double-buffered state on the parent surface, see
* wl_subsurface and wl_surface.commit for more information.
*/
static inline void
wl_subsurface_place_above(struct wl_subsurface *wl_subsurface, struct wl_surface *sibling)
@@ -6394,6 +6572,7 @@ wl_subsurface_place_above(struct wl_subsurface *wl_subsurface, struct wl_surface
* @ingroup iface_wl_subsurface
*
* The sub-surface is placed just below the reference surface.
*
* See wl_subsurface.place_above.
*/
static inline void
@@ -6407,18 +6586,9 @@ wl_subsurface_place_below(struct wl_subsurface *wl_subsurface, struct wl_surface
* @ingroup iface_wl_subsurface
*
* Change the commit behaviour of the sub-surface to synchronized
* mode, also described as the parent dependent mode.
* mode.
*
* In synchronized mode, wl_surface.commit on a sub-surface will
* accumulate the committed state in a cache, but the state will
* not be applied and hence will not change the compositor output.
* The cached state is applied to the sub-surface immediately after
* the parent surface's state is applied. This ensures atomic
* updates of the parent and all its synchronized sub-surfaces.
* Applying the cached state will invalidate the cache, so further
* parent surface commits do not (re-)apply old state.
*
* See wl_subsurface for the recursive effect of this mode.
* See wl_subsurface and wl_surface.commit for more information.
*/
static inline void
wl_subsurface_set_sync(struct wl_subsurface *wl_subsurface)
@@ -6431,24 +6601,9 @@ wl_subsurface_set_sync(struct wl_subsurface *wl_subsurface)
* @ingroup iface_wl_subsurface
*
* Change the commit behaviour of the sub-surface to desynchronized
* mode, also described as independent or freely running mode.
* mode.
*
* In desynchronized mode, wl_surface.commit on a sub-surface will
* apply the pending state directly, without caching, as happens
* normally with a wl_surface. Calling wl_surface.commit on the
* parent surface has no effect on the sub-surface's wl_surface
* state. This mode allows a sub-surface to be updated on its own.
*
* If cached state exists when wl_surface.commit is called in
* desynchronized mode, the pending state is added to the cached
* state, and applied as a whole. This invalidates the cache.
*
* Note: even if a sub-surface is set to desynchronized, a parent
* sub-surface may override it to behave as synchronized. For details,
* see wl_subsurface.
*
* If a surface's parent surface behaves as desynchronized, then
* the cached state is applied on set_desync.
* See wl_subsurface and wl_surface.commit for more information.
*/
static inline void
wl_subsurface_set_desync(struct wl_subsurface *wl_subsurface)

2
include/fennec/platform/linux/wayland/lib/headers/xdg-shell-client-protocols.h
View File

@@ -1,4 +1,4 @@
/* Generated by wayland-scanner 1.24.0 */
/* Generated by wayland-scanner 1.25.0 */
#ifndef XDG_SHELL_CLIENT_PROTOCOL_H
#define XDG_SHELL_CLIENT_PROTOCOL_H

2906
include/fennec/platform/linux/wayland/lib/protocols/wayland.xml
View File

File diff suppressed because it is too large Load Diff

2
include/fennec/platform/linux/wayland/server.h
View File

@@ -81,7 +81,7 @@ public:
void connect() override; //!< connect to wayland
void disconnect() override; //!< disconnect from wayland
bool connected() const override; //!< check if connected to wayland \returns \f$true\f$ if connected, \f$false\f$ otherwise
bool connected() const override; //!< check if connected to wayland \returns \emph{true} if connected, \emph{false} otherwise
void dispatch() override; //!< dispatch the current context

74
include/fennec/platform/linux/wayland/vulkan/context.h Normal file
View File

@@ -0,0 +1,74 @@
// =====================================================================================================================
// fennec, a free and open source game engine
// Copyright © 2025 Medusa Slockbower
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <https://www.gnu.org/licenses/>.
// =====================================================================================================================
///
/// \file context.h
/// \brief
///
///
/// \details
/// \author Medusa Slockbower
///
/// \copyright Copyright © 2025 - 2026 Medusa Slockbower ([GPLv3](https://www.gnu.org/licenses/gpl-3.0.en.html))
///
///
#ifndef FENNEC_PLATFORM_LINUX_WAYLAND_VULKAN_CONTEXT_H
#define FENNEC_PLATFORM_LINUX_WAYLAND_VULKAN_CONTEXT_H
#include <fennec/renderers/vulkan/vkcontext.h>
#include <fennec/platform/linux/wayland/server.h>
namespace fennec
{
class wayland_vkcontext : public vkcontext {
// Definitions & Constants =============================================================================================
public:
///
/// \brief Required Extensions
inline static const dynarray<cstring> extensions = {
VK_KHR_WAYLAND_SURFACE_EXTENSION_NAME
};
// Constructors & Destructor ===========================================================================================
public:
explicit wayland_vkcontext(display_server* display);
~wayland_vkcontext();
// Operations ==========================================================================================================
public:
gfxsurface* create_surface(window* window) override;
// Private Member Variables ============================================================================================
private:
FENNEC_RTTI_CLASS_ENABLE(vkcontext) {
wayland_server::ctx_registry::register_type<wayland_vkcontext>();
}
};
}
#endif // FENNEC_PLATFORM_LINUX_WAYLAND_VULKAN_CONTEXT_H

4
include/fennec/platform/linux/wayland/window.h
View File

@@ -76,6 +76,8 @@ public:
/// @}
void set_size(const ivec2& size) override;
// Behaviour Flags =====================================================================================================
public:
@@ -86,7 +88,7 @@ public:
/// \brief sets a specific flag
/// \param flag the flag from `window::flag_`
/// \param val the value to set the flag to
/// \returns \f$true\f$ on success, \f$false\f$ otherwise
/// \returns \emph{true} on success, \emph{false} otherwise
bool set_flag(uint8_t flag, bool val) override;
/// @}

2
include/fennec/platform/opengl/egl/context.h
View File

@@ -66,7 +66,7 @@ public:
//
///
/// \returns \f$true\f$ if the context is valid, \f$false\f$ otherwise
/// \returns \emph{true} if the context is valid, \emph{false} otherwise
bool is_valid() override;
private:

2
include/fennec/platform/opengl/egl/error.h
View File

@@ -37,7 +37,7 @@
/// \brief convert egl error to a readable string
/// \param err the error code
/// \returns the error string corresponding to \f$err\f$
/// \returns the error string corresponding to \emph{err}
inline fennec::cstring eglErrorString(EGLint err) {
switch (err) {
case EGL_SUCCESS: return "None";

2176
include/fennec/platform/vulkan/volk/volk.h Normal file
View File

File diff suppressed because it is too large Load Diff

43
include/fennec/platform/window_manager.h
View File

@@ -104,12 +104,13 @@ public:
/// \brief destructor
~window_manager();
/// @}
private:
///
/// \brief Copy Constructor
/// \details Deleted, no semantics for copying a platform
window_manager(const window_manager&) = delete;
/// @}
// Initialization & Update =============================================================================================
public:
@@ -247,7 +248,7 @@ public:
/// \brief tests if the window is visible
///
/// \param window The window.
/// \returns \f$true\f$ if the window is visible, \f$false\f$ otherwise
/// \returns \emph{true} if the window is visible, \emph{false} otherwise
bool is_visible(window_id window) const {
lock_guard guard(_lock);
return _check_state(window, window::state_visible);
@@ -257,7 +258,7 @@ public:
/// \brief tests if the window is a child
///
/// \param window The window.
/// \returns \f$true\f$ if the window is a child, \f$false\f$ otherwise
/// \returns \emph{true} if the window is a child, \emph{false} otherwise
bool is_child(window_id window) const {
lock_guard guard(_lock);
return _check_state(window, window::state_child);
@@ -267,7 +268,7 @@ public:
/// \brief tests if the window is running
///
/// \param window The window.
/// \returns \f$true\f$ if the window is running, \f$false\f$ otherwise
/// \returns \emph{true} if the window is running, \emph{false} otherwise
bool is_running(window_id window) const {
lock_guard guard(_lock);
return _check_state(window, window::state_running);
@@ -277,7 +278,7 @@ public:
/// \brief tests if the window is suspended
///
/// \param window The window.
/// \returns \f$true\f$ if the window is suspended, \f$false\f$ otherwise
/// \returns \emph{true} if the window is suspended, \emph{false} otherwise
bool is_suspended(window_id window) const {
lock_guard guard(_lock);
return _check_state(window, window::state_suspended);
@@ -297,7 +298,7 @@ public:
///
/// \param window The window.
/// \param flag the flag from `window::flag_`
/// \returns \f$true\f$ if the flag is set, \f$false\f$ otherwise
/// \returns \emph{true} if the flag is set, \emph{false} otherwise
bool get_flag(window_id window, uint8_t flag) {
lock_guard guard(_lock);
return _get_flag(window, flag);
@@ -308,7 +309,7 @@ public:
/// \brief check if the window is flagged to always be on top of other windows
///
/// \param window The window.
/// \returns \f$true\f$ if set, \f$false\f$ otherwise
/// \returns \emph{true} if set, \emph{false} otherwise
bool is_always_on_top(window_id window) {
return get_flag(window, window::flag_always_on_top);
}
@@ -317,7 +318,7 @@ public:
/// \brief check if the window is flagged to have no window decorations
///
/// \param window The window.
/// \returns \f$true\f$ if set, \f$false\f$ otherwise
/// \returns \emph{true} if set, \emph{false} otherwise
bool is_borderless(window_id window) {
return get_flag(window, window::flag_borderless);
}
@@ -326,7 +327,7 @@ public:
/// \brief check if the window is flagged to be modal
///
/// \param window The window.
/// \returns \f$true\f$ if set, \f$false\f$ otherwise
/// \returns \emph{true} if set, \emph{false} otherwise
bool is_modal(window_id window) {
return get_flag(window, window::flag_modal);
}
@@ -335,7 +336,7 @@ public:
/// \brief check if the window is flagged to pass mouse input to windows underneath from the same application
///
/// \param window The window.
/// \returns \f$true\f$ if set, \f$false\f$ otherwise
/// \returns \emph{true} if set, \emph{false} otherwise
bool is_passing_mouse(window_id window) {
return get_flag(window, window::flag_pass_mouse);
}
@@ -344,7 +345,7 @@ public:
/// \brief check if the window is flagged as a popup
///
/// \param window The window.
/// \returns \f$true\f$ if set, \f$false\f$ otherwise
/// \returns \emph{true} if set, \emph{false} otherwise
bool is_popup(window_id window) {
return get_flag(window, window::flag_popup);
}
@@ -353,7 +354,7 @@ public:
/// \brief check if the window is flagged to be resizable
///
/// \param window The window.
/// \returns \f$true\f$ if set, \f$false\f$ otherwise
/// \returns \emph{true} if set, \emph{false} otherwise
bool is_resizable(window_id window) {
return get_flag(window, window::flag_resizable);
}
@@ -362,7 +363,7 @@ public:
/// \brief check if the window is flagged to be transparent
///
/// \param window The window.
/// \returns \f$true\f$ if set, \f$false\f$ otherwise
/// \returns \emph{true} if set, \emph{false} otherwise
bool is_transparent(window_id window) {
return get_flag(window, window::flag_transparent);
}
@@ -371,7 +372,7 @@ public:
/// \brief check if the window is flagged to be unfocusable
///
/// \param window The window.
/// \returns \f$true\f$ if set, \f$false\f$ otherwise
/// \returns \emph{true} if set, \emph{false} otherwise
bool is_no_focus(window_id window) {
return get_flag(window, window::flag_no_focus);
}
@@ -398,7 +399,6 @@ public:
///
/// \param window The window.
/// \param val the value to set the flag to
/// \returns \f$true\f$ on success, \f$false\f$ otherwise
void set_always_on_top(window_id window, bool val) {
return set_flag(window, window::flag_always_on_top, val);
}
@@ -408,7 +408,6 @@ public:
///
/// \param window The window.
/// \param val the value to set the flag to
/// \returns \f$true\f$ on success, \f$false\f$ otherwise
void set_borderless(window_id window, bool val) {
return set_flag(window, window::flag_borderless, val);
}
@@ -418,7 +417,6 @@ public:
///
/// \param window The window.
/// \param val the value to set the flag to
/// \returns \f$true\f$ on success, \f$false\f$ otherwise
void set_modal(window_id window, bool val) {
return set_flag(window, window::flag_modal, val);
}
@@ -428,7 +426,6 @@ public:
///
/// \param window The window.
/// \param val the value to set the flag to
/// \returns \f$true\f$ on success, \f$false\f$ otherwise
void set_passing_mouse(window_id window, bool val) {
return set_flag(window, window::flag_pass_mouse, val);
}
@@ -438,7 +435,6 @@ public:
///
/// \param window The window.
/// \param val the value to set the flag to
/// \returns \f$true\f$ on success, \f$false\f$ otherwise
void set_popup(window_id window, bool val) {
return set_flag(window, window::flag_popup, val);
}
@@ -448,7 +444,6 @@ public:
///
/// \param window The window.
/// \param val the value to set the flag to
/// \returns \f$true\f$ on success, \f$false\f$ otherwise
void set_resizable(window_id window, bool val) {
return set_flag(window, window::flag_resizable, val);
}
@@ -458,7 +453,6 @@ public:
///
/// \param window The window.
/// \param val the value to set the flag to
/// \returns \f$true\f$ on success, \f$false\f$ otherwise
void set_transparent(window_id window, bool val) {
return set_flag(window, window::flag_transparent, val);
}
@@ -468,7 +462,6 @@ public:
///
/// \param window The window.
/// \param val the value to set the flag to
/// \returns \f$true\f$ on success, \f$false\f$ otherwise
void set_no_focus(window_id window, bool val) {
return set_flag(window, window::flag_no_focus, val);
}

13
include/fennec/renderers/interface/gfxcontext.h
View File

@@ -76,12 +76,15 @@ public:
/// @{
///
/// \returns \f$true\f$ if this
/// \brief Context Validity
/// \returns \emph{true} if the context is initialized and valid, \emph{false} otherwise.
virtual bool is_valid() = 0;
///
/// \returns A version struct containing the version of the graphics API.
virtual const version& get_version() const { return version; }
virtual const version& get_version() const {
return version;
}
/// @}
@@ -108,12 +111,6 @@ protected:
FENNEC_RTTI_CLASS_ENABLE() {
}
// Assignment Operators ================================================================================================
private:
gfxcontext& operator=(const gfxcontext&) = delete;
gfxcontext& operator=(gfxcontext&&) = delete;
};
}

536
include/fennec/renderers/opengl/lib/buffer.h
View File

@@ -1,536 +0,0 @@
// =====================================================================================================================
// fennec, a free and open source game engine
// Copyright © 2025 - 2026 Medusa Slockbower
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <https://www.gnu.org/licenses/>.
// =====================================================================================================================
///
/// \file fennec/renderers/opengl/lib/buffer.h
/// \brief
///
///
/// \details
/// \author Medusa Slockbower
///
/// \copyright Copyright © 2025 - 2026 Medusa Slockbower ([GPLv3](https://www.gnu.org/licenses/gpl-3.0.en.html))
///
///
#ifndef FENNEC_RENDERERS_OPENGL_LIB_BUFFER_H
#define FENNEC_RENDERERS_OPENGL_LIB_BUFFER_H
#include <fennec/math/common.h>
#include <fennec/renderers/opengl/lib/forward.h>
#include <fennec/renderers/opengl/lib/enum.h>
namespace fennec
{
namespace gl
{
///
/// \brief Vertex Buffer Alias
/// \tparam FlagsV The buffer flags, see \ref fennec::gl::buffer_map_flags "buffer_map_flags"
/// \tparam ImmutableV Mutability
template<GLbitfield FlagsV, GLboolean ImmutableV>
using vertex_buffer = buffer<VERTEX, FlagsV, ImmutableV>;
///
/// \brief Vertex Buffer Alias
/// \tparam FlagsV The buffer flags, see \ref fennec::gl::buffer_map_flags "buffer_map_flags"
/// \tparam ImmutableV Mutability
template<GLbitfield FlagsV, GLboolean ImmutableV>
using element_buffer = buffer<ELEMENT, FlagsV, ImmutableV>;
///
/// \brief Vertex Buffer Alias
/// \tparam FlagsV The buffer flags, see \ref fennec::gl::buffer_map_flags "buffer_map_flags"
/// \tparam ImmutableV Mutability
template<GLbitfield FlagsV, GLboolean ImmutableV>
using uniform_buffer = buffer<UNIFORM, FlagsV, ImmutableV>;
///
/// \brief Vertex Buffer Alias
/// \tparam FlagsV The buffer flags, see \ref fennec::gl::buffer_map_flags "buffer_map_flags"
/// \tparam ImmutableV Mutability
template<GLbitfield FlagsV, GLboolean ImmutableV>
using shader_storage_buffer = buffer<SHADER_STORAGE, FlagsV, ImmutableV>;
///
/// \brief Vertex Buffer Alias
/// \tparam FlagsV The buffer flags, see \ref fennec::gl::buffer_map_flags "buffer_map_flags"
/// \tparam ImmutableV Mutability
template<GLbitfield FlagsV, GLboolean ImmutableV>
using query_buffer = buffer<QUERY, FlagsV, ImmutableV>;
///
/// \brief Vertex Buffer Alias
/// \tparam FlagsV The buffer flags, see \ref fennec::gl::buffer_map_flags "buffer_map_flags"
/// \tparam ImmutableV Mutability
template<GLbitfield FlagsV, GLboolean ImmutableV>
using texture_buffer = buffer<TEXTURE, FlagsV, ImmutableV>;
///
/// \brief Vertex Buffer Alias
/// \tparam FlagsV The buffer flags, see \ref fennec::gl::buffer_map_flags "buffer_map_flags"
/// \tparam ImmutableV Mutability
template<GLbitfield FlagsV, GLboolean ImmutableV>
using transform_feedback_buffer = buffer<TRANSFORM_FEEDBACK, FlagsV, ImmutableV>;
///
/// \brief Vertex Buffer Alias
/// \tparam FlagsV The buffer flags, see \ref fennec::gl::buffer_map_flags "buffer_map_flags"
/// \tparam ImmutableV Mutability
template<GLbitfield FlagsV, GLboolean ImmutableV>
using atomic_counter_buffer = buffer<ATOMIC_COUNTER, FlagsV, ImmutableV>;
///
/// \brief Vertex Buffer Alias
/// \tparam FlagsV The buffer flags, see \ref fennec::gl::buffer_map_flags "buffer_map_flags"
/// \tparam ImmutableV Mutability
template<GLbitfield FlagsV, GLboolean ImmutableV>
using parameter_buffer = buffer<PARAMETER, FlagsV, ImmutableV>;
///
/// \brief Vertex Buffer Alias
/// \tparam FlagsV The buffer flags, see \ref fennec::gl::buffer_map_flags "buffer_map_flags"
/// \tparam ImmutableV Mutability
template<GLbitfield FlagsV, GLboolean ImmutableV>
using indirect_draw_buffer = buffer<INDIRECT_DRAW, FlagsV, ImmutableV>;
///
/// \brief Vertex Buffer Alias
/// \tparam FlagsV The buffer flags, see \ref fennec::gl::buffer_map_flags "buffer_map_flags"
/// \tparam ImmutableV Mutability
template<GLbitfield FlagsV, GLboolean ImmutableV>
using indirect_dispatch_buffer = buffer<INDIRECT_DISPATCH, FlagsV, ImmutableV>;
///
/// \brief Vertex Buffer Alias
/// \tparam FlagsV The buffer flags, see \ref fennec::gl::buffer_map_flags "buffer_map_flags"
/// \tparam ImmutableV Mutability
template<GLbitfield FlagsV, GLboolean ImmutableV>
using copy_read_buffer = buffer<COPY_READ, FlagsV, ImmutableV>;
///
/// \brief Vertex Buffer Alias
/// \tparam FlagsV The buffer flags, see \ref fennec::gl::buffer_map_flags "buffer_map_flags"
/// \tparam ImmutableV Mutability
template<GLbitfield FlagsV, GLboolean ImmutableV>
using copy_write_buffer = buffer<COPY_WRITE, FlagsV, ImmutableV>;
///
/// \brief Vertex Buffer Alias
/// \tparam FlagsV The buffer flags, see \ref fennec::gl::buffer_map_flags "buffer_map_flags"
/// \tparam ImmutableV Mutability
template<GLbitfield FlagsV, GLboolean ImmutableV>
using pixel_pack_buffer = buffer<PIXEL_PACK, FlagsV, ImmutableV>;
///
/// \brief Vertex Buffer Alias
/// \tparam FlagsV The buffer flags, see \ref fennec::gl::buffer_map_flags "buffer_map_flags"
/// \tparam ImmutableV Mutability
template<GLbitfield FlagsV, GLboolean ImmutableV>
using pixel_unpack_buffer = buffer<PIXEL_UNPACK, FlagsV, ImmutableV>;
///
/// \brief
/// \tparam TypeV The buffer type, see \ref fennec::gl::buffer_types "buffer_types"
/// \tparam FlagsV The buffer flags, see \ref fennec::gl::buffer_map_flags "buffer_map_flags"
/// \tparam ImmutableV Mutability
template<GLenum TypeV, GLbitfield FlagsV, GLboolean ImmutableV>
class buffer {
// Private Helpers =====================================================================================================
private:
static constexpr GLenum get_mutable_traits() {
GLenum res;
// Set READ/DRAW/COPY
if constexpr (map_read) {
res = GL_STREAM_READ;
} else if constexpr (map_write) {
res = GL_STREAM_DRAW;
} else {
res = GL_STREAM_COPY;
}
// Set STATIC/DYNAMIC/STREAM
if constexpr (client or coherent) {
// do nothing
} else if constexpr (dynamic or persistent) {
res += 6;
} else {
res += 3;
}
return res;
}
// Constants ===========================================================================================================
public:
/// \name Constants
/// @{
///
/// \brief Enum value containing the buffer type.
/// \see fennec::gl::buffer_types
static constexpr GLenum type = TypeV;
///
/// \brief Boolean value representing whether this buffer is immutable.
/// \note Immutable buffers may not be resized.
static constexpr GLboolean immutable = ImmutableV;
///
/// \brief Bitfield value containing the buffer flags.
/// \see fennec::gl::buffer_map_flags
static constexpr GLbitfield flags = FlagsV;
///
/// \brief Boolean value representing whether this buffer has indexed binding targets.
/// \note Indexed buffer types must be bound to an indexed binding target to be used in shaders.
/// \see fennec::gl::buffer::bind
/// \see fennec::gl::buffer::bind_range
static constexpr GLboolean indexed = type == ATOMIC_COUNTER or type == SHADER_STORAGE or type == TRANSFORM_FEEDBACK or type == UNIFORM;
///
/// \brief Boolean value representing whether this buffer is mapped for reading.
/// \note Not to be confused with `read()`, which is specifically for dynamic buffers.
/// \see fennec::gl::buffer::map
static constexpr GLboolean map_read = flags & READ;
///
/// \brief Boolean value representing whether this buffer is mapped for writing.
/// \note Not to be confused with `write()`, which is specifically for dynamic buffers.
/// \see fennec::gl::buffer::map
static constexpr GLboolean map_write = flags & WRITE;
///
/// \brief Boolean value representing whether this buffer is mapped
/// \see fennec::gl::buffer::map
static constexpr GLboolean mapped = map_read or map_write;
///
/// \brief Boolean value representing whether this buffer is dynamic.
/// \note This allows use of the dynamic `read()` and `write()` functions.
/// \see fennec::gl::buffer::read
/// \see fennec::gl::buffer::write
static constexpr GLboolean dynamic = flags & DYNAMIC;
///
/// \brief Boolean value representing whether this buffer is persistent, i.e. can be used while mapped.
/// \see fennec::gl::buffer::map
static constexpr GLboolean persistent = flags & PERSISTENT;
///
/// \brief Boolean value representing whether this buffer is coherent when mapped.
/// \see fennec::gl::buffer::map
static constexpr GLboolean coherent = flags & COHERENT;
///
/// \brief Boolean value representing whether this buffers memory is on the client.
/// \note This is only a hint for the driver, which may be ignored.
static constexpr GLboolean client = flags & CLIENT;
///
/// \brief Enum value containing the mutable usage traits.
/// \see fennec::gl::buffer::immutable
static constexpr GLenum usage = get_mutable_traits();
/// @}
// Assertions ==========================================================================================================
public:
static_assert(not persistent or persistent == mapped, "Persistent buffer must be mappable.");
static_assert(not coherent or coherent == persistent, "Coherent buffer must be persistent.");
// Constructors & Destructor ===========================================================================================
public:
/// \name Constructors & Destructor
/// @{
///
/// \brief Buffer Data Constructor
/// \param data Data to upload to the buffer, may be \f$nullptr\f$.
/// \param size Size of the buffer.
buffer(const void* data, GLsizeiptr size)
: _handle()
, _size(size)
, _data(nullptr)
, _mapflags(0) {
glGenBuffers(1, &_handle);
use();
if constexpr(immutable) {
glBufferStorage(type, _size, data, flags);
} else {
glBufferData(type, _size, data, usage);
}
}
///
/// \brief Buffer Move Constructor
/// \param buff The buffer to take ownership of
buffer(buffer&& buff) noexcept
: _handle(buff)
, _size(buff._size)
, _data(nullptr)
, _mapflags(0) {
}
///
/// \brief Buffer Destructor
///
/// \details Cleans up buffer data and object
~buffer() {
glDeleteBuffers(1, &_handle);
}
/// @}
private:
buffer(const buffer&) = delete;
// Assignment ==========================================================================================================
public:
/// \name Assignment
/// @{
///
/// \brief Buffer Move Assignment
/// \param buff The buffer to take ownership of.
/// \returns A reference to self after having taken ownership of \f$buff\f$.
buffer& operator=(buffer&& buff) noexcept {
fennec::swap(_handle, buff._handle);
fennec::swap(_size, buff._size);
return *this;
}
/// @}
private:
buffer& operator=(const buffer&) = delete;
// Use & Binding =======================================================================================================
public:
/// \name Use & Binding
/// @{
///
/// \brief Use this buffer for buffer operations.
void use() const {
glBindBuffer(type, _handle);
}
///
/// \brief Bind this buffer to an indexed target.
///
/// \param i The index to bind to.
/// \see fennec::gl::buffer::type.
void bind(GLuint i) {
static_assert(indexed, "Buffer must have an indexed binding target.");
glBindBufferBase(type, i, _handle);
}
///
/// \brief Bind a range of this buffer to an indexed target.
/// \param i The index to bind to.
/// \param size The size of the range to bind.
/// \param offset The offset of the range to bind.
void bind_range(GLuint i, GLsizeiptr size = -1, GLintptr offset = 0) {
static_assert(indexed, "Buffer must have an indexed binding target.");
offset = max(offset, GLintptr(0));
size = size < 0 ? _size : size;
size = min(size, _size - offset);
if (size <= 0) return;
glBindBufferRange(type, i, _handle, offset, size);
}
/// @}
// Mapping =============================================================================================================
public:
/// \name Mapping
/// @{
///
/// \brief Map a range of the buffer to be used by the client.
/// \param access The access specifiers.
/// \param size The size of the range to map.
/// \param offset The offset of the range to map.
/// \return
void* map(GLbitfield access, GLsizeiptr size = -1, GLintptr offset = 0) {
if (_data) {
return _data;
}
offset = max(offset, GLintptr(0));
size = size < 0 ? _size : size;
size = min(size, _size - offset);
if (size <= 0) return nullptr;
return _data = glMapBufferRange(type, offset, size, _mapflags = flags | access);
}
///
/// \brief Release the mapping of the buffer.
void unmap() {
glUnmapBuffer(type);
_data = nullptr;
}
/// @}
// Operations ==========================================================================================================
public:
///
/// \brief Resize the buffer.
///
/// \param size The new size for the buffer.
/// \note Buffer must be mutable. Clears buffer with zeroes.
/// \see fennec::gl::buffer::immutable
void resize(GLsizei size) requires(not immutable) {
unmap();
glBufferData(type, _size = size, nullptr, usage);
}
///
/// \brief Clear the buffer.
/// \param size The number of elements to clear
/// \param offset The offset into the buffer to begin clearing.
/// \param value The value to clear with. Must be a pointer to an object of appropriate size for the type and format.
/// \param value_type The type of the data.
/// \param format The format of the data.
/// \param internal The assumed internal format of the buffer.
void clear(GLsizeiptr size = -1, GLintptr offset = 0, const void* value = nullptr, GLenum value_type = BYTE, GLenum format = R, GLenum internal = R8) {
offset = max(offset, GLintptr(0));
size = size < 0 ? _size : size;
size = min(size, _size - offset);
if (size <= 0) return;
glClearBufferSubData(type, internal, offset, size, format, value_type, value);
}
///
/// \brief Copy data from another buffer.
/// \tparam OTypeV The type of the buffer to copy from.
/// \tparam OFlagsV The flags of the buffer being copied from.
/// \tparam OImmutableV The mutability of the buffer being copied from.
/// \param cpy The buffer to copy.
/// \param size The size of the region to copy
/// \param write_offset The offset into this buffer to begin writing at.
/// \param read_offset The offset into \f$cpy\f$ to begin reading from.
template<GLenum OTypeV, GLbitfield OFlagsV, GLboolean OImmutableV>
void copy(const buffer<OTypeV, OFlagsV, OImmutableV>& cpy, GLsizeiptr size = -1, GLintptr write_offset = 0, GLintptr read_offset = 0) {
write_offset = max(write_offset, GLintptr(0));
read_offset = max(read_offset, GLintptr(0));
size = size < 0 ? _size : size;
size = fennec::min(size, cpy._size - read_offset);
size = fennec::min(size, _size - write_offset);
if (size <= 0) return;
glBindBuffer(COPY_READ, cpy._handle);
glBindBuffer(COPY_WRITE, _handle);
glCopyBufferSubData(COPY_READ, COPY_WRITE, read_offset, write_offset, size);
glBindBuffer(COPY_READ, NULL);
glBindBuffer(COPY_WRITE, NULL);
}
///
/// \brief Read data from the buffer.
/// \param data The handle to the client buffer to read into.
/// \param size The size of the region to read.
/// \param offset The offset into the buffer to begin reading from.
void read(void* data, GLsizeiptr size, GLintptr offset = 0) const {
static_assert(dynamic);
offset = max(offset, GLintptr(0));
size = size < 0 ? _size : size;
size = min(size, _size - offset);
if (size <= 0) return;
glGetBufferSubData(type, offset, size, data);
}
///
/// \brief Write data to the buffer.
/// \param data The handle to the client buffer to write from.
/// \param size The size of the region to write.
/// \param offset The offset into the buffer to begin writing at.
void write(const void* data, GLsizeiptr size, GLintptr offset = 0) {
static_assert(dynamic);
offset = max(offset, GLintptr(0));
size = size < 0 ? _size : size;
size = min(size, _size - offset);
if (size <= 0) return;
glBufferSubData(type, offset, size, data);
}
///
/// \brief Flush a range of the buffer.
/// \param size The size of the range.
/// \param offset The offset of the range.
/// \note The buffer must be mapped with the \ref fennec::gl::buffer_map_flags::EXPLICIT_FLUSH "EXPLICIT_FLUSH" flag.
void flush(GLsizeiptr size = -1, GLintptr offset = 0) {
if (not _data) return;
if (not (_mapflags & EXPLICIT_FLUSH)) return;
offset = max(offset, GLintptr(0));
size = size < 0 ? _size : size;
size = min(size, _size - offset);
if (size <= 0) return;
glFlushMappedBufferRange(type, offset, size);
}
void invalidate(GLsizeiptr size, GLintptr offset = 0) {
offset = max(offset, GLintptr(0));
size = size < 0 ? _size : size;
size = min(size, _size - offset);
if (size <= 0) return;
glInvalidateBufferSubData(type, offset, size);
}
// TYPED FUNCTIONS =====================================================================================================
template<typename TypeT>
TypeT* map(GLbitfield access, GLsizeiptr n, GLintptr offset = 0) {
return static_cast<TypeT*>(map(access, n * sizeof(TypeT), offset * sizeof(TypeT)));
}
private:
GLuint _handle;
GLsizeiptr _size;
void* _data;
GLbitfield _mapflags;
};
}
}
#endif // FENNEC_RENDERERS_OPENGL_LIB_BUFFER_H

40
include/fennec/renderers/opengl/lib/enum.h
View File

@@ -107,6 +107,20 @@ enum texture_types : GLenum {
};
// Cubemap Faces =======================================================================================================
///
/// \brief OpenGL Cubemap Faces
enum cubemap_faces : GLenum {
CUBEMAP_POSITIVE_X = GL_TEXTURE_CUBE_MAP_POSITIVE_X, //!< Cube Map +X Face
CUBEMAP_NEGATIVE_X = GL_TEXTURE_CUBE_MAP_NEGATIVE_X, //!< Cube Map -X Face
CUBEMAP_POSITIVE_Y = GL_TEXTURE_CUBE_MAP_POSITIVE_Y, //!< Cube Map +Y Face
CUBEMAP_NEGATIVE_Y = GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, //!< Cube Map -Y Face
CUBEMAP_POSITIVE_Z = GL_TEXTURE_CUBE_MAP_POSITIVE_Z, //!< Cube Map +Z Face
CUBEMAP_NEGATIVE_Z = GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, //!< Cube Map -Z Face
};
// Built-In Types ======================================================================================================
///
@@ -259,6 +273,9 @@ enum types : GLenum {
UINT_ATOMIC_COUNTER = GL_UNSIGNED_INT_ATOMIC_COUNTER, //!< Atomic Counter
};
// Pixel Components ====================================================================================================
///
/// \brief OpenGL Pixel Components
enum pixel_components : GLenum {
@@ -287,10 +304,13 @@ enum pixel_components : GLenum {
DEPTH_STENCIL = GL_DEPTH_STENCIL, //!< Combined Depth-Stencil
};
// Pixel Formats =======================================================================================================
///
/// \brief OpenGL Color Formats
/// \note UNORM formats are integers interpreted in the normalized range \f$[0.0, 1.0]\f$
/// \note SNORM formats are integers interpreted in the normalized range \f$[-1.0, 1.0]\f$
/// \brief OpenGL Pixel Formats
/// \note UNORM formats are integers interpreted in the normalized range \math{[0.0, 1.0]}
/// \note SNORM formats are integers interpreted in the normalized range \math{[-1.0, 1.0]}
enum pixel_formats : GLint {
R8_UNORM = GL_R8, //!< 8-Bit Unsigned Normalized Single Component Color
R8_SNORM = GL_R8_SNORM, //!< 8-Bit Signed Normalized Single Component Color
@@ -378,6 +398,20 @@ enum pixel_formats : GLint {
SRGBA_DXT5 = GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT, //!< Compressed sRGBA DXT5 Color
};
// Framebuffer Attachments =============================================================================================
///
/// \brief OpenGL Framebuffer Attachments
enum framebuffer_attachments {
NO_ATTACHMENT = GL_NONE, //!< No Attachment
DEPTH_ATTACHMENT = GL_DEPTH_ATTACHMENT, //!< Depth Attachment
STENCIL_ATTACHMENT = GL_STENCIL_ATTACHMENT, //!< Stencil Attachment
DEPTH_STENCIL_ATTACHMENT = GL_DEPTH_STENCIL_ATTACHMENT, //!< Depth Stencil Attachment
COLOR_ATTACHMENT = GL_COLOR_ATTACHMENT0, //!< Color Attachment
};
}
}

331
include/fennec/renderers/opengl/lib/texture.h
View File

@@ -1,331 +0,0 @@
// =====================================================================================================================
// fennec, a free and open source game engine
// Copyright © 2025 - 2026 Medusa Slockbower
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <https://www.gnu.org/licenses/>.
// =====================================================================================================================
///
/// \file fennec/renderers/opengl/lib/texture.h
/// \brief
///
///
/// \details
/// \author Medusa Slockbower
///
/// \copyright Copyright © 2025 - 2026 Medusa Slockbower ([GPLv3](https://www.gnu.org/licenses/gpl-3.0.en.html))
///
///
#ifndef FENNEC_RENDERERS_OPENGL_LIB_TEXTURE_H
#define FENNEC_RENDERERS_OPENGL_LIB_TEXTURE_H
/* Because our implementation targets minimum OpenGL ES 3.2,
* we are guaranteed to have the following relevant extensions (Starting from OpenGL ES 3.0):
*
* OES_texture_compression_astc
* EXT_texture_border_clamp
* OES_EGL_image_external_essl3
* ARB_shader_image_load_store
* ARB_stencil_texturing
* ARG_shader_image_size
* ARB_texture_multisample
* ARB_texture_storage_multisample
* ARB_sample_locations
* OES_texture_view
* NV_image_formats
* EXT_render_snorm
* EXT_render_norm16
* EXT_color_buffer_float
* OES_copy_image
* OES_shader_image_atomic
* OES_texture_border_clamp
* OES_texture_buffer
* OES_texture_cube_map_array
* OES_texture_stencil8
* OES_texture_storage_multisample_2d_array
*/
#include <fennec/math/common.h>
#include <fennec/renderers/opengl/lib/fwd.h>
#include <fennec/renderers/opengl/lib/enum.h>
namespace fennec
{
namespace gl
{
template<GLint FormatV, GLboolean ImmutableV> using texture1d = texture<TEXTURE_1D, FormatV, ImmutableV>;
template<GLint FormatV, GLboolean ImmutableV> using texture1d_array = texture<TEXTURE_1D_ARRAY, FormatV, ImmutableV>;
template<GLint FormatV, GLboolean ImmutableV> using texture2d = texture<TEXTURE_2D, FormatV, ImmutableV>;
template<GLint FormatV, GLboolean ImmutableV> using texture2d_array = texture<TEXTURE_2D_ARRAY, FormatV, ImmutableV>;
template<GLint FormatV, GLboolean ImmutableV> using texture_rect = texture<TEXTURE_RECTANGLE, FormatV, ImmutableV>;
template<GLint FormatV, GLboolean ImmutableV> using texture2d_ms = texture<TEXTURE_2D_MS, FormatV, ImmutableV>;
template<GLint FormatV, GLboolean ImmutableV> using texture2d_ms_array = texture<TEXTURE_2D_MS_ARRAY, FormatV, ImmutableV>;
template<GLint FormatV, GLboolean ImmutableV> using cubemap = texture<CUBEMAP, FormatV, ImmutableV>;
template<GLint FormatV, GLboolean ImmutableV> using cubemap_array = texture<CUBEMAP_ARRAY, FormatV, ImmutableV>;
template<GLint FormatV, GLboolean ImmutableV> using texture3d = texture<TEXTURE_3D, FormatV, ImmutableV>;
template<GLint FormatV, GLboolean ImmutableV> using buffer_texture = texture<BUFFER_TEXTURE, FormatV, ImmutableV>;
///
/// \brief Wrapper for OpenGL Texture Objects
/// \tparam TypeV The type of the texture
/// \tparam FormatV The internal pixel format
/// \tparam ImmutableV Mutability
///
/// \details Immutable textures require EXT_texture_storage or ARB_texture_storage
/// Immutable multisample textures require ARB_texture_storage_multisample of OES_texture_storage_multisample_2d_array
template<GLenum TypeV, GLint FormatV, GLboolean ImmutableV>
class texture {
// Constants ===========================================================================================================
public:
static constexpr GLenum type = TypeV;
static constexpr GLint format = FormatV;
static constexpr GLboolean immutable = ImmutableV;
static constexpr GLboolean is_rect = type == TEXTURE_RECTANGLE;
static constexpr GLboolean is_buffered = type == BUFFER_TEXTURE;
static constexpr GLboolean sampled = type == TEXTURE_2D_MS or type == TEXTURE_2D_MS_ARRAY;
static constexpr GLboolean cubemap = type == CUBEMAP or type == CUBEMAP_ARRAY;
static constexpr GLboolean is_1d = type == TEXTURE_1D or type == TEXTURE_1D_ARRAY;
static constexpr GLboolean is_2d = sampled or is_rect or type == TEXTURE_2D or type == TEXTURE_2D_ARRAY or cubemap;
static constexpr GLboolean is_array = type == TEXTURE_1D_ARRAY or type == TEXTURE_2D_ARRAY or type == TEXTURE_2D_MS_ARRAY or type == CUBEMAP_ARRAY;
static constexpr GLboolean is_3d = type == TEXTURE_3D;
static constexpr GLboolean has_mipmaps = not(sampled or is_rect or is_buffered);
static constexpr GLboolean use_1d = is_1d and not is_array;
static constexpr GLboolean use_2d = ((is_2d and not is_array) or (is_1d and is_array)) and not sampled;
static constexpr GLboolean use_3d = (is_3d or (is_2d and is_array)) and not (sampled or cubemap);
static constexpr GLint cubemap_faces = 6;
static constexpr GLenum base_cubemap_face = GL_TEXTURE_CUBE_MAP_POSITIVE_X;
static constexpr GLboolean compressed = type == RGB_DXT1 or type == RGBA_DXT1 or type == RGBA_DXT3 or type == RGBA_DXT5
or type == SRGB_DXT1 or type == SRGBA_DXT1 or type == SRGBA_DXT3 or type == SRGBA_DXT5;
// Constructors ========================================================================================================
///
/// \brief 1D Texture Constructor
/// \param width The width of the texture
/// \param mips The number of mipmap levels
/// \param data A pointer to a buffer containing pixel values, used as an offset if a PIXEL_UNPACK_BUFFER is bound.
/// \param component The type of each component
/// \param layout The layout of components in each pixel
/// \param size The size of the image data in bytes, for compressed pixel formats
texture(GLsizei width, GLint mips,
void* data = nullptr, GLenum component = BYTE, GLenum layout = R, GLsizei size = 0) requires use_1d
: _handle(NULL)
, _width(width), _height(1), _depth(1)
, _samples(1), _mips(mips) {
glGenTextures(1, &_handle);
start();
if constexpr(immutable) {
glTexStorage1D(type, _mips, format, _width);
glTexSubImage1D(type, 0, 0, _width, layout, component, data);
} else if constexpr(compressed) {
glCompressedTexImage1D(type, 0, format, _width, 0, size, data);
} else {
glTexImage1D(type, 0, format, _width, 0, layout, component, data);
}
genmips();
}
///
/// \brief 2D Texture Constructor
/// \param width The width of the texture
/// \param height The height of the texture, or number of layers for arrays
/// \param mips The number of mipmap levels
/// \param data A pointer to a buffer containing pixel values, used as an offset if a PIXEL_UNPACK_BUFFER is bound.
/// \param component The type of each component
/// \param layout The layout of components in each pixel
/// \param size The size of the image data in bytes, for compressed pixel formats
texture(GLsizei width, GLsizei height, GLint mips,
void* data = nullptr, GLenum component = BYTE, GLenum layout = R, GLsizei size = 0) requires use_2d and not cubemap
: _handle(NULL)
, _width(width), _height(height), _depth(1)
, _samples(1), _mips(mips) {
glGenTextures(1, &_handle);
start();
if constexpr(immutable) {
glTexStorage2D(type, _mips, format, _width, _height);
glTexSubImage2D(type, 0, 0, 0, _width, _height, layout, component, data);
} else if constexpr(compressed) {
glCompressedTexImage2D(type, 0, format, _width, _height, 0, size, data);
} else {
glTexImage2D(type, 0, format, _width, _height, 0, layout, component, data);
}
}
///
/// \brief 2D Texture Constructor
/// \param width The width of the texture
/// \param height The height of the texture
/// \param depth The depth of the texture, or number of layers for arrays
/// \param mips The number of mipmap levels
/// \param data A pointer to a buffer containing pixel values, used as an offset if a PIXEL_UNPACK_BUFFER is bound.
/// \param component The type of each component
/// \param layout The layout of components in each pixel
/// \param size The size of the image data in bytes, for compressed pixel formats
texture(GLsizei width, GLsizei height, GLsizei depth, GLsizei mips,
void* data = nullptr, GLenum component = BYTE, GLenum layout = R, GLsizei size = 0) requires use_3d and not cubemap
: _handle(NULL)
, _width(width), _height(height), _depth(depth)
, _samples(1), _mips(mips) {
glGenTextures(1, &_handle);
start();
if constexpr(immutable) {
glTexStorage3D(type, _mips, format, _width, _height, _depth);
glTexSubImage3D(type, 0, 0, 0, 0, _width, _height, _depth, layout, component, data);
} else if constexpr(compressed) {
glCompressedTexImage3D(type, 0, format, _width, _height, _depth, 0, size, data);
} else {
glTexImage3D(type, 0, format, _width, _height, _depth, 0, layout, component, data);
}
}
///
/// \brief 2D Multisample Texture Constructor
/// \param width The width of the texture
/// \param height The height of the texture
/// \param samples The number of samples per pixel
/// \param fixed When true, a fixed set of sample locations is used
texture(GLsizei width, GLsizei height, GLsizei samples, GLboolean fixed = true) requires sampled and not is_array
: _handle(NULL)
, _width(width), _height(height), _depth(1)
, _samples(samples), _mips(0) {
glGenTextures(1, &_handle);
start();
if constexpr(immutable) {
glTexStorage2DMultisample(type, _samples, format, _width, _height, fixed);
} else {
glTexImage2DMultisample(type, _samples, format, _width, _height, fixed);
}
}
///
/// \brief 2D Multisample Array Texture Constructor
/// \param width The width of the texture
/// \param height The height of the texture
/// \param depth The number of layers in the array
/// \param samples The number of samples per pixel
/// \param fixed When true, a fixed set of sample locations is used
texture(GLsizei width, GLsizei height, GLsizei depth, GLsizei samples, GLboolean fixed = true) requires sampled and is_array
: _handle(NULL)
, _width(width), _height(height), _depth(depth)
, _samples(samples), _mips(0) {
glGenTextures(1, &_handle);
start();
if constexpr(immutable) {
glTexStorage3DMultisample(type, _samples, format, _width, _height, _depth, fixed);
} else {
glTexImage3DMultisample(type, _samples, format, _width, _height, _depth, fixed);
}
}
///
/// \brief Cubemap Constructor
/// \param size The size of each face texture
/// \param mips The number of mipmap layers
/// \param faces An array of pointers to textures containing pixel data for each face
/// \param component The component type of the data
/// \param layout The layout of the components in the pixel
/// \param bytes The size of the image data in bytes, for compressed pixel formats
texture(GLsizei size, GLsizei mips,
const void* faces[6], GLenum component = BYTE, GLenum layout = R, GLsizei bytes = 0) requires is_2d and cubemap
: _handle(NULL)
, _width(size), _height(size), _depth(1)
, _samples(1), _mips(mips) {
glGenTextures(1, &_handle);
start();
if constexpr(immutable) {
glTexStorage2D(type, _mips, format, _width, _height);
for (int i = 0; i < cubemap_faces; ++i) {
glTexSubImage2D(base_cubemap_face + i, 0, 0, 0, _width, _height, layout, component, faces[i]);
}
} else if constexpr(compressed) {
for (int i = 0; i < cubemap_faces; ++i) {
glCompressedTexImage2D(base_cubemap_face + i, 0, format, _width, _height, 0, bytes, faces[i]);
}
} else {
for (int i = 0; i < cubemap_faces; ++i) {
glTexImage2D(base_cubemap_face + i, 0, format, _width, _height, 0, layout, component, faces[i]);
}
}
}
///
/// \brief Cubemap Array Constructor
/// \param size The size of each face texture
/// \param depth The number of layers in the array
/// \param mips The number of mipmap layers
/// \param data A pointer to a buffer containing image data
/// \param component The component type of the data
/// \param layout The layout of the components in the pixel
/// \param bytes The size of the image data in bytes, for compressed pixel formats
///
/// \details Requires OES_texture_cube_map_array
texture(GLsizei size, GLsizei depth, GLsizei mips,
const void* data, GLenum component = BYTE, GLenum layout = R, GLsizei bytes = 0) requires is_2d and cubemap
: _handle(NULL)
, _width(size), _height(size), _depth(depth)
, _samples(1), _mips(mips) {
glGenTextures(1, &_handle);
start();
if constexpr(immutable) {
glTexStorage3D(type, _mips, format, _width, _height, _depth * 6);
glTexSubImage3D(type, 0, 0, 0, 0, _width, _height, _depth * 6, layout, component, data);
} else if constexpr(compressed) {
for (int i = 0; i < cubemap_faces; ++i) {
glCompressedTexImage3D(type, 0, format, _width, _height, _depth * 6, 0, bytes, data);
}
} else {
glTexImage3D(type, 0, format, _width, _height, _depth * 6, 0, layout, component, data);
}
}
// Basic Functions =====================================================================================================
void use() {
glBindTexture(type, _handle);
}
void bind(GLint i) {
glActiveTexture(GL_TEXTURE0 + i);
use();
}
void genmips() {
glGenerateMipmap(type);
}
private:
GLuint _handle;
GLsizei _width;
GLsizei _height;
GLsizei _depth;
GLsizei _samples;
GLint _mips;
};
}
}
#endif // FENNEC_RENDERERS_OPENGL_LIB_TEXTURE_H

68
include/fennec/renderers/vulkan/lib/app_info.h
View File

@@ -32,7 +32,7 @@
#ifndef FENNEC_RENDERERS_VULKAN_LIB_APP_INFO_H
#define FENNEC_RENDERERS_VULKAN_LIB_APP_INFO_H
#include <volk.h>
#include <fennec/renderers/vulkan/lib/forward.h>
#include <fennec/core/version.h>
#include <fennec/string/cstring.h>
@@ -44,6 +44,12 @@ namespace fennec::vk
/// \brief Wrapper class for VkApplicationInfo
struct app_info : private VkApplicationInfo {
// Definitions =========================================================================================================
private:
// Constructors & Destructor ===========================================================================================
public:
@@ -52,30 +58,36 @@ public:
///
/// \brief Create a Vulkan application information structure
/// \param app_name the name of the application, this cstring must exist for the lifetime of this object
/// until a structure of type fennec::vk::instance is constructed
/// \param app_name the name of the application.
/// \param app_version the internal version of the application
/// \param engine_name the name of the engine, this cstring must exist for the lifetime of this object
/// until a structure of type fennec::vk::instance is constructed
/// \param engine_name the name of the engine.
/// \param engine_version the internal version of the engine
/// \param api_version the Vulkan API version to use, version::patch and version::str are ignored
/// \param ext a pointer to an extension structure, the object next points to must exist for the lifetime of this
/// object until a structure of type fennec::vk::instance is constructed
/// TODO: DEFINE EXTENSION STRUCTURE WRAPPERS
app_info(
const cstring& app_name = {}, const version& app_version = {},
const cstring& engine_name = {}, const version& engine_version = {},
const version& api_version = {},
void* ext = nullptr
const cstring& engine_name = {}, const version& engine_version = {}
) noexcept : VkApplicationInfo {
.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO,
.pNext = ext,
.pApplicationName = app_name,
.pNext = nullptr,
.pApplicationName = nullptr,
.applicationVersion = VK_MAKE_VERSION(app_version.major, app_version.minor, app_version.patch),
.pEngineName = engine_name,
.pEngineName = nullptr,
.engineVersion = VK_MAKE_VERSION(engine_version.major, engine_version.minor, engine_version.patch),
.apiVersion = VK_MAKE_API_VERSION(0, api_version.major, api_version.minor, 0),
} {
.apiVersion = VK_MAKE_API_VERSION(0, 1, 0, 0), // Default to 1.0
}, _app_name(app_name)
, _engine_name(engine_name) {
pApplicationName = _app_name.data();
pEngineName = _engine_name.data();
// Attempt to acquire version supported by the driver
if (vkEnumerateInstanceVersion) {
uint32_t api_version;
vkEnumerateInstanceVersion(&api_version);
apiVersion = VK_MAKE_API_VERSION(0, VK_API_VERSION_MAJOR(api_version), VK_API_VERSION_MINOR(api_version), 0);
}
}
///
@@ -102,13 +114,13 @@ public:
///
/// \brief Copy Assignment
/// \param info The app_info object to move
/// \returns A reference to self
/// \returns A reference to \emph{this}
app_info& operator=(const app_info& info) noexcept = default;
///
/// \brief Move Assignment
/// \param info The app_info object to move
/// \returns A reference to self
/// \returns A reference to \emph{this}
app_info& operator=(app_info&& info) noexcept = default;
/// @}
@@ -121,14 +133,14 @@ public:
/// @{
///
/// \returns \f$this\f$ as if it were a pointer to the underlying type, \f$VkApplicationInfo\f$.
/// \returns \emph{this} as if it were a pointer to the underlying type, \emph{VkApplicationInfo}.
operator VkApplicationInfo*() noexcept {
return this;
}
///
/// \brief Implicit Pointer Conversion
/// \returns \f$this\f$ as if it were a pointer to the underlying type, \f$VkApplicationInfo\f$.
/// \returns \emph{this} as if it were a pointer to the underlying type, \emph{VkApplicationInfo}.
operator const VkApplicationInfo*() const noexcept {
return this;
}
@@ -168,18 +180,22 @@ public:
///
/// \brief Set the engine version
/// \param ver A version struct containing the new version
void set_engine_version(const version& ver) {
engineVersion = VK_MAKE_VERSION(ver.major, ver.minor, ver.patch);
void set_app_version(const version& ver) {
applicationVersion = VK_MAKE_VERSION(ver.major, ver.minor, ver.patch);
}
///
/// \returns A cstring containing the engine name
cstring get_engine_name() const { return cstring(pEngineName, strlen(pEngineName)); }
cstring get_engine_name() const {
return { pEngineName, strlen(pEngineName) };
}
///
/// \brief Set the engine name
/// \param str A cstring containing the new name
void set_engine_name(const cstring& str) { pEngineName = str; }
void set_engine_name(const cstring& str) {
pEngineName = str;
}
///
/// \returns A version struct containing the engine version
@@ -203,7 +219,9 @@ public:
version get_api_version() const {
return version {
.major = VK_API_VERSION_MAJOR(apiVersion),
.minor = VK_API_VERSION_MINOR(apiVersion)
.minor = VK_API_VERSION_MINOR(apiVersion),
.patch = VK_API_VERSION_PATCH(apiVersion),
.meta = VK_API_VERSION_VARIANT(apiVersion),
};
}
@@ -222,7 +240,7 @@ public:
}
///
/// \brief Clear the extension structure with \f$nullptr\f$
/// \brief Clear the extension structure with \emph{nullptr}
void set_extension(nullptr_t) {
pNext = nullptr;
}
@@ -232,6 +250,8 @@ public:
// Private Member Variables ============================================================================================
private:
string _app_name;
string _engine_name;
};
}

145
include/fennec/renderers/vulkan/lib/debug.h Normal file
View File

@@ -0,0 +1,145 @@
// =====================================================================================================================
// fennec, a free and open source game engine
// Copyright © 2025 Medusa Slockbower
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <https://www.gnu.org/licenses/>.
// =====================================================================================================================
///
/// \file debug.h
/// \brief
///
///
/// \details
/// \author Medusa Slockbower
///
/// \copyright Copyright © 2025 - 2026 Medusa Slockbower ([GPLv3](https://www.gnu.org/licenses/gpl-3.0.en.html))
///
///
#ifndef FENNEC_RENDERERS_VULKAN_LIB_DEBUG_H
#define FENNEC_RENDERERS_VULKAN_LIB_DEBUG_H
#include <fennec/containers/dynarray.h>
#include <fennec/format/format.h>
#include <fennec/lang/ranges.h>
#include <fennec/renderers/vulkan/lib/forward.h>
#include <fennec/renderers/vulkan/lib/enum.h>
#include <fennec/string/string.h>
namespace fennec::vk
{
///
/// \brief Vulkan Debugger Interface
class debugger {
// Definitions =========================================================================================================
public:
///
/// \brief Info for attaching a debugger to an instance.
struct info
: private VkDebugUtilsMessengerCreateInfoEXT
{
explicit info(const debugger& dbg)
: VkDebugUtilsMessengerCreateInfoEXT {
.sType = VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT,
.pNext = nullptr,
.flags = 0,
.messageSeverity = debug_message_severity_all,
.messageType = debug_message_type_all,
.pfnUserCallback = _debug_message,
.pUserData = const_cast<debugger*>(&dbg),
} {
}
operator const VkDebugUtilsMessengerCreateInfoEXT*() const {
return this;
}
};
// Properties ==========================================================================================================
public:
///
/// \brief Instance Creation Info
/// \returns An info object for attaching this debugger to an instance.
info get_info() const {
return info(*this);
}
// Debug Callbacks =====================================================================================================
public:
///
/// \brief
/// \param severity The message severity
/// \param type The message type
/// \param id The message id
/// \param message The message string
/// \param queue The labels in the queue
/// \param commands The labels in the command buffer
/// \param objects The related objects
virtual void message(uint32_t severity,
uint32_t type,
const cstring& id,
const cstring& message,
const dynarray<cstring>& queue,
const dynarray<cstring>& commands,
const dynarray<string>& objects) = 0;
// Private Helper Functions ============================================================================================
private:
static VkBool32 _debug_message(
VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity,
VkDebugUtilsMessageTypeFlagsEXT messageType,
const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData,
void* pUserData
) {
const cstring id = cstring(pCallbackData->pMessageIdName, strlen(pCallbackData->pMessageIdName));
const cstring message = cstring(pCallbackData->pMessage, strlen(pCallbackData->pMessage));
dynarray<cstring> queue;
dynarray<cstring> commands;
dynarray<string> objects;
debugger* dbg = static_cast<debugger*>(pUserData);
for (const auto& label : range(pCallbackData->pQueueLabels, pCallbackData->pQueueLabels + pCallbackData->queueLabelCount)) {
queue.emplace_back(label.pLabelName, strlen(label.pLabelName));
}
for (const auto& label : range(pCallbackData->pCmdBufLabels, pCallbackData->pCmdBufLabels + pCallbackData->cmdBufLabelCount)) {
commands.emplace_back(label.pLabelName, strlen(label.pLabelName));
}
for (const auto& obj : range(pCallbackData->pObjects, pCallbackData->pObjects + pCallbackData->objectCount)) {
objects.push_back(format("{:#016x} ({})", obj.objectHandle, object_string(obj.objectType)));
}
dbg->message(messageSeverity, messageType, id, message, queue, commands, objects);
return VK_FALSE;
}
};
}
#endif // FENNEC_RENDERERS_VULKAN_LIB_DEBUG_H

359
include/fennec/renderers/vulkan/lib/enum.h Normal file
View File

@@ -0,0 +1,359 @@
// =====================================================================================================================
// fennec, a free and open source game engine
// Copyright © 2025 Medusa Slockbower
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <https://www.gnu.org/licenses/>.
// =====================================================================================================================
///
/// \file enum.h
/// \brief
///
///
/// \details
/// \author Medusa Slockbower
///
/// \copyright Copyright © 2025 - 2026 Medusa Slockbower ([GPLv3](https://www.gnu.org/licenses/gpl-3.0.en.html))
///
///
#ifndef FENNEC_RENDERERS_VULKAN_LIB_ENUM_H
#define FENNEC_RENDERERS_VULKAN_LIB_ENUM_H
#include <fennec/renderers/vulkan/lib/forward.h>
namespace fennec::vk
{
// Objects =============================================================================================================
///
/// \brief An enum representing the Vulkan object types
enum object_ : uint32_t {
object_unknown = VK_OBJECT_TYPE_UNKNOWN, //!< Unknown type
object_instance = VK_OBJECT_TYPE_INSTANCE, //!< Vulkan Instance
object_physical_device = VK_OBJECT_TYPE_PHYSICAL_DEVICE, //!< Physical Device
object_logical_device = VK_OBJECT_TYPE_DEVICE, //!< Logical Device
object_queue = VK_OBJECT_TYPE_QUEUE, //!< Queue
object_semaphore = VK_OBJECT_TYPE_SEMAPHORE, //!< Semaphore
object_command_buffer = VK_OBJECT_TYPE_COMMAND_BUFFER, //!< Command Buffer
object_fence = VK_OBJECT_TYPE_FENCE, //!< Fence
object_device_memory = VK_OBJECT_TYPE_DEVICE_MEMORY, //!< Device Memory
object_buffer = VK_OBJECT_TYPE_BUFFER, //!< Buffer
object_image = VK_OBJECT_TYPE_IMAGE, //!< Image
object_event = VK_OBJECT_TYPE_EVENT, //!< Event
object_query_pool = VK_OBJECT_TYPE_QUERY_POOL, //!< Query Pool
object_buffer_view = VK_OBJECT_TYPE_BUFFER_VIEW, //!< Buffer View
object_image_view = VK_OBJECT_TYPE_IMAGE_VIEW, //!< Image View
object_shader_module = VK_OBJECT_TYPE_SHADER_MODULE, //!< Shader Module
object_pipeline_cache = VK_OBJECT_TYPE_PIPELINE_CACHE, //!< Pipeline Cache
object_pipeline_layout = VK_OBJECT_TYPE_PIPELINE_LAYOUT, //!< Pipeline Layout
object_render_pass = VK_OBJECT_TYPE_RENDER_PASS, //!< Render Pass
object_pipeline = VK_OBJECT_TYPE_PIPELINE, //!< Pipeline
object_descriptor_set_layout = VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT, //!< Descriptor Set
object_sampler = VK_OBJECT_TYPE_SAMPLER, //!< Sampler
object_descriptor_pool = VK_OBJECT_TYPE_DESCRIPTOR_POOL, //!< Descriptor Pool
object_descriptor_set = VK_OBJECT_TYPE_DESCRIPTOR_SET, //!< Descriptor Set
object_framebuffer = VK_OBJECT_TYPE_FRAMEBUFFER, //!< Framebuffer
object_command_pool = VK_OBJECT_TYPE_COMMAND_POOL, //!< Command Pool
object_sampler_ycbcr_conversion = VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION, //!< YCBCR Conversion Sampler
object_descriptor_update_template = VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE, //!< Descriptor Update Template
object_private_data_slot = VK_OBJECT_TYPE_PRIVATE_DATA_SLOT, //!< Private Data Slot
object_debug_report_callback_ext = VK_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT, //!< Debug Report Callback
object_debug_utils_messenger_ext = VK_OBJECT_TYPE_DEBUG_UTILS_MESSENGER_EXT, //!< Debug Utility Messenger
object_validation_cache_ext = VK_OBJECT_TYPE_VALIDATION_CACHE_EXT, //!< Validation Cache
object_micromap_ext = VK_OBJECT_TYPE_MICROMAP_EXT, //!< Micro-Map
object_shader_ext = VK_OBJECT_TYPE_SHADER_EXT, //!< Shader
object_indirect_commands_layout_ext = VK_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_EXT, //!< Indirect Commands Layout
object_indirect_execution_set_ext = VK_OBJECT_TYPE_INDIRECT_EXECUTION_SET_EXT, //!< Indirect Execution Set
object_surface = VK_OBJECT_TYPE_SURFACE_KHR, //!< Surface
object_swapchain = VK_OBJECT_TYPE_SWAPCHAIN_KHR, //!< Swap-chain
object_display = VK_OBJECT_TYPE_DISPLAY_KHR, //!< Display
object_display_mode = VK_OBJECT_TYPE_DISPLAY_MODE_KHR, //!< Display Mode
object_video_session = VK_OBJECT_TYPE_VIDEO_SESSION_KHR, //!< Video Session
object_video_session_parameters = VK_OBJECT_TYPE_VIDEO_SESSION_PARAMETERS_KHR, //!< Video Session Parameters
object_acceleration_structure = VK_OBJECT_TYPE_ACCELERATION_STRUCTURE_KHR, //!< Acceleration Structure
object_deferred_operation = VK_OBJECT_TYPE_DEFERRED_OPERATION_KHR, //!< Deferred Operation
object_pipeline_binary = VK_OBJECT_TYPE_PIPELINE_BINARY_KHR, //!< Pipeline Binary
object_acceleration_structure_NV = VK_OBJECT_TYPE_ACCELERATION_STRUCTURE_NV, //!< NV Acceleration Structure
object_indirect_commands_layout_NV = VK_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NV, //!< NV Indirect Commands Layout
object_optical_flow_session_NV = VK_OBJECT_TYPE_OPTICAL_FLOW_SESSION_NV, //!< NV Optical Flow Session
object_external_compute_queue_NV = VK_OBJECT_TYPE_EXTERNAL_COMPUTE_QUEUE_NV, //!< NV External Compute Queue
object_cu_module_NVX = VK_OBJECT_TYPE_CU_MODULE_NVX, //!< NVX CU Module
object_cu_function_NVX = VK_OBJECT_TYPE_CU_FUNCTION_NVX, //!< NVX CU Function
object_performance_configuration_INTEL = VK_OBJECT_TYPE_PERFORMANCE_CONFIGURATION_INTEL, //!< Intel Performance Configuration
object_buffer_collection_FUCHSIA = VK_OBJECT_TYPE_BUFFER_COLLECTION_FUCHSIA, //!< Fuchsia Buffer Collection
object_tensor_ARM = VK_OBJECT_TYPE_TENSOR_ARM, //!< ARM Tensor
object_tensor_view_ARM = VK_OBJECT_TYPE_TENSOR_VIEW_ARM, //!< ARM Tensor View
object_data_graph_pipeline_session_ARM = VK_OBJECT_TYPE_DATA_GRAPH_PIPELINE_SESSION_ARM, //!< ARM Data Graph Pipeline Session
// Beta Extensions
#ifdef VK_ENABLE_BETA_EXTENSIONS
object_cuda_module_NV = VK_OBJECT_TYPE_CUDA_MODULE_NV, //!< NV Cuda Module
object_cuda_function_NV = VK_OBJECT_TYPE_CUDA_FUNCTION_NV, //!< NV Cuda Function
#endif
};
inline cstring object_string(uint32_t flag) {
switch (flag) {
default:
case object_unknown: return "Unknown";
case object_instance: return "Instance";
case object_physical_device: return "Physical Device";
case object_logical_device: return "Logical Device";
case object_queue: return "Queue";
case object_semaphore: return "Semaphore";
case object_command_buffer: return "Command Buffer";
case object_fence: return "Fence";
case object_device_memory: return "Device Memory";
case object_buffer: return "Buffer";
case object_image: return "Image";
case object_event: return "Event";
case object_query_pool: return "Query Pool";
case object_buffer_view: return "Buffer View";
case object_image_view: return "Image View";
case object_shader_module: return "Shader Module";
case object_pipeline_cache: return "Pipeline Cache";
case object_pipeline_layout: return "Pipeline Layout";
case object_render_pass: return "Render Pass";
case object_pipeline: return "Pipeline";
case object_descriptor_set_layout: return "Descriptor Set Layout";
case object_sampler: return "Sampler";
case object_descriptor_pool: return "Descriptor Pool";
case object_descriptor_set: return "Descriptor Set";
case object_framebuffer: return "Framebuffer";
case object_command_pool: return "Command Pool";
case object_sampler_ycbcr_conversion: return "YCBCR Conversion Sampler";
case object_descriptor_update_template: return "Descriptor Update Template";
case object_private_data_slot: return "Private Data Slot";
case object_debug_report_callback_ext: return "Report Callback";
case object_debug_utils_messenger_ext: return "Debug Messenger";
case object_validation_cache_ext: return "Validation Cache";
case object_micromap_ext: return "Micro-Map";
case object_shader_ext: return "Shader";
case object_indirect_commands_layout_ext: return "Indirect Commands Layout";
case object_indirect_execution_set_ext: return "Indirect Execution Set";
case object_surface: return "Surface";
case object_swapchain: return "Swap-Chain";
case object_display: return "Display";
case object_display_mode: return "Display Mode";
case object_video_session: return "Video Session";
case object_video_session_parameters: return "Video Session Parameters";
case object_acceleration_structure: return "Acceleration Structure";
case object_deferred_operation: return "Deferred Operation";
case object_pipeline_binary: return "Pipeline Binary";
case object_acceleration_structure_NV: return "NV Acceleration Structure";
case object_indirect_commands_layout_NV: return "NV Indirect Commands Layout";
case object_optical_flow_session_NV: return "NV Optical Flow Session";
case object_external_compute_queue_NV: return "NV External Compute Queue";
case object_cu_module_NVX: return "NVX CU Module";
case object_cu_function_NVX: return "NVX CU Function";
case object_performance_configuration_INTEL: return "Intel Performance Configuration";
case object_buffer_collection_FUCHSIA: return "Fuchsia Buffer Collection";
case object_tensor_ARM: return "ARM Tensor";
case object_tensor_view_ARM: return "ARM Tensor View";
case object_data_graph_pipeline_session_ARM: return "ARM Data Graph Pipeline Session";
// Beta Extensions
#ifdef VK_ENABLE_BETA_EXTENSIONS
case object_cuda_module_NV: return "NV CUDA Module",
case object_cuda_function_NV: return "NV CUDA Function",
#endif
}
}
// Physical Devices ====================================================================================================
///
/// \brief An enum representing the Vulkan physical device types
enum device_ : uint32_t {
device_other = VK_PHYSICAL_DEVICE_TYPE_OTHER, //!< Other Type
device_integrated = VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU, //!< Integrated GPU
device_discrete = VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU, //!< Discrete / Dedicated GPU
device_virtual = VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU, //!< Virtualized / Software GPU
device_cpu = VK_PHYSICAL_DEVICE_TYPE_CPU, //!< CPU
};
///
/// \brief Get a descriptor string for the provided device type.
/// \param type The device type.
/// \returns A cstring containing a short description.
inline cstring device_string(uint32_t type) {
switch (type) {
default:
case device_other: return "Other";
case device_integrated: return "iGPU";
case device_discrete: return "dGPU";
case device_virtual: return "Virtual";
case device_cpu: return "CPU";
}
}
// Instances ===========================================================================================================
///
/// \brief An enum representing the Vulkan instance creation flags
enum instance_flag_ : uint32_t {
instance_flag_portability = VK_INSTANCE_CREATE_ENUMERATE_PORTABILITY_BIT_KHR, //!< Portability, allow non-conformant devices
instance_flag_none = 0, //!< No flags
instance_flag_all = instance_flag_portability, //!< All flags
};
///
/// \brief Get a descriptor string for the provided device type.
/// \param flag The instance flag.
/// \returns A cstring containing a short description.
inline cstring instance_flag_string(uint32_t flag) {
switch (flag) {
default:
case instance_flag_none: return "None";
case instance_flag_portability: return "Portability";
// TODO: Multi-Flags
//case instance_flag_all: return cstring("All");
}
}
// Debugging ===========================================================================================================
///
/// \brief An enum representing the Vulkan debug message severity flags
enum debug_message_severity_ : uint32_t {
debug_message_severity_verbose = VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT, //!< Verbose Message
debug_message_severity_info = VK_DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT, //!< Info Message
debug_message_severity_warning = VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT, //!< Warning Message
debug_message_severity_error = VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT, //!< Error Message
debug_message_severity_none = 0, //!< No flags
debug_message_severity_all = debug_message_severity_verbose
| debug_message_severity_info
| debug_message_severity_warning
| debug_message_severity_error, //!< All flags
};
///
/// \brief Get a descriptor string for the provided message severity.
/// \param flag The severity flag.
/// \returns A cstring containing a short description.
inline cstring message_severity_string(uint32_t flag) {
switch (flag) {
default:
case debug_message_severity_none: return "None";
case debug_message_severity_verbose: return "Verbose";
case debug_message_severity_info: return "Info";
case debug_message_severity_warning: return "Warning";
case debug_message_severity_error: return "Error";
// TODO: Multi-Flags
case debug_message_severity_all: return "All";
}
}
///
/// \brief An enum representing the Vulkan debug message type flags
enum debug_message_type_ : uint32_t {
debug_message_type_general = VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT, //!< General Message
debug_message_type_validation = VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT, //!< Validation Message
debug_message_type_performance = VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT, //!< Performance Message
debug_message_type_none = 0, //!< No flags
debug_message_type_all = debug_message_type_general
| debug_message_type_validation
| debug_message_type_performance, //!< All flags
};
///
/// \brief Get a descriptor string for the provided message type.
/// \param flag The type flag.
/// \returns A cstring containing a short description.
inline cstring message_type_string(uint32_t flag) {
switch (flag) {
default:
case debug_message_type_none: return "None";
case debug_message_type_general: return "General";
case debug_message_type_validation: return "Validation";
case debug_message_type_performance: return "Performance";
// TODO: Multi-Flags
case debug_message_type_all: return "All";
}
}
///
/// \brief An enum representing the Vulkan debug report flags
enum debug_report_ : uint32_t {
debug_report_information = VK_DEBUG_REPORT_INFORMATION_BIT_EXT, //!< Information Report
debug_report_warning = VK_DEBUG_REPORT_WARNING_BIT_EXT, //!< Warning Report
debug_report_performance = VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT, //!< Performance Warning Report
debug_report_error = VK_DEBUG_REPORT_ERROR_BIT_EXT, //!< Error Report
debug_report_debug = VK_DEBUG_REPORT_DEBUG_BIT_EXT, //!< Debug Report
debug_report_none = 0, //!< No flags
debug_report_all = debug_report_information
| debug_report_warning
| debug_report_performance
| debug_report_error
| debug_report_debug, //!< All flags
};
///
/// \brief Get a descriptor string for the provided report type.
/// \param flag The type flag.
/// \returns A cstring containing a short description.
inline cstring report_string(uint32_t flag) {
switch (flag) {
default:
case debug_report_none: return "None";
case debug_report_information: return "Information";
case debug_report_warning: return "Warning";
case debug_report_performance: return "Performance";
case debug_report_error: return "Error";
case debug_report_debug: return "Debug";
// TODO: Multi-Flags
case debug_report_all: return "All";
}
}
}
#endif // FENNEC_RENDERERS_VULKAN_LIB_ENUM_H

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