coffee/etl
1
0
Fork 0
mirror of https://github.com/ETLCPP/etl.git synced 2026-04-30 19:09:10 +08:00
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'development' into memory-operators-namespace

Browse Source
This commit is contained in:
John Wellbelove 2026-04-28 09:31:07 +02:00 committed by GitHub
commit 9fc2fda8fb
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
142 changed files with 7407 additions and 806 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

24
.devcontainer/Dockerfile
View File

@ -36,15 +36,27 @@ RUN set -eux \
&& apt-get -y install --no-install-recommends \
python3-full \
python3-pip \
python3-cogapp \
git \
wget \
cmake \
&& rm -rf /var/lib/apt/lists/* \
&& if pip help install | grep -q '\-\-break-system-packages'; then \
pip install --no-cache-dir --break-system-packages cogapp; \
else \
pip install --no-cache-dir cogapp; \
fi
clang-format \
clang-format-18 \
lcov \
&& rm -rf /var/lib/apt/lists/*
RUN set -eux; \
VERSION="2.4.1"; \
case "$(uname -m)" in \
x86_64) ARCH="amd64"; SHA256="bdaa2c0fbee03e5c2f99e605d9419386ce5d558440baac2017398faada839e04" ;; \
aarch64) ARCH="arm64"; SHA256="0a09e1f04a0f8a86fd4e709552613f5d82adf6bc72f0a4b5e217670894e79fbf" ;; \
*) echo "Unsupported architecture: $(uname -m)"; exit 1 ;; \
esac; \
wget -O treefmt.tar.gz "https://github.com/numtide/treefmt/releases/download/v${VERSION}/treefmt_${VERSION}_linux_${ARCH}.tar.gz" \
&& echo "${SHA256} treefmt.tar.gz" | sha256sum -c \
&& tar xzf treefmt.tar.gz treefmt \
&& install -m 755 treefmt /usr/bin/treefmt \
&& rm treefmt.tar.gz treefmt
RUN set -eux \
&& echo "Pip version: " \

54
.devcontainer/armhf/Dockerfile Normal file
View File

@ -0,0 +1,54 @@
# armhf Test Environment for ETL
# Uses QEMU user-mode emulation to run armhf binaries on x64 host
FROM debian:trixie
# Avoid prompts from apt
ENV DEBIAN_FRONTEND=noninteractive
# Install QEMU user-mode emulation and armhf cross-compilation tools
RUN dpkg --add-architecture armhf && \
apt-get update && apt-get install -y --no-install-recommends \
qemu-user-static \
qemu-user \
binfmt-support \
gcc-arm-linux-gnueabihf \
g++-arm-linux-gnueabihf \
cmake \
make \
ninja-build \
git \
wget \
file \
libc6:armhf \
libstdc++6:armhf \
&& rm -rf /var/lib/apt/lists/*
# Create non-root user with stable UID/GID
ARG USERNAME=vscode
ARG USER_UID=1000
ARG USER_GID=1000
RUN groupadd --gid ${USER_GID} ${USERNAME} && \
useradd --uid ${USER_UID} --gid ${USER_GID} --shell /bin/bash --create-home ${USERNAME}
# Set working directory
WORKDIR /workspaces/etl
# Verify QEMU and cross-compilation setup
RUN echo "=== Host Architecture ===" && \
uname -m && \
echo "" && \
echo "=== armhf Cross Compiler ===" && \
arm-linux-gnueabihf-gcc --version && \
echo "" && \
echo "=== QEMU arm ===" && \
qemu-arm-static --version | head -n1
# Ensure workspace directory ownership for non-root user
RUN mkdir -p /workspaces/etl && chown -R ${USERNAME}:${USERNAME} /workspaces
# Switch to non-root user
USER ${USERNAME}
# Default command
CMD ["/bin/bash"]

29
.devcontainer/armhf/devcontainer.json Normal file
View File

@ -0,0 +1,29 @@
// For format details, see https://aka.ms/devcontainer.json. For config options, see the
// README at: https://github.com/devcontainers/templates/tree/main/src/cpp
{
"name": "armhf (Debian)",
"build": {
"dockerfile": "./Dockerfile",
"context": "."
},
"customizations": {
"vscode": {
"extensions": [
"ms-vscode.cpptools",
"ms-vscode.cmake-tools"
],
"settings": {
"cmake.sourceDirectory": "${workspaceFolder}/test",
"cmake.configureArgs": [
"-DCMAKE_TOOLCHAIN_FILE=${workspaceFolder}/.devcontainer/armhf/toolchain-armhf.cmake",
"-DBUILD_TESTS=ON",
"-DNO_STL=OFF",
"-DETL_CXX_STANDARD=23"
],
"cmake.buildDirectory": "${workspaceFolder}/build-armhf",
"cmake.generator": "Ninja"
}
}
},
"remoteUser": "root"
}

21
.devcontainer/armhf/toolchain-armhf.cmake Normal file
View File

@ -0,0 +1,21 @@
# CMake toolchain file for armhf cross-compilation
set(CMAKE_SYSTEM_NAME Linux)
set(CMAKE_SYSTEM_PROCESSOR arm)
# Specify the cross compiler
set(CMAKE_C_COMPILER arm-linux-gnueabihf-gcc)
set(CMAKE_CXX_COMPILER arm-linux-gnueabihf-g++)
set(CMAKE_AR arm-linux-gnueabihf-ar)
set(CMAKE_RANLIB arm-linux-gnueabihf-ranlib)
set(CMAKE_STRIP arm-linux-gnueabihf-strip)
# Search for programs in the build host directories
set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER)
# For libraries and headers in the target directories
set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)
set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)
set(CMAKE_FIND_ROOT_PATH_MODE_PACKAGE ONLY)
# Set QEMU for running tests
set(CMAKE_CROSSCOMPILING_EMULATOR /usr/bin/qemu-arm-static CACHE FILEPATH "Path to the emulator for cross-compiled binaries")

54
.devcontainer/i386/Dockerfile Normal file
View File

@ -0,0 +1,54 @@
# i386 Test Environment for ETL
# Uses QEMU user-mode emulation to run i386 binaries on x64 host
FROM debian:trixie
# Avoid prompts from apt
ENV DEBIAN_FRONTEND=noninteractive
# Install QEMU user-mode emulation and i386 cross-compilation tools
RUN dpkg --add-architecture i386 && \
apt-get update && apt-get install -y --no-install-recommends \
qemu-user-static \
qemu-user \
binfmt-support \
gcc-i686-linux-gnu \
g++-i686-linux-gnu \
cmake \
make \
ninja-build \
git \
wget \
file \
libc6:i386 \
libstdc++6:i386 \
&& rm -rf /var/lib/apt/lists/*
# Create non-root user with stable UID/GID
ARG USERNAME=vscode
ARG USER_UID=1000
ARG USER_GID=1000
RUN groupadd --gid ${USER_GID} ${USERNAME} && \
useradd --uid ${USER_UID} --gid ${USER_GID} --shell /bin/bash --create-home ${USERNAME}
# Set working directory
WORKDIR /workspaces/etl
# Verify QEMU and cross-compilation setup
RUN echo "=== Host Architecture ===" && \
uname -m && \
echo "" && \
echo "=== i386 Cross Compiler ===" && \
i686-linux-gnu-gcc --version && \
echo "" && \
echo "=== QEMU i386 ===" && \
qemu-i386-static --version | head -n1
# Ensure workspace directory ownership for non-root user
RUN mkdir -p /workspaces/etl && chown -R ${USERNAME}:${USERNAME} /workspaces
# Switch to non-root user
USER ${USERNAME}
# Default command
CMD ["/bin/bash"]

29
.devcontainer/i386/devcontainer.json Normal file
View File

@ -0,0 +1,29 @@
// For format details, see https://aka.ms/devcontainer.json. For config options, see the
// README at: https://github.com/devcontainers/templates/tree/main/src/cpp
{
"name": "i386 (Debian)",
"build": {
"dockerfile": "./Dockerfile",
"context": "."
},
"customizations": {
"vscode": {
"extensions": [
"ms-vscode.cpptools",
"ms-vscode.cmake-tools"
],
"settings": {
"cmake.sourceDirectory": "${workspaceFolder}/test",
"cmake.configureArgs": [
"-DCMAKE_TOOLCHAIN_FILE=${workspaceFolder}/.devcontainer/i386/toolchain-i386.cmake",
"-DBUILD_TESTS=ON",
"-DNO_STL=OFF",
"-DETL_CXX_STANDARD=23"
],
"cmake.buildDirectory": "${workspaceFolder}/build-i386",
"cmake.generator": "Ninja"
}
}
},
"remoteUser": "root"
}

21
.devcontainer/i386/toolchain-i386.cmake Normal file
View File

@ -0,0 +1,21 @@
# CMake toolchain file for i386 cross-compilation
set(CMAKE_SYSTEM_NAME Linux)
set(CMAKE_SYSTEM_PROCESSOR i386)
# Specify the cross compiler
set(CMAKE_C_COMPILER i686-linux-gnu-gcc)
set(CMAKE_CXX_COMPILER i686-linux-gnu-g++)
set(CMAKE_AR i686-linux-gnu-ar)
set(CMAKE_RANLIB i686-linux-gnu-ranlib)
set(CMAKE_STRIP i686-linux-gnu-strip)
# Search for programs in the build host directories
set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER)
# For libraries and headers in the target directories
set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)
set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)
set(CMAKE_FIND_ROOT_PATH_MODE_PACKAGE ONLY)
# Set QEMU for running tests
set(CMAKE_CROSSCOMPILING_EMULATOR /usr/bin/qemu-i386-static CACHE FILEPATH "Path to the emulator for cross-compiled binaries")

79
.devcontainer/powerpc/Dockerfile Normal file
View File

@ -0,0 +1,79 @@
# powerpc Test Environment for ETL
# Uses QEMU user-mode emulation to run powerpc binaries on x64 host
FROM debian:sid-20260406
# Avoid prompts from apt
ENV DEBIAN_FRONTEND=noninteractive
# Install QEMU user-mode emulation and powerpc cross-compilation tools
RUN dpkg --add-architecture powerpc && \
apt-get update && apt-get install -y --no-install-recommends \
binfmt-support \
gpg \
ca-certificates \
cmake \
make \
ninja-build \
git \
wget \
file \
debian-ports-archive-keyring \
&& rm -rf /var/lib/apt/lists/*
RUN cat <<EOF > /etc/apt/sources.list.d/debian.sources
Types: deb
URIs: http://snapshot.debian.org/archive/debian/20260406T000000Z
Suites: sid
Components: main
Signed-By: /usr/share/keyrings/debian-archive-keyring.pgp
EOF
RUN cat <<EOF > /etc/apt/sources.list.d/powerpc.sources
Types: deb
URIs: http://snapshot.debian.org/archive/debian-ports/20260406T000000Z
Suites: sid
Components: main
Architectures: powerpc
Signed-By: /usr/share/keyrings/debian-ports-archive-keyring.gpg
EOF
RUN echo 'Acquire::Check-Valid-Until "false";' > /etc/apt/apt.conf.d/99no-check-valid
RUN apt-get update && apt-get install -y --no-install-recommends \
qemu-user-static \
qemu-user \
gcc-powerpc-linux-gnu \
g++-powerpc-linux-gnu \
libc6:powerpc \
libstdc++6:powerpc \
&& rm -rf /var/lib/apt/lists/*
# Create non-root user with stable UID/GID
ARG USERNAME=vscode
ARG USER_UID=1000
ARG USER_GID=1000
RUN groupadd --gid ${USER_GID} ${USERNAME} && \
useradd --uid ${USER_UID} --gid ${USER_GID} --shell /bin/bash --create-home ${USERNAME}
# Set working directory
WORKDIR /workspaces/etl
# Verify QEMU and cross-compilation setup
RUN echo "=== Host Architecture ===" && \
uname -m && \
echo "" && \
echo "=== powerpc Cross Compiler ===" && \
powerpc-linux-gnu-gcc --version && \
echo "" && \
echo "=== QEMU powerpc ===" && \
qemu-ppc-static --version | head -n1
# Ensure workspace directory ownership for non-root user
RUN mkdir -p /workspaces/etl && chown -R ${USERNAME}:${USERNAME} /workspaces
# Switch to non-root user
USER ${USERNAME}
# Default command
CMD ["/bin/bash"]

29
.devcontainer/powerpc/devcontainer.json Normal file
View File

@ -0,0 +1,29 @@
// For format details, see https://aka.ms/devcontainer.json. For config options, see the
// README at: https://github.com/devcontainers/templates/tree/main/src/cpp
{
"name": "powerpc (Debian)",
"build": {
"dockerfile": "./Dockerfile",
"context": "."
},
"customizations": {
"vscode": {
"extensions": [
"ms-vscode.cpptools",
"ms-vscode.cmake-tools"
],
"settings": {
"cmake.sourceDirectory": "${workspaceFolder}/test",
"cmake.configureArgs": [
"-DCMAKE_TOOLCHAIN_FILE=${workspaceFolder}/.devcontainer/powerpc/toolchain-powerpc.cmake",
"-DBUILD_TESTS=ON",
"-DNO_STL=ON",
"-DETL_CXX_STANDARD=23"
],
"cmake.buildDirectory": "${workspaceFolder}/build-powerpc",
"cmake.generator": "Ninja"
}
}
},
"remoteUser": "root"
}

21
.devcontainer/powerpc/toolchain-powerpc.cmake Normal file
View File

@ -0,0 +1,21 @@
# CMake toolchain file for powerpc cross-compilation
set(CMAKE_SYSTEM_NAME Linux)
set(CMAKE_SYSTEM_PROCESSOR powerpc)
# Specify the cross compiler
set(CMAKE_C_COMPILER powerpc-linux-gnu-gcc)
set(CMAKE_CXX_COMPILER powerpc-linux-gnu-g++)
set(CMAKE_AR powerpc-linux-gnu-ar)
set(CMAKE_RANLIB powerpc-linux-gnu-ranlib)
set(CMAKE_STRIP powerpc-linux-gnu-strip)
# Search for programs in the build host directories
set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER)
# For libraries and headers in the target directories
set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)
set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)
set(CMAKE_FIND_ROOT_PATH_MODE_PACKAGE ONLY)
# Set QEMU for running tests
set(CMAKE_CROSSCOMPILING_EMULATOR /usr/bin/qemu-ppc CACHE FILEPATH "Path to the emulator for cross-compiled binaries")

54
.devcontainer/riscv64/Dockerfile Normal file
View File

@ -0,0 +1,54 @@
# riscv64 Test Environment for ETL
# Uses QEMU user-mode emulation to run riscv64 binaries on x64 host
FROM debian:trixie
# Avoid prompts from apt
ENV DEBIAN_FRONTEND=noninteractive
# Install QEMU user-mode emulation and riscv64 cross-compilation tools
RUN dpkg --add-architecture riscv64 && \
apt-get update && apt-get install -y --no-install-recommends \
qemu-user-static \
qemu-user \
binfmt-support \
gcc-riscv64-linux-gnu \
g++-riscv64-linux-gnu \
cmake \
make \
ninja-build \
git \
wget \
file \
libc6:riscv64 \
libstdc++6:riscv64 \
&& rm -rf /var/lib/apt/lists/*
# Create non-root user with stable UID/GID
ARG USERNAME=vscode
ARG USER_UID=1000
ARG USER_GID=1000
RUN groupadd --gid ${USER_GID} ${USERNAME} && \
useradd --uid ${USER_UID} --gid ${USER_GID} --shell /bin/bash --create-home ${USERNAME}
# Set working directory
WORKDIR /workspaces/etl
# Verify QEMU and cross-compilation setup
RUN echo "=== Host Architecture ===" && \
uname -m && \
echo "" && \
echo "=== riscv64 Cross Compiler ===" && \
riscv64-linux-gnu-gcc --version && \
echo "" && \
echo "=== QEMU riscv64 ===" && \
qemu-riscv64-static --version | head -n1
# Ensure workspace directory ownership for non-root user
RUN mkdir -p /workspaces/etl && chown -R ${USERNAME}:${USERNAME} /workspaces
# Switch to non-root user
USER ${USERNAME}
# Default command
CMD ["/bin/bash"]

29
.devcontainer/riscv64/devcontainer.json Normal file
View File

@ -0,0 +1,29 @@
// For format details, see https://aka.ms/devcontainer.json. For config options, see the
// README at: https://github.com/devcontainers/templates/tree/main/src/cpp
{
"name": "riscv64 (Debian)",
"build": {
"dockerfile": "./Dockerfile",
"context": "."
},
"customizations": {
"vscode": {
"extensions": [
"ms-vscode.cpptools",
"ms-vscode.cmake-tools"
],
"settings": {
"cmake.sourceDirectory": "${workspaceFolder}/test",
"cmake.configureArgs": [
"-DCMAKE_TOOLCHAIN_FILE=${workspaceFolder}/.devcontainer/riscv64/toolchain-riscv64.cmake",
"-DBUILD_TESTS=ON",
"-DNO_STL=OFF",
"-DETL_CXX_STANDARD=23"
],
"cmake.buildDirectory": "${workspaceFolder}/build-riscv64",
"cmake.generator": "Ninja"
}
}
},
"remoteUser": "root"
}

20
.devcontainer/riscv64/toolchain-riscv64.cmake Normal file
View File

@ -0,0 +1,20 @@
# CMake toolchain file for riscv64 cross-compilation
set(CMAKE_SYSTEM_NAME Linux)
set(CMAKE_SYSTEM_PROCESSOR riscv64)
# Specify the cross compiler
set(CMAKE_C_COMPILER riscv64-linux-gnu-gcc)
set(CMAKE_CXX_COMPILER riscv64-linux-gnu-g++)
set(CMAKE_AR riscv64-linux-gnu-ar)
set(CMAKE_RANLIB riscv64-linux-gnu-ranlib)
set(CMAKE_STRIP riscv64-linux-gnu-strip)
# Search for programs in the build host directories
set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER)
# For libraries and headers in the target directories
set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)
set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)
set(CMAKE_FIND_ROOT_PATH_MODE_PACKAGE ONLY)
# Set QEMU for running tests
set(CMAKE_CROSSCOMPILING_EMULATOR /usr/bin/qemu-riscv64-static CACHE FILEPATH "Path to the emulator for cross-compiled binaries")

56
.devcontainer/run-tests.sh Executable file
View File

@ -0,0 +1,56 @@
#!/bin/bash
#
# Run tests inside the separately created docker container for different hardware architecture
#
# Strategy:
# * Create docker image
# * Enter image
# * Cross build tests
# * Run tests via QEMU
#
set -e
usage()
{
echo "Usage: run-tests.sh <architecture>"
echo "Architecture: armhf|i386|powerpc|riscv64|s390x"
echo "(run from project root)"
}
ARCHLIST="armhf i386 powerpc riscv64 s390x"
if [[ " $ARCHLIST " =~ " $1 " ]] ; then
ARCH=$1
else
echo "Unsupported architecture: $1"
usage
exit 1
fi
if [ "$2" = "" ] ; then
echo "Creating docker image..."
docker build -t $ARCH .devcontainer/$ARCH
echo "Entering container..."
docker run -it --rm -v "$PWD":/workspaces/etl -w /workspaces/etl $ARCH /bin/bash .devcontainer/run-tests.sh $ARCH inside_container
elif [ "$2" = "inside_container" ] ; then
echo "Cross building tests..."
mkdir -p build-$ARCH
cd build-$ARCH
cmake -DCMAKE_TOOLCHAIN_FILE=../.devcontainer/$ARCH/toolchain-$ARCH.cmake \
-DBUILD_TESTS=ON -DNO_STL=ON -DETL_CXX_STANDARD=23 \
-DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF -DETL_OPTIMISATION=-O0 -DETL_ENABLE_SANITIZER=Off -DETL_MESSAGES_ARE_NOT_VIRTUAL=OFF \
../test
export CMAKE_BUILD_PARALLEL_LEVEL=$(nproc)
cmake --build .
echo "Running tests via CTest (using QEMU emulator from toolchain)..."
ctest -V --output-on-failure
echo "Tests successful."
else
echo "Invalid second argument: $2"
usage
exit 1
fi

16
.devcontainer/s390x/Dockerfile
View File

@ -7,7 +7,7 @@ ENV DEBIAN_FRONTEND=noninteractive
# Install QEMU user-mode emulation and s390x cross-compilation tools
RUN dpkg --add-architecture s390x && \
apt-get update && apt-get install -y --no-install-recommends\
apt-get update && apt-get install -y --no-install-recommends \
qemu-user-static \
qemu-user \
binfmt-support \
@ -23,6 +23,14 @@ RUN dpkg --add-architecture s390x && \
libstdc++6:s390x \
&& rm -rf /var/lib/apt/lists/*
# Create non-root user with stable UID/GID
ARG USERNAME=vscode
ARG USER_UID=1000
ARG USER_GID=1000
RUN groupadd --gid ${USER_GID} ${USERNAME} && \
useradd --uid ${USER_UID} --gid ${USER_GID} --shell /bin/bash --create-home ${USERNAME}
# Set working directory
WORKDIR /workspaces/etl
@ -36,5 +44,11 @@ RUN echo "=== Host Architecture ===" && \
echo "=== QEMU s390x ===" && \
qemu-s390x-static --version | head -n1
# Ensure workspace directory ownership for non-root user
RUN mkdir -p /workspaces/etl && chown -R ${USERNAME}:${USERNAME} /workspaces
# Switch to non-root user
USER ${USERNAME}
# Default command
CMD ["/bin/bash"]

2
.devcontainer/s390x/devcontainer.json
View File

@ -18,7 +18,7 @@
"-DCMAKE_TOOLCHAIN_FILE=${workspaceFolder}/.devcontainer/s390x/toolchain-s390x.cmake",
"-DBUILD_TESTS=ON",
"-DNO_STL=OFF",
"-DETL_CXX_STANDARD=17"
"-DETL_CXX_STANDARD=23"
],
"cmake.buildDirectory": "${workspaceFolder}/build-s390x",
"cmake.generator": "Ninja"

4
.github/workflows/clang-c++11.yml vendored
View File

@ -25,7 +25,7 @@ jobs:
export ASAN_OPTIONS=alloc_dealloc_mismatch=0,detect_leaks=0
cmake -D BUILD_TESTS=ON -DNO_STL=OFF -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF -DETL_CXX_STANDARD=11 ./
clang --version
make -j $(getconf _NPROCESSORS_ONLN)
make -j "$(getconf _NPROCESSORS_ONLN)"
- name: Run tests
run: ./test/etl_tests -v
@ -47,7 +47,7 @@ jobs:
export ASAN_OPTIONS=alloc_dealloc_mismatch=0,detect_leaks=0
cmake -D BUILD_TESTS=ON -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF -DETL_CXX_STANDARD=11 ./
clang --version
make -j $(getconf _NPROCESSORS_ONLN)
make -j "$(getconf _NPROCESSORS_ONLN)"
- name: Run tests
run: ./test/etl_tests -v

4
.github/workflows/clang-c++14.yml vendored
View File

@ -25,7 +25,7 @@ jobs:
export ASAN_OPTIONS=alloc_dealloc_mismatch=0,detect_leaks=0
cmake -D BUILD_TESTS=ON -DNO_STL=OFF -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF -DETL_CXX_STANDARD=14 ./
clang --version
make -j $(getconf _NPROCESSORS_ONLN)
make -j "$(getconf _NPROCESSORS_ONLN)"
- name: Run tests
run: ./test/etl_tests -v
@ -47,7 +47,7 @@ jobs:
export ASAN_OPTIONS=alloc_dealloc_mismatch=0,detect_leaks=0
cmake -D BUILD_TESTS=ON -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF -DETL_CXX_STANDARD=14 ./
clang --version
make -j $(getconf _NPROCESSORS_ONLN)
make -j "$(getconf _NPROCESSORS_ONLN)"
- name: Run tests
run: ./test/etl_tests -v

4
.github/workflows/clang-c++17.yml vendored
View File

@ -25,7 +25,7 @@ jobs:
export ASAN_OPTIONS=alloc_dealloc_mismatch=0,detect_leaks=0
cmake -D BUILD_TESTS=ON -DNO_STL=OFF -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF -DETL_CXX_STANDARD=17 ./
clang --version
make -j $(getconf _NPROCESSORS_ONLN)
make -j "$(getconf _NPROCESSORS_ONLN)"
- name: Run tests
run: ./test/etl_tests -v
@ -47,7 +47,7 @@ jobs:
export ASAN_OPTIONS=alloc_dealloc_mismatch=0,detect_leaks=0
cmake -D BUILD_TESTS=ON -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF -DETL_CXX_STANDARD=17 ./
clang --version
make -j $(getconf _NPROCESSORS_ONLN)
make -j "$(getconf _NPROCESSORS_ONLN)"
- name: Run tests
run: ./test/etl_tests -v

14
.github/workflows/clang-c++20.yml vendored
View File

@ -32,7 +32,7 @@ jobs:
export ASAN_OPTIONS=alloc_dealloc_mismatch=0,detect_leaks=0
cmake -DBUILD_TESTS=ON -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF -DETL_CXX_STANDARD=20 ./
clang-17 --version
make -j $(getconf _NPROCESSORS_ONLN)
make -j "$(getconf _NPROCESSORS_ONLN)"
- name: Run tests
run: ./test/etl_tests -v
@ -61,7 +61,7 @@ jobs:
export ASAN_OPTIONS=alloc_dealloc_mismatch=0,detect_leaks=0
cmake -D BUILD_TESTS=ON -DNO_STL=OFF -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=ON -DETL_CXX_STANDARD=20 ./
clang-17 --version
make -j $(getconf _NPROCESSORS_ONLN)
make -j "$(getconf _NPROCESSORS_ONLN)"
- name: Run tests
run: ./test/etl_tests -v
@ -90,7 +90,7 @@ jobs:
export ASAN_OPTIONS=alloc_dealloc_mismatch=0,detect_leaks=0
cmake -D BUILD_TESTS=ON -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=ON -DETL_CXX_STANDARD=20 ./
clang-17 --version
make -j $(getconf _NPROCESSORS_ONLN)
make -j "$(getconf _NPROCESSORS_ONLN)"
- name: Run tests
run: ./test/etl_tests -v
@ -112,7 +112,7 @@ jobs:
export ASAN_OPTIONS=alloc_dealloc_mismatch=0,detect_leaks=0
cmake -D BUILD_TESTS=ON -DNO_STL=OFF -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF -DETL_CXX_STANDARD=20 ./
clang --version
make -j $(getconf _NPROCESSORS_ONLN)
make -j "$(getconf _NPROCESSORS_ONLN)"
- name: Run tests
run: ./test/etl_tests -v
@ -134,7 +134,7 @@ jobs:
export ASAN_OPTIONS=alloc_dealloc_mismatch=0,detect_leaks=0
cmake -D BUILD_TESTS=ON -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF -DETL_CXX_STANDARD=20 ./
clang --version
make -j $(getconf _NPROCESSORS_ONLN)
make -j "$(getconf _NPROCESSORS_ONLN)"
- name: Run tests
run: ./test/etl_tests -v
@ -156,7 +156,7 @@ jobs:
export ASAN_OPTIONS=alloc_dealloc_mismatch=0,detect_leaks=0
cmake -D BUILD_TESTS=ON -DNO_STL=OFF -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=ON -DETL_CXX_STANDARD=20 ./
clang --version
make -j $(getconf _NPROCESSORS_ONLN)
make -j "$(getconf _NPROCESSORS_ONLN)"
- name: Run tests
run: ./test/etl_tests -v
@ -178,7 +178,7 @@ jobs:
export ASAN_OPTIONS=alloc_dealloc_mismatch=0,detect_leaks=0
cmake -D BUILD_TESTS=ON -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=ON -DETL_CXX_STANDARD=20 ./
clang --version
make -j $(getconf _NPROCESSORS_ONLN)
make -j "$(getconf _NPROCESSORS_ONLN)"
- name: Run tests
run: ./test/etl_tests -v

28
.github/workflows/clang-c++23.yml vendored
View File

@ -30,9 +30,9 @@ jobs:
export CC=clang-17
export CXX=clang++-17
export ASAN_OPTIONS=alloc_dealloc_mismatch=0,detect_leaks=0
cmake -DBUILD_TESTS=ON -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03=OFF -DETL_CXX_STANDARD=23 ./
cmake -DBUILD_TESTS=ON -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF -DETL_CXX_STANDARD=23 ./
clang-17 --version
make -j $(getconf _NPROCESSORS_ONLN)
make -j "$(getconf _NPROCESSORS_ONLN)"
- name: Run tests
run: ./test/etl_tests -v
@ -59,9 +59,9 @@ jobs:
export CC=clang-17
export CXX=clang++-17
export ASAN_OPTIONS=alloc_dealloc_mismatch=0,detect_leaks=0
cmake -D BUILD_TESTS=ON -DNO_STL=OFF -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03=ON -DETL_CXX_STANDARD=23 ./
cmake -D BUILD_TESTS=ON -DNO_STL=OFF -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=ON -DETL_CXX_STANDARD=23 ./
clang-17 --version
make -j $(getconf _NPROCESSORS_ONLN)
make -j "$(getconf _NPROCESSORS_ONLN)"
- name: Run tests
run: ./test/etl_tests -v
@ -88,9 +88,9 @@ jobs:
export CC=clang-17
export CXX=clang++-17
export ASAN_OPTIONS=alloc_dealloc_mismatch=0,detect_leaks=0
cmake -D BUILD_TESTS=ON -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03=ON -DETL_CXX_STANDARD=23 ./
cmake -D BUILD_TESTS=ON -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=ON -DETL_CXX_STANDARD=23 ./
clang-17 --version
make -j $(getconf _NPROCESSORS_ONLN)
make -j "$(getconf _NPROCESSORS_ONLN)"
- name: Run tests
run: ./test/etl_tests -v
@ -110,9 +110,9 @@ jobs:
export CC=clang
export CXX=clang++
export ASAN_OPTIONS=alloc_dealloc_mismatch=0,detect_leaks=0
cmake -D BUILD_TESTS=ON -DNO_STL=OFF -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03=OFF -DETL_CXX_STANDARD=23 ./
cmake -D BUILD_TESTS=ON -DNO_STL=OFF -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF -DETL_CXX_STANDARD=23 ./
clang --version
make -j $(getconf _NPROCESSORS_ONLN)
make -j "$(getconf _NPROCESSORS_ONLN)"
- name: Run tests
run: ./test/etl_tests -v
@ -132,9 +132,9 @@ jobs:
export CC=clang
export CXX=clang++
export ASAN_OPTIONS=alloc_dealloc_mismatch=0,detect_leaks=0
cmake -D BUILD_TESTS=ON -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03=OFF -DETL_CXX_STANDARD=23 ./
cmake -D BUILD_TESTS=ON -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF -DETL_CXX_STANDARD=23 ./
clang --version
make -j $(getconf _NPROCESSORS_ONLN)
make -j "$(getconf _NPROCESSORS_ONLN)"
- name: Run tests
run: ./test/etl_tests -v
@ -154,9 +154,9 @@ jobs:
export CC=clang
export CXX=clang++
export ASAN_OPTIONS=alloc_dealloc_mismatch=0,detect_leaks=0
cmake -D BUILD_TESTS=ON -DNO_STL=OFF -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03=ON -DETL_CXX_STANDARD=23 ./
cmake -D BUILD_TESTS=ON -DNO_STL=OFF -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=ON -DETL_CXX_STANDARD=23 ./
clang --version
make -j $(getconf _NPROCESSORS_ONLN)
make -j "$(getconf _NPROCESSORS_ONLN)"
- name: Run tests
run: ./test/etl_tests -v
@ -176,9 +176,9 @@ jobs:
export CC=clang
export CXX=clang++
export ASAN_OPTIONS=alloc_dealloc_mismatch=0,detect_leaks=0
cmake -D BUILD_TESTS=ON -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03=ON -DETL_CXX_STANDARD=23 ./
cmake -D BUILD_TESTS=ON -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=ON -DETL_CXX_STANDARD=23 ./
clang --version
make -j $(getconf _NPROCESSORS_ONLN)
make -j "$(getconf _NPROCESSORS_ONLN)"
- name: Run tests
run: ./test/etl_tests -v

189
.github/workflows/clang-c++26.yml vendored Normal file
View File

@ -0,0 +1,189 @@
name: clang-c++26
on:
push:
branches: [ master, development, pull-request/* ]
pull_request:
branches: [ master, development, pull-request/* ]
types: [opened, synchronize, reopened]
jobs:
build-clang-cpp26-linux-stl:
name: Clang C++26 Linux - STL
if: false # enabled when ubuntu-26.04 is available in github
runs-on: ${{ matrix.os }}
strategy:
matrix:
os: [ubuntu-26.04]
steps:
- uses: actions/checkout@v4
- name: Build
run: |
export CC=clang
export CXX=clang++
export ASAN_OPTIONS=alloc_dealloc_mismatch=0,detect_leaks=0
cmake -DBUILD_TESTS=ON -DNO_STL=OFF -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF -DETL_CXX_STANDARD=26 ./
clang --version
make -j "$(getconf _NPROCESSORS_ONLN)"
- name: Run tests
run: ./test/etl_tests -v
build-clang-cpp26-linux-no-stl:
name: Clang C++26 Linux - No STL
if: false # enabled when ubuntu-26.04 is available in github
runs-on: ${{ matrix.os }}
strategy:
matrix:
os: [ubuntu-26.04]
steps:
- uses: actions/checkout@v4
- name: Build
run: |
export CC=clang
export CXX=clang++
export ASAN_OPTIONS=alloc_dealloc_mismatch=0,detect_leaks=0
cmake -DBUILD_TESTS=ON -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF -DETL_CXX_STANDARD=26 ./
clang --version
make -j "$(getconf _NPROCESSORS_ONLN)"
- name: Run tests
run: ./test/etl_tests -v
build-clang-cpp26-linux-stl-force-cpp03:
name: Clang C++26 Linux - STL - Force C++03
if: false # enabled when ubuntu-26.04 is available in github
runs-on: ${{ matrix.os }}
strategy:
matrix:
os: [ubuntu-26.04]
steps:
- uses: actions/checkout@v4
- name: Build
run: |
export CC=clang
export CXX=clang++
export ASAN_OPTIONS=alloc_dealloc_mismatch=0,detect_leaks=0
cmake -D BUILD_TESTS=ON -DNO_STL=OFF -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=ON -DETL_CXX_STANDARD=26 ./
clang --version
make -j "$(getconf _NPROCESSORS_ONLN)"
- name: Run tests
run: ./test/etl_tests -v
build-clang-cpp26-linux-no-stl-force-cpp03:
name: Clang C++26 Linux - No STL - Force C++03
if: false # enabled when ubuntu-26.04 is available in github
runs-on: ${{ matrix.os }}
strategy:
matrix:
os: [ubuntu-26.04]
steps:
- uses: actions/checkout@v4
- name: Build
run: |
export CC=clang
export CXX=clang++
export ASAN_OPTIONS=alloc_dealloc_mismatch=0,detect_leaks=0
cmake -D BUILD_TESTS=ON -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=ON -DETL_CXX_STANDARD=26 ./
clang --version
make -j "$(getconf _NPROCESSORS_ONLN)"
- name: Run tests
run: ./test/etl_tests -v
build-clang-cpp26-osx-stl:
name: Clang C++26 OSX - STL
runs-on: ${{ matrix.os }}
strategy:
matrix:
os: [macos-26]
steps:
- uses: actions/checkout@v4
- name: Build
run: |
export CC=clang
export CXX=clang++
export ASAN_OPTIONS=alloc_dealloc_mismatch=0,detect_leaks=0
cmake -D BUILD_TESTS=ON -DNO_STL=OFF -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF -DETL_CXX_STANDARD=26 ./
clang --version
make -j "$(getconf _NPROCESSORS_ONLN)"
- name: Run tests
run: ./test/etl_tests -v
build-clang-cpp26-osx-no-stl:
name: Clang C++26 OSX - No STL
runs-on: ${{ matrix.os }}
strategy:
matrix:
os: [macos-26]
steps:
- uses: actions/checkout@v4
- name: Build
run: |
export CC=clang
export CXX=clang++
export ASAN_OPTIONS=alloc_dealloc_mismatch=0,detect_leaks=0
cmake -D BUILD_TESTS=ON -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF -DETL_CXX_STANDARD=26 ./
clang --version
make -j "$(getconf _NPROCESSORS_ONLN)"
- name: Run tests
run: ./test/etl_tests -v
build-clang-cpp26-osx-stl-force-cpp03:
name: Clang C++26 OSX - STL - Force C++03
runs-on: ${{ matrix.os }}
strategy:
matrix:
os: [macos-26]
steps:
- uses: actions/checkout@v4
- name: Build
run: |
export CC=clang
export CXX=clang++
export ASAN_OPTIONS=alloc_dealloc_mismatch=0,detect_leaks=0
cmake -D BUILD_TESTS=ON -DNO_STL=OFF -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=ON -DETL_CXX_STANDARD=26 ./
clang --version
make -j "$(getconf _NPROCESSORS_ONLN)"
- name: Run tests
run: ./test/etl_tests -v
build-clang-cpp26-osx-no-stl-force-cpp03:
name: Clang C++26 OSX - No STL - Force C++03
runs-on: ${{ matrix.os }}
strategy:
matrix:
os: [macos-26]
steps:
- uses: actions/checkout@v4
- name: Build
run: |
export CC=clang
export CXX=clang++
export ASAN_OPTIONS=alloc_dealloc_mismatch=0,detect_leaks=0
cmake -D BUILD_TESTS=ON -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=ON -DETL_CXX_STANDARD=26 ./
clang --version
make -j "$(getconf _NPROCESSORS_ONLN)"
- name: Run tests
run: ./test/etl_tests -v

132
.github/workflows/clang-syntax-checks.yml vendored
View File

@ -23,10 +23,10 @@ jobs:
export CXX=clang++
cmake -DNO_STL=OFF -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF -DETL_CXX_STANDARD=03 ./test/syntax_check
clang --version
make -j $(getconf _NPROCESSORS_ONLN)
make -j "$(getconf _NPROCESSORS_ONLN)"
build-clang-cpp03-linux-No-STL:
name: Syntax Check - Clang C++03 Linux No STL
name: Syntax Check - Clang C++03 Linux No STL
runs-on: ${{ matrix.os }}
strategy:
matrix:
@ -41,7 +41,7 @@ jobs:
export CXX=clang++
cmake -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF -DETL_CXX_STANDARD=03 ./test/syntax_check
clang --version
make -j $(getconf _NPROCESSORS_ONLN)
make -j "$(getconf _NPROCESSORS_ONLN)"
build-clang-cpp11-linux-STL:
name: Syntax Check - Clang C++11 Linux STL
@ -59,10 +59,10 @@ jobs:
export CXX=clang++
cmake -DNO_STL=OFF -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF -DETL_CXX_STANDARD=11 ./test/syntax_check
clang --version
make -j $(getconf _NPROCESSORS_ONLN)
make -j "$(getconf _NPROCESSORS_ONLN)"
build-clang-cpp11-linux-No-STL:
name: Syntax Check - Clang C++11 Linux No STL
name: Syntax Check - Clang C++11 Linux No STL
runs-on: ${{ matrix.os }}
strategy:
matrix:
@ -77,7 +77,7 @@ jobs:
export CXX=clang++
cmake -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF -DETL_CXX_STANDARD=11 ./test/syntax_check
clang --version
make -j $(getconf _NPROCESSORS_ONLN)
make -j "$(getconf _NPROCESSORS_ONLN)"
build-clang-cpp11-linux-STL-Force-CPP03:
name: Syntax Check - Clang C++11 Linux STL Force C++03
@ -95,7 +95,7 @@ jobs:
export CXX=clang++
cmake -DNO_STL=OFF -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=ON -DETL_CXX_STANDARD=11 ./test/syntax_check
clang --version
make -j $(getconf _NPROCESSORS_ONLN)
make -j "$(getconf _NPROCESSORS_ONLN)"
build-clang-cpp11-linux-No-STL-Force-CPP03:
name: Syntax Check - Clang C++11 Linux No STL Force C++03
@ -113,7 +113,7 @@ jobs:
export CXX=clang++
cmake -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=ON -DETL_CXX_STANDARD=11 ./test/syntax_check
clang --version
make -j $(getconf _NPROCESSORS_ONLN)
make -j "$(getconf _NPROCESSORS_ONLN)"
build-clang-cpp14-linux-STL:
name: Syntax Check - Clang C++14 Linux STL
@ -131,10 +131,10 @@ jobs:
export CXX=clang++
cmake -DNO_STL=OFF -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF -DETL_CXX_STANDARD=14 ./test/syntax_check
clang --version
make -j $(getconf _NPROCESSORS_ONLN)
make -j "$(getconf _NPROCESSORS_ONLN)"
build-clang-cpp14-linux-No-STL:
name: Syntax Check - Clang C++14 Linux No STL
name: Syntax Check - Clang C++14 Linux No STL
runs-on: ${{ matrix.os }}
strategy:
matrix:
@ -149,7 +149,7 @@ jobs:
export CXX=clang++
cmake -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF -DETL_CXX_STANDARD=14 ./test/syntax_check
clang --version
make -j $(getconf _NPROCESSORS_ONLN)
make -j "$(getconf _NPROCESSORS_ONLN)"
build-clang-cpp14-linux-STL-Force-CPP03:
name: Syntax Check - Clang C++14 Linux STL Force C++03
@ -167,7 +167,7 @@ jobs:
export CXX=clang++
cmake -DNO_STL=OFF -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=ON -DETL_CXX_STANDARD=14 ./test/syntax_check
clang --version
make -j $(getconf _NPROCESSORS_ONLN)
make -j "$(getconf _NPROCESSORS_ONLN)"
build-clang-cpp14-linux-No-STL-Force-CPP03:
name: Syntax Check - Clang C++14 Linux No STL Force C++03
@ -185,7 +185,7 @@ jobs:
export CXX=clang++
cmake -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=ON -DETL_CXX_STANDARD=14 ./test/syntax_check
clang --version
make -j $(getconf _NPROCESSORS_ONLN)
make -j "$(getconf _NPROCESSORS_ONLN)"
build-clang-cpp17-linux-STL:
name: Syntax Check - Clang C++17 Linux STL
@ -203,10 +203,10 @@ jobs:
export CXX=clang++
cmake -DNO_STL=OFF -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF -DETL_CXX_STANDARD=17 ./test/syntax_check
clang --version
make -j $(getconf _NPROCESSORS_ONLN)
make -j "$(getconf _NPROCESSORS_ONLN)"
build-clang-cpp17-linux-No-STL:
name: Syntax Check - Clang C++17 Linux No STL
name: Syntax Check - Clang C++17 Linux No STL
runs-on: ${{ matrix.os }}
strategy:
matrix:
@ -221,7 +221,7 @@ jobs:
export CXX=clang++
cmake -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF -DETL_CXX_STANDARD=17 ./test/syntax_check
clang --version
make -j $(getconf _NPROCESSORS_ONLN)
make -j "$(getconf _NPROCESSORS_ONLN)"
build-clang-cpp17-linux-STL-Force-CPP03:
name: Syntax Check - Clang C++17 Linux STL Force C++03
@ -239,7 +239,7 @@ jobs:
export CXX=clang++
cmake -DNO_STL=OFF -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=ON -DETL_CXX_STANDARD=17 ./test/syntax_check
clang --version
make -j $(getconf _NPROCESSORS_ONLN)
make -j "$(getconf _NPROCESSORS_ONLN)"
build-clang-cpp17-linux-No-STL-Force-CPP03:
name: Syntax Check - Clang C++17 Linux No STL Force C++03
@ -257,7 +257,7 @@ jobs:
export CXX=clang++
cmake -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=ON -DETL_CXX_STANDARD=17 ./test/syntax_check
clang --version
make -j $(getconf _NPROCESSORS_ONLN)
make -j "$(getconf _NPROCESSORS_ONLN)"
build-clang-cpp20-linux-STL:
name: Syntax Check - Clang C++20 Linux STL
@ -275,10 +275,10 @@ jobs:
export CXX=clang++
cmake -DNO_STL=OFF -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF -DETL_CXX_STANDARD=20 ./test/syntax_check
clang --version
make -j $(getconf _NPROCESSORS_ONLN)
make -j "$(getconf _NPROCESSORS_ONLN)"
build-clang-cpp20-linux-No-STL:
name: Syntax Check - Clang C++20 Linux No STL
name: Syntax Check - Clang C++20 Linux No STL
runs-on: ${{ matrix.os }}
strategy:
matrix:
@ -293,7 +293,7 @@ jobs:
export CXX=clang++
cmake -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF -DETL_CXX_STANDARD=20 ./test/syntax_check
clang --version
make -j $(getconf _NPROCESSORS_ONLN)
make -j "$(getconf _NPROCESSORS_ONLN)"
build-clang-cpp20-linux-STL-Force-CPP03:
name: Syntax Check - Clang C++20 Linux STL Force C++03
@ -311,7 +311,7 @@ jobs:
export CXX=clang++
cmake -DNO_STL=OFF -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=ON -DETL_CXX_STANDARD=20 ./test/syntax_check
clang --version
make -j $(getconf _NPROCESSORS_ONLN)
make -j "$(getconf _NPROCESSORS_ONLN)"
build-clang-cpp20-linux-No-STL-Force-CPP03:
name: Syntax Check - Clang C++20 Linux No STL Force C++03
@ -329,7 +329,7 @@ jobs:
export CXX=clang++
cmake -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=ON -DETL_CXX_STANDARD=20 ./test/syntax_check
clang --version
make -j $(getconf _NPROCESSORS_ONLN)
make -j "$(getconf _NPROCESSORS_ONLN)"
build-clang-cpp23-linux-STL:
name: Syntax Check - Clang C++23 Linux STL
@ -347,10 +347,10 @@ jobs:
export CXX=clang++
cmake -DNO_STL=OFF -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF -DETL_CXX_STANDARD=23 ./test/syntax_check
clang --version
make -j $(getconf _NPROCESSORS_ONLN)
make -j "$(getconf _NPROCESSORS_ONLN)"
build-clang-cpp23-linux-No-STL:
name: Syntax Check - Clang C++23 Linux No STL
name: Syntax Check - Clang C++23 Linux No STL
runs-on: ${{ matrix.os }}
strategy:
matrix:
@ -365,7 +365,7 @@ jobs:
export CXX=clang++
cmake -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF -DETL_CXX_STANDARD=23 ./test/syntax_check
clang --version
make -j $(getconf _NPROCESSORS_ONLN)
make -j "$(getconf _NPROCESSORS_ONLN)"
build-clang-cpp23-linux-STL-Force-CPP03:
name: Syntax Check - Clang C++23 Linux STL Force C++03
@ -383,7 +383,7 @@ jobs:
export CXX=clang++
cmake -DNO_STL=OFF -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=ON -DETL_CXX_STANDARD=23 ./test/syntax_check
clang --version
make -j $(getconf _NPROCESSORS_ONLN)
make -j "$(getconf _NPROCESSORS_ONLN)"
build-clang-cpp23-linux-No-STL-Force-CPP03:
name: Syntax Check - Clang C++23 Linux No STL Force C++03
@ -401,4 +401,80 @@ jobs:
export CXX=clang++
cmake -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=ON -DETL_CXX_STANDARD=23 ./test/syntax_check
clang --version
make -j $(getconf _NPROCESSORS_ONLN)
make -j "$(getconf _NPROCESSORS_ONLN)"
build-clang-cpp26-linux-STL:
name: Syntax Check - Clang C++26 Linux STL
if: false # enabled when ubuntu-26.04 is available in github
runs-on: ${{ matrix.os }}
strategy:
matrix:
os: [ubuntu-26.04]
steps:
- uses: actions/checkout@v4
- name: Build
run: |
export CC=clang
export CXX=clang++
cmake -DNO_STL=OFF -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF -DETL_CXX_STANDARD=26 ./test/syntax_check
clang++ --version
make -j "$(getconf _NPROCESSORS_ONLN)"
build-clang-cpp26-linux-No-STL:
name: Syntax Check - Clang C++26 Linux No STL
if: false # enabled when ubuntu-26.04 is available in github
runs-on: ${{ matrix.os }}
strategy:
matrix:
os: [ubuntu-26.04]
steps:
- uses: actions/checkout@v4
- name: Build
run: |
export CC=clang
export CXX=clang++
cmake -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF -DETL_CXX_STANDARD=26 ./test/syntax_check
clang++ --version
make -j "$(getconf _NPROCESSORS_ONLN)"
build-clang-cpp26-linux-STL-Force-CPP03:
name: Syntax Check - Clang C++26 Linux STL Force C++03
if: false # enabled when ubuntu-26.04 is available in github
runs-on: ${{ matrix.os }}
strategy:
matrix:
os: [ubuntu-26.04]
steps:
- uses: actions/checkout@v4
- name: Build
run: |
export CC=clang
export CXX=clang++
cmake -DNO_STL=OFF -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=ON -DETL_CXX_STANDARD=26 ./test/syntax_check
clang++ --version
make -j "$(getconf _NPROCESSORS_ONLN)"
build-clang-cpp26-linux-No-STL-Force-CPP03:
name: Syntax Check - Clang C++26 Linux No STL Force C++03
if: false # enabled when ubuntu-26.04 is available in github
runs-on: ${{ matrix.os }}
strategy:
matrix:
os: [ubuntu-26.04]
steps:
- uses: actions/checkout@v4
- name: Build
run: |
export CC=clang
export CXX=clang++
cmake -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=ON -DETL_CXX_STANDARD=26 ./test/syntax_check
clang++ --version
make -j "$(getconf _NPROCESSORS_ONLN)"

6
.github/workflows/coverage.yml vendored
View File

@ -65,8 +65,4 @@ jobs:
steps:
- name: Deploy to GitHub Pages
id: deployment
uses: actions/deploy-pages@v4
# GitHub Repository settings
# -> Settings -> Pages
# -> Source: gh actions
uses: actions/deploy-pages@v5

4
.github/workflows/gcc-c++11.yml vendored
View File

@ -26,7 +26,7 @@ jobs:
export CXX=g++
cmake -DBUILD_TESTS=ON -DNO_STL=OFF -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF -DETL_CXX_STANDARD=11 ./
gcc --version
make -j $(getconf _NPROCESSORS_ONLN)
make -j "$(getconf _NPROCESSORS_ONLN)"
- name: Run tests
run: ./test/etl_tests -v
@ -49,7 +49,7 @@ jobs:
export CXX=g++
cmake -DBUILD_TESTS=ON -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF -DETL_CXX_STANDARD=11 ./
gcc --version
make -j $(getconf _NPROCESSORS_ONLN)
make -j "$(getconf _NPROCESSORS_ONLN)"
- name: Run tests
run: ./test/etl_tests -v

4
.github/workflows/gcc-c++14.yml vendored
View File

@ -25,7 +25,7 @@ jobs:
export CXX=g++
cmake -DBUILD_TESTS=ON -DNO_STL=OFF -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF -DETL_CXX_STANDARD=14 ./
gcc --version
make -j $(getconf _NPROCESSORS_ONLN)
make -j "$(getconf _NPROCESSORS_ONLN)"
- name: Run tests
run: ./test/etl_tests -v
@ -47,7 +47,7 @@ jobs:
export CXX=g++
cmake -DBUILD_TESTS=ON -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF -DETL_CXX_STANDARD=14 ./
gcc --version
make -j $(getconf _NPROCESSORS_ONLN)
make -j "$(getconf _NPROCESSORS_ONLN)"
- name: Run tests
run: ./test/etl_tests -v

4
.github/workflows/gcc-c++17.yml vendored
View File

@ -25,7 +25,7 @@ jobs:
export CXX=g++
cmake -DBUILD_TESTS=ON -DNO_STL=OFF -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF -DETL_CXX_STANDARD=17 ./
gcc --version
make -j $(getconf _NPROCESSORS_ONLN)
make -j "$(getconf _NPROCESSORS_ONLN)"
- name: Run tests
run: ./test/etl_tests -v
@ -47,7 +47,7 @@ jobs:
export CXX=g++
cmake -DBUILD_TESTS=ON -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF -DETL_CXX_STANDARD=17 ./
gcc --version
make -j $(getconf _NPROCESSORS_ONLN)
make -j "$(getconf _NPROCESSORS_ONLN)"
- name: Run tests
run: ./test/etl_tests -v

8
.github/workflows/gcc-c++20.yml vendored
View File

@ -25,7 +25,7 @@ jobs:
export CXX=g++
cmake -DBUILD_TESTS=ON -DNO_STL=OFF -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF -DETL_CXX_STANDARD=20 ./
gcc --version
make -j $(getconf _NPROCESSORS_ONLN)
make -j "$(getconf _NPROCESSORS_ONLN)"
- name: Run tests
run: ./test/etl_tests -v
@ -47,7 +47,7 @@ jobs:
export CXX=g++
cmake -DBUILD_TESTS=ON -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF -DETL_CXX_STANDARD=20 ./
gcc --version
make -j $(getconf _NPROCESSORS_ONLN)
make -j "$(getconf _NPROCESSORS_ONLN)"
- name: Run tests
run: ./test/etl_tests -v
@ -69,7 +69,7 @@ jobs:
export CXX=g++
cmake -DBUILD_TESTS=ON -DNO_STL=OFF -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=ON -DETL_CXX_STANDARD=20 ./
gcc --version
make -j $(getconf _NPROCESSORS_ONLN)
make -j "$(getconf _NPROCESSORS_ONLN)"
- name: Run tests
run: ./test/etl_tests -v
@ -91,7 +91,7 @@ jobs:
export CXX=g++
cmake -DBUILD_TESTS=ON -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=ON -DETL_CXX_STANDARD=20 ./
gcc --version
make -j $(getconf _NPROCESSORS_ONLN)
make -j "$(getconf _NPROCESSORS_ONLN)"
- name: Run tests
run: ./test/etl_tests -v

29
.github/workflows/gcc-c++23-armhf.yml vendored Normal file
View File

@ -0,0 +1,29 @@
name: gcc-c++23-armhf
on:
push:
branches: [ master, development, pull-request/* ]
pull_request:
branches: [ master, development, pull-request/* ]
types: [opened, synchronize, reopened]
jobs:
build-gcc-cpp23-linux-no-stl-armhf:
name: GCC C++23 Linux - No STL - armhf
runs-on: ubuntu-24.04
steps:
- uses: actions/checkout@v4
- name: Build Docker image
run: docker build -t etl-armhf -f .devcontainer/armhf/Dockerfile .
- name: Build and run tests
run: |
docker run --rm --user root -v ${{ github.workspace }}:/workspaces/etl etl-armhf bash -c "\
cmake -DBUILD_TESTS=ON -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF \
-DETL_CXX_STANDARD=23 -DCMAKE_TOOLCHAIN_FILE=.devcontainer/armhf/toolchain-armhf.cmake \
-DEXTRA_TESTING_FLAGS=-v \
./ && \
cmake --build . -- -j \$(getconf _NPROCESSORS_ONLN) && \
ctest -V"

29
.github/workflows/gcc-c++23-i386.yml vendored Normal file
View File

@ -0,0 +1,29 @@
name: gcc-c++23-i386
on:
push:
branches: [ master, development, pull-request/* ]
pull_request:
branches: [ master, development, pull-request/* ]
types: [opened, synchronize, reopened]
jobs:
build-gcc-cpp23-linux-no-stl-i386:
name: GCC C++23 Linux - No STL - i386
runs-on: ubuntu-24.04
steps:
- uses: actions/checkout@v4
- name: Build Docker image
run: docker build -t etl-i386 -f .devcontainer/i386/Dockerfile .
- name: Build and run tests
run: |
docker run --rm --user root -v ${{ github.workspace }}:/workspaces/etl etl-i386 bash -c "\
cmake -DBUILD_TESTS=ON -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF \
-DETL_CXX_STANDARD=23 -DCMAKE_TOOLCHAIN_FILE=.devcontainer/i386/toolchain-i386.cmake \
-DEXTRA_TESTING_FLAGS=-v \
./ && \
cmake --build . -- -j \$(getconf _NPROCESSORS_ONLN) && \
ctest -V"

29
.github/workflows/gcc-c++23-powerpc.yml vendored Normal file
View File

@ -0,0 +1,29 @@
name: gcc-c++23-powerpc
on:
push:
branches: [ master, development, pull-request/* ]
pull_request:
branches: [ master, development, pull-request/* ]
types: [opened, synchronize, reopened]
jobs:
build-gcc-cpp23-linux-no-stl-powerpc:
name: GCC C++23 Linux - No STL - powerpc
runs-on: ubuntu-24.04
steps:
- uses: actions/checkout@v4
- name: Build Docker image
run: docker build -t etl-powerpc -f .devcontainer/powerpc/Dockerfile .
- name: Build and run tests
run: |
docker run --rm --user root -v ${{ github.workspace }}:/workspaces/etl etl-powerpc bash -c "\
cmake -DBUILD_TESTS=ON -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF \
-DETL_CXX_STANDARD=23 -DCMAKE_TOOLCHAIN_FILE=.devcontainer/powerpc/toolchain-powerpc.cmake \
-DEXTRA_TESTING_FLAGS=-v \
./ && \
cmake --build . -- -j \$(getconf _NPROCESSORS_ONLN) && \
ctest -V"

29
.github/workflows/gcc-c++23-riscv64.yml vendored Normal file
View File

@ -0,0 +1,29 @@
name: gcc-c++23-riscv64
on:
push:
branches: [ master, development, pull-request/* ]
pull_request:
branches: [ master, development, pull-request/* ]
types: [opened, synchronize, reopened]
jobs:
build-gcc-cpp23-linux-no-stl-riscv64:
name: GCC C++23 Linux - No STL - riscv64
runs-on: ubuntu-24.04
steps:
- uses: actions/checkout@v4
- name: Build Docker image
run: docker build -t etl-riscv64 -f .devcontainer/riscv64/Dockerfile .
- name: Build and run tests
run: |
docker run --rm --user root -v ${{ github.workspace }}:/workspaces/etl etl-riscv64 bash -c "\
cmake -DBUILD_TESTS=ON -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF \
-DETL_CXX_STANDARD=23 -DCMAKE_TOOLCHAIN_FILE=.devcontainer/riscv64/toolchain-riscv64.cmake \
-DEXTRA_TESTING_FLAGS=-v \
./ && \
cmake --build . -- -j \$(getconf _NPROCESSORS_ONLN) && \
ctest -V"

29
.github/workflows/gcc-c++23-s390x.yml vendored Normal file
View File

@ -0,0 +1,29 @@
name: gcc-c++23-s390x
on:
push:
branches: [ master, development, pull-request/* ]
pull_request:
branches: [ master, development, pull-request/* ]
types: [opened, synchronize, reopened]
jobs:
build-gcc-cpp23-linux-no-stl-s390x:
name: GCC C++23 Linux - No STL - s390x
runs-on: ubuntu-24.04
steps:
- uses: actions/checkout@v4
- name: Build Docker image
run: docker build -t etl-s390x -f .devcontainer/s390x/Dockerfile .
- name: Build and run tests
run: |
docker run --rm --user root -v ${{ github.workspace }}:/workspaces/etl etl-s390x bash -c "\
cmake -DBUILD_TESTS=ON -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF \
-DETL_CXX_STANDARD=23 -DCMAKE_TOOLCHAIN_FILE=.devcontainer/s390x/toolchain-s390x.cmake \
-DEXTRA_TESTING_FLAGS=-v \
./ && \
cmake --build . -- -j \$(getconf _NPROCESSORS_ONLN) && \
ctest -V"

16
.github/workflows/gcc-c++23.yml vendored
View File

@ -23,9 +23,9 @@ jobs:
export ASAN_OPTIONS=alloc_dealloc_mismatch=0,detect_leaks=0
export CC=gcc
export CXX=g++
cmake -DBUILD_TESTS=ON -DNO_STL=OFF -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03=OFF -DETL_CXX_STANDARD=23 ./
cmake -DBUILD_TESTS=ON -DNO_STL=OFF -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF -DETL_CXX_STANDARD=23 ./
gcc --version
make -j $(getconf _NPROCESSORS_ONLN)
make -j "$(getconf _NPROCESSORS_ONLN)"
- name: Run tests
run: ./test/etl_tests -v
@ -45,9 +45,9 @@ jobs:
export ASAN_OPTIONS=alloc_dealloc_mismatch=0,detect_leaks=0
export CC=gcc
export CXX=g++
cmake -DBUILD_TESTS=ON -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03=OFF -DETL_CXX_STANDARD=23 ./
cmake -DBUILD_TESTS=ON -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF -DETL_CXX_STANDARD=23 ./
gcc --version
make -j $(getconf _NPROCESSORS_ONLN)
make -j "$(getconf _NPROCESSORS_ONLN)"
- name: Run tests
run: ./test/etl_tests -v
@ -67,9 +67,9 @@ jobs:
export ASAN_OPTIONS=alloc_dealloc_mismatch=0,detect_leaks=0
export CC=gcc
export CXX=g++
cmake -DBUILD_TESTS=ON -DNO_STL=OFF -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03=ON -DETL_CXX_STANDARD=23 ./
cmake -DBUILD_TESTS=ON -DNO_STL=OFF -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=ON -DETL_CXX_STANDARD=23 ./
gcc --version
make -j $(getconf _NPROCESSORS_ONLN)
make -j "$(getconf _NPROCESSORS_ONLN)"
- name: Run tests
run: ./test/etl_tests -v
@ -89,9 +89,9 @@ jobs:
export ASAN_OPTIONS=alloc_dealloc_mismatch=0,detect_leaks=0
export CC=gcc
export CXX=g++
cmake -DBUILD_TESTS=ON -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03=ON -DETL_CXX_STANDARD=23 ./
cmake -DBUILD_TESTS=ON -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=ON -DETL_CXX_STANDARD=23 ./
gcc --version
make -j $(getconf _NPROCESSORS_ONLN)
make -j "$(getconf _NPROCESSORS_ONLN)"
- name: Run tests
run: ./test/etl_tests -v

101
.github/workflows/gcc-c++26.yml vendored Normal file
View File

@ -0,0 +1,101 @@
name: gcc-c++26
on:
push:
branches: [ master, development, pull-request/* ]
pull_request:
branches: [ master, development, pull-request/* ]
types: [opened, synchronize, reopened]
jobs:
build-gcc-cpp26-linux-stl:
name: GCC C++26 Linux - STL
if: false # enabled when ubuntu-26.04 is available in github
runs-on: ${{ matrix.os }}
strategy:
matrix:
os: [ubuntu-26.04]
steps:
- uses: actions/checkout@v4
- name: Build
run: |
export ASAN_OPTIONS=alloc_dealloc_mismatch=0,detect_leaks=0
export CC=gcc
export CXX=g++
cmake -DBUILD_TESTS=ON -DNO_STL=OFF -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF -DETL_CXX_STANDARD=26 ./
gcc --version
make -j "$(getconf _NPROCESSORS_ONLN)"
- name: Run tests
run: ./test/etl_tests -v
build-gcc-cpp26-linux-no-stl:
name: GCC C++26 Linux - No STL
if: false # enabled when ubuntu-26.04 is available in github
runs-on: ${{ matrix.os }}
strategy:
matrix:
os: [ubuntu-26.04]
steps:
- uses: actions/checkout@v4
- name: Build
run: |
export ASAN_OPTIONS=alloc_dealloc_mismatch=0,detect_leaks=0
export CC=gcc
export CXX=g++
cmake -DBUILD_TESTS=ON -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF -DETL_CXX_STANDARD=26 ./
gcc --version
make -j "$(getconf _NPROCESSORS_ONLN)"
- name: Run tests
run: ./test/etl_tests -v
build-gcc-cpp26-linux-stl-force-cpp03:
name: GCC C++26 Linux - STL - Force C++03
if: false # enabled when ubuntu-26.04 is available in github
runs-on: ${{ matrix.os }}
strategy:
matrix:
os: [ubuntu-26.04]
steps:
- uses: actions/checkout@v4
- name: Build
run: |
export ASAN_OPTIONS=alloc_dealloc_mismatch=0,detect_leaks=0
export CC=gcc
export CXX=g++
cmake -DBUILD_TESTS=ON -DNO_STL=OFF -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=ON -DETL_CXX_STANDARD=26 ./
gcc --version
make -j "$(getconf _NPROCESSORS_ONLN)"
- name: Run tests
run: ./test/etl_tests -v
build-gcc-cpp26-linux-no-stl-force-cpp03:
name: GCC C++26 Linux - No STL - Force C++03
if: false # enabled when ubuntu-26.04 is available in github
runs-on: ${{ matrix.os }}
strategy:
matrix:
os: [ubuntu-26.04]
steps:
- uses: actions/checkout@v4
- name: Build
run: |
export ASAN_OPTIONS=alloc_dealloc_mismatch=0,detect_leaks=0
export CC=gcc
export CXX=g++
cmake -DBUILD_TESTS=ON -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=ON -DETL_CXX_STANDARD=26 ./
gcc --version
make -j "$(getconf _NPROCESSORS_ONLN)"
- name: Run tests
run: ./test/etl_tests -v

122
.github/workflows/gcc-syntax-checks.yml vendored
View File

@ -23,10 +23,10 @@ jobs:
export CXX=g++
cmake -DNO_STL=OFF -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF -DETL_CXX_STANDARD=03 ./test/syntax_check
gcc --version
make -j $(getconf _NPROCESSORS_ONLN)
make -j "$(getconf _NPROCESSORS_ONLN)"
build-gcc-cpp03-linux-No-STL:
name: Syntax Check - GCC C++03 Linux No STL
name: Syntax Check - GCC C++03 Linux No STL
runs-on: ${{ matrix.os }}
strategy:
matrix:
@ -41,7 +41,7 @@ jobs:
export CXX=g++
cmake -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF -DETL_CXX_STANDARD=03 ./test/syntax_check
gcc --version
make -j $(getconf _NPROCESSORS_ONLN)
make -j "$(getconf _NPROCESSORS_ONLN)"
build-gcc-cpp11-linux-STL:
name: Syntax Check - GCC C++11 Linux STL
@ -59,7 +59,7 @@ jobs:
export CXX=g++
cmake -DNO_STL=OFF -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF -DETL_CXX_STANDARD=11 ./test/syntax_check
gcc --version
make -j $(getconf _NPROCESSORS_ONLN)
make -j "$(getconf _NPROCESSORS_ONLN)"
build-gcc-cpp11-linux-No-STL:
name: Syntax Check - GCC C++11 Linux No STL
@ -77,7 +77,7 @@ jobs:
export CXX=g++
cmake -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF -DETL_CXX_STANDARD=11 ./test/syntax_check
gcc --version
make -j $(getconf _NPROCESSORS_ONLN)
make -j "$(getconf _NPROCESSORS_ONLN)"
build-gcc-cpp11-linux-STL-Force-CPP03:
name: Syntax Check - GCC C++11 Linux STL Force C++03
@ -95,7 +95,7 @@ jobs:
export CXX=g++
cmake -DNO_STL=OFF -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=ON -DETL_CXX_STANDARD=11 ./test/syntax_check
gcc --version
make -j $(getconf _NPROCESSORS_ONLN)
make -j "$(getconf _NPROCESSORS_ONLN)"
build-gcc-cpp11-linux-No-STL-Force-CPP03:
name: Syntax Check - GCC C++11 Linux No STL Force C++03
@ -113,7 +113,7 @@ jobs:
export CXX=g++
cmake -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=ON -DETL_CXX_STANDARD=11 ./test/syntax_check
gcc --version
make -j $(getconf _NPROCESSORS_ONLN)
make -j "$(getconf _NPROCESSORS_ONLN)"
build-gcc-cpp14-linux-STL:
name: Syntax Check - GCC C++14 Linux STL
@ -131,7 +131,7 @@ jobs:
export CXX=g++
cmake -DNO_STL=OFF -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF -DETL_CXX_STANDARD=14 ./test/syntax_check
gcc --version
make -j $(getconf _NPROCESSORS_ONLN)
make -j "$(getconf _NPROCESSORS_ONLN)"
build-gcc-cpp14-linux-No-STL:
name: Syntax Check - GCC C++14 Linux No STL
@ -149,7 +149,7 @@ jobs:
export CXX=g++
cmake -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF -DETL_CXX_STANDARD=14 ./test/syntax_check
gcc --version
make -j $(getconf _NPROCESSORS_ONLN)
make -j "$(getconf _NPROCESSORS_ONLN)"
build-gcc-cpp14-linux-STL-Force-CPP03:
name: Syntax Check - GCC C++14 Linux STL Force C++03
@ -167,7 +167,7 @@ jobs:
export CXX=g++
cmake -DNO_STL=OFF -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=ON -DETL_CXX_STANDARD=14 ./test/syntax_check
gcc --version
make -j $(getconf _NPROCESSORS_ONLN)
make -j "$(getconf _NPROCESSORS_ONLN)"
build-gcc-cpp14-linux-No-STL-Force-CPP03:
name: Syntax Check - GCC C++14 Linux No STL Force C++03
@ -185,7 +185,7 @@ jobs:
export CXX=g++
cmake -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=ON -DETL_CXX_STANDARD=14 ./test/syntax_check
gcc --version
make -j $(getconf _NPROCESSORS_ONLN)
make -j "$(getconf _NPROCESSORS_ONLN)"
build-gcc-cpp17-linux-STL:
name: Syntax Check - GCC C++17 Linux STL
@ -203,7 +203,7 @@ jobs:
export CXX=g++
cmake -DNO_STL=OFF -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF -DETL_CXX_STANDARD=17 ./test/syntax_check
gcc --version
make -j $(getconf _NPROCESSORS_ONLN)
make -j "$(getconf _NPROCESSORS_ONLN)"
build-gcc-cpp17-linux-No-STL:
name: Syntax Check - GCC C++17 Linux No STL
@ -221,7 +221,7 @@ jobs:
export CXX=g++
cmake -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF -DETL_CXX_STANDARD=17 ./test/syntax_check
gcc --version
make -j $(getconf _NPROCESSORS_ONLN)
make -j "$(getconf _NPROCESSORS_ONLN)"
build-gcc-cpp17-linux-STL-Force-CPP03:
name: Syntax Check - GCC C++17 Linux STL Force C++03
@ -239,7 +239,7 @@ jobs:
export CXX=g++
cmake -DNO_STL=OFF -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=ON -DETL_CXX_STANDARD=17 ./test/syntax_check
gcc --version
make -j $(getconf _NPROCESSORS_ONLN)
make -j "$(getconf _NPROCESSORS_ONLN)"
build-gcc-cpp17-linux-No-STL-Force-CPP03:
name: Syntax Check - GCC C++17 Linux No STL Force C++03
@ -257,7 +257,7 @@ jobs:
export CXX=g++
cmake -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=ON -DETL_CXX_STANDARD=17 ./test/syntax_check
gcc --version
make -j $(getconf _NPROCESSORS_ONLN)
make -j "$(getconf _NPROCESSORS_ONLN)"
build-gcc-cpp20-linux-STL:
name: Syntax Check - GCC C++20 Linux STL
@ -275,7 +275,7 @@ jobs:
export CXX=g++
cmake -DNO_STL=OFF -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF -DETL_CXX_STANDARD=20 ./test/syntax_check
gcc --version
make -j $(getconf _NPROCESSORS_ONLN)
make -j "$(getconf _NPROCESSORS_ONLN)"
build-gcc-cpp20-linux-No-STL:
name: Syntax Check - GCC C++20 Linux No STL
@ -293,7 +293,7 @@ jobs:
export CXX=g++
cmake -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF -DETL_CXX_STANDARD=20 ./test/syntax_check
gcc --version
make -j $(getconf _NPROCESSORS_ONLN)
make -j "$(getconf _NPROCESSORS_ONLN)"
build-gcc-cpp20-linux-STL-Force-CPP03:
name: Syntax Check - GCC C++20 Linux STL Force C++03
@ -311,7 +311,7 @@ jobs:
export CXX=g++
cmake -DNO_STL=OFF -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=ON -DETL_CXX_STANDARD=20 ./test/syntax_check
gcc --version
make -j $(getconf _NPROCESSORS_ONLN)
make -j "$(getconf _NPROCESSORS_ONLN)"
build-gcc-cpp20-linux-No-STL-Force-CPP03:
name: Syntax Check - GCC C++20 Linux No STL Force C++03
@ -329,7 +329,7 @@ jobs:
export CXX=g++
cmake -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=ON -DETL_CXX_STANDARD=20 ./test/syntax_check
gcc --version
make -j $(getconf _NPROCESSORS_ONLN)
make -j "$(getconf _NPROCESSORS_ONLN)"
build-gcc-cpp23-linux-STL:
name: Syntax Check - GCC C++23 Linux STL
@ -347,7 +347,7 @@ jobs:
export CXX=g++
cmake -DNO_STL=OFF -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF -DETL_CXX_STANDARD=23 ./test/syntax_check
gcc --version
make -j $(getconf _NPROCESSORS_ONLN)
make -j "$(getconf _NPROCESSORS_ONLN)"
build-gcc-cpp23-linux-No-STL:
name: Syntax Check - GCC C++23 Linux No STL
@ -365,7 +365,7 @@ jobs:
export CXX=g++
cmake -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF -DETL_CXX_STANDARD=23 ./test/syntax_check
gcc --version
make -j $(getconf _NPROCESSORS_ONLN)
make -j "$(getconf _NPROCESSORS_ONLN)"
build-gcc-cpp23-linux-STL-Force-CPP03:
name: Syntax Check - GCC C++23 Linux STL Force C++03
@ -383,7 +383,7 @@ jobs:
export CXX=g++
cmake -DNO_STL=OFF -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=ON -DETL_CXX_STANDARD=23 ./test/syntax_check
gcc --version
make -j $(getconf _NPROCESSORS_ONLN)
make -j "$(getconf _NPROCESSORS_ONLN)"
build-gcc-cpp23-linux-No-STL-Force-CPP03:
name: Syntax Check - GCC C++23 Linux No STL Force C++03
@ -401,4 +401,80 @@ jobs:
export CXX=g++
cmake -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=ON -DETL_CXX_STANDARD=23 ./test/syntax_check
gcc --version
make -j $(getconf _NPROCESSORS_ONLN)
make -j "$(getconf _NPROCESSORS_ONLN)"
build-gcc-cpp26-linux-STL:
name: Syntax Check - GCC C++26 Linux STL
if: false # enabled when ubuntu-26.04 is available in github
runs-on: ${{ matrix.os }}
strategy:
matrix:
os: [ubuntu-26.04]
steps:
- uses: actions/checkout@v4
- name: Build
run: |
export CC=gcc
export CXX=g++
cmake -DNO_STL=OFF -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF -DETL_CXX_STANDARD=26 ./test/syntax_check
gcc --version
make -j "$(getconf _NPROCESSORS_ONLN)"
build-gcc-cpp26-linux-No-STL:
name: Syntax Check - GCC C++26 Linux No STL
if: false # enabled when ubuntu-26.04 is available in github
runs-on: ${{ matrix.os }}
strategy:
matrix:
os: [ubuntu-26.04]
steps:
- uses: actions/checkout@v4
- name: Build
run: |
export CC=gcc
export CXX=g++
cmake -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF -DETL_CXX_STANDARD=26 ./test/syntax_check
gcc --version
make -j "$(getconf _NPROCESSORS_ONLN)"
build-gcc-cpp26-linux-STL-Force-CPP03:
name: Syntax Check - GCC C++26 Linux STL Force C++03
if: false # enabled when ubuntu-26.04 is available in github
runs-on: ${{ matrix.os }}
strategy:
matrix:
os: [ubuntu-26.04]
steps:
- uses: actions/checkout@v4
- name: Build
run: |
export CC=gcc
export CXX=g++
cmake -DNO_STL=OFF -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=ON -DETL_CXX_STANDARD=26 ./test/syntax_check
gcc --version
make -j "$(getconf _NPROCESSORS_ONLN)"
build-gcc-cpp26-linux-No-STL-Force-CPP03:
name: Syntax Check - GCC C++26 Linux No STL Force C++03
if: false # enabled when ubuntu-26.04 is available in github
runs-on: ${{ matrix.os }}
strategy:
matrix:
os: [ubuntu-26.04]
steps:
- uses: actions/checkout@v4
- name: Build
run: |
export CC=gcc
export CXX=g++
cmake -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=ON -DETL_CXX_STANDARD=26 ./test/syntax_check
gcc --version
make -j "$(getconf _NPROCESSORS_ONLN)"

7
.github/workflows/generator.yml vendored
View File

@ -14,12 +14,11 @@ jobs:
steps:
- uses: actions/checkout@v4
- name: Generate
- name: Install dependencies
run: |
sudo apt-get update
sudo apt-get install -y python3-cogapp
cd include/etl/generators && bash generate.bat
- name: Check Generated Headers For Changes
- name: Run generator_test.py
run: |
git diff --exit-code
cd scripts && python3 generator_test.py

6
README.md
View File

@ -2,7 +2,7 @@
![GitHub release (latest by date)](https://img.shields.io/github/v/release/jwellbelove/etl)
[![Release date](https://img.shields.io/github/release-date/jwellbelove/etl?color=%231182c3)](https://img.shields.io/github/release-date/jwellbelove/etl?color=%231182c3)
[![Standard](https://img.shields.io/badge/c%2B%2B-98/03/11/14/17/20/23-blue.svg)](https://en.wikipedia.org/wiki/C%2B%2B#Standardization)
[![Standard](https://img.shields.io/badge/c%2B%2B-98/03/11/14/17/20/23/26-blue.svg)](https://en.wikipedia.org/wiki/C%2B%2B#Standardization)
[![License](https://img.shields.io/badge/license-MIT-blue.svg)](https://opensource.org/licenses/MIT)
![GitHub contributors](https://img.shields.io/github/contributors-anon/ETLCPP/etl)
![GitHub forks](https://img.shields.io/github/forks/ETLCPP/etl?style=flat)
@ -15,6 +15,7 @@
![CI](https://github.com/ETLCPP/etl/actions/workflows/gcc-c++17.yml/badge.svg?branch=master)
![CI](https://github.com/ETLCPP/etl/actions/workflows/gcc-c++20.yml/badge.svg?branch=master)
![CI](https://github.com/ETLCPP/etl/actions/workflows/gcc-c++23.yml/badge.svg?branch=master)
![CI](https://github.com/ETLCPP/etl/actions/workflows/gcc-c++26.yml/badge.svg?branch=master)
![CI](https://github.com/ETLCPP/etl/actions/workflows/gcc-syntax-checks.yml/badge.svg?branch=master)
![CI](https://github.com/ETLCPP/etl/actions/workflows/clang-c++11.yml/badge.svg?branch=master)
@ -22,6 +23,7 @@
![CI](https://github.com/ETLCPP/etl/actions/workflows/clang-c++17.yml/badge.svg?branch=master)
![CI](https://github.com/ETLCPP/etl/actions/workflows/clang-c++20.yml/badge.svg?branch=master)
![CI](https://github.com/ETLCPP/etl/actions/workflows/clang-c++23.yml/badge.svg?branch=master)
![CI](https://github.com/ETLCPP/etl/actions/workflows/clang-c++26.yml/badge.svg?branch=master)
![CI](https://github.com/ETLCPP/etl/actions/workflows/clang-syntax-checks.yml/badge.svg?branch=master)
[![Codacy Badge](https://api.codacy.com/project/badge/Grade/3c14cd918ccf40008d0bcd7b083d5946)](https://www.codacy.com/manual/jwellbelove/etl?utm_source=github.com&amp;utm_medium=referral&amp;utm_content=ETLCPP/etl&amp;utm_campaign=Badge_Grade)
@ -49,7 +51,7 @@ Its design goals include:
- Offering APIs that closely resemble those of the STL, enabling familiar and consistent usage.
- Maintaining compatibility with C++98 while implementing many features introduced in later standards
(C++11/14/17/20/23) where possible.
(C++11/14/17/20/23/26) where possible.
- Ensuring deterministic behavior, which is critical in real-time and resource-constrained environments.

289
docs/docker.md Normal file
View File

@ -0,0 +1,289 @@
# Docker for Development
## Overview
The ETL repository ships a set of Docker-based development environments under
`.devcontainer/`. They give every contributor an identical, reproducible toolchain
regardless of host operating system. Three flavours are provided:
| Flavour | Path | Purpose |
|---|---|---|
| **Default** | `.devcontainer/` | Day-to-day development (Microsoft C++ dev-container base image) |
| **Compiler-specific** | `.devcontainer/gcc09/` … `.devcontainer/gcc15/`, `.devcontainer/clang7/` … `.devcontainer/clang21/` | Test against a specific GCC or Clang version |
| **s390x big-endian** | `.devcontainer/s390x/` | Cross-compile and run tests on an s390x target via QEMU |
All containers include CMake, Make, Git, Python 3, cogapp (the code generator used
by ETL), clang-format 18, and treefmt.
## Prerequisites
- **Docker** (or Docker Desktop) – any recent version that supports `docker build`
and `docker run`.
- **VS Code** with the
[Dev Containers](https://marketplace.visualstudio.com/items?itemName=ms-vscode-remote.remote-containers)
extension (optional, but recommended for the smoothest experience).
- **Git** – to clone the repository.
## Quick Start
### Using the helper script
The fastest way to get a shell inside the default container from the project root:
```bash
./scripts/run-docker.sh
```
This script performs two steps:
1. **Builds** the image from `.devcontainer/Dockerfile` and tags it `etl`.
2. **Runs** an interactive container that bind-mounts the repository at
`/home/vscode/etl` so that edits made inside the container are visible on
the host (and vice versa).
You are dropped into a Bash shell as the `vscode` user with the working
directory set to the repository root.
### Using VS Code Dev Containers
1. Open the repository folder in VS Code.
2. When prompted, click **Reopen in Container** – or run the command
*Dev Containers: Reopen in Container* from the command palette.
3. VS Code reads `.devcontainer/devcontainer.json`, builds the image, and
attaches to the running container automatically.
To open a **specific compiler variant** instead, run
*Dev Containers: Open Folder in Container…* and pick the sub-folder (e.g.
`.devcontainer/gcc14/`), or use the command palette action
*Dev Containers: Open Named Container Configuration…* and select the desired
name (e.g. "Gcc 14", "Clang 18").
## Default Development Container
The file `.devcontainer/Dockerfile` is a multi-purpose image used by the
default configuration **and** by every compiler-specific variant (they simply
override the `BASE_IMAGE_NAME` build argument).
### Base image
```text
mcr.microsoft.com/devcontainers/cpp:2
```
The exact digest is pinned in `devcontainer.json` so that builds are
reproducible even if the upstream tag is updated.
### Installed tools
The Dockerfile installs the following on top of the base image:
| Tool | Purpose |
|---|---|
| `python3`, `pip` | Runtime for helper scripts |
| `python3-cogapp` / `cogapp` | ETL code generator |
| `git` | Version control |
| `wget` | Downloading additional tooling |
| `cmake`, `make` | Build system |
| `clang-format` (v18) | Source formatting (see [source-formatting.md](source-formatting.md)) |
| `treefmt` (v2.4.1) | Single-command formatting wrapper |
### Reproducible builds with Debian snapshots
The default configuration sets the build argument
`DEBIAN_SNAPSHOT=20260223T000000Z`. When this value is not `"none"`, the
Dockerfile rewrites the APT sources to point at
`snapshot.debian.org/archive/debian/<timestamp>`, ensuring that every
contributor installs identical package versions. Compiler-specific variants
that are based on upstream `gcc:*` or `silkeh/clang:*` images set
`DEBIAN_SNAPSHOT=none` because those images manage their own package sources.
## Compiler-Specific Containers
Each sub-folder under `.devcontainer/` contains a `devcontainer.json` that
reuses the **same** `Dockerfile` (`../Dockerfile`) but overrides the
`BASE_IMAGE_NAME` build argument to select a different compiler.
### GCC variants
| Folder | Base image | Name |
|---|---|---|
| `gcc09/` | `gcc:9` | Gcc 09 |
| `gcc10/` | `gcc:10` | Gcc 10 |
| `gcc11/` | `gcc:11` | Gcc 11 |
| `gcc12/` | `gcc:12` | Gcc 12 |
| `gcc13/` | `gcc:13` | Gcc 13 |
| `gcc14/` | `gcc:14` | Gcc 14 |
| `gcc15/` | `gcc:15` | Gcc 15 |
### Clang variants
| Folder | Base image | Name |
|---|---|---|
| `clang7/` | `silkeh/clang:7` | Clang 7 |
| `clang8/` | `silkeh/clang:8` | Clang 8 |
| `clang9/` | `silkeh/clang:9` | Clang 9 |
| `clang10/` | `silkeh/clang:10` | Clang 10 |
| `clang11/` | `silkeh/clang:11` | Clang 11 |
| `clang12/` | `silkeh/clang:12` | Clang 12 |
| `clang13/` | `silkeh/clang:13` | Clang 13 |
| `clang14/` | `silkeh/clang:14` | Clang 14 |
| `clang15/` | `silkeh/clang:15` | Clang 15 |
| `clang16/` | `silkeh/clang:16` | Clang 16 |
| `clang17/` | `silkeh/clang:17` | Clang 17 |
| `clang18/` | `silkeh/clang:18` | Clang 18 |
| `clang19/` | `silkeh/clang:19` | Clang 19 |
| `clang20/` | `silkeh/clang:20` | Clang 20 |
| `clang21/` | `silkeh/clang:21` | Clang 21 |
All compiler-specific variants set `DEBIAN_SNAPSHOT` to `"none"` because they
rely on the upstream image's own package sources.
## s390x Big-Endian Cross-Compilation
The `s390x` container lives in `.devcontainer/s390x/` and has its **own**
Dockerfile (it does not reuse the default one). It is based on
`debian:trixie` and installs:
- QEMU user-mode emulation (`qemu-user-static`, `qemu-user`, `binfmt-support`)
- s390x cross-compilation toolchain (`gcc-s390x-linux-gnu`,
`g++-s390x-linux-gnu`)
- CMake, Make, Ninja, Git, wget
### Container setup
Open `.devcontainer/s390x/` as a Dev Container in VS Code, or build manually:
```bash
docker build -t etl-s390x .devcontainer/s390x
docker run -it --rm -v .:/workspaces/etl -w /workspaces/etl etl-s390x
```
### CMake toolchain
A CMake toolchain file is provided at
`.devcontainer/s390x/toolchain-s390x.cmake`. It sets:
- `CMAKE_SYSTEM_PROCESSOR` to `s390x`
- Cross-compilers `s390x-linux-gnu-gcc` / `g++`
- `CMAKE_CROSSCOMPILING_EMULATOR` to `/usr/bin/qemu-s390x-static`
The VS Code Dev Container configuration already passes this toolchain file
via `cmake.configureArgs`, so CMake Tools picks it up automatically.
### Running tests under QEMU
Because the toolchain file sets `CMAKE_CROSSCOMPILING_EMULATOR`, CTest
automatically invokes `qemu-s390x-static` when running test binaries.
No extra flags are needed:
```bash
cmake -S test -B build-s390x \
-DCMAKE_TOOLCHAIN_FILE=.devcontainer/s390x/toolchain-s390x.cmake \
-DBUILD_TESTS=ON -DNO_STL=OFF -DETL_CXX_STANDARD=17 -G Ninja
cmake --build build-s390x
ctest --test-dir build-s390x
```
## Building and Running Tests
Once inside any container (default, compiler-specific, or s390x) you can
build and run the ETL test suite.
### Quick CMake workflow
```bash
# Configure – build tests with C++17
cmake -S test -B build -DBUILD_TESTS=ON -DETL_CXX_STANDARD=17
# Build
cmake --build build -j $(nproc)
# Run tests
ctest --test-dir build
```
Change `DETL_CXX_STANDARD` to `11`, `14`, `17`, `20`, or `23` as needed.
Add `-DNO_STL=ON` to build without the standard library.
### Using the run-tests script
The repository also provides a convenience script in `test/`:
```bash
cd test
./run-tests.sh <standard> [optimisation] [threads] [sanitizer] [compiler] [verbose]
```
| Argument | Values | Default |
|---|---|---|
| C++ standard | `11`, `14`, `17`, `20`, `23` | *(required)* |
| Optimisation | `0`, `1`, `2`, `3` | `0` |
| Threads | any integer | `4` |
| Sanitizer | `s` (enable) / `n` (disable) | `n` |
| Compiler | `gcc` / `clang` | all |
| Verbose | `v` (enable) / `n` (disable) | `n` |
Example – run C++17 tests at `-O2` with 8 threads using GCC:
```bash
./run-tests.sh 17 2 8 n gcc n
```
## Formatting Inside the Container
The default container ships with **clang-format 18** and **treefmt**.
See [source-formatting.md](source-formatting.md) for the full formatting guide.
Quick reference:
```bash
# Format all tracked C/C++ files with treefmt
treefmt
# Or use clang-format directly via the wrapper
./scripts/clang-format-wrapper -i include/etl/*.h
```
The wrapper script `scripts/clang-format-wrapper` resolves the correct
clang-format binary (prefers `clang-format-18`, falls back to `clang-format`
after checking the major version).
## Customisation
To add extra packages or tools to the default container, edit
`.devcontainer/Dockerfile`. The image follows a straightforward
`apt-get install` pattern, so adding a new package is as simple as appending
it to the existing `apt-get` line.
To create a new compiler variant:
1. Create a folder under `.devcontainer/` (e.g. `.devcontainer/gcc16/`).
2. Add a `devcontainer.json` that references `"../Dockerfile"` and sets
`BASE_IMAGE_NAME` to the desired image (e.g. `gcc:16`).
3. Set `DEBIAN_SNAPSHOT` to `"none"` for upstream compiler images.
Example:
```jsonc
{
"name": "Gcc 16",
"build": {
"dockerfile": "../Dockerfile",
"args": {
"BASE_IMAGE_NAME": "gcc:16",
"DEBIAN_SNAPSHOT": "none"
},
"context": "../context"
}
}
```
## Troubleshooting
| Symptom | Cause / Fix |
|---|---|
| `apt-get` fails with *"Release file … is not valid yet"* | The Debian snapshot timestamp is in the future relative to the build host clock. Either update `DEBIAN_SNAPSHOT` in `devcontainer.json` or set it to `"none"`. |
| `clang-format` reports the wrong version | The wrapper expects version **18**. Make sure the image installs `clang-format` (or `clang-format-18`) and that the binary is on `PATH`. |
| Permission errors on mounted files | The `run-docker.sh` script runs as user `vscode`. Ensure your host UID matches, or adjust the `--user` flag. |
| s390x tests crash immediately | Verify that `qemu-user-static` is installed and that `binfmt-support` is active. On some hosts you may need to register binfmt handlers with `docker run --privileged --rm tonistiigi/binfmt --install all`. |
| Build is very slow the first time | Docker is downloading and building the image from scratch. Subsequent builds use the layer cache and are much faster. |

382
docs/format.md Normal file
View File

@ -0,0 +1,382 @@
# ETL Format & Print
## 1. Overview
ETL provides text formatting facilities modelled on C++20 `std::format` and C++23
`std::print`. They allow type-safe, positional formatting of values into strings
or directly to a character output device — without heap allocation.
**Minimum language standard:** C++11 (`ETL_USING_CPP11`).
**Headers:**
| Header | Provides |
|---|---|
| `etl/format.h` | `etl::format_to`, `etl::format_to_n`, `etl::formatted_size` |
| `etl/print.h` | `etl::print`, `etl::println` (includes `etl/format.h`) |
## 2. `etl::format_to`
### Generic output-iterator overload
```cpp
template<typename OutputIt, class... Args>
OutputIt format_to(OutputIt out, format_string<Args...> fmt, Args&&... args);
```
Formats `args` according to the format string `fmt` and writes the result through
the output iterator `out`. Returns an iterator past the last character written.
`OutputIt` can be any output iterator whose dereferenced type is assignable from
`char`, for example `etl::istring::iterator` or
`etl::back_insert_iterator<etl::istring>`.
```cpp
etl::string<100> s;
// Using a raw iterator — you must resize the string yourself
etl::istring::iterator result = etl::format_to(s.begin(), "{0} {1}", 34, 56);
s.uninitialized_resize(static_cast<size_t>(result - s.begin()));
// s == "34 56"
// Using a back_insert_iterator — string grows automatically
s.clear();
etl::back_insert_iterator<etl::istring> it(s);
etl::format_to(it, "{} {}", 65, 34);
// s == "65 34"
```
### `etl::istring&` overload (ETL-specific)
```cpp
template<class... Args>
etl::istring::iterator format_to(etl::istring& out,
format_string<Args...> fmt,
Args&&... args);
```
Convenience overload that writes into an `etl::istring` (or any derived
`etl::string<N>`). The string is automatically resized to the number of
characters written, up to `out.max_size()`. Returns an iterator past the
last character written.
```cpp
etl::string<100> s;
etl::format_to(s, "Hello, {}!", "world");
// s == "Hello, world!"
```
### `etl::format_to_n`
```cpp
template<typename OutputIt, class... Args>
OutputIt format_to_n(OutputIt out, size_t n,
format_string<Args...> fmt, Args&&... args);
```
Like `format_to`, but writes **at most** `n` characters. Characters beyond the
limit are silently discarded.
```cpp
etl::string<10> s = "abcdefghij";
etl::format_to_n(s.begin(), 3, "xy{}", 123);
// s == "xy1defghij" (only 3 chars written)
```
## 3. `etl::formatted_size`
```cpp
template<class... Args>
size_t formatted_size(format_string<Args...> fmt, Args&&... args);
```
Returns the total number of characters that `format_to` would produce, without
actually writing anything. Useful for pre-computing buffer sizes.
```cpp
size_t n;
n = etl::formatted_size(""); // 0
n = etl::formatted_size("{}", ""); // 0
n = etl::formatted_size("xyz{}", 12); // 5
n = etl::formatted_size("{}", "abc"); // 3
```
## 4. `etl::print` and `etl::println`
Declared in `etl/print.h`.
### `etl::print`
```cpp
template<class... Args>
void print(etl::format_string<Args...> fmt, Args&&... args);
```
Formats the arguments and outputs each character by calling `etl_putchar()`.
### `etl::println`
```cpp
// With arguments — prints formatted text followed by '\n'
template<class... Args>
void println(etl::format_string<Args...> fmt, Args&&... args);
// Without arguments — prints a bare newline
void println();
```
### Implementing `etl_putchar`
`etl/print.h` declares (but does not define) the following C-linkage function:
```cpp
extern "C" void etl_putchar(int c);
```
You **must** provide a definition in your project. The `int` parameter follows
the convention of the standard `putchar()` and carries a single `char` value.
Typical implementations forward to a UART, a debug probe, `putchar`, or any
other single-character output sink:
```cpp
// Example: forward to standard putchar
extern "C" void etl_putchar(int c)
{
putchar(c);
}
```
### Example
```cpp
etl::print("x = {}, y = {}\n", 10, 20); // "x = 10, y = 20\n"
etl::println("Hello, {}!", "world"); // "Hello, world!\n"
etl::println(); // "\n"
```
## 5. Format String Syntax
A format string is ordinary text with **replacement fields** delimited by braces:
```
"literal text {} more text {1:>10} end"
```
### Replacement field grammar
```
replacement_field ::= '{' [arg_id] [':' format_spec] '}'
arg_id ::= integer // e.g. 0, 1, 2 …
format_spec ::= [[fill]align] [sign] ['#'] ['0'] [width] ['.' precision] ['L'] [type]
```
| Component | Syntax | Description |
|---|---|---|
| **Argument index** | `{0}`, `{1}`, … | Manual positional indexing. Cannot be mixed with automatic indexing. |
| **Automatic index** | `{}` | Uses the next argument in order. Cannot be mixed with manual indexing. |
| **Fill character** | any character except `{` or `}` | Used together with an alignment specifier. Default is space (` `). |
| **Alignment** | `<` left, `>` right, `^` center | Aligns the formatted value within the given *width*. |
| **Sign** | `+` always, `-` negative only (default), ` ` space for positive | Controls sign display for numeric types. |
| **`#` (alt form)** | `#` | Adds `0x`/`0X` for hex, `0b`/`0B` for binary, `0` for octal. |
| **`0` (zero-pad)** | `0` | Pads the number with leading zeros (after sign/prefix). |
| **Width** | integer, or `{}` / `{n}` | Minimum field width. Supports nested replacement fields for dynamic width. |
| **Precision** | `.` integer, or `.{}` / `.{n}` | For strings: maximum characters to output. For floats: number of decimal digits. Supports nested replacement fields. |
| **`L`** | `L` | Locale-specific flag (parsed but currently ignored). |
| **Type** | see [Presentation Types](#7-presentation-types-per-argument-kind) | Selects the output representation. |
### Examples
```cpp
etl::format_to(s, "{:>10}", 42); // " 42"
etl::format_to(s, "{:*^10}", 42); // "****42****"
etl::format_to(s, "{:+05d}", 67); // "+00067"
etl::format_to(s, "{:#x}", 0x3f4); // "0x3f4"
etl::format_to(s, "{:.3s}", "abcdef"); // "abc"
etl::format_to(s, "{1} {0}", 1, 2); // "2 1"
```
## 6. Supported Argument Types
The core set of formattable types (matching `std::basic_format_arg`):
| Category | Types |
|---|---|
| Boolean | `bool` |
| Character | `char` |
| Signed integer | `int`, `long long int` |
| Unsigned integer | `unsigned int`, `unsigned long long int` |
| Floating-point *(opt-in)* | `float`, `double`, `long double` — requires `ETL_USING_FORMAT_FLOATING_POINT` |
| String | `const char*`, `etl::string_view` |
| Pointer | `const void*` |
### Implicit conversions
Types not listed above are converted automatically before formatting:
| Source type | Stored as |
|---|---|
| `short` | `int` |
| `unsigned short`, `uint16_t` | `unsigned int` |
| `long int` | `int` or `long long int` (platform-dependent) |
| `unsigned long int`, `size_t` | `unsigned int` or `unsigned long long int` |
| `int8_t` (`signed char`) | `char` |
| `uint8_t` (`unsigned char`) | `char` |
| `int16_t` | `int` |
| `uint32_t` | `unsigned int` |
| `int32_t` | `int` |
| `etl::string<N>` | `etl::string_view` (lifetime of the temporary is guaranteed) |
| any pointer `T*` | `const void*` |
## 7. Presentation Types per Argument Kind
### Integers (`int`, `unsigned int`, `long long int`, `unsigned long long int`)
| Type | Meaning | Example |
|---|---|---|
| `d` *(default)* | Decimal | `134` → `"134"` |
| `x` | Lowercase hexadecimal | `0x3f4` → `"3f4"` |
| `X` | Uppercase hexadecimal | `0x3f4` → `"3F4"` |
| `o` | Octal | `034` → `"34"` |
| `b` | Lowercase binary | `0b1010` → `"1010"` |
| `B` | Uppercase binary | `0b1010` → `"1010"` |
| `c` | Character (value as char) | `67` → `"C"` |
With `#`: prefixes `0x`/`0X`, `0b`/`0B`, or leading `0` for octal.
### Characters (`char`, `signed char`, `unsigned char`)
| Type | Meaning | Example |
|---|---|---|
| `c` *(default)* | Character itself | `'s'` → `"s"` |
| `?` | Debug / escaped | `'\n'` → `"'\\n'"` |
| `d` | Decimal code point | `'a'` → `"97"` |
| `x` / `X` | Hex code point | `'a'` → `"61"` |
### Booleans (`bool`)
| Type | Meaning | Example |
|---|---|---|
| *(default)* | `false` / `true` | `true` → `"true"` |
| `s` | Same as default | `true` → `"true"` |
| `d` | `0` / `1` | `true` → `"1"` |
| `x` / `X` | Hex `0` / `1` | `true` → `"1"` |
| `o` | Octal (with `#`: `01`) | `true` → `"01"` |
### Strings (`const char*`, `etl::string_view`, `etl::string<N>`)
| Type | Meaning | Example |
|---|---|---|
| `s` *(default)* | String output | `"data1"` → `"data1"` |
| `?` | Debug / escaped | `"data1\n"` → `"\"data1\\n\""` |
Width and precision apply: width sets the minimum field width; precision (`.N`)
truncates the string to at most *N* characters.
```cpp
etl::format_to(s, "{:>10s}", "data1"); // " data1"
etl::format_to(s, "{:.3s}", "abcdef"); // "abc"
etl::format_to(s, ".{:^8.3s}!", "data1"); // ". dat !"
```
### Pointers (`const void*`)
| Type | Meaning | Example |
|---|---|---|
| `p` *(default)* | Lowercase hex with `0x` prefix | `nullptr` → `"0x0"` |
| `P` | Uppercase hex with `0X` prefix | `nullptr` → `"0X0"` |
### Floating-point (`float`, `double`, `long double`)
Requires `ETL_USING_FORMAT_FLOATING_POINT`.
| Type | Meaning | Example |
|---|---|---|
| *(default)* | Shortest representation | `1.5f` → `"1.5"` |
| `e` / `E` | Scientific notation | `1.0f` → `"1.000000e+00"` |
| `f` / `F` | Fixed-point notation | `1.125f` → `"1.125000"` |
| `g` / `G` | General (fixed or scientific) | `1e10f` → `"1.000000e+10"` |
| `a` / `A` | Hexadecimal floating-point | `1.5f` → `"0x1.8p+0"` |
`nan`, `inf` (lowercase for `e`/`f`/`g`/`a`, uppercase for `E`/`F`/`G`/`A`).
## 8. Escape Sequences and Literal Braces
### Literal braces
Because `{` and `}` delimit replacement fields, they must be escaped by
doubling:
| Input | Output |
|---|---|
| `{{` | `{` |
| `}}` | `}` |
```cpp
etl::format_to(s, "abc{{def"); // "abc{def"
etl::format_to(s, "}}abc"); // "}abc"
```
### Debug / escaped presentation (`?`)
The `?` type specifier produces a debug representation:
- **Characters** are wrapped in single quotes with C-style escape sequences:
| Character | Output |
|---|---|
| `\t` | `'\\t'` |
| `\n` | `'\\n'` |
| `\r` | `'\\r'` |
| `"` | `'\\\"'` |
| `'` | `'\\''` |
| `\\` | `'\\\\'` |
- **Strings** are wrapped in double quotes with the same escape sequences:
```cpp
etl::format_to(s, "{:?}", "data1\n"); // "\"data1\\n\""
```
## 9. Error Handling
Invalid format strings cause an `etl::bad_format_string_exception` (derived from
`etl::format_exception`, which is derived from `etl::exception`).
Common error conditions:
| Condition | Example |
|---|---|
| Missing closing brace | `"a{b"` |
| Unescaped `}` without matching `{` | `"a}b"` |
| Invalid characters inside `{}` | `"a{b}"` |
| Argument index out of range | `"{1}"` with only one argument |
| Mixing manual and automatic indexing | `"{0} {}"` |
| Invalid type specifier for the argument | `"{:d}"` on a `string_view` |
| Double colon in format spec | `"{::}"` |
| Precision on an integer | `"{:+#05.5X}"` on an `int` |
```cpp
etl::string<100> s;
// These all throw etl::bad_format_string_exception:
etl::format_to(s, "a{b}", 1); // bad index spec
etl::format_to(s, "a{b", 1); // closing brace missing
etl::format_to(s, "a}b"); // unescaped }
etl::format_to(s, "{:d}", sv); // invalid type for string_view
```
> **Note:** On C++20 and later, compile-time format string validation through
> `consteval` is planned but not yet fully implemented.
## 10. Differences from `std::format`
| Area | `std::format` (C++20/23) | ETL |
|---|---|---|
| **Output target** | Returns `std::string` | Writes through an output iterator or into `etl::istring&` — no heap allocation. |
| **`etl::istring&` overload** | Not available | `format_to(etl::istring&, ...)` automatically resizes the string. |
| **`print` / `println` output** | Writes to `FILE*` / `stdout` | Writes character-by-character via user-defined `etl_putchar(int)`. |
| **Floating-point support** | Always available | Opt-in via `ETL_USING_FORMAT_FLOATING_POINT`. |
| **User-defined formatters** | `std::formatter<T>` specialisations | Not yet supported. |
| **Locale** | `L` flag uses `std::locale` | `L` flag is parsed but has no effect. |
| **Compile-time validation** | Enforced via `consteval` on C++20 | Planned; currently validates at run time and throws `etl::bad_format_string_exception`. |
| **`format_to_n` return type** | `std::format_to_n_result` | Returns the underlying `OutputIt` directly. |

190
docs/generators.md Normal file
View File

@ -0,0 +1,190 @@
# Code Generation for Pre-C++11 Support
ETL supports C++03 (also referred to as C++98) environments where variadic
templates, `constexpr`, and other modern features are unavailable. To
provide equivalent functionality, certain headers are **generated** using
[Cog](https://nedbatchelder.com/code/cog/), a Python-based code generation
tool that embeds Python snippets inside source files.
This document explains how the code generation system works and how to
regenerate the headers if you modify a generator template.
---
## Overview
| Directory | Contents |
|---|---|
| `include/etl/generators/` | Generator templates (`*_generator.h`) and batch scripts |
| `include/etl/private/` | Generated output (`*_cpp03.h`) committed to the repository |
| `scripts/generator_test.py` | CI script that verifies generators match committed files |
The generator templates contain embedded Python code (delimited by `[[[cog`
and `]]]`) that produces the repetitive C++03 boilerplate. Cog processes
these templates and writes the expanded output to `include/etl/private/`.
---
## Generated Headers
The following C++03 compatibility headers are generated:
| Generator | Output | Purpose |
|---|---|---|
| `fsm_fwd_decl_cpp03_generator.h` | `fsm_fwd_decl_cpp03.h` | FSM forward declarations |
| `fsm_friend_decl_cpp03_generator.h` | `fsm_friend_decl_cpp03.h` | FSM friend declarations |
| `fsm_cpp03_generator.h` | `fsm_cpp03.h` | Finite state machine implementation |
| `message_router_cpp03_generator.h` | `message_router_cpp03.h` | Message router |
| `message_packet_cpp03_generator.h` | `message_packet_cpp03.h` | Message packet |
| `largest_type_cpp03_generator.h` | `largest_type_cpp03.h` | Largest type metafunction |
| `largest_alignment_cpp03_generator.h` | `largest_alignment_cpp03.h` | Largest alignment metafunction |
| `largest_cpp03_generator.h` | `largest_cpp03.h` | Largest type/size utilities |
| `smallest_cpp03_generator.h` | `smallest_cpp03.h` | Smallest type/size utilities |
| `type_traits_cpp03_generator.h` | `type_traits_cpp03.h` | Type traits (`is_one_of`, etc.) |
| `type_lookup_cpp03_generator.h` | `type_lookup_cpp03.h` | Type lookup metafunction |
| `type_select_cpp03_generator.h` | `type_select_cpp03.h` | Type selection metafunction |
| `variant_pool_cpp03_generator.h` | `variant_pool_cpp03.h` | Variant pool |
---
## Generator Parameters
Cog variables control how many template parameter overloads are generated:
| Variable | Default | Used by |
|---|---|---|
| `Handlers` | 16 | FSM and message router generators |
| `NTypes` | 16 | Type utility generators (largest, smallest, lookup, select, variant pool) |
| `IsOneOf` | 16 | Type traits generator (`is_one_of`) |
These defaults produce overloads supporting up to 16 types or handlers,
which is sufficient for most embedded applications while keeping compile
times reasonable.
---
## Prerequisites
* **Python 3**
* **cogapp** – install via:
```bash
pip install cogapp
```
---
## Regenerating Headers
### Using the batch scripts (Windows)
Each generator has a corresponding `.bat` file in `include/etl/generators/`:
```bat
cd include/etl/generators
generate.bat # Regenerate all headers
generate_fsm.bat # Regenerate FSM headers only
generate_smallest.bat # Regenerate smallest_cpp03.h only
# etc.
```
### Manual invocation
Run Cog directly from the `include/etl/generators/` directory:
```bash
cd include/etl/generators
# Example: regenerate smallest_cpp03.h
python3 -m cogapp -d -e -o../private/smallest_cpp03.h -DNTypes=16 smallest_cpp03_generator.h
# Example: regenerate fsm_cpp03.h
python3 -m cogapp -d -e -o../private/fsm_cpp03.h -DHandlers=16 fsm_cpp03_generator.h
```
Cog options used:
| Option | Meaning |
|---|---|
| `-d` | Delete the generator markers from output |
| `-e` | Warn if the input file has no generator markers |
| `-o<file>` | Write output to the specified file |
| `-D<var>=<value>` | Define a Cog variable |
### Regenerating all headers
The `generate.bat` script regenerates every header:
```bash
cd include/etl/generators
./generate.bat # Windows
# or run the commands manually on Linux/macOS
```
On Linux/macOS you can run the commands from `generate.bat` directly in
your shell (they are standard `python3 -m cogapp` invocations).
---
## Verifying Generators
After modifying a generator template, verify the output matches the
committed file:
```bash
python3 scripts/generator_test.py
```
This script:
1. Runs Cog on every `*_generator.h` file.
2. Compares each output against the corresponding file in
`include/etl/private/`.
3. Reports success or failure.
The `generator.yml` GitHub Actions workflow runs this automatically on
every push and pull request.
---
## How Generators Work
A generator template contains standard C++ code interspersed with Cog
directives. For example, from `smallest_cpp03_generator.h`:
```cpp
/*[[[cog
import cog
cog.outl("template <typename T1, ")
for n in range(2, int(NTypes)):
cog.out("typename T%s = void, " % n)
cog.outl("typename T%s = void>" % int(NTypes))
]]]*/
// Generated code appears here after running Cog
/*[[[end]]]*/
```
When Cog processes this file with `-DNTypes=16`, the Python code executes
and outputs the expanded template parameter list supporting 16 types.
---
## Adding a New Generator
1. Create `include/etl/generators/<name>_cpp03_generator.h` with Cog
directives.
2. Add a corresponding entry to `generate.bat`.
3. Run `generate.bat` (or the equivalent Cog command) to produce
`include/etl/private/<name>_cpp03.h`.
4. Commit both the generator and the generated output.
5. Verify with `python3 scripts/generator_test.py`.
---
## Troubleshooting
| Problem | Solution |
|---|---|
| `ModuleNotFoundError: No module named 'cogapp'` | Install Cog: `pip install cogapp` |
| Generator output differs from committed file | Regenerate and commit the updated output |
| Need more than 16 types/handlers | Change `-DNTypes=` or `-DHandlers=` and regenerate |

412
docs/testing.md Normal file
View File

@ -0,0 +1,412 @@
# Testing ETL
This document describes how to build and run the ETL test suite locally,
inside Dev Containers, and in CI.
## Table of Contents
1. [Prerequisites](#prerequisites)
2. [Running Tests Locally (`test/run-tests.sh`)](#running-tests-locally)
3. [Syntax Checks (`test/run-syntax-checks.sh`)](#syntax-checks)
4. [Cross-Architecture Testing (`.devcontainer/run-tests.sh`)](#cross-architecture-testing)
5. [Dev Containers for Native Compilers](#dev-containers-for-native-compilers)
6. [CMake Options Reference](#cmake-options-reference)
7. [CI Checks (GitHub Actions)](#ci-checks-github-actions)
8. [Appveyor (Windows / MSVC)](#appveyor-windows--msvc)
9. [Code Coverage](#code-coverage)
10. [Generator Tests (`scripts/generator_test.py`)](#generator-tests)
---
## Prerequisites
* **CMake** ≥ 3.10
* **GCC** and/or **Clang** (any version supported by the project)
* **Make** or **Ninja** (build backend)
* **Docker** (only needed for cross-architecture testing via `.devcontainer/run-tests.sh`)
* **QEMU user-mode** (installed automatically inside the cross-arch Docker images)
The project is header-only, so there is no library to compile – the build
step compiles the test binary `etl_tests` which links against a bundled copy
of **UnitTest++**.
---
## Running Tests Locally
The main entry point for local testing is **`test/run-tests.sh`**. It
iterates over a matrix of compiler / configuration combinations, creates a
temporary `build-make` directory for each one, runs CMake + Make + CTest,
and reports coloured pass/fail output (also appended to `log.txt`).
### Synopsis
```bash
cd test
./run-tests.sh <C++ Standard> [Optimisation] [Threads] [Sanitizer] [Compiler] [Verbose]
```
| Argument | Values | Default |
|---|---|---|
| C++ Standard | `11`, `14`, `17`, `20`, `23`, or `all` | *(required)* |
| Optimisation | `0`, `1`, `2`, `3` | `0` |
| Threads | any positive integer | `4` |
| Sanitizer | `s` (enable) / `n` (disable) | `n` (disabled) |
| Compiler | `gcc`, `clang` | all compilers |
| Verbose | `v` (enable) / `n` (disable) | `n` (disabled) |
### Examples
```bash
# Run all C++17 tests with GCC only, optimisation -O0, 8 threads
./run-tests.sh 17 0 8 n gcc
# Run every standard with both compilers, sanitizers enabled, verbose
./run-tests.sh all 0 4 s "" v
```
### What the script does
For every selected C++ standard the script loops over a built-in list of
configurations (STL / No STL / Force C++03 / Non-virtual messages / …) for
each selected compiler. For every combination it:
1. Creates a fresh `build-make` directory inside the configuration's source
subdirectory.
2. Invokes `cmake` with the appropriate `-D` flags (see
[CMake Options Reference](#cmake-options-reference)).
3. Builds via `cmake --build .` (parallel level controlled by
`CMAKE_BUILD_PARALLEL_LEVEL`).
4. Runs `ctest -V`.
5. Reports success or failure and removes the build directory.
The script exits immediately on the first compilation or test failure.
### Test configurations exercised
| Compiler | Configuration |
|---|---|
| GCC | STL |
| GCC | STL – Non-virtual messages |
| GCC | STL – Force C++03 |
| GCC | No STL |
| GCC | No STL – Force C++03 |
| GCC | No STL – Builtin mem functions |
| Clang | STL |
| Clang | STL – Force C++03 |
| Clang | No STL |
| Clang | No STL – Force C++03 |
| Clang | No STL – Builtin mem functions |
| GCC / Clang | Initializer list test |
| GCC / Clang | Error macros – log_errors, exceptions, log_errors_and_exceptions, assert_function |
---
## Syntax Checks
The script **`test/run-syntax-checks.sh`** performs compilation-only syntax
checks across multiple C++ standards and configurations. Unlike
`run-tests.sh`, it **does not run the test binary** – it only verifies that
the code compiles successfully. This is useful for quickly validating that
header changes do not introduce compilation errors across the supported
standard/configuration matrix.
### Synopsis
```bash
cd test
./run-syntax-checks.sh <C++ Standard> [Threads] [Compiler]
```
| Argument | Values | Default |
|---|---|---|
| C++ Standard | `03`, `11`, `14`, `17`, `20`, `23`, or `a` (all) | *(required)* |
| Threads | any positive integer | `4` |
| Compiler | `gcc`, `clang` | all compilers |
### Examples
```bash
# Check C++17 syntax with GCC only, using 8 threads
./run-syntax-checks.sh 17 8 gcc
# Check all standards with both compilers
./run-syntax-checks.sh a
```
### What the script does
The script operates from the `test/syntax_check` directory and iterates over
the selected C++ standard(s). For each standard and compiler combination it:
1. Creates fresh build directories (`bgcc` / `bclang`).
2. Invokes `cmake` with the appropriate `-D` flags for the configuration.
3. Builds via `cmake --build`.
4. Reports compilation success or failure (logged to `log.txt`).
The script exits immediately on the first compilation failure.
### Configurations checked per standard
For each C++ standard the following configurations are compiled:
| Compiler | Configuration |
|---|---|
| GCC | STL |
| GCC | No STL |
| GCC | STL – Built-in traits |
| GCC | No STL – Built-in traits |
| Clang | STL |
| Clang | No STL |
| Clang | STL – Built-in traits |
| Clang | No STL – Built-in traits |
---
## Cross-Architecture Testing
**`.devcontainer/run-tests.sh`** builds and runs the test suite for
non-x86_64 architectures using Docker and QEMU user-mode emulation. It is
designed to be run **from the project root**.
### Supported architectures
| Argument | Target | Endianness | QEMU binary |
|---|---|---|---|
| `armhf` | ARM hard-float (32-bit) | Little | `qemu-arm-static` |
| `i386` | x86 32-bit | Little | `qemu-i386-static` |
| `powerpc` | PowerPC 32-bit | Big | `qemu-ppc` |
| `riscv64` | RISC-V 64-bit | Little | `qemu-riscv64-static` |
| `s390x` | IBM Z (64-bit) | Big | `qemu-s390x-static` |
### Synopsis
```bash
# From the project root
.devcontainer/run-tests.sh <architecture>
```
### How it works
The script has two phases controlled by a second (internal) argument:
1. **Outside the container** (no second argument):
* Builds a Docker image from `.devcontainer/<arch>/Dockerfile`.
* Starts a container, bind-mounting the project at `/workspaces/etl`.
* Re-invokes itself *inside* the container with the `inside_container`
flag.
2. **Inside the container** (`inside_container`):
* Creates `build-<arch>` and runs CMake with the appropriate cross-
compilation toolchain file
(`.devcontainer/<arch>/toolchain-<arch>.cmake`).
* Builds with `cmake --build .` using all available cores.
* Runs the test suite via `ctest --output-on-failure`.
The toolchain files set `CMAKE_CROSSCOMPILING_EMULATOR` so that CTest can
run the binary transparently through QEMU.
### Example
```bash
# Build & run the armhf test suite
.devcontainer/run-tests.sh armhf
```
The cross-arch containers build with the following fixed settings:
* C++23, No STL, sanitizer off, optimisation -O0.
---
## Dev Containers for Native Compilers
The `.devcontainer/` directory also provides Dev Container definitions for a
wide range of **native** (x86_64) compiler versions. These are intended for
use with **VS Code Dev Containers** or **GitHub Codespaces**.
| Directory | Compiler |
|---|---|
| `gcc09` – `gcc15` | GCC 9 through 15 |
| `clang7` – `clang21` | Clang 7 through 21 |
Each subdirectory contains a `devcontainer.json` that references the shared
`Dockerfile` (`.devcontainer/Dockerfile`) and passes the appropriate base
Docker image via the `BASE_IMAGE_NAME` build argument (e.g. `gcc:15`).
The default Dev Container (`.devcontainer/devcontainer.json`) uses the
Microsoft C++ dev-container base image.
To use one of these containers:
1. Open the repository in VS Code.
2. **Ctrl+Shift+P → Dev Containers: Reopen in Container** and select the
desired configuration (e.g. *Gcc 15*).
3. Use `test/run-tests.sh` inside the container as described above.
---
## CMake Options Reference
When invoking CMake for the test suite (source directory is `test/`), the
following `-D` options control the build:
| Option | Type | Description |
|---|---|---|
| `BUILD_TESTS` | `BOOL` | Must be `ON` to compile the test binary. |
| `NO_STL` | `BOOL` | Build without the C++ Standard Library. |
| `ETL_CXX_STANDARD` | `STRING` | C++ standard: `11`, `14`, `17`, `20`, `23`. |
| `ETL_OPTIMISATION` | `STRING` | Compiler optimisation flag, e.g. `-O0`. |
| `ETL_ENABLE_SANITIZER` | `BOOL` | Enable address / undefined-behaviour sanitizers. |
| `ETL_USE_TYPE_TRAITS_BUILTINS` | `BOOL` | Use compiler built-in type traits. |
| `ETL_USER_DEFINED_TYPE_TRAITS` | `BOOL` | Use user-defined type traits. |
| `ETL_FORCE_TEST_CPP03_IMPLEMENTATION` | `BOOL` | Force the C++03 code paths even on newer standards. |
| `ETL_MESSAGES_ARE_NOT_VIRTUAL` | `BOOL` | Use non-virtual message types. |
| `ETL_USE_BUILTIN_MEM_FUNCTIONS` | `BOOL` | Use built-in memory functions in No-STL mode. |
| `CMAKE_TOOLCHAIN_FILE` | `PATH` | Toolchain file for cross-compilation. |
### Minimal manual build example
```bash
cd test
mkdir build && cd build
cmake -DBUILD_TESTS=ON -DNO_STL=OFF -DETL_CXX_STANDARD=20 ..
cmake --build . -j$(nproc)
ctest -V
```
---
## CI Checks (GitHub Actions)
Every push or pull request to `master`, `development`, or `pull-request/*`
branches triggers a comprehensive set of GitHub Actions workflows defined in
`.github/workflows/`.
### Workflow matrix
| Workflow file | Compiler | Standard | Notes |
|---|---|---|---|
| `gcc-c++11.yml` | GCC | C++11 | STL, No STL, Force C++03 |
| `gcc-c++14.yml` | GCC | C++14 | STL, No STL, Force C++03 |
| `gcc-c++17.yml` | GCC | C++17 | STL, No STL, Force C++03 |
| `gcc-c++20.yml` | GCC | C++20 | STL, No STL, Force C++03 |
| `gcc-c++23.yml` | GCC | C++23 | STL, No STL, Force C++03 |
| `clang-c++11.yml` | Clang | C++11 | STL, No STL, Force C++03 |
| `clang-c++14.yml` | Clang | C++14 | STL, No STL, Force C++03 |
| `clang-c++17.yml` | Clang | C++17 | STL, No STL, Force C++03 |
| `clang-c++20.yml` | Clang | C++20 | STL, No STL, Force C++03 |
| `clang-c++23.yml` | Clang | C++23 | STL, No STL, Force C++03 |
| `gcc-syntax-checks.yml` | GCC | C++03 – C++23 | Compilation-only syntax checks (no tests run) |
| `clang-syntax-checks.yml` | Clang | C++03 – C++23 | Compilation-only syntax checks (no tests run) |
| `msvc.yml` | MSVC 2022 | C++17 | Windows, STL & No STL |
| `gcc-c++23-armhf.yml` | GCC cross | C++23 | armhf via QEMU |
| `gcc-c++23-i386.yml` | GCC cross | C++23 | i386 via QEMU |
| `gcc-c++23-powerpc.yml` | GCC cross | C++23 | powerpc via QEMU |
| `gcc-c++23-riscv64.yml` | GCC cross | C++23 | RISC-V 64 via QEMU |
| `gcc-c++23-s390x.yml` | GCC cross | C++23 | s390x via QEMU |
| `coverage.yml` | GCC | — | Generates lcov coverage report, deploys to GitHub Pages |
| `generator.yml` | — | — | Runs the code generator |
| `platformio-update.yml` | — | — | PlatformIO registry update |
### Typical CI job structure
Each compiler/standard workflow follows the same pattern:
1. **Checkout** – `actions/checkout@v4`.
2. **Build** – set `CC`/`CXX`, call `cmake` with the appropriate `-D` flags,
then `make -j`.
3. **Run tests** – execute `./test/etl_tests -v` (or `ctest -V` for cross-
arch jobs).
The cross-architecture CI jobs additionally install a cross-compiler
toolchain and QEMU inside a `debian:trixie` container, use the matching
toolchain file from `.devcontainer/<arch>/`, and run tests via CTest (which
delegates to QEMU through `CMAKE_CROSSCOMPILING_EMULATOR`).
### Branches tested
* `master`
* `development`
* `pull-request/*`
All workflows run on both `push` and `pull_request` events (types: opened,
synchronize, reopened).
---
## Appveyor (Windows / MSVC)
The `appveyor.yml` at the repository root provides additional Windows CI
using **Visual Studio 2022**. It builds the `master` branch only.
Configurations tested:
* Debug MSVC C++14
* Debug MSVC C++14 – No STL
* Debug MSVC C++17
* Debug MSVC C++17 – No STL
* Debug MSVC C++20
* Debug MSVC C++20 – No STL
The build uses the VS 2022 solution file at `test/vs2022/etl.vcxproj`.
---
## Code Coverage
The `coverage.yml` GitHub Actions workflow generates an **lcov** coverage
report:
1. Runs `test/run-coverage.sh` which builds and tests with GCC coverage
flags.
2. Uploads the HTML report as a build artifact (retained for 30 days).
3. On pushes to `master`, deploys the report to **GitHub Pages**.
To generate coverage locally:
```bash
cd test
./run-coverage.sh
# Open test/build-coverage/coverage/index.html
```
---
## Generator Tests
The script **`scripts/generator_test.py`** verifies that the code generators
in `include/etl/generators/` produce output matching the checked-in header
files in `include/etl/private/`.
ETL uses [Cog](https://nedbatchelder.com/code/cog/) to generate certain
repetitive header files (e.g. `delegate.h`, `message_packet.h`). The
generator templates live in `include/etl/generators/*_generator.h` and the
generated output is committed to `include/etl/private/*.h`. This test
ensures the two stay in sync.
### Prerequisites
* **Python 3**
* **cogapp** – install via `pip install cogapp`
### Synopsis
```bash
python3 scripts/generator_test.py
```
### What the script does
1. Iterates over every `*_generator.h` file in `include/etl/generators/`.
2. Runs Cog on each generator, outputting to `build/generator_tmp/`.
3. Compares each generated file against the corresponding file in
`include/etl/private/`.
4. Reports success if all files match, or failure if any differ.
The script exits with code `0` on success and `1` on failure.
### CI integration
The `generator.yml` GitHub Actions workflow runs this script automatically
on pushes and pull requests to verify generator consistency.

21
include/etl/algorithm.h
View File

@ -558,7 +558,8 @@ namespace etl
{
while (first != last)
{
*first = value;
// This cast is necessary because the signedness can differ
*first = static_cast<typename etl::iterator_traits<TIterator>::value_type>(value);
++first;
}
}
@ -898,6 +899,7 @@ namespace etl
{
TDistance parent = (value_index - 1) / 2;
#include "etl/private/diagnostic_array_bounds_push.h"
while ((value_index > top_index) && compare(first[parent], value))
{
first[value_index] = ETL_MOVE(first[parent]);
@ -906,6 +908,7 @@ namespace etl
}
first[value_index] = ETL_MOVE(value);
#include "etl/private/diagnostic_pop.h"
}
// Adjust Heap Helper
@ -1358,7 +1361,9 @@ namespace etl
value_type temp(ETL_MOVE(*first));
// Move the rest.
#include "etl/private/diagnostic_stringop_overread_push.h"
TIterator result = etl::move(etl::next(first), last, first);
#include "etl/private/diagnostic_pop.h"
// Restore the first item in its rotated position.
*result = ETL_MOVE(temp);
@ -2786,7 +2791,9 @@ namespace etl
d_size_type d_size = etl::distance(o_begin, o_end);
min_size_type min_size = etl::min<min_size_type>(s_size, d_size);
#include "etl/private/diagnostic_null_dereference_push.h"
return etl::move(i_begin, i_begin + min_size, o_begin);
#include "etl/private/diagnostic_pop.h"
}
//***************************************************************************
@ -5860,12 +5867,14 @@ namespace etl
}
}
#include "etl/private/diagnostic_array_bounds_push.h"
// Sort the heap to produce a sorted output range
for (auto heap_end = heap_size - 1; heap_end > 0; --heap_end)
{
etl::iter_swap(result_first, result_first + heap_end);
sift_down(result_first, decltype(heap_size){0}, heap_end, comp, proj2);
}
#include "etl/private/diagnostic_pop.h"
return {etl::move(in_last), etl::move(r)};
}
@ -6202,6 +6211,16 @@ namespace etl
I left_partition = stable_partition_impl(first, middle, etl::ref(pred), etl::ref(proj), len / 2);
I right_partition = stable_partition_impl(middle, last, etl::ref(pred), etl::ref(proj), len - len / 2);
if (left_partition == middle)
{
return right_partition;
}
if (middle == right_partition)
{
return left_partition;
}
return etl::rotate(left_partition, middle, right_partition);
}
};

128
include/etl/atomic/atomic_gcc_sync.h
View File

@ -341,6 +341,68 @@ namespace etl
return __atomic_fetch_xor(&value, v, order);
}
// Fetch max
T fetch_max(T v, etl::memory_order order = etl::memory_order_seq_cst)
{
T old = load(order);
while (v > old)
{
if (compare_exchange_weak(old, v, order))
{
break;
}
}
return old;
}
T fetch_max(T v, etl::memory_order order = etl::memory_order_seq_cst) volatile
{
T old = load(order);
while (v > old)
{
if (compare_exchange_weak(old, v, order))
{
break;
}
}
return old;
}
// Fetch min
T fetch_min(T v, etl::memory_order order = etl::memory_order_seq_cst)
{
T old = load(order);
while (v < old)
{
if (compare_exchange_weak(old, v, order))
{
break;
}
}
return old;
}
T fetch_min(T v, etl::memory_order order = etl::memory_order_seq_cst) volatile
{
T old = load(order);
while (v < old)
{
if (compare_exchange_weak(old, v, order))
{
break;
}
}
return old;
}
// Exchange
T exchange(T v, etl::memory_order order = etl::memory_order_seq_cst)
{
@ -1234,6 +1296,72 @@ namespace etl
return __sync_fetch_and_xor(&value, v);
}
// Fetch max
T fetch_max(T v, etl::memory_order order = etl::memory_order_seq_cst)
{
(void)order;
T old = load(order);
while (v > old)
{
if (compare_exchange_weak(old, v, order))
{
break;
}
}
return old;
}
T fetch_max(T v, etl::memory_order order = etl::memory_order_seq_cst) volatile
{
(void)order;
T old = load(order);
while (v > old)
{
if (compare_exchange_weak(old, v, order))
{
break;
}
}
return old;
}
// Fetch min
T fetch_min(T v, etl::memory_order order = etl::memory_order_seq_cst)
{
(void)order;
T old = load(order);
while (v < old)
{
if (compare_exchange_weak(old, v, order))
{
break;
}
}
return old;
}
T fetch_min(T v, etl::memory_order order = etl::memory_order_seq_cst) volatile
{
(void)order;
T old = load(order);
while (v < old)
{
if (compare_exchange_weak(old, v, order))
{
break;
}
}
return old;
}
// Exchange
T exchange(T v, etl::memory_order order = etl::memory_order_seq_cst)
{

181
include/etl/atomic/atomic_std.h
View File

@ -40,11 +40,98 @@ namespace etl
{
//***************************************************************************
// ETL Atomic type for compilers that support std::atomic.
// etl::atomic is a simple wrapper around std::atomic.
// etl::atomic is a wrapper around std::atomic that adds fetch_max and
// fetch_min if the standard library does not yet provide them.
//***************************************************************************
#if ETL_HAS_STD_ATOMIC_MIN_MAX
// The standard library already provides fetch_max/fetch_min.
template <typename T>
using atomic = std::atomic<T>;
#else
template <typename T>
class atomic : public std::atomic<T>
{
using base_type = std::atomic<T>;
public:
atomic() ETL_NOEXCEPT = default;
ETL_CONSTEXPR atomic(T desired) ETL_NOEXCEPT
: base_type(desired)
{
}
atomic(const atomic&) = delete;
atomic& operator=(const atomic&) = delete;
atomic& operator=(const atomic&) volatile = delete;
using base_type::operator=;
// Fetch max
T fetch_max(T v, std::memory_order order = std::memory_order_seq_cst)
{
T old = this->load(order);
while (v > old)
{
if (this->compare_exchange_weak(old, v, order))
{
break;
}
}
return old;
}
T fetch_max(T v, std::memory_order order = std::memory_order_seq_cst) volatile
{
T old = this->load(order);
while (v > old)
{
if (this->compare_exchange_weak(old, v, order))
{
break;
}
}
return old;
}
// Fetch min
T fetch_min(T v, std::memory_order order = std::memory_order_seq_cst)
{
T old = this->load(order);
while (v < old)
{
if (this->compare_exchange_weak(old, v, order))
{
break;
}
}
return old;
}
T fetch_min(T v, std::memory_order order = std::memory_order_seq_cst) volatile
{
T old = this->load(order);
while (v < old)
{
if (this->compare_exchange_weak(old, v, order))
{
break;
}
}
return old;
}
};
#endif
using memory_order = std::memory_order;
@ -55,66 +142,66 @@ namespace etl
static ETL_CONSTANT etl::memory_order memory_order_acq_rel = std::memory_order_acq_rel;
static ETL_CONSTANT etl::memory_order memory_order_seq_cst = std::memory_order_seq_cst;
using atomic_bool = std::atomic<bool>;
using atomic_char = std::atomic<char>;
using atomic_schar = std::atomic<signed char>;
using atomic_uchar = std::atomic<unsigned char>;
using atomic_short = std::atomic<short>;
using atomic_ushort = std::atomic<unsigned short>;
using atomic_int = std::atomic<int>;
using atomic_uint = std::atomic<unsigned int>;
using atomic_long = std::atomic<long>;
using atomic_ulong = std::atomic<unsigned long>;
using atomic_llong = std::atomic<long long>;
using atomic_ullong = std::atomic<unsigned long long>;
using atomic_wchar_t = std::atomic<wchar_t>;
using atomic_bool = etl::atomic<bool>;
using atomic_char = etl::atomic<char>;
using atomic_schar = etl::atomic<signed char>;
using atomic_uchar = etl::atomic<unsigned char>;
using atomic_short = etl::atomic<short>;
using atomic_ushort = etl::atomic<unsigned short>;
using atomic_int = etl::atomic<int>;
using atomic_uint = etl::atomic<unsigned int>;
using atomic_long = etl::atomic<long>;
using atomic_ulong = etl::atomic<unsigned long>;
using atomic_llong = etl::atomic<long long>;
using atomic_ullong = etl::atomic<unsigned long long>;
using atomic_wchar_t = etl::atomic<wchar_t>;
#if ETL_HAS_NATIVE_CHAR8_T
using atomic_char8_t = std::atomic<char8_t>;
using atomic_char8_t = etl::atomic<char8_t>;
#endif
#if ETL_HAS_NATIVE_CHAR16_T
using atomic_char16_t = std::atomic<char16_t>;
using atomic_char16_t = etl::atomic<char16_t>;
#endif
#if ETL_HAS_NATIVE_CHAR32_T
using atomic_char32_t = std::atomic<char32_t>;
using atomic_char32_t = etl::atomic<char32_t>;
#endif
#if ETL_USING_8BIT_TYPES
using atomic_uint8_t = std::atomic<uint8_t>;
using atomic_int8_t = std::atomic<int8_t>;
using atomic_uint8_t = etl::atomic<uint8_t>;
using atomic_int8_t = etl::atomic<int8_t>;
#endif
using atomic_uint16_t = std::atomic<uint16_t>;
using atomic_int16_t = std::atomic<int16_t>;
using atomic_uint32_t = std::atomic<uint32_t>;
using atomic_int32_t = std::atomic<int32_t>;
using atomic_uint16_t = etl::atomic<uint16_t>;
using atomic_int16_t = etl::atomic<int16_t>;
using atomic_uint32_t = etl::atomic<uint32_t>;
using atomic_int32_t = etl::atomic<int32_t>;
#if ETL_USING_64BIT_TYPES
using atomic_uint64_t = std::atomic<uint64_t>;
using atomic_int64_t = std::atomic<int64_t>;
using atomic_uint64_t = etl::atomic<uint64_t>;
using atomic_int64_t = etl::atomic<int64_t>;
#endif
using atomic_int_least8_t = std::atomic<int_least8_t>;
using atomic_uint_least8_t = std::atomic<uint_least8_t>;
using atomic_int_least16_t = std::atomic<int_least16_t>;
using atomic_uint_least16_t = std::atomic<uint_least16_t>;
using atomic_int_least32_t = std::atomic<int_least32_t>;
using atomic_uint_least32_t = std::atomic<uint_least32_t>;
using atomic_int_least8_t = etl::atomic<int_least8_t>;
using atomic_uint_least8_t = etl::atomic<uint_least8_t>;
using atomic_int_least16_t = etl::atomic<int_least16_t>;
using atomic_uint_least16_t = etl::atomic<uint_least16_t>;
using atomic_int_least32_t = etl::atomic<int_least32_t>;
using atomic_uint_least32_t = etl::atomic<uint_least32_t>;
#if ETL_USING_64BIT_TYPES
using atomic_int_least64_t = std::atomic<int_least64_t>;
using atomic_uint_least64_t = std::atomic<uint_least64_t>;
using atomic_int_least64_t = etl::atomic<int_least64_t>;
using atomic_uint_least64_t = etl::atomic<uint_least64_t>;
#endif
using atomic_int_fast8_t = std::atomic<int_fast8_t>;
using atomic_uint_fast8_t = std::atomic<uint_fast8_t>;
using atomic_int_fast16_t = std::atomic<int_fast16_t>;
using atomic_uint_fast16_t = std::atomic<uint_fast16_t>;
using atomic_int_fast32_t = std::atomic<int_fast32_t>;
using atomic_uint_fast32_t = std::atomic<uint_fast32_t>;
using atomic_int_fast8_t = etl::atomic<int_fast8_t>;
using atomic_uint_fast8_t = etl::atomic<uint_fast8_t>;
using atomic_int_fast16_t = etl::atomic<int_fast16_t>;
using atomic_uint_fast16_t = etl::atomic<uint_fast16_t>;
using atomic_int_fast32_t = etl::atomic<int_fast32_t>;
using atomic_uint_fast32_t = etl::atomic<uint_fast32_t>;
#if ETL_USING_64BIT_TYPES
using atomic_int_fast64_t = std::atomic<int_fast64_t>;
using atomic_uint_fast64_t = std::atomic<uint_fast64_t>;
using atomic_int_fast64_t = etl::atomic<int_fast64_t>;
using atomic_uint_fast64_t = etl::atomic<uint_fast64_t>;
#endif
using atomic_intptr_t = std::atomic<intptr_t>;
using atomic_uintptr_t = std::atomic<uintptr_t>;
using atomic_size_t = std::atomic<size_t>;
using atomic_ptrdiff_t = std::atomic<ptrdiff_t>;
using atomic_intmax_t = std::atomic<intmax_t>;
using atomic_uintmax_t = std::atomic<uintmax_t>;
using atomic_intptr_t = etl::atomic<intptr_t>;
using atomic_uintptr_t = etl::atomic<uintptr_t>;
using atomic_size_t = etl::atomic<size_t>;
using atomic_ptrdiff_t = etl::atomic<ptrdiff_t>;
using atomic_intmax_t = etl::atomic<intmax_t>;
using atomic_uintmax_t = etl::atomic<uintmax_t>;
} // namespace etl
#endif

4
include/etl/bip_buffer_spsc_atomic.h
View File

@ -404,7 +404,7 @@ namespace etl
//*************************************************************************
void read_commit(const span<T>& reserve)
{
size_type rindex = etl::distance(p_buffer, reserve.data());
size_type rindex = static_cast<size_type>(etl::distance(p_buffer, reserve.data()));
apply_read_reserve(rindex, reserve.size());
}
@ -438,7 +438,7 @@ namespace etl
//*************************************************************************
void write_commit(const span<T>& reserve)
{
size_type windex = etl::distance(p_buffer, reserve.data());
size_type windex = static_cast<size_type>(etl::distance(p_buffer, reserve.data()));
apply_write_reserve(windex, reserve.size());
}

4
include/etl/chrono.h
View File

@ -35,10 +35,6 @@ SOFTWARE.
#include "platform.h"
#if ETL_NOT_USING_CPP11 && !defined(ETL_IN_UNIT_TEST)
#error NOT SUPPORTED FOR C++03 OR BELOW
#endif
#if ETL_USING_CPP11
#include "hash.h"

170
include/etl/closure.h
View File

@ -33,53 +33,62 @@ SOFTWARE.
#include "platform.h"
#include "delegate.h"
#include "invoke.h"
#include "tuple.h"
#include "type_list.h"
#include "utility.h"
namespace etl
{
#if ETL_USING_CPP11 && !defined(ETL_CLOSURE_FORCE_CPP03_IMPLEMENTATION)
//*************************************************************************
/// Base template for closure.
/// \tparam TSignature The callback signature.
/// \tparam TCallback The callback type, defaults to etl::delegate<TSignature>.
//*************************************************************************
template <typename>
template <typename TSignature, typename TCallback = etl::delegate<TSignature> >
class closure;
#if ETL_USING_CPP11 && !defined(ETL_CLOSURE_FORCE_CPP03_IMPLEMENTATION)
//*************************************************************************
/// Closure for binding arguments to a delegate and invoking it later.
/// Stores a delegate and its arguments, allowing deferred execution.
/// Closure for binding arguments to a callback and invoking it later.
/// Stores a callback and its arguments, allowing deferred execution.
/// Arguments are stored in a tuple and can be rebound using bind().
/// Example usage:
/// \code
/// etl::closure<void(int, int)> c(my_delegate, 1, 2);
/// c(); // Invokes my_delegate(1, 2)
/// \endcode
/// \tparam TReturn The return type of the delegate.
/// \tparam TArgs The argument types of the delegate.
/// \tparam TReturn The return type of the callback.
/// \tparam TArgs The argument types of the callback.
/// \tparam TCallback The callback type.
//*************************************************************************
template <typename TReturn, typename... TArgs>
class closure<TReturn(TArgs...)>
template <typename TReturn, typename... TArgs, typename TCallback>
class closure<TReturn(TArgs...), TCallback>
{
public:
using delegate_type = etl::delegate<TReturn(TArgs...)>; ///< The delegate type to be invoked.
using argument_types = etl::type_list<TArgs...>; ///< The type list of arguments.
using delegate_type ETL_DEPRECATED_REASON("Use callback_type") =
TCallback; ///< The callback type to be invoked. Deprecated, use callback_type instead.
using callback_type = TCallback; ///< The callback type to be invoked.
using argument_types = etl::type_list<TArgs...>; ///< The type list of arguments.
static_assert(etl::is_invocable_r<TReturn, TCallback, TArgs...>::value, "Callback is not invocable with the specified arguments");
static_assert(etl::is_copy_constructible<TCallback>::value, "Callback type must be copy constructible");
//*********************************************************************
/// Construct a closure with a delegate and its arguments.
/// \param f The delegate to be invoked.
/// \param args The arguments to bind to the delegate.
/// Construct a closure with a callback and its arguments.
/// \param f The callback to be invoked.
/// \param args The arguments to bind to the callback.
//*********************************************************************
ETL_CONSTEXPR14 closure(const delegate_type& f, const TArgs... args)
ETL_CONSTEXPR14 closure(const callback_type& f, const TArgs... args)
: m_f(f)
, m_args(args...)
{
}
//*********************************************************************
/// Invoke the stored delegate with the bound arguments.
/// \return The result of the delegate invocation.
/// Invoke the stored callback with the bound arguments.
/// \return The result of the callback invocation.
//*********************************************************************
ETL_CONSTEXPR14 TReturn operator()() const
{
@ -131,7 +140,7 @@ namespace etl
//*********************************************************************
/// Execute the closure with the stored arguments.
/// \tparam idx Index sequence for tuple unpacking.
/// \return The result of the delegate invocation.
/// \return The result of the callback invocation.
//*********************************************************************
template <size_t... Indexes>
ETL_CONSTEXPR14 TReturn execute(etl::index_sequence<Indexes...>) const
@ -139,43 +148,38 @@ namespace etl
return m_f(etl::get<Indexes>(m_args)...);
}
delegate_type m_f; ///< The delegate to invoke.
callback_type m_f; ///< The callback to invoke.
etl::tuple<TArgs...> m_args; ///< The bound arguments.
};
#else
//*************************************************************************
/// Base template for closure.
//*************************************************************************
template <typename>
class closure;
//*************************************************************************
/// Closure for binding one argument to a delegate and invoking it later.
/// \tparam TReturn The return type of the delegate.
/// Closure for binding one argument to a callback and invoking it later.
/// \tparam TReturn The return type of the callback.
/// \tparam TArg0 The type of the argument.
/// \tparam TCallback The callback type.
//*************************************************************************
template <typename TReturn, typename TArg0>
class closure<TReturn(TArg0)>
template <typename TReturn, typename TArg0, typename TCallback>
class closure<TReturn(TArg0), TCallback>
{
public:
/// The delegate type to be invoked.
typedef etl::delegate<TReturn(TArg0)> delegate_type;
/// The callback type to be invoked.
typedef TCallback callback_type;
//*********************************************************************
/// Construct a closure with a delegate and its argument.
/// \param f The delegate to be invoked.
/// \param arg0 The argument to bind to the delegate.
/// Construct a closure with a callback and its argument.
/// \param f The callback to be invoked.
/// \param arg0 The argument to bind to the callback.
//*********************************************************************
closure(const delegate_type& f, const TArg0 arg0)
closure(const callback_type& f, const TArg0 arg0)
: m_f(f)
, m_arg0(arg0)
{
}
//*********************************************************************
/// Invoke the stored delegate with the bound argument.
/// \return The result of the delegate invocation.
/// Invoke the stored callback with the bound argument.
/// \return The result of the callback invocation.
//*********************************************************************
TReturn operator()() const
{
@ -184,30 +188,31 @@ namespace etl
private:
delegate_type m_f; ///< The delegate to invoke.
callback_type m_f; ///< The callback to invoke.
TArg0 m_arg0;
};
//*************************************************************************
/// Closure for binding two arguments to a delegate and invoking it later.
/// \tparam TReturn The return type of the delegate.
/// Closure for binding two arguments to a callback and invoking it later.
/// \tparam TReturn The return type of the callback.
/// \tparam TArg0 The type of the first argument.
/// \tparam TArg1 The type of the second argument.
/// \tparam TCallback The callback type.
//*************************************************************************
template <typename TReturn, typename TArg0, typename TArg1>
class closure<TReturn(TArg0, TArg1)>
template <typename TReturn, typename TArg0, typename TArg1, typename TCallback>
class closure<TReturn(TArg0, TArg1), TCallback>
{
public:
typedef etl::delegate<TReturn(TArg0, TArg1)> delegate_type;
typedef TCallback callback_type;
//*********************************************************************
/// Construct a closure with a delegate and its arguments.
/// \param f The delegate to be invoked.
/// Construct a closure with a callback and its arguments.
/// \param f The callback to be invoked.
/// \param arg0 The first argument to bind.
/// \param arg1 The second argument to bind.
//*********************************************************************
closure(const delegate_type& f, const TArg0 arg0, const TArg1 arg1)
closure(const callback_type& f, const TArg0 arg0, const TArg1 arg1)
: m_f(f)
, m_arg0(arg0)
, m_arg1(arg1)
@ -215,8 +220,8 @@ namespace etl
}
//*********************************************************************
/// Invoke the stored delegate with the bound arguments.
/// \return The result of the delegate invocation.
/// Invoke the stored callback with the bound arguments.
/// \return The result of the callback invocation.
//*********************************************************************
TReturn operator()() const
{
@ -225,33 +230,34 @@ namespace etl
private:
delegate_type m_f; ///< The delegate to invoke.
callback_type m_f; ///< The callback to invoke.
TArg0 m_arg0;
TArg1 m_arg1;
};
//*************************************************************************
/// Closure for binding three arguments to a delegate and invoking it later.
/// \tparam TReturn The return type of the delegate.
/// Closure for binding three arguments to a callback and invoking it later.
/// \tparam TReturn The return type of the callback.
/// \tparam TArg0 The type of the first argument.
/// \tparam TArg1 The type of the second argument.
/// \tparam TArg2 The type of the third argument.
/// \tparam TCallback The callback type.
//*************************************************************************
template <typename TReturn, typename TArg0, typename TArg1, typename TArg2>
class closure<TReturn(TArg0, TArg1, TArg2)>
template <typename TReturn, typename TArg0, typename TArg1, typename TArg2, typename TCallback>
class closure<TReturn(TArg0, TArg1, TArg2), TCallback>
{
public:
typedef etl::delegate<TReturn(TArg0, TArg1, TArg2)> delegate_type;
typedef TCallback callback_type;
//*********************************************************************
/// Construct a closure with a delegate and its arguments.
/// \param f The delegate to be invoked.
/// Construct a closure with a callback and its arguments.
/// \param f The callback to be invoked.
/// \param arg0 The first argument to bind.
/// \param arg1 The second argument to bind.
/// \param arg2 The third argument to bind.
//*********************************************************************
closure(const delegate_type& f, const TArg0 arg0, const TArg1 arg1, const TArg2 arg2)
closure(const callback_type& f, const TArg0 arg0, const TArg1 arg1, const TArg2 arg2)
: m_f(f)
, m_arg0(arg0)
, m_arg1(arg1)
@ -260,8 +266,8 @@ namespace etl
}
//*********************************************************************
/// Invoke the stored delegate with the bound arguments.
/// \return The result of the delegate invocation.
/// Invoke the stored callback with the bound arguments.
/// \return The result of the callback invocation.
//*********************************************************************
TReturn operator()() const
{
@ -270,36 +276,37 @@ namespace etl
private:
delegate_type m_f; ///< The delegate to invoke.
callback_type m_f; ///< The callback to invoke.
TArg0 m_arg0;
TArg1 m_arg1;
TArg2 m_arg2;
};
//*************************************************************************
/// Closure for binding four arguments to a delegate and invoking it later.
/// \tparam TReturn The return type of the delegate.
/// Closure for binding four arguments to a callback and invoking it later.
/// \tparam TReturn The return type of the callback.
/// \tparam TArg0 The type of the first argument.
/// \tparam TArg1 The type of the second argument.
/// \tparam TArg2 The type of the third argument.
/// \tparam TArg3 The type of the fourth argument.
/// \tparam TCallback The callback type.
//*************************************************************************
template <typename TReturn, typename TArg0, typename TArg1, typename TArg2, typename TArg3>
class closure<TReturn(TArg0, TArg1, TArg2, TArg3)>
template <typename TReturn, typename TArg0, typename TArg1, typename TArg2, typename TArg3, typename TCallback>
class closure<TReturn(TArg0, TArg1, TArg2, TArg3), TCallback>
{
public:
typedef etl::delegate<TReturn(TArg0, TArg1, TArg2, TArg3)> delegate_type;
typedef TCallback callback_type;
//*********************************************************************
/// Construct a closure with a delegate and its arguments.
/// \param f The delegate to be invoked.
/// Construct a closure with a callback and its arguments.
/// \param f The callback to be invoked.
/// \param arg0 The first argument to bind.
/// \param arg1 The second argument to bind.
/// \param arg2 The third argument to bind.
/// \param arg3 The fourth argument to bind.
//*********************************************************************
closure(const delegate_type& f, const TArg0 arg0, const TArg1 arg1, const TArg2 arg2, const TArg3 arg3)
closure(const callback_type& f, const TArg0 arg0, const TArg1 arg1, const TArg2 arg2, const TArg3 arg3)
: m_f(f)
, m_arg0(arg0)
, m_arg1(arg1)
@ -309,8 +316,8 @@ namespace etl
}
//*********************************************************************
/// Invoke the stored delegate with the bound arguments.
/// \return The result of the delegate invocation.
/// Invoke the stored callback with the bound arguments.
/// \return The result of the callback invocation.
//*********************************************************************
TReturn operator()() const
{
@ -319,7 +326,7 @@ namespace etl
private:
delegate_type m_f; ///< The delegate to invoke.
callback_type m_f; ///< The callback to invoke.
TArg0 m_arg0;
TArg1 m_arg1;
TArg2 m_arg2;
@ -327,31 +334,32 @@ namespace etl
};
//*************************************************************************
/// Closure for binding five arguments to a delegate and invoking it later.
/// \tparam TReturn The return type of the delegate.
/// Closure for binding five arguments to a callback and invoking it later.
/// \tparam TReturn The return type of the callback.
/// \tparam TArg0 The type of the first argument.
/// \tparam TArg1 The type of the second argument.
/// \tparam TArg2 The type of the third argument.
/// \tparam TArg3 The type of the fourth argument.
/// \tparam TArg4 The type of the fifth argument.
/// \tparam TCallback The callback type.
//*************************************************************************
template <typename TReturn, typename TArg0, typename TArg1, typename TArg2, typename TArg3, typename TArg4>
class closure<TReturn(TArg0, TArg1, TArg2, TArg3, TArg4)>
template <typename TReturn, typename TArg0, typename TArg1, typename TArg2, typename TArg3, typename TArg4, typename TCallback>
class closure<TReturn(TArg0, TArg1, TArg2, TArg3, TArg4), TCallback>
{
public:
typedef etl::delegate<TReturn(TArg0, TArg1, TArg2, TArg3, TArg4)> delegate_type;
typedef TCallback callback_type;
//*********************************************************************
/// Construct a closure with a delegate and its arguments.
/// \param f The delegate to be invoked.
/// Construct a closure with a callback and its arguments.
/// \param f The callback to be invoked.
/// \param arg0 The first argument to bind.
/// \param arg1 The second argument to bind.
/// \param arg2 The third argument to bind.
/// \param arg3 The fourth argument to bind.
/// \param arg4 The fifth argument to bind.
//*********************************************************************
closure(const delegate_type& f, const TArg0 arg0, const TArg1 arg1, const TArg2 arg2, const TArg3 arg3, const TArg4 arg4)
closure(const callback_type& f, const TArg0 arg0, const TArg1 arg1, const TArg2 arg2, const TArg3 arg3, const TArg4 arg4)
: m_f(f)
, m_arg0(arg0)
, m_arg1(arg1)
@ -362,8 +370,8 @@ namespace etl
}
//*********************************************************************
/// Invoke the stored delegate with the bound arguments.
/// \return The result of the delegate invocation.
/// Invoke the stored callback with the bound arguments.
/// \return The result of the callback invocation.
//*********************************************************************
TReturn operator()() const
{
@ -372,7 +380,7 @@ namespace etl
private:
delegate_type m_f; ///< The delegate to invoke.
callback_type m_f; ///< The callback to invoke.
TArg0 m_arg0;
TArg1 m_arg1;
TArg2 m_arg2;

4
include/etl/concepts.h
View File

@ -36,10 +36,6 @@ SOFTWARE.
#include "type_traits.h"
#include "utility.h"
#if ETL_NOT_USING_CPP20 && !defined(ETL_IN_UNIT_TEST)
#error NOT SUPPORTED FOR BELOW C++20
#endif
#if ETL_USING_CPP20
#if ETL_USING_STL

27
include/etl/const_map.h
View File

@ -33,10 +33,6 @@ SOFTWARE.
#include "platform.h"
#if ETL_NOT_USING_CPP11
#error NOT SUPPORTED FOR C++03 OR BELOW
#endif
#include "algorithm.h"
#include "functional.h"
#include "nth_type.h"
@ -45,6 +41,8 @@ SOFTWARE.
#include "private/comparator_is_transparent.h"
#if ETL_USING_CPP11
///\defgroup const_map const_map
///\ingroup containers
@ -528,14 +526,14 @@ namespace etl
value_type element_list[Size];
};
//*************************************************************************
/// Template deduction guides.
//*************************************************************************
#if ETL_USING_CPP17
//*************************************************************************
/// Template deduction guides.
//*************************************************************************
#if ETL_USING_CPP17
template <typename... TElements>
const_map(TElements...)
-> const_map<typename etl::nth_type_t<0, TElements...>::first_type, typename etl::nth_type_t<0, TElements...>::second_type, sizeof...(TElements)>;
#endif
#endif
//*********************************************************************
/// Map type designed for constexpr.
@ -586,16 +584,16 @@ namespace etl
}
};
//*************************************************************************
/// Template deduction guides.
//*************************************************************************
#if ETL_USING_CPP17
//*************************************************************************
/// Template deduction guides.
//*************************************************************************
#if ETL_USING_CPP17
template <typename TElements, size_t Size>
const_map_ext(const etl::span<TElements, Size>&) -> const_map_ext<typename TElements::first_type, typename TElements::second_type>;
template <typename TElements, size_t Size>
const_map_ext(const TElements (&)[Size]) -> const_map_ext<typename TElements::first_type, typename TElements::second_type>;
#endif
#endif
//*************************************************************************
/// Equality test.
@ -659,3 +657,4 @@ namespace etl
} // namespace etl
#endif
#endif

27
include/etl/const_multimap.h
View File

@ -33,10 +33,6 @@ SOFTWARE.
#include "platform.h"
#if ETL_NOT_USING_CPP11
#error NOT SUPPORTED FOR C++03 OR BELOW
#endif
#include "algorithm.h"
#include "functional.h"
#include "nth_type.h"
@ -45,6 +41,8 @@ SOFTWARE.
#include "private/comparator_is_transparent.h"
#if ETL_USING_CPP11
///\defgroup const_multimap const_multimap
///\ingroup containers
@ -478,14 +476,14 @@ namespace etl
value_type element_list[Size];
};
//*************************************************************************
/// Template deduction guides.
//*************************************************************************
#if ETL_USING_CPP17
//*************************************************************************
/// Template deduction guides.
//*************************************************************************
#if ETL_USING_CPP17
template <typename... TPairs>
const_multimap(TPairs...)
-> const_multimap<typename etl::nth_type_t<0, TPairs...>::first_type, typename etl::nth_type_t<0, TPairs...>::second_type, sizeof...(TPairs)>;
#endif
#endif
//*********************************************************************
/// Map type designed for constexpr.
@ -536,16 +534,16 @@ namespace etl
}
};
//*************************************************************************
/// Template deduction guides.
//*************************************************************************
#if ETL_USING_CPP17
//*************************************************************************
/// Template deduction guides.
//*************************************************************************
#if ETL_USING_CPP17
template <typename TElements, size_t Size>
const_multimap_ext(const etl::span<TElements, Size>&) -> const_multimap_ext<typename TElements::first_type, typename TElements::second_type>;
template <typename TElements, size_t Size>
const_multimap_ext(const TElements (&)[Size]) -> const_multimap_ext<typename TElements::first_type, typename TElements::second_type>;
#endif
#endif
//*************************************************************************
/// Equality test.
@ -626,3 +624,4 @@ namespace etl
} // namespace etl
#endif
#endif

27
include/etl/const_multiset.h
View File

@ -33,10 +33,6 @@ SOFTWARE.
#include "platform.h"
#if ETL_NOT_USING_CPP11
#error NOT SUPPORTED FOR C++03 OR BELOW
#endif
#include "algorithm.h"
#include "functional.h"
#include "nth_type.h"
@ -45,6 +41,8 @@ SOFTWARE.
#include "private/comparator_is_transparent.h"
#if ETL_USING_CPP11
///\defgroup const_multiset const_multiset
///\ingroup containers
@ -433,13 +431,13 @@ namespace etl
value_type element_list[Size];
};
//*************************************************************************
/// Template deduction guides.
//*************************************************************************
#if ETL_USING_CPP17
//*************************************************************************
/// Template deduction guides.
//*************************************************************************
#if ETL_USING_CPP17
template <typename... TElements>
const_multiset(TElements...) -> const_multiset<etl::nth_type_t<0, TElements...>, sizeof...(TElements)>;
#endif
#endif
//*********************************************************************
/// Multiset type designed for constexpr.
@ -488,16 +486,16 @@ namespace etl
}
};
//*************************************************************************
/// Template deduction guides.
//*************************************************************************
#if ETL_USING_CPP17
//*************************************************************************
/// Template deduction guides.
//*************************************************************************
#if ETL_USING_CPP17
template <typename TElements, size_t Size>
const_multiset_ext(const etl::span<TElements, Size>&) -> const_multiset_ext<TElements>;
template <typename TElements, size_t Size>
const_multiset_ext(const TElements (&)[Size]) -> const_multiset_ext<TElements>;
#endif
#endif
//*************************************************************************
/// Equality test.
@ -572,3 +570,4 @@ namespace etl
} // namespace etl
#endif
#endif

27
include/etl/const_set.h
View File

@ -33,10 +33,6 @@ SOFTWARE.
#include "platform.h"
#if ETL_NOT_USING_CPP11
#error NOT SUPPORTED FOR C++03 OR BELOW
#endif
#include "algorithm.h"
#include "functional.h"
#include "nth_type.h"
@ -45,6 +41,8 @@ SOFTWARE.
#include "private/comparator_is_transparent.h"
#if ETL_USING_CPP11
///\defgroup const_set const_set
///\ingroup containers
@ -426,13 +424,13 @@ namespace etl
value_type element_list[Size];
};
//*************************************************************************
/// Template deduction guides.
//*************************************************************************
#if ETL_USING_CPP17
//*************************************************************************
/// Template deduction guides.
//*************************************************************************
#if ETL_USING_CPP17
template <typename... TElements>
const_set(TElements...) -> const_set<etl::nth_type_t<0, TElements...>, sizeof...(TElements)>;
#endif
#endif
//*********************************************************************
/// Map type designed for constexpr.
@ -481,16 +479,16 @@ namespace etl
}
};
//*************************************************************************
/// Template deduction guides.
//*************************************************************************
#if ETL_USING_CPP17
//*************************************************************************
/// Template deduction guides.
//*************************************************************************
#if ETL_USING_CPP17
template <typename TElements, size_t Size>
const_set_ext(const etl::span<TElements, Size>&) -> const_set_ext<TElements>;
template <typename TElements, size_t Size>
const_set_ext(const TElements (&)[Size]) -> const_set_ext<TElements>;
#endif
#endif
//*************************************************************************
/// Equality test.
@ -548,3 +546,4 @@ namespace etl
} // namespace etl
#endif
#endif

38
include/etl/doxygen.h
View File

@ -27,31 +27,29 @@ SOFTWARE.
******************************************************************************/
///\defgroup etl Embedded Template Library.
https
: // github.com/ETLCPP/etl
http
: // www.etlcpp.com
/// https://github.com/ETLCPP/etl
/// http://www.etlcpp.com
///\defgroup containers Containers
///\ingroup etl
///\defgroup containers Containers
///\ingroup etl
///\defgroup utilities Utilities
/// A set of utility templates.
///\ingroup etl
///\defgroup utilities Utilities
/// A set of utility templates.
///\ingroup etl
///\defgroup maths Maths
/// A set of mathematical templates.
///\ingroup etl
///\defgroup maths Maths
/// A set of mathematical templates.
///\ingroup etl
///\defgroup patterns Patterns
/// A set of templated design patterns.
///\ingroup etl
///\defgroup patterns Patterns
/// A set of templated design patterns.
///\ingroup etl
///\defgroup crc CRC
/// A set of CRC calculations
///\ingroup maths
///\defgroup crc CRC
/// A set of CRC calculations
///\ingroup maths
///\ingroup etl
namespace etl
///\ingroup etl
namespace etl
{
}

7
include/etl/expected.h
View File

@ -827,13 +827,12 @@ namespace etl
enum
{
Uninitialised,
Value_Type,
Error_Type
};
typedef etl::variant<etl::monostate, value_type, error_type> storage_type;
storage_type storage;
typedef etl::variant<value_type, error_type> storage_type;
storage_type storage;
#if ETL_USING_CPP11
template < typename F, typename TExp, typename TRet, typename TValueRef, typename = typename etl::enable_if<!etl::is_void<TRet>::value>::type>
@ -1189,7 +1188,7 @@ namespace etl
enum
{
Uninitialised,
Void_Type,
Error_Type
};

112
include/etl/format.h
View File

@ -1039,22 +1039,27 @@ namespace etl
{
const size_t fractional_decimals = 6; // default
T integral;
T fractional = modf(value, &integral);
bool sign;
unsigned long long int fractional_int;
unsigned long long int integral_int;
if (integral < 0.0)
// Detect sign using signbit to correctly handle -0.0
bool sign = signbit(value);
T integral;
T fractional = modf(value, &integral);
// Take absolute values to avoid casting negative values to unsigned
if (sign)
{
sign = true;
fractional_int = static_cast<unsigned long long int>(-fractional * pow(10., fractional_decimals));
integral_int = static_cast<unsigned long long int>(-integral);
fractional = -fractional;
integral = -integral;
}
else
unsigned long long int scale = int_pow<unsigned long long int>(10, fractional_decimals);
unsigned long long int fractional_int = static_cast<unsigned long long int>(round(fractional * scale));
unsigned long long int integral_int = static_cast<unsigned long long int>(integral);
if (fractional_int == scale)
{
sign = false;
fractional_int = static_cast<unsigned long long int>(fractional * pow(10., fractional_decimals));
integral_int = static_cast<unsigned long long int>(integral);
fractional_int = 0;
++integral_int;
}
private_format::format_sign<OutputIt, int>(it, sign ? -1 : 0, spec);
@ -1071,9 +1076,8 @@ namespace etl
static const size_t exponent_decimals = 1;
long long int exponent_int = 0;
bool sign;
unsigned long long int fractional_int;
unsigned long long int integral_int;
// Detect sign using signbit to correctly handle -0.0
bool sign = signbit(value);
T integral;
T fractional = modf(value, &integral);
@ -1092,17 +1096,21 @@ namespace etl
fractional = modf(value, &integral);
}
if (integral < 0.0)
// Take absolute values to avoid casting negative values to unsigned
if (sign)
{
sign = true;
fractional_int = static_cast<unsigned long long int>(-fractional * pow(static_cast<T>(0x10), fractional_decimals));
integral_int = static_cast<unsigned long long int>(-integral);
fractional = -fractional;
integral = -integral;
}
else
unsigned long long int scale = int_pow<unsigned long long int>(0x10, fractional_decimals);
unsigned long long int fractional_int = static_cast<unsigned long long int>(round(fractional * scale));
unsigned long long int integral_int = static_cast<unsigned long long int>(integral);
if (fractional_int == scale)
{
sign = false;
fractional_int = static_cast<unsigned long long int>(fractional * pow(static_cast<T>(0x10), fractional_decimals));
integral_int = static_cast<unsigned long long int>(integral);
fractional_int = 0;
++integral_int;
}
private_format::format_sign<OutputIt, int>(it, sign ? -1 : 0, spec);
@ -1133,9 +1141,8 @@ namespace etl
static const size_t exponent_decimals = 2;
long long int exponent_int = 0;
bool sign;
unsigned long long int fractional_int;
unsigned long long int integral_int;
// Detect sign using signbit to correctly handle -0.0
bool sign = std::signbit(value);
T integral;
T fractional = modf(value, &integral);
@ -1154,17 +1161,21 @@ namespace etl
fractional = modf(value, &integral);
}
if (integral < 0.0)
// Take absolute values to avoid casting negative values to unsigned
if (sign)
{
sign = true;
fractional_int = static_cast<unsigned long long int>(-fractional * pow(10., fractional_decimals));
integral_int = static_cast<unsigned long long int>(-integral);
fractional = -fractional;
integral = -integral;
}
else
unsigned long long int scale = int_pow<unsigned long long int>(10, fractional_decimals);
unsigned long long int fractional_int = static_cast<unsigned long long int>(round(fractional * scale));
unsigned long long int integral_int = static_cast<unsigned long long int>(integral);
if (fractional_int == scale)
{
sign = false;
fractional_int = static_cast<unsigned long long int>(fractional * pow(10., fractional_decimals));
integral_int = static_cast<unsigned long long int>(integral);
fractional_int = 0;
++integral_int;
}
private_format::format_sign<OutputIt, int>(it, sign ? -1 : 0, spec);
@ -1186,22 +1197,27 @@ namespace etl
{
const size_t fractional_decimals = 6; // default
T integral;
T fractional = modf(value, &integral);
bool sign;
unsigned long long int fractional_int;
unsigned long long int integral_int;
if (integral < 0.0)
// Detect sign using signbit to correctly handle -0.0
bool sign = std::signbit(value);
T integral;
T fractional = modf(value, &integral);
// Take absolute values to avoid casting negative values to unsigned
if (sign)
{
sign = true;
fractional_int = static_cast<unsigned long long int>(-fractional * pow(10., fractional_decimals));
integral_int = static_cast<unsigned long long int>(-integral);
fractional = -fractional;
integral = -integral;
}
else
unsigned long long int scale = int_pow<unsigned long long int>(10, fractional_decimals);
unsigned long long int fractional_int = static_cast<unsigned long long int>(round(fractional * scale));
unsigned long long int integral_int = static_cast<unsigned long long int>(integral);
if (fractional_int == scale)
{
sign = false;
fractional_int = static_cast<unsigned long long int>(fractional * pow(10., fractional_decimals));
integral_int = static_cast<unsigned long long int>(integral);
fractional_int = 0;
++integral_int;
}
private_format::format_sign<OutputIt, int>(it, sign ? -1 : 0, spec);

2
include/etl/ipool.h
View File

@ -644,7 +644,7 @@ namespace etl
// in debug.
#if ETL_IS_DEBUG_BUILD
// Is the address on a valid object boundary?
bool is_valid_address = ((distance % Item_Size) == 0);
bool is_valid_address = ((static_cast<size_t>(distance) % Item_Size) == 0);
#else
bool is_valid_address = true;
#endif

205
include/etl/iterator.h
View File

@ -958,13 +958,121 @@ namespace etl
template <typename T>
ETL_CONSTANT bool is_random_access_iterator_concept<T>::value;
#if ETL_USING_CPP11
//***************************************************************************
/// Trait to detect if a type is a container (has iterator and begin/end)
/// but is not itself an iterator.
/// Used to constrain begin()/end() free functions in C++26.
//***************************************************************************
namespace private_iterator
{
// Check if T has iterator_category (i.e., is an iterator)
template <typename T, typename = void>
struct has_iterator_category : etl::false_type
{
};
template <typename T>
struct has_iterator_category<T, etl::void_t<typename T::iterator_category>> : etl::true_type
{
};
// is_container: has iterator/const_iterator/begin/end but does NOT have iterator_category
template <typename T, typename = void>
struct is_container : etl::false_type
{
};
template <typename T>
struct is_container<
T, etl::void_t< typename T::iterator, typename T::const_iterator, decltype(etl::declval<T&>().begin()), decltype(etl::declval<T&>().end()) >>
: etl::bool_constant<!has_iterator_category<T>::value>
{
};
} // namespace private_iterator
#endif
#if ETL_NOT_USING_STL || ETL_CPP11_NOT_SUPPORTED
#if ETL_USING_CPP11
//*****************************************************************************
/// Get the 'begin' iterator.
/// Note: Contains SFINAE guard, ensuring they only participate in overload
/// resolution when TContainer actually has the corresponding member function.
/// This prevents ADL from matching these templates when std::ranges::begin
/// performs an unqualified call on etl:: iterator types.
///\ingroup container
//*****************************************************************************
template <typename TContainer, typename = etl::void_t<decltype(etl::declval<TContainer&>().begin())> >
ETL_CONSTEXPR typename etl::enable_if<private_iterator::is_container<TContainer>::value, typename TContainer::iterator>::type
begin(TContainer& container)
{
return container.begin();
}
//*****************************************************************************
/// Get the 'begin' const_iterator for a container.
///\ingroup container
//*****************************************************************************
template <typename TContainer, typename = etl::void_t<decltype(etl::declval<const TContainer&>().begin())> >
ETL_CONSTEXPR typename etl::enable_if<private_iterator::is_container<TContainer>::value, typename TContainer::const_iterator>::type
begin(const TContainer& container)
{
return container.begin();
}
//*****************************************************************************
/// Get the 'begin' const_iterator for a container.
///\ingroup container
//*****************************************************************************
template <typename TContainer, typename = etl::void_t<decltype(etl::declval<const TContainer&>().cbegin())> >
ETL_CONSTEXPR typename etl::enable_if<private_iterator::is_container<TContainer>::value, typename TContainer::const_iterator>::type
cbegin(const TContainer& container)
{
return container.cbegin();
}
//*****************************************************************************
/// Get the 'end' iterator for a container.
///\ingroup container
//*****************************************************************************
template <typename TContainer, typename = etl::void_t<decltype(etl::declval<TContainer&>().end())> >
ETL_CONSTEXPR typename etl::enable_if<private_iterator::is_container<TContainer>::value, typename TContainer::iterator>::type end(TContainer& container)
{
return container.end();
}
//*****************************************************************************
/// Get the 'end' const_iterator for a container.
///\ingroup container
//*****************************************************************************
template <typename TContainer, typename = etl::void_t<decltype(etl::declval<const TContainer&>().end())> >
ETL_CONSTEXPR typename etl::enable_if<private_iterator::is_container<TContainer>::value, typename TContainer::const_iterator>::type
end(const TContainer& container)
{
return container.end();
}
//*****************************************************************************
/// Get the 'end' const_iterator for a container.
///\ingroup container
//*****************************************************************************
template <typename TContainer, typename = etl::void_t<decltype(etl::declval<const TContainer&>().cend())> >
ETL_CONSTEXPR typename etl::enable_if<private_iterator::is_container<TContainer>::value, typename TContainer::const_iterator>::type
cend(const TContainer& container)
{
return container.cend();
}
#else
// C++03 fallback:
// - no SFINAE guards needed since std::ranges does not exist
// - no constraint needed as C++26 ADL issue doesn't apply
//*****************************************************************************
/// Get the 'begin' iterator.
///\ingroup container
//*****************************************************************************
template <typename TContainer>
ETL_CONSTEXPR typename TContainer::iterator begin(TContainer& container)
typename TContainer::iterator begin(TContainer& container)
{
return container.begin();
}
@ -974,7 +1082,7 @@ namespace etl
///\ingroup container
//*****************************************************************************
template <typename TContainer>
ETL_CONSTEXPR typename TContainer::const_iterator begin(const TContainer& container)
typename TContainer::const_iterator begin(const TContainer& container)
{
return container.begin();
}
@ -984,7 +1092,7 @@ namespace etl
///\ingroup container
//*****************************************************************************
template <typename TContainer>
ETL_CONSTEXPR typename TContainer::const_iterator cbegin(const TContainer& container)
typename TContainer::const_iterator cbegin(const TContainer& container)
{
return container.cbegin();
}
@ -994,7 +1102,7 @@ namespace etl
///\ingroup container
//*****************************************************************************
template <typename TContainer>
ETL_CONSTEXPR typename TContainer::iterator end(TContainer& container)
typename TContainer::iterator end(TContainer& container)
{
return container.end();
}
@ -1004,7 +1112,7 @@ namespace etl
///\ingroup container
//*****************************************************************************
template <typename TContainer>
ETL_CONSTEXPR typename TContainer::const_iterator end(const TContainer& container)
typename TContainer::const_iterator end(const TContainer& container)
{
return container.end();
}
@ -1014,10 +1122,11 @@ namespace etl
///\ingroup container
//*****************************************************************************
template <typename TContainer>
ETL_CONSTEXPR typename TContainer::const_iterator cend(const TContainer& container)
typename TContainer::const_iterator cend(const TContainer& container)
{
return container.cend();
}
#endif
//*****************************************************************************
/// Get the 'begin' pointer for an array.
@ -1081,12 +1190,83 @@ namespace etl
#endif
#if ETL_NOT_USING_STL || ETL_CPP14_NOT_SUPPORTED
#if ETL_USING_CPP11
//*****************************************************************************
/// Get the 'begin' reverse_iterator for a container.
/// Note: Contains SFINAE guard (see begin/end above for rationale).
///\ingroup container
//*****************************************************************************
template <typename TContainer, typename = etl::void_t<decltype(etl::declval<TContainer&>().rbegin())> >
ETL_CONSTEXPR typename etl::enable_if<private_iterator::is_container<TContainer>::value, typename TContainer::reverse_iterator>::type
rbegin(TContainer& container)
{
return container.rbegin();
}
//*****************************************************************************
/// Get the 'begin' reverse_iterator for a container.
///\ingroup container
//*****************************************************************************
template <typename TContainer, typename = etl::void_t<decltype(etl::declval<const TContainer&>().rbegin())> >
ETL_CONSTEXPR typename etl::enable_if<private_iterator::is_container<TContainer>::value, typename TContainer::const_reverse_iterator>::type
rbegin(const TContainer& container)
{
return container.rbegin();
}
//*****************************************************************************
/// Get the 'begin' reverse_iterator for a container.
///\ingroup container
//*****************************************************************************
template <typename TContainer, typename = etl::void_t<decltype(etl::declval<const TContainer&>().crbegin())> >
ETL_CONSTEXPR typename etl::enable_if<private_iterator::is_container<TContainer>::value, typename TContainer::const_reverse_iterator>::type
crbegin(const TContainer& container)
{
return container.crbegin();
}
//*****************************************************************************
/// Get the 'end' reverse_iterator for a container.
///\ingroup container
//*****************************************************************************
template <typename TContainer, typename = etl::void_t<decltype(etl::declval<TContainer&>().rend())> >
ETL_CONSTEXPR typename etl::enable_if<private_iterator::is_container<TContainer>::value, typename TContainer::reverse_iterator>::type
rend(TContainer& container)
{
return container.rend();
}
//*****************************************************************************
/// Get the 'end' reverse_iterator for a container.
///\ingroup container
//*****************************************************************************
template <typename TContainer, typename = etl::void_t<decltype(etl::declval<const TContainer&>().rend())> >
ETL_CONSTEXPR typename etl::enable_if<private_iterator::is_container<TContainer>::value, typename TContainer::const_reverse_iterator>::type
rend(const TContainer& container)
{
return container.rend();
}
//*****************************************************************************
/// Get the 'end' reverse_iterator for a container.
///\ingroup container
//*****************************************************************************
template <typename TContainer, typename = etl::void_t<decltype(etl::declval<const TContainer&>().crend())> >
ETL_CONSTEXPR typename etl::enable_if<private_iterator::is_container<TContainer>::value, typename TContainer::const_reverse_iterator>::type
crend(const TContainer& container)
{
return container.crend();
}
#else
// C++03 fallback:
// - no SFINAE guards needed since std::ranges does not exist.
// - no constraint needed as C++26 ADL issue doesn't apply
//*****************************************************************************
/// Get the 'begin' reverse_iterator for a container.
///\ingroup container
//*****************************************************************************
template <typename TContainer>
ETL_CONSTEXPR typename TContainer::reverse_iterator rbegin(TContainer& container)
typename TContainer::reverse_iterator rbegin(TContainer& container)
{
return container.rbegin();
}
@ -1096,7 +1276,7 @@ namespace etl
///\ingroup container
//*****************************************************************************
template <typename TContainer>
ETL_CONSTEXPR typename TContainer::const_reverse_iterator rbegin(const TContainer& container)
typename TContainer::const_reverse_iterator rbegin(const TContainer& container)
{
return container.rbegin();
}
@ -1106,7 +1286,7 @@ namespace etl
///\ingroup container
//*****************************************************************************
template <typename TContainer>
ETL_CONSTEXPR typename TContainer::const_reverse_iterator crbegin(const TContainer& container)
typename TContainer::const_reverse_iterator crbegin(const TContainer& container)
{
return container.crbegin();
}
@ -1116,7 +1296,7 @@ namespace etl
///\ingroup container
//*****************************************************************************
template <typename TContainer>
ETL_CONSTEXPR typename TContainer::reverse_iterator rend(TContainer& container)
typename TContainer::reverse_iterator rend(TContainer& container)
{
return container.rend();
}
@ -1126,7 +1306,7 @@ namespace etl
///\ingroup container
//*****************************************************************************
template <typename TContainer>
ETL_CONSTEXPR typename TContainer::const_reverse_iterator rend(const TContainer& container)
typename TContainer::const_reverse_iterator rend(const TContainer& container)
{
return container.rend();
}
@ -1136,10 +1316,11 @@ namespace etl
///\ingroup container
//*****************************************************************************
template <typename TContainer>
ETL_CONSTEXPR typename TContainer::const_reverse_iterator crend(const TContainer& container)
typename TContainer::const_reverse_iterator crend(const TContainer& container)
{
return container.crend();
}
#endif
//*****************************************************************************
/// Get the 'begin' reverse_iterator for an array.

75
include/etl/manchester.h
View File

@ -35,6 +35,8 @@ SOFTWARE.
#include "span.h"
#include "static_assert.h"
#if ETL_USING_CPP11
///\defgroup manchester manchester
/// Manchester encoding and decoding
///\ingroup utilities
@ -51,13 +53,13 @@ namespace etl
struct is_encodable
{
static const bool value =
#if ETL_USING_8BIT_TYPES
#if ETL_USING_8BIT_TYPES
etl::is_same<TChunk, uint8_t>::value ||
#endif
#endif
etl::is_same<TChunk, uint16_t>::value
#if ETL_USING_64BIT_TYPES
#if ETL_USING_64BIT_TYPES
|| etl::is_same<TChunk, uint32_t>::value
#endif
#endif
;
};
@ -69,13 +71,13 @@ namespace etl
struct is_decodable
{
static const bool value =
#if ETL_USING_8BIT_TYPES
#if ETL_USING_8BIT_TYPES
etl::is_same<TChunk, uint16_t>::value ||
#endif
#endif
etl::is_same<TChunk, uint32_t>::value
#if ETL_USING_64BIT_TYPES
#if ETL_USING_64BIT_TYPES
|| etl::is_same<TChunk, uint64_t>::value
#endif
#endif
;
};
@ -91,13 +93,13 @@ namespace etl
ETL_STATIC_ASSERT(sizeof(T) == 0, "Manchester encoding type should be one of [uint8_t, uint16_t, uint32_t]");
};
#if ETL_USING_8BIT_TYPES
#if ETL_USING_8BIT_TYPES
template <>
struct encoded<uint8_t>
{
typedef uint16_t type;
};
#endif
#endif
template <>
struct encoded<uint16_t>
@ -105,13 +107,13 @@ namespace etl
typedef uint32_t type;
};
#if ETL_USING_64BIT_TYPES
#if ETL_USING_64BIT_TYPES
template <>
struct encoded<uint32_t>
{
typedef uint64_t type;
};
#endif
#endif
//*************************************************************************
/// Type trait to determine the decoded type for a given encoded type.
@ -125,13 +127,13 @@ namespace etl
ETL_STATIC_ASSERT(sizeof(T) == 0, "Manchester decoding type should be one of [uint16_t, uint32_t, uint64_t]");
};
#if ETL_USING_64BIT_TYPES
#if ETL_USING_64BIT_TYPES
template <>
struct decoded<uint16_t>
{
typedef uint8_t type;
};
#endif
#endif
template <>
struct decoded<uint32_t>
@ -139,24 +141,24 @@ namespace etl
typedef uint16_t type;
};
#if ETL_USING_64BIT_TYPES
#if ETL_USING_64BIT_TYPES
template <>
struct decoded<uint64_t>
{
typedef uint32_t type;
};
#endif
#endif
//*************************************************************************
/// Normal Manchester encoding type (no inversion).
//*************************************************************************
struct manchester_type_normal
{
#if ETL_USING_64BIT_TYPES
#if ETL_USING_64BIT_TYPES
static const uint64_t inversion_mask = 0x0000000000000000ULL;
#else
#else
static const uint32_t inversion_mask = 0x00000000UL;
#endif
#endif
};
//*************************************************************************
@ -164,11 +166,11 @@ namespace etl
//*************************************************************************
struct manchester_type_inverted
{
#if ETL_USING_64BIT_TYPES
#if ETL_USING_64BIT_TYPES
static const uint64_t inversion_mask = 0xFFFFFFFFFFFFFFFFULL;
#else
#else
static const uint32_t inversion_mask = 0xFFFFFFFFUL;
#endif
#endif
};
//*************************************************************************
@ -247,11 +249,11 @@ namespace etl
ETL_STATIC_ASSERT(CHAR_BIT == etl::numeric_limits<uint_least8_t>::digits,
"Manchester requires uint_least8_t to have the same number of bits as CHAR (CHAR_BITS)");
//*************************************************************************
// Encoding functions
//*************************************************************************
//*************************************************************************
// Encoding functions
//*************************************************************************
#if ETL_USING_8BIT_TYPES
#if ETL_USING_8BIT_TYPES
//*************************************************************************
/// Encode a 8-bit unsigned value and return 16-bit result.
///\param decoded The value to encode.
@ -273,7 +275,7 @@ namespace etl
^ (0xAAAAU ^ static_cast<unsigned int>(TManchesterType::inversion_mask)));
return encoded;
}
#endif
#endif
//*************************************************************************
/// Encode a 16-bit unsigned value and return the 32-bit result.
@ -297,7 +299,7 @@ namespace etl
return encoded;
}
#if ETL_USING_64BIT_TYPES
#if ETL_USING_64BIT_TYPES
//*************************************************************************
/// Encode a 32-bit unsigned value and return the 64-bit result.
///\param decoded The value to encode.
@ -320,7 +322,7 @@ namespace etl
encoded = (encoded | (encoded << 1U)) ^ (0xAAAAAAAAAAAAAAAAULL ^ TManchesterType::inversion_mask);
return encoded;
}
#endif
#endif
//*************************************************************************
/// Encode a span of data with the specified chunk size.
@ -350,11 +352,11 @@ namespace etl
}
}
//*************************************************************************
// Decoding functions
//*************************************************************************
//*************************************************************************
// Decoding functions
//*************************************************************************
#if ETL_USING_8BIT_TYPES
#if ETL_USING_8BIT_TYPES
//*************************************************************************
/// Decode a 16-bit value and return the 8-bit result.
///\param encoded The value to decode.
@ -373,7 +375,7 @@ namespace etl
encoded = static_cast<TEncoded>((static_cast<unsigned int>(encoded) | (static_cast<unsigned int>(encoded) >> 2)) & 0x0F0FU);
return static_cast<TDecoded>(static_cast<unsigned int>(encoded) | (static_cast<unsigned int>(encoded) >> 4U));
}
#endif
#endif
//*************************************************************************
/// Decode a 32-bit value and return the 16-bit result.
@ -394,7 +396,7 @@ namespace etl
return static_cast<TDecoded>(encoded | (encoded >> 8U));
}
#if ETL_USING_64BIT_TYPES
#if ETL_USING_64BIT_TYPES
//*************************************************************************
/// Decode a 64-bit value and return the 32-bit result.
///\param encoded The value to decode.
@ -414,7 +416,7 @@ namespace etl
encoded = (encoded | (encoded >> 8)) & 0x0000FFFF0000FFFFULL;
return static_cast<TDecoded>(encoded | (encoded >> 16U));
}
#endif
#endif
//*************************************************************************
/// Decode a span of data using the specified chunk type.
@ -500,3 +502,4 @@ namespace etl
} // namespace etl
#endif
#endif

111
include/etl/memory.h
View File

@ -1798,6 +1798,117 @@ namespace etl
} // namespace ranges
#endif
#if ETL_USING_CPP11
//*****************************************************************************
/// Trivially relocate a range of objects.
/// This function relocates objects by copying their bytes using memmove.
/// The source objects' lifetimes are ended without calling destructors.
/// Based on C++26 P2786R13.
/// https://en.cppreference.com/w/cpp/memory/trivially_relocate
///\ingroup memory
//*****************************************************************************
template <typename T>
typename etl::enable_if<etl::is_trivially_relocatable<T>::value && !etl::is_const<T>::value, T*>::type trivially_relocate(T* first, T* last,
T* result)
{
if (first == result)
{
return last;
}
const size_t count = static_cast<size_t>(last - first);
if (count > 0)
{
// Use memmove to handle overlapping ranges
::memmove(static_cast<void*>(result), static_cast<const void*>(first), count * sizeof(T));
}
return result + count;
}
//*****************************************************************************
/// Relocate implementation for trivially relocatable types.
/// Delegates to etl::trivially_relocate.
/// Uses SFINAE (enable_if) so that etl::trivially_relocate is never
/// instantiated for non-trivially relocatable types on pre-C++17 compilers,
/// avoiding the ill-formed instantiation that would occur with a plain
/// ETL_IF_CONSTEXPR branch.
///\ingroup memory
//*****************************************************************************
template <typename T>
typename etl::enable_if<etl::is_trivially_relocatable<T>::value, T*>::type relocate_impl(T* first, T* last, T* result)
{
return etl::trivially_relocate(first, last, result);
}
//*****************************************************************************
/// Relocate implementation for non-trivially relocatable types.
/// Uses move construction + destroy.
///\ingroup memory
//*****************************************************************************
template <typename T>
typename etl::enable_if<!etl::is_trivially_relocatable<T>::value, T*>::type relocate_impl(T* first, T* last, T* result)
{
const ptrdiff_t count = last - first;
// Check if ranges overlap and handle accordingly
if (result < first || result >= last)
{
// No overlap or destination is after source - iterate forward
T* src = first;
T* dst = result;
while (src != last)
{
::new (static_cast<void*>(dst)) T(etl::move(*src));
src->~T();
++src;
++dst;
}
}
else
{
// Destination overlaps with source from below - iterate backward
T* src = last;
T* dst = result + count;
while (src != first)
{
--src;
--dst;
::new (static_cast<void*>(dst)) T(etl::move(*src));
src->~T();
}
}
return result + count;
}
//*****************************************************************************
/// Relocate a range of objects.
/// For trivially relocatable types, uses trivially_relocate via relocate_impl.
/// For other nothrow relocatable types, uses move + destroy via relocate_impl.
/// Delegates to SFINAE-guarded relocate_impl overloads instead of using
/// ETL_IF_CONSTEXPR, so that etl::trivially_relocate is never instantiated
/// for non-trivially relocatable types on pre-C++17 compilers.
/// Based on C++26 P2786R13.
/// https://en.cppreference.com/w/cpp/memory/relocate
///\ingroup memory
//*****************************************************************************
template <typename T>
typename etl::enable_if<etl::is_nothrow_relocatable<T>::value && !etl::is_const<T>::value, T*>::type relocate(T* first, T* last, T* result)
{
// Handle trivial relocation case
if (first == result || first == last)
{
return (first == result) ? last : result;
}
// SFINAE on etl::is_trivially_relocatable<T> selects the correct overload
// so that etl::trivially_relocate is only instantiated when valid.
return relocate_impl(first, last, result);
}
#endif
//*****************************************************************************
/// Default deleter.
///\tparam T The pointed to type type.

288
include/etl/numeric.h
View File

@ -130,11 +130,11 @@ namespace etl
{
if (a > b)
{
return b + (etl::distance(b, a) / 2U);
return b + (etl::distance(b, a) / 2);
}
else
{
return a + (etl::distance(a, b) / 2U);
return a + (etl::distance(a, b) / 2);
}
}
@ -151,11 +151,11 @@ namespace etl
{
if (a > b)
{
return b + (etl::distance(b, a) / 2U);
return b + (etl::distance(b, a) / 2);
}
else
{
return a + (etl::distance(a, b) / 2U);
return a + (etl::distance(a, b) / 2);
}
}
@ -172,7 +172,7 @@ namespace etl
|| etl::is_same<typename etl::iterator_traits<T>::iterator_category, ETL_OR_STD::bidirectional_iterator_tag>::value)),
int>::type = 0)
{
etl::advance(a, etl::distance(a, b) / 2U);
etl::advance(a, etl::distance(a, b) / 2);
return a;
}
@ -204,6 +204,284 @@ namespace etl
return typecast_a(a) + (typecast_t(t) * (typecast_b(b) - typecast_a(a)));
}
//***************************************************************************
/// Saturating addition for unsigned integers.
/// Returns x + y, clamped to the range of T.
//***************************************************************************
template <typename T>
ETL_CONSTEXPR14 typename etl::enable_if<etl::is_integral<T>::value && etl::is_unsigned<T>::value, T>::type add_sat(T x, T y) ETL_NOEXCEPT
{
T result = static_cast<T>(x + y);
// Overflow occurred if result < x
if (result < x)
{
return etl::numeric_limits<T>::max();
}
return result;
}
//***************************************************************************
/// Saturating addition for signed integers.
/// Returns x + y, clamped to the range of T.
//***************************************************************************
template <typename T>
ETL_CONSTEXPR14 typename etl::enable_if<etl::is_integral<T>::value && etl::is_signed<T>::value, T>::type add_sat(T x, T y) ETL_NOEXCEPT
{
// Check for overflow: both operands have same sign and result has different sign
if (y > T(0))
{
// Positive overflow check
if (x > (etl::numeric_limits<T>::max() - y))
{
return etl::numeric_limits<T>::max();
}
}
else
{
// Negative overflow check
if (x < (etl::numeric_limits<T>::min() - y))
{
return etl::numeric_limits<T>::min();
}
}
return static_cast<T>(x + y);
}
//***************************************************************************
/// Saturating subtraction for unsigned integers.
/// Returns x - y, clamped to the range of T.
//***************************************************************************
template <typename T>
ETL_CONSTEXPR14 typename etl::enable_if<etl::is_integral<T>::value && etl::is_unsigned<T>::value, T>::type sub_sat(T x, T y) ETL_NOEXCEPT
{
// Underflow occurred if y > x
if (y > x)
{
return T(0);
}
return static_cast<T>(x - y);
}
//***************************************************************************
/// Saturating subtraction for signed integers.
/// Returns x - y, clamped to the range of T.
//***************************************************************************
template <typename T>
ETL_CONSTEXPR14 typename etl::enable_if<etl::is_integral<T>::value && etl::is_signed<T>::value, T>::type sub_sat(T x, T y) ETL_NOEXCEPT
{
// Check for overflow/underflow
if (y > T(0))
{
// Subtracting positive: check for underflow
if (x < (etl::numeric_limits<T>::min() + y))
{
return etl::numeric_limits<T>::min();
}
}
else
{
// Subtracting negative (adding): check for overflow
if (x > (etl::numeric_limits<T>::max() + y))
{
return etl::numeric_limits<T>::max();
}
}
return static_cast<T>(x - y);
}
//***************************************************************************
/// Saturating multiplication for unsigned integers.
/// Returns x * y, clamped to the range of T.
//***************************************************************************
template <typename T>
ETL_CONSTEXPR14 typename etl::enable_if<etl::is_integral<T>::value && etl::is_unsigned<T>::value, T>::type mul_sat(T x, T y) ETL_NOEXCEPT
{
if ((x == T(0)) || (y == T(0)))
{
return T(0);
}
// Check for overflow: x * y > max => x > max / y
if (x > (etl::numeric_limits<T>::max() / y))
{
return etl::numeric_limits<T>::max();
}
return static_cast<T>(x * y);
}
//***************************************************************************
/// Saturating multiplication for signed integers.
/// Returns x * y, clamped to the range of T.
//***************************************************************************
template <typename T>
ETL_CONSTEXPR14 typename etl::enable_if<etl::is_integral<T>::value && etl::is_signed<T>::value, T>::type mul_sat(T x, T y) ETL_NOEXCEPT
{
if ((x == T(0)) || (y == T(0)))
{
return T(0);
}
// Both positive
if ((x > T(0)) && (y > T(0)))
{
if (x > (etl::numeric_limits<T>::max() / y))
{
return etl::numeric_limits<T>::max();
}
}
// Both negative
else if ((x < T(0)) && (y < T(0)))
{
if (x < (etl::numeric_limits<T>::max() / y))
{
return etl::numeric_limits<T>::max();
}
}
// Different signs (x positive, y negative)
else if ((x > T(0)) && (y < T(0)))
{
if (y < (etl::numeric_limits<T>::min() / x))
{
return etl::numeric_limits<T>::min();
}
}
// Different signs (x negative, y positive)
else
{
if (x < (etl::numeric_limits<T>::min() / y))
{
return etl::numeric_limits<T>::min();
}
}
return static_cast<T>(x * y);
}
//***************************************************************************
/// Saturating division for unsigned integers.
/// Returns x / y. For unsigned types, no saturation is needed.
/// \pre y != 0 (undefined behaviour if y is zero, matching C++26).
//***************************************************************************
template <typename T>
ETL_CONSTEXPR14 typename etl::enable_if<etl::is_integral<T>::value && etl::is_unsigned<T>::value, T>::type div_sat(T x, T y) ETL_NOEXCEPT
{
return static_cast<T>(x / y);
}
//***************************************************************************
/// Saturating division for signed integers.
/// Returns x / y, clamped to the range of T.
/// The only case of overflow is min / -1.
/// \pre y != 0 (undefined behaviour if y is zero, matching C++26).
//***************************************************************************
template <typename T>
ETL_CONSTEXPR14 typename etl::enable_if<etl::is_integral<T>::value && etl::is_signed<T>::value, T>::type div_sat(T x, T y) ETL_NOEXCEPT
{
// The only overflow case: min / -1 would be max + 1
if ((x == etl::numeric_limits<T>::min()) && (y == T(-1)))
{
return etl::numeric_limits<T>::max();
}
return static_cast<T>(x / y);
}
//***************************************************************************
/// saturate_cast
/// Converts an integer value to another integer type, clamping the value
/// to the representable range of the destination type.
/// C++26 equivalent of std::saturate_cast.
///
/// When the source value is within the range of R, returns the value as R.
/// When the source value is below R's minimum, returns numeric_limits<R>::min().
/// When the source value is above R's maximum, returns numeric_limits<R>::max().
//***************************************************************************
// Case 1: Both unsigned.
template <typename R, typename T>
ETL_CONSTEXPR14
typename etl::enable_if<etl::is_integral<R>::value && etl::is_integral<T>::value && etl::is_unsigned<R>::value && etl::is_unsigned<T>::value,
R>::type
saturate_cast(T value) ETL_NOEXCEPT
{
// If sizeof(R) >= sizeof(T), all values of T fit in R.
// If sizeof(R) < sizeof(T), clamp to R's max. The comparison is safe
// because R's max fits in T when T is wider.
if ((sizeof(R) < sizeof(T)) && (value > static_cast<T>(etl::numeric_limits<R>::max())))
{
return etl::numeric_limits<R>::max();
}
return static_cast<R>(value);
}
// Case 2: Both signed.
template <typename R, typename T>
ETL_CONSTEXPR14
typename etl::enable_if<etl::is_integral<R>::value && etl::is_integral<T>::value && etl::is_signed<R>::value && etl::is_signed<T>::value, R>::type
saturate_cast(T value) ETL_NOEXCEPT
{
// Only need to clamp when narrowing (R is smaller than T).
// When sizeof(R) >= sizeof(T), all values of T fit in R.
if (sizeof(R) < sizeof(T))
{
if (value > static_cast<T>(etl::numeric_limits<R>::max()))
{
return etl::numeric_limits<R>::max();
}
if (value < static_cast<T>(etl::numeric_limits<R>::min()))
{
return etl::numeric_limits<R>::min();
}
}
return static_cast<R>(value);
}
// Case 3: Signed source -> Unsigned destination.
template <typename R, typename T>
ETL_CONSTEXPR14
typename etl::enable_if<etl::is_integral<R>::value && etl::is_integral<T>::value && etl::is_unsigned<R>::value && etl::is_signed<T>::value,
R>::type
saturate_cast(T value) ETL_NOEXCEPT
{
if (value < T(0))
{
return R(0);
}
typedef typename etl::make_unsigned<T>::type unsigned_t;
unsigned_t uvalue = static_cast<unsigned_t>(value);
// Compare in unsigned domain. R's max is always representable as unsigned_t
// when sizeof(T) > sizeof(R), and when sizeof(R) >= sizeof(T) all positive
// values of T fit in R.
if ((sizeof(R) < sizeof(T)) && (uvalue > static_cast<unsigned_t>(etl::numeric_limits<R>::max())))
{
return etl::numeric_limits<R>::max();
}
return static_cast<R>(value);
}
// Case 4: Unsigned source -> Signed destination.
template <typename R, typename T>
ETL_CONSTEXPR14
typename etl::enable_if<etl::is_integral<R>::value && etl::is_integral<T>::value && etl::is_signed<R>::value && etl::is_unsigned<T>::value,
R>::type
saturate_cast(T value) ETL_NOEXCEPT
{
// R's max is positive, so we can safely represent it as T (unsigned) when
// sizeof(T) >= sizeof(R). When sizeof(T) < sizeof(R), all values of T fit.
typedef typename etl::make_unsigned<R>::type unsigned_r;
if (value > static_cast<T>(static_cast<unsigned_r>(etl::numeric_limits<R>::max())))
{
return etl::numeric_limits<R>::max();
}
return static_cast<R>(value);
}
} // namespace etl
#endif

113
include/etl/optional.h
View File

@ -127,7 +127,7 @@ namespace etl
/// Constructor.
//***************************************************************************
ETL_CONSTEXPR20_STL
optional_impl()
optional_impl() ETL_NOEXCEPT
: storage()
{
}
@ -136,7 +136,7 @@ namespace etl
/// Constructor with nullopt.
//***************************************************************************
ETL_CONSTEXPR20_STL
optional_impl(etl::nullopt_t)
optional_impl(etl::nullopt_t) ETL_NOEXCEPT
: storage()
{
}
@ -146,7 +146,7 @@ namespace etl
/// Copy constructor.
//***************************************************************************
ETL_CONSTEXPR20_STL
optional_impl(const optional_impl<T>& other)
optional_impl(const optional_impl<T>& other) ETL_NOEXCEPT_IF(etl::is_nothrow_copy_constructible<T>::value)
{
if (other.has_value())
{
@ -160,7 +160,7 @@ namespace etl
/// Move constructor.
//***************************************************************************
ETL_CONSTEXPR20_STL
optional_impl(optional_impl<T>&& other)
optional_impl(optional_impl<T>&& other) ETL_NOEXCEPT_IF(etl::is_nothrow_move_constructible<T>::value)
{
if (other.has_value())
{
@ -177,7 +177,7 @@ namespace etl
typename etl::enable_if< etl::is_constructible<T, U&&>::value && !etl::is_same<typename etl::decay<U>::type, etl::in_place_t>::value
&& !etl::is_same<typename etl::decay<U>::type, optional_impl>::value,
int>::type = 0>
ETL_CONSTEXPR20_STL optional_impl(U&& value_)
ETL_CONSTEXPR20_STL optional_impl(U&& value_) ETL_NOEXCEPT_IF((etl::is_nothrow_constructible<T, U&&>::value))
{
storage.construct(etl::forward<U>(value_));
}
@ -186,7 +186,7 @@ namespace etl
/// Constructor from variadic args.
//***************************************************************************
template <typename... TArgs>
ETL_CONSTEXPR20_STL optional_impl(etl::in_place_t, TArgs&&... args)
ETL_CONSTEXPR20_STL optional_impl(etl::in_place_t, TArgs&&... args) ETL_NOEXCEPT_IF((etl::is_nothrow_constructible<T, TArgs...>::value))
{
storage.construct(etl::forward<TArgs>(args)...);
}
@ -197,6 +197,7 @@ namespace etl
//*******************************************
template <typename U, typename... TArgs >
ETL_CONSTEXPR20_STL optional_impl(etl::in_place_t, std::initializer_list<U> ilist, TArgs&&... args)
ETL_NOEXCEPT_IF((etl::is_nothrow_constructible<T, std::initializer_list<U>, TArgs...>::value))
{
storage.construct(ilist, etl::forward<TArgs>(args)...);
}
@ -207,7 +208,7 @@ namespace etl
/// Destructor.
//***************************************************************************
ETL_CONSTEXPR20_STL
~optional_impl()
~optional_impl() ETL_NOEXCEPT
{
storage.destroy();
}
@ -216,7 +217,7 @@ namespace etl
/// Assignment operator from nullopt.
//***************************************************************************
ETL_CONSTEXPR20_STL
optional_impl& operator=(etl::nullopt_t)
optional_impl& operator=(etl::nullopt_t) ETL_NOEXCEPT
{
if (has_value())
{
@ -230,7 +231,7 @@ namespace etl
/// Assignment operator from optional_impl.
//***************************************************************************
ETL_CONSTEXPR20_STL
optional_impl& operator=(const optional_impl<T>& other)
optional_impl& operator=(const optional_impl<T>& other) ETL_NOEXCEPT_IF(etl::is_nothrow_copy_constructible<T>::value)
{
if (this != &other)
{
@ -252,7 +253,7 @@ namespace etl
/// Assignment operator from optional_impl.
//***************************************************************************
ETL_CONSTEXPR20_STL
optional_impl& operator=(optional_impl&& other)
optional_impl& operator=(optional_impl&& other) ETL_NOEXCEPT_IF(etl::is_nothrow_move_constructible<T>::value)
{
if (this != &other)
{
@ -277,7 +278,7 @@ namespace etl
template <typename U,
typename etl::enable_if< etl::is_constructible<T, U&&>::value && !etl::is_same<typename etl::decay<U>::type, optional_impl>::value,
int>::type = 0>
ETL_CONSTEXPR20_STL optional_impl& operator=(U&& value_)
ETL_CONSTEXPR20_STL optional_impl& operator=(U&& value_) ETL_NOEXCEPT_IF((etl::is_nothrow_constructible<T, U&&>::value))
{
storage.construct(etl::forward<U>(value_));
@ -488,7 +489,7 @@ namespace etl
/// Reset back to invalid.
//***************************************************************************
ETL_CONSTEXPR20_STL
void reset()
void reset() ETL_NOEXCEPT
{
storage.destroy();
}
@ -518,7 +519,7 @@ namespace etl
template < typename U, typename... URest,
typename etl::enable_if<
!etl::is_base_of< optional_impl, typename etl::remove_cv< typename etl::remove_reference<U>::type>::type>::value, int>::type = 0>
ETL_CONSTEXPR20_STL T& emplace(U&& first, URest&&... rest)
ETL_CONSTEXPR20_STL T& emplace(U&& first, URest&&... rest) ETL_NOEXCEPT_IF((etl::is_nothrow_constructible<T, U&&, URest...>::value))
{
storage.construct(etl::forward<U>(first), etl::forward<URest>(rest)...);
@ -529,7 +530,7 @@ namespace etl
/// Emplaces with zero arguments, i.e. default construct emplace.
//*************************************************************************
ETL_CONSTEXPR20_STL
T& emplace()
T& emplace() ETL_NOEXCEPT_IF(etl::is_nothrow_default_constructible<T>::value)
{
storage.construct();
@ -735,7 +736,7 @@ namespace etl
//***************************************************************************
/// Constructor.
//***************************************************************************
ETL_CONSTEXPR14 optional_impl()
ETL_CONSTEXPR14 optional_impl() ETL_NOEXCEPT
: storage()
{
}
@ -743,7 +744,7 @@ namespace etl
//***************************************************************************
/// Constructor with nullopt.
//***************************************************************************
ETL_CONSTEXPR14 optional_impl(etl::nullopt_t)
ETL_CONSTEXPR14 optional_impl(etl::nullopt_t) ETL_NOEXCEPT
: storage()
{
}
@ -752,7 +753,7 @@ namespace etl
//***************************************************************************
/// Copy constructor.
//***************************************************************************
ETL_CONSTEXPR14 optional_impl(const optional_impl<T>& other)
ETL_CONSTEXPR14 optional_impl(const optional_impl<T>& other) ETL_NOEXCEPT
{
if (other.has_value())
{
@ -765,7 +766,7 @@ namespace etl
//***************************************************************************
/// Move constructor.
//***************************************************************************
ETL_CONSTEXPR14 optional_impl(optional_impl&& other)
ETL_CONSTEXPR14 optional_impl(optional_impl&& other) ETL_NOEXCEPT
{
if (other.has_value())
{
@ -776,7 +777,7 @@ namespace etl
//***************************************************************************
/// Constructor from value type.
//***************************************************************************
ETL_CONSTEXPR14 optional_impl(const T& value_)
ETL_CONSTEXPR14 optional_impl(const T& value_) ETL_NOEXCEPT
{
storage.construct(value_);
}
@ -784,7 +785,7 @@ namespace etl
//***************************************************************************
/// Constructor from value type.
//***************************************************************************
ETL_CONSTEXPR14 optional_impl(T&& value_)
ETL_CONSTEXPR14 optional_impl(T&& value_) ETL_NOEXCEPT
{
storage.construct(etl::move(value_));
}
@ -793,7 +794,7 @@ namespace etl
/// Constructor from variadic args.
//***************************************************************************
template <typename... TArgs>
ETL_CONSTEXPR14 optional_impl(etl::in_place_t, TArgs&&... args)
ETL_CONSTEXPR14 optional_impl(etl::in_place_t, TArgs&&... args) ETL_NOEXCEPT
{
storage.construct(etl::forward<TArgs>(args)...);
}
@ -803,7 +804,7 @@ namespace etl
/// Construct from initializer_list and arguments.
//*******************************************
template <typename U, typename... TArgs >
ETL_CONSTEXPR14 optional_impl(etl::in_place_t, std::initializer_list<U> ilist, TArgs&&... args)
ETL_CONSTEXPR14 optional_impl(etl::in_place_t, std::initializer_list<U> ilist, TArgs&&... args) ETL_NOEXCEPT
{
storage.construct(ilist, etl::forward<TArgs>(args)...);
}
@ -813,7 +814,7 @@ namespace etl
//***************************************************************************
/// Assignment operator from nullopt.
//***************************************************************************
ETL_CONSTEXPR14 optional_impl& operator=(etl::nullopt_t)
ETL_CONSTEXPR14 optional_impl& operator=(etl::nullopt_t) ETL_NOEXCEPT
{
if (has_value())
{
@ -826,7 +827,7 @@ namespace etl
//***************************************************************************
/// Assignment operator from optional_impl.
//***************************************************************************
ETL_CONSTEXPR14 optional_impl& operator=(const optional_impl<T>& other)
ETL_CONSTEXPR14 optional_impl& operator=(const optional_impl<T>& other) ETL_NOEXCEPT
{
if (this != &other)
{
@ -847,7 +848,7 @@ namespace etl
//***************************************************************************
/// Assignment operator from optional_impl.
//***************************************************************************
ETL_CONSTEXPR14 optional_impl& operator=(optional_impl&& other)
ETL_CONSTEXPR14 optional_impl& operator=(optional_impl&& other) ETL_NOEXCEPT
{
if (this != &other)
{
@ -868,7 +869,7 @@ namespace etl
//***************************************************************************
/// Assignment operator from value type.
//***************************************************************************
ETL_CONSTEXPR14 optional_impl& operator=(const T& value_)
ETL_CONSTEXPR14 optional_impl& operator=(const T& value_) ETL_NOEXCEPT
{
storage.construct(value_);
@ -879,7 +880,7 @@ namespace etl
//***************************************************************************
/// Assignment operator from value type.
//***************************************************************************
ETL_CONSTEXPR14 optional_impl& operator=(T&& value_)
ETL_CONSTEXPR14 optional_impl& operator=(T&& value_) ETL_NOEXCEPT
{
storage.construct(etl::move(value_));
@ -1058,7 +1059,7 @@ namespace etl
//***************************************************************************
/// Swaps this value with another.
//***************************************************************************
ETL_CONSTEXPR14 void swap(optional_impl& other)
ETL_CONSTEXPR14 void swap(optional_impl& other) ETL_NOEXCEPT
{
optional_impl temp(*this);
*this = other;
@ -1068,7 +1069,7 @@ namespace etl
//***************************************************************************
/// Reset back to invalid.
//***************************************************************************
ETL_CONSTEXPR14 void reset()
ETL_CONSTEXPR14 void reset() ETL_NOEXCEPT
{
storage.destroy();
}
@ -1094,7 +1095,7 @@ namespace etl
///\param args The arguments to construct with.
//*************************************************************************
template <typename... TArgs>
ETL_CONSTEXPR14 T& emplace(TArgs&&... args)
ETL_CONSTEXPR14 T& emplace(TArgs&&... args) ETL_NOEXCEPT
{
storage.construct(etl::forward<TArgs>(args)...);
@ -1286,7 +1287,7 @@ namespace etl
/// Constructor.
//***************************************************************************
template <typename U = T, ETL_OPTIONAL_ENABLE_CPP14>
ETL_CONSTEXPR14 optional()
ETL_CONSTEXPR14 optional() ETL_NOEXCEPT
: impl_t()
{
}
@ -1295,12 +1296,12 @@ namespace etl
/// Constructor.
//***************************************************************************
template <typename U = T, ETL_OPTIONAL_ENABLE_CPP20_STL>
ETL_CONSTEXPR20_STL optional()
ETL_CONSTEXPR20_STL optional() ETL_NOEXCEPT
: impl_t()
{
}
#else
optional()
optional() ETL_NOEXCEPT
: impl_t()
{
}
@ -1311,7 +1312,7 @@ namespace etl
/// Constructor with nullopt.
//***************************************************************************
template <typename U = T, ETL_OPTIONAL_ENABLE_CPP14>
ETL_CONSTEXPR14 optional(etl::nullopt_t)
ETL_CONSTEXPR14 optional(etl::nullopt_t) ETL_NOEXCEPT
: impl_t(etl::nullopt)
{
}
@ -1320,7 +1321,7 @@ namespace etl
/// Constructor with nullopt.
//***************************************************************************
template <typename U = T, ETL_OPTIONAL_ENABLE_CPP20_STL>
ETL_CONSTEXPR20_STL optional(etl::nullopt_t)
ETL_CONSTEXPR20_STL optional(etl::nullopt_t) ETL_NOEXCEPT
: impl_t(etl::nullopt)
{
}
@ -1328,7 +1329,7 @@ namespace etl
//***************************************************************************
/// Constructor with nullopt.
//***************************************************************************
optional(etl::nullopt_t)
optional(etl::nullopt_t) ETL_NOEXCEPT
: impl_t(etl::nullopt)
{
}
@ -1340,7 +1341,7 @@ namespace etl
/// Copy constructor.
//***************************************************************************
template <typename U = T, ETL_OPTIONAL_ENABLE_CPP14>
ETL_CONSTEXPR14 optional(const optional& other)
ETL_CONSTEXPR14 optional(const optional& other) ETL_NOEXCEPT_IF(etl::is_nothrow_copy_constructible<T>::value)
: impl_t(other)
{
}
@ -1349,7 +1350,7 @@ namespace etl
/// Copy constructor.
//***************************************************************************
template <typename U = T, ETL_OPTIONAL_ENABLE_CPP20_STL>
ETL_CONSTEXPR20_STL optional(const optional& other)
ETL_CONSTEXPR20_STL optional(const optional& other) ETL_NOEXCEPT_IF(etl::is_nothrow_copy_constructible<T>::value)
: impl_t(other)
{
}
@ -1369,8 +1370,8 @@ namespace etl
/// Move constructor.
//***************************************************************************
template <typename U = T, ETL_OPTIONAL_ENABLE_CPP14>
ETL_CONSTEXPR14 optional(optional&& other)
: impl_t(other)
ETL_CONSTEXPR14 optional(optional&& other) ETL_NOEXCEPT_IF(etl::is_nothrow_move_constructible<T>::value)
: impl_t(etl::move(other))
{
}
@ -1378,8 +1379,8 @@ namespace etl
/// Move constructor.
//***************************************************************************
template <typename U = T, ETL_OPTIONAL_ENABLE_CPP20_STL>
ETL_CONSTEXPR20_STL optional(optional&& other)
: impl_t(other)
ETL_CONSTEXPR20_STL optional(optional&& other) ETL_NOEXCEPT_IF(etl::is_nothrow_move_constructible<T>::value)
: impl_t(etl::move(other))
{
}
#endif
@ -1396,7 +1397,7 @@ namespace etl
&& !etl::is_same<typename etl::decay<U>::type, etl::nullopt_t>::value
&& etl::is_pod<typename etl::remove_cv<T>::type>::value,
int>::type = 0>
ETL_CONSTEXPR14 optional(U&& value_)
ETL_CONSTEXPR14 optional(U&& value_) ETL_NOEXCEPT_IF((etl::is_nothrow_constructible<T, U&&>::value))
: impl_t(etl::forward<U>(value_))
{
}
@ -1410,7 +1411,7 @@ namespace etl
&& !etl::is_same<typename etl::decay<U>::type, etl::nullopt_t>::value
&& !etl::is_pod<typename etl::remove_cv<T>::type>::value,
int>::type = 0>
ETL_CONSTEXPR20_STL optional(U&& value_)
ETL_CONSTEXPR20_STL optional(U&& value_) ETL_NOEXCEPT_IF((etl::is_nothrow_constructible<T, U&&>::value))
: impl_t(etl::forward<U>(value_))
{
}
@ -1429,7 +1430,7 @@ namespace etl
/// Emplace construct from arguments.
//***************************************************************************
template <typename U = T, ETL_OPTIONAL_ENABLE_CPP14, typename... Args>
ETL_CONSTEXPR14 explicit optional(etl::in_place_t, Args&&... args)
ETL_CONSTEXPR14 explicit optional(etl::in_place_t, Args&&... args) ETL_NOEXCEPT_IF((etl::is_nothrow_constructible<T, Args...>::value))
: impl_t(etl::in_place_t{}, etl::forward<Args>(args)...)
{
}
@ -1438,7 +1439,7 @@ namespace etl
/// Emplace construct from arguments.
//***************************************************************************
template <typename U = T, ETL_OPTIONAL_ENABLE_CPP20_STL, typename... Args>
ETL_CONSTEXPR20_STL explicit optional(etl::in_place_t, Args&&... args)
ETL_CONSTEXPR20_STL explicit optional(etl::in_place_t, Args&&... args) ETL_NOEXCEPT_IF((etl::is_nothrow_constructible<T, Args...>::value))
: impl_t(etl::in_place_t{}, etl::forward<Args>(args)...)
{
}
@ -1449,6 +1450,7 @@ namespace etl
//*******************************************
template <typename U = T, ETL_OPTIONAL_ENABLE_CPP14, typename... TArgs>
ETL_CONSTEXPR14 explicit optional(etl::in_place_t, std::initializer_list<U> ilist, TArgs&&... args)
ETL_NOEXCEPT_IF((etl::is_nothrow_constructible<T, std::initializer_list<U>, TArgs...>::value))
: impl_t(etl::in_place_t{}, ilist, etl::forward<TArgs>(args)...)
{
}
@ -1458,6 +1460,7 @@ namespace etl
//*******************************************
template <typename U = T, ETL_OPTIONAL_ENABLE_CPP20_STL, typename... TArgs>
ETL_CONSTEXPR20_STL explicit optional(etl::in_place_t, std::initializer_list<U> ilist, TArgs&&... args)
ETL_NOEXCEPT_IF((etl::is_nothrow_constructible<T, std::initializer_list<U>, TArgs...>::value))
: impl_t(etl::in_place_t{}, ilist, etl::forward<TArgs>(args)...)
{
}
@ -1469,7 +1472,7 @@ namespace etl
/// Assignment operator from nullopt.
//***************************************************************************
template <typename U = T, ETL_OPTIONAL_ENABLE_CPP14>
ETL_CONSTEXPR14 optional& operator=(etl::nullopt_t)
ETL_CONSTEXPR14 optional& operator=(etl::nullopt_t) ETL_NOEXCEPT
{
impl_t::operator=(etl::nullopt);
@ -1480,7 +1483,7 @@ namespace etl
/// Assignment operator from nullopt.
//***************************************************************************
template <typename U = T, ETL_OPTIONAL_ENABLE_CPP20_STL>
ETL_CONSTEXPR20_STL optional& operator=(etl::nullopt_t)
ETL_CONSTEXPR20_STL optional& operator=(etl::nullopt_t) ETL_NOEXCEPT
{
impl_t::operator=(etl::nullopt);
@ -1490,7 +1493,7 @@ namespace etl
//***************************************************************************
/// Assignment operator from nullopt.
//***************************************************************************
optional& operator=(etl::nullopt_t)
optional& operator=(etl::nullopt_t) ETL_NOEXCEPT
{
impl_t::operator=(etl::nullopt);
@ -1503,7 +1506,7 @@ namespace etl
/// Assignment operator from optional.
//***************************************************************************
template <typename U = T, ETL_OPTIONAL_ENABLE_CPP14>
ETL_CONSTEXPR14 optional& operator=(const optional& other)
ETL_CONSTEXPR14 optional& operator=(const optional& other) ETL_NOEXCEPT_IF(etl::is_nothrow_copy_constructible<T>::value)
{
impl_t::operator=(other);
@ -1514,7 +1517,7 @@ namespace etl
/// Assignment operator from optional.
//***************************************************************************
template <typename U = T, ETL_OPTIONAL_ENABLE_CPP20_STL>
ETL_CONSTEXPR20_STL optional& operator=(const optional& other)
ETL_CONSTEXPR20_STL optional& operator=(const optional& other) ETL_NOEXCEPT_IF(etl::is_nothrow_copy_constructible<T>::value)
{
impl_t::operator=(other);
@ -1537,7 +1540,7 @@ namespace etl
/// Move assignment operator from optional.
//***************************************************************************
template <typename U = T, ETL_OPTIONAL_ENABLE_CPP14>
ETL_CONSTEXPR14 optional& operator=(optional&& other)
ETL_CONSTEXPR14 optional& operator=(optional&& other) ETL_NOEXCEPT_IF(etl::is_nothrow_move_constructible<T>::value)
{
impl_t::operator=(etl::move(other));
@ -1548,7 +1551,7 @@ namespace etl
/// Move assignment operator from optional.
//***************************************************************************
template <typename U = T, ETL_OPTIONAL_ENABLE_CPP20_STL>
ETL_CONSTEXPR20_STL optional& operator=(optional&& other)
ETL_CONSTEXPR20_STL optional& operator=(optional&& other) ETL_NOEXCEPT_IF(etl::is_nothrow_move_constructible<T>::value)
{
impl_t::operator=(etl::move(other));
@ -1565,7 +1568,7 @@ namespace etl
&& !etl::is_same<typename etl::decay<U>::type, etl::nullopt_t>::value
&& etl::is_pod<typename etl::remove_cv<T>::type>::value,
int>::type = 0>
ETL_CONSTEXPR14 optional& operator=(U&& value_)
ETL_CONSTEXPR14 optional& operator=(U&& value_) ETL_NOEXCEPT_IF((etl::is_nothrow_constructible<T, U&&>::value))
{
impl_t::operator=(etl::forward<U>(value_));
@ -1580,7 +1583,7 @@ namespace etl
&& !etl::is_same<typename etl::decay<U>::type, etl::nullopt_t>::value
&& !etl::is_pod<typename etl::remove_cv<T>::type>::value,
int>::type = 0>
ETL_CONSTEXPR20_STL optional& operator=(U&& value_)
ETL_CONSTEXPR20_STL optional& operator=(U&& value_) ETL_NOEXCEPT_IF((etl::is_nothrow_constructible<T, U&&>::value))
{
impl_t::operator=(etl::forward<U>(value_));

6
include/etl/parameter_pack.h
View File

@ -34,11 +34,7 @@ SOFTWARE.
#include <stdint.h>
#if ETL_CPP11_NOT_SUPPORTED
#if !defined(ETL_IN_UNIT_TEST)
#error NOT SUPPORTED FOR C++03 OR BELOW
#endif
#else
#if ETL_CPP11_SUPPORTED
namespace etl
{
//***************************************************************************

16
include/etl/platform.h
View File

@ -489,6 +489,18 @@ SOFTWARE.
#define ETL_ASSUME ETL_DO_NOTHING
#endif
//*************************************
// C++26
#if defined(__has_cpp_attribute)
#if __has_cpp_attribute(indeterminate)
#define ETL_INDETERMINATE [[indeterminate]]
#else
#define ETL_INDETERMINATE
#endif
#else
#define ETL_INDETERMINATE
#endif
//*************************************
// Determine if the ETL can use char8_t type.
#if ETL_NO_SMALL_CHAR_SUPPORT
@ -650,6 +662,7 @@ namespace etl
static ETL_CONSTANT bool using_cpp17 = (ETL_USING_CPP17 == 1);
static ETL_CONSTANT bool using_cpp20 = (ETL_USING_CPP20 == 1);
static ETL_CONSTANT bool using_cpp23 = (ETL_USING_CPP23 == 1);
static ETL_CONSTANT bool using_cpp26 = (ETL_USING_CPP26 == 1);
static ETL_CONSTANT bool using_gcc_compiler = (ETL_USING_GCC_COMPILER == 1);
static ETL_CONSTANT bool using_microsoft_compiler = (ETL_USING_MICROSOFT_COMPILER == 1);
static ETL_CONSTANT bool using_arm5_compiler = (ETL_USING_ARM5_COMPILER == 1);
@ -697,6 +710,9 @@ namespace etl
static ETL_CONSTANT bool has_chrono_literals_microseconds = (ETL_HAS_CHRONO_LITERALS_DURATION == 1);
static ETL_CONSTANT bool has_chrono_literals_nanoseconds = (ETL_HAS_CHRONO_LITERALS_DURATION == 1);
static ETL_CONSTANT bool has_std_byteswap = (ETL_HAS_STD_BYTESWAP == 1);
static ETL_CONSTANT bool has_std_is_virtual_base_of = (ETL_HAS_STD_IS_VIRTUAL_BASE_OF == 1);
static ETL_CONSTANT bool has_std_trivially_relocatable = (ETL_HAS_STD_TRIVIALLY_RELOCATABLE == 1);
static ETL_CONSTANT bool has_std_atomic_min_max = (ETL_HAS_STD_ATOMIC_MIN_MAX == 1);
static ETL_CONSTANT bool has_noexcept_function_type = (ETL_HAS_NOEXCEPT_FUNCTION_TYPE == 1);
// Is...

2
include/etl/priority_queue.h
View File

@ -439,7 +439,9 @@ namespace etl
//*************************************************************************
void clone(const ipriority_queue& other)
{
#include "etl/private/diagnostic_uninitialized_push.h"
assign(other.container.cbegin(), other.container.cend());
#include "etl/private/diagnostic_pop.h"
}
#if ETL_USING_CPP11

12
include/etl/private/bitset_new.h
View File

@ -1078,7 +1078,7 @@ namespace etl
/// Extract an value from multiple elements.
//*************************************************************************
template <typename T>
static ETL_CONSTEXPR14 typename etl::make_unsigned<T>::type extract_from_multiple_elements(const element_type* pbuffer, int element_index,
static ETL_CONSTEXPR14 typename etl::make_unsigned<T>::type extract_from_multiple_elements(const element_type* pbuffer, size_t element_index,
size_t active_bits_in_msb, size_t length) ETL_NOEXCEPT
{
typedef typename etl::make_unsigned<T>::type unsigned_t;
@ -1133,8 +1133,8 @@ namespace etl
unsigned_t value(0);
const int Msb_Element_Index = (position + length - 1) >> etl::log2<Bits_Per_Element>::value;
const int Lsb_Element_Index = position >> etl::log2<Bits_Per_Element>::value;
const size_t Msb_Element_Index = (position + length - 1) >> etl::log2<Bits_Per_Element>::value;
const size_t Lsb_Element_Index = position >> etl::log2<Bits_Per_Element>::value;
// Is the value contained within one element?
if (Msb_Element_Index == Lsb_Element_Index)
@ -1150,7 +1150,7 @@ namespace etl
size_t active_bits_in_msb = (position + length) - (static_cast<size_t>(Msb_Element_Index) * Bits_Per_Element);
// Start with index of the element containing the msb.
int element_index = Msb_Element_Index;
size_t element_index = Msb_Element_Index;
value = extract_from_multiple_elements<T>(pbuffer, element_index, active_bits_in_msb, length);
}
@ -1169,7 +1169,7 @@ namespace etl
{
typedef typename etl::make_unsigned<T>::type unsigned_t;
const int Element_Index = (Position + Length - 1) >> etl::log2<Bits_Per_Element>::value;
const size_t Element_Index = (Position + Length - 1) >> etl::log2<Bits_Per_Element>::value;
const unsigned_t Mask = etl::lsb_mask<unsigned_t, Length>::value;
const unsigned_t Shift = Position % Bits_Per_Element;
@ -1186,7 +1186,7 @@ namespace etl
extract_from_buffer(const_pointer pbuffer)
{
// Start with index of the element containing the msb.
const int Msb_Element_Index = (Position + Length - 1) >> etl::log2<Bits_Per_Element>::value;
const size_t Msb_Element_Index = (Position + Length - 1) >> etl::log2<Bits_Per_Element>::value;
// Get the number of active bits in the first element
const size_t Active_Bits_In_Msb = ((Position + Length - 1) % Bits_Per_Element) + 1;

6
include/etl/private/chrono/year_month_weekday.h
View File

@ -174,11 +174,11 @@ namespace etl
unsigned int target_wd = ymwd.weekday().c_encoding();
unsigned int target_index = ymwd.index();
etl::chrono::weekday first_weekday(static_cast<unsigned>(sd.time_since_epoch().count()));
etl::chrono::weekday first_weekday(sd);
unsigned int first_wd = first_weekday.c_encoding();
unsigned int offset = (target_wd - first_wd + 7U) % 7U;
unsigned int day_of_month = offset + (target_index - 1U) * 7U;
unsigned int day_of_month = 1U + offset + (target_index - 1U) * 7U;
etl::chrono::year_month_day result(year(), month(), etl::chrono::day(day_of_month));
@ -382,7 +382,7 @@ namespace etl
{
etl::chrono::year_month_day ymd(year(), month(), etl::chrono::day(d));
etl::chrono::sys_days ymd_sys_days = static_cast<etl::chrono::sys_days>(ymd);
etl::chrono::weekday wd(static_cast<unsigned>(ymd_sys_days.time_since_epoch().count()));
etl::chrono::weekday wd(ymd_sys_days);
if (wd == weekday())
{

11
include/etl/private/delegate_cpp11.h
View File

@ -172,7 +172,7 @@ namespace etl
//*************************************************************************
// Construct from a function pointer.
//*************************************************************************
delegate(function_ptr fp) ETL_NOEXCEPT
explicit delegate(function_ptr fp) ETL_NOEXCEPT
{
assign(fp, function_ptr_stub);
}
@ -534,7 +534,14 @@ namespace etl
//*************************************************************************
delegate& operator=(function_ptr fp) ETL_NOEXCEPT
{
assign(fp, function_ptr_stub);
if (fp == ETL_NULLPTR)
{
invocation.clear();
}
else
{
assign(fp, function_ptr_stub);
}
return *this;
}

44
include/etl/private/diagnostic_sign_conversion_push.h Normal file
View File

@ -0,0 +1,44 @@
///\file
/******************************************************************************
The MIT License(MIT)
Embedded Template Library.
https://github.com/ETLCPP/etl
https://www.etlcpp.com
Copyright(c) 2025 John Wellbelove
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files(the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and / or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions :
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
******************************************************************************/
/*
* The header include guard has been intentionally omitted.
* This file is intended to evaluated multiple times by design.
*/
#if defined(__GNUC__) && !defined(__clang__) && !defined(__llvm__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6))
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wsign-conversion"
#endif
#if defined(__clang__) || defined(__llvm__)
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wsign-conversion"
#endif

25
include/etl/private/variant_variadic.h
View File

@ -486,7 +486,7 @@ namespace etl
/// alternative (index() is zero).
//***************************************************************************
#include "diagnostic_uninitialized_push.h"
ETL_CONSTEXPR14 variant()
ETL_CONSTEXPR14 variant() ETL_NOEXCEPT_IF(etl::is_nothrow_default_constructible<type_from_index<0U> >::value)
{
using type = type_from_index<0U>;
@ -501,7 +501,7 @@ namespace etl
//***************************************************************************
#include "diagnostic_uninitialized_push.h"
template <typename T, etl::enable_if_t< !etl::is_same<etl::remove_cvref_t<T>, variant>::value, int> = 0>
ETL_CONSTEXPR14 variant(T&& value)
ETL_CONSTEXPR14 variant(T&& value) ETL_NOEXCEPT_IF((etl::is_nothrow_constructible<etl::remove_cvref_t<T>, T&&>::value))
: operation(operation_type< etl::remove_cvref_t<T>, etl::is_copy_constructible<etl::remove_cvref_t<T> >::value,
etl::is_move_constructible<etl::remove_cvref_t<T> >::value>::do_operation)
, type_id(index_of_type<T>::value)
@ -518,6 +518,7 @@ namespace etl
#include "diagnostic_uninitialized_push.h"
template <typename T, typename... TArgs>
ETL_CONSTEXPR14 explicit variant(etl::in_place_type_t<T>, TArgs&&... args)
ETL_NOEXCEPT_IF((etl::is_nothrow_constructible<etl::remove_cvref_t<T>, TArgs...>::value))
: operation(operation_type< etl::remove_cvref_t<T>, etl::is_copy_constructible<etl::remove_cvref_t<T> >::value,
etl::is_move_constructible<etl::remove_cvref_t<T> >::value>::do_operation)
, type_id(index_of_type<T>::value)
@ -534,6 +535,7 @@ namespace etl
#include "diagnostic_uninitialized_push.h"
template <size_t Index, typename... TArgs>
ETL_CONSTEXPR14 explicit variant(etl::in_place_index_t<Index>, TArgs&&... args)
ETL_NOEXCEPT_IF((etl::is_nothrow_constructible<type_from_index<Index>, TArgs...>::value))
: type_id(Index)
{
using type = type_from_index<Index>;
@ -552,6 +554,7 @@ namespace etl
#include "diagnostic_uninitialized_push.h"
template <typename T, typename U, typename... TArgs >
ETL_CONSTEXPR14 explicit variant(etl::in_place_type_t<T>, std::initializer_list<U> init, TArgs&&... args)
ETL_NOEXCEPT_IF((etl::is_nothrow_constructible<etl::remove_cvref_t<T>, std::initializer_list<U>, TArgs...>::value))
: operation(operation_type< etl::remove_cvref_t<T>, etl::is_copy_constructible<etl::remove_cvref_t<T> >::value,
etl::is_move_constructible<etl::remove_cvref_t<T> >::value>::do_operation)
, type_id(index_of_type<T>::value)
@ -568,6 +571,7 @@ namespace etl
#include "diagnostic_uninitialized_push.h"
template <size_t Index, typename U, typename... TArgs >
ETL_CONSTEXPR14 explicit variant(etl::in_place_index_t<Index>, std::initializer_list<U> init, TArgs&&... args)
ETL_NOEXCEPT_IF((etl::is_nothrow_constructible<type_from_index<Index>, std::initializer_list<U>, TArgs...>::value))
: type_id(Index)
{
using type = type_from_index<Index>;
@ -585,7 +589,7 @@ namespace etl
///\param other The other variant object to copy.
//***************************************************************************
#include "diagnostic_uninitialized_push.h"
ETL_CONSTEXPR14 variant(const variant& other)
ETL_CONSTEXPR14 variant(const variant& other) ETL_NOEXCEPT_IF((etl::conjunction<etl::is_nothrow_copy_constructible<TTypes>...>::value))
: operation(other.operation)
, type_id(other.type_id)
{
@ -605,7 +609,7 @@ namespace etl
///\param other The other variant object to copy.
//***************************************************************************
#include "diagnostic_uninitialized_push.h"
ETL_CONSTEXPR14 variant(variant&& other)
ETL_CONSTEXPR14 variant(variant&& other) ETL_NOEXCEPT_IF((etl::conjunction<etl::is_nothrow_move_constructible<TTypes>...>::value))
: operation(other.operation)
, type_id(other.type_id)
{
@ -623,7 +627,7 @@ namespace etl
//***************************************************************************
/// Destructor.
//***************************************************************************
~variant()
~variant() ETL_NOEXCEPT
{
if (!valueless_by_exception())
{
@ -638,7 +642,7 @@ namespace etl
/// Emplace by type with variadic constructor parameters.
//***************************************************************************
template <typename T, typename... TArgs>
T& emplace(TArgs&&... args)
T& emplace(TArgs&&... args) ETL_NOEXCEPT_IF((etl::is_nothrow_constructible<etl::remove_cvref_t<T>, TArgs...>::value))
{
static_assert(etl::is_one_of<T, TTypes...>::value, "Unsupported type");
@ -664,6 +668,7 @@ namespace etl
//***************************************************************************
template <typename T, typename U, typename... TArgs>
T& emplace(std::initializer_list<U> il, TArgs&&... args)
ETL_NOEXCEPT_IF((etl::is_nothrow_constructible<etl::remove_cvref_t<T>, std::initializer_list<U>, TArgs...>::value))
{
static_assert(etl::is_one_of<T, TTypes...>::value, "Unsupported type");
@ -689,6 +694,7 @@ namespace etl
//***************************************************************************
template <size_t Index, typename... TArgs>
typename etl::variant_alternative_t<Index, variant<TTypes...> >& emplace(TArgs&&... args)
ETL_NOEXCEPT_IF((etl::is_nothrow_constructible<type_from_index<Index>, TArgs...>::value))
{
static_assert(Index < sizeof...(TTypes), "Index out of range");
@ -714,6 +720,7 @@ namespace etl
//***************************************************************************
template <size_t Index, typename U, typename... TArgs>
typename etl::variant_alternative_t<Index, variant<TTypes...> >& emplace(std::initializer_list<U> il, TArgs&&... args)
ETL_NOEXCEPT_IF((etl::is_nothrow_constructible<type_from_index<Index>, std::initializer_list<U>, TArgs...>::value))
{
static_assert(Index < sizeof...(TTypes), "Index out of range");
@ -739,7 +746,7 @@ namespace etl
///\param value The value to assign.
//***************************************************************************
template <typename T, etl::enable_if_t< !etl::is_same<etl::remove_cvref_t<T>, variant>::value, int> = 0>
variant& operator=(T&& value)
variant& operator=(T&& value) ETL_NOEXCEPT_IF((etl::is_nothrow_constructible<etl::remove_cvref_t<T>, T&&>::value))
{
using type = etl::remove_cvref_t<T>;
@ -762,7 +769,7 @@ namespace etl
/// Assignment operator for variant type.
///\param other The variant to assign.
//***************************************************************************
variant& operator=(const variant& other)
variant& operator=(const variant& other) ETL_NOEXCEPT_IF((etl::conjunction<etl::is_nothrow_copy_constructible<TTypes>...>::value))
{
if (this != &other)
{
@ -791,7 +798,7 @@ namespace etl
/// Assignment operator for variant type.
///\param other The variant to assign.
//***************************************************************************
variant& operator=(variant&& other)
variant& operator=(variant&& other) ETL_NOEXCEPT_IF((etl::conjunction<etl::is_nothrow_move_constructible<TTypes>...>::value))
{
if (this != &other)
{

49
include/etl/profiles/cpp20.h Normal file
View File

@ -0,0 +1,49 @@
///\file
/******************************************************************************
The MIT License(MIT)
Embedded Template Library.
https://github.com/ETLCPP/etl
https://www.etlcpp.com
Copyright(c) 2026 BMW AG
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files(the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and / or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions :
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
******************************************************************************/
#ifndef ETL_CPP20_INCLUDED
#define ETL_CPP20_INCLUDED
//*****************************************************************************
// Generic C++20
//*****************************************************************************
#define ETL_TARGET_DEVICE_GENERIC
#define ETL_TARGET_OS_NONE
#define ETL_COMPILER_GENERIC
#define ETL_CPP11_SUPPORTED 1
#define ETL_CPP14_SUPPORTED 1
#define ETL_CPP17_SUPPORTED 1
#define ETL_CPP20_SUPPORTED 1
#define ETL_NO_NULLPTR_SUPPORT 0
#define ETL_NO_LARGE_CHAR_SUPPORT 0
#define ETL_CPP11_TYPE_TRAITS_IS_TRIVIAL_SUPPORTED 1
#endif

50
include/etl/profiles/cpp20_no_stl.h Normal file
View File

@ -0,0 +1,50 @@
///\file
/******************************************************************************
The MIT License(MIT)
Embedded Template Library.
https://github.com/ETLCPP/etl
https://www.etlcpp.com
Copyright(c) 2026 BMW AG
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files(the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and / or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions :
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
******************************************************************************/
#ifndef ETL_CPP20_NO_STL_INCLUDED
#define ETL_CPP20_NO_STL_INCLUDED
//*****************************************************************************
// Generic C++20 without STL support
//*****************************************************************************
#define ETL_TARGET_DEVICE_GENERIC
#define ETL_TARGET_OS_NONE
#define ETL_COMPILER_GENERIC
#define ETL_CPP11_SUPPORTED 1
#define ETL_CPP14_SUPPORTED 1
#define ETL_CPP17_SUPPORTED 1
#define ETL_CPP20_SUPPORTED 1
#define ETL_NO_NULLPTR_SUPPORT 0
#define ETL_NO_LARGE_CHAR_SUPPORT 0
#define ETL_CPP11_TYPE_TRAITS_IS_TRIVIAL_SUPPORTED 0
#define ETL_NO_STL
#endif

50
include/etl/profiles/cpp23.h Normal file
View File

@ -0,0 +1,50 @@
///\file
/******************************************************************************
The MIT License(MIT)
Embedded Template Library.
https://github.com/ETLCPP/etl
https://www.etlcpp.com
Copyright(c) 2026 BMW AG
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files(the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and / or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions :
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
******************************************************************************/
#ifndef ETL_CPP23_INCLUDED
#define ETL_CPP23_INCLUDED
//*****************************************************************************
// Generic C++23
//*****************************************************************************
#define ETL_TARGET_DEVICE_GENERIC
#define ETL_TARGET_OS_NONE
#define ETL_COMPILER_GENERIC
#define ETL_CPP11_SUPPORTED 1
#define ETL_CPP14_SUPPORTED 1
#define ETL_CPP17_SUPPORTED 1
#define ETL_CPP20_SUPPORTED 1
#define ETL_CPP23_SUPPORTED 1
#define ETL_NO_NULLPTR_SUPPORT 0
#define ETL_NO_LARGE_CHAR_SUPPORT 0
#define ETL_CPP11_TYPE_TRAITS_IS_TRIVIAL_SUPPORTED 1
#endif

51
include/etl/profiles/cpp23_no_stl.h Normal file
View File

@ -0,0 +1,51 @@
///\file
/******************************************************************************
The MIT License(MIT)
Embedded Template Library.
https://github.com/ETLCPP/etl
https://www.etlcpp.com
Copyright(c) 2026 BMW AG
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files(the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and / or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions :
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
******************************************************************************/
#ifndef ETL_CPP23_NO_STL_INCLUDED
#define ETL_CPP23_NO_STL_INCLUDED
//*****************************************************************************
// Generic C++23 without STL support
//*****************************************************************************
#define ETL_TARGET_DEVICE_GENERIC
#define ETL_TARGET_OS_NONE
#define ETL_COMPILER_GENERIC
#define ETL_CPP11_SUPPORTED 1
#define ETL_CPP14_SUPPORTED 1
#define ETL_CPP17_SUPPORTED 1
#define ETL_CPP20_SUPPORTED 1
#define ETL_CPP23_SUPPORTED 1
#define ETL_NO_NULLPTR_SUPPORT 0
#define ETL_NO_LARGE_CHAR_SUPPORT 0
#define ETL_CPP11_TYPE_TRAITS_IS_TRIVIAL_SUPPORTED 0
#define ETL_NO_STL
#endif

51
include/etl/profiles/cpp26.h Normal file
View File

@ -0,0 +1,51 @@
///\file
/******************************************************************************
The MIT License(MIT)
Embedded Template Library.
https://github.com/ETLCPP/etl
https://www.etlcpp.com
Copyright(c) 2026 BMW AG
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files(the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and / or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions :
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
******************************************************************************/
#ifndef ETL_CPP26_INCLUDED
#define ETL_CPP26_INCLUDED
//*****************************************************************************
// Generic C++26
//*****************************************************************************
#define ETL_TARGET_DEVICE_GENERIC
#define ETL_TARGET_OS_NONE
#define ETL_COMPILER_GENERIC
#define ETL_CPP11_SUPPORTED 1
#define ETL_CPP14_SUPPORTED 1
#define ETL_CPP17_SUPPORTED 1
#define ETL_CPP20_SUPPORTED 1
#define ETL_CPP23_SUPPORTED 1
#define ETL_CPP26_SUPPORTED 1
#define ETL_NO_NULLPTR_SUPPORT 0
#define ETL_NO_LARGE_CHAR_SUPPORT 0
#define ETL_CPP11_TYPE_TRAITS_IS_TRIVIAL_SUPPORTED 1
#endif

52
include/etl/profiles/cpp26_no_stl.h Normal file
View File

@ -0,0 +1,52 @@
///\file
/******************************************************************************
The MIT License(MIT)
Embedded Template Library.
https://github.com/ETLCPP/etl
https://www.etlcpp.com
Copyright(c) 2026 BMW AG
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files(the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and / or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions :
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
******************************************************************************/
#ifndef ETL_CPP26_NO_STL_INCLUDED
#define ETL_CPP26_NO_STL_INCLUDED
//*****************************************************************************
// Generic C++26 without STL support
//*****************************************************************************
#define ETL_TARGET_DEVICE_GENERIC
#define ETL_TARGET_OS_NONE
#define ETL_COMPILER_GENERIC
#define ETL_CPP11_SUPPORTED 1
#define ETL_CPP14_SUPPORTED 1
#define ETL_CPP17_SUPPORTED 1
#define ETL_CPP20_SUPPORTED 1
#define ETL_CPP23_SUPPORTED 1
#define ETL_CPP26_SUPPORTED 1
#define ETL_NO_NULLPTR_SUPPORT 0
#define ETL_NO_LARGE_CHAR_SUPPORT 0
#define ETL_CPP11_TYPE_TRAITS_IS_TRIVIAL_SUPPORTED 0
#define ETL_NO_STL
#endif

82
include/etl/profiles/determine_builtin_support.h
View File

@ -41,6 +41,14 @@ SOFTWARE.
#define ETL_USING_BUILTIN_IS_CONSTRUCTIBLE 1
#endif
#if !defined(ETL_USING_BUILTIN_IS_NOTHROW_CONSTRUCTIBLE)
#define ETL_USING_BUILTIN_IS_NOTHROW_CONSTRUCTIBLE 1
#endif
#if !defined(ETL_USING_BUILTIN_IS_NOTHROW_ASSIGNABLE)
#define ETL_USING_BUILTIN_IS_NOTHROW_ASSIGNABLE 1
#endif
#if !defined(ETL_USING_BUILTIN_IS_TRIVIALLY_CONSTRUCTIBLE)
#define ETL_USING_BUILTIN_IS_TRIVIALLY_CONSTRUCTIBLE 1
#endif
@ -60,7 +68,10 @@ SOFTWARE.
#if !defined(ETL_USING_BUILTIN_IS_CONSTANT_EVALUATED)
#define ETL_USING_BUILTIN_IS_CONSTANT_EVALUATED 1
#endif
#endif
#if defined(ETL_USE_BUILTIN_MEM_FUNCTIONS) // Set all of them to be true if not
// already defined
#if !defined(ETL_USING_BUILTIN_MEMCPY)
#define ETL_USING_BUILTIN_MEMCPY 1
#endif
@ -93,6 +104,14 @@ SOFTWARE.
#define ETL_USING_BUILTIN_IS_CONSTRUCTIBLE __has_builtin(__is_constructible)
#endif
#if !defined(ETL_USING_BUILTIN_IS_NOTHROW_CONSTRUCTIBLE)
#define ETL_USING_BUILTIN_IS_NOTHROW_CONSTRUCTIBLE __has_builtin(__is_nothrow_constructible)
#endif
#if !defined(ETL_USING_BUILTIN_IS_NOTHROW_ASSIGNABLE)
#define ETL_USING_BUILTIN_IS_NOTHROW_ASSIGNABLE __has_builtin(__is_nothrow_assignable)
#endif
#if !defined(ETL_USING_BUILTIN_IS_TRIVIALLY_CONSTRUCTIBLE)
#define ETL_USING_BUILTIN_IS_TRIVIALLY_CONSTRUCTIBLE (__has_builtin(__has_trivial_constructor) || __has_builtin(__is_trivially_constructible))
#endif
@ -132,6 +151,20 @@ SOFTWARE.
#if !defined(ETL_USING_BUILTIN_MEMCHR)
#define ETL_USING_BUILTIN_MEMCHR __has_builtin(__builtin_memchr)
#endif
#if !defined(ETL_USING_BUILTIN_IS_VIRTUAL_BASE_OF)
#define ETL_USING_BUILTIN_IS_VIRTUAL_BASE_OF __has_builtin(__is_virtual_base_of)
#endif
#if !defined(ETL_USING_BUILTIN_IS_TRIVIALLY_RELOCATABLE)
#define ETL_USING_BUILTIN_IS_TRIVIALLY_RELOCATABLE __has_builtin(__is_trivially_relocatable)
#endif
// __builtin_is_cpp_trivially_relocatable replaces __is_trivially_relocatable by an
// effort of standardization for newer C++ standards
#if !defined(ETL_USING_BUILTIN_BUILTIN_IS_CPP_TRIVIALLY_RELOCATABLE)
#define ETL_USING_BUILTIN_BUILTIN_IS_CPP_TRIVIALLY_RELOCATABLE __has_builtin(__builtin_is_cpp_trivially_relocatable)
#endif
#endif
// The default. Set to 0, if not already set.
@ -143,6 +176,14 @@ SOFTWARE.
#define ETL_USING_BUILTIN_IS_CONSTRUCTIBLE 0
#endif
#if !defined(ETL_USING_BUILTIN_IS_NOTHROW_CONSTRUCTIBLE)
#define ETL_USING_BUILTIN_IS_NOTHROW_CONSTRUCTIBLE 0
#endif
#if !defined(ETL_USING_BUILTIN_IS_NOTHROW_ASSIGNABLE)
#define ETL_USING_BUILTIN_IS_NOTHROW_ASSIGNABLE 0
#endif
#if !defined(ETL_USING_BUILTIN_IS_TRIVIALLY_CONSTRUCTIBLE)
#define ETL_USING_BUILTIN_IS_TRIVIALLY_CONSTRUCTIBLE 0
#endif
@ -183,24 +224,41 @@ SOFTWARE.
#define ETL_USING_BUILTIN_MEMCHR 0
#endif
#if !defined(ETL_USING_BUILTIN_IS_VIRTUAL_BASE_OF)
#define ETL_USING_BUILTIN_IS_VIRTUAL_BASE_OF 0
#endif
#if !defined(ETL_USING_BUILTIN_IS_TRIVIALLY_RELOCATABLE)
#define ETL_USING_BUILTIN_IS_TRIVIALLY_RELOCATABLE 0
#endif
#if !defined(ETL_USING_BUILTIN_BUILTIN_IS_CPP_TRIVIALLY_RELOCATABLE)
#define ETL_USING_BUILTIN_BUILTIN_IS_CPP_TRIVIALLY_RELOCATABLE 0
#endif
namespace etl
{
namespace traits
{
// Documentation: https://www.etlcpp.com/etl_traits.html
static ETL_CONSTANT bool using_builtin_is_assignable = (ETL_USING_BUILTIN_IS_ASSIGNABLE == 1);
static ETL_CONSTANT bool using_builtin_is_constructible = (ETL_USING_BUILTIN_IS_CONSTRUCTIBLE == 1);
static ETL_CONSTANT bool using_builtin_is_trivially_constructible = (ETL_USING_BUILTIN_IS_TRIVIALLY_CONSTRUCTIBLE == 1);
static ETL_CONSTANT bool using_builtin_is_trivially_destructible = (ETL_USING_BUILTIN_IS_TRIVIALLY_DESTRUCTIBLE == 1);
static ETL_CONSTANT bool using_builtin_is_trivially_copyable = (ETL_USING_BUILTIN_IS_TRIVIALLY_COPYABLE == 1);
static ETL_CONSTANT bool using_builtin_underlying_type = (ETL_USING_BUILTIN_UNDERLYING_TYPE == 1);
static ETL_CONSTANT bool using_builtin_is_constant_evaluated = (ETL_USING_BUILTIN_IS_CONSTANT_EVALUATED == 1);
static ETL_CONSTANT bool using_builtin_memcpy = (ETL_USING_BUILTIN_MEMCPY == 1);
static ETL_CONSTANT bool using_builtin_memmove = (ETL_USING_BUILTIN_MEMMOVE == 1);
static ETL_CONSTANT bool using_builtin_memset = (ETL_USING_BUILTIN_MEMSET == 1);
static ETL_CONSTANT bool using_builtin_memcmp = (ETL_USING_BUILTIN_MEMCMP == 1);
static ETL_CONSTANT bool using_builtin_memchr = (ETL_USING_BUILTIN_MEMCHR == 1);
static ETL_CONSTANT bool using_builtin_is_assignable = (ETL_USING_BUILTIN_IS_ASSIGNABLE == 1);
static ETL_CONSTANT bool using_builtin_is_constructible = (ETL_USING_BUILTIN_IS_CONSTRUCTIBLE == 1);
static ETL_CONSTANT bool using_builtin_is_nothrow_constructible = (ETL_USING_BUILTIN_IS_NOTHROW_CONSTRUCTIBLE == 1);
static ETL_CONSTANT bool using_builtin_is_nothrow_assignable = (ETL_USING_BUILTIN_IS_NOTHROW_ASSIGNABLE == 1);
static ETL_CONSTANT bool using_builtin_is_trivially_constructible = (ETL_USING_BUILTIN_IS_TRIVIALLY_CONSTRUCTIBLE == 1);
static ETL_CONSTANT bool using_builtin_is_trivially_destructible = (ETL_USING_BUILTIN_IS_TRIVIALLY_DESTRUCTIBLE == 1);
static ETL_CONSTANT bool using_builtin_is_trivially_copyable = (ETL_USING_BUILTIN_IS_TRIVIALLY_COPYABLE == 1);
static ETL_CONSTANT bool using_builtin_underlying_type = (ETL_USING_BUILTIN_UNDERLYING_TYPE == 1);
static ETL_CONSTANT bool using_builtin_is_constant_evaluated = (ETL_USING_BUILTIN_IS_CONSTANT_EVALUATED == 1);
static ETL_CONSTANT bool using_builtin_memcpy = (ETL_USING_BUILTIN_MEMCPY == 1);
static ETL_CONSTANT bool using_builtin_memmove = (ETL_USING_BUILTIN_MEMMOVE == 1);
static ETL_CONSTANT bool using_builtin_memset = (ETL_USING_BUILTIN_MEMSET == 1);
static ETL_CONSTANT bool using_builtin_memcmp = (ETL_USING_BUILTIN_MEMCMP == 1);
static ETL_CONSTANT bool using_builtin_memchr = (ETL_USING_BUILTIN_MEMCHR == 1);
static ETL_CONSTANT bool using_builtin_is_virtual_base_of = (ETL_USING_BUILTIN_IS_VIRTUAL_BASE_OF == 1);
static ETL_CONSTANT bool using_builtin_is_trivially_relocatable = (ETL_USING_BUILTIN_IS_TRIVIALLY_RELOCATABLE == 1);
static ETL_CONSTANT bool using_builtin_builtin_is_cpp_trivially_relocatable = (ETL_USING_BUILTIN_BUILTIN_IS_CPP_TRIVIALLY_RELOCATABLE == 1);
} // namespace traits
} // namespace etl

59
include/etl/profiles/determine_compiler_language_support.h
View File

@ -35,6 +35,31 @@ SOFTWARE.
#include "determine_compiler.h"
// Determine C++26 support
#if !defined(ETL_CPP26_SUPPORTED)
#if defined(__cplusplus)
#if defined(ETL_COMPILER_MICROSOFT)
#define ETL_CPP26_SUPPORTED (__cplusplus >= 202400L)
#elif defined(ETL_COMPILER_ARM5)
#define ETL_CPP26_SUPPORTED 0
#elif defined(ETL_COMPILER_GCC)
#define ETL_CPP26_SUPPORTED (__cplusplus >= 202400L)
#else
#define ETL_CPP26_SUPPORTED (__cplusplus >= 202400L)
#endif
#else
#define ETL_CPP26_SUPPORTED 0
#endif
#endif
#if ETL_CPP26_SUPPORTED
#define ETL_CPP11_SUPPORTED 1
#define ETL_CPP14_SUPPORTED 1
#define ETL_CPP17_SUPPORTED 1
#define ETL_CPP20_SUPPORTED 1
#define ETL_CPP23_SUPPORTED 1
#endif
// Determine C++23 support
#if !defined(ETL_CPP23_SUPPORTED)
#if defined(__cplusplus)
@ -162,6 +187,7 @@ SOFTWARE.
#define ETL_CPP17_NOT_SUPPORTED (!ETL_CPP17_SUPPORTED)
#define ETL_CPP20_NOT_SUPPORTED (!ETL_CPP20_SUPPORTED)
#define ETL_CPP23_NOT_SUPPORTED (!ETL_CPP23_SUPPORTED)
#define ETL_CPP26_NOT_SUPPORTED (!ETL_CPP26_SUPPORTED)
// 'Using' macros
#define ETL_USING_CPP11 (ETL_CPP11_SUPPORTED == 1)
@ -169,12 +195,14 @@ SOFTWARE.
#define ETL_USING_CPP17 (ETL_CPP17_SUPPORTED == 1)
#define ETL_USING_CPP20 (ETL_CPP20_SUPPORTED == 1)
#define ETL_USING_CPP23 (ETL_CPP23_SUPPORTED == 1)
#define ETL_USING_CPP26 (ETL_CPP26_SUPPORTED == 1)
#define ETL_NOT_USING_CPP11 (ETL_CPP11_SUPPORTED == 0)
#define ETL_NOT_USING_CPP14 (ETL_CPP14_SUPPORTED == 0)
#define ETL_NOT_USING_CPP17 (ETL_CPP17_SUPPORTED == 0)
#define ETL_NOT_USING_CPP20 (ETL_CPP20_SUPPORTED == 0)
#define ETL_NOT_USING_CPP23 (ETL_CPP23_SUPPORTED == 0)
#define ETL_NOT_USING_CPP26 (ETL_CPP26_SUPPORTED == 0)
#if !defined(ETL_NO_NULLPTR_SUPPORT)
#define ETL_NO_NULLPTR_SUPPORT ETL_NOT_USING_CPP11
@ -198,7 +226,9 @@ SOFTWARE.
// Language standard
#if !defined(ETL_LANGUAGE_STANDARD)
#if ETL_USING_CPP23
#if ETL_USING_CPP26
#define ETL_LANGUAGE_STANDARD 26
#elif ETL_USING_CPP23
#define ETL_LANGUAGE_STANDARD 23
#elif ETL_USING_CPP20
#define ETL_LANGUAGE_STANDARD 20
@ -227,10 +257,37 @@ SOFTWARE.
#define ETL_HAS_STD_BYTESWAP 1
#endif
#endif
#if defined(__cpp_lib_is_virtual_base_of)
#if __cpp_lib_is_virtual_base_of != 0
#define ETL_HAS_STD_IS_VIRTUAL_BASE_OF 1
#endif
#endif
#if defined(__cpp_lib_trivially_relocatable)
#if __cpp_lib_trivially_relocatable != 0
#define ETL_HAS_STD_TRIVIALLY_RELOCATABLE 1
#endif
#endif
#if defined(__cpp_lib_atomic_min_max)
#if __cpp_lib_atomic_min_max != 0
#define ETL_HAS_STD_ATOMIC_MIN_MAX 1
#endif
#endif
#endif
#endif
#ifndef ETL_HAS_STD_BYTESWAP
#define ETL_HAS_STD_BYTESWAP 0
#endif
#ifndef ETL_HAS_STD_IS_VIRTUAL_BASE_OF
#define ETL_HAS_STD_IS_VIRTUAL_BASE_OF 0
#endif
#ifndef ETL_HAS_STD_TRIVIALLY_RELOCATABLE
#define ETL_HAS_STD_TRIVIALLY_RELOCATABLE 0
#endif
#ifndef ETL_HAS_STD_ATOMIC_MIN_MAX
#define ETL_HAS_STD_ATOMIC_MIN_MAX 0
#endif
#endif

52
include/etl/ranges.h
View File

@ -2975,7 +2975,7 @@ namespace etl
iterator() = default;
iterator(const_iterator_type current, const_iterator_type segment_end, bool is_end)
: _current(current)
: _current_it(current)
, _segment_end(segment_end)
, _is_end(is_end || (current == segment_end))
{
@ -2983,18 +2983,18 @@ namespace etl
reference operator*() const
{
return *_current;
return *_current_it;
}
pointer operator->() const
{
return &(*_current);
return &(*_current_it);
}
iterator& operator++()
{
++_current;
if (_current == _segment_end)
++_current_it;
if (_current_it == _segment_end)
{
_is_end = true;
}
@ -3018,7 +3018,7 @@ namespace etl
{
return false;
}
return _current == other._current;
return _current_it == other._current_it;
}
constexpr bool operator!=(const iterator& other) const
@ -3028,7 +3028,7 @@ namespace etl
private:
const_iterator_type _current{};
const_iterator_type _current_it{};
const_iterator_type _segment_end{};
bool _is_end = true;
};
@ -3379,7 +3379,7 @@ namespace etl
concat_iterator(size_t index, concat_view<Ranges...>& view, iterator_variant_type current)
: _ranges_index{index}
, _view(view)
, _current(current)
, _current_it(current)
{
}
@ -3387,7 +3387,7 @@ namespace etl
constexpr reference operator*() const
{
return _view.get_value(_ranges_index, _current);
return _view.get_value(_ranges_index, _current_it);
}
constexpr decltype(auto) operator[](difference_type pos) const
@ -3397,14 +3397,14 @@ namespace etl
{
for (difference_type i = 0; i < pos; ++i)
{
tmp._view.advance(tmp._ranges_index, tmp._current, 1);
tmp._view.advance(tmp._ranges_index, tmp._current_it, 1);
}
}
if (pos < 0)
{
for (difference_type i = 0; i < -pos; ++i)
{
tmp._view.advance(tmp._ranges_index, tmp._current, -1);
tmp._view.advance(tmp._ranges_index, tmp._current_it, -1);
}
}
return *tmp;
@ -3412,27 +3412,27 @@ namespace etl
constexpr concat_iterator& operator++()
{
_view.advance(_ranges_index, _current, 1);
_view.advance(_ranges_index, _current_it, 1);
return *this;
}
constexpr concat_iterator operator++(int)
{
auto result = *this;
_view.advance(_ranges_index, _current, 1);
_view.advance(_ranges_index, _current_it, 1);
return result;
}
constexpr concat_iterator& operator--()
{
_view.advance(_ranges_index, _current, -1);
_view.advance(_ranges_index, _current_it, -1);
return *this;
}
constexpr concat_iterator operator--(int)
{
auto result = *this;
_view.advance(_ranges_index, _current, -1);
_view.advance(_ranges_index, _current_it, -1);
return result;
}
@ -3440,7 +3440,7 @@ namespace etl
{
for (difference_type i = 0; i < n; ++i)
{
_view.advance(_ranges_index, _current, 1);
_view.advance(_ranges_index, _current_it, 1);
}
return *this;
}
@ -3449,7 +3449,7 @@ namespace etl
{
for (difference_type i = 0; i < n; ++i)
{
_view.advance(_ranges_index, _current, -1);
_view.advance(_ranges_index, _current_it, -1);
}
return *this;
}
@ -3457,12 +3457,12 @@ namespace etl
friend constexpr bool operator==(const concat_iterator<Ranges...>& x, etl::default_sentinel_t)
{
return x._ranges_index == x._view.number_of_ranges - 1
&& etl::get<x._view.number_of_ranges - 1>(x._current) == etl::get<x._view.number_of_ranges - 1>(x._view).end();
&& etl::get<x._view.number_of_ranges - 1>(x._current_it) == etl::get<x._view.number_of_ranges - 1>(x._view).end();
}
friend constexpr bool operator==(const concat_iterator<Ranges...>& x, const concat_iterator<Ranges...>& y)
{
return x._ranges_index == y._ranges_index && x._current.index() == y._current.index() && x._current == y._current;
return x._ranges_index == y._ranges_index && x._current_it.index() == y._current_it.index() && x._current_it == y._current_it;
}
friend constexpr bool operator!=(const concat_iterator<Ranges...>& x, etl::default_sentinel_t)
@ -3479,7 +3479,7 @@ namespace etl
size_t _ranges_index;
const concat_view<Ranges...>& _view;
iterator_variant_type _current;
iterator_variant_type _current_it;
};
template <class... Ranges>
@ -5746,7 +5746,7 @@ namespace etl
using iterator_category = ETL_OR_STD::forward_iterator_tag;
constexpr cartesian_product_iterator(iterators_type current, iterators_type begins, iterators_type ends, bool is_end = false)
: _current(current)
: _current_it(current)
, _begins(begins)
, _ends(ends)
, _is_end(is_end)
@ -5799,7 +5799,7 @@ namespace etl
template <size_t I>
constexpr etl::enable_if_t<(I > 0)> increment_at()
{
auto& it = etl::get<I>(_current);
auto& it = etl::get<I>(_current_it);
++it;
if (it == etl::get<I>(_ends))
{
@ -5811,7 +5811,7 @@ namespace etl
template <size_t I>
constexpr etl::enable_if_t<(I == 0)> increment_at()
{
auto& it = etl::get<0>(_current);
auto& it = etl::get<0>(_current_it);
++it;
if (it == etl::get<0>(_ends))
{
@ -5822,16 +5822,16 @@ namespace etl
template <size_t... Is>
constexpr value_type deref(etl::index_sequence<Is...>) const
{
return value_type(*etl::get<Is>(_current)...);
return value_type(*etl::get<Is>(_current_it)...);
}
template <size_t... Is>
constexpr bool all_equal(const cartesian_product_iterator& other, etl::index_sequence<Is...>) const
{
return ((etl::get<Is>(_current) == etl::get<Is>(other._current)) && ...);
return ((etl::get<Is>(_current_it) == etl::get<Is>(other._current_it)) && ...);
}
iterators_type _current;
iterators_type _current_it;
iterators_type _begins;
iterators_type _ends;
bool _is_end;

24
include/etl/ratio.h
View File

@ -161,12 +161,20 @@ namespace etl
#endif
//***********************************************************************
/// Predefined ration types.
/// Predefined ratio types.
//***********************************************************************
#if INT_MAX > INT32_MAX
typedef ratio<1, 1000000000000000000> atto;
typedef ratio<1, 1000000000000000> femto;
typedef ratio<1, 1000000000000> pico;
// 2022 SI prefix (10^-30)
typedef ratio<1, 1000000000000000000LL * 1000000000000LL> quecto;
// 2022 SI prefix (10^-27)
typedef ratio<1, 1000000000000000000LL * 1000000000LL> ronto;
// 10^-24
typedef ratio<1, 1000000000000000000LL * 1000000LL> yocto;
// 10^-21
typedef ratio<1, 1000000000000000000LL * 1000LL> zepto;
typedef ratio<1, 1000000000000000000> atto;
typedef ratio<1, 1000000000000000> femto;
typedef ratio<1, 1000000000000> pico;
#endif
#if (INT_MAX >= INT32_MAX)
@ -192,6 +200,14 @@ namespace etl
typedef ratio<1000000000000, 1> tera;
typedef ratio<1000000000000000, 1> peta;
typedef ratio<1000000000000000000, 1> exa;
// 10^21
typedef ratio<1000000000000000000LL * 1000LL, 1> zetta;
// 10^24
typedef ratio<1000000000000000000LL * 1000000LL, 1> yotta;
// 2022 SI prefix (10^27)
typedef ratio<1000000000000000000LL * 1000000000LL, 1> ronna;
// 2022 SI prefix (10^30)
typedef ratio<1000000000000000000LL * 1000000000000LL, 1> quetta;
#endif
/// An approximation of Pi.

68
include/etl/result.h
View File

@ -38,11 +38,7 @@ SOFTWARE.
#include "optional.h"
#include "variant.h"
#if ETL_CPP11_NOT_SUPPORTED
#if !defined(ETL_IN_UNIT_TEST)
#error NOT SUPPORTED FOR C++03 OR BELOW
#endif
#else
#if ETL_CPP11_SUPPORTED
namespace etl
{
@ -70,7 +66,6 @@ namespace etl
{
}
#if ETL_CPP11_SUPPORTED
//*******************************************
/// Move constructor
//*******************************************
@ -78,7 +73,6 @@ namespace etl
: data(etl::move(other.data))
{
}
#endif
//*******************************************
// Construct from a value
@ -104,15 +98,13 @@ namespace etl
{
}
//*******************************************
/// Move construct from error
//*******************************************
#if ETL_CPP11_SUPPORTED
//*******************************************
/// Move construct from error
//*******************************************
result(TError&& error)
: data(etl::move(error))
{
}
#endif
//*******************************************
/// Copy assign
@ -141,16 +133,14 @@ namespace etl
return *this;
}
//*******************************************
/// Move assign from value
//*******************************************
#if ETL_CPP11_SUPPORTED
//*******************************************
/// Move assign from value
//*******************************************
result& operator=(TValue&& value)
{
data = etl::move(value);
return *this;
}
#endif
//*******************************************
/// Copy assign from error
@ -161,16 +151,14 @@ namespace etl
return *this;
}
//*******************************************
/// Move assign from error
//*******************************************
#if ETL_CPP11_SUPPORTED
//*******************************************
/// Move assign from error
//*******************************************
result& operator=(TError&& error)
{
data = etl::move(error);
return *this;
}
#endif
//*******************************************
/// <b>true</b> if result contains a value
@ -223,16 +211,14 @@ namespace etl
return etl::get<TError>(data);
}
//*******************************************
/// Returns an rvalue reference to the error.
/// Undefined if the result does not contain an error.
//*******************************************
#if ETL_CPP11_SUPPORTED
//*******************************************
/// Returns an rvalue reference to the error.
/// Undefined if the result does not contain an error.
//*******************************************
TError&& error()
{
return etl::move(etl::get<TError>(data));
}
#endif
private:
@ -280,15 +266,13 @@ namespace etl
{
}
//*******************************************
/// Move construct from error
//*******************************************
#if ETL_CPP11_SUPPORTED
//*******************************************
/// Move construct from error
//*******************************************
result(TError&& error)
: data(etl::move(error))
{
}
#endif
//*******************************************
/// Copy assign from error
@ -299,16 +283,14 @@ namespace etl
return *this;
}
//*******************************************
/// Move assign from error
//*******************************************
#if ETL_CPP11_SUPPORTED
//*******************************************
/// Move assign from error
//*******************************************
result& operator=(TError&& error)
{
data = etl::move(error);
return *this;
}
#endif
//*******************************************
/// <b>true</b> if result contains a value
@ -343,16 +325,14 @@ namespace etl
return data.value();
}
//*******************************************
/// Returns an rvalue reference to the error.
/// Undefined if the result does not contain an error.
//*******************************************
#if ETL_CPP11_SUPPORTED
//*******************************************
/// Returns an rvalue reference to the error.
/// Undefined if the result does not contain an error.
//*******************************************
TError&& error()
{
return etl::move(data.value());
}
#endif
private:

5
include/etl/rounded_integral_division.h
View File

@ -36,6 +36,8 @@ SOFTWARE.
#include "type_traits.h"
#include "utility.h"
#if ETL_USING_CPP11
namespace etl
{
namespace private_rounded_integral_division
@ -565,7 +567,7 @@ namespace etl
// Work with magnitudes in unsigned form (avoids abs() overflow for
// T::min()).
typedef typename std::make_unsigned<T>::type utype;
typedef typename etl::make_unsigned<T>::type utype;
const utype abs_denominator = (denominator < 0) ? (utype(0) - utype(denominator)) : utype(denominator);
const utype abs_remainder = (remainder < 0) ? (utype(0) - utype(remainder)) : utype(remainder);
const utype half_denominator = abs_denominator / 2U;
@ -784,3 +786,4 @@ namespace etl
} // namespace etl
#endif
#endif

4
include/etl/signal.h
View File

@ -35,10 +35,6 @@ SOFTWARE.
#include "platform.h"
#if ETL_NOT_USING_CPP11 && !defined(ETL_IN_UNIT_TEST)
#error NOT SUPPORTED FOR C++03 OR BELOW
#endif
#if ETL_USING_CPP11
#include "algorithm.h"

4
include/etl/tuple.h
View File

@ -31,10 +31,6 @@ SOFTWARE.
#include "platform.h"
#if ETL_NOT_USING_CPP11 && !defined(ETL_IN_UNIT_TEST)
#error NOT SUPPORTED FOR C++03 OR BELOW
#endif
#if ETL_USING_CPP11
#if ETL_USING_STL

424
include/etl/type_traits.h
View File

@ -1170,6 +1170,21 @@ namespace etl
inline constexpr bool is_base_of_v = is_base_of<T1, T2>::value;
#endif
//***************************************************************************
/// is_virtual_base_of
/// Determines if TBase is a virtual base class of TDerived
#if ETL_USING_CPP11 && ETL_USING_BUILTIN_IS_VIRTUAL_BASE_OF
template <typename TBase, typename TDerived>
struct is_virtual_base_of : etl::bool_constant<__is_virtual_base_of(TBase, TDerived)>
{
};
#if ETL_USING_CPP17
template <typename TBase, typename TDerived>
inline constexpr bool is_virtual_base_of_v = is_virtual_base_of<TBase, TDerived>::value;
#endif
#endif
//***************************************************************************
/// add_lvalue_reference
template <typename T>
@ -2017,6 +2032,32 @@ namespace etl
inline constexpr bool is_base_of_v = std::is_base_of_v<TBase, TDerived>;
#endif
//***************************************************************************
/// is_virtual_base_of
/// Determines if TBase is a virtual base class of TDerived
///\ingroup type_traits
#if ETL_HAS_STD_IS_VIRTUAL_BASE_OF
template <typename TBase, typename TDerived>
struct is_virtual_base_of : std::is_virtual_base_of<TBase, TDerived>
{
};
#if ETL_USING_CPP17
template <typename TBase, typename TDerived>
inline constexpr bool is_virtual_base_of_v = std::is_virtual_base_of_v<TBase, TDerived>;
#endif
#elif ETL_USING_BUILTIN_IS_VIRTUAL_BASE_OF
template <typename TBase, typename TDerived>
struct is_virtual_base_of : etl::bool_constant<__is_virtual_base_of(TBase, TDerived)>
{
};
#if ETL_USING_CPP17
template <typename TBase, typename TDerived>
inline constexpr bool is_virtual_base_of_v = is_virtual_base_of<TBase, TDerived>::value;
#endif
#endif
//***************************************************************************
/// is_class
template <typename T>
@ -2594,6 +2635,41 @@ namespace etl
template <typename T>
using is_move_assignable = std::is_move_assignable<T>;
//*********************************************
// is_nothrow_constructible
template <typename T, typename... TArgs>
using is_nothrow_constructible = std::is_nothrow_constructible<T, TArgs...>;
//*********************************************
// is_nothrow_default_constructible
template <typename T>
using is_nothrow_default_constructible = std::is_nothrow_default_constructible<T>;
//*********************************************
// is_nothrow_copy_constructible
template <typename T>
using is_nothrow_copy_constructible = std::is_nothrow_copy_constructible<T>;
//*********************************************
// is_nothrow_move_constructible
template <typename T>
using is_nothrow_move_constructible = std::is_nothrow_move_constructible<T>;
//*********************************************
// is_nothrow_assignable
template <typename T, typename U>
using is_nothrow_assignable = std::is_nothrow_assignable<T, U>;
//*********************************************
// is_nothrow_copy_assignable
template <typename T>
using is_nothrow_copy_assignable = std::is_nothrow_copy_assignable<T>;
//*********************************************
// is_nothrow_move_assignable
template <typename T>
using is_nothrow_move_assignable = std::is_nothrow_move_assignable<T>;
//*********************************************
// is_trivially_constructible
#if ETL_CPP11_TYPE_TRAITS_IS_TRIVIAL_SUPPORTED
@ -2647,6 +2723,40 @@ namespace etl
using is_trivially_copyable = etl::bool_constant<etl::is_arithmetic<T>::value || etl::is_pointer<T>::value>;
#endif
//*********************************************
// is_trivially_relocatable
#if ETL_HAS_STD_TRIVIALLY_RELOCATABLE && ETL_USING_STL
template <typename T>
using is_trivially_relocatable = std::is_trivially_relocatable<T>;
#elif ETL_USING_BUILTIN_BUILTIN_IS_CPP_TRIVIALLY_RELOCATABLE
template <typename T>
using is_trivially_relocatable = etl::bool_constant<__builtin_is_cpp_trivially_relocatable(T)>;
#elif ETL_USING_BUILTIN_IS_TRIVIALLY_RELOCATABLE
template <typename T>
using is_trivially_relocatable = etl::bool_constant<__is_trivially_relocatable(T)>;
#else
template <typename T>
using is_trivially_relocatable = etl::bool_constant<etl::is_trivially_copyable<T>::value && etl::is_trivially_destructible<T>::value>;
#endif
//*********************************************
// is_nothrow_relocatable
// A type is nothrow relocatable if it is trivially relocatable, or
// if it has a nothrow move constructor and nothrow destructor.
#if ETL_HAS_STD_TRIVIALLY_RELOCATABLE && ETL_USING_STL
template <typename T>
using is_nothrow_relocatable = std::is_nothrow_relocatable<T>;
#elif ETL_USING_STL
template <typename T>
using is_nothrow_relocatable = etl::bool_constant< etl::is_trivially_relocatable<T>::value
|| (std::is_nothrow_move_constructible<typename etl::remove_all_extents<T>::type>::value
&& std::is_nothrow_destructible<typename etl::remove_all_extents<T>::type>::value)>;
#else
// Fallback: only trivially relocatable types are known to be nothrow relocatable
template <typename T>
using is_nothrow_relocatable = etl::is_trivially_relocatable<T>;
#endif
#elif defined(ETL_USE_TYPE_TRAITS_BUILTINS) && !defined(ETL_USER_DEFINED_TYPE_TRAITS)
//*********************************************
@ -2723,6 +2833,71 @@ namespace etl
};
#endif
#if ETL_USING_CPP11
//*********************************************
// is_nothrow_constructible
template <typename T, typename... TArgs>
struct is_nothrow_constructible
{
#if ETL_USING_BUILTIN_IS_NOTHROW_CONSTRUCTIBLE
static ETL_CONSTANT bool value = __is_nothrow_constructible(T, TArgs...);
#else
static ETL_CONSTANT bool value = etl::is_arithmetic<T>::value || etl::is_pointer<T>::value;
#endif
};
//*********************************************
// is_nothrow_default_constructible
template <typename T>
struct is_nothrow_default_constructible : public etl::is_nothrow_constructible<T>
{
};
//*********************************************
// is_nothrow_copy_constructible
template <typename T>
struct is_nothrow_copy_constructible : public etl::is_nothrow_constructible<T, typename etl::add_lvalue_reference<const T>::type>
{
};
//*********************************************
// is_nothrow_move_constructible
template <typename T>
struct is_nothrow_move_constructible : public etl::is_nothrow_constructible<T, typename etl::add_rvalue_reference<T>::type>
{
};
#endif
#if ETL_USING_CPP11
//*********************************************
// is_nothrow_assignable
template <typename T, typename U>
struct is_nothrow_assignable
{
#if ETL_USING_BUILTIN_IS_NOTHROW_ASSIGNABLE
static ETL_CONSTANT bool value = __is_nothrow_assignable(T, U);
#else
static ETL_CONSTANT bool value = etl::is_arithmetic<T>::value || etl::is_pointer<T>::value;
#endif
};
//*********************************************
// is_nothrow_copy_assignable
template <typename T>
struct is_nothrow_copy_assignable
: public etl::is_nothrow_assignable<typename etl::add_lvalue_reference<T>::type, typename etl::add_lvalue_reference<const T>::type>
{
};
//*********************************************
// is_nothrow_move_assignable
template <typename T>
struct is_nothrow_move_assignable
: public etl::is_nothrow_assignable<typename etl::add_lvalue_reference<T>::type, typename etl::add_rvalue_reference<T>::type>
{
};
#endif
#if ETL_USING_CPP11
//*********************************************
// is_trivially_constructible
@ -2800,6 +2975,31 @@ namespace etl
static ETL_CONSTANT bool value = __is_trivially_copyable(T);
};
//*********************************************
// is_trivially_relocatable
template <typename T>
struct is_trivially_relocatable
{
#if ETL_USING_BUILTIN_BUILTIN_IS_CPP_TRIVIALLY_RELOCATABLE
static ETL_CONSTANT bool value = __builtin_is_cpp_trivially_relocatable(T);
#elif ETL_USING_BUILTIN_IS_TRIVIALLY_RELOCATABLE
static ETL_CONSTANT bool value = __is_trivially_relocatable(T);
#else
static ETL_CONSTANT bool value = etl::is_trivially_copyable<T>::value && etl::is_trivially_destructible<T>::value;
#endif
};
//*********************************************
// is_nothrow_relocatable
// A type is nothrow relocatable if it is trivially relocatable, or
// if it has a nothrow move constructor and nothrow destructor.
template <typename T>
struct is_nothrow_relocatable
{
// In builtins mode, conservatively use trivially_relocatable as the definition
static ETL_CONSTANT bool value = etl::is_trivially_relocatable<T>::value;
};
#elif defined(ETL_USER_DEFINED_TYPE_TRAITS) && !defined(ETL_USE_TYPE_TRAITS_BUILTINS)
//*********************************************
@ -2894,6 +3094,104 @@ namespace etl
template <typename T>
struct is_move_assignable<T, false>;
#if ETL_USING_CPP11
//*********************************************
// is_nothrow_constructible
template <typename T, bool BValue, typename... TArgs>
struct is_nothrow_constructible_helper;
template <typename T, typename... TArgs>
struct is_nothrow_constructible_helper<T, true, TArgs...> : public etl::true_type
{
};
template <typename T, typename... TArgs>
struct is_nothrow_constructible_helper<T, false, TArgs...>;
template <typename T, typename... TArgs>
struct is_nothrow_constructible : public is_nothrow_constructible_helper<T, etl::is_arithmetic<T>::value || etl::is_pointer<T>::value, TArgs...>
{
};
//*********************************************
// is_nothrow_default_constructible
template <typename T, bool BValue = etl::is_arithmetic<T>::value || etl::is_pointer<T>::value>
struct is_nothrow_default_constructible;
template <typename T>
struct is_nothrow_default_constructible<T, true> : public etl::true_type
{
};
template <typename T>
struct is_nothrow_default_constructible<T, false>;
//*********************************************
// is_nothrow_copy_constructible
template <typename T, bool BValue = etl::is_arithmetic<T>::value || etl::is_pointer<T>::value>
struct is_nothrow_copy_constructible;
template <typename T>
struct is_nothrow_copy_constructible<T, true> : public etl::true_type
{
};
template <typename T>
struct is_nothrow_copy_constructible<T, false>;
//*********************************************
// is_nothrow_move_constructible
template <typename T, bool BValue = etl::is_arithmetic<T>::value || etl::is_pointer<T>::value>
struct is_nothrow_move_constructible;
template <typename T>
struct is_nothrow_move_constructible<T, true> : public etl::true_type
{
};
template <typename T>
struct is_nothrow_move_constructible<T, false>;
//*********************************************
// is_nothrow_assignable
template <typename T, typename U, bool BValue = etl::is_arithmetic<T>::value || etl::is_pointer<T>::value>
struct is_nothrow_assignable;
template <typename T, typename U>
struct is_nothrow_assignable<T, U, true> : public etl::true_type
{
};
template <typename T, typename U>
struct is_nothrow_assignable<T, U, false>;
//*********************************************
// is_nothrow_copy_assignable
template <typename T, bool BValue = etl::is_arithmetic<T>::value || etl::is_pointer<T>::value>
struct is_nothrow_copy_assignable;
template <typename T>
struct is_nothrow_copy_assignable<T, true> : public etl::true_type
{
};
template <typename T>
struct is_nothrow_copy_assignable<T, false>;
//*********************************************
// is_nothrow_move_assignable
template <typename T, bool BValue = etl::is_arithmetic<T>::value || etl::is_pointer<T>::value>
struct is_nothrow_move_assignable;
template <typename T>
struct is_nothrow_move_assignable<T, true> : public etl::true_type
{
};
template <typename T>
struct is_nothrow_move_assignable<T, false>;
#endif
//*********************************************
// is_trivially_constructible
template <typename T, bool BValue = etl::is_arithmetic<T>::value || etl::is_pointer<T>::value>
@ -2959,6 +3257,33 @@ namespace etl
template <typename T>
struct is_trivially_copyable<T, false>;
//*********************************************
// is_trivially_relocatable
template <typename T, bool BValue = etl::is_arithmetic<T>::value || etl::is_pointer<T>::value>
struct is_trivially_relocatable;
template <typename T>
struct is_trivially_relocatable<T, true> : public etl::true_type
{
};
template <typename T>
struct is_trivially_relocatable<T, false>;
//*********************************************
// is_nothrow_relocatable
// In user-defined mode, users must specialize for non-trivially-relocatable types
template <typename T, bool BValue = etl::is_arithmetic<T>::value || etl::is_pointer<T>::value>
struct is_nothrow_relocatable;
template <typename T>
struct is_nothrow_relocatable<T, true> : public etl::true_type
{
};
template <typename T>
struct is_nothrow_relocatable<T, false>;
#else
//*********************************************
@ -3087,6 +3412,57 @@ namespace etl
};
#endif
#if ETL_USING_CPP11
//*********************************************
// is_nothrow_constructible
template <typename T, typename... TArgs>
struct is_nothrow_constructible : public etl::bool_constant<etl::is_arithmetic<T>::value || etl::is_pointer<T>::value>
{
};
//*********************************************
// is_nothrow_default_constructible
template <typename T>
struct is_nothrow_default_constructible : public etl::bool_constant<etl::is_arithmetic<T>::value || etl::is_pointer<T>::value>
{
};
//*********************************************
// is_nothrow_copy_constructible
template <typename T>
struct is_nothrow_copy_constructible : public etl::bool_constant<etl::is_arithmetic<T>::value || etl::is_pointer<T>::value>
{
};
//*********************************************
// is_nothrow_move_constructible
template <typename T>
struct is_nothrow_move_constructible : public etl::bool_constant<etl::is_arithmetic<T>::value || etl::is_pointer<T>::value>
{
};
//*********************************************
// is_nothrow_assignable
template <typename T, typename U>
struct is_nothrow_assignable : public etl::bool_constant<etl::is_arithmetic<T>::value || etl::is_pointer<T>::value>
{
};
//*********************************************
// is_nothrow_copy_assignable
template <typename T>
struct is_nothrow_copy_assignable : public etl::bool_constant<etl::is_arithmetic<T>::value || etl::is_pointer<T>::value>
{
};
//*********************************************
// is_nothrow_move_assignable
template <typename T>
struct is_nothrow_move_assignable : public etl::bool_constant<etl::is_arithmetic<T>::value || etl::is_pointer<T>::value>
{
};
#endif
//*********************************************
// is_trivially_constructible
template <typename T>
@ -3126,6 +3502,27 @@ namespace etl
{
};
//*********************************************
// is_trivially_relocatable
template <typename T>
#if ETL_USING_BUILTIN_BUILTIN_IS_CPP_TRIVIALLY_RELOCATABLE
struct is_trivially_relocatable : public etl::bool_constant<__builtin_is_cpp_trivially_relocatable(T)>
#elif ETL_USING_BUILTIN_IS_TRIVIALLY_RELOCATABLE
struct is_trivially_relocatable : public etl::bool_constant<__is_trivially_relocatable(T)>
#else
struct is_trivially_relocatable : public etl::bool_constant<etl::is_trivially_copyable<T>::value && etl::is_trivially_destructible<T>::value>
#endif
{
};
//*********************************************
// is_nothrow_relocatable
// Fallback: only trivially relocatable types are known to be nothrow relocatable
template <typename T>
struct is_nothrow_relocatable : public etl::is_trivially_relocatable<T>
{
};
#endif
template <typename T1, typename T2>
@ -3180,6 +3577,27 @@ namespace etl
template <typename T>
inline constexpr bool is_move_assignable_v = etl::is_move_assignable<T>::value;
template <typename T, typename... TArgs>
inline constexpr bool is_nothrow_constructible_v = etl::is_nothrow_constructible<T, TArgs...>::value;
template <typename T>
inline constexpr bool is_nothrow_default_constructible_v = etl::is_nothrow_default_constructible<T>::value;
template <typename T>
inline constexpr bool is_nothrow_copy_constructible_v = etl::is_nothrow_copy_constructible<T>::value;
template <typename T>
inline constexpr bool is_nothrow_move_constructible_v = etl::is_nothrow_move_constructible<T>::value;
template <typename T, typename U>
inline constexpr bool is_nothrow_assignable_v = etl::is_nothrow_assignable<T, U>::value;
template <typename T>
inline constexpr bool is_nothrow_copy_assignable_v = etl::is_nothrow_copy_assignable<T>::value;
template <typename T>
inline constexpr bool is_nothrow_move_assignable_v = etl::is_nothrow_move_assignable<T>::value;
template <typename T>
inline constexpr bool is_trivially_constructible_v = etl::is_trivially_constructible<T>::value;
@ -3195,6 +3613,12 @@ namespace etl
template <typename T>
inline constexpr bool is_trivially_copyable_v = etl::is_trivially_copyable<T>::value;
template <typename T>
inline constexpr bool is_trivially_relocatable_v = etl::is_trivially_relocatable<T>::value;
template <typename T>
inline constexpr bool is_nothrow_relocatable_v = etl::is_nothrow_relocatable<T>::value;
#endif
#if ETL_USING_CPP11

34
include/etl/vector.h
View File

@ -479,7 +479,9 @@ namespace etl
{
ETL_ASSERT_CHECK_PUSH_POP(size() != CAPACITY, ETL_ERROR(vector_full));
#include "private/diagnostic_sign_conversion_push.h"
::new (p_end) T(etl::forward<Args>(args)...);
#include "private/diagnostic_pop.h"
++p_end;
ETL_INCREMENT_DEBUG_COUNT;
return back();
@ -668,7 +670,9 @@ namespace etl
(*position_).~T();
}
#include "private/diagnostic_sign_conversion_push.h"
::new (p) T(etl::forward<Args>(args)...);
#include "private/diagnostic_pop.h"
return position_;
}
@ -1014,7 +1018,7 @@ namespace etl
//*************************************************************************
/// Move assignment operator.
//*************************************************************************
ivector& operator=(ivector&& rhs)
ivector& operator=(ivector&& rhs) ETL_NOEXCEPT_IF((etl::is_nothrow_move_constructible<T>::value))
{
if (&rhs != this)
{
@ -1081,7 +1085,7 @@ namespace etl
//*********************************************************************
/// Constructor.
//*********************************************************************
ivector(T* p_buffer_, size_t MAX_SIZE)
ivector(T* p_buffer_, size_t MAX_SIZE) ETL_NOEXCEPT
: vector_base(MAX_SIZE)
, p_buffer(p_buffer_)
, p_end(p_buffer_)
@ -1284,7 +1288,7 @@ namespace etl
//*************************************************************************
/// Constructor.
//*************************************************************************
vector()
vector() ETL_NOEXCEPT
: etl::ivector<T>(reinterpret_cast<T*>(&buffer), MAX_SIZE)
{
this->initialise();
@ -1363,7 +1367,7 @@ namespace etl
//*************************************************************************
/// Move constructor.
//*************************************************************************
vector(vector&& other)
vector(vector&& other) ETL_NOEXCEPT_IF((etl::is_nothrow_move_constructible<T>::value))
: etl::ivector<T>(reinterpret_cast<T*>(&buffer), MAX_SIZE)
{
if (this != &other)
@ -1384,7 +1388,7 @@ namespace etl
//*************************************************************************
/// Move assignment operator.
//*************************************************************************
vector& operator=(vector&& rhs)
vector& operator=(vector&& rhs) ETL_NOEXCEPT_IF((etl::is_nothrow_move_constructible<T>::value))
{
if (&rhs != this)
{
@ -1409,7 +1413,7 @@ namespace etl
#ifdef ETL_IVECTOR_REPAIR_ENABLE
virtual
#endif
~vector()
~vector() ETL_NOEXCEPT
{
this->clear();
}
@ -1466,7 +1470,7 @@ namespace etl
//*************************************************************************
/// Constructor.
//*************************************************************************
vector_ext(void* buffer, size_t max_size)
vector_ext(void* buffer, size_t max_size) ETL_NOEXCEPT
: etl::ivector<T>(reinterpret_cast<T*>(buffer), max_size)
{
this->initialise();
@ -1546,7 +1550,7 @@ namespace etl
//*************************************************************************
/// Move constructor.
//*************************************************************************
vector_ext(vector_ext&& other, void* buffer, size_t max_size)
vector_ext(vector_ext&& other, void* buffer, size_t max_size) ETL_NOEXCEPT_IF((etl::is_nothrow_move_constructible<T>::value))
: etl::ivector<T>(reinterpret_cast<T*>(buffer), max_size)
{
if (this != &other)
@ -1567,7 +1571,7 @@ namespace etl
//*************************************************************************
/// Move assignment operator.
//*************************************************************************
vector_ext& operator=(vector_ext&& rhs)
vector_ext& operator=(vector_ext&& rhs) ETL_NOEXCEPT_IF((etl::is_nothrow_move_constructible<T>::value))
{
if (&rhs != this)
{
@ -1590,7 +1594,7 @@ namespace etl
//*************************************************************************
/// Destructor.
//*************************************************************************
~vector_ext()
~vector_ext() ETL_NOEXCEPT
{
this->clear();
}
@ -1625,7 +1629,7 @@ namespace etl
//*************************************************************************
/// Constructor.
//*************************************************************************
vector()
vector() ETL_NOEXCEPT
: etl::ivector<T*>(reinterpret_cast<T**>(&buffer), MAX_SIZE)
{
this->initialise();
@ -1701,7 +1705,7 @@ namespace etl
//*************************************************************************
/// Move constructor.
//*************************************************************************
vector(vector&& other)
vector(vector&& other) ETL_NOEXCEPT
: etl::ivector<T*>(reinterpret_cast<T**>(&buffer), MAX_SIZE)
{
(void)etl::ivector<T*>::operator=(etl::move(other));
@ -1710,7 +1714,7 @@ namespace etl
//*************************************************************************
/// Move assignment operator.
//*************************************************************************
vector& operator=(vector&& rhs)
vector& operator=(vector&& rhs) ETL_NOEXCEPT
{
(void)etl::ivector<T*>::operator=(etl::move(rhs));
@ -1765,7 +1769,7 @@ namespace etl
//*************************************************************************
/// Constructor.
//*************************************************************************
vector_ext(void* buffer, size_t max_size)
vector_ext(void* buffer, size_t max_size) ETL_NOEXCEPT
: etl::ivector<T*>(reinterpret_cast<T**>(buffer), max_size)
{
this->initialise();
@ -1872,7 +1876,7 @@ namespace etl
//*************************************************************************
/// Destructor.
//*************************************************************************
~vector_ext()
~vector_ext() ETL_NOEXCEPT
{
this->clear();
}

18
scripts/run-docker.sh Executable file
View File

@ -0,0 +1,18 @@
#!/bin/bash
#
# Create docker image for development environment and enter container
#
# Run from project root directory
#
set -e
# Verify script is running from project root
if [ ! -d ".devcontainer" ]; then
echo "Error: This script must be run from the project root directory." >&2
echo "The .devcontainer directory was not found." >&2
exit 1
fi
docker build -t etl .devcontainer
docker run -it --rm -v "$(pwd)":/home/vscode/etl -u vscode -w /home/vscode/etl etl /bin/bash

32
test/CMakeLists.txt
View File

@ -83,8 +83,9 @@ add_executable(etl_tests
test_circular_buffer.cpp
test_circular_buffer_external_buffer.cpp
test_circular_iterator.cpp
test_closure.cpp
test_closure_constexpr.cpp
test_closure_with_default_delegate.cpp
test_closure_with_default_delegate_constexpr.cpp
test_closure_with_inplace_function.cpp
test_compare.cpp
test_concepts.cpp
test_constant.cpp
@ -384,6 +385,7 @@ option(ETL_NO_STL "No STL" OFF)
set(EXTRA_COMPILE_OPTIONS "" CACHE STRING "Additional compiler options")
set(EXTRA_LINK_OPTIONS "" CACHE STRING "Additional linker options")
set(EXTRA_LINK_LIBS "" CACHE STRING "Additional libraries to link")
set(EXTRA_TESTING_FLAGS "" CACHE STRING "Additional testing flags for ctest")
if (ETL_CXX_STANDARD MATCHES "98")
message(STATUS "Compiling for C++98")
@ -404,10 +406,26 @@ elseif (ETL_CXX_STANDARD MATCHES "20")
message(STATUS "Compiling for C++20")
set_property(TARGET etl_tests PROPERTY CXX_STANDARD 20)
elseif (ETL_CXX_STANDARD MATCHES "23")
message(STATUS "Compiling for C++23")
set_property(TARGET etl_tests PROPERTY CXX_STANDARD 23)
if (CMAKE_VERSION VERSION_GREATER_EQUAL "3.20")
message(STATUS "Compiling for C++23")
set_property(TARGET etl_tests PROPERTY CXX_STANDARD 23)
else()
message(STATUS "CMake version ${CMAKE_VERSION} does not support C++23, falling back to C++20")
set_property(TARGET etl_tests PROPERTY CXX_STANDARD 20)
endif()
elseif (ETL_CXX_STANDARD MATCHES "26")
if (CMAKE_VERSION VERSION_GREATER_EQUAL "3.25")
message(STATUS "Compiling for C++26")
set_property(TARGET etl_tests PROPERTY CXX_STANDARD 26)
elseif (CMAKE_VERSION VERSION_GREATER_EQUAL "3.20")
message(STATUS "CMake version ${CMAKE_VERSION} does not support C++26, falling back to C++23")
set_property(TARGET etl_tests PROPERTY CXX_STANDARD 23)
else()
message(FATAL_ERROR "CMake version ${CMAKE_VERSION} is too old to support C++23 or C++26. Please upgrade to CMake 3.20 or later.")
endif()
else()
message(STATUS "Unsupported C++ standard")
message(STATUS "Compiling for C++17")
set_property(TARGET etl_tests PROPERTY CXX_STANDARD 17)
endif()
if (NO_STL OR ETL_NO_STL)
@ -523,7 +541,7 @@ if ((CMAKE_CXX_COMPILER_ID MATCHES "GNU") OR (CMAKE_CXX_COMPILER_ID MATCHES "Cla
target_link_options(etl_tests
PRIVATE
-fsanitize=address,undefined,bounds
)
)
endif()
endif ()
endif ()
@ -537,7 +555,7 @@ target_link_libraries(etl_tests PRIVATE UnitTestpp ${EXTRA_LINK_LIBS})
enable_testing()
# Enable the 'make test' CMake target using the executable defined above
add_test(NAME etl_unit_tests COMMAND etl_tests)
add_test(NAME etl_unit_tests COMMAND etl_tests ${EXTRA_TESTING_FLAGS})
# Since ctest will only show you the results of the single executable
# define a target that will output all of the failing or passing tests

22
test/etl_error_handler/assert_function/CMakeLists.txt
View File

@ -34,9 +34,27 @@ elseif (ETL_CXX_STANDARD MATCHES "17")
elseif (ETL_CXX_STANDARD MATCHES "20")
message(STATUS "Compiling for C++20")
set_property(TARGET etl_tests PROPERTY CXX_STANDARD 20)
elseif (ETL_CXX_STANDARD MATCHES "23")
if (CMAKE_VERSION VERSION_GREATER_EQUAL "3.20")
message(STATUS "Compiling for C++23")
set_property(TARGET etl_tests PROPERTY CXX_STANDARD 23)
else()
message(STATUS "CMake version ${CMAKE_VERSION} does not support C++23, falling back to C++20")
set_property(TARGET etl_tests PROPERTY CXX_STANDARD 20)
endif()
elseif (ETL_CXX_STANDARD MATCHES "26")
if (CMAKE_VERSION VERSION_GREATER_EQUAL "3.25")
message(STATUS "Compiling for C++26")
set_property(TARGET etl_tests PROPERTY CXX_STANDARD 26)
elseif (CMAKE_VERSION VERSION_GREATER_EQUAL "3.20")
message(STATUS "CMake version ${CMAKE_VERSION} does not support C++26, falling back to C++23")
set_property(TARGET etl_tests PROPERTY CXX_STANDARD 23)
else()
message(FATAL_ERROR "CMake version ${CMAKE_VERSION} is too old to support C++23 or C++26. Please upgrade to CMake 3.20 or later.")
endif()
else()
message(STATUS "Compiling for C++23")
set_property(TARGET etl_tests PROPERTY CXX_STANDARD 23)
message(STATUS "Compiling for C++17")
set_property(TARGET etl_tests PROPERTY CXX_STANDARD 17)
endif()
if (ETL_OPTIMISATION MATCHES "-O1")

22
test/etl_error_handler/exceptions/CMakeLists.txt
View File

@ -32,9 +32,27 @@ elseif (ETL_CXX_STANDARD MATCHES "17")
elseif (ETL_CXX_STANDARD MATCHES "20")
message(STATUS "Compiling for C++20")
set_property(TARGET etl_tests PROPERTY CXX_STANDARD 20)
elseif (ETL_CXX_STANDARD MATCHES "23")
if (CMAKE_VERSION VERSION_GREATER_EQUAL "3.20")
message(STATUS "Compiling for C++23")
set_property(TARGET etl_tests PROPERTY CXX_STANDARD 23)
else()
message(STATUS "CMake version ${CMAKE_VERSION} does not support C++23, falling back to C++20")
set_property(TARGET etl_tests PROPERTY CXX_STANDARD 20)
endif()
elseif (ETL_CXX_STANDARD MATCHES "26")
if (CMAKE_VERSION VERSION_GREATER_EQUAL "3.25")
message(STATUS "Compiling for C++26")
set_property(TARGET etl_tests PROPERTY CXX_STANDARD 26)
elseif (CMAKE_VERSION VERSION_GREATER_EQUAL "3.20")
message(STATUS "CMake version ${CMAKE_VERSION} does not support C++26, falling back to C++23")
set_property(TARGET etl_tests PROPERTY CXX_STANDARD 23)
else()
message(FATAL_ERROR "CMake version ${CMAKE_VERSION} is too old to support C++23 or C++26. Please upgrade to CMake 3.20 or later.")
endif()
else()
message(STATUS "Compiling for C++23")
set_property(TARGET etl_tests PROPERTY CXX_STANDARD 23)
message(STATUS "Compiling for C++17")
set_property(TARGET etl_tests PROPERTY CXX_STANDARD 17)
endif()
if (ETL_OPTIMISATION MATCHES "-O1")

28
test/etl_error_handler/log_errors/CMakeLists.txt
View File

@ -18,7 +18,7 @@ if (ETL_CXX_STANDARD MATCHES "98")
message(STATUS "Compiling for C++98")
set_property(TARGET etl_tests PROPERTY CXX_STANDARD 98)
elseif (ETL_CXX_STANDARD MATCHES "03")
message(STATUS "Compiling for C++98")
message(STATUS "Compiling for C++03")
set_property(TARGET etl_tests PROPERTY CXX_STANDARD 98)
elseif (ETL_CXX_STANDARD MATCHES "11")
message(STATUS "Compiling for C++11")
@ -32,9 +32,27 @@ elseif (ETL_CXX_STANDARD MATCHES "17")
elseif (ETL_CXX_STANDARD MATCHES "20")
message(STATUS "Compiling for C++20")
set_property(TARGET etl_tests PROPERTY CXX_STANDARD 20)
elseif (ETL_CXX_STANDARD MATCHES "23")
if (CMAKE_VERSION VERSION_GREATER_EQUAL "3.20")
message(STATUS "Compiling for C++23")
set_property(TARGET etl_tests PROPERTY CXX_STANDARD 23)
else()
message(STATUS "CMake version ${CMAKE_VERSION} does not support C++23, falling back to C++20")
set_property(TARGET etl_tests PROPERTY CXX_STANDARD 20)
endif()
elseif (ETL_CXX_STANDARD MATCHES "26")
if (CMAKE_VERSION VERSION_GREATER_EQUAL "3.25")
message(STATUS "Compiling for C++26")
set_property(TARGET etl_tests PROPERTY CXX_STANDARD 26)
elseif (CMAKE_VERSION VERSION_GREATER_EQUAL "3.20")
message(STATUS "CMake version ${CMAKE_VERSION} does not support C++26, falling back to C++23")
set_property(TARGET etl_tests PROPERTY CXX_STANDARD 23)
else()
message(FATAL_ERROR "CMake version ${CMAKE_VERSION} is too old to support C++23 or C++26. Please upgrade to CMake 3.20 or later.")
endif()
else()
message(STATUS "Compiling for C++23")
set_property(TARGET etl_tests PROPERTY CXX_STANDARD 23)
message(STATUS "Compiling for C++17")
set_property(TARGET etl_tests PROPERTY CXX_STANDARD 17)
endif()
if (ETL_OPTIMISATION MATCHES "-O1")
@ -121,7 +139,3 @@ add_test(etl_error_handler_unit_tests etl_tests)
# as they appear from UnitTest++
add_custom_target(test_verbose COMMAND ${CMAKE_CTEST_COMMAND} --verbose)
#RSG
set_property(TARGET etl_tests PROPERTY CXX_STANDARD 17)

6
test/etl_error_handler/log_errors/test_error_handler.cpp
View File

@ -117,12 +117,12 @@ bool AssertFailAndReturnValue()
return false;
}
static ErrorLog error_log;
//*****************************************************************************
int main()
{
static ErrorLog error_log;
etl::error_handler::set_callback<ErrorLog, error_log, &ErrorLog::Log>();
etl::error_handler::set_callback<ErrorLog, &ErrorLog::Log>(error_log);
Assert(false);
Assert(true);

26
test/etl_error_handler/log_errors_and_exceptions/CMakeLists.txt
View File

@ -33,9 +33,27 @@ elseif (ETL_CXX_STANDARD MATCHES "17")
elseif (ETL_CXX_STANDARD MATCHES "20")
message(STATUS "Compiling for C++20")
set_property(TARGET etl_tests PROPERTY CXX_STANDARD 20)
elseif (ETL_CXX_STANDARD MATCHES "23")
if (CMAKE_VERSION VERSION_GREATER_EQUAL "3.20")
message(STATUS "Compiling for C++23")
set_property(TARGET etl_tests PROPERTY CXX_STANDARD 23)
else()
message(STATUS "CMake version ${CMAKE_VERSION} does not support C++23, falling back to C++20")
set_property(TARGET etl_tests PROPERTY CXX_STANDARD 20)
endif()
elseif (ETL_CXX_STANDARD MATCHES "26")
if (CMAKE_VERSION VERSION_GREATER_EQUAL "3.25")
message(STATUS "Compiling for C++26")
set_property(TARGET etl_tests PROPERTY CXX_STANDARD 26)
elseif (CMAKE_VERSION VERSION_GREATER_EQUAL "3.20")
message(STATUS "CMake version ${CMAKE_VERSION} does not support C++26, falling back to C++23")
set_property(TARGET etl_tests PROPERTY CXX_STANDARD 23)
else()
message(FATAL_ERROR "CMake version ${CMAKE_VERSION} is too old to support C++23 or C++26. Please upgrade to CMake 3.20 or later.")
endif()
else()
message(STATUS "Compiling for C++23")
set_property(TARGET etl_tests PROPERTY CXX_STANDARD 23)
message(STATUS "Compiling for C++17")
set_property(TARGET etl_tests PROPERTY CXX_STANDARD 17)
endif()
if (ETL_OPTIMISATION MATCHES "-O1")
@ -120,7 +138,3 @@ add_test(etl_error_handler_unit_tests etl_tests)
# as they appear from UnitTest++
add_custom_target(test_verbose COMMAND ${CMAKE_CTEST_COMMAND} --verbose)
#RSG
set_property(TARGET etl_tests PROPERTY CXX_STANDARD 17)

22
test/etl_initializer_list/CMakeLists.txt
View File

@ -48,9 +48,27 @@ elseif (ETL_CXX_STANDARD MATCHES "17")
elseif (ETL_CXX_STANDARD MATCHES "20")
message(STATUS "Compiling for C++20")
set_property(TARGET etl_tests PROPERTY CXX_STANDARD 20)
elseif (ETL_CXX_STANDARD MATCHES "23")
if (CMAKE_VERSION VERSION_GREATER_EQUAL "3.20")
message(STATUS "Compiling for C++23")
set_property(TARGET etl_tests PROPERTY CXX_STANDARD 23)
else()
message(STATUS "CMake version ${CMAKE_VERSION} does not support C++23, falling back to C++20")
set_property(TARGET etl_tests PROPERTY CXX_STANDARD 20)
endif()
elseif (ETL_CXX_STANDARD MATCHES "26")
if (CMAKE_VERSION VERSION_GREATER_EQUAL "3.25")
message(STATUS "Compiling for C++26")
set_property(TARGET etl_tests PROPERTY CXX_STANDARD 26)
elseif (CMAKE_VERSION VERSION_GREATER_EQUAL "3.20")
message(STATUS "CMake version ${CMAKE_VERSION} does not support C++26, falling back to C++23")
set_property(TARGET etl_tests PROPERTY CXX_STANDARD 23)
else()
message(FATAL_ERROR "CMake version ${CMAKE_VERSION} is too old to support C++23 or C++26. Please upgrade to CMake 3.20 or later.")
endif()
else()
message(STATUS "Compiling for C++23")
set_property(TARGET etl_tests PROPERTY CXX_STANDARD 23)
message(STATUS "Compiling for C++17")
set_property(TARGET etl_tests PROPERTY CXX_STANDARD 17)
endif()
target_include_directories(etl_tests

5
test/run-coverage.sh
View File

@ -44,7 +44,7 @@ mkdir -p "$BUILD"
cd "$BUILD" || exit 1
touch total.info
for CXXSTD in 11 14 17 20 23; do
for CXXSTD in 11 14 17 20 23 26; do
for NOSTL in OFF ON; do
rm -rf CMakeFiles
cmake -DEXTRA_COMPILE_OPTIONS="--coverage" \
@ -76,6 +76,7 @@ for CXXSTD in 11 14 17 20 23; do
done
genhtml total.info --output-directory coverage --rc "genhtml_branch_coverage=1" --branch-coverage -t $COMPILER \
--ignore-errors inconsistent
--ignore-errors inconsistent \
--ignore-errors category
cd ..

262
test/run-syntax-checks.sh
View File

@ -1,4 +1,4 @@
#!/bin/sh
#!/bin/bash
clear
echo -e
@ -47,7 +47,7 @@ PrintHelp()
echo "$HelpColour"
echo "----------------------------------------------------------------------------------"
echo " Syntax : ./runtests.sh <C++ Standard> <Threads> "
echo " C++ Standard : a, 03, 11, 14, 17, 20 or 23 (a = All standards) "
echo " C++ Standard : a, 03, 11, 14, 17, 20, 23 or 26 (a = All standards) "
echo " Threads : Number of threads to use. Default = 4 "
echo " Compiler select : gcc or clang. Default All compilers "
echo "----------------------------------------------------------------------------------"
@ -101,6 +101,8 @@ elif [ "$1" = "20" ]; then
requested_cxx_standard="20"
elif [ "$1" = "23" ]; then
requested_cxx_standard="23"
elif [ "$1" = "26" ]; then
requested_cxx_standard="26"
elif [ "$1" = "A" ]; then
requested_cxx_standard="All"
elif [ "$1" = "a" ]; then
@ -288,8 +290,8 @@ PrintHeader
rm -rdf bgcc
rm -rdf bclang
cmake -E make_directory bgcc bclang
CC=clang CXX=clang++ cmake -E chdir bgcc cmake -DNO_STL=OFF -DETL_USE_TYPE_TRAITS_BUILTINS=ON -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF -DETL_CXX_STANDARD=$cxx_standard ..
cmake --build bgcc
CC=clang CXX=clang++ cmake -E chdir bclang cmake -DNO_STL=OFF -DETL_USE_TYPE_TRAITS_BUILTINS=ON -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF -DETL_CXX_STANDARD=$cxx_standard ..
cmake --build bclang
if [ $? -eq 0 ]; then
PassedCompilation
else
@ -305,8 +307,8 @@ PrintHeader
rm -rdf bgcc
rm -rdf bclang
cmake -E make_directory bgcc bclang
CC=clang CXX=clang++ cmake -E chdir bgcc cmake -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=ON -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF -DETL_CXX_STANDARD=$cxx_standard ..
cmake --build bgcc
CC=clang CXX=clang++ cmake -E chdir bclang cmake -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=ON -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF -DETL_CXX_STANDARD=$cxx_standard ..
cmake --build bclang
if [ $? -eq 0 ]; then
PassedCompilation
else
@ -533,8 +535,8 @@ PrintHeader
rm -rdf bgcc
rm -rdf bclang
cmake -E make_directory bgcc bclang
CC=clang CXX=clang++ cmake -E chdir bgcc cmake -DNO_STL=OFF -DETL_USE_TYPE_TRAITS_BUILTINS=ON -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF -DETL_CXX_STANDARD=$cxx_standard ..
cmake --build bgcc
CC=clang CXX=clang++ cmake -E chdir bclang cmake -DNO_STL=OFF -DETL_USE_TYPE_TRAITS_BUILTINS=ON -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF -DETL_CXX_STANDARD=$cxx_standard ..
cmake --build bclang
if [ $? -eq 0 ]; then
PassedCompilation
else
@ -550,8 +552,8 @@ PrintHeader
rm -rdf bgcc
rm -rdf bclang
cmake -E make_directory bgcc bclang
CC=clang CXX=clang++ cmake -E chdir bgcc cmake -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=ON -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF -DETL_CXX_STANDARD=$cxx_standard ..
cmake --build bgcc
CC=clang CXX=clang++ cmake -E chdir bclang cmake -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=ON -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF -DETL_CXX_STANDARD=$cxx_standard ..
cmake --build bclang
if [ $? -eq 0 ]; then
PassedCompilation
else
@ -777,8 +779,8 @@ PrintHeader
rm -rdf bgcc
rm -rdf bclang
cmake -E make_directory bgcc bclang
CC=clang CXX=clang++ cmake -E chdir bgcc cmake -DNO_STL=OFF -DETL_USE_TYPE_TRAITS_BUILTINS=ON -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF -DETL_CXX_STANDARD=$cxx_standard ..
cmake --build bgcc
CC=clang CXX=clang++ cmake -E chdir bclang cmake -DNO_STL=OFF -DETL_USE_TYPE_TRAITS_BUILTINS=ON -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF -DETL_CXX_STANDARD=$cxx_standard ..
cmake --build bclang
if [ $? -eq 0 ]; then
PassedCompilation
else
@ -794,8 +796,8 @@ PrintHeader
rm -rdf bgcc
rm -rdf bclang
cmake -E make_directory bgcc bclang
CC=clang CXX=clang++ cmake -E chdir bgcc cmake -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=ON -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF -DETL_CXX_STANDARD=$cxx_standard ..
cmake --build bgcc
CC=clang CXX=clang++ cmake -E chdir bclang cmake -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=ON -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF -DETL_CXX_STANDARD=$cxx_standard ..
cmake --build bclang
if [ $? -eq 0 ]; then
PassedCompilation
else
@ -1021,8 +1023,8 @@ PrintHeader
rm -rdf bgcc
rm -rdf bclang
cmake -E make_directory bgcc bclang
CC=clang CXX=clang++ cmake -E chdir bgcc cmake -DNO_STL=OFF -DETL_USE_TYPE_TRAITS_BUILTINS=ON -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF -DETL_CXX_STANDARD=$cxx_standard ..
cmake --build bgcc
CC=clang CXX=clang++ cmake -E chdir bclang cmake -DNO_STL=OFF -DETL_USE_TYPE_TRAITS_BUILTINS=ON -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF -DETL_CXX_STANDARD=$cxx_standard ..
cmake --build bclang
if [ $? -eq 0 ]; then
PassedCompilation
else
@ -1038,8 +1040,8 @@ PrintHeader
rm -rdf bgcc
rm -rdf bclang
cmake -E make_directory bgcc bclang
CC=clang CXX=clang++ cmake -E chdir bgcc cmake -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=ON -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF -DETL_CXX_STANDARD=$cxx_standard ..
cmake --build bgcc
CC=clang CXX=clang++ cmake -E chdir bclang cmake -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=ON -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF -DETL_CXX_STANDARD=$cxx_standard ..
cmake --build bclang
if [ $? -eq 0 ]; then
PassedCompilation
else
@ -1265,8 +1267,8 @@ PrintHeader
rm -rdf bgcc
rm -rdf bclang
cmake -E make_directory bgcc bclang
CC=clang CXX=clang++ cmake -E chdir bgcc cmake -DNO_STL=OFF -DETL_USE_TYPE_TRAITS_BUILTINS=ON -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF -DETL_CXX_STANDARD=$cxx_standard ..
cmake --build bgcc
CC=clang CXX=clang++ cmake -E chdir bclang cmake -DNO_STL=OFF -DETL_USE_TYPE_TRAITS_BUILTINS=ON -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF -DETL_CXX_STANDARD=$cxx_standard ..
cmake --build bclang
if [ $? -eq 0 ]; then
PassedCompilation
else
@ -1282,8 +1284,8 @@ PrintHeader
rm -rdf bgcc
rm -rdf bclang
cmake -E make_directory bgcc bclang
CC=clang CXX=clang++ cmake -E chdir bgcc cmake -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=ON -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF -DETL_CXX_STANDARD=$cxx_standard ..
cmake --build bgcc
CC=clang CXX=clang++ cmake -E chdir bclang cmake -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=ON -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF -DETL_CXX_STANDARD=$cxx_standard ..
cmake --build bclang
if [ $? -eq 0 ]; then
PassedCompilation
else
@ -1509,8 +1511,8 @@ PrintHeader
rm -rdf bgcc
rm -rdf bclang
cmake -E make_directory bgcc bclang
CC=clang CXX=clang++ cmake -E chdir bgcc cmake -DNO_STL=OFF -DETL_USE_TYPE_TRAITS_BUILTINS=ON -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF -DETL_CXX_STANDARD=$cxx_standard ..
cmake --build bgcc
CC=clang CXX=clang++ cmake -E chdir bclang cmake -DNO_STL=OFF -DETL_USE_TYPE_TRAITS_BUILTINS=ON -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF -DETL_CXX_STANDARD=$cxx_standard ..
cmake --build bclang
if [ $? -eq 0 ]; then
PassedCompilation
else
@ -1526,7 +1528,30 @@ PrintHeader
rm -rdf bgcc
rm -rdf bclang
cmake -E make_directory bgcc bclang
CC=clang CXX=clang++ cmake -E chdir bgcc cmake -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=ON -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF -DETL_CXX_STANDARD=$cxx_standard ..
CC=clang CXX=clang++ cmake -E chdir bclang cmake -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=ON -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF -DETL_CXX_STANDARD=$cxx_standard ..
cmake --build bclang
if [ $? -eq 0 ]; then
PassedCompilation
else
FailedCompilation
exit $?
fi
fi
fi
###############################################################################
if [ "$requested_cxx_standard" = "26" ] || [ "$requested_cxx_standard" = "All" ]; then
SetCxxStandard "26"
if [ "$compiler_enabled" = "gcc" ] || [ "$compiler_enabled" = "All compilers" ]; then
SetConfigurationName "STL"
compiler=$gcc_compiler
PrintHeader
rm -rdf bgcc
rm -rdf bclang
cmake -E make_directory bgcc bclang
CC=gcc CXX=g++ cmake -E chdir bgcc cmake -DNO_STL=OFF -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF -DETL_CXX_STANDARD=$cxx_standard ..
cmake --build bgcc
if [ $? -eq 0 ]; then
PassedCompilation
@ -1536,6 +1561,193 @@ else
fi
fi
if [ "$compiler_enabled" = "gcc" ] || [ "$compiler_enabled" = "All compilers" ]; then
SetConfigurationName "No STL"
compiler=$gcc_compiler
PrintHeader
rm -rdf bgcc
rm -rdf bclang
cmake -E make_directory bgcc bclang
CC=gcc CXX=g++ cmake -E chdir bgcc cmake -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF -DETL_CXX_STANDARD=$cxx_standard ..
cmake --build bgcc
if [ $? -eq 0 ]; then
PassedCompilation
else
FailedCompilation
exit $?
fi
fi
if [ "$compiler_enabled" = "gcc" ] || [ "$compiler_enabled" = "All compilers" ]; then
SetConfigurationName "STL - Force C++03"
compiler=$gcc_compiler
PrintHeader
rm -rdf bgcc
rm -rdf bclang
cmake -E make_directory bgcc bclang
CC=gcc CXX=g++ cmake -E chdir bgcc cmake -DNO_STL=OFF -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=ON -DETL_CXX_STANDARD=$cxx_standard ..
cmake --build bgcc
if [ $? -eq 0 ]; then
PassedCompilation
else
FailedCompilation
exit $?
fi
fi
if [ "$compiler_enabled" = "gcc" ] || [ "$compiler_enabled" = "All compilers" ]; then
SetConfigurationName "No STL - Force C++03"
compiler=$gcc_compiler
PrintHeader
rm -rdf bgcc
rm -rdf bclang
cmake -E make_directory bgcc bclang
CC=gcc CXX=g++ cmake -E chdir bgcc cmake -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=ON -DETL_CXX_STANDARD=$cxx_standard ..
cmake --build bgcc
if [ $? -eq 0 ]; then
PassedCompilation
else
FailedCompilation
exit $?
fi
fi
if [ "$compiler_enabled" = "clang" ] || [ "$compiler_enabled" = "All compilers" ]; then
SetConfigurationName "STL"
compiler=$clang_compiler
PrintHeader
rm -rdf bgcc
rm -rdf bclang
cmake -E make_directory bgcc bclang
CC=clang CXX=clang++ cmake -E chdir bclang cmake -DNO_STL=OFF -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF -DETL_CXX_STANDARD=$cxx_standard ..
cmake --build bclang
if [ $? -eq 0 ]; then
PassedCompilation
else
FailedCompilation
exit $?
fi
fi
if [ "$compiler_enabled" = "clang" ] || [ "$compiler_enabled" = "All compilers" ]; then
SetConfigurationName "No STL"
compiler=$clang_compiler
PrintHeader
rm -rdf bgcc
rm -rdf bclang
cmake -E make_directory bgcc bclang
CC=clang CXX=clang++ cmake -E chdir bclang cmake -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF -DETL_CXX_STANDARD=$cxx_standard ..
cmake --build bclang
if [ $? -eq 0 ]; then
PassedCompilation
else
FailedCompilation
exit $?
fi
fi
if [ "$compiler_enabled" = "clang" ] || [ "$compiler_enabled" = "All compilers" ]; then
SetConfigurationName "STL - Force C++03"
compiler=$clang_compiler
PrintHeader
rm -rdf bgcc
rm -rdf bclang
cmake -E make_directory bgcc bclang
CC=clang CXX=clang++ cmake -E chdir bclang cmake -DNO_STL=OFF -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=ON -DETL_CXX_STANDARD=$cxx_standard ..
cmake --build bclang
if [ $? -eq 0 ]; then
PassedCompilation
else
FailedCompilation
exit $?
fi
fi
if [ "$compiler_enabled" = "clang" ] || [ "$compiler_enabled" = "All compilers" ]; then
SetConfigurationName "No STL - Force C++03"
compiler=$clang_compiler
PrintHeader
rm -rdf bgcc
rm -rdf bclang
cmake -E make_directory bgcc bclang
CC=clang CXX=clang++ cmake -E chdir bclang cmake -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=ON -DETL_CXX_STANDARD=$cxx_standard ..
cmake --build bclang
if [ $? -eq 0 ]; then
PassedCompilation
else
FailedCompilation
exit $?
fi
fi
if [ "$compiler_enabled" = "gcc" ] || [ "$compiler_enabled" = "All compilers" ]; then
SetConfigurationName "STL - Built-in traits"
compiler=$gcc_compiler
PrintHeader
rm -rdf bgcc
rm -rdf bclang
cmake -E make_directory bgcc bclang
CC=gcc CXX=g++ cmake -E chdir bgcc cmake -DNO_STL=OFF -DETL_USE_TYPE_TRAITS_BUILTINS=ON -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF -DETL_CXX_STANDARD=$cxx_standard ..
cmake --build bgcc
if [ $? -eq 0 ]; then
PassedCompilation
else
FailedCompilation
exit $?
fi
fi
if [ "$compiler_enabled" = "gcc" ] || [ "$compiler_enabled" = "All compilers" ]; then
SetConfigurationName "No STL - Built-in traits"
compiler=$gcc_compiler
PrintHeader
rm -rdf bgcc
rm -rdf bclang
cmake -E make_directory bgcc bclang
CC=gcc CXX=g++ cmake -E chdir bgcc cmake -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=ON -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF -DETL_CXX_STANDARD=$cxx_standard ..
cmake --build bgcc
if [ $? -eq 0 ]; then
PassedCompilation
else
FailedCompilation
exit $?
fi
fi
if [ "$compiler_enabled" = "clang" ] || [ "$compiler_enabled" = "All compilers" ]; then
SetConfigurationName "STL - Built-in traits"
compiler=$clang_compiler
PrintHeader
rm -rdf bgcc
rm -rdf bclang
cmake -E make_directory bgcc bclang
CC=clang CXX=clang++ cmake -E chdir bclang cmake -DNO_STL=OFF -DETL_USE_TYPE_TRAITS_BUILTINS=ON -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF -DETL_CXX_STANDARD=$cxx_standard ..
cmake --build bclang
if [ $? -eq 0 ]; then
PassedCompilation
else
FailedCompilation
exit $?
fi
fi
if [ "$compiler_enabled" = "clang" ] || [ "$compiler_enabled" = "All compilers" ]; then
SetConfigurationName "No STL - Built-in traits"
compiler=$clang_compiler
PrintHeader
rm -rdf bgcc
rm -rdf bclang
cmake -E make_directory bgcc bclang
CC=clang CXX=clang++ cmake -E chdir bclang cmake -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=ON -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF -DETL_CXX_STANDARD=$cxx_standard ..
cmake --build bclang
if [ $? -eq 0 ]; then
PassedCompilation
else
FailedCompilation
exit $?
fi
fi
fi
ChecksCompleted

138
test/run-tests.sh
View File

@ -2,6 +2,8 @@
shopt -s xpg_echo
set -e
clear
export ASAN_OPTIONS=symbol_line=1
@ -54,7 +56,7 @@ PrintHelp()
echo "$HelpColour"
echo "----------------------------------------------------------------------------------------------------------"
echo " Syntax : ./run-tests.sh <C++ Standard> <Optimisation> <Threads> <Sanitizer> <Compiler> <Verbose>"
echo " C++ Standard : 11, 14, 17, 20 or 23 "
echo " C++ Standard : 11, 14, 17, 20, 23, 26 or all "
echo " Optimisation : 0, 1, 2 or 3. Default = 0 "
echo " Threads : Number of threads to use. Default = 4 "
echo " Sanitizer : s enables sanitizer checks, n disables. Default disabled "
@ -115,15 +117,19 @@ TestsCompleted()
# Set the language standard.
#******************************************************************************
if [ "$1" = "11" ]; then
cxx_standard="11"
cxx_standards="11"
elif [ "$1" = "14" ]; then
cxx_standard="14"
cxx_standards="14"
elif [ "$1" = "17" ]; then
cxx_standard="17"
cxx_standards="17"
elif [ "$1" = "20" ]; then
cxx_standard="20"
cxx_standards="20"
elif [ "$1" = "23" ]; then
cxx_standard="23"
cxx_standards="23"
elif [ "$1" = "26" ]; then
cxx_standards="26"
elif [ "$1" = "all" ]; then
cxx_standards="11 14 17 20 23 26"
else
PrintHelp
exit
@ -180,10 +186,10 @@ fi
#******************************************************************************
if [ "$6" = "v" ]; then
verbose="On"
verbose_flag="-v"
verbose_cmake_flag="-DEXTRA_TESTING_FLAGS=-v"
else
verbose="Off"
verbose_flag=""
verbose_cmake_flag=""
fi
#******************************************************************************
@ -196,66 +202,66 @@ etl_version=$(echo $etl_version_raw | sed -e 's/\r//g') # Remove trailing \r
# Get the compiler versions
#******************************************************************************
while read i ; do
CC=`echo $i | cut -d, -f1 | sed -e 's/ *$//'`
MSG=`echo $i | cut -d, -f2 | sed -e 's/ *$//'`
DIR=`echo $i | cut -d, -f3 | sed -e 's/ *$//'`
CMD=`echo $i | cut -d, -f4 | sed -e 's/ *$//'`
for cxx_standard in $cxx_standards ; do
while read i ; do
CC=`echo $i | cut -d, -f1 | sed -e 's/ *$//'`
MSG=`echo $i | cut -d, -f2 | sed -e 's/ *$//'`
DIR=`echo $i | cut -d, -f3 | sed -e 's/ *$//'`
CMD=`echo $i | cut -d, -f4 | sed -e 's/ *$//'`
if [ "$compiler_enabled" = "$CC" ] || [ "$compiler_enabled" = "All compilers" ]; then
if [ "$CC" = "gcc" ] ; then
compiler=$(g++ --version | grep g++)
else
compiler=$(clang++ --version | grep clang)
if [ "$compiler_enabled" = "$CC" ] || [ "$compiler_enabled" = "All compilers" ]; then
if [ "$CC" = "gcc" ] ; then
compiler=$(g++ --version | grep g++)
else
compiler=$(clang++ --version | grep clang)
fi
OLD_DIR=`pwd`
cd $DIR
mkdir -p build-make || exit 1
cd build-make || exit 1
echo "ETL Tests" > log.txt
SetConfigurationName "$MSG"
PrintHeader
$CMD
if cmake --build .; then
PassedCompilation
else
FailedCompilation
exit 1
fi
if ctest -V; then
PassedTests
else
FailedTests
exit 1
fi
cd ..
rm -rf build-make
cd $OLD_DIR
fi
OLD_DIR=`pwd`
cd $DIR
mkdir -p build-make || exit 1
cd build-make || exit 1
echo "ETL Tests" > log.txt
SetConfigurationName "$MSG"
PrintHeader
$CMD
cmake --build .
if [ $? -eq 0 ]; then
PassedCompilation
else
FailedCompilation
exit $?
fi
./etl_tests $verbose_flag
if [ $? -eq 0 ]; then
PassedTests
else
FailedTests
exit $?
fi
cd ..
rm -rf build-make
cd $OLD_DIR
fi
done <<-EOF
gcc ,STL ,.,cmake -DCMAKE_C_COMPILER=gcc -DCMAKE_CXX_COMPILER=g++ -DNO_STL=OFF -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF -DETL_OPTIMISATION=$opt -DETL_CXX_STANDARD=$cxx_standard -DETL_ENABLE_SANITIZER=$sanitize -DETL_MESSAGES_ARE_NOT_VIRTUAL=OFF ..
gcc ,STL - Non-virtual messages,.,cmake -DCMAKE_C_COMPILER=gcc -DCMAKE_CXX_COMPILER=g++ -DNO_STL=OFF -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF -DETL_OPTIMISATION=$opt -DETL_CXX_STANDARD=$cxx_standard -DETL_ENABLE_SANITIZER=$sanitize -DETL_MESSAGES_ARE_NOT_VIRTUAL=ON ..
gcc ,STL - Force C++03 ,.,cmake -DCMAKE_C_COMPILER=gcc -DCMAKE_CXX_COMPILER=g++ -DNO_STL=OFF -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=ON -DETL_OPTIMISATION=$opt -DETL_CXX_STANDARD=$cxx_standard -DETL_ENABLE_SANITIZER=$sanitize -DETL_MESSAGES_ARE_NOT_VIRTUAL=OFF ..
gcc ,No STL ,.,cmake -DCMAKE_C_COMPILER=gcc -DCMAKE_CXX_COMPILER=g++ -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF -DETL_OPTIMISATION=$opt -DETL_CXX_STANDARD=$cxx_standard -DETL_ENABLE_SANITIZER=$sanitize -DETL_MESSAGES_ARE_NOT_VIRTUAL=OFF ..
gcc ,No STL - Force C++03 ,.,cmake -DCMAKE_C_COMPILER=gcc -DCMAKE_CXX_COMPILER=g++ -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=ON -DETL_OPTIMISATION=$opt -DETL_CXX_STANDARD=$cxx_standard -DETL_ENABLE_SANITIZER=$sanitize -DETL_MESSAGES_ARE_NOT_VIRTUAL=OFF ..
gcc ,No STL - Builtin mem functions ,.,cmake -DCMAKE_C_COMPILER=gcc -DCMAKE_CXX_COMPILER=g++ -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF -DETL_OPTIMISATION=$opt -DETL_CXX_STANDARD=$cxx_standard -DETL_ENABLE_SANITIZER=$sanitize -DETL_MESSAGES_ARE_NOT_VIRTUAL=OFF -DETL_USE_BUILTIN_MEM_FUNCTIONS=ON ..
clang,STL ,.,cmake -DCMAKE_C_COMPILER=clang -DCMAKE_CXX_COMPILER=clang++ -DNO_STL=OFF -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF -DETL_OPTIMISATION=$opt -DETL_CXX_STANDARD=$cxx_standard -DETL_ENABLE_SANITIZER=$sanitize -DETL_MESSAGES_ARE_NOT_VIRTUAL=OFF ..
clang,STL - Force C++03 ,.,cmake -DCMAKE_C_COMPILER=clang -DCMAKE_CXX_COMPILER=clang++ -DNO_STL=OFF -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=ON -DETL_OPTIMISATION=$opt -DETL_CXX_STANDARD=$cxx_standard -DETL_ENABLE_SANITIZER=$sanitize -DETL_MESSAGES_ARE_NOT_VIRTUAL=OFF ..
clang,No STL ,.,cmake -DCMAKE_C_COMPILER=clang -DCMAKE_CXX_COMPILER=clang++ -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF -DETL_OPTIMISATION=$opt -DETL_CXX_STANDARD=$cxx_standard -DETL_ENABLE_SANITIZER=$sanitize -DETL_MESSAGES_ARE_NOT_VIRTUAL=OFF ..
clang,No STL - Force C++03 ,.,cmake -DCMAKE_C_COMPILER=clang -DCMAKE_CXX_COMPILER=clang++ -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=ON -DETL_OPTIMISATION=$opt -DETL_CXX_STANDARD=$cxx_standard -DETL_ENABLE_SANITIZER=$sanitize -DETL_MESSAGES_ARE_NOT_VIRTUAL=OFF ..
clang,No STL - Builtin mem functions ,.,cmake -DCMAKE_C_COMPILER=gcc -DCMAKE_CXX_COMPILER=g++ -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF -DETL_OPTIMISATION=$opt -DETL_CXX_STANDARD=$cxx_standard -DETL_ENABLE_SANITIZER=$sanitize -DETL_MESSAGES_ARE_NOT_VIRTUAL=OFF -DETL_USE_BUILTIN_MEM_FUNCTIONS=ON ..
gcc ,Initializer list test ,etl_initializer_list,cmake -DCMAKE_C_COMPILER=gcc -DCMAKE_CXX_COMPILER=g++ -DETL_OPTIMISATION=$opt -DETL_CXX_STANDARD=$cxx_standard -DETL_ENABLE_SANITIZER=$sanitize ..
clang,Initializer list test ,etl_initializer_list,cmake -DCMAKE_C_COMPILER=clang -DCMAKE_CXX_COMPILER=clang++ -DETL_OPTIMISATION=$opt -DETL_CXX_STANDARD=$cxx_standard -DETL_ENABLE_SANITIZER=$sanitize ..
gcc ,Error macros 'log_errors' test,etl_error_handler/log_errors ,cmake -DCMAKE_C_COMPILER=gcc -DCMAKE_CXX_COMPILER=g++ -DETL_OPTIMISATION=$opt -DETL_CXX_STANDARD=$cxx_standard -DETL_ENABLE_SANITIZER=$sanitize ..
gcc ,Error macros 'exceptions' test,etl_error_handler/exceptions ,cmake -DCMAKE_C_COMPILER=gcc -DCMAKE_CXX_COMPILER=g++ -DETL_OPTIMISATION=$opt -DETL_CXX_STANDARD=$cxx_standard -DETL_ENABLE_SANITIZER=$sanitize ..
gcc ,Error macros 'log_errors and exceptions' test,etl_error_handler/log_errors_and_exceptions,cmake -DCMAKE_C_COMPILER=gcc -DCMAKE_CXX_COMPILER=g++ -DETL_OPTIMISATION=$opt -DETL_CXX_STANDARD=$cxx_standard -DETL_ENABLE_SANITIZER=$sanitize ..
gcc ,Error macros 'assert function' test,etl_error_handler/assert_function ,cmake -DCMAKE_C_COMPILER=gcc -DCMAKE_CXX_COMPILER=g++ -DETL_OPTIMISATION=$opt -DETL_CXX_STANDARD=$cxx_standard -DETL_ENABLE_SANITIZER=$sanitize ..
clang,Error macros 'log_errors' test,etl_error_handler/log_errors ,cmake -DCMAKE_C_COMPILER=clang -DCMAKE_CXX_COMPILER=clang++ -DETL_OPTIMISATION=$opt -DETL_CXX_STANDARD=$cxx_standard -DETL_ENABLE_SANITIZER=$sanitize ..
clang,Error macros 'exceptions' test,etl_error_handler/exceptions ,cmake -DCMAKE_C_COMPILER=clang -DCMAKE_CXX_COMPILER=clang++ -DETL_OPTIMISATION=$opt -DETL_CXX_STANDARD=$cxx_standard -DETL_ENABLE_SANITIZER=$sanitize ..
clang,Error macros 'log_errors and exceptions' test,etl_error_handler/log_errors_and_exceptions,cmake -DCMAKE_C_COMPILER=clang -DCMAKE_CXX_COMPILER=clang++ -DETL_OPTIMISATION=$opt -DETL_CXX_STANDARD=$cxx_standard -DETL_ENABLE_SANITIZER=$sanitize ..
clang,Error macros 'assert function' test,etl_error_handler/assert_function ,cmake -DCMAKE_C_COMPILER=clang -DCMAKE_CXX_COMPILER=clang++ -DETL_OPTIMISATION=$opt -DETL_CXX_STANDARD=$cxx_standard -DETL_ENABLE_SANITIZER=$sanitize ..
done <<-EOF
gcc ,STL ,.,cmake -DCMAKE_C_COMPILER=gcc -DCMAKE_CXX_COMPILER=g++ -DNO_STL=OFF -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF -DETL_OPTIMISATION=$opt -DETL_CXX_STANDARD=$cxx_standard -DETL_ENABLE_SANITIZER=$sanitize -DETL_MESSAGES_ARE_NOT_VIRTUAL=OFF $verbose_cmake_flag ..
gcc ,STL - Non-virtual messages,.,cmake -DCMAKE_C_COMPILER=gcc -DCMAKE_CXX_COMPILER=g++ -DNO_STL=OFF -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF -DETL_OPTIMISATION=$opt -DETL_CXX_STANDARD=$cxx_standard -DETL_ENABLE_SANITIZER=$sanitize -DETL_MESSAGES_ARE_NOT_VIRTUAL=ON $verbose_cmake_flag ..
gcc ,STL - Force C++03 ,.,cmake -DCMAKE_C_COMPILER=gcc -DCMAKE_CXX_COMPILER=g++ -DNO_STL=OFF -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=ON -DETL_OPTIMISATION=$opt -DETL_CXX_STANDARD=$cxx_standard -DETL_ENABLE_SANITIZER=$sanitize -DETL_MESSAGES_ARE_NOT_VIRTUAL=OFF $verbose_cmake_flag ..
gcc ,No STL ,.,cmake -DCMAKE_C_COMPILER=gcc -DCMAKE_CXX_COMPILER=g++ -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF -DETL_OPTIMISATION=$opt -DETL_CXX_STANDARD=$cxx_standard -DETL_ENABLE_SANITIZER=$sanitize -DETL_MESSAGES_ARE_NOT_VIRTUAL=OFF $verbose_cmake_flag ..
gcc ,No STL - Force C++03 ,.,cmake -DCMAKE_C_COMPILER=gcc -DCMAKE_CXX_COMPILER=g++ -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=ON -DETL_OPTIMISATION=$opt -DETL_CXX_STANDARD=$cxx_standard -DETL_ENABLE_SANITIZER=$sanitize -DETL_MESSAGES_ARE_NOT_VIRTUAL=OFF $verbose_cmake_flag ..
gcc ,No STL - Builtin mem functions ,.,cmake -DCMAKE_C_COMPILER=gcc -DCMAKE_CXX_COMPILER=g++ -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF -DETL_OPTIMISATION=$opt -DETL_CXX_STANDARD=$cxx_standard -DETL_ENABLE_SANITIZER=$sanitize -DETL_MESSAGES_ARE_NOT_VIRTUAL=OFF -DETL_USE_BUILTIN_MEM_FUNCTIONS=ON $verbose_cmake_flag ..
clang,STL ,.,cmake -DCMAKE_C_COMPILER=clang -DCMAKE_CXX_COMPILER=clang++ -DNO_STL=OFF -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF -DETL_OPTIMISATION=$opt -DETL_CXX_STANDARD=$cxx_standard -DETL_ENABLE_SANITIZER=$sanitize -DETL_MESSAGES_ARE_NOT_VIRTUAL=OFF $verbose_cmake_flag ..
clang,STL - Force C++03 ,.,cmake -DCMAKE_C_COMPILER=clang -DCMAKE_CXX_COMPILER=clang++ -DNO_STL=OFF -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=ON -DETL_OPTIMISATION=$opt -DETL_CXX_STANDARD=$cxx_standard -DETL_ENABLE_SANITIZER=$sanitize -DETL_MESSAGES_ARE_NOT_VIRTUAL=OFF $verbose_cmake_flag ..
clang,No STL ,.,cmake -DCMAKE_C_COMPILER=clang -DCMAKE_CXX_COMPILER=clang++ -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF -DETL_OPTIMISATION=$opt -DETL_CXX_STANDARD=$cxx_standard -DETL_ENABLE_SANITIZER=$sanitize -DETL_MESSAGES_ARE_NOT_VIRTUAL=OFF $verbose_cmake_flag ..
clang,No STL - Force C++03 ,.,cmake -DCMAKE_C_COMPILER=clang -DCMAKE_CXX_COMPILER=clang++ -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=ON -DETL_OPTIMISATION=$opt -DETL_CXX_STANDARD=$cxx_standard -DETL_ENABLE_SANITIZER=$sanitize -DETL_MESSAGES_ARE_NOT_VIRTUAL=OFF $verbose_cmake_flag ..
clang,No STL - Builtin mem functions ,.,cmake -DCMAKE_C_COMPILER=clang -DCMAKE_CXX_COMPILER=clang++ -DNO_STL=ON -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03_IMPLEMENTATION=OFF -DETL_OPTIMISATION=$opt -DETL_CXX_STANDARD=$cxx_standard -DETL_ENABLE_SANITIZER=$sanitize -DETL_MESSAGES_ARE_NOT_VIRTUAL=OFF -DETL_USE_BUILTIN_MEM_FUNCTIONS=ON $verbose_cmake_flag ..
gcc ,Initializer list test ,etl_initializer_list,cmake -DCMAKE_C_COMPILER=gcc -DCMAKE_CXX_COMPILER=g++ -DETL_OPTIMISATION=$opt -DETL_CXX_STANDARD=$cxx_standard -DETL_ENABLE_SANITIZER=$sanitize $verbose_cmake_flag ..
clang,Initializer list test ,etl_initializer_list,cmake -DCMAKE_C_COMPILER=clang -DCMAKE_CXX_COMPILER=clang++ -DETL_OPTIMISATION=$opt -DETL_CXX_STANDARD=$cxx_standard -DETL_ENABLE_SANITIZER=$sanitize $verbose_cmake_flag ..
gcc ,Error macros 'log_errors' test,etl_error_handler/log_errors ,cmake -DCMAKE_C_COMPILER=gcc -DCMAKE_CXX_COMPILER=g++ -DETL_OPTIMISATION=$opt -DETL_CXX_STANDARD=$cxx_standard -DETL_ENABLE_SANITIZER=$sanitize $verbose_cmake_flag ..
gcc ,Error macros 'exceptions' test,etl_error_handler/exceptions ,cmake -DCMAKE_C_COMPILER=gcc -DCMAKE_CXX_COMPILER=g++ -DETL_OPTIMISATION=$opt -DETL_CXX_STANDARD=$cxx_standard -DETL_ENABLE_SANITIZER=$sanitize $verbose_cmake_flag ..
gcc ,Error macros 'log_errors and exceptions' test,etl_error_handler/log_errors_and_exceptions,cmake -DCMAKE_C_COMPILER=gcc -DCMAKE_CXX_COMPILER=g++ -DETL_OPTIMISATION=$opt -DETL_CXX_STANDARD=$cxx_standard -DETL_ENABLE_SANITIZER=$sanitize $verbose_cmake_flag ..
gcc ,Error macros 'assert function' test,etl_error_handler/assert_function ,cmake -DCMAKE_C_COMPILER=gcc -DCMAKE_CXX_COMPILER=g++ -DETL_OPTIMISATION=$opt -DETL_CXX_STANDARD=$cxx_standard -DETL_ENABLE_SANITIZER=$sanitize $verbose_cmake_flag ..
clang,Error macros 'log_errors' test,etl_error_handler/log_errors ,cmake -DCMAKE_C_COMPILER=clang -DCMAKE_CXX_COMPILER=clang++ -DETL_OPTIMISATION=$opt -DETL_CXX_STANDARD=$cxx_standard -DETL_ENABLE_SANITIZER=$sanitize $verbose_cmake_flag ..
clang,Error macros 'exceptions' test,etl_error_handler/exceptions ,cmake -DCMAKE_C_COMPILER=clang -DCMAKE_CXX_COMPILER=clang++ -DETL_OPTIMISATION=$opt -DETL_CXX_STANDARD=$cxx_standard -DETL_ENABLE_SANITIZER=$sanitize $verbose_cmake_flag ..
clang,Error macros 'log_errors and exceptions' test,etl_error_handler/log_errors_and_exceptions,cmake -DCMAKE_C_COMPILER=clang -DCMAKE_CXX_COMPILER=clang++ -DETL_OPTIMISATION=$opt -DETL_CXX_STANDARD=$cxx_standard -DETL_ENABLE_SANITIZER=$sanitize $verbose_cmake_flag ..
clang,Error macros 'assert function' test,etl_error_handler/assert_function ,cmake -DCMAKE_C_COMPILER=clang -DCMAKE_CXX_COMPILER=clang++ -DETL_OPTIMISATION=$opt -DETL_CXX_STANDARD=$cxx_standard -DETL_ENABLE_SANITIZER=$sanitize $verbose_cmake_flag ..
EOF
done
TestsCompleted

32
test/syntax_check/CMakeLists.txt
View File

@ -74,9 +74,25 @@ elseif (ETL_CXX_STANDARD MATCHES "17")
elseif (ETL_CXX_STANDARD MATCHES "20")
message(STATUS "Compiling for C++20")
set_property(TARGET tests PROPERTY CXX_STANDARD 20)
elseif (ETL_CXX_STANDARD MATCHES "23")
if (CMAKE_VERSION VERSION_GREATER_EQUAL "3.20")
message(STATUS "Compiling for C++23")
set_property(TARGET tests PROPERTY CXX_STANDARD 23)
else()
message(STATUS "CMake version ${CMAKE_VERSION} does not support C++23, falling back to C++20")
set_property(TARGET tests PROPERTY CXX_STANDARD 20)
endif()
elseif (ETL_CXX_STANDARD MATCHES "26")
if (CMAKE_VERSION VERSION_GREATER_EQUAL "3.25")
message(STATUS "Compiling for C++26")
set_property(TARGET tests PROPERTY CXX_STANDARD 26)
else()
message(STATUS "CMake version ${CMAKE_VERSION} does not support C++26, falling back to C++23")
set_property(TARGET tests PROPERTY CXX_STANDARD 23)
endif()
else()
message(STATUS "Compiling for C++23")
set_property(TARGET tests PROPERTY CXX_STANDARD 23)
message(STATUS "Compiling for C++17")
set_property(TARGET tests PROPERTY CXX_STANDARD 17)
endif()
target_sources(tests PRIVATE
@ -115,6 +131,10 @@ target_sources(tests PRIVATE
checksum.h.t.cpp
chrono.h.t.cpp
concepts.h.t.cpp
const_map.h.t.cpp
const_multimap.h.t.cpp
const_multiset.h.t.cpp
const_set.h.t.cpp
circular_buffer.h.t.cpp
circular_iterator.h.t.cpp
closure.h.t.cpp
@ -163,6 +183,7 @@ target_sources(tests PRIVATE
crc32_q.h.t.cpp
crc32_xfer.h.t.cpp
crc64_ecma.h.t.cpp
crc64_iso.h.t.cpp
crc8_ccitt.h.t.cpp
crc8_cdma2000.h.t.cpp
crc8_darc.h.t.cpp
@ -174,6 +195,7 @@ target_sources(tests PRIVATE
crc8_j1850_zero.h.t.cpp
crc8_maxim.h.t.cpp
crc8_opensafety.h.t.cpp
crc8_nrsc5.h.t.cpp
crc8_rohc.h.t.cpp
crc8_wcdma.h.t.cpp
cyclic_value.h.t.cpp
@ -215,6 +237,7 @@ target_sources(tests PRIVATE
histogram.h.t.cpp
ihash.h.t.cpp
imemory_block_allocator.h.t.cpp
index_of_type.h.t.cpp
indirect_vector.h.t.cpp
initializer_list.h.t.cpp
inplace_function.h.t.cpp
@ -239,6 +262,7 @@ target_sources(tests PRIVATE
list.h.t.cpp
log.h.t.cpp
macros.h.t.cpp
manchester.h.t.cpp
map.h.t.cpp
math.h.t.cpp
math_constants.h.t.cpp
@ -284,6 +308,7 @@ target_sources(tests PRIVATE
poly_span.h.t.cpp
pool.h.t.cpp
power.h.t.cpp
print.h.t.cpp
priority_queue.h.t.cpp
pseudo_moving_average.h.t.cpp
quantize.h.t.cpp
@ -295,6 +320,7 @@ target_sources(tests PRIVATE
queue_spsc_locked.h.t.cpp
radix.h.t.cpp
random.h.t.cpp
ranges.h.t.cpp
ratio.h.t.cpp
reference_counted_message.h.t.cpp
reference_counted_message_pool.h.t.cpp
@ -306,6 +332,7 @@ target_sources(tests PRIVATE
rescale.h.t.cpp
result.h.t.cpp
rms.h.t.cpp
rounded_integral_division.h.t.cpp
scaled_rounding.h.t.cpp
scheduler.h.t.cpp
set.h.t.cpp
@ -337,6 +364,7 @@ target_sources(tests PRIVATE
to_wstring.h.t.cpp
tuple.h.t.cpp
type_def.h.t.cpp
type_list.h.t.cpp
type_lookup.h.t.cpp
type_select.h.t.cpp
type_traits.h.t.cpp

29
test/syntax_check/const_map.h.t.cpp Normal file
View File

@ -0,0 +1,29 @@
/******************************************************************************
The MIT License(MIT)
Embedded Template Library.
https://github.com/ETLCPP/etl
https://www.etlcpp.com
Copyright(c) 2026 BMW AG
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files(the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and / or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions :
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
******************************************************************************/
#include <etl/const_map.h>

29
test/syntax_check/const_multimap.h.t.cpp Normal file
View File

@ -0,0 +1,29 @@
/******************************************************************************
The MIT License(MIT)
Embedded Template Library.
https://github.com/ETLCPP/etl
https://www.etlcpp.com
Copyright(c) 2026 BMW AG
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files(the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and / or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions :
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
******************************************************************************/
#include <etl/const_multimap.h>

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