Fix operator| conflict with std::ranges (#1395)

* Print test names at test time (#1343)

* Fix initializer_list use in algorithm.h

Needs to be conditional.

* Move definition of data() in iterator.h

Needs to be defined earlier.

---------

Co-authored-by: John Wellbelove <john.wellbelove@etlcpp.com>

.clang-format

@@ -1,51 +1,184 @@
 ---
-#------------------------------------
-# Configuration for clang-format v12
-#------------------------------------
+BasedOnStyle: LLVM
+Standard:     Auto # let the formatter accept any C++ standard
 
-Language: Cpp
+# =============================================================================
+# Indentation
+# =============================================================================
+TabWidth:                          2
+ContinuationIndentWidth:           2
+ConstructorInitializerIndentWidth: 2
+NamespaceIndentation:              All        # everything inside namespace is indented
+IndentCaseLabels:                  true       # case labels at switch-body indent level
+IndentCaseBlocks:                  true       # indent block inside case label
+IndentExternBlock:                 Indent
+IndentWrappedFunctionNames:        true       # keep function name at same indent as return type
+IndentPPDirectives:                BeforeHash # nested #if / #include get indented before the #
+PPIndentWidth:                     2
 
-SortIncludes: true
+# =============================================================================
+# Braces & line-break style
+# =============================================================================
+BreakBeforeBraces:               Allman
+BreakConstructorInitializers:    BeforeComma   # colon on new line, commas lead
+BreakInheritanceList:            BeforeComma
+BreakBeforeBinaryOperators:      NonAssignment
+BreakStringLiterals:             false
+AlwaysBreakTemplateDeclarations: Yes           # template <…> always on its own line
+BreakAfterAttributes:            Always
 
-BasedOnStyle: Chromium
+# =============================================================================
+# Short statements
+# =============================================================================
+AllowShortBlocksOnASingleLine:     Empty
+AllowShortFunctionsOnASingleLine:  Empty  # only empty bodies: void f() {}
+AllowShortCaseLabelsOnASingleLine: true   # case X: stmt; break; on one line
+AllowShortLoopsOnASingleLine:      true
+AllowShortLambdasOnASingleLine:    Inline
 
-BinPackParameters: false
-BitFieldColonSpacing: Both
+# =============================================================================
+# Empty lines
+# =============================================================================
+KeepEmptyLinesAtTheStartOfBlocks: false
+EmptyLineBeforeAccessModifier:    Always # blank line before public:/private:/protected:
+EmptyLineAfterAccessModifier:     Always # blank line after  public:/private:/protected:
+InsertNewlineAtEOF:               true
 
-BreakBeforeBraces: Allman
-BreakConstructorInitializers: BeforeComma
+# =============================================================================
+# Spacing
+# =============================================================================
+SpacesInAngles:            Leave # preserve C++03 "> >" vs C++11 ">>"
+SpacesInContainerLiterals: false
 
-AllowShortBlocksOnASingleLine: false
-AllowShortCaseLabelsOnASingleLine: true
-AllowShortFunctionsOnASingleLine: None
-AllowShortIfStatementsOnASingleLine: false
-
-AllowAllArgumentsOnNextLine: true
-AllowAllParametersOfDeclarationOnNextLine: true
-
-ConstructorInitializerAllOnOneLineOrOnePerLine: 'true'
-ConstructorInitializerIndentWidth: '2'
-
-NamespaceIndentation: All
-IndentPPDirectives: BeforeHash
-PointerAlignment: Left
-ColumnLimit: '0'
-ContinuationIndentWidth: '2'
-UseTab: Never
-TabWidth: '2'
-IndentWidth: '2'
-AccessModifierOffset : '-2'
-IndentCaseLabels: false
-Cpp11BracedListStyle: 'true'
-AlignAfterOpenBracket: Align
+# =============================================================================
+# Alignment
+# =============================================================================
+PointerAlignment:             Left # T* ptr, const T& ref
+ReferenceAlignment:           Left
+AlignConsecutiveAssignments:  true
 AlignConsecutiveDeclarations: true
+AlignConsecutiveBitFields:    true
+AlignConsecutiveMacros:       true # align macro bodies
 
-#------------------------------------
-# Configurations not supported by clang-format v12
-#------------------------------------
-# BreakInheritanceList: AfterComma
-# EmptyLineBeforeAccessModifier: Always
-# EmptyLineAfterAccessModifier: Always
-# ReferenceAlignment: Left
+# =============================================================================
+# Line length and wrapping
+# =============================================================================
+ColumnLimit:    150
+ReflowComments: true # preserve hand-formatted comment rulers
+AlignEscapedNewlines: Left
 
-...
+# =============================================================================
+# Includes
+# =============================================================================
+IncludeCategories:
+  - Regex:    '^(<|")(.*/)?platform\.h(>|")$'
+    Priority: -1
+  - Regex:    'private'
+    Priority: 1
+  - Regex:    '.*'
+    Priority: 0
+
+# =============================================================================
+# Arguments, parameters and constructor initialisers
+# =============================================================================
+PackConstructorInitializers: Never # each initialiser on its own line
+
+# =============================================================================
+# Namespaces and using declarations
+# =============================================================================
+SortUsingDeclarations: Lexicographic
+
+# =============================================================================
+# Macro-aware formatting
+# =============================================================================
+# ETL-specific macros that should be treated as statement-level constructs
+StatementMacros:
+  - ETL_DECLARE_DEBUG_COUNT
+  - ETL_INCREMENT_DEBUG_COUNT
+  - ETL_DECREMENT_DEBUG_COUNT
+  - ETL_ADD_DEBUG_COUNT
+  - ETL_STATIC_ASSERT
+  - ETL_ASSERT
+  - ETL_ASSERT_OR_RETURN
+  - ETL_ASSERT_OR_RETURN_VALUE
+  - ETL_ASSERT_FAIL
+  - ETL_ASSERT_FAIL_AND_RETURN
+  - ETL_ASSERT_FAIL_AND_RETURN_VALUE
+  - ETL_MOVE
+  - ETL_ENUM_CLASS
+  - ETL_ENUM_CLASS_TYPE
+  - ETL_IF_CONSTEXPR
+
+# Macros that behave like attributes or specifiers.
+AttributeMacros:
+  - ETL_NORETURN
+  - ETL_FINAL
+  - ETL_OVERRIDE
+  - ETL_EXPLICIT
+  - ETL_DELETE
+  - ETL_CONSTANT
+  - ETL_CONSTEXPR
+  - ETL_CONSTEXPR11
+  - ETL_CONSTEXPR14
+  - ETL_CONSTEXPR17
+  - ETL_CONSTEXPR20
+  - ETL_CONSTEXPR23
+  - ETL_CONSTEVAL
+  - ETL_NODISCARD
+  - ETL_NORETURN
+  - ETL_DEPRECATED
+  - ETL_DEPRECATED_REASON
+  - ETL_LIKELY
+  - ETL_UNLIKELY
+  - ETL_FALLTHROUGH
+  - ETL_MAYBE_UNUSED
+  - ETL_INLINE_VAR
+  - ETL_ASSUME
+  - ETL_LVALUE_REF_QUALIFIER
+  - ETL_RVALUE_REF_QUALIFIER
+  - ETL_NOEXCEPT
+  - ETL_NOEXCEPT_EXPR
+  - ETL_NOEXCEPT_IF
+  - ETL_NOEXCEPT_FROM
+
+Macros:
+  - ETL_NORETURN=[[noreturn]]
+  - ETL_FINAL=final
+  - ETL_OVERRIDE=override
+  - ETL_EXPLICIT=explicit
+  - ETL_DELETE=delete
+  - ETL_CONSTANT=const
+  - ETL_CONSTEXPR=constexpr
+  - ETL_CONSTEXPR11=constexpr
+  - ETL_CONSTEXPR14=constexpr
+  - ETL_CONSTEXPR17=constexpr
+  - ETL_CONSTEXPR20=constexpr
+  - ETL_CONSTEXPR23=constexpr
+  - ETL_CONSTEVAL=consteval
+  - ETL_NODISCARD=[[nodiscard]]
+  - ETL_NORETURN=[[noreturn]]
+  - ETL_DEPRECATED=[[deprecated]]
+#  - ETL_DEPRECATED_REASON=[[deprecated(%0)]] # Hangs with clang-format 18
+  - ETL_LIKELY=[[likely]]
+  - ETL_UNLIKELY=[[unlikely]]
+  - ETL_FALLTHROUGH=[[fallthrough]]
+  - ETL_MAYBE_UNUSED=[[maybe_unused]]
+  - ETL_INLINE_VAR=inline
+  - ETL_ASSUME=[[assume(&0)]]
+  - ETL_LVALUE_REF_QUALIFIER=&
+  - ETL_RVALUE_REF_QUALIFIER=&&
+  - ETL_NOEXCEPT=noexcept
+#  - ETL_NOEXCEPT_EXPR=noexcept(&0)) # Hangs with clang-format 18
+#  - ETL_NOEXCEPT_IF=noexcept(&0)    # Hangs with clang-format 18
+#  - ETL_NOEXCEPT_FROM=noexcept(&0)  # Hangs with clang-format 18
+
+# Macros that behave like type names
+TypenameMacros:
+  - ETL_OR_STD
+
+# Do not reformat these macros — they contain DSL-like content
+WhitespaceSensitiveMacros:
+  - ETL_ERROR_TEXT
+  - ETL_DECLARE_ENUM_TYPE
+  - ETL_ENUM_TYPE
+  - ETL_END_ENUM_TYPE

.coderabbit.yaml

@@ -0,0 +1,200 @@
+language: "en-GB"
+early_access: false
+
+reviews:
+  profile: "chill"
+  request_changes_workflow: false
+  high_level_summary: false
+  high_level_summary_in_walkthrough: false
+  poem: false
+  review_status: false 
+  collapse_walkthrough: false
+  changed_files_summary: false
+  sequence_diagrams: false
+  estimate_code_review_effort: false
+  assess_linked_issues: false
+  related_issues: false
+  related_prs: false
+  suggested_labels: false
+  suggested_reviewers: false
+  auto_review:
+    enabled: true
+    drafts: false
+  path_instructions:
+    - path: "include/etl/*.h"
+      instructions: |
+        Review the C++ code in these directories. The code must not use
+        STL containers but must instead rely on Embedded Template Library
+        (ETL) for data structures and algorithms.
+
+        When answering questions, provide accurate and concise information based on the ETL documentation and codebase. If you don't know the answer, just say "I don't know". Do not make up answers.
+        When providing code examples, ensure they are relevant to the ETL and follow its conventions.
+        Always be polite and professional in your responses.
+
+        Header files should start with the ETL's standard MIT comment block.
+
+        Header files should have include guards in the format '#ifndef ETL_<FILENAME>>_INCLUDED #define ETL_<FILENAME>_INCLUDED #endif'
+
+        Headers should be organized in the following order
+          - The first header include should be '#include "platform.h"'
+          - Headers from the ETL
+          - Headers from the path 'private/**'
+          - C++ standard library headers
+          - C standard library headers
+
+        Pay extra attention to the following
+          - Buffer overflows
+          - Memory leaks
+          - Undefined behavior
+
+        Check that the following conventions are used
+          - Variable names should be in `snake_case`
+          - Macro constants should be `ALL_CAPS_WITH_UNDERSCORES`
+          - Macro constants should be prefixed with 'ETL_'
+          - Function, class, and type names should be `snake_case`
+          - enum members should be `Caps_Snake_Case`
+
+        Please keep your outputs short and to the point, unless otherwise asked
+          - Keep your responses short, describe small issues in a few sentences
+          - Don't output tips, analysis chains or anything else with a collapsible view
+          - Don't output `comment summaries` or `fix prompts for AIs`
+          - If the highlighted issue is complex, don't suggest a solution
+          - Don't use emojis
+
+    - path: "include/etl/atomic/*.h"
+      instructions: |
+        Review the C++ code in these directories. The code must not use
+        STL containers but must instead rely on Embedded Template Library
+        (ETL) for data structures and algorithms.
+
+        When answering questions, provide accurate and concise information based on the ETL documentation and codebase. If you don't know the answer, just say "I don't know". Do not make up answers.
+        When providing code examples, ensure they are relevant to the ETL and follow its conventions.
+        Always be polite and professional in your responses.
+
+        Header files should start with the ETL's standard MIT comment block.
+
+        Header files are allowed to not have include guards
+
+        Headers should be organized in the following order
+          - Headers from the ETL
+          - Headers from the path 'private/**'
+          - C++ standard library headers
+          - C standard library headers
+
+        Pay extra attention to the following
+          - Buffer overflows
+          - Memory leaks
+          - Undefined behavior
+
+        Check that the following conventions are used
+          - Variable names should be in `snake_case`
+          - Macro constants should be `ALL_CAPS_WITH_UNDERSCORES`
+          - Macro constants should be prefixed with 'ETL_'
+          - Function, class, and type names should be `snake_case`
+          - enum members should be `Caps_Snake_Case`
+
+        Please keep your outputs short and to the point, unless otherwise asked
+          - Keep your responses short, describe small issues in a few sentences
+          - Don't output tips, analysis chains or anything else with a collapsible view
+          - Don't output `comment summaries` or `fix prompts for AIs`
+          - If the highlighted issue is complex, don't suggest a solution
+          - Don't use emojis
+
+    - path: "include/etl/atomic/*.h"
+      instructions: |
+        Review the C++ code in these directories. The code must not use
+        STL containers but must instead rely on Embedded Template Library
+        (ETL) for data structures and algorithms.
+
+        When answering questions, provide accurate and concise information based on the ETL documentation and codebase. If you don't know the answer, just say "I don't know". Do not make up answers.
+        When providing code examples, ensure they are relevant to the ETL and follow its conventions.
+        Always be polite and professional in your responses.
+
+        Header files should start with the ETL's standard MIT comment block.
+
+        Header files are allowed to not have include guards
+
+        Headers should be organized in the following order
+          - Headers from the ETL
+          - Headers from the path 'private/**'
+          - C++ standard library headers
+          - C standard library headers
+
+        Pay extra attention to the following
+          - Buffer overflows
+          - Memory leaks
+          - Undefined behavior
+
+        Check that the following conventions are used
+          - Variable names should be in `snake_case`
+          - Macro constants should be `ALL_CAPS_WITH_UNDERSCORES`
+          - Macro constants should be prefixed with 'ETL_'
+          - Function, class, and type names should be `snake_case`
+          - enum members should be `Caps_Snake_Case`
+
+        Please keep your outputs short and to the point, unless otherwise asked
+          - Keep your responses short, describe small issues in a few sentences
+          - Don't output tips, analysis chains or anything else with a collapsible view
+          - Don't output `comment summaries` or `fix prompts for AIs`
+          - If the highlighted issue is complex, don't suggest a solution
+          - Don't use emojis
+
+    - path: "include/etl/mutex/*.h"
+      instructions: |
+        Review the C++ code in these directories. The code must not use
+        STL containers but must instead rely on Embedded Template Library
+        (ETL) for data structures and algorithms.
+
+        When answering questions, provide accurate and concise information based on the ETL documentation and codebase. If you don't know the answer, just say "I don't know". Do not make up answers.
+        When providing code examples, ensure they are relevant to the ETL and follow its conventions.
+        Always be polite and professional in your responses.
+
+        Header files should start with the ETL's standard MIT comment block.
+
+        Header files are allowed to not have include guards
+
+        Headers should be organized in the following order
+          - Headers from the ETL
+          - Headers from the path 'private/**'
+          - C++ standard library headers
+          - C standard library headers
+
+        Pay extra attention to the following
+          - Buffer overflows
+          - Memory leaks
+          - Undefined behavior
+
+        Check that the following conventions are used
+          - Variable names should be in `snake_case`
+          - Macro constants should be `ALL_CAPS_WITH_UNDERSCORES`
+          - Macro constants should be prefixed with 'ETL_'
+          - Function, class, and type names should be `snake_case`
+          - enum members should be `Caps_Snake_Case`
+
+        Please keep your outputs short and to the point, unless otherwise asked
+          - Keep your responses short, describe small issues in a few sentences
+          - Don't output tips, analysis chains or anything else with a collapsible view
+          - Don't output `comment summaries` or `fix prompts for AIs`
+          - If the highlighted issue is complex, don't suggest a solution
+          - Don't use emojis
+
+    - path: "include/etl/deprecated/*.h"
+      instructions: |
+        Ingnore files in this directory
+
+    - path: "include/etl/experimental/*.h"
+      instructions: |
+        Ingnore files in this directory
+
+    - path: "include/etl/generators/*.h"
+      instructions: |
+        Ingnore files in this directory
+
+    - path: "include/etl/profiles/*.h"
+      instructions: |
+        Ingnore files in this directory
+
+chat:
+  art: false
+  auto_reply: true
+

.devcontainer/Dockerfile

@@ -0,0 +1,61 @@
+ARG BASE_IMAGE_NAME="mcr.microsoft.com/devcontainers/cpp:2@sha256:a5eb5a1e9109af88bf82ebb0f71903608a68144851ed1e4b852e31b251ac59c6"
+
+FROM ${BASE_IMAGE_NAME}
+
+ARG DEBIAN_SNAPSHOT="20260223T000000Z"
+
+SHELL ["/bin/bash", "-o", "pipefail", "-c"]
+
+ENV LANG=C.UTF-8 \
+    LC_ALL=C.UTF-8 \
+    TZ=UTC
+
+RUN set -eux \
+    && export DEBIAN_FRONTEND=noninteractive \
+    && if [[ "${DEBIAN_SNAPSHOT}" != "none" ]]; then \
+        snapshot_main="http://snapshot.debian.org/archive/debian/${DEBIAN_SNAPSHOT}"; \
+        snapshot_security="http://snapshot.debian.org/archive/debian-security/${DEBIAN_SNAPSHOT}"; \
+        if [[ -f /etc/apt/sources.list.d/debian.sources ]]; then \
+            sed -ri "s|^URIs: https?://deb.debian.org/debian$|URIs: ${snapshot_main}|g" /etc/apt/sources.list.d/debian.sources; \
+            sed -ri "s|^URIs: https?://deb.debian.org/debian-security$|URIs: ${snapshot_security}|g" /etc/apt/sources.list.d/debian.sources; \
+        elif [[ -f /etc/apt/sources.list ]] || compgen -G "/etc/apt/sources.list.d/*.list" > /dev/null; then \
+            for list_file in /etc/apt/sources.list /etc/apt/sources.list.d/*.list; do \
+                [[ -f "${list_file}" ]] || continue; \
+                sed -ri "s|https?://deb.debian.org/debian|${snapshot_main}|g" "${list_file}"; \
+                sed -ri "s|https?://security.debian.org/debian-security|${snapshot_security}|g" "${list_file}"; \
+                sed -ri "s|https?://deb.debian.org/debian-security|${snapshot_security}|g" "${list_file}"; \
+            done; \
+        else \
+            echo "ERROR: DEBIAN_SNAPSHOT='${DEBIAN_SNAPSHOT}' is set, but no supported apt source files were found."; \
+            echo "Expected /etc/apt/sources.list.d/debian.sources or one or more .list files under /etc/apt/."; \
+            exit 1; \
+        fi; \
+        printf 'Acquire::Check-Valid-Until "false";\n' > /etc/apt/apt.conf.d/99snapshot; \
+    fi \
+    && apt-get update \
+    && apt-get -y install --no-install-recommends \
+        python3-full \
+        python3-pip \
+        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
+
+RUN set -eux \
+    && echo "Pip version: " \
+    && pip --version \
+    && echo "Cogapp version: " \
+    && pip show cogapp \
+    && echo "Git version: " \
+    && git --version \
+    && echo "Wget version: " \
+    && wget --version \
+    && echo "Cmake version: " \
+    && cmake --version \
+    && echo "Make version: " \
+    && make --version

.devcontainer/clang10/devcontainer.json

@@ -0,0 +1,13 @@
+// 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": "Clang 10",
+	"build": {
+		"dockerfile": "../Dockerfile",
+		"args": {
+			"BASE_IMAGE_NAME": "silkeh/clang:10",
+			"DEBIAN_SNAPSHOT": "none"
+		},
+		"context": "../context"
+	}
+}

.devcontainer/clang11/devcontainer.json

@@ -0,0 +1,13 @@
+// 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": "Clang 11",
+	"build": {
+		"dockerfile": "../Dockerfile",
+		"args": {
+			"BASE_IMAGE_NAME": "silkeh/clang:11",
+			"DEBIAN_SNAPSHOT": "none"
+		},
+		"context": "../context"
+	}
+}

.devcontainer/clang12/devcontainer.json

@@ -0,0 +1,13 @@
+// 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": "Clang 12",
+	"build": {
+		"dockerfile": "../Dockerfile",
+		"args": {
+			"BASE_IMAGE_NAME": "silkeh/clang:12",
+			"DEBIAN_SNAPSHOT": "none"
+		},
+		"context": "../context"
+	}
+}

.devcontainer/clang13/devcontainer.json

@@ -0,0 +1,13 @@
+// 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": "Clang 13",
+	"build": {
+		"dockerfile": "../Dockerfile",
+		"args": {
+			"BASE_IMAGE_NAME": "silkeh/clang:13",
+			"DEBIAN_SNAPSHOT": "none"
+		},
+		"context": "../context"
+	}
+}

.devcontainer/clang14/devcontainer.json

@@ -0,0 +1,13 @@
+// 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": "Clang 14",
+	"build": {
+		"dockerfile": "../Dockerfile",
+		"args": {
+			"BASE_IMAGE_NAME": "silkeh/clang:14",
+			"DEBIAN_SNAPSHOT": "none"
+		},
+		"context": "../context"
+	}
+}

.devcontainer/clang15/devcontainer.json

@@ -0,0 +1,13 @@
+// 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": "Clang 15",
+	"build": {
+		"dockerfile": "../Dockerfile",
+		"args": {
+			"BASE_IMAGE_NAME": "silkeh/clang:15",
+			"DEBIAN_SNAPSHOT": "none"
+		},
+		"context": "../context"
+	}
+}

.devcontainer/clang16/devcontainer.json

@@ -0,0 +1,13 @@
+// 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": "Clang 16",
+	"build": {
+		"dockerfile": "../Dockerfile",
+		"args": {
+			"BASE_IMAGE_NAME": "silkeh/clang:16",
+			"DEBIAN_SNAPSHOT": "none"
+		},
+		"context": "../context"
+	}
+}

.devcontainer/clang17/devcontainer.json

@@ -0,0 +1,13 @@
+// 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": "Clang 17",
+	"build": {
+		"dockerfile": "../Dockerfile",
+		"args": {
+			"BASE_IMAGE_NAME": "silkeh/clang:17",
+			"DEBIAN_SNAPSHOT": "none"
+		},
+		"context": "../context"
+	}
+}

.devcontainer/clang18/devcontainer.json

@@ -0,0 +1,13 @@
+// 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": "Clang 18",
+	"build": {
+		"dockerfile": "../Dockerfile",
+		"args": {
+			"BASE_IMAGE_NAME": "silkeh/clang:18-bullseye",
+			"DEBIAN_SNAPSHOT": "none"
+		},
+		"context": "../context"
+	}
+}

.devcontainer/clang19/devcontainer.json

@@ -0,0 +1,13 @@
+// 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": "Clang 19",
+	"build": {
+		"dockerfile": "../Dockerfile",
+		"args": {
+			"BASE_IMAGE_NAME": "silkeh/clang:19-bullseye",
+			"DEBIAN_SNAPSHOT": "none"
+		},
+		"context": "../context"
+	}
+}

.devcontainer/clang20/devcontainer.json

@@ -0,0 +1,13 @@
+// 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": "Clang 20",
+	"build": {
+		"dockerfile": "../Dockerfile",
+		"args": {
+			"BASE_IMAGE_NAME": "silkeh/clang:20-bullseye",
+			"DEBIAN_SNAPSHOT": "none"
+		},
+		"context": "../context"
+	}
+}

.devcontainer/clang21/devcontainer.json

@@ -0,0 +1,13 @@
+// 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": "Clang 21",
+	"build": {
+		"dockerfile": "../Dockerfile",
+		"args": {
+			"BASE_IMAGE_NAME": "silkeh/clang:21-bullseye",
+			"DEBIAN_SNAPSHOT": "none"
+		},
+		"context": "../context"
+	}
+}

.devcontainer/clang7/devcontainer.json

@@ -0,0 +1,13 @@
+// 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": "Clang 07",
+	"build": {
+		"dockerfile": "../Dockerfile",
+		"args": {
+			"BASE_IMAGE_NAME": "silkeh/clang:7",
+			"DEBIAN_SNAPSHOT": "none"
+		},
+		"context": "../context"
+	}
+}

.devcontainer/clang8/devcontainer.json

@@ -0,0 +1,13 @@
+// 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": "Clang 08",
+	"build": {
+		"dockerfile": "../Dockerfile",
+		"args": {
+			"BASE_IMAGE_NAME": "silkeh/clang:8",
+			"DEBIAN_SNAPSHOT": "none"
+		},
+		"context": "../context"
+	}
+}

.devcontainer/clang9/devcontainer.json

@@ -0,0 +1,13 @@
+// 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": "Clang 09",
+	"build": {
+		"dockerfile": "../Dockerfile",
+		"args": {
+			"BASE_IMAGE_NAME": "silkeh/clang:9",
+			"DEBIAN_SNAPSHOT": "none"
+		},
+		"context": "../context"
+	}
+}

.devcontainer/context/reinstall-cmake.sh

@@ -0,0 +1,291 @@
+#!/usr/bin/env bash
+
+# For more detailed debugging, uncomment the next line
+# set -x
+
+# Explicitly set CMAKE_VERSION from first argument, default to "none"
+CMAKE_VERSION=${1:-"none"}
+
+# --- Configuration ---
+DOWNLOAD_ATTEMPTS=3
+DOWNLOAD_RETRY_DELAY=5 # seconds
+
+# --- Global Variables ---
+TMP_DIR="" # Initialize TMP_DIR, will be set by mktemp
+# Filenames used within TMP_DIR
+CMAKE_INSTALLER_SCRIPT_LOCAL_NAME="cmake-installer.sh"
+CMAKE_CHECKSUM_FILE_LOCAL_NAME="cmake-checksums.txt"
+# This will be the actual name of the CMake binary, derived from version and arch
+# It's important for matching against the checksum file.
+DERIVED_CMAKE_BINARY_FILENAME=""
+
+# --- Cleanup Function ---
+# This trap will execute on EXIT, ERR, SIGINT, SIGTERM
+# It's crucial for debugging to see the state of TMP_DIR if things go wrong.
+cleanup() {
+    # $? is the exit code of the last command before the trap was triggered
+    # or the argument to exit if the script called exit explicitly.
+    LAST_EXIT_CODE=$?
+    echo # Newline for readability
+
+    # Only proceed with detailed cleanup if TMP_DIR was actually created
+    if [[ -n "${TMP_DIR}" && -d "${TMP_DIR}" ]]; then
+        echo "--- Cleanup: Temporary Directory Inspector (${TMP_DIR}) ---"
+        echo "Listing contents of TMP_DIR:"
+        ls -la "${TMP_DIR}"
+
+        # Check and display checksum file content
+        if [[ -f "${TMP_DIR}/${CMAKE_CHECKSUM_FILE_LOCAL_NAME}" ]]; then
+            echo "--- Content of downloaded checksum file (${CMAKE_CHECKSUM_FILE_LOCAL_NAME}) ---"
+            cat "${TMP_DIR}/${CMAKE_CHECKSUM_FILE_LOCAL_NAME}"
+            echo "--- End of checksum file ---"
+        else
+            echo "Checksum file (${CMAKE_CHECKSUM_FILE_LOCAL_NAME}) not found in TMP_DIR."
+        fi
+
+        # Check and display head of (potentially) installer script
+        # Useful to see if it's an HTML error page
+        if [[ -f "${TMP_DIR}/${CMAKE_INSTALLER_SCRIPT_LOCAL_NAME}" ]]; then
+            echo "--- First 10 lines of downloaded installer script (${CMAKE_INSTALLER_SCRIPT_LOCAL_NAME}) ---"
+            head -n 10 "${TMP_DIR}/${CMAKE_INSTALLER_SCRIPT_LOCAL_NAME}"
+            echo "--- End of installer script head ---"
+        elif [[ -f "${TMP_DIR}/${DERIVED_CMAKE_BINARY_FILENAME}" ]]; then
+             # If it was renamed
+            echo "--- First 10 lines of downloaded installer script (${DERIVED_CMAKE_BINARY_FILENAME}) ---"
+            head -n 10 "${TMP_DIR}/${DERIVED_CMAKE_BINARY_FILENAME}"
+            echo "--- End of installer script head ---"
+        else
+            echo "Installer script not found in TMP_DIR (checked for ${CMAKE_INSTALLER_SCRIPT_LOCAL_NAME} and ${DERIVED_CMAKE_BINARY_FILENAME})."
+        fi
+
+        echo "Attempting to remove temporary directory: ${TMP_DIR}"
+        rm -Rf "${TMP_DIR}"
+        echo "Temporary directory removed."
+        echo "--- End of Cleanup ---"
+    else
+        echo "--- Cleanup: TMP_DIR was not set or not a directory, no temp files to inspect or clean. ---"
+    fi
+
+    # Ensure the script exits with the LAST_EXIT_CODE observed by the trap
+    # unless it was 0 and the script is exiting due to an explicit non-zero exit.
+    # The 'exit' command within the trap will override the script's natural exit code.
+    # So, if the script was going to exit 0, but cleanup had an issue, this could change it.
+    # However, for debugging an exit code 8, we want to preserve the code that *caused* the trap.
+    echo "Script finished with exit code: ${LAST_EXIT_CODE}."
+    exit "${LAST_EXIT_CODE}"
+}
+trap cleanup EXIT ERR SIGINT SIGTERM
+
+# Immediately turn on `set -e` after trap setup
+set -e
+
+# --- Helper Functions ---
+# Function to download a file with retries and basic validation
+download_file() {
+    local url="$1"
+    local output_filename="$2"
+    local attempts_left=$DOWNLOAD_ATTEMPTS
+    local wget_exit_code=0
+
+    while [ $attempts_left -gt 0 ]; do
+        echo "Downloading: ${url}"
+        echo "Saving to: ${TMP_DIR}/${output_filename}"
+        echo "Attempt $((DOWNLOAD_ATTEMPTS - attempts_left + 1)) of ${DOWNLOAD_ATTEMPTS}..."
+
+        # Use wget with:
+        # -O: specify output file
+        # --timeout: connection/read timeout
+        # --tries: number of retries (wget's own retry, distinct from this loop)
+        # --quiet: suppress normal output, but errors still go to stderr
+        # --show-progress: if not quiet, shows a progress bar (optional)
+        # Using -q for less verbose logs, but on failure, we need to know.
+        wget -O "${TMP_DIR}/${output_filename}" --timeout=30 --tries=1 "${url}"
+        wget_exit_code=$?
+
+        if [ ${wget_exit_code} -eq 0 ]; then
+            echo "Download command successful for ${output_filename}."
+            if [ -s "${TMP_DIR}/${output_filename}" ]; then # -s: file exists and has a size greater than 0
+                # Basic check for common HTML error page indicators
+                # This is a heuristic and might not catch all error pages.
+                if head -n 5 "${TMP_DIR}/${output_filename}" | grep -Eiq '<html|<head|<!doctype html|404 Not Found|Error'; then
+                    echo "WARNING: Downloaded file '${output_filename}' might be an HTML error page."
+                    echo "First 5 lines of ${output_filename}:"
+                    head -n 5 "${TMP_DIR}/${output_filename}"
+                    # Consider this a failure for critical files
+                    return 1 # Treat as failure
+                fi
+                echo "File ${output_filename} downloaded and is not empty."
+                return 0 # Success
+            else
+                echo "ERROR: Downloaded file ${output_filename} is empty."
+                # No need to rm here, loop will retry or fail
+            fi
+        else
+            echo "ERROR: wget failed to download ${url} with exit code ${wget_exit_code}."
+        fi
+
+        attempts_left=$((attempts_left - 1))
+        if [ $attempts_left -gt 0 ]; then
+            echo "Retrying in ${DOWNLOAD_RETRY_DELAY} seconds..."
+            sleep $DOWNLOAD_RETRY_DELAY
+        else
+            echo "ERROR: Failed to download ${url} after ${DOWNLOAD_ATTEMPTS} attempts."
+            return 1 # Explicit failure
+        fi
+    done
+    return 1 # Should be unreachable if loop logic is correct, but as a fallback
+}
+
+# --- Main Script Logic ---
+
+if [ "${CMAKE_VERSION}" = "none" ]; then
+    echo "No CMake version specified by argument, skipping CMake reinstallation."
+    exit 0
+fi
+echo "CMake version to install: ${CMAKE_VERSION}"
+
+# 1. Ensure wget is available
+echo "Checking for wget..."
+if ! command -v wget > /dev/null; then
+    echo "wget not found. Attempting to install wget via apt-get..."
+    if command -v apt-get > /dev/null; then
+        apt-get update -y
+        apt-get install -y --no-install-recommends wget
+        echo "wget installed."
+    else
+        echo "ERROR: apt-get not found. Cannot install wget. Please install wget manually."
+        exit 1
+    fi
+else
+    echo "wget is available."
+fi
+
+# 2. (Optional) Remove existing CMake installed via apt
+echo "Attempting to remove any existing CMake installed via apt..."
+if command -v apt-get > /dev/null; then
+    if dpkg -s cmake &> /dev/null; then # Check if cmake package is actually installed
+        apt-get -y purge --auto-remove cmake
+        echo "cmake package purged."
+    else
+        echo "cmake package not found via dpkg, skipping purge."
+    fi
+else
+    echo "apt-get not found, skipping removal of CMake via apt."
+fi
+
+# 3. Create installation and temporary directories
+echo "Creating CMake installation directory /opt/cmake..."
+mkdir -p /opt/cmake
+
+TMP_DIR=$(mktemp -d -t cmake-install-XXXXXXXXXX)
+echo "Temporary directory created: ${TMP_DIR}"
+# Crucial: subsequent operations needing temp files should happen in or relative to TMP_DIR
+# We will cd into TMP_DIR later, or use full paths like ${TMP_DIR}/filename
+
+# 4. Determine system architecture
+echo "Determining system architecture..."
+architecture=$(dpkg --print-architecture)
+case "${architecture}" in
+    arm64) ARCH="aarch64" ;;
+    amd64) ARCH="x86_64" ;;
+    *)
+        echo "ERROR: Unsupported architecture '${architecture}' reported by dpkg."
+        exit 1
+        ;;
+esac
+echo "Detected architecture: ${architecture} (mapped to CMake arch: ${ARCH})"
+
+# 5. Define CMake download URLs and the filename expected by checksum
+DERIVED_CMAKE_BINARY_FILENAME="cmake-${CMAKE_VERSION}-linux-${ARCH}.sh"
+CMAKE_BINARY_URL="https://github.com/Kitware/CMake/releases/download/v${CMAKE_VERSION}/${DERIVED_CMAKE_BINARY_FILENAME}"
+CMAKE_CHECKSUM_FILE_URL="https://github.com/Kitware/CMake/releases/download/v${CMAKE_VERSION}/cmake-${CMAKE_VERSION}-SHA-256.txt"
+
+# 6. Download CMake binary and checksum file
+echo "--- Downloading Files ---"
+if ! download_file "${CMAKE_BINARY_URL}" "${CMAKE_INSTALLER_SCRIPT_LOCAL_NAME}"; then
+    echo "ERROR: Failed to download CMake binary installer. See messages above."
+    exit 1
+fi
+
+if ! download_file "${CMAKE_CHECKSUM_FILE_URL}" "${CMAKE_CHECKSUM_FILE_LOCAL_NAME}"; then
+    echo "ERROR: Failed to download CMake checksum file. See messages above."
+    exit 1
+fi
+echo "Downloads complete."
+echo "--- End of Downloading Files ---"
+echo # Newline for readability
+
+# Before checksum, rename the downloaded installer to its derived name,
+# as the checksum file refers to this specific name.
+echo "Renaming downloaded installer from '${CMAKE_INSTALLER_SCRIPT_LOCAL_NAME}' to '${DERIVED_CMAKE_BINARY_FILENAME}' for checksum verification."
+mv "${TMP_DIR}/${CMAKE_INSTALLER_SCRIPT_LOCAL_NAME}" "${TMP_DIR}/${DERIVED_CMAKE_BINARY_FILENAME}"
+if [ ! -f "${TMP_DIR}/${DERIVED_CMAKE_BINARY_FILENAME}" ]; then
+    echo "ERROR: Failed to rename installer script for checksum. File '${TMP_DIR}/${DERIVED_CMAKE_BINARY_FILENAME}' does not exist after move."
+    exit 1
+fi
+
+# 7. Verify checksum
+echo "--- Verifying Checksum ---"
+echo "Checksum file is: ${TMP_DIR}/${CMAKE_CHECKSUM_FILE_LOCAL_NAME}"
+echo "Binary file to check is: ${TMP_DIR}/${DERIVED_CMAKE_BINARY_FILENAME}"
+
+# Ensure the checksum file actually contains an entry for our binary
+# This is important because the SHA-256.txt file contains checksums for *all* release assets
+echo "Checking if checksum file contains entry for '${DERIVED_CMAKE_BINARY_FILENAME}'..."
+if ! grep -q "${DERIVED_CMAKE_BINARY_FILENAME}" "${TMP_DIR}/${CMAKE_CHECKSUM_FILE_LOCAL_NAME}"; then
+    echo "ERROR: The downloaded checksum file '${CMAKE_CHECKSUM_FILE_LOCAL_NAME}' does NOT contain an entry for '${DERIVED_CMAKE_BINARY_FILENAME}'."
+    echo "This strongly suggests that the CMAKE_VERSION ('${CMAKE_VERSION}') or ARCH ('${ARCH}') is incorrect, or the specified version does not provide a .sh installer for this architecture."
+    echo "Please verify the version and available files at https://github.com/Kitware/CMake/releases/tag/v${CMAKE_VERSION}"
+    exit 1
+fi
+echo "Checksum file contains an entry for '${DERIVED_CMAKE_BINARY_FILENAME}'."
+
+# Perform the checksum. We need to be in the directory where the files are.
+echo "Changing directory to ${TMP_DIR} for checksum verification."
+cd "${TMP_DIR}" # <<<<<<< IMPORTANT: sha256sum -c needs to find files
+
+echo "Verifying checksum of '${DERIVED_CMAKE_BINARY_FILENAME}' using '${CMAKE_CHECKSUM_FILE_LOCAL_NAME}'..."
+# The --ignore-missing flag is good, as the .txt file has many checksums.
+# The --strict flag would cause it to error if there are improperly formatted lines.
+# We rely on the grep check above to ensure our specific file is mentioned.
+if sha256sum -c --ignore-missing "${CMAKE_CHECKSUM_FILE_LOCAL_NAME}"; then
+    echo "Checksum verification successful for '${DERIVED_CMAKE_BINARY_FILENAME}'."
+else
+    SHA_EXIT_CODE=$?
+    echo "ERROR: Checksum verification FAILED for '${DERIVED_CMAKE_BINARY_FILENAME}' with exit code ${SHA_EXIT_CODE}."
+    # Cleanup trap will show file contents.
+    exit 1 # Critical failure
+fi
+echo "--- End of Verifying Checksum ---"
+echo # Newline for readability
+
+# 8. Install CMake
+echo "--- Installing CMake ---"
+echo "Making the CMake installer script '${DERIVED_CMAKE_BINARY_FILENAME}' executable..."
+chmod +x "${DERIVED_CMAKE_BINARY_FILENAME}" # Still in TMP_DIR
+
+echo "Executing CMake installer script: ./${DERIVED_CMAKE_BINARY_FILENAME} --prefix=/opt/cmake --skip-license"
+# Execute the script. If this script exits with 8, this is our culprit.
+if ./"${DERIVED_CMAKE_BINARY_FILENAME}" --prefix=/opt/cmake --skip-license; then
+    echo "CMake installer script executed successfully."
+else
+    INSTALLER_EXIT_CODE=$?
+    echo "ERROR: CMake installer script FAILED with exit code ${INSTALLER_EXIT_CODE}."
+    # This is the most likely place for an exit code 8 if downloads and checksums were okay.
+    # The trap will handle cleanup. The script will exit with INSTALLER_EXIT_CODE due to the trap.
+    exit ${INSTALLER_EXIT_CODE} # Explicitly exit with the installer's code
+fi
+echo "--- End of Installing CMake ---"
+echo # Newline for readability
+
+# 9. Create symlinks
+echo "Creating symbolic links for cmake and ctest in /usr/local/bin/..."
+ln -sf /opt/cmake/bin/cmake /usr/local/bin/cmake
+ln -sf /opt/cmake/bin/ctest /usr/local/bin/ctest
+echo "Symbolic links created."
+
+echo # Newline for readability
+echo "SUCCESS: CMake ${CMAKE_VERSION} installation and setup complete."
+
+# The script will exit with 0 here. The trap will run, see $? is 0, and then exit 0.
+exit 0

.devcontainer/devcontainer.json

@@ -0,0 +1,13 @@
+// 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": "Default",
+	"build": {
+		"dockerfile": "./Dockerfile",
+		"args": {
+			"BASE_IMAGE_NAME": "mcr.microsoft.com/devcontainers/cpp:2@sha256:a5eb5a1e9109af88bf82ebb0f71903608a68144851ed1e4b852e31b251ac59c6",
+			"DEBIAN_SNAPSHOT": "20260223T000000Z"
+		},
+		"context": "./context"
+	}
+}

.devcontainer/gcc09/devcontainer.json

@@ -0,0 +1,13 @@
+// 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": "Gcc 09",
+	"build": {
+		"dockerfile": "../Dockerfile",
+		"args": {
+			"BASE_IMAGE_NAME": "gcc:9",
+			"DEBIAN_SNAPSHOT": "none"
+		},
+		"context": "../context"
+	}
+}

.devcontainer/gcc10/devcontainer.json

@@ -0,0 +1,13 @@
+// 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": "Gcc 10",
+	"build": {
+		"dockerfile": "../Dockerfile",
+		"args": {
+			"BASE_IMAGE_NAME": "gcc:10",
+			"DEBIAN_SNAPSHOT": "none"
+		},
+		"context": "../context"
+	}
+}

.devcontainer/gcc11/devcontainer.json

@@ -0,0 +1,13 @@
+// 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": "Gcc 11",
+	"build": {
+		"dockerfile": "../Dockerfile",
+		"args": {
+			"BASE_IMAGE_NAME": "gcc:11",
+			"DEBIAN_SNAPSHOT": "none"
+		},
+		"context": "../context"
+	}
+}

.devcontainer/gcc12/devcontainer.json

@@ -0,0 +1,13 @@
+// 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": "Gcc 12",
+	"build": {
+		"dockerfile": "../Dockerfile",
+		"args": {
+			"BASE_IMAGE_NAME": "gcc:12",
+			"DEBIAN_SNAPSHOT": "none"
+		},
+		"context": "../context"
+	}
+}

.devcontainer/gcc13/devcontainer.json

@@ -0,0 +1,13 @@
+// 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": "Gcc 13",
+	"build": {
+		"dockerfile": "../Dockerfile",
+		"args": {
+			"BASE_IMAGE_NAME": "gcc:13",
+			"DEBIAN_SNAPSHOT": "none"
+		},
+		"context": "../context"
+	}
+}

.devcontainer/gcc14/devcontainer.json

@@ -0,0 +1,13 @@
+// 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": "Gcc 14",
+	"build": {
+		"dockerfile": "../Dockerfile",
+		"args": {
+			"BASE_IMAGE_NAME": "gcc:14",
+			"DEBIAN_SNAPSHOT": "none"
+		},
+		"context": "../context"
+	}
+}

.devcontainer/gcc15/devcontainer.json

@@ -0,0 +1,13 @@
+// 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": "Gcc 15",
+	"build": {
+		"dockerfile": "../Dockerfile",
+		"args": {
+			"BASE_IMAGE_NAME": "gcc:15",
+			"DEBIAN_SNAPSHOT": "none"
+		},
+		"context": "../context"
+	}
+}

.devcontainer/s390x/Dockerfile

@@ -0,0 +1,40 @@
+# s390x Big-Endian Test Environment for ETL
+# Uses QEMU user-mode emulation to run s390x binaries on x64 host
+FROM debian:trixie
+
+# Avoid prompts from apt
+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\
+    qemu-user-static \
+    qemu-user \
+    binfmt-support \
+    gcc-s390x-linux-gnu \
+    g++-s390x-linux-gnu \
+    cmake \
+    make \
+    ninja-build \
+    git \
+    wget \
+    file \
+    libc6:s390x \
+    libstdc++6:s390x \
+    && rm -rf /var/lib/apt/lists/*
+
+# Set working directory
+WORKDIR /workspaces/etl
+
+# Verify QEMU and cross-compilation setup
+RUN echo "=== Host Architecture ===" && \
+    uname -m && \
+    echo "" && \
+    echo "=== s390x Cross Compiler ===" && \
+    s390x-linux-gnu-gcc --version && \
+    echo "" && \
+    echo "=== QEMU s390x ===" && \
+    qemu-s390x-static --version | head -n1
+
+# Default command
+CMD ["/bin/bash"]

.devcontainer/s390x/devcontainer.json

@@ -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": "s390x Big Endian (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/s390x/toolchain-s390x.cmake",
+          "-DBUILD_TESTS=ON",
+          "-DNO_STL=OFF",
+          "-DETL_CXX_STANDARD=17"
+        ],
+        "cmake.buildDirectory": "${workspaceFolder}/build-s390x",
+        "cmake.generator": "Ninja"
+      }
+    }
+  },
+  "remoteUser": "root"
+}

.devcontainer/s390x/toolchain-s390x.cmake

@@ -0,0 +1,21 @@
+# CMake toolchain file for s390x cross-compilation
+set(CMAKE_SYSTEM_NAME Linux)
+set(CMAKE_SYSTEM_PROCESSOR s390x)
+
+# Specify the cross compiler
+set(CMAKE_C_COMPILER s390x-linux-gnu-gcc)
+set(CMAKE_CXX_COMPILER s390x-linux-gnu-g++)
+set(CMAKE_AR s390x-linux-gnu-ar)
+set(CMAKE_RANLIB s390x-linux-gnu-ranlib)
+set(CMAKE_STRIP s390x-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-s390x-static CACHE FILEPATH "Path to the emulator for cross-compiled binaries")

.github/workflows/clang-c++11.yml

@@ -3,7 +3,8 @@ on:
   push:
     branches: [ master, development, pull-request/* ]
   pull_request:
-    branches: [ master, pull-request/* ]
+    branches: [ master, development, pull-request/* ]
+    types: [opened, synchronize, reopened]
 
 jobs:
 
@@ -15,19 +16,19 @@ jobs:
         os: [ubuntu-22.04]
 
     steps:
-    - uses: actions/checkout@v3
+    - 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=OFF -DETL_CXX_STANDARD=11 ./
+        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
+        make -j $(getconf _NPROCESSORS_ONLN)
 
     - name: Run tests
-      run: ./test/etl_tests
+      run: ./test/etl_tests -v
 
   build-clang-cpp11-linux-no-stl:
     name: Clang C++11 Linux - No STL
@@ -37,16 +38,16 @@ jobs:
         os: [ubuntu-22.04]
 
     steps:
-    - uses: actions/checkout@v3
+    - 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=OFF -DETL_CXX_STANDARD=11 ./
+        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
+        make -j $(getconf _NPROCESSORS_ONLN)
 
     - name: Run tests
-      run: ./test/etl_tests
+      run: ./test/etl_tests -v

.github/workflows/clang-c++14.yml

@@ -3,7 +3,8 @@ on:
   push:
     branches: [ master, development, pull-request/* ]
   pull_request:
-    branches: [ master, pull-request/* ]
+    branches: [ master, development, pull-request/* ]
+    types: [opened, synchronize, reopened]
 
 jobs:
 
@@ -15,19 +16,19 @@ jobs:
         os: [ubuntu-22.04]
 
     steps:
-    - uses: actions/checkout@v3
+    - 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=OFF -DETL_CXX_STANDARD=14 ./
+        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
+        make -j $(getconf _NPROCESSORS_ONLN)
 
     - name: Run tests
-      run: ./test/etl_tests
+      run: ./test/etl_tests -v
 
   build-clang-cpp14-linux-no-stl:
     name: Clang C++14 Linux - No STL
@@ -37,16 +38,16 @@ jobs:
         os: [ubuntu-22.04]
 
     steps:
-    - uses: actions/checkout@v3
+    - 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=OFF -DETL_CXX_STANDARD=14 ./
+        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
+        make -j $(getconf _NPROCESSORS_ONLN)
 
     - name: Run tests
-      run: ./test/etl_tests
+      run: ./test/etl_tests -v

.github/workflows/clang-c++17.yml

@@ -3,7 +3,8 @@ on:
   push:
     branches: [ master, development, pull-request/* ]
   pull_request:
-    branches: [ master, pull-request/* ]
+    branches: [ master, development, pull-request/* ]
+    types: [opened, synchronize, reopened]
 
 jobs:
 
@@ -15,19 +16,19 @@ jobs:
         os: [ubuntu-22.04]
 
     steps:
-    - uses: actions/checkout@v3
+    - 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=OFF -DETL_CXX_STANDARD=17 ./
+        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
+        make -j $(getconf _NPROCESSORS_ONLN)
 
     - name: Run tests
-      run: ./test/etl_tests
+      run: ./test/etl_tests -v
 
   build-clang-cpp17-linux-no-stl:
     name: Clang C++17 Linux - No STL
@@ -37,16 +38,16 @@ jobs:
         os: [ubuntu-22.04]
 
     steps:
-    - uses: actions/checkout@v3
+    - 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=OFF -DETL_CXX_STANDARD=17 ./
+        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
+        make -j $(getconf _NPROCESSORS_ONLN)
 
     - name: Run tests
-      run: ./test/etl_tests
+      run: ./test/etl_tests -v

.github/workflows/clang-c++20.yml

@@ -3,7 +3,8 @@ on:
   push:
     branches: [ master, development, pull-request/* ]
   pull_request:
-    branches: [ master, pull-request/* ]
+    branches: [ master, development, pull-request/* ]
+    types: [opened, synchronize, reopened]
 
 jobs:
 
@@ -15,7 +16,7 @@ jobs:
         os: [ubuntu-22.04]
 
     steps:
-    - uses: actions/checkout@v3
+    - uses: actions/checkout@v4
 
     # Temporary fix. See https://github.com/actions/runner-images/issues/8659
     - name: Install newer Clang
@@ -29,12 +30,12 @@ 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=20 ./
+        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
+        make -j $(getconf _NPROCESSORS_ONLN)
     
     - name: Run tests
-      run: ./test/etl_tests
+      run: ./test/etl_tests -v
 
   build-clang-cpp20-linux-stl-force-cpp03:
     name: Clang C++20 Linux - STL - Force C++03
@@ -44,7 +45,7 @@ jobs:
         os: [ubuntu-22.04]
 
     steps:
-    - uses: actions/checkout@v3
+    - uses: actions/checkout@v4
 
     # Temporary fix. See https://github.com/actions/runner-images/issues/8659
     - name: Install newer Clang
@@ -58,12 +59,12 @@ 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=20 ./
+        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
+        make -j $(getconf _NPROCESSORS_ONLN)
 
     - name: Run tests
-      run: ./test/etl_tests
+      run: ./test/etl_tests -v
 
   build-clang-cpp20-linux-no-stl-force-cpp03:
     name: Clang C++20 Linux - No STL - Force C++03
@@ -73,7 +74,7 @@ jobs:
         os: [ubuntu-22.04]
 
     steps:
-    - uses: actions/checkout@v3
+    - uses: actions/checkout@v4
 
     # Temporary fix. See https://github.com/actions/runner-images/issues/8659
     - name: Install newer Clang
@@ -87,98 +88,98 @@ 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=20 ./
+        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
+        make -j $(getconf _NPROCESSORS_ONLN)
 
     - name: Run tests
-      run: ./test/etl_tests
+      run: ./test/etl_tests -v
 
   build-clang-cpp20-osx-stl:
     name: Clang C++20 OSX - STL
     runs-on: ${{ matrix.os }}
     strategy:
       matrix:
-        os: [macos-12]
+        os: [macos-15]
 
     steps:
-    - uses: actions/checkout@v3
+    - 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=OFF -DETL_CXX_STANDARD=20 ./
+        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
+        make -j $(getconf _NPROCESSORS_ONLN)
 
     - name: Run tests
-      run: ./test/etl_tests
+      run: ./test/etl_tests -v
 
   build-clang-cpp20-osx-no-stl:
     name: Clang C++20 OSX - No STL
     runs-on: ${{ matrix.os }}
     strategy:
       matrix:
-        os: [macos-12]
+        os: [macos-15]
 
     steps:
-    - uses: actions/checkout@v3
+    - 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=OFF -DETL_CXX_STANDARD=20 ./
+        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
+        make -j $(getconf _NPROCESSORS_ONLN)
 
     - name: Run tests
-      run: ./test/etl_tests
+      run: ./test/etl_tests -v
 
   build-clang-cpp20-osx-stl-force-cpp03:
     name: Clang C++20 OSX - STL - Force C++03
     runs-on: ${{ matrix.os }}
     strategy:
       matrix:
-        os: [macos-12]
+        os: [macos-15]
 
     steps:
-    - uses: actions/checkout@v3
+    - 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=ON -DETL_CXX_STANDARD=20 ./
+        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
+        make -j $(getconf _NPROCESSORS_ONLN)
 
     - name: Run tests
-      run: ./test/etl_tests
+      run: ./test/etl_tests -v
 
   build-clang-cpp20-osx-no-stl-force-cpp03:
     name: Clang C++20 OSX - No STL - Force C++03
     runs-on: ${{ matrix.os }}
     strategy:
       matrix:
-        os: [macos-12]
+        os: [macos-15]
 
     steps:
-    - uses: actions/checkout@v3
+    - 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=ON -DETL_CXX_STANDARD=20 ./
+        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
+        make -j $(getconf _NPROCESSORS_ONLN)
 
     - name: Run tests
-      run: ./test/etl_tests
+      run: ./test/etl_tests -v
 

.github/workflows/clang-c++23.yml

@@ -0,0 +1,185 @@
+name: clang-c++23
+on:
+  push:
+    branches: [ master, development, pull-request/* ]
+  pull_request:
+    branches: [ master, development, pull-request/* ]
+    types: [opened, synchronize, reopened]
+
+jobs:
+
+  build-clang-cpp23-linux-no-stl:
+    name: Clang C++23 Linux - No STL
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: [ubuntu-22.04]
+
+    steps:
+    - uses: actions/checkout@v4
+
+    # Temporary fix. See https://github.com/actions/runner-images/issues/8659
+    - name: Install newer Clang
+      run: |
+        wget https://apt.llvm.org/llvm.sh
+        chmod +x ./llvm.sh
+        sudo ./llvm.sh 17
+
+    - name: Build
+      run: |
+        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 ./
+        clang-17 --version
+        make -j $(getconf _NPROCESSORS_ONLN)
+    
+    - name: Run tests
+      run: ./test/etl_tests -v
+
+  build-clang-cpp23-linux-stl-force-cpp03:
+    name: Clang C++23 Linux - STL - Force C++03
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: [ubuntu-22.04]
+
+    steps:
+    - uses: actions/checkout@v4
+
+    # Temporary fix. See https://github.com/actions/runner-images/issues/8659
+    - name: Install newer Clang
+      run: |
+        wget https://apt.llvm.org/llvm.sh
+        chmod +x ./llvm.sh
+        sudo ./llvm.sh 17
+
+    - name: Build
+      run: |
+        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 ./
+        clang-17 --version
+        make -j $(getconf _NPROCESSORS_ONLN)
+
+    - name: Run tests
+      run: ./test/etl_tests -v
+
+  build-clang-cpp2-linux-no-stl-force-cpp03:
+    name: Clang C++23 Linux - No STL - Force C++03
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: [ubuntu-22.04]
+
+    steps:
+    - uses: actions/checkout@v4
+
+    # Temporary fix. See https://github.com/actions/runner-images/issues/8659
+    - name: Install newer Clang
+      run: |
+        wget https://apt.llvm.org/llvm.sh
+        chmod +x ./llvm.sh
+        sudo ./llvm.sh 17
+
+    - name: Build
+      run: |
+        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 ./
+        clang-17 --version
+        make -j $(getconf _NPROCESSORS_ONLN)
+
+    - name: Run tests
+      run: ./test/etl_tests -v
+
+  build-clang-cpp23-osx-stl:
+    name: Clang C++23 OSX - STL
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: [macos-15]
+
+    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=OFF -DETL_CXX_STANDARD=23 ./
+        clang --version
+        make -j $(getconf _NPROCESSORS_ONLN)
+
+    - name: Run tests
+      run: ./test/etl_tests -v
+
+  build-clang-cpp23-osx-no-stl:
+    name: Clang C++23 OSX - No STL
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: [macos-15]
+
+    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=OFF -DETL_CXX_STANDARD=23 ./
+        clang --version
+        make -j $(getconf _NPROCESSORS_ONLN)
+
+    - name: Run tests
+      run: ./test/etl_tests -v
+
+  build-clang-cpp23-osx-stl-force-cpp03:
+    name: Clang C++23 OSX - STL - Force C++03
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: [macos-15]
+
+    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=ON -DETL_CXX_STANDARD=23 ./
+        clang --version
+        make -j $(getconf _NPROCESSORS_ONLN)
+
+    - name: Run tests
+      run: ./test/etl_tests -v
+
+  build-clang-cpp23-osx-no-stl-force-cpp03:
+    name: Clang C++23 OSX - No STL - Force C++03
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: [macos-15]
+
+    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=ON -DETL_CXX_STANDARD=23 ./
+        clang --version
+        make -j $(getconf _NPROCESSORS_ONLN)
+
+    - name: Run tests
+      run: ./test/etl_tests -v
+

.github/workflows/clang-format.yaml

@@ -0,0 +1,43 @@
+name: clang-format
+
+on:
+  push:
+    branches: [ master, development, pull-request/* ]
+  pull_request:
+    branches: [ master, development, pull-request/* ]
+    types: [opened, synchronize, reopened]
+
+jobs:
+  clang-format:
+    name: clang-format
+    runs-on: ubuntu-24.04
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Install clang-format and git
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y --no-install-recommends git clang-format
+          clang-format --version
+
+      - name: Run clang-format on added/changed files
+        run: |
+          if [ "${{ github.event_name }}" = "pull_request" ]; then
+            BEFORE="origin/${{ github.base_ref }}"
+          elif [ "${{ github.event_name }}" = "push" ]; then
+            BEFORE="${{ github.event.before }}"
+          else
+            echo "Unsupported event: ${{ github.event_name }}"
+            echo "This is likely a bug in the workflow configuration. Please report it to the maintainers."
+            exit 1
+          fi
+
+          git diff --name-only -z --diff-filter=AMCR "$BEFORE"..HEAD -- \
+            '*.c' '*.cc' '*.cxx' '*.cpp' \
+            '*.h' '*.hh' '*.hpp' '*.hxx' \
+            '*.ipp' '*.inl' \
+            ':(exclude)include/etl/generators/*' \
+            ':(exclude)include/etl/private/*_cpp03.h' \
+            | xargs -0 --no-run-if-empty clang-format --Werror -n --style=file

.github/workflows/clang-format_update.yaml

@@ -0,0 +1,21 @@
+name: clang-format-update
+
+on:
+  workflow_dispatch:
+
+jobs:
+  clang-format:
+    runs-on: ubuntu-24.04
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Install clang-format
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y --no-install-recommends clang-format
+          clang-format --version
+
+      - name: Run clang-format
+        run: |
+          find . \( -name '*.cpp' -o -name '*.h' -o -name '*.c' \) | xargs clang-format --dry-run --Werror

.github/workflows/clang-syntax-checks.yml

@@ -3,329 +3,402 @@ on:
   push:
     branches: [ master, development, pull-request/* ]
   pull_request:
-    branches: [ master, pull-request/* ]
+    branches: [ master, development, pull-request/* ]
+    types: [opened, synchronize, reopened]
 
 jobs:
   build-clang-cpp03-linux-STL:
-    name: Clang C++03 Linux STL
+    name: Syntax Check - Clang C++03 Linux STL
     runs-on: ${{ matrix.os }}
     strategy:
       matrix:
         os: [ubuntu-22.04]
 
     steps:
-    - uses: actions/checkout@v3
+    - 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 ./test/syntax_check/c++03
+        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
+        make -j $(getconf _NPROCESSORS_ONLN)
 
   build-clang-cpp03-linux-No-STL:
-    name: Clang C++03 Linux No STL 
+    name: Syntax Check - Clang C++03 Linux No STL 
     runs-on: ${{ matrix.os }}
     strategy:
       matrix:
         os: [ubuntu-22.04]
 
     steps:
-    - uses: actions/checkout@v3
+    - 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 ./test/syntax_check/c++03
+        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
+        make -j $(getconf _NPROCESSORS_ONLN)
 
   build-clang-cpp11-linux-STL:
-    name: Clang C++11 Linux STL
+    name: Syntax Check - Clang C++11 Linux STL
     runs-on: ${{ matrix.os }}
     strategy:
       matrix:
         os: [ubuntu-22.04]
 
     steps:
-    - uses: actions/checkout@v3
+    - 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 ./test/syntax_check/c++11
+        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
+        make -j $(getconf _NPROCESSORS_ONLN)
 
   build-clang-cpp11-linux-No-STL:
-    name: Clang C++11 Linux No STL 
+    name: Syntax Check - Clang C++11 Linux No STL 
     runs-on: ${{ matrix.os }}
     strategy:
       matrix:
         os: [ubuntu-22.04]
 
     steps:
-    - uses: actions/checkout@v3
+    - 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 ./test/syntax_check/c++11
+        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
+        make -j $(getconf _NPROCESSORS_ONLN)
 
   build-clang-cpp11-linux-STL-Force-CPP03:
-    name: Clang C++11 Linux STL Force C++03
+    name: Syntax Check - Clang C++11 Linux STL Force C++03
     runs-on: ${{ matrix.os }}
     strategy:
       matrix:
         os: [ubuntu-22.04]
 
     steps:
-    - uses: actions/checkout@v3
+    - 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 ./test/syntax_check/c++11
+        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
+        make -j $(getconf _NPROCESSORS_ONLN)
 
   build-clang-cpp11-linux-No-STL-Force-CPP03:
-    name: Clang C++11 Linux No STL Force C++03
+    name: Syntax Check - Clang C++11 Linux No STL Force C++03
     runs-on: ${{ matrix.os }}
     strategy:
       matrix:
         os: [ubuntu-22.04]
 
     steps:
-    - uses: actions/checkout@v3
+    - 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 ./test/syntax_check/c++11
+        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
+        make -j $(getconf _NPROCESSORS_ONLN)
 
   build-clang-cpp14-linux-STL:
-    name: Clang C++14 Linux STL
+    name: Syntax Check - Clang C++14 Linux STL
     runs-on: ${{ matrix.os }}
     strategy:
       matrix:
         os: [ubuntu-22.04]
 
     steps:
-    - uses: actions/checkout@v3
+    - 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 ./test/syntax_check/c++14
+        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
+        make -j $(getconf _NPROCESSORS_ONLN)
 
   build-clang-cpp14-linux-No-STL:
-    name: Clang C++14 Linux No STL 
+    name: Syntax Check - Clang C++14 Linux No STL 
     runs-on: ${{ matrix.os }}
     strategy:
       matrix:
         os: [ubuntu-22.04]
 
     steps:
-    - uses: actions/checkout@v3
+    - 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 ./test/syntax_check/c++14
+        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
+        make -j $(getconf _NPROCESSORS_ONLN)
 
   build-clang-cpp14-linux-STL-Force-CPP03:
-    name: Clang C++14 Linux STL Force C++03
+    name: Syntax Check - Clang C++14 Linux STL Force C++03
     runs-on: ${{ matrix.os }}
     strategy:
       matrix:
         os: [ubuntu-22.04]
 
     steps:
-    - uses: actions/checkout@v3
+    - 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 ./test/syntax_check/c++14
+        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
+        make -j $(getconf _NPROCESSORS_ONLN)
 
   build-clang-cpp14-linux-No-STL-Force-CPP03:
-    name: Clang C++14 Linux No STL Force C++03
+    name: Syntax Check - Clang C++14 Linux No STL Force C++03
     runs-on: ${{ matrix.os }}
     strategy:
       matrix:
         os: [ubuntu-22.04]
 
     steps:
-    - uses: actions/checkout@v3
+    - 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 ./test/syntax_check/c++14
+        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
+        make -j $(getconf _NPROCESSORS_ONLN)
 
   build-clang-cpp17-linux-STL:
-    name: Clang C++17 Linux STL
+    name: Syntax Check - Clang C++17 Linux STL
     runs-on: ${{ matrix.os }}
     strategy:
       matrix:
         os: [ubuntu-22.04]
 
     steps:
-    - uses: actions/checkout@v3
+    - 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 ./test/syntax_check/c++17
+        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
+        make -j $(getconf _NPROCESSORS_ONLN)
 
   build-clang-cpp17-linux-No-STL:
-    name: Clang C++17 Linux No STL 
+    name: Syntax Check - Clang C++17 Linux No STL 
     runs-on: ${{ matrix.os }}
     strategy:
       matrix:
         os: [ubuntu-22.04]
 
     steps:
-    - uses: actions/checkout@v3
+    - 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 ./test/syntax_check/c++17
+        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
+        make -j $(getconf _NPROCESSORS_ONLN)
 
   build-clang-cpp17-linux-STL-Force-CPP03:
-    name: Clang C++17 Linux STL Force C++03
+    name: Syntax Check - Clang C++17 Linux STL Force C++03
     runs-on: ${{ matrix.os }}
     strategy:
       matrix:
         os: [ubuntu-22.04]
 
     steps:
-    - uses: actions/checkout@v3
+    - 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 ./test/syntax_check/c++17
+        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
+        make -j $(getconf _NPROCESSORS_ONLN)
 
   build-clang-cpp17-linux-No-STL-Force-CPP03:
-    name: Clang C++17 Linux No STL Force C++03
+    name: Syntax Check - Clang C++17 Linux No STL Force C++03
     runs-on: ${{ matrix.os }}
     strategy:
       matrix:
         os: [ubuntu-22.04]
 
     steps:
-    - uses: actions/checkout@v3
+    - 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 ./test/syntax_check/c++17
+        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
+        make -j $(getconf _NPROCESSORS_ONLN)
 
   build-clang-cpp20-linux-STL:
-    name: Clang C++20 Linux STL
+    name: Syntax Check - Clang C++20 Linux STL
     runs-on: ${{ matrix.os }}
     strategy:
       matrix:
         os: [ubuntu-22.04]
 
     steps:
-    - uses: actions/checkout@v3
+    - 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 ./test/syntax_check/c++20
+        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
+        make -j $(getconf _NPROCESSORS_ONLN)
 
   build-clang-cpp20-linux-No-STL:
-    name: Clang C++20 Linux No STL 
+    name: Syntax Check - Clang C++20 Linux No STL 
     runs-on: ${{ matrix.os }}
     strategy:
       matrix:
         os: [ubuntu-22.04]
 
     steps:
-    - uses: actions/checkout@v3
+    - 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 ./test/syntax_check/c++20
+        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
+        make -j $(getconf _NPROCESSORS_ONLN)
 
   build-clang-cpp20-linux-STL-Force-CPP03:
-    name: Clang C++20 Linux STL Force C++03
+    name: Syntax Check - Clang C++20 Linux STL Force C++03
     runs-on: ${{ matrix.os }}
     strategy:
       matrix:
         os: [ubuntu-22.04]
 
     steps:
-    - uses: actions/checkout@v3
+    - 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 ./test/syntax_check/c++20
+        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
+        make -j $(getconf _NPROCESSORS_ONLN)
 
   build-clang-cpp20-linux-No-STL-Force-CPP03:
-    name: Clang C++20 Linux No STL Force C++03
+    name: Syntax Check - Clang C++20 Linux No STL Force C++03
     runs-on: ${{ matrix.os }}
     strategy:
       matrix:
         os: [ubuntu-22.04]
 
     steps:
-    - uses: actions/checkout@v3
+    - 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 ./test/syntax_check/c++20
+        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
+        make -j $(getconf _NPROCESSORS_ONLN)
+
+  build-clang-cpp23-linux-STL:
+    name: Syntax Check - Clang C++23 Linux STL
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: [ubuntu-22.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=23 ./test/syntax_check
+        clang --version
+        make -j $(getconf _NPROCESSORS_ONLN)
+
+  build-clang-cpp23-linux-No-STL:
+    name: Syntax Check - Clang C++23 Linux No STL 
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: [ubuntu-22.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=23 ./test/syntax_check
+        clang --version
+        make -j $(getconf _NPROCESSORS_ONLN)
+
+  build-clang-cpp23-linux-STL-Force-CPP03:
+    name: Syntax Check - Clang C++23 Linux STL Force C++03
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: [ubuntu-22.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=23 ./test/syntax_check
+        clang --version
+        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
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: [ubuntu-22.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=23 ./test/syntax_check
+        clang --version
+        make -j $(getconf _NPROCESSORS_ONLN)

.github/workflows/coverage.yml

@@ -0,0 +1,72 @@
+name: coverage
+
+on:
+  push:
+    branches: [ master, pull-request/* ]
+  pull_request:
+    branches: [ master, pull-request/* ]
+    types: [opened, synchronize, reopened]
+
+# Allow only one concurrent deployment to GitHub Pages
+concurrency:
+  group: coverage-${{ github.ref }}
+  cancel-in-progress: true
+
+# Grant GITHUB_TOKEN the minimum permissions needed at the workflow level
+permissions:
+  contents: read
+
+jobs:
+
+  coverage:
+    name: Generate Coverage Report
+    runs-on: ubuntu-24.04
+
+    steps:
+    - uses: actions/checkout@v4
+
+    - name: Install dependencies
+      run: |
+        sudo apt-get update
+        sudo apt-get install -y lcov llvm gcc g++ clang cmake
+
+    - name: Build, test, and collect coverage
+      run: |
+        cd test
+        ./run-coverage.sh
+
+    - name: Upload coverage report artifact
+      uses: actions/upload-artifact@v4
+      with:
+        name: coverage-report
+        path: test/build-coverage/coverage/
+        retention-days: 30
+
+    - name: Upload Pages artifact
+      if: github.event_name == 'push' && github.ref == 'refs/heads/master'
+      uses: actions/upload-pages-artifact@v3
+      with:
+        path: test/build-coverage/coverage/
+
+  deploy-pages:
+    name: Deploy to GitHub Pages
+    if: github.event_name == 'push' && github.ref == 'refs/heads/master'
+    needs: coverage
+    runs-on: ubuntu-22.04
+
+    permissions:
+      pages: write
+      id-token: write
+
+    environment:
+      name: github-pages
+      url: ${{ steps.deployment.outputs.page_url }}
+
+    steps:
+    - name: Deploy to GitHub Pages
+      id: deployment
+      uses: actions/deploy-pages@v4
+
+# GitHub Repository settings
+# -> Settings -> Pages
+# -> Source: gh actions

.github/workflows/gcc-c++11.yml

@@ -3,7 +3,8 @@ on:
   push:
     branches: [ master, development, pull-request/* ]
   pull_request:
-    branches: [ master, pull-request/* ]
+    branches: [ master, development, pull-request/* ]
+    types: [opened, synchronize, reopened]
 
 jobs:
   
@@ -15,7 +16,7 @@ jobs:
         os: [ubuntu-22.04]
 
     steps:
-    - uses: actions/checkout@v3
+    - uses: actions/checkout@v4
 
     - name: Build
       run: |
@@ -23,12 +24,12 @@ 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=11 ./
+        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
+        make -j $(getconf _NPROCESSORS_ONLN)
     
     - name: Run tests
-      run: ./test/etl_tests
+      run: ./test/etl_tests -v
 
   build-gcc-cpp11-linux-no-stl:
     name: GCC C++11 Linux - No STL
@@ -38,7 +39,7 @@ jobs:
         os: [ubuntu-22.04]
 
     steps:
-    - uses: actions/checkout@v3
+    - uses: actions/checkout@v4
 
     - name: Build
       run: |
@@ -46,9 +47,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=11 ./
+        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
+        make -j $(getconf _NPROCESSORS_ONLN)
     
     - name: Run tests
-      run: ./test/etl_tests
+      run: ./test/etl_tests -v

.github/workflows/gcc-c++14.yml

@@ -3,7 +3,8 @@ on:
   push:
     branches: [ master, development, pull-request/* ]
   pull_request:
-    branches: [ master, pull-request/* ]
+    branches: [ master, development, pull-request/* ]
+    types: [opened, synchronize, reopened]
 
 jobs:
 
@@ -15,19 +16,19 @@ jobs:
         os: [ubuntu-22.04]
 
     steps:
-    - uses: actions/checkout@v3
+    - 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=OFF -DETL_CXX_STANDARD=14 ./
+        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
+        make -j $(getconf _NPROCESSORS_ONLN)
     
     - name: Run tests
-      run: ./test/etl_tests
+      run: ./test/etl_tests -v
 
   build-gcc-cpp14-linux-no-stl:
     name: GCC C++14 Linux - No STL
@@ -37,16 +38,16 @@ jobs:
         os: [ubuntu-22.04]
 
     steps:
-    - uses: actions/checkout@v3
+    - 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=OFF -DETL_CXX_STANDARD=14 ./
+        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
+        make -j $(getconf _NPROCESSORS_ONLN)
     
     - name: Run tests
-      run: ./test/etl_tests
+      run: ./test/etl_tests -v

.github/workflows/gcc-c++17.yml

@@ -3,7 +3,8 @@ on:
   push:
     branches: [ master, development, pull-request/* ]
   pull_request:
-    branches: [ master, pull-request/* ]
+    branches: [ master, development, pull-request/* ]
+    types: [opened, synchronize, reopened]
 
 jobs:
 
@@ -15,19 +16,19 @@ jobs:
         os: [ubuntu-22.04]
 
     steps:
-    - uses: actions/checkout@v3
+    - 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=OFF -DETL_CXX_STANDARD=17 ./
+        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
+        make -j $(getconf _NPROCESSORS_ONLN)
     
     - name: Run tests
-      run: ./test/etl_tests
+      run: ./test/etl_tests -v
 
   build-gcc-cpp17-linux-no-stl:
     name: GCC C++17 Linux - No STL
@@ -37,16 +38,16 @@ jobs:
         os: [ubuntu-22.04]
 
     steps:
-    - uses: actions/checkout@v3
+    - 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=OFF -DETL_CXX_STANDARD=17 ./
+        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
+        make -j $(getconf _NPROCESSORS_ONLN)
     
     - name: Run tests
-      run: ./test/etl_tests
+      run: ./test/etl_tests -v

.github/workflows/gcc-c++20.yml

@@ -3,7 +3,8 @@ on:
   push:
     branches: [ master, development, pull-request/* ]
   pull_request:
-    branches: [ master, pull-request/* ]
+    branches: [ master, development, pull-request/* ]
+    types: [opened, synchronize, reopened]
 
 jobs:
 
@@ -15,19 +16,19 @@ jobs:
         os: [ubuntu-22.04]
 
     steps:
-    - uses: actions/checkout@v3
+    - 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=OFF -DETL_CXX_STANDARD=20 ./
+        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
+        make -j $(getconf _NPROCESSORS_ONLN)
     
     - name: Run tests
-      run: ./test/etl_tests
+      run: ./test/etl_tests -v
 
   build-gcc-cpp20-linux-no-stl:
     name: GCC C++20 Linux - No STL
@@ -37,19 +38,19 @@ jobs:
         os: [ubuntu-22.04]
 
     steps:
-    - uses: actions/checkout@v3
+    - 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=OFF -DETL_CXX_STANDARD=20 ./
+        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
+        make -j $(getconf _NPROCESSORS_ONLN)
     
     - name: Run tests
-      run: ./test/etl_tests
+      run: ./test/etl_tests -v
 
   build-gcc-cpp20-linux-stl-force-cpp03:
     name: GCC C++20 Linux - STL - Force C++03
@@ -59,19 +60,19 @@ jobs:
         os: [ubuntu-22.04]
 
     steps:
-    - uses: actions/checkout@v3
+    - 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=ON -DETL_CXX_STANDARD=20 ./
+        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
+        make -j $(getconf _NPROCESSORS_ONLN)
 
     - name: Run tests
-      run: ./test/etl_tests
+      run: ./test/etl_tests -v
 
   build-gcc-cpp20-linux-no-stl-force-cpp03:
     name: GCC C++20 Linux - No STL - Force C++03
@@ -81,16 +82,16 @@ jobs:
         os: [ubuntu-22.04]
 
     steps:
-    - uses: actions/checkout@v3
+    - 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=OON -DETL_USE_TYPE_TRAITS_BUILTINS=OFF -DETL_USER_DEFINED_TYPE_TRAITS=OFF -DETL_FORCE_TEST_CPP03=ON -DETL_CXX_STANDARD=20 ./
+        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
+        make -j $(getconf _NPROCESSORS_ONLN)
     
     - name: Run tests
-      run: ./test/etl_tests
+      run: ./test/etl_tests -v

.github/workflows/gcc-c++23.yml

@@ -0,0 +1,97 @@
+name: gcc-c++23
+on:
+  push:
+    branches: [ master, development, pull-request/* ]
+  pull_request:
+    branches: [ master, development, pull-request/* ]
+    types: [opened, synchronize, reopened]
+
+jobs:
+
+  build-gcc-cpp23-linux-stl:
+    name: GCC C++23 Linux - STL
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: [ubuntu-22.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=OFF -DETL_CXX_STANDARD=23 ./
+        gcc --version
+        make -j $(getconf _NPROCESSORS_ONLN)
+    
+    - name: Run tests
+      run: ./test/etl_tests -v
+
+  build-gcc-cpp23-linux-no-stl:
+    name: GCC C++23 Linux - No STL
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: [ubuntu-22.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=OFF -DETL_CXX_STANDARD=23 ./
+        gcc --version
+        make -j $(getconf _NPROCESSORS_ONLN)
+    
+    - name: Run tests
+      run: ./test/etl_tests -v
+
+  build-gcc-cpp23-linux-stl-force-cpp03:
+    name: GCC C++23 Linux - STL - Force C++03
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: [ubuntu-22.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=ON -DETL_CXX_STANDARD=23 ./
+        gcc --version
+        make -j $(getconf _NPROCESSORS_ONLN)
+
+    - name: Run tests
+      run: ./test/etl_tests -v
+
+  build-gcc-cpp23-linux-no-stl-force-cpp03:
+    name: GCC C++23 Linux - No STL - Force C++03
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: [ubuntu-22.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=ON -DETL_CXX_STANDARD=23 ./
+        gcc --version
+        make -j $(getconf _NPROCESSORS_ONLN)
+    
+    - name: Run tests
+      run: ./test/etl_tests -v

.github/workflows/gcc-syntax-checks.yml

@@ -3,329 +3,402 @@ on:
   push:
     branches: [ master, development, pull-request/* ]
   pull_request:
-    branches: [ master, pull-request/* ]
+    branches: [ master, development, pull-request/* ]
+    types: [opened, synchronize, reopened]
 
 jobs:
   build-gcc-cpp03-linux-STL:
-    name: GCC C++03 Linux STL
+    name: Syntax Check - GCC C++03 Linux STL
     runs-on: ${{ matrix.os }}
     strategy:
       matrix:
         os: [ubuntu-22.04]
 
     steps:
-    - uses: actions/checkout@v3
+    - 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 ./test/syntax_check/c++03
+        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
+        make -j $(getconf _NPROCESSORS_ONLN)
 
   build-gcc-cpp03-linux-No-STL:
-    name: GCC C++03 Linux No STL 
+    name: Syntax Check - GCC C++03 Linux No STL 
     runs-on: ${{ matrix.os }}
     strategy:
       matrix:
         os: [ubuntu-22.04]
 
     steps:
-    - uses: actions/checkout@v3
+    - 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 ./test/syntax_check/c++03
+        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
+        make -j $(getconf _NPROCESSORS_ONLN)
 
   build-gcc-cpp11-linux-STL:
-    name: GCC C++11 Linux STL
+    name: Syntax Check - GCC C++11 Linux STL
     runs-on: ${{ matrix.os }}
     strategy:
       matrix:
         os: [ubuntu-22.04]
 
     steps:
-    - uses: actions/checkout@v3
+    - 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 ./test/syntax_check/c++11
+        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
+        make -j $(getconf _NPROCESSORS_ONLN)
 
   build-gcc-cpp11-linux-No-STL:
-    name: GCC C++11 Linux No STL 
+    name: Syntax Check - GCC C++11 Linux No STL 
     runs-on: ${{ matrix.os }}
     strategy:
       matrix:
         os: [ubuntu-22.04]
 
     steps:
-    - uses: actions/checkout@v3
+    - 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 ./test/syntax_check/c++11
+        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
+        make -j $(getconf _NPROCESSORS_ONLN)
 
   build-gcc-cpp11-linux-STL-Force-CPP03:
-    name: GCC C++11 Linux STL Force C++03
+    name: Syntax Check - GCC C++11 Linux STL Force C++03
     runs-on: ${{ matrix.os }}
     strategy:
       matrix:
         os: [ubuntu-22.04]
 
     steps:
-    - uses: actions/checkout@v3
+    - 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 ./test/syntax_check/c++11
+        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
+        make -j $(getconf _NPROCESSORS_ONLN)
 
   build-gcc-cpp11-linux-No-STL-Force-CPP03:
-    name: GCC C++11 Linux No STL Force C++03
+    name: Syntax Check - GCC C++11 Linux No STL Force C++03
     runs-on: ${{ matrix.os }}
     strategy:
       matrix:
         os: [ubuntu-22.04]
 
     steps:
-    - uses: actions/checkout@v3
+    - 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 ./test/syntax_check/c++11
+        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
+        make -j $(getconf _NPROCESSORS_ONLN)
 
   build-gcc-cpp14-linux-STL:
-    name: GCC C++14 Linux STL
+    name: Syntax Check - GCC C++14 Linux STL
     runs-on: ${{ matrix.os }}
     strategy:
       matrix:
         os: [ubuntu-22.04]
 
     steps:
-    - uses: actions/checkout@v3
+    - 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 ./test/syntax_check/c++14
+        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
+        make -j $(getconf _NPROCESSORS_ONLN)
 
   build-gcc-cpp14-linux-No-STL:
-    name: GCC C++14 Linux No STL 
+    name: Syntax Check - GCC C++14 Linux No STL 
     runs-on: ${{ matrix.os }}
     strategy:
       matrix:
         os: [ubuntu-22.04]
 
     steps:
-    - uses: actions/checkout@v3
+    - 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 ./test/syntax_check/c++14
+        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
+        make -j $(getconf _NPROCESSORS_ONLN)
 
   build-gcc-cpp14-linux-STL-Force-CPP03:
-    name: GCC C++14 Linux STL Force C++03
+    name: Syntax Check - GCC C++14 Linux STL Force C++03
     runs-on: ${{ matrix.os }}
     strategy:
       matrix:
         os: [ubuntu-22.04]
 
     steps:
-    - uses: actions/checkout@v3
+    - 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 ./test/syntax_check/c++14
+        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
+        make -j $(getconf _NPROCESSORS_ONLN)
 
   build-gcc-cpp14-linux-No-STL-Force-CPP03:
-    name: GCC C++14 Linux No STL Force C++03
+    name: Syntax Check - GCC C++14 Linux No STL Force C++03
     runs-on: ${{ matrix.os }}
     strategy:
       matrix:
         os: [ubuntu-22.04]
 
     steps:
-    - uses: actions/checkout@v3
+    - 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 ./test/syntax_check/c++14
+        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
+        make -j $(getconf _NPROCESSORS_ONLN)
 
   build-gcc-cpp17-linux-STL:
-    name: GCC C++17 Linux STL
+    name: Syntax Check - GCC C++17 Linux STL
     runs-on: ${{ matrix.os }}
     strategy:
       matrix:
         os: [ubuntu-22.04]
 
     steps:
-    - uses: actions/checkout@v3
+    - 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 ./test/syntax_check/c++17
+        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
+        make -j $(getconf _NPROCESSORS_ONLN)
 
   build-gcc-cpp17-linux-No-STL:
-    name: GCC C++17 Linux No STL 
+    name: Syntax Check - GCC C++17 Linux No STL 
     runs-on: ${{ matrix.os }}
     strategy:
       matrix:
         os: [ubuntu-22.04]
 
     steps:
-    - uses: actions/checkout@v3
+    - 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 ./test/syntax_check/c++17
+        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
+        make -j $(getconf _NPROCESSORS_ONLN)
 
   build-gcc-cpp17-linux-STL-Force-CPP03:
-    name: GCC C++17 Linux STL Force C++03
+    name: Syntax Check - GCC C++17 Linux STL Force C++03
     runs-on: ${{ matrix.os }}
     strategy:
       matrix:
         os: [ubuntu-22.04]
 
     steps:
-    - uses: actions/checkout@v3
+    - 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 ./test/syntax_check/c++17
+        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
+        make -j $(getconf _NPROCESSORS_ONLN)
 
   build-gcc-cpp17-linux-No-STL-Force-CPP03:
-    name: GCC C++17 Linux No STL Force C++03
+    name: Syntax Check - GCC C++17 Linux No STL Force C++03
     runs-on: ${{ matrix.os }}
     strategy:
       matrix:
         os: [ubuntu-22.04]
 
     steps:
-    - uses: actions/checkout@v3
+    - 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 ./test/syntax_check/c++17
+        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
+        make -j $(getconf _NPROCESSORS_ONLN)
 
   build-gcc-cpp20-linux-STL:
-    name: GCC C++20 Linux STL
+    name: Syntax Check - GCC C++20 Linux STL
     runs-on: ${{ matrix.os }}
     strategy:
       matrix:
         os: [ubuntu-22.04]
 
     steps:
-    - uses: actions/checkout@v3
+    - 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 ./test/syntax_check/c++20
+        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
+        make -j $(getconf _NPROCESSORS_ONLN)
 
   build-gcc-cpp20-linux-No-STL:
-    name: GCC C++20 Linux No STL 
+    name: Syntax Check - GCC C++20 Linux No STL 
     runs-on: ${{ matrix.os }}
     strategy:
       matrix:
         os: [ubuntu-22.04]
 
     steps:
-    - uses: actions/checkout@v3
+    - 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 ./test/syntax_check/c++20
+        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
+        make -j $(getconf _NPROCESSORS_ONLN)
 
   build-gcc-cpp20-linux-STL-Force-CPP03:
-    name: GCC C++20 Linux STL Force C++03
+    name: Syntax Check - GCC C++20 Linux STL Force C++03
     runs-on: ${{ matrix.os }}
     strategy:
       matrix:
         os: [ubuntu-22.04]
 
     steps:
-    - uses: actions/checkout@v3
+    - 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 ./test/syntax_check/c++20
+        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
+        make -j $(getconf _NPROCESSORS_ONLN)
 
   build-gcc-cpp20-linux-No-STL-Force-CPP03:
-    name: GCC C++20 Linux No STL Force C++03
+    name: Syntax Check - GCC C++20 Linux No STL Force C++03
     runs-on: ${{ matrix.os }}
     strategy:
       matrix:
         os: [ubuntu-22.04]
 
     steps:
-    - uses: actions/checkout@v3
+    - 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 ./test/syntax_check/c++20
+        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
+        make -j $(getconf _NPROCESSORS_ONLN)
+
+  build-gcc-cpp23-linux-STL:
+    name: Syntax Check - GCC C++23 Linux STL
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: [ubuntu-22.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=23 ./test/syntax_check
+        gcc --version
+        make -j $(getconf _NPROCESSORS_ONLN)
+
+  build-gcc-cpp23-linux-No-STL:
+    name: Syntax Check - GCC C++23 Linux No STL 
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: [ubuntu-22.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=23 ./test/syntax_check
+        gcc --version
+        make -j $(getconf _NPROCESSORS_ONLN)
+
+  build-gcc-cpp23-linux-STL-Force-CPP03:
+    name: Syntax Check - GCC C++23 Linux STL Force C++03
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: [ubuntu-22.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=23 ./test/syntax_check
+        gcc --version
+        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
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: [ubuntu-22.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=23 ./test/syntax_check
+        gcc --version
+        make -j $(getconf _NPROCESSORS_ONLN)

.github/workflows/generator.yml

@@ -0,0 +1,25 @@
+name: generator checks
+on:
+  push:
+    branches: [ master, development, pull-request/* ]
+  pull_request:
+    branches: [ master, pull-request/* ]
+    types: [opened, synchronize, reopened]
+
+jobs:
+  generator-run:
+    name: Header Generator
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v4
+
+    - name: Generate
+      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
+      run: |
+        git diff --exit-code

.github/workflows/msvc.yml

@@ -3,7 +3,8 @@ on:
   push:
     branches: [ master, development, pull-request/* ]
   pull_request:
-    branches: [ master, pull-request/* ]
+    branches: [ master, development, pull-request/* ]
+    types: [opened, synchronize, reopened]
 
 jobs:
   build-windows-msvc-stl:
@@ -12,7 +13,7 @@ jobs:
 
     steps:
     - name: Checkout
-      uses: actions/checkout@v3
+      uses: actions/checkout@v4
       with:
         submodules: recursive
 
@@ -21,19 +22,19 @@ jobs:
 
     - name: Build
       run: |
-        cmake -G "Visual Studio 17 2022" -AWin32 -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=20 ./
+        cmake -G "Visual Studio 17 2022" -AWin32 -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 ./
         MSBuild.exe -version
         MSBuild.exe .\etl.sln
         
     - name: Run tests
-      run: test/Debug/etl_tests.exe
+      run: test/Debug/etl_tests.exe -v
 
   build-windows-msvc-no-stl:
     name: Windows - No STL
     runs-on: [windows-2022]
     steps:
     - name: Checkout
-      uses: actions/checkout@v3
+      uses: actions/checkout@v4
       with:
         submodules: recursive
 
@@ -42,12 +43,12 @@ jobs:
 
     - name: Build
       run: |
-        cmake -G "Visual Studio 17 2022" -AWin32 -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=17 ./
+        cmake -G "Visual Studio 17 2022" -AWin32 -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 ./
         MSBuild.exe -version
         MSBuild.exe .\etl.sln
         
     - name: Run tests
-      run: test/Debug/etl_tests.exe
+      run: test/Debug/etl_tests.exe -v
 
   build-windows-msvc-stl-force-cpp03:
     name: Windows - STL - Force C++03
@@ -55,7 +56,7 @@ jobs:
 
     steps:
     - name: Checkout
-      uses: actions/checkout@v3
+      uses: actions/checkout@v4
       with:
         submodules: recursive
 
@@ -64,12 +65,12 @@ jobs:
 
     - name: Build
       run: |
-        cmake -G "Visual Studio 17 2022" -AWin32 -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=17 ./
+        cmake -G "Visual Studio 17 2022" -AWin32 -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=17 ./
         MSBuild.exe -version
         MSBuild.exe .\etl.sln
 
     - name: Run tests
-      run: test/Debug/etl_tests.exe
+      run: test/Debug/etl_tests.exe -v
         
   build-windows-msvc-no-stl-force-cpp03:
     name: Windows - No STL - Force C++03
@@ -77,7 +78,7 @@ jobs:
 
     steps:
     - name: Checkout
-      uses: actions/checkout@v3
+      uses: actions/checkout@v4
       with:
         submodules: recursive
 
@@ -86,10 +87,10 @@ jobs:
 
     - name: Build
       run: |
-        cmake -G "Visual Studio 17 2022" -AWin32 -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=17 ./
+        cmake -G "Visual Studio 17 2022" -AWin32 -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=17 ./
         MSBuild.exe -version
         MSBuild.exe .\etl.sln
 
     - name: Run tests
-      run: test/Debug/etl_tests.exe
+      run: test/Debug/etl_tests.exe -v
 

.github/workflows/platformio-update.yml

@@ -0,0 +1,26 @@
+name: Publish ETL to PlatformIO
+
+on:
+  release:
+    types: [published]  # Trigger only when a GitHub release is published
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.x"
+
+      - name: Install PlatformIO
+        run: pip install platformio
+
+      - name: Publish to PlatformIO Registry
+        run: pio package publish --owner etlcpp --non-interactive
+        env:
+          PLATFORMIO_AUTH_TOKEN: ${{ secrets.PLATFORMIO_TOKEN }}

.gitignore

@@ -3,6 +3,8 @@
 ## Personal
 #################
 docs/html
+hugo/public
+hugo/.hugo_build.lock
 include/etl/html/
 include/etl/latex/
 test/vs2013/Debug
@@ -386,3 +388,34 @@ test/vs2022/Debug MSVC C++20 - No virtual messages
 examples/MutexMessageRouter/.vs
 support/time remaining test.xlsx
 test/vs2022/Debug MSVC C++20 - Force C++03
+test/vs2022/Release MSVC C++20 - No STL - Optimised -O2 - Sanitiser
+test/test_file_list.txt
+examples/QueuedMessageRouter/vs2022/.vs/QueuedMessageRouter/CopilotIndices
+examples/QueuedMessageRouter/vs2022/.vs/QueuedMessageRouter/FileContentIndex
+examples/QueuedMessageRouter/vs2022/.vs/QueuedMessageRouter/v17
+test/etl_error_handler/assert_errors/build-make
+test/etl_error_handler/assert_function/build-make
+test/syntax_check/bgcc
+test/syntax_check/bclang
+test/vs2022/Debug Clang C++20
+test/vs2022/Debug MSVC C++20 - Forve C++03 - No virtual messages
+test/reflog.txt
+test/etl_error_handler/assert_function/build-make
+test/syntax_check/bgcc
+test/vs2022/Debug MSVC C++23
+test/vs2022/Debug MSVC C++23 - No STL
+.vs
+examples/UniquePtrWithPool/CMakeFiles
+examples/UniquePtrWithPool/cmake_install.cmake
+examples/UniquePtrWithPool/Makefile
+examples/UniquePtrWithPool/CMakeCache.txt
+examples/UniquePtrWithPool/UniquePtrWithPool
+test/vs2022/Debug Clang C++20 - Optimised -O2
+include/etl/header_file_list.txt
+temp
+test/syntax_check/build-make
+hugo/public
+hugo/resources
+hugo/.hugo_build.lock
+docs/*.html
+test/build-coverage

.treefmt.toml

@@ -0,0 +1,45 @@
+[global]
+excludes = [
+  "**/Doxyfile",
+  "**/Makefile",
+  "*.*-format",
+  "*.S",
+  "*.cmm",
+  "*.css",
+  "*.dld",
+  "*.gdb",
+  "*.gif",
+  "*.gitignore",
+  "*.html",
+  "*.ini",
+  "*.josh",
+  "*.json",
+  "*.md",
+  "*.png",
+  "*.puml",
+  "*.py",
+  "*.rb",
+  "*.rst",
+  "*.s",
+  "*.sh",
+  "*.spec",
+  "*.toml",
+  "*.txt",
+  "*.yaml",
+  "*.yml",
+  "docker/**",
+  "temp/**",
+  "scripts/clang-format-wrapper",
+  "include/etl/generators/**",
+  "include/etl/private/*_cpp03.h",
+  "subprojects/**",
+  "test/UnitTest++/**",
+  "test/Deprecated/**",
+  "test/Performance/**",
+  "test/temp/**"
+]
+
+[formatter.cpp]
+command = "scripts/clang-format-wrapper"
+options = [ "-i", "--style=file" ]
+includes = [ "*.c", "*.cc", "*.cpp", "*.h", "*.hh", "*.hpp" ]

CMakeLists.txt

@@ -1,14 +1,14 @@
 #######################################################################
 # The Embedded Template Library (https://www.etlcpp.com/)
 #######################################################################
-cmake_minimum_required(VERSION 3.5.0)
+cmake_minimum_required(VERSION 3.10)
 
 include(${CMAKE_CURRENT_SOURCE_DIR}/cmake/helpers.cmake)
 
 set(MSG_PREFIX "etl |")
-determine_version_with_git(${GIT_DIR_LOOKUP_POLICY})
+etl_determine_version_with_git(${GIT_DIR_LOOKUP_POLICY})
 if(NOT ETL_VERSION)
-    determine_version_with_file("version.txt")
+    etl_determine_version_with_file("version.txt")
 endif()
 
 project(etl VERSION ${ETL_VERSION} LANGUAGES CXX)
@@ -52,11 +52,24 @@ if(${CMAKE_PROJECT_NAME} STREQUAL ${PROJECT_NAME})
     )
     if(ETL_VERSION)
         # Generate the package configuration files using CMake provided macros
-        write_basic_package_version_file(
-            "${PROJECT_NAME}ConfigVersion.cmake"
-            COMPATIBILITY SameMajorVersion
-            ARCH_INDEPENDENT
-        )
+        if(CMAKE_VERSION VERSION_GREATER_EQUAL 3.14)
+            # Generate the package configuration files using CMake provided macros
+            write_basic_package_version_file(
+                "${PROJECT_NAME}ConfigVersion.cmake"
+                COMPATIBILITY SameMajorVersion
+                ARCH_INDEPENDENT
+            )
+        else()
+            # This is needed for CMake < 3.14
+            # because the ARCH_INDEPENDENT option is not available
+            # in CMake < 3.14
+            # See https://cmake.org/cmake/help/latest/module/CMakePackageConfigHelpers.html
+            # for more information
+            write_basic_package_version_file(
+                "${PROJECT_NAME}ConfigVersion.cmake"
+                COMPATIBILITY SameMajorVersion
+            )
+        endif()
     endif()
     configure_package_config_file(
         "${PROJECT_SOURCE_DIR}/cmake/${PROJECT_NAME}Config.cmake.in"

CONTRIBUTING.md

@@ -0,0 +1,17 @@
+# How to contribute
+
+Thanks for considering a contribution! Here’s what you need to know before opening a pull request:
+
+- If you are adding or modifying a feature, add *new* unit tests that test that feature.
+- If you are fixing a bug, add a unit test that *fails* before the bug fix is implemented.
+- Do not initiate a pull request until all of the units tests pass. See below for information on project files and test scripts.
+- Branches should be based on the branch `master`. If `development` has pending updates, I’ll rebase the PR against it before pulling..
+- For formatting help, you can use clang-format, or the convenience wrapper treefmt. See also [docs/source-formatting.md](docs/source-formatting.md)
+
+There is a project file for VS2022 for C++14, 17, 20, 23, and bash scripts that run the tests for C++11, 14, 17, 20, 23 under Linux with GCC and Clang.
+There are syntax-only check bash scripts that cover C++03, 11, 14, 17, 20, 23 under Linux with GCC and Clang.
+
+If you are thinking of adding a new feature then raise this on the GitHub Issues page for discussion as the maintainers and user of the ETL may have questions or suggestions.
+It is possible that the maintainer of the ETL or another contributor is already working on the same or a related feature. 
+  
+Take a look through our current issues and see if anything sparks your interest!

Converting header guards.txt

@@ -0,0 +1,12 @@
+How to convert the ETL header beween #include guards and #pragma once.
+
+Install
+python3 -m pip install guardonce
+
+Navigate to etl/scripts
+
+Change from #include guard to #pragma once
+./convert_headers_to_use_once.bat
+
+Change from #pragma once to #include guard
+./convert_headers_to_use_guards.bat

LICENSE

@@ -1,7 +1,5 @@
 The MIT License (MIT)
 
-Copyright (c) 2016 jwellbelove, https://github.com/ETLCPP/etl, http://www.etlcpp.com
-
 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

README.md

@@ -1,65 +1,118 @@
-Embedded Template Library (ETL)
--------------------------
+# ![alt text](https://github.com/ETLCPP/etl/blob/master/images/etl64.png?raw=true) Embedded Template Library (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)
 ![GitHub release (latest by date)](https://img.shields.io/github/v/release/jwellbelove/etl)
-[![Standard](https://img.shields.io/badge/c%2B%2B-98/03/11/14/17-blue.svg)](https://en.wikipedia.org/wiki/C%2B%2B#Standardization)
+[![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)
 [![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)
+![GitHub Repo stars](https://img.shields.io/github/stars/ETLCPP/etl?style=flat)
+
+![CI](https://github.com/ETLCPP/etl/actions/workflows/msvc.yml/badge.svg?branch=master)
+
+![CI](https://github.com/ETLCPP/etl/actions/workflows/gcc-c++11.yml/badge.svg?branch=master)
+![CI](https://github.com/ETLCPP/etl/actions/workflows/gcc-c++14.yml/badge.svg?branch=master)
+![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-syntax-checks.yml/badge.svg?branch=master)
+
+![CI](https://github.com/ETLCPP/etl/actions/workflows/clang-c++11.yml/badge.svg?branch=master)
+![CI](https://github.com/ETLCPP/etl/actions/workflows/clang-c++14.yml/badge.svg?branch=master)
+![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-syntax-checks.yml/badge.svg?branch=master)
 
-![CI](https://github.com/ETLCPP/etl/workflows/msvc/badge.svg?branch=master)
-![CI](https://github.com/ETLCPP/etl/workflows/gcc/badge.svg?branch=master)
-![CI](https://github.com/ETLCPP/etl/workflows/clang/badge.svg?branch=master)
-[![Build status](https://ci.appveyor.com/api/projects/status/b7jgecv7unqjw4u0/branch/master?svg=true)](https://ci.appveyor.com/project/jwellbelove/etl/branch/master)
 [![Codacy Badge](https://api.codacy.com/project/badge/Grade/3c14cd918ccf40008d0bcd7b083d5946)](https://www.codacy.com/manual/jwellbelove/etl?utm_source=github.com&utm_medium=referral&utm_content=ETLCPP/etl&utm_campaign=Badge_Grade)
 
-![GitHub contributors](https://img.shields.io/github/contributors-anon/ETLCPP/etl)
-[![](https://img.shields.io/static/v1?label=Sponsor&message=%E2%9D%A4&logo=GitHub&color=%23fe8e86)](https://github.com/sponsors/ETLCPP)
+[![](https://img.shields.io/static/v1?label=Sponsor&message=%E2%9D%A4&logo=GitHub&color=%23fe8e86)](https://www.etlcpp.com/sponsor.html)
 
 [Project documentation](https://www.etlcpp.com/)
 
 ## Motivation
 
-C++ is a great language to use for embedded applications and templates are a powerful aspect. The standard library can offer a great deal of well tested functionality,  but there are some parts of the standard library that do not fit well with deterministic behaviour and limited resource requirements. These limitations usually preclude the use of dynamically allocated memory and containers with open ended sizes.
+C++ is a powerful language for embedded systems development, with templates offering a great deal of flexibility and type safety. While the C++ Standard Library provides a wealth of well-tested functionality, it’s often not well suited to environments with strict deterministic behavior and limited resources.
 
-What is needed is a template library where the user can declare the size, or maximum size of any object upfront. Most embedded compilers do not currently support the standard beyond C++ 03, therefore excluding the programmer from using the enhanced features of the later library.
+In many embedded applications, dynamic memory allocation is discouraged or outright prohibited, making standard STL containers and many other components impractical or unusable.
 
-This is what the ETL attempts to achieve.
+What’s needed is a template library specifically designed for embedded systems — one that allows developers to define fixed or maximum sizes for containers and other objects at compile time. Additionally, since many embedded toolchains still lack full support for standards beyond C++03, it's valuable to have access to a library that backports select features from later versions of the C++ Standard Library.
 
-## Summary
+## About the ETL
 
-The ETL is not designed to completely replace the STL, but complement it.
-Its design objective covers three areas.
+The Embedded Template Library (ETL) is not intended as a full replacement for the C++ Standard Template Library (STL), but rather as a complementary solution tailored specifically for embedded systems.
 
-- Create a set of containers where the size or maximum size is determined at compile time. These containers are direct equivalents of those supplied in the STL.
-- Be compatible with C++ 03 but implement as many of the C++ 11/14/17/20 additions as possible.
-- Add other useful components that are not present in the standard library.
+Its design goals include:
 
-The embedded template library has been designed for lower resource embedded applications.
-It contains a set of containers, algorithms and utilities, some of which emulate parts of the STL.
-There is no dynamic memory allocation. The library makes no use of the heap. All of the containers have a fixed capacity allowing all memory allocation to be determined at compile time.
-The library is intended for any compiler that supports C++98/03/11/14/17/20.
+-	Providing a set of containers with fixed or maximum sizes defined at compile-time.
 
-## Main features
+-	Offering APIs that closely resemble those of the STL, enabling familiar and consistent usage.
 
-- Cross platform. This library is not specific to any processor type.
-- No dynamic memory allocation
-- No RTTI required
-- Very little use of virtual functions. They are used only when they are absolutely necessary for the required functionality
-- A set of fixed capacity containers. (array, bitset, deque, forward_list, list, queue,  stack, vector, map, set, etc.)
-- As the storage for all of the container types is allocated as a contiguous block, they are extremely cache friendly
-- Templated compile time constants
-- Templated design pattern base classes (Visitor, Observer)
-- Reverse engineered C++ 0x11 features (type traits, algorithms, containers etc.)
-- Type-safe enumerations
-- Type-safe typedefs
-- 8, 16, 32 & 64 bit CRC calculations
-- Checksums & hash functions
-- Variants (a type that can store many types in a type-safe interface)
-- Choice of asserts, exceptions, error handler or no checks on errors
-- Unit tested (currently over 6480 tests), using VS2019, GCC 8.1.0, , GCC 9.3.0, Clang 9.0.0 & 10.0.0
-- Many utilities for template support.
-- Easy to read and documented source.
-- Free email support
+-	Maintaining compatibility with C++98 while implementing many features introduced in later standards
+(C++11/14/17/20/23) where possible.
+
+-	Ensuring deterministic behavior, which is critical in real-time and resource-constrained environments.
+
+-	Introducing additional components and utilities useful in embedded contexts but absent from the STL.
+
+The ETL avoids dynamic memory allocation entirely; the heap is never used. All non-intrusive containers have a fixed capacity, allowing memory requirements to be fully determined at compile-time. This makes the ETL ideal for lower-resource embedded applications where predictability, performance, and memory control are essential.
+
+The library is compatible with any compiler that supports C++03 or later.
+
+Help on integrating the ETL with your project may be found here.
+
+
+## Key features of the ETL
+
+-	Actively Maintained: Developed and maintained on GitHub since 2014.
+
+-	Open Source: MIT licensed.
+
+-	No STL Dependency: Designed to operate independently of the C++ Standard Template Library.
+
+-	No Dynamic Memory Allocation: All storage is allocated either at compile-time or on the stack; heap usage is entirely avoided.
+
+-	RTTI and Virtual Functions: No runtime type information (RTTI) is required. Virtual functions are used sparingly and only when strictly necessary.
+
+-	Header-Only Library: All functionality is provided via header files; No separate compilation needed.
+
+-	Fixed-Capacity Containers: Offers STL-like containers with fixed or maximum capacity, plus additional non-standard container types.
+
+-	Cache Efficiency: Containers use contiguous memory layouts for optimal cache performance.
+
+-	Compact Codebase: Shared base classes (based on type) help reduce overall container code size.
+
+-	Compile-Time Features:
+    -	Templated compile-time constants
+    -	Template-based design pattern base classes (e.g., Visitor, Observer)
+    -	Type-safe smart enumerations
+    -	Type-safe typedefs and constants
+
+-	Embedded System Frameworks:
+    -	Message routing
+    -	Finite state machines
+    -	Task scheduling
+
+-	C++11 Backports: Implements many C++11 features (type traits, algorithms, containers) for use in C++03 environments.
+
+-	Utilities:
+    -	CRC calculations (8, 16, 32 & 64-bit)
+    -	Checksums and hash functions
+    -	Variants (type-safe unions)
+    -	Extensive template support utilities
+
+-	Robust Error Handling: Configurable error checking using asserts, exceptions, error handlers, or no checks; user’s choice.
+
+-	Thoroughly Tested:
+    -	Over 10,000 unit tests
+    -	Tested with Visual Studio 2022, GCC 12, and Clang 14
+    -	Continuous integration via GitHub Actions.
+
+-	Readable and Well-Documented: Clean, maintainable source code with clear documentation.
+
+-	Support: Free email support available. A Slack group is available. Paid support on request.
+
+-	Archived: A snapshot of the ETL is preserved in the Arctic Code Vault for long-term digital preservation.
 
 Any help porting the library to work under different platforms and compilers would be gratefully received.
 I am especially interested in people who are using Keil, IAR, Green Hills, TI Code Composer etc, bare metal or RTOS, and DSPs.
@@ -129,6 +182,84 @@ add_executable(foo main.cpp)
 target_link_libraries(foo PRIVATE etl::etl)
 ```
 
+## Profile definition
+
+When using ETL in a project, there is typically an `etl_profile.h` defined to
+adjust ETL to the project needs. ETL will automatically find `etl_profile.h`
+if it is available in the include path(s). If it's not available, ETL will
+work with default values.
+
+### Example
+
+```
+#ifndef __ETL_PROFILE_H__
+#define __ETL_PROFILE_H__
+
+#define ETL_TARGET_DEVICE_GENERIC
+#define ETL_TARGET_OS_NONE
+
+#define ETL_NO_STL
+
+#endif
+```
+
+## Platform specific implementation
+
+Although ETL is generally a self-contained header-only library, some interfaces need to be
+implemented in every project or platform, at least if those interfaces are actually being
+used, due to project specifics:
+
+| ETL header | Platform specific API to be implemented | Needed when using                   |
+|------------|-----------------------------------------|-------------------------------------|
+| `chrono.h` | `etl_get_high_resolution_clock()`       | `etl::high_resolution_clock::now()` |
+|            | `etl_get_system_clock()`                | `etl::system_clock::now()`          |
+|            | `etl_get_steady_clock()`                | `etl::steady_clock::now()`          |
+| `print.h`  | `etl_putchar()`                         | `etl::print()`                      |
+|            |                                         | `etl::println()`                    |
+
+### Example
+
+```
+#include <etl/chrono.h>
+#include <etl/print.h>
+
+extern "C"
+{
+
+etl::chrono::high_resolution_clock::rep etl_get_high_resolution_clock()
+{
+  return etl::chrono::high_resolution_clock::rep(static_cast<int64_t>(getSystemTimeNs()));
+}
+
+etl::chrono::system_clock::rep etl_get_system_clock()
+{
+  return etl::chrono::system_clock::rep(static_cast<int64_t>(getSystemTimeNs()));
+}
+
+etl::chrono::system_clock::rep etl_get_steady_clock()
+{
+  return etl::chrono::system_clock::rep(static_cast<int64_t>(getSystemTimeNs()));
+}
+
+void etl_putchar(int c)
+{
+  putByteToStdout(static_cast<uint8_t>(c));
+}
+
+}
+```
+
+The following default values apply if the respective macros are not defined
+(e.g. in `etl_profile.h`):
+
+| Macro                                         | Default                    |
+|-----------------------------------------------|----------------------------|
+| `ETL_CHRONO_SYSTEM_CLOCK_DURATION`            | `etl::chrono::nanoseconds` |
+| `ETL_CHRONO_SYSTEM_CLOCK_IS_STEADY`           | `true`                     |
+| `ETL_CHRONO_HIGH_RESOLUTION_CLOCK_DURATION`   | `etl::chrono::nanoseconds` |
+| `ETL_CHRONO_HIGH_RESOLUTION_CLOCK_IS_STEADY`  | `true`                     |
+| `ETL_CHRONO_STEADY_CLOCK_DURATION`            | `etl::chrono::nanoseconds` |
+
 ## Arduino library
 
 The content of this repo is available as a library in the Arduino IDE (search for the "Embedded Template Library" in the IDE library manager). The Arduino library repository is available at ```https://github.com/ETLCPP/etl-arduino```, see there for more details.

appveyor.yml

@@ -16,11 +16,5 @@ install:
 build:
   project: test/vs2022/etl.vcxproj
   verbosity: minimal
-notifications:
-- provider: Webhook
-  url: https://hooks.slack.com/services/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
-  method: POST
-  on_build_success: true
-  on_build_failure: true
-  on_build_status_changed: true
+
   

arduino/Embedded_Template_Library.h

@@ -2,79 +2,79 @@
 #ifndef ETL_EMBEDDED_TEMPLATE_LIBRARY_INCLUDED
 #define ETL_EMBEDDED_TEMPLATE_LIBRARY_INCLUDED
 
-#if defined(TEENSYDUINO) 
+#if defined(TEENSYDUINO)
 
-    #if defined(__AVR_ATmega32U4__)
-        #define ARDUINO_BOARD "Teensy 2.0"
-    #elif defined(__AVR_AT90USB1286__)       
-        #define ARDUINO_BOARD "Teensy++ 2.0"
-    #elif defined(__MK20DX128__)       
-        #define ARDUINO_BOARD "Teensy 3.0"
-    #elif defined(__MK20DX256__)       
-        #define ARDUINO_BOARD "Teensy 3.2" // and Teensy 3.1
-    #elif defined(__MKL26Z64__)       
-        #define ARDUINO_BOARD "Teensy LC"
-    #elif defined(__MK64FX512__)
-        #define ARDUINO_BOARD "Teensy 3.5"
-    #elif defined(__MK66FX1M0__)
-        #define ARDUINO_BOARD "Teensy 3.6"
-    #else
-       #define ARDUINO_BOARD "Unknown"
-    #endif
+  #if defined(__AVR_ATmega32U4__)
+    #define ARDUINO_BOARD "Teensy 2.0"
+  #elif defined(__AVR_AT90USB1286__)
+    #define ARDUINO_BOARD "Teensy++ 2.0"
+  #elif defined(__MK20DX128__)
+    #define ARDUINO_BOARD "Teensy 3.0"
+  #elif defined(__MK20DX256__)
+    #define ARDUINO_BOARD "Teensy 3.2" // and Teensy 3.1
+  #elif defined(__MKL26Z64__)
+    #define ARDUINO_BOARD "Teensy LC"
+  #elif defined(__MK64FX512__)
+    #define ARDUINO_BOARD "Teensy 3.5"
+  #elif defined(__MK66FX1M0__)
+    #define ARDUINO_BOARD "Teensy 3.6"
+  #else
+    #define ARDUINO_BOARD "Unknown"
+  #endif
 
 #else // --------------- Arduino ------------------
 
-    #if defined(ARDUINO_AVR_ADK)       
-        #define ARDUINO_BOARD "Mega Adk"
-    #elif defined(ARDUINO_AVR_BT)
-        #define ARDUINO_BOARD "Bt"
-    #elif defined(ARDUINO_AVR_DUEMILANOVE)       
-        #define ARDUINO_BOARD "Duemilanove"
-    #elif defined(ARDUINO_AVR_ESPLORA)       
-        #define ARDUINO_BOARD "Esplora"
-    #elif defined(ARDUINO_AVR_ETHERNET)       
-        #define ARDUINO_BOARD "Ethernet"
-    #elif defined(ARDUINO_AVR_FIO)       
-        #define ARDUINO_BOARD "Fio"
-    #elif defined(ARDUINO_AVR_GEMMA)
-        #define ARDUINO_BOARD "Gemma"
-    #elif defined(ARDUINO_AVR_LEONARDO)       
-        #define ARDUINO_BOARD "Leonardo"
-    #elif defined(ARDUINO_AVR_LILYPAD)
-        #define ARDUINO_BOARD "Lilypad"
-    #elif defined(ARDUINO_AVR_LILYPAD_USB)
-        #define ARDUINO_BOARD "Lilypad Usb"
-    #elif defined(ARDUINO_AVR_MEGA)       
-        #define ARDUINO_BOARD "Mega"
-    #elif defined(ARDUINO_AVR_MEGA2560)       
-        #define ARDUINO_BOARD "Mega 2560"
-    #elif defined(ARDUINO_AVR_MICRO)       
-        #define ARDUINO_BOARD "Micro"
-    #elif defined(ARDUINO_AVR_MINI)       
-        #define ARDUINO_BOARD "Mini"
-    #elif defined(ARDUINO_AVR_NANO)       
-        #define ARDUINO_BOARD "Nano"
-    #elif defined(ARDUINO_AVR_NG)       
-        #define ARDUINO_BOARD "NG"
-    #elif defined(ARDUINO_AVR_PRO)       
-        #define ARDUINO_BOARD "Pro"
-    #elif defined(ARDUINO_AVR_ROBOT_CONTROL)       
-        #define ARDUINO_BOARD "Robot Ctrl"
-    #elif defined(ARDUINO_AVR_ROBOT_MOTOR)       
-        #define ARDUINO_BOARD "Robot Motor"
-    #elif defined(ARDUINO_AVR_UNO)       
-        #define ARDUINO_BOARD "Uno"
-    #elif defined(ARDUINO_AVR_YUN)       
-        #define ARDUINO_BOARD "Yun"
-    #elif defined(ARDUINO_SAM_DUE)       
-        #define ARDUINO_BOARD "Due"
-    #elif defined(ARDUINO_SAMD_ZERO)
-        #define ARDUINO_BOARD "Zero"
-    #elif defined(ARDUINO_ARC32_TOOLS)       
-        #define ARDUINO_BOARD "101"
-    #else
-       #define ARDUINO_BOARD "Unknown"
-    #endif
+  #if defined(ARDUINO_AVR_ADK)
+    #define ARDUINO_BOARD "Mega Adk"
+  #elif defined(ARDUINO_AVR_BT)
+    #define ARDUINO_BOARD "Bt"
+  #elif defined(ARDUINO_AVR_DUEMILANOVE)
+    #define ARDUINO_BOARD "Duemilanove"
+  #elif defined(ARDUINO_AVR_ESPLORA)
+    #define ARDUINO_BOARD "Esplora"
+  #elif defined(ARDUINO_AVR_ETHERNET)
+    #define ARDUINO_BOARD "Ethernet"
+  #elif defined(ARDUINO_AVR_FIO)
+    #define ARDUINO_BOARD "Fio"
+  #elif defined(ARDUINO_AVR_GEMMA)
+    #define ARDUINO_BOARD "Gemma"
+  #elif defined(ARDUINO_AVR_LEONARDO)
+    #define ARDUINO_BOARD "Leonardo"
+  #elif defined(ARDUINO_AVR_LILYPAD)
+    #define ARDUINO_BOARD "Lilypad"
+  #elif defined(ARDUINO_AVR_LILYPAD_USB)
+    #define ARDUINO_BOARD "Lilypad Usb"
+  #elif defined(ARDUINO_AVR_MEGA)
+    #define ARDUINO_BOARD "Mega"
+  #elif defined(ARDUINO_AVR_MEGA2560)
+    #define ARDUINO_BOARD "Mega 2560"
+  #elif defined(ARDUINO_AVR_MICRO)
+    #define ARDUINO_BOARD "Micro"
+  #elif defined(ARDUINO_AVR_MINI)
+    #define ARDUINO_BOARD "Mini"
+  #elif defined(ARDUINO_AVR_NANO)
+    #define ARDUINO_BOARD "Nano"
+  #elif defined(ARDUINO_AVR_NG)
+    #define ARDUINO_BOARD "NG"
+  #elif defined(ARDUINO_AVR_PRO)
+    #define ARDUINO_BOARD "Pro"
+  #elif defined(ARDUINO_AVR_ROBOT_CONTROL)
+    #define ARDUINO_BOARD "Robot Ctrl"
+  #elif defined(ARDUINO_AVR_ROBOT_MOTOR)
+    #define ARDUINO_BOARD "Robot Motor"
+  #elif defined(ARDUINO_AVR_UNO)
+    #define ARDUINO_BOARD "Uno"
+  #elif defined(ARDUINO_AVR_YUN)
+    #define ARDUINO_BOARD "Yun"
+  #elif defined(ARDUINO_SAM_DUE)
+    #define ARDUINO_BOARD "Due"
+  #elif defined(ARDUINO_SAMD_ZERO)
+    #define ARDUINO_BOARD "Zero"
+  #elif defined(ARDUINO_ARC32_TOOLS)
+    #define ARDUINO_BOARD "101"
+  #else
+    #define ARDUINO_BOARD "Unknown"
+  #endif
 #endif
 
 #endif

arduino/library-arduino.json

@@ -1,6 +1,6 @@
 {
-  "name": "Embedded Template Library - Arduino",
-  "version": "20.38.4",
+  "name": "Embedded Template Library ETL",
+  "version": "20.47.1",
   "authors": {
     "name": "John Wellbelove",
     "email": "john.wellbelove@etlcpp.com"
@@ -11,7 +11,7 @@
   "keywords": "c-plus-plus, cpp, algorithms, containers, templates",
   "repository": {
     "type": "git",
-    "url": "https://github.com/ETLCPP/etl.git"
+    "url": "https://github.com/ETLCPP/etl-arduino.git"
   },
   "build": {
     "includeDir": "include"

arduino/library-arduino.properties

@@ -1,5 +1,5 @@
-name=Embedded Template Library - Arduino
-version=20.38.4
+name=Embedded Template Library ETL
+version=20.47.1
 author= John Wellbelove <john.wellbelove@etlcpp.com>
 maintainer=John Wellbelove <john.wellbelove@etlcpp.com>
 license=MIT

cmake/GetGitRevisionDescription.cmake

@@ -12,23 +12,6 @@
 # Returns the results of git describe on the source tree, and adjusting
 # the output so that it tests false if an error occurs.
 #
-#  git_describe_working_tree(<var> [<additional arguments to git describe> ...])
-#
-# Returns the results of git describe on the working tree (--dirty option),
-# and adjusting the output so that it tests false if an error occurs.
-#
-#  git_get_exact_tag(<var> [<additional arguments to git describe> ...])
-#
-# Returns the results of git describe --exact-match on the source tree,
-# and adjusting the output so that it tests false if there was no exact
-# matching tag.
-#
-#  git_local_changes(<var>)
-#
-# Returns either "CLEAN" or "DIRTY" with respect to uncommitted changes.
-# Uses the return code of "git diff-index --quiet HEAD --".
-# Does not regard untracked files.
-#
 # Requires CMake 2.6 or newer (uses the 'function' command)
 #
 # Original Author:
@@ -43,10 +26,10 @@
 # (See accompanying file LICENSE_1_0.txt or copy at
 # http://www.boost.org/LICENSE_1_0.txt)
 
-if(__get_git_revision_description)
+if(__etl_get_git_revision_description)
     return()
 endif()
-set(__get_git_revision_description YES)
+set(__etl_get_git_revision_description YES)
 
 # We must run the following at "include" time, not at function call time,
 # to find the path to this module rather than the path to a calling list file
@@ -59,10 +42,10 @@ get_filename_component(_gitdescmoddir ${CMAKE_CURRENT_LIST_FILE} PATH)
 # function returns an empty string via _git_dir_var.
 #
 # Example: Given a path C:/bla/foo/bar and assuming C:/bla/.git exists and
-# neither foo nor bar contain a file/directory .git. This wil return
+# neither foo nor bar contain a file/directory .git. This will return
 # C:/bla/.git
 #
-function(_git_find_closest_git_dir _start_dir _git_dir_var)
+function(_etl_git_find_closest_git_dir _start_dir _git_dir_var)
     set(cur_dir "${_start_dir}")
     set(git_dir "${_start_dir}/.git")
     while(NOT EXISTS "${git_dir}")
@@ -83,8 +66,8 @@ function(_git_find_closest_git_dir _start_dir _git_dir_var)
         PARENT_SCOPE)
 endfunction()
 
-function(get_git_head_revision _refspecvar _hashvar)
-    _git_find_closest_git_dir("${CMAKE_CURRENT_SOURCE_DIR}" GIT_DIR)
+function(etl_get_git_head_revision _refspecvar _hashvar)
+    _etl_git_find_closest_git_dir("${CMAKE_CURRENT_SOURCE_DIR}" GIT_DIR)
 
     if("${ARGN}" STREQUAL "ALLOW_LOOKING_ABOVE_CMAKE_SOURCE_DIR")
         set(ALLOW_LOOKING_ABOVE_CMAKE_SOURCE_DIR TRUE)
@@ -143,7 +126,7 @@ function(get_git_head_revision _refspecvar _hashvar)
             string(REGEX REPLACE "gitdir: (.*)$" "\\1" git_worktree_dir
                                  ${worktree_ref})
             string(STRIP ${git_worktree_dir} git_worktree_dir)
-            _git_find_closest_git_dir("${git_worktree_dir}" GIT_DIR)
+            _etl_git_find_closest_git_dir("${git_worktree_dir}" GIT_DIR)
             set(HEAD_SOURCE_FILE "${git_worktree_dir}/HEAD")
         endif()
     else()
@@ -172,11 +155,11 @@ function(get_git_head_revision _refspecvar _hashvar)
         PARENT_SCOPE)
 endfunction()
 
-function(git_describe _var)
+function(etl_git_describe _var)
     if(NOT GIT_FOUND)
         find_package(Git QUIET)
     endif()
-    get_git_head_revision(refspec hash ${ARGN})
+    etl_get_git_head_revision(refspec hash ${ARGN})
     if(NOT GIT_FOUND)
         set(${_var}
             "GIT-NOTFOUND"
@@ -214,71 +197,3 @@ function(git_describe _var)
         "${out}"
         PARENT_SCOPE)
 endfunction()
-
-function(git_describe_working_tree _var)
-    if(NOT GIT_FOUND)
-        find_package(Git QUIET)
-    endif()
-    if(NOT GIT_FOUND)
-        set(${_var}
-            "GIT-NOTFOUND"
-            PARENT_SCOPE)
-        return()
-    endif()
-
-    execute_process(
-        COMMAND "${GIT_EXECUTABLE}" describe --dirty ${ARGN}
-        WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}"
-        RESULT_VARIABLE res
-        OUTPUT_VARIABLE out
-        ERROR_QUIET OUTPUT_STRIP_TRAILING_WHITESPACE)
-    if(NOT res EQUAL 0)
-        set(out "${out}-${res}-NOTFOUND")
-    endif()
-
-    set(${_var}
-        "${out}"
-        PARENT_SCOPE)
-endfunction()
-
-function(git_get_exact_tag _var)
-    git_describe(out --exact-match ${ARGN})
-    set(${_var}
-        "${out}"
-        PARENT_SCOPE)
-endfunction()
-
-function(git_local_changes _var)
-    if(NOT GIT_FOUND)
-        find_package(Git QUIET)
-    endif()
-    get_git_head_revision(refspec hash)
-    if(NOT GIT_FOUND)
-        set(${_var}
-            "GIT-NOTFOUND"
-            PARENT_SCOPE)
-        return()
-    endif()
-    if(NOT hash)
-        set(${_var}
-            "HEAD-HASH-NOTFOUND"
-            PARENT_SCOPE)
-        return()
-    endif()
-
-    execute_process(
-        COMMAND "${GIT_EXECUTABLE}" diff-index --quiet HEAD --
-        WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}"
-        RESULT_VARIABLE res
-        OUTPUT_VARIABLE out
-        ERROR_QUIET OUTPUT_STRIP_TRAILING_WHITESPACE)
-    if(res EQUAL 0)
-        set(${_var}
-            "CLEAN"
-            PARENT_SCOPE)
-    else()
-        set(${_var}
-            "DIRTY"
-            PARENT_SCOPE)
-    endif()
-endfunction()

cmake/helpers.cmake

@@ -1,4 +1,4 @@
-function(determine_version_with_file VER_FILE_NAME)
+function(etl_determine_version_with_file VER_FILE_NAME)
     file(READ ${VER_FILE_NAME} ETL_VERSION_RAW)
     # Remove trailing whitespaces and/or newline
     string(STRIP ${ETL_VERSION_RAW} ETL_VERSION)
@@ -8,12 +8,12 @@ function(determine_version_with_file VER_FILE_NAME)
     message(STATUS "${MSG_PREFIX} Determined ETL version ${ETL_VERSION} from version.txt file")
 endfunction()
 
-function(determine_version_with_git)
+function(etl_determine_version_with_git)
     include(${CMAKE_CURRENT_SOURCE_DIR}/cmake/GetGitRevisionDescription.cmake)
-    git_describe(VERSION ${ARGN})
+    etl_git_describe(VERSION ${ARGN})
     string(FIND ${VERSION} "." VALID_VERSION)
     if(VALID_VERSION EQUAL -1)
-        if(PROJECT_IS_TOP_LEVEL)
+        if(CMAKE_CURRENT_LIST_DIR STREQUAL PROJECT_SOURCE_DIR)
             # only warn if this is the top-level project, since we may be
             # building from a tarball as a subproject
             message(WARNING "Version string ${VERSION} retrieved with git describe is invalid")

docs/_config.yml

@@ -0,0 +1,6 @@
+plugins:
+  - jekyll-relative-links
+relative_links:
+  enabled: true
+include:
+  - manchester.md

docs/index.md

@@ -0,0 +1,7 @@
+---
+title: ETL documentation
+---
+
+## Pages
+
+* [Manchester](manchester.md)

docs/manchester.md

@@ -0,0 +1,259 @@
+---
+title: Manchester encoding and decoding
+---
+
+Efficient Manchester encoding and decoding of data. The Manchester code represents a data bit as a sequence of a 'high' and a 'low' value. In software this translates to a conversion from one to two bits, or in a practical situation, from `n` bytes to `n*2` bytes.
+
+## See also
+
+[Manchester code](https://en.wikipedia.org/wiki/Manchester_code)
+
+## Features
+
+- Normal and inverted Manchester encoding
+- Support for multiple encoding chunk sizes: 8-bit, 16-bit and 32-bit
+- Span-based operations or chunk-based operations
+- Constexpr functions for compile-time encoding/decoding
+- Validation of encoded data
+- Chunked span I/O uses little-endian byte order for multi-byte chunks, independent of host platform endianness
+
+## Algorithm background
+
+To encode the value `0b11001100` we must first duplicate all bits to create the value `0b1111000011110000`. We then perform an XOR of this value with the constant `0b1010101010101010` (`0xAAAA`) to obtain the Manchester coded value of `0b1010010110100101`. We have now replaced each `1` bit with the sequence `10` and each `0` bit with the sequence `01`.
+
+### 2. Bit duplication
+
+Bit duplication is achieved with the following steps. This is also called binary interleaving. The example shows encoding of an 8-bit value.
+
+| Step | High Byte          | Low Byte           | Operation                  |
+|------|--------------------|--------------------|----------------------------|
+| 0    | `_ _ _ _ _ _ _ _`  | `A B C D E F G H`  | input value (i)            |
+| 1    | `_ _ _ _ A B C D`  | `_ _ _ _ E F G H`  | `(i \| (i << 4)) & 0x0F0F` |
+| 2    | `_ _ A B _ _ C D`  | `_ _ E F _ _ G H`  | `(i \| (i << 2)) & 0x3333` |
+| 3    | `_ A _ B _ C _ D`  | `_ E _ F _ G _ H`  | `(i \| (i << 1)) & 0x5555` |
+| 4    | `A A B B C C D D`  | `E E F F G G H H`  | `(i \| (i << 1))`          |
+
+This process can be easily extended to 16-bit or 32-bit values by adding additional steps to the bit duplication.
+
+### 3. Manchester Decoding
+
+Manchester decoding is done in a similar, but reversed way.
+
+### 4. Error Detection
+
+Error detection in Manchester coded data is done by comparing 2 neighboring bits. If they are
+equal, then there is an error in the encoded input data.
+
+Comparing all 8 bit pairs in a 16-bit word is done as follows.
+
+| Step | Binary Value | Operation         | Description                                                                                   |
+|------|--------------|-------------------|-----------------------------------------------------------------------------------------------|
+| 1    | `11011000`   | Original          | First bit pair (lsb, 00) is invalid. Last bit pair is also invalid. Other bit pairs are valid |
+| 2    | `01101100`   | Shift right by 1  | Shift the original value right by one bit                                                     |
+| 3    | `10110100`   | XOR               | XOR the original with the shifted value                                                       |
+| 4    | `01010101`   | Mask with 0x55    | Apply mask to isolate bit pairs                                                               |
+| 5    | `00010100`   | Result            | If result is not equal to 0x55, there was an error in the input                               |
+
+## Analysis
+
+Most traditional ways to Manchester encode data consist of a loop over all bits and a nested if-statement to check the value of the current bit. This approach does not scale well to increasing number of bits. The algorithm implemented here contains no conditional code and scales well. Doubling the number of processed bits per step (the chunk size) adds a single row to the bit duplication table. Because of the lack of loops and conditional code, this algorithm is likely to perform better than traditional ones on simple processors or when compiler optimization is disabled. On modern, powerful processors with caches and advanced optimization possibilities this algorithm may not show much benefit. In any case, the performance of the algorithm depends heavily on the processor type, compiler and compiler (optimization) settings.
+
+## API Reference
+
+### Classes
+
+Classes `etl::manchester` and `etl::manchester_inverted` contain static functions for encoding, decoding and validity checking. It is not necessary to instantiate objects of these classes.
+
+#### etl::manchester
+
+```cpp
+typedef manchester_base<private_manchester::manchester_type_normal> manchester;
+```
+
+Manchester encoder using normal encoding (no inversion).
+
+#### etl::manchester_inverted
+
+```cpp
+typedef manchester_base<private_manchester::manchester_type_inverted> manchester_inverted;
+```
+
+Manchester encoder using inverted encoding.
+
+### Encoding Functions
+
+#### Encode single value
+
+```cpp
+template <typename TDecoded>
+static ETL_CONSTEXPR14 typename encoded<TDecoded>::type encode(TDecoded decoded)
+```
+
+Encodes a single value using Manchester encoding.
+
+**Parameters:**
+
+- `decoded`: The value to encode (`uint8_t`, `uint16_t`, or `uint32_t`)
+
+**Returns:**
+
+- The Manchester encoded value (twice the bit width of input)
+
+**Example:**
+
+```cpp
+uint16_t encoded = etl::manchester::encode(0x55);
+```
+
+#### Encode range
+
+```cpp
+template <typename TChunk = uint_least8_t>
+static ETL_CONSTEXPR14 void encode(etl::span<const uint_least8_t> decoded, 
+                                   etl::span<uint_least8_t> encoded)
+```
+
+Encodes a span of data using the specified chunk size.
+
+**Parameters:**
+
+- `decoded`: Source data to encode
+- `encoded`: Destination for encoded data (must be twice the size of `decoded`)
+
+**Template Parameters:**
+
+- `TChunk`: Chunk size for encoding (`uint8_t`, `uint16_t` or `uint32_t`)
+
+**Example:**
+
+```cpp
+std::array<uint8_t, 4> data = {0x12, 0x34, 0x56, 0x78};
+std::array<uint8_t, 8> encoded_data1{};
+std::array<uint8_t, 8> encoded_data2{};
+
+// Encode with TChunk == uint8_t
+etl::manchester::encode(data, encoded_data1);
+
+// Encode with TChunk == uint32_t
+etl::manchester::encode<uint32_t>(data, encoded_data2);
+```
+
+### Decoding Functions
+
+#### Decode single value
+
+```cpp
+template <typename TEncoded>
+static ETL_CONSTEXPR14 typename decoded<TEncoded>::type decode(TEncoded encoded)
+```
+
+Decodes a single Manchester encoded value.
+
+**Parameters:**
+
+- `encoded`: The encoded value to decode (`uint16_t`, `uint32_t`, or `uint64_t`)
+
+**Returns:**
+
+- The Manchester decoded value (half the bit width of input)
+
+**Example:**
+
+```cpp
+uint8_t decoded = etl::manchester::decode(0x5A5A);
+```
+
+#### Decode range
+
+```cpp
+template <typename TChunk = typename private_manchester::encoded<uint_least8_t>::type>
+static ETL_CONSTEXPR14 void decode(etl::span<const uint_least8_t> encoded, 
+                                   etl::span<uint_least8_t> decoded)
+```
+
+Decodes a span of Manchester encoded data.
+
+**Parameters:**
+
+- `encoded`: Source data to decode
+- `decoded`: Destination for decoded data (must be half the size of `encoded`)
+
+**Template Parameters:**
+
+- `TChunk`: Chunk type for decoding (`uint16_t`, `uint32_t`, or `uint64_t`)
+
+**Example:**
+
+```cpp
+std::array<uint8_t, 8> encoded = {/* ... */};
+std::array<uint8_t, 4> decoded1 {};
+std::array<uint8_t, 4> decoded2 {};
+
+// Decode with TChunk == uint16_t
+etl::manchester::decode(encoded, decoded1);
+
+// Decode with TChunk == uint64_t
+etl::manchester::decode<uint64_t>(encoded, decoded2);
+```
+
+### Validation Functions
+
+#### Single value
+
+```cpp
+template <typename TChunk>
+static ETL_CONSTEXPR14 bool is_valid(TChunk encoded)
+```
+
+Validates that a single value contains valid Manchester encoded data.
+
+**Parameters:**
+
+- `encoded`: The encoded value to validate
+
+**Returns:**
+
+- `true` if the value contains valid Manchester encoded data, `false` otherwise
+
+**Example:**
+
+```cpp
+bool valid = etl::manchester::is_valid(0x5A5A);
+```
+
+#### Range
+
+```cpp
+static ETL_CONSTEXPR14 bool is_valid(etl::span<const uint_least8_t> encoded)
+```
+
+Validates that a range contains valid Manchester encoded data.
+
+**Parameters:**
+
+- `encoded`: The range of encoded data to validate
+
+**Returns:**
+
+- `true` if all data is valid Manchester encoding, `false` otherwise
+
+**Example:**
+
+```cpp
+std::array<uint8_t, 8> encoded_data = {/* ... */};
+bool valid = etl::manchester::is_valid(encoded_data);
+```
+
+## Supported Types
+
+### Input/chunk types for encoding
+
+- `uint8_t` → `uint16_t` (if 8-bit types are supported)
+- `uint16_t` → `uint32_t`
+- `uint32_t` → `uint64_t` (if 64-bit types are supported)
+
+### Input/chunk types for decoding
+
+- `uint16_t` → `uint8_t` (if 8-bit types are supported)
+- `uint32_t` → `uint16_t`
+- `uint64_t` → `uint32_t` (if 64-bit types are supported)

docs/ranges.md

@@ -0,0 +1,328 @@
+# ETL C++17 Ranges Implementation
+
+## Overview
+
+The Embedded Template Library provides a C++17-compatible implementation of ranges, inspired by the C++20 ranges library. This implementation enables range-based algorithms and views for embedded and resource-constrained environments where full C++20 support may not be available.
+
+## Features
+
+- **Ranges**: Provides range types and iterator wrappers for composing operations over sequences.
+- **Views**: Includes lightweight, composable views such as `filter_view`, `transform_view`, and `subrange`.
+- **Algorithms**: Supports range-based algorithms compatible with ETL containers and standard containers.
+- **Compatibility**: Designed for C++17, with minimal dependencies and no reliance on C++20 features.
+
+## Getting Started
+
+Include the main header in your project:
+
+```cpp
+#include <etl/ranges.h>
+```
+
+### Example Usage
+
+#### Using Ranges
+
+```cpp
+#include <etl/print.h>
+#include <etl/ranges.h>
+#include <etl/vector.h>
+
+...
+
+  etl::vector<int, 10> data = {6, 1, 3, 3, 2};
+  etl::ranges::sort(data);
+  etl::ranges::for_each(data, [](const int& i){etl::print(" {}", i);});
+```
+
+Output:
+```text
+ 1 2 3 3 6
+```
+
+#### Using Views
+
+```cpp
+#include <etl/print.h>
+#include <etl/ranges.h>
+#include <etl/vector.h>
+
+...
+
+  etl::vector<int, 10> data = {1, 2, 3, 4, 5};
+  auto even = [](int v) { return v % 2 == 0; };
+  auto filtered = etl::ranges::filter_view(data, even);
+  etl::ranges::for_each(filtered, [](const int& i){etl::print(" {}", i);});
+```
+
+Output:
+```text
+ 2 4
+```
+
+#### Transforming Elements
+
+```cpp
+#include <etl/print.h>
+#include <etl/ranges.h>
+#include <etl/vector.h>
+
+...
+
+  etl::vector<int, 10> data = {1, 2, 3, 4, 5};
+  auto squared = etl::ranges::transform_view(data, [](int v) { return v * v; });
+  etl::ranges::for_each(squared, [](const int& i){etl::print(" {}", i);});
+```
+
+Output:
+```text
+ 1 4 9 16 25
+```
+
+#### Composition
+
+Views can be composed using the pipe (`|`) operator, allowing you to chain multiple transformations in a readable, left-to-right style:
+
+```cpp
+#include <etl/print.h>
+#include <etl/ranges.h>
+#include <etl/vector.h>
+
+namespace views = etl::ranges::views;
+
+...
+
+  etl::vector<int, 10> data = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
+
+  auto result = data
+    | views::filter([](const int& v) { return v % 2 == 0; })
+    | views::transform([](const int& v) { return v * v; });
+
+  etl::ranges::for_each(result, [](const int& i){ etl::print(" {}", i); });
+```
+
+Output:
+```text
+ 4 16 36 64 100
+```
+
+This first filters the even numbers and then squares them. Each `|` passes the result of the previous stage as input to the next view adaptor.
+
+## Supported Views
+
+All views are in the `etl::ranges` namespace. Corresponding range adaptor objects are available in `etl::ranges::views`.
+
+### Range Factories
+
+| View | `views::` adaptor | Description |
+|---|---|---|
+| `empty_view<T>` | `views::empty<T>` | A view with no elements. |
+| `single_view` | `views::single` | A view containing exactly one element. |
+| `iota_view` | `views::iota` | A view of sequentially increasing values. |
+| `repeat_view` | `views::repeat` | A view that repeats a value a given number of times. |
+
+### Range Adaptors
+
+| View | `views::` adaptor | Description |
+|---|---|---|
+| `ref_view` | `views::ref` | A non-owning view that wraps a reference to a range. |
+| `owning_view` | `views::owning` | A view that takes ownership of a range via move. |
+| — | `views::all` | Returns the range itself (if already a view), a `ref_view`, or an `owning_view`. |
+| `filter_view` | `views::filter` | Filters elements based on a predicate. |
+| `transform_view` | `views::transform` | Applies a transformation to each element. |
+| `as_rvalue_view` | `views::as_rvalue` | Casts each element to an rvalue reference. |
+| `as_const_view` | `views::as_const` | Provides a const view of the elements. |
+| `cache_latest_view` | `views::cache_latest` | Caches the most recently accessed element (avoids recomputation). |
+| `reverse_view` | `views::reverse` | Reverses the order of elements. |
+| `drop_view` | `views::drop` | Skips the first *n* elements. |
+| `drop_while_view` | `views::drop_while` | Skips leading elements while a predicate is true. |
+| `take_view` | `views::take` | Takes the first *n* elements. |
+| `take_while_view` | `views::take_while` | Takes leading elements while a predicate is true. |
+| `join_view` | `views::join` | Flattens a range of ranges into a single range. |
+| `join_with_view` | `views::join_with` | Flattens a range of ranges, inserting a delimiter between each. |
+| `split_view` | `views::split` | Splits a range into subranges around a delimiter pattern. |
+| `lazy_split_view` | `views::lazy_split` | Lazily splits a range by a pattern (inner ranges discovered on iteration). |
+| — | `views::counted` | Creates a view of *n* elements starting from an iterator. |
+| `concat_view` | `views::concat` | Concatenates multiple ranges into a single view. |
+| `zip_view` | `views::zip` | Zips multiple ranges into a view of tuples (length of shortest range). |
+| `zip_transform_view` | `views::zip_transform` | Zips multiple ranges and applies a function to each tuple of elements. |
+| `common_view` | `views::common` | Adapts a view so that its iterator and sentinel types are the same. |
+| `enumerate_view` | `views::enumerate` | Pairs each element with its index, producing tuples of (index, value). |
+| `elements_view` | `views::elements` | Extracts the *N*-th element from each tuple-like value. |
+| `keys_view` | `views::keys` | Alias for `elements_view` with *N*=0 (extracts first element of pairs/tuples). |
+| `values_view` | `views::values` | Alias for `elements_view` with *N*=1 (extracts second element of pairs/tuples). |
+| `adjacent_view` | `views::adjacent` | Produces a view of tuples of *N* adjacent elements (sliding window of tuples). |
+| — | `views::pairwise` | Alias for `views::adjacent<2>`. |
+| `adjacent_transform_view` | `views::adjacent_transform` | Applies a function to each group of *N* adjacent elements. |
+| — | `views::pairwise_transform` | Alias for `views::adjacent_transform<2>`. |
+| `chunk_view` | `views::chunk` | Splits a range into non-overlapping chunks of a given size. |
+| `slide_view` | `views::slide` | Produces overlapping subranges (sliding windows) of a given size. |
+| `chunk_by_view` | `views::chunk_by` | Splits a range into subranges between adjacent elements where a predicate is false. |
+| `stride_view` | `views::stride` | Yields every *N*-th element from the underlying range. |
+| `cartesian_product_view` | `views::cartesian_product` | Produces the Cartesian product of multiple ranges as a view of tuples. |
+| `to_input_view` | `views::to_input` | Downgrades iterator category to input iterator while preserving elements and order. |
+| `subrange` | — | Represents a sub-range defined by an iterator–sentinel pair. |
+
+All views support range-based for-loop iteration and can be composed with the pipe (`|`) operator.
+
+## Supported Algorithms
+
+All algorithms are callable objects in the `etl::ranges` namespace. Each supports both an iterator-pair overload and a range overload (where applicable), and most accept optional projection and comparator arguments.
+
+### Non-modifying Sequence Operations
+
+| Algorithm | Description |
+|---|---|
+| `for_each` | Applies a function to each element in a range. |
+| `for_each_n` | Applies a function to the first *n* elements. |
+| `find` | Finds the first element equal to a value. |
+| `find_if` | Finds the first element satisfying a predicate. |
+| `find_if_not` | Finds the first element not satisfying a predicate. |
+| `find_end` | Finds the last occurrence of a subsequence. |
+| `find_first_of` | Finds the first element matching any in a second range. |
+| `adjacent_find` | Finds the first pair of adjacent equal elements. |
+| `count` | Counts elements equal to a value. |
+| `count_if` | Counts elements satisfying a predicate. |
+| `all_of` | Checks if all elements satisfy a predicate. |
+| `any_of` | Checks if any element satisfies a predicate. |
+| `none_of` | Checks if no elements satisfy a predicate. |
+| `mismatch` | Finds the first position where two ranges differ. |
+| `equal` | Checks if two ranges are equal. |
+| `is_permutation` | Checks if one range is a permutation of another. |
+| `search` | Searches for the first occurrence of a subsequence. |
+| `search_n` | Searches for *n* consecutive copies of a value. |
+| `starts_with` | Checks if a range starts with another range. |
+| `ends_with` | Checks if a range ends with another range. |
+| `lexicographical_compare` | Compares two ranges lexicographically. |
+
+### Fold Operations
+
+| Algorithm | Description |
+|---|---|
+| `fold_left` | Left-folds elements with a binary operation. |
+| `fold_left_with_iter` | Left-folds, returning both the result and an iterator. |
+| `fold_left_first` | Left-folds using the first element as the initial value. |
+| `fold_left_first_with_iter` | Like `fold_left_first`, also returning an iterator. |
+| `fold_right` | Right-folds elements with a binary operation. |
+| `fold_right_last` | Right-folds using the last element as the initial value. |
+
+### Modifying Sequence Operations
+
+| Algorithm | Description |
+|---|---|
+| `copy` | Copies elements to a destination range. |
+| `copy_n` | Copies *n* elements to a destination range. |
+| `copy_if` | Copies elements satisfying a predicate. |
+| `copy_backward` | Copies elements backwards to a destination range. |
+| `move` | Moves elements to a destination range. |
+| `move_backward` | Moves elements backwards to a destination range. |
+| `swap_ranges` | Swaps elements between two ranges. |
+| `replace` | Replaces elements equal to a value. |
+| `replace_if` | Replaces elements satisfying a predicate. |
+| `replace_copy` | Copies, replacing elements equal to a value. |
+| `replace_copy_if` | Copies, replacing elements satisfying a predicate. |
+| `remove` | Removes elements equal to a value. |
+| `remove_if` | Removes elements satisfying a predicate. |
+| `remove_copy` | Copies, omitting elements equal to a value. |
+| `fill` | Fills a range with a value. |
+| `fill_n` | Fills *n* elements with a value. |
+| `generate` | Assigns each element the result of a generator function. |
+| `generate_n` | Assigns *n* elements the result of a generator function. |
+| `iota` | Fills a range with sequentially increasing values. |
+| `unique` | Removes consecutive duplicate elements. |
+| `unique_copy` | Copies, removing consecutive duplicates. |
+| `transform` | Applies a transformation to each element. |
+| `reverse` | Reverses the order of elements. |
+| `reverse_copy` | Copies elements in reverse order. |
+| `rotate` | Rotates elements in a range. |
+| `rotate_copy` | Copies elements with rotation. |
+| `shift_left` | Shifts elements to the left. |
+| `shift_right` | Shifts elements to the right. |
+| `shuffle` | Randomly reorders elements. |
+| `sample` | Selects *n* random elements from a range. |
+
+### Sorting Operations
+
+| Algorithm | Description |
+|---|---|
+| `sort` | Sorts elements in a range. |
+| `stable_sort` | Sorts elements preserving relative order of equivalent elements. |
+| `partial_sort` | Partially sorts a range so that the first *n* elements are sorted. |
+| `partial_sort_copy` | Copies and partially sorts elements. |
+| `nth_element` | Partially sorts so that the *n*-th element is in its sorted position. |
+| `is_sorted` | Checks if a range is sorted. |
+| `is_sorted_until` | Finds the first unsorted element. |
+
+### Partitioning Operations
+
+| Algorithm | Description |
+|---|---|
+| `partition` | Partitions elements by a predicate. |
+| `stable_partition` | Partitions elements, preserving relative order. |
+| `is_partitioned` | Checks if a range is partitioned. |
+| `partition_copy` | Copies elements into two ranges based on a predicate. |
+| `partition_point` | Finds the partition point. |
+
+### Binary Search (on sorted ranges)
+
+| Algorithm | Description |
+|---|---|
+| `lower_bound` | Finds the first element not less than a value. |
+| `upper_bound` | Finds the first element greater than a value. |
+| `equal_range` | Returns the range of elements equal to a value. |
+| `binary_search` | Checks if a sorted range contains a value. |
+
+### Set Operations (on sorted ranges)
+
+| Algorithm | Description |
+|---|---|
+| `includes` | Checks if one sorted range includes another. |
+| `merge` | Merges two sorted ranges. |
+| `inplace_merge` | Merges two consecutive sorted sub-ranges in place. |
+| `set_union` | Computes the union of two sorted ranges. |
+| `set_intersection` | Computes the intersection of two sorted ranges. |
+| `set_difference` | Computes the difference of two sorted ranges. |
+| `set_symmetric_difference` | Computes the symmetric difference of two sorted ranges. |
+
+### Heap Operations
+
+| Algorithm | Description |
+|---|---|
+| `make_heap` | Creates a heap from a range. |
+| `push_heap` | Pushes an element onto a heap. |
+| `pop_heap` | Pops the top element from a heap. |
+| `sort_heap` | Sorts a heap into a sorted range. |
+| `is_heap` | Checks if a range is a heap. |
+| `is_heap_until` | Finds the first element that breaks the heap property. |
+
+### Min/Max Operations
+
+| Algorithm | Description |
+|---|---|
+| `min` | Returns the smaller of two values or the smallest in an initializer list. |
+| `min_element` | Finds the smallest element in a range. |
+| `max` | Returns the larger of two values or the largest in an initializer list. |
+| `max_element` | Finds the largest element in a range. |
+| `minmax` | Returns the smaller and larger of two values. |
+| `minmax_element` | Finds both the smallest and largest elements in a range. |
+| `clamp` | Clamps a value between a minimum and maximum. |
+
+### Permutation Operations
+
+| Algorithm | Description |
+|---|---|
+| `next_permutation` | Generates the next lexicographic permutation. |
+| `prev_permutation` | Generates the previous lexicographic permutation. |
+
+
+## Reference
+
+For reference to the STD implementation, see also:
+
+- Algorithms: https://en.cppreference.com/w/cpp/algorithm.html
+- Ranges/Views: https://en.cppreference.com/w/cpp/ranges.html
+
+## Limitations
+
+- Not all C++20 range features are available due to limitation to C++17. Especially C++20 concepts are not used.
+- Designed for ETL containers but can work with standard containers if compatible with ETL's iterator requirements.

docs/source-formatting.md

@@ -0,0 +1,100 @@
+# Source Formatting
+
+This project uses **clang-format** (version 18) to enforce a consistent coding style
+for C and C++ source files. For convenience, **treefmt** is also configured as a
+single-command wrapper that discovers and formats every file in the tree.
+
+---
+
+## clang-format
+
+### Configuration file
+
+The formatting rules live in [`.clang-format`](../.clang-format) at the repository
+root. The style is based on **LLVM**.
+
+See the `.clang-format` file itself for the complete list.
+
+### Version requirement
+
+clang-format **18** is required.
+The helper script [`scripts/clang-format-wrapper`](../scripts/clang-format-wrapper)
+automatically resolves the correct binary: it first looks for `clang-format-18` on
+`PATH`, then falls back to `clang-format` and verifies that its major version is 18.
+All other tooling in the repo calls this wrapper instead of `clang-format` directly.
+
+### Running clang-format manually
+
+Format every tracked source file in the repository:
+
+```bash
+git ls-files -z \
+            '*.c' '*.cc' '*.cpp' \
+            '*.h' '*.hh' '*.hpp' \
+            ':(exclude)include/etl/generators/*' \
+            ':(exclude)include/etl/private/*_cpp03.h' | xargs -0 scripts/clang-format-wrapper -i --verbose --style=file
+```
+
+You can also format individual files directly:
+
+```bash
+scripts/clang-format-wrapper -i --style=file path/to/file.cpp
+```
+
+---
+
+## treefmt
+
+[treefmt](https://treefmt.com) is a language-agnostic source-tree formatter.
+It reads a single configuration file and dispatches each file to the appropriate
+formatter. In this project, it delegates all C/C++ formatting to the same
+`clang-format-wrapper` described above.
+
+In comparison to calling clang-format directly, it brings a significant speedup.
+
+### Configuration file
+
+The configuration lives in [`.treefmt.toml`](../.treefmt.toml) at the repository root.
+
+### Installing treefmt
+
+treefmt is a standalone Go binary. Install it with any of:
+
+```bash
+# Using the official install script
+curl -fsSL https://raw.githubusercontent.com/numtide/treefmt/main/install.sh | bash
+
+# Or via Homebrew
+brew install treefmt
+
+# Or via Nix
+nix profile install nixpkgs#treefmt2
+```
+
+See the [treefmt documentation](https://treefmt.com) for more options.
+
+### Running treefmt
+
+From the repository root:
+
+```bash
+# Format everything
+treefmt
+
+# Check formatting without modifying files (useful in CI)
+treefmt --fail-on-change
+```
+
+---
+
+## Excluded paths
+
+`.treefmt.toml` excludes generated files under
+`include/etl/generators/`. Do **not** format those files manually via clang-format or treefmt.
+
+## Pre-commit
+
+Before submitting a PR / contribution, run `treefmt --fail-on-change` to catch
+unformatted code before merge.
+
+Alternatively, a plain `treefmt` automatically fixes any issues.

examples/ArmTimerCallbacks - C++/etl_profile.h

@@ -10,6 +10,6 @@
 #define ETL_CALLBACK_TIMER_USE_ATOMIC_LOCK
 #define ETL_NO_STL
 
-//#include "etl/profiles/auto.h"
+// #include "etl/profiles/auto.h"
 
 #endif

examples/ArmTimerCallbacks - C++/main.cpp

@@ -1,23 +1,23 @@
 
 #include <stdio.h>
 
-//#if (__cplusplus < 201103L)
+// #if (__cplusplus < 201103L)
 extern "C"
 {
-//#endif
-#include "Board_LED.h"     // ::Board Support:LED
+// #endif
 #include "Board_Buttons.h" // ::Board Support:Buttons
-//#if (__cplusplus < 201103L)
+#include "Board_LED.h"     // ::Board Support:LED
+  // #if (__cplusplus < 201103L)
 }
-//#endif
+// #endif
 
-#include "stm32f4xx.h"     // Device header
+#include "stm32f4xx.h" // Device header
 
-#include "etl/function.h"
-#include "etl/callback_timer.h"
-#include "etl/vector.h"
-#include "etl/iterator.h"
 #include "etl/binary.h"
+#include "etl/callback_timer.h"
+#include "etl/function.h"
+#include "etl/iterator.h"
+#include "etl/vector.h"
 
 struct FP
 {
@@ -28,7 +28,7 @@ static etl::vector<FP, 10> power_callbacks;
 
 void register_poweroff_callback(void (*function)())
 {
-  FP fp = { function };
+  FP fp = {function};
   power_callbacks.push_back(fp);
 }
 
@@ -45,38 +45,38 @@ etl::timer::id::type swap_timers;
  * SystemCoreClockConfigure: configure SystemCoreClock using HSI
                              (HSE is not populated on Nucleo board)
  *----------------------------------------------------------------------------*/
-void SystemCoreClockConfigure(void) {
+void SystemCoreClockConfigure(void)
+{
+  RCC->CR |= ((uint32_t)RCC_CR_HSION);    // Enable HSI
+  while ((RCC->CR & RCC_CR_HSIRDY) == 0); // Wait for HSI Ready
 
-  RCC->CR |= ((uint32_t)RCC_CR_HSION);                     // Enable HSI
-  while ((RCC->CR & RCC_CR_HSIRDY) == 0);                  // Wait for HSI Ready
+  RCC->CFGR = RCC_CFGR_SW_HSI;                            // HSI is system clock
+  while ((RCC->CFGR & RCC_CFGR_SWS) != RCC_CFGR_SWS_HSI); // Wait for HSI used as system clock
 
-  RCC->CFGR = RCC_CFGR_SW_HSI;                             // HSI is system clock
-  while ((RCC->CFGR & RCC_CFGR_SWS) != RCC_CFGR_SWS_HSI);  // Wait for HSI used as system clock
+  FLASH->ACR = FLASH_ACR_PRFTEN;       // Enable Prefetch Buffer
+  FLASH->ACR |= FLASH_ACR_ICEN;        // Instruction cache enable
+  FLASH->ACR |= FLASH_ACR_DCEN;        // Data cache enable
+  FLASH->ACR |= FLASH_ACR_LATENCY_5WS; // Flash 5 wait state
 
-  FLASH->ACR  = FLASH_ACR_PRFTEN;                          // Enable Prefetch Buffer
-  FLASH->ACR |= FLASH_ACR_ICEN;                            // Instruction cache enable
-  FLASH->ACR |= FLASH_ACR_DCEN;                            // Data cache enable
-  FLASH->ACR |= FLASH_ACR_LATENCY_5WS;                     // Flash 5 wait state
+  RCC->CFGR |= RCC_CFGR_HPRE_DIV1;  // HCLK = SYSCLK
+  RCC->CFGR |= RCC_CFGR_PPRE1_DIV4; // APB1 = HCLK/4
+  RCC->CFGR |= RCC_CFGR_PPRE2_DIV2; // APB2 = HCLK/2
 
-  RCC->CFGR |= RCC_CFGR_HPRE_DIV1;                         // HCLK = SYSCLK
-  RCC->CFGR |= RCC_CFGR_PPRE1_DIV4;                        // APB1 = HCLK/4
-  RCC->CFGR |= RCC_CFGR_PPRE2_DIV2;                        // APB2 = HCLK/2
-
-  RCC->CR &= ~RCC_CR_PLLON;                                // Disable PLL
+  RCC->CR &= ~RCC_CR_PLLON; // Disable PLL
 
   // PLL configuration:  VCO = HSI/M * N,  Sysclk = VCO/P
-  RCC->PLLCFGR = ( 16ul                   |                // PLL_M =  16
-                 (384ul <<  6U)           |                // PLL_N = 384
-                 (  3ul << 16U)           |                // PLL_P =   8
-                 (RCC_PLLCFGR_PLLSRC_HSI) |                // PLL_SRC = HSI
-                 (  8ul << 24U)            );              // PLL_Q =   8
+  RCC->PLLCFGR = (16ul |                     // PLL_M =  16
+                  (384ul << 6U) |            // PLL_N = 384
+                  (3ul << 16U) |             // PLL_P =   8
+                  (RCC_PLLCFGR_PLLSRC_HSI) | // PLL_SRC = HSI
+                  (8ul << 24U));             // PLL_Q =   8
 
-  RCC->CR |= RCC_CR_PLLON;                                 // Enable PLL
-  while((RCC->CR & RCC_CR_PLLRDY) == 0) __NOP();           // Wait till PLL is ready
+  RCC->CR |= RCC_CR_PLLON;                        // Enable PLL
+  while ((RCC->CR & RCC_CR_PLLRDY) == 0) __NOP(); // Wait till PLL is ready
 
-  RCC->CFGR &= ~RCC_CFGR_SW;                               // Select PLL as system clock source
-  RCC->CFGR |=  RCC_CFGR_SW_PLL;
-  while ((RCC->CFGR & RCC_CFGR_SWS) != RCC_CFGR_SWS_PLL);  // Wait till PLL is system clock src
+  RCC->CFGR &= ~RCC_CFGR_SW; // Select PLL as system clock source
+  RCC->CFGR |= RCC_CFGR_SW_PLL;
+  while ((RCC->CFGR & RCC_CFGR_SWS) != RCC_CFGR_SWS_PLL); // Wait till PLL is system clock src
 }
 
 void StartTimers()
@@ -123,7 +123,7 @@ void LedToggle()
 
 int main()
 {
-  SystemCoreClockConfigure();                              // configure HSI as System Clock
+  SystemCoreClockConfigure(); // configure HSI as System Clock
   SystemCoreClockUpdate();
 
   LED_Initialize();
@@ -131,10 +131,10 @@ int main()
 
   // The LEDs will start flashing fast after 2 seconds.
   // After another 5 seconds they will start flashing slower.
-  short_toggle = callback_timer.register_timer(LedToggle,   50,  etl::timer::mode::REPEATING);
-  long_toggle  = callback_timer.register_timer(LedToggle,   100,  etl::timer::mode::REPEATING);
+  short_toggle = callback_timer.register_timer(LedToggle, 50, etl::timer::mode::REPEATING);
+  long_toggle  = callback_timer.register_timer(LedToggle, 100, etl::timer::mode::REPEATING);
   start_timers = callback_timer.register_timer(StartTimers, 2000, etl::timer::mode::SINGLE_SHOT);
-  swap_timers  = callback_timer.register_timer(SwapTimers,  1500, etl::timer::mode::SINGLE_SHOT);
+  swap_timers  = callback_timer.register_timer(SwapTimers, 1500, etl::timer::mode::SINGLE_SHOT);
 
   SysTick_Config(SystemCoreClock / 1000);
 
@@ -152,7 +152,7 @@ extern "C"
 {
   void SysTick_Handler()
   {
-    const  uint32_t TICK   = 1U;
+    const uint32_t  TICK   = 1U;
     static uint32_t nticks = TICK;
 
     if (callback_timer.tick(nticks))

examples/FunctionInterruptSimulation-Delegates/FunctionInterruptSimulation.cpp

@@ -11,8 +11,8 @@ enum VectorId
   USART1_IRQ_HANDLER  = 52,
   USART2_IRQ_HANDLER  = 53,
   VECTOR_ID_END,
-  VECTOR_ID_OFFSET    = TIM1_CC_IRQ_HANDLER,
-  VECTOR_ID_RANGE     = VECTOR_ID_END - VECTOR_ID_OFFSET
+  VECTOR_ID_OFFSET = TIM1_CC_IRQ_HANDLER,
+  VECTOR_ID_RANGE  = VECTOR_ID_END - VECTOR_ID_OFFSET
 };
 
 typedef etl::delegate_service<VECTOR_ID_RANGE, VECTOR_ID_OFFSET> InterruptVectors;
@@ -91,8 +91,8 @@ public:
 
   // Constructor.
   Uart(int port_id, size_t interruptId)
-    : port_id(port_id),
-      callback(etl::delegate<void(size_t)>::create<Uart, &Uart::InterruptHandler>(*this))
+    : port_id(port_id)
+    , callback(etl::delegate<void(size_t)>::create<Uart, &Uart::InterruptHandler>(*this))
   {
     GetInterruptVectorsInstance().register_delegate(interruptId, callback);
   }
@@ -119,7 +119,8 @@ Uart  uart1(0, USART1_IRQ_HANDLER);
 Uart  uart2(1, USART2_IRQ_HANDLER);
 
 // Declare a global callback for the timer.
-// Uses the most efficient callback type for a class, as everthing is known at compile time.
+// Uses the most efficient callback type for a class, as everything is known at
+// compile time.
 etl::delegate<void(size_t)> timer_member_callback = etl::delegate<void(size_t)>::create<Timer, timer, &Timer::InterruptHandler>();
 
 // Declare the callbacks for the free functions.

examples/FunctionInterruptSimulation/FunctionInterruptSimulation.cpp

@@ -1,7 +1,7 @@
 #include <iostream>
 
-#include "etl/function.h"
 #include "etl/callback_service.h"
+#include "etl/function.h"
 
 enum VectorId
 {
@@ -11,8 +11,8 @@ enum VectorId
   USART1_IRQ_HANDLER  = 52,
   USART2_IRQ_HANDLER  = 53,
   VECTOR_ID_END,
-  VECTOR_ID_OFFSET    = TIM1_CC_IRQ_HANDLER,
-  VECTOR_ID_RANGE     = VECTOR_ID_END - VECTOR_ID_OFFSET
+  VECTOR_ID_OFFSET = TIM1_CC_IRQ_HANDLER,
+  VECTOR_ID_RANGE  = VECTOR_ID_END - VECTOR_ID_OFFSET
 };
 
 typedef etl::callback_service<VECTOR_ID_RANGE, VECTOR_ID_OFFSET> InterruptVectors;
@@ -91,8 +91,8 @@ public:
 
   // Constructor.
   Uart(int port_id, int interruptId)
-    : port_id(port_id),
-      callback(*this)
+    : port_id(port_id)
+    , callback(*this)
   {
     GetInterruptVectorsInstance().register_callback(interruptId, callback);
   }
@@ -119,7 +119,8 @@ Uart  uart1(0, USART1_IRQ_HANDLER);
 Uart  uart2(1, USART2_IRQ_HANDLER);
 
 // Declare a global callback for the timer.
-// Uses the most efficient callback type for a class, as everthing is known at compile time.
+// Uses the most efficient callback type for a class, as everything is known at
+// compile time.
 etl::function_imp<Timer, size_t, timer, &Timer::InterruptHandler> timer_member_callback;
 
 // Declare the callbacks for the free functions.

examples/MutexMessageRouter/MutexMessageRouter.cpp

@@ -1,13 +1,13 @@
 
-#include <iostream>
-#include <thread>
 #include <atomic>
-#include <string>
 #include <chrono>
+#include <iostream>
+#include <string>
+#include <thread>
 
-#include "etl/mutex.h"
 #include "etl/message.h"
 #include "etl/message_router.h"
+#include "etl/mutex.h"
 
 //*************************************
 struct Message1 : public etl::message<1>
@@ -48,9 +48,7 @@ public:
   }
 
   //*****************
-  void on_receive_unknown(const etl::imessage&)
-  {
-  }
+  void on_receive_unknown(const etl::imessage&) {}
 
   std::string result;
 
@@ -61,7 +59,7 @@ private:
 
 //*************************************
 etl::atomic<bool> start = false;
-Router router;
+Router            router;
 
 //*************************************
 void thread1()
@@ -106,5 +104,3 @@ int main()
 
   return 0;
 }
-
-

examples/QueuedFSM/QueuedFSM.cpp

@@ -31,9 +31,9 @@ SOFTWARE.
 // derived class.
 //*****************************************************************************
 
-#include "etl/queue.h"
 #include "etl/fsm.h"
 #include "etl/message_packet.h"
+#include "etl/queue.h"
 
 #include <iostream>
 #include <string>
@@ -122,7 +122,7 @@ public:
     while (!queue.empty())
     {
       message_packet& packet = queue.front();
-      etl::imessage& msg = packet.get();
+      etl::imessage&  msg    = packet.get();
       std::cout << "Processing message " << int(msg.get_message_id()) << std::endl;
 
       // Call the base class's receive function.
@@ -258,7 +258,7 @@ int main()
   State2 state2;
 
   // The list of states.
-  etl::ifsm_state* state_list[] = { &state1, &state2 };
+  etl::ifsm_state* state_list[] = {&state1, &state2};
 
   // Define some messages.
   Message1 m1(1);
@@ -285,4 +285,3 @@ int main()
 
   return 0;
 }
-

examples/QueuedMessageRouter/QueuedMessageRouter.cpp

@@ -1,6 +1,6 @@
 
-#include "etl/queue.h"
 #include "etl/message_router.h"
+#include "etl/queue.h"
 
 #include <iostream>
 #include <string>
@@ -52,8 +52,6 @@ public:
 
   typedef etl::message_router<Router, Message1, Message2, Message3> Base_t;
 
-  using Base_t::receive;
-
   //***************************************************************************
   Router()
     : message_router(1)
@@ -83,7 +81,7 @@ public:
     while (!queue.empty())
     {
       message_packet& packet = queue.front();
-      etl::imessage& msg = packet.get();
+      etl::imessage&  msg    = packet.get();
       std::cout << "Processing message " << int(msg.get_message_id()) << std::endl;
 
       // Call the base class's receive function.
@@ -148,4 +146,3 @@ int main()
 
   return 0;
 }
-

examples/QueuedMessageRouter/vs2022/QueuedMessageRouter.vcxproj

@@ -29,26 +29,26 @@
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
     <ConfigurationType>Application</ConfigurationType>
     <UseDebugLibraries>true</UseDebugLibraries>
-    <PlatformToolset>v142</PlatformToolset>
+    <PlatformToolset>v143</PlatformToolset>
     <CharacterSet>Unicode</CharacterSet>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
     <ConfigurationType>Application</ConfigurationType>
     <UseDebugLibraries>false</UseDebugLibraries>
-    <PlatformToolset>v142</PlatformToolset>
+    <PlatformToolset>v143</PlatformToolset>
     <WholeProgramOptimization>true</WholeProgramOptimization>
     <CharacterSet>Unicode</CharacterSet>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
     <ConfigurationType>Application</ConfigurationType>
     <UseDebugLibraries>true</UseDebugLibraries>
-    <PlatformToolset>v142</PlatformToolset>
+    <PlatformToolset>v143</PlatformToolset>
     <CharacterSet>Unicode</CharacterSet>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
     <ConfigurationType>Application</ConfigurationType>
     <UseDebugLibraries>false</UseDebugLibraries>
-    <PlatformToolset>v142</PlatformToolset>
+    <PlatformToolset>v143</PlatformToolset>
     <WholeProgramOptimization>true</WholeProgramOptimization>
     <CharacterSet>Unicode</CharacterSet>
   </PropertyGroup>

examples/Scheduler/Scheduler.cpp

@@ -31,9 +31,9 @@ SOFTWARE.
 // Experiment with the different scheduling policies.
 //*****************************************************************************
 
+#include "etl/function.h"
 #include "etl/scheduler.h"
 #include "etl/task.h"
-#include "etl/function.h"
 
 #include <iostream>
 #include <string>
@@ -50,13 +50,13 @@ public:
     : task(1)
     , work(3)
   {
-
   }
 
   //*************************************
   uint32_t task_request_work() const
   {
-    return work; // How much work do we still have to do? This could be a message queue length.
+    return work; // How much work do we still have to do? This could be a
+                 // message queue length.
   }
 
   //*************************************
@@ -83,13 +83,13 @@ public:
     : task(2)
     , work(4)
   {
-
   }
 
   //*************************************
   uint32_t task_request_work() const
   {
-    return work; // How much work do we still have to do? This could be a message queue length.
+    return work; // How much work do we still have to do? This could be a
+                 // message queue length.
   }
 
   //*************************************
@@ -115,7 +115,6 @@ public:
   Idle(etl::ischeduler& scheduler_)
     : scheduler(scheduler_)
   {
-
   }
 
   //*************************************
@@ -181,4 +180,3 @@ int main()
 
   return 0;
 }
-

examples/SharedMessage/SharedMessage.cpp

@@ -2,18 +2,18 @@
 // Shared message example
 //*****************************************************************************
 
-#include "etl/shared_message.h"
-#include "etl/message.h"
-#include "etl/reference_counted_message_pool.h"
-#include "etl/message_router.h"
-#include "etl/message_bus.h"
 #include "etl/fixed_sized_memory_block_allocator.h"
+#include "etl/message.h"
+#include "etl/message_bus.h"
+#include "etl/message_router.h"
 #include "etl/queue.h"
+#include "etl/reference_counted_message_pool.h"
+#include "etl/shared_message.h"
 
-#include <iostream>
 #include <atomic>
-#include <string>
+#include <iostream>
 #include <mutex>
+#include <string>
 
 constexpr etl::message_router_id_t RouterId1 = 1U;
 constexpr etl::message_router_id_t RouterId2 = 2U;
@@ -26,9 +26,8 @@ struct Message1 : public etl::message<1>
   Message1(std::string s_)
     : s(s_)
   {
-    
   }
-  
+
   std::string s;
 };
 
@@ -40,10 +39,10 @@ struct Message2 : public etl::message<2>
   Message2(std::string s_)
     : s(s_)
   {
-    
   }
-  
+
   std::string s;
+
   char data[100];
 };
 
@@ -55,7 +54,6 @@ struct Message3 : public etl::message<3>
   Message3(std::string s_)
     : s(s_)
   {
-
   }
 
   std::string s;
@@ -199,7 +197,7 @@ struct Bus : public etl::message_bus<2U>
 //*****************************************************************************
 MessageRouter1 router1;
 MessageRouter2 router2;
-Bus bus;
+Bus            bus;
 
 //*****************************************************************************
 // The thread safe message pool. Uses atomic uint32_t for counting.
@@ -230,8 +228,8 @@ private:
 };
 
 //*****************************************************************************
-// The memory block allocator that supplies the pool with memory 
-// to store reference counted messages in. 
+// The memory block allocator that supplies the pool with memory
+// to store reference counted messages in.
 
 // The reference counted message parameters type for the messages we will use.
 using message_parameters_small = MessagePool::pool_message_parameters<Message1, Message3>;
@@ -243,10 +241,12 @@ constexpr size_t max_alignment_small = message_parameters_small::max_alignment;
 constexpr size_t max_size_large      = message_parameters_large::max_size;
 constexpr size_t max_alignment_large = message_parameters_large::max_alignment;
 
-// A fixed memory block allocator for 4 items, using the parameters from the smaller messages.
+// A fixed memory block allocator for 4 items, using the parameters from the
+// smaller messages.
 etl::fixed_sized_memory_block_allocator<max_size_small, max_alignment_small, 4U> memory_allocator;
 
-// A fixed memory block allocator for 4 items, using the parameters from the larger message.
+// A fixed memory block allocator for 4 items, using the parameters from the
+// larger message.
 etl::fixed_sized_memory_block_allocator<max_size_large, max_alignment_large, 4U> memory_allocator_successor;
 
 //*****************************************************************************
@@ -256,8 +256,8 @@ etl::fixed_sized_memory_block_allocator<max_size_large, max_alignment_large, 4U>
 MessagePool message_pool(memory_allocator);
 
 //*****************************************************************************
-// A statically allocated reference counted message that is never allocated or released by a pool.
-// Contains a copy of Message3("Three").
+// A statically allocated reference counted message that is never allocated or
+// released by a pool. Contains a copy of Message3("Three").
 //*****************************************************************************
 etl::persistent_message<Message3> pm3(Message3("Three"));
 
@@ -269,10 +269,15 @@ int main()
 
   Message1 m1("One");
   Message2 m2("Two");
-  
-  etl::shared_message sm1(message_pool, m1); // Created a shared message by allocating a reference counted message from message_pool containing a copy of m1.
-  etl::shared_message sm2(message_pool, m2); // Created a shared message by allocating a reference counted message from message_pool containing a copy of m2.
-  etl::shared_message sm3(pm3);              // Created a shared message from a statically allocated persistent message.
+
+  etl::shared_message sm1(message_pool,
+                          m1); // Created a shared message by allocating a reference counted message
+                               // from message_pool containing a copy of m1.
+  etl::shared_message sm2(message_pool,
+                          m2);  // Created a shared message by allocating a reference counted message
+                                // from message_pool containing a copy of m2.
+  etl::shared_message sm3(pm3); // Created a shared message from a statically
+                                // allocated persistent message.
 
   bus.subscribe(router1); // Subscribe router1 to the bus.
   bus.subscribe(router2); // Subscribe router2 to the bus.

examples/UniquePtrWithPool/CmakeLists.txt

@@ -0,0 +1,10 @@
+cmake_minimum_required(VERSION 3.10)
+project(UniquePtrWithPool LANGUAGES CXX)
+
+set(CMAKE_CXX_STANDARD 14)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+
+# Add source files
+add_executable(UniquePtrWithPool Main.cpp)
+
+target_include_directories(UniquePtrWithPool PRIVATE ../../include)

examples/UniquePtrWithPool/Main.cpp

@@ -0,0 +1,38 @@
+#include <iostream>
+
+#include "etl/memory.h"
+#include "etl/pool.h"
+
+struct S
+{
+  S(int a_, double b_)
+    : a(a_)
+    , b(b_)
+  {
+  }
+
+  int    a;
+  double b;
+};
+
+int main()
+{
+  etl::pool<S, 10> pool;
+  auto             pool_deleter = [&pool](auto ptr)
+  {
+    std::cout << "Releasing S(" << ptr->a << ", " << ptr->b << ") back to pool." << std::endl;
+    pool.destroy(ptr);
+  };
+  using Unique = etl::unique_ptr<S, decltype(pool_deleter)>;
+
+  Unique us1(pool.create(1, 2), pool_deleter);
+  std::cout << "Created S(" << us1->a << ", " << us1->b << ") from pool." << std::endl;
+
+  {
+    Unique us2(pool.create(3, 4), pool_deleter);
+    std::cout << "Created S(" << us2->a << ", " << us2->b << ") from pool." << std::endl;
+  }
+
+  Unique us3(pool.create(5, 6), pool_deleter);
+  std::cout << "Created S(" << us3->a << ", " << us3->b << ") from pool." << std::endl;
+}

examples/UniquePtrWithPool/UniquePtrWithPool.sln

@@ -0,0 +1,31 @@
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio Version 17
+VisualStudioVersion = 17.14.36408.4 d17.14
+MinimumVisualStudioVersion = 10.0.40219.1
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "UniquePtrWithPool", "UniquePtrWithPool.vcxproj", "{B9ED2FDF-2529-4315-9AEF-02A98B804DEC}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|x64 = Debug|x64
+		Debug|x86 = Debug|x86
+		Release|x64 = Release|x64
+		Release|x86 = Release|x86
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{B9ED2FDF-2529-4315-9AEF-02A98B804DEC}.Debug|x64.ActiveCfg = Debug|x64
+		{B9ED2FDF-2529-4315-9AEF-02A98B804DEC}.Debug|x64.Build.0 = Debug|x64
+		{B9ED2FDF-2529-4315-9AEF-02A98B804DEC}.Debug|x86.ActiveCfg = Debug|Win32
+		{B9ED2FDF-2529-4315-9AEF-02A98B804DEC}.Debug|x86.Build.0 = Debug|Win32
+		{B9ED2FDF-2529-4315-9AEF-02A98B804DEC}.Release|x64.ActiveCfg = Release|x64
+		{B9ED2FDF-2529-4315-9AEF-02A98B804DEC}.Release|x64.Build.0 = Release|x64
+		{B9ED2FDF-2529-4315-9AEF-02A98B804DEC}.Release|x86.ActiveCfg = Release|Win32
+		{B9ED2FDF-2529-4315-9AEF-02A98B804DEC}.Release|x86.Build.0 = Release|Win32
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+	GlobalSection(ExtensibilityGlobals) = postSolution
+		SolutionGuid = {D21FA849-65C8-4A81-BD9D-B38BFBD73494}
+	EndGlobalSection
+EndGlobal

examples/UniquePtrWithPool/UniquePtrWithPool.vcxproj

@@ -19,36 +19,36 @@
     </ProjectConfiguration>
   </ItemGroup>
   <PropertyGroup Label="Globals">
-    <VCProjectVersion>16.0</VCProjectVersion>
+    <VCProjectVersion>17.0</VCProjectVersion>
     <Keyword>Win32Proj</Keyword>
-    <ProjectGuid>{0523db70-0955-4eb0-a042-04514987a602}</ProjectGuid>
-    <RootNamespace>etlinitialiserlist</RootNamespace>
+    <ProjectGuid>{b9ed2fdf-2529-4315-9aef-02a98b804dec}</ProjectGuid>
+    <RootNamespace>UniquePtrWithPool</RootNamespace>
     <WindowsTargetPlatformVersion>10.0</WindowsTargetPlatformVersion>
   </PropertyGroup>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
     <ConfigurationType>Application</ConfigurationType>
     <UseDebugLibraries>true</UseDebugLibraries>
-    <PlatformToolset>v142</PlatformToolset>
+    <PlatformToolset>v143</PlatformToolset>
     <CharacterSet>Unicode</CharacterSet>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
     <ConfigurationType>Application</ConfigurationType>
     <UseDebugLibraries>false</UseDebugLibraries>
-    <PlatformToolset>v142</PlatformToolset>
+    <PlatformToolset>v143</PlatformToolset>
     <WholeProgramOptimization>true</WholeProgramOptimization>
     <CharacterSet>Unicode</CharacterSet>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
     <ConfigurationType>Application</ConfigurationType>
     <UseDebugLibraries>true</UseDebugLibraries>
-    <PlatformToolset>v142</PlatformToolset>
+    <PlatformToolset>v143</PlatformToolset>
     <CharacterSet>Unicode</CharacterSet>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
     <ConfigurationType>Application</ConfigurationType>
     <UseDebugLibraries>false</UseDebugLibraries>
-    <PlatformToolset>v142</PlatformToolset>
+    <PlatformToolset>v143</PlatformToolset>
     <WholeProgramOptimization>true</WholeProgramOptimization>
     <CharacterSet>Unicode</CharacterSet>
   </PropertyGroup>
@@ -70,26 +70,13 @@
     <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
   </ImportGroup>
   <PropertyGroup Label="UserMacros" />
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
-    <LinkIncremental>true</LinkIncremental>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
-    <LinkIncremental>false</LinkIncremental>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
-    <LinkIncremental>true</LinkIncremental>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
-    <LinkIncremental>false</LinkIncremental>
-  </PropertyGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
     <ClCompile>
       <WarningLevel>Level3</WarningLevel>
       <SDLCheck>true</SDLCheck>
-      <PreprocessorDefinitions>WIN32;_DEBUG;_CONSOLE;ETL_NO_STL;ETL_IN_UNIT_TEST_INITIALIZER_LIST;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <PreprocessorDefinitions>WIN32;_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <ConformanceMode>true</ConformanceMode>
-      <AdditionalIncludeDirectories>../../../include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
-      <LanguageStandard>stdcpp17</LanguageStandard>
+      <AdditionalIncludeDirectories>../../include/;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
     </ClCompile>
     <Link>
       <SubSystem>Console</SubSystem>
@@ -104,11 +91,10 @@
       <SDLCheck>true</SDLCheck>
       <PreprocessorDefinitions>WIN32;NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <ConformanceMode>true</ConformanceMode>
+      <AdditionalIncludeDirectories>../../include/;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
     </ClCompile>
     <Link>
       <SubSystem>Console</SubSystem>
-      <EnableCOMDATFolding>true</EnableCOMDATFolding>
-      <OptimizeReferences>true</OptimizeReferences>
       <GenerateDebugInformation>true</GenerateDebugInformation>
     </Link>
   </ItemDefinitionGroup>
@@ -135,13 +121,11 @@
     </ClCompile>
     <Link>
       <SubSystem>Console</SubSystem>
-      <EnableCOMDATFolding>true</EnableCOMDATFolding>
-      <OptimizeReferences>true</OptimizeReferences>
       <GenerateDebugInformation>true</GenerateDebugInformation>
     </Link>
   </ItemDefinitionGroup>
   <ItemGroup>
-    <ClCompile Include="..\..\test_initializer_list.cpp" />
+    <ClCompile Include="Main.cpp" />
   </ItemGroup>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
   <ImportGroup Label="ExtensionTargets">

examples/platformio/src/main.cpp

@@ -88,35 +88,35 @@ public:
   // Notify observers about a position event.
   void Position_Event()
   {
-    Position position = { 100, 200 };
+    Position position = {100, 200};
     notify_observers(position);
   }
 
   // Notify observers about a button up event.
   void Button_Event_Up()
   {
-    Button button = { Button::Up };
+    Button button = {Button::Up};
     notify_observers(button);
   }
 
   // Notify observers about a button down event.
   void Button_Event_Down()
   {
-    Button button = { Button::Down };
+    Button button = {Button::Down};
     notify_observers(button);
   }
 
   // Notify observers about a wheel up event.
   void Wheel_Event_Up()
   {
-    Wheel wheel = { 50 };
+    Wheel wheel = {50};
     notify_observers(wheel);
   }
 
   // Notify observers about a wheel down event.
   void Wheel_Event_Down()
   {
-    Wheel wheel = { -25 };
+    Wheel wheel = {-25};
     notify_observers(wheel);
   }
 };
@@ -137,6 +137,6 @@ int main()
   mouse_driver.Position_Event();
   mouse_driver.Wheel_Event_Down();
   mouse_driver.Wheel_Event_Up();
- 
+
   return 0;
 }

hugo/layouts/_default/baseof.html

@@ -0,0 +1,15 @@
+<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>{{ .Title }} | {{ .Site.Title }}</title>
+  </head>
+  <body>
+    <main>
+      {{ block "main" . }}{{ end }}
+    </main>
+
+    {{ partial "footer.html" . }}
+  </body>
+</html>

hugo/layouts/_partials/footer.html

@@ -0,0 +1,4 @@
+<footer style="text-align: center;">
+  <p>© 2014–{{ now.Format "2006" }} {{ .Site.Title }}. All rights reserved.</p>
+  <p></p>
+</footer>

images/Coverty Shields.txt

@@ -0,0 +1,9 @@
+<a href="https://scan.coverity.com/projects/embedded-template-library">
+  <img alt="Coverity Scan Build Status"
+       src="https://scan.coverity.com/projects/30565/badge.svg"/>
+</a>
+
+<a href="https://scan.coverity.com/projects/embedded-template-library">
+  <img alt="Coverity Scan Build Status"
+       src="https://img.shields.io/coverity/scan/30565.svg"/>
+</a>

include/etl/absolute.h

@@ -31,17 +31,41 @@ SOFTWARE.
 #ifndef ETL_ABSOLUTE_INCLUDED
 #define ETL_ABSOLUTE_INCLUDED
 
-#include "type_traits.h"
+#include "platform.h"
+#include "error_handler.h"
 #include "integral_limits.h"
+#include "type_traits.h"
 
 namespace etl
 {
+  namespace private_absolute
+  {
+    //*************************************************************************
+    // Non-constexpr function that is never called for valid inputs.
+    // If reached during constant evaluation, the compiler emits an error
+    // because it's not constexpr.
+    // At runtime, triggers the ETL assert handler.
+    //*************************************************************************
+    template <typename T>
+    inline T signed_min_error()
+    {
+      ETL_ASSERT_FAIL(ETL_ERROR_GENERIC("absolute value of minimum signed integer is undefined"));
+      return T(0);
+    }
+  } // namespace private_absolute
+
   //***************************************************************************
   // For signed types.
   //***************************************************************************
   template <typename T>
-  ETL_CONSTEXPR typename etl::enable_if<etl::is_signed<T>::value, T>::type
-    absolute(T value)
+  ETL_NODISCARD ETL_CONSTEXPR typename etl::enable_if< etl::is_signed<T>::value && etl::is_integral<T>::value, T>::type absolute(T value)
+  {
+    return (value == etl::integral_limits<T>::min) ? etl::private_absolute::signed_min_error<T>() : static_cast<T>((value < T(0)) ? -value : value);
+  }
+
+  template <typename T>
+  ETL_NODISCARD ETL_CONSTEXPR typename etl::enable_if< etl::is_signed<T>::value && !etl::is_integral<T>::value, T>::type absolute(T value)
+    ETL_NOEXCEPT
   {
     return (value < T(0)) ? -value : value;
   }
@@ -50,8 +74,7 @@ namespace etl
   // For unsigned types.
   //***************************************************************************
   template <typename T>
-  ETL_CONSTEXPR typename etl::enable_if<etl::is_unsigned<T>::value, T>::type
-    absolute(T value)
+  ETL_NODISCARD ETL_CONSTEXPR typename etl::enable_if<etl::is_unsigned<T>::value, T>::type absolute(T value) ETL_NOEXCEPT
   {
     return value;
   }
@@ -60,16 +83,15 @@ namespace etl
   // For signed types.
   // Returns the result as the unsigned type.
   //***************************************************************************
-#if ETL_USING_CPP11
-  template <typename T, typename TReturn = typename etl::make_unsigned<T>::type>
-#else
-  template <typename T, typename TReturn>
-  #endif
-  ETL_CONSTEXPR typename etl::enable_if<etl::is_signed<T>::value, TReturn>::type
-    absolute_unsigned(T value)
+  template <typename T>
+  ETL_NODISCARD ETL_CONSTEXPR typename etl::enable_if<etl::is_signed<T>::value, typename etl::make_unsigned<T>::type>::type absolute_unsigned(T value)
+    ETL_NOEXCEPT
   {
+    typedef typename etl::make_unsigned<T>::type TReturn;
+
     return (value == etl::integral_limits<T>::min) ? (etl::integral_limits<TReturn>::max / 2U) + 1U
-                                                   : (value < T(0)) ? TReturn(-value) : TReturn(value);
+           : (value < T(0))                        ? TReturn(-value)
+                                                   : TReturn(value);
   }
 
   //***************************************************************************
@@ -77,12 +99,10 @@ namespace etl
   // Returns the result as the unsigned type.
   //***************************************************************************
   template <typename T>
-  ETL_CONSTEXPR typename etl::enable_if<etl::is_unsigned<T>::value, T>::type
-    absolute_unsigned(T value)
+  ETL_NODISCARD ETL_CONSTEXPR typename etl::enable_if<etl::is_unsigned<T>::value, T>::type absolute_unsigned(T value) ETL_NOEXCEPT
   {
     return etl::absolute(value);
   }
-}
+} // namespace etl
 
 #endif
-

include/etl/alignment.h

@@ -32,10 +32,11 @@ SOFTWARE.
 #define ETL_ALIGNMENT_INCLUDED
 
 #include "platform.h"
-#include "type_traits.h"
-#include "static_assert.h"
 #include "error_handler.h"
 #include "exception.h"
+#include "static_assert.h"
+#include "type_traits.h"
+#include "utility.h"
 
 #include <stdint.h>
 
@@ -71,10 +72,23 @@ namespace etl
     }
   };
 
+  //***************************************************************************
+  /// Typed storage exception.
+  //***************************************************************************
+  class typed_storage_error : public alignment_exception
+  {
+  public:
+
+    typed_storage_error(string_type file_name_, numeric_type line_number_)
+      : alignment_exception(ETL_ERROR_TEXT("typed_storage:error", ETL_ALIGNMENT_FILE_ID"B"), file_name_, line_number_)
+    {
+    }
+  };
+
   //*****************************************************************************
   /// Check that 'p' has 'required_alignment'.
   //*****************************************************************************
-  inline bool is_aligned(void* p, size_t required_alignment)
+  inline bool is_aligned(const void* p, size_t required_alignment)
   {
     uintptr_t address = reinterpret_cast<uintptr_t>(p);
     return (address % required_alignment) == 0U;
@@ -84,7 +98,7 @@ namespace etl
   /// Check that 'p' has 'Alignment'.
   //*****************************************************************************
   template <size_t Alignment>
-  bool is_aligned(void* p)
+  bool is_aligned(const void* p)
   {
     uintptr_t address = reinterpret_cast<uintptr_t>(p);
     return (address % Alignment) == 0U;
@@ -94,7 +108,7 @@ namespace etl
   /// Check that 'p' has the alignment of 'T'.
   //*****************************************************************************
   template <typename T>
-  bool is_aligned(void* p)
+  bool is_aligned(const void* p)
   {
     return is_aligned<etl::alignment_of<T>::value>(p);
   }
@@ -110,28 +124,28 @@ namespace etl
 
     // Matching alignment.
     template <size_t Alignment, typename T1, typename... TRest>
-    class type_with_alignment_matcher<true, Alignment, T1, TRest...> 
+    class type_with_alignment_matcher<true, Alignment, T1, TRest...>
     {
     public:
-    
+
       typedef T1 type;
     };
 
     // Non-matching alignment
     template <size_t Alignment, typename T1, typename T2, typename... TRest>
-    class type_with_alignment_matcher <false, Alignment, T1, T2, TRest...> 
+    class type_with_alignment_matcher<false, Alignment, T1, T2, TRest...>
     {
     public:
-    
-      typedef typename type_with_alignment_matcher < Alignment <= etl::alignment_of<T2>::value , Alignment, T2, TRest... > ::type type;
+
+      typedef typename type_with_alignment_matcher< Alignment <= etl::alignment_of<T2>::value, Alignment, T2, TRest... >::type type;
     };
 
     // Non-matching alignment, none left.
     template <size_t Alignment, typename T1>
-    class type_with_alignment_matcher <false, Alignment, T1> 
+    class type_with_alignment_matcher<false, Alignment, T1>
     {
     public:
-    
+
       typedef char type;
     };
 
@@ -139,23 +153,23 @@ namespace etl
     // Helper.
     //***************************************************************************
     template <size_t Alignment, typename T1, typename... T>
-    class type_with_alignment_helper 
+    class type_with_alignment_helper
     {
     public:
-    
+
       typedef typename type_with_alignment_matcher<Alignment <= etl::alignment_of<T1>::value, Alignment, T1, T...>::type type;
     };
 #else
     //***************************************************************************
     // Matcher.
     //***************************************************************************
-    template <bool Is_Match, const size_t Alignment, typename T1 = void, typename T2 = void, typename T3 = void, typename T4 = void, 
-                                                     typename T5 = void, typename T6 = void, typename T7 = void, typename T8 = void>
+    template <bool Is_Match, const size_t Alignment, typename T1 = void, typename T2 = void, typename T3 = void, typename T4 = void,
+              typename T5 = void, typename T6 = void, typename T7 = void, typename T8 = void>
     class type_with_alignment_matcher;
 
     // Matching alignment.
     template <size_t Alignment, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8>
-    class type_with_alignment_matcher <true, Alignment, T1, T2, T3, T4, T5, T6, T7, T8>
+    class type_with_alignment_matcher<true, Alignment, T1, T2, T3, T4, T5, T6, T7, T8>
     {
     public:
 
@@ -164,16 +178,17 @@ namespace etl
 
     // Non-matching alignment.
     template <size_t Alignment, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8>
-    class type_with_alignment_matcher <false, Alignment, T1, T2, T3, T4, T5, T6, T7, T8>
+    class type_with_alignment_matcher<false, Alignment, T1, T2, T3, T4, T5, T6, T7, T8>
     {
     public:
 
-      typedef typename type_with_alignment_matcher<Alignment <= etl::alignment_of<T2>::value, Alignment, T2, T3, T4, T5, T6, T7, T8, void>::type type;
+      typedef
+        typename type_with_alignment_matcher< Alignment <= etl::alignment_of<T2>::value, Alignment, T2, T3, T4, T5, T6, T7, T8, void>::type type;
     };
 
     // Non-matching alignment, none left.
     template <size_t Alignment>
-    class type_with_alignment_matcher <false, Alignment, void, void, void, void, void, void, void, void>
+    class type_with_alignment_matcher<false, Alignment, void, void, void, void, void, void, void, void>
     {
     public:
 
@@ -183,16 +198,16 @@ namespace etl
     //***************************************************************************
     // Helper.
     //***************************************************************************
-    template <size_t Alignment, typename T1,        typename T2 = void, typename T3 = void, typename T4 = void,
-                                typename T5 = void, typename T6 = void, typename T7 = void, typename T8 = void>
+    template <size_t Alignment, typename T1, typename T2 = void, typename T3 = void, typename T4 = void, typename T5 = void, typename T6 = void,
+              typename T7 = void, typename T8 = void>
     class type_with_alignment_helper
     {
     public:
 
-      typedef typename type_with_alignment_matcher<Alignment <= etl::alignment_of<T1>::value, Alignment, T1, T2, T3, T4, T5, T6, T7, T8>::type type;
+      typedef typename type_with_alignment_matcher< Alignment <= etl::alignment_of<T1>::value, Alignment, T1, T2, T3, T4, T5, T6, T7, T8>::type type;
     };
 #endif
-  }
+  } // namespace private_alignment
 
   //***************************************************************************
   /// Gets a type that has the same as the specified alignment.
@@ -204,12 +219,17 @@ namespace etl
   public:
 
 #if ETL_USING_CPP11
-    typedef struct { alignas(Alignment) char dummy; } type;
+    typedef struct
+    {
+      alignas(Alignment) char dummy;
+    } type;
 #else
   #if ETL_NOT_USING_64BIT_TYPES
-      typedef typename private_alignment::type_with_alignment_helper<Alignment, int_least8_t, int_least16_t, int32_t, float, double, void*>::type type;
+    typedef typename private_alignment::type_with_alignment_helper< Alignment, int_least8_t, int_least16_t, int32_t, float, double, void*>::type type;
   #else
-      typedef typename private_alignment::type_with_alignment_helper<Alignment, int_least8_t, int_least16_t, int32_t, int64_t, float, double, void*>::type type;
+    typedef
+      typename private_alignment::type_with_alignment_helper< Alignment, int_least8_t, int_least16_t, int32_t, int64_t, float, double, void*>::type
+        type;
   #endif
 #endif
 
@@ -231,42 +251,37 @@ namespace etl
   {
     struct type
     {
-      //type() 
-      //  : data()
-      //{
-      //}
-
       /// Convert to T reference.
       template <typename T>
-      operator T& ()
+      operator T&()
       {
-        ETL_STATIC_ASSERT((etl::is_same<T*, void*>:: value || ((Alignment % etl::alignment_of<T>::value) == 0)), "Incompatible alignment");
+        ETL_STATIC_ASSERT((etl::is_same<T*, void*>::value || ((Alignment % etl::alignment_of<T>::value) == 0)), "Incompatible alignment");
         T* t = *this;
         return *t;
       }
 
       /// Convert to const T reference.
       template <typename T>
-      operator const T& () const
+      operator const T&() const
       {
-        ETL_STATIC_ASSERT((etl::is_same<T*, void*>:: value || ((Alignment % etl::alignment_of<T>::value) == 0)), "Incompatible alignment");
+        ETL_STATIC_ASSERT((etl::is_same<T*, void*>::value || ((Alignment % etl::alignment_of<T>::value) == 0)), "Incompatible alignment");
         const T* t = *this;
         return *t;
       }
 
       /// Convert to T pointer.
       template <typename T>
-      operator T* ()
+      operator T*()
       {
-        ETL_STATIC_ASSERT((etl::is_same<T*, void*>:: value || ((Alignment % etl::alignment_of<T>::value) == 0)), "Incompatible alignment");
+        ETL_STATIC_ASSERT((etl::is_same<T*, void*>::value || ((Alignment % etl::alignment_of<T>::value) == 0)), "Incompatible alignment");
         return reinterpret_cast<T*>(data);
       }
 
       /// Convert to const T pointer.
       template <typename T>
-      operator const T* () const
+      operator const T*() const
       {
-        ETL_STATIC_ASSERT((etl::is_same<T*, void*>:: value || ((Alignment % etl::alignment_of<T>::value) == 0)), "Incompatible alignment");
+        ETL_STATIC_ASSERT((etl::is_same<T*, void*>::value || ((Alignment % etl::alignment_of<T>::value) == 0)), "Incompatible alignment");
         return reinterpret_cast<const T*>(data);
       }
 
@@ -274,7 +289,7 @@ namespace etl
       template <typename T>
       T& get_reference()
       {
-        ETL_STATIC_ASSERT((etl::is_same<T*, void*>:: value || ((Alignment % etl::alignment_of<T>::value) == 0)), "Incompatible alignment");
+        ETL_STATIC_ASSERT((etl::is_same<T*, void*>::value || ((Alignment % etl::alignment_of<T>::value) == 0)), "Incompatible alignment");
         T* t = *this;
         return *t;
       }
@@ -283,7 +298,7 @@ namespace etl
       template <typename T>
       const T& get_reference() const
       {
-        ETL_STATIC_ASSERT((etl::is_same<T*, void*>:: value || ((Alignment % etl::alignment_of<T>::value) == 0)), "Incompatible alignment");
+        ETL_STATIC_ASSERT((etl::is_same<T*, void*>::value || ((Alignment % etl::alignment_of<T>::value) == 0)), "Incompatible alignment");
         const T* t = *this;
         return *t;
       }
@@ -292,7 +307,7 @@ namespace etl
       template <typename T>
       T* get_address()
       {
-        ETL_STATIC_ASSERT((etl::is_same<T*, void*>:: value || ((Alignment % etl::alignment_of<T>::value) == 0)), "Incompatible alignment");
+        ETL_STATIC_ASSERT((etl::is_same<T*, void*>::value || ((Alignment % etl::alignment_of<T>::value) == 0)), "Incompatible alignment");
         return reinterpret_cast<T*>(data);
       }
 
@@ -300,7 +315,7 @@ namespace etl
       template <typename T>
       const T* get_address() const
       {
-        ETL_STATIC_ASSERT((etl::is_same<T*, void*>:: value || ((Alignment % etl::alignment_of<T>::value) == 0)), "Incompatible alignment");
+        ETL_STATIC_ASSERT((etl::is_same<T*, void*>::value || ((Alignment % etl::alignment_of<T>::value) == 0)), "Incompatible alignment");
         return reinterpret_cast<const T*>(data);
       }
 
@@ -309,8 +324,9 @@ namespace etl
 #else
       union
       {
-        char data[Length];
-        typename etl::type_with_alignment<Alignment>::type etl_alignment_type; // A POD type that has the same alignment as Alignment.
+        char                                               data[Length];
+        typename etl::type_with_alignment<Alignment>::type etl_alignment_type; // A POD type that has the same alignment
+                                                                               // as Alignment.
       };
 #endif
     };
@@ -334,6 +350,516 @@ namespace etl
   template <size_t Length, typename T>
   using aligned_storage_as_t = typename aligned_storage_as<Length, T>::type;
 #endif
-}
+
+  //***************************************************************************
+  /// Wrapper class that provides a memory area and lets the user create an
+  /// instance of T in this memory at runtime. This class also erases the
+  /// destructor call of T, i.e. if typed_storage goes out of scope, the
+  /// destructor if the wrapped type will not be called. This can be done
+  /// explicitly by calling destroy().
+  /// \tparam T    Type of element stored in this instance of typed_storage.
+  //***************************************************************************
+  template <typename T>
+  class typed_storage
+  {
+  public:
+
+    typedef T        value_type;
+    typedef T&       reference;
+    typedef const T& const_reference;
+    typedef T*       pointer;
+    typedef const T* const_pointer;
+
+    //***************************************************************************
+    // Default constructor
+    //***************************************************************************
+    ETL_CONSTEXPR typed_storage() ETL_NOEXCEPT
+      : valid(false)
+    {
+    }
+
+#if ETL_USING_CPP11
+    //***************************************************************************
+    /// Constructs the instance of T forwarding the given \p args to its
+    /// constructor.
+    //***************************************************************************
+    template <typename... TArgs>
+    typed_storage(TArgs&&... args) ETL_NOEXCEPT_EXPR(ETL_NOT_USING_EXCEPTIONS)
+      : valid(false)
+    {
+      create(etl::forward<TArgs>(args)...);
+    }
+#else
+    //***************************************************************************
+    /// Constructs the instance of T with type T1
+    //***************************************************************************
+    template <typename T1>
+    typed_storage(const T1& t1)
+      : valid(false)
+    {
+      create(t1);
+    }
+
+    //***************************************************************************
+    /// Constructs the instance of T with types T1, T2
+    //***************************************************************************
+    template <typename T1, typename T2>
+    typed_storage(const T1& t1, const T2& t2)
+      : valid(false)
+    {
+      create(t1, t2);
+    }
+
+    //***************************************************************************
+    /// Constructs the instance of T with types T1, T2, T3
+    //***************************************************************************
+    template <typename T1, typename T2, typename T3>
+    typed_storage(const T1& t1, const T2& t2, const T3& t3)
+      : valid(false)
+    {
+      create(t1, t2, t3);
+    }
+
+    //***************************************************************************
+    /// Constructs the instance of T with types T1, T2, T3, T4
+    //***************************************************************************
+    template <typename T1, typename T2, typename T3, typename T4>
+    typed_storage(const T1& t1, const T2& t2, const T3& t3, const T4& t4)
+      : valid(false)
+    {
+      create(t1, t2, t3, t4);
+    }
+#endif
+
+    //***************************************************************************
+    /// Default destructor which will NOT call the destructor of the object
+    /// which was created by calling create().
+    //***************************************************************************
+    ~typed_storage() ETL_NOEXCEPT
+    {
+      // Intentionally empty.
+    }
+
+    //***************************************************************************
+    /// \returns <b>true</b> if object has been constructed using create().
+    /// \returns <b>false</b> otherwise.
+    //***************************************************************************
+    bool has_value() const ETL_NOEXCEPT
+    {
+      return valid;
+    }
+
+#if ETL_USING_CPP11
+    //***************************************************************************
+    /// Constructs the instance of T forwarding the given \p args to its
+    /// constructor. \returns the instance of T which has been constructed in
+    /// the internal byte array.
+    //***************************************************************************
+    template <typename... TArgs>
+    reference create(TArgs&&... args) ETL_NOEXCEPT_EXPR(ETL_NOT_USING_EXCEPTIONS)
+    {
+      ETL_ASSERT(!has_value(), ETL_ERROR(etl::typed_storage_error));
+      pointer p = ::new (&storage.value) value_type(etl::forward<TArgs>(args)...);
+      valid     = true;
+      return *p;
+    }
+#else
+    //***************************************************************************
+    /// Constructs the instance of T with type T1
+    /// \returns the instance of T which has been constructed in the internal
+    /// byte array.
+    //***************************************************************************
+    template <typename T1>
+    reference create(const T1& t1)
+    {
+      ETL_ASSERT(!has_value(), ETL_ERROR(etl::typed_storage_error));
+      pointer p = ::new (&storage.value) value_type(t1);
+      valid     = true;
+      return *p;
+    }
+
+    //***************************************************************************
+    /// Constructs the instance of T with types T1, T2
+    /// \returns the instance of T which has been constructed in the internal
+    /// byte array.
+    //***************************************************************************
+    template <typename T1, typename T2>
+    reference create(const T1& t1, const T2& t2)
+    {
+      ETL_ASSERT(!has_value(), ETL_ERROR(etl::typed_storage_error));
+      pointer p = ::new (&storage.value) value_type(t1, t2);
+      valid     = true;
+      return *p;
+    }
+
+    //***************************************************************************
+    /// Constructs the instance of T with types T1, T2, T3
+    /// \returns the instance of T which has been constructed in the internal
+    /// byte array.
+    //***************************************************************************
+    template <typename T1, typename T2, typename T3>
+    reference create(const T1& t1, const T2& t2, const T3& t3)
+    {
+      ETL_ASSERT(!has_value(), ETL_ERROR(etl::typed_storage_error));
+      pointer p = ::new (&storage.value) value_type(t1, t2, t3);
+      valid     = true;
+      return *p;
+    }
+
+    //***************************************************************************
+    /// Constructs the instance of T with types T1, T2, T3, T4
+    /// \returns the instance of T which has been constructed in the internal
+    /// byte array.
+    //***************************************************************************
+    template <typename T1, typename T2, typename T3, typename T4>
+    reference create(const T1& t1, const T2& t2, const T3& t3, const T4& t4)
+    {
+      ETL_ASSERT(!has_value(), ETL_ERROR(etl::typed_storage_error));
+      pointer p = ::new (&storage.value) value_type(t1, t2, t3, t4);
+      valid     = true;
+      return *p;
+    }
+#endif
+
+    //***************************************************************************
+    /// Calls the destructor of the stored object, if created.
+    //***************************************************************************
+    void destroy() ETL_NOEXCEPT
+    {
+      if (has_value())
+      {
+        storage.value.~T();
+        valid = false;
+      }
+    }
+
+    //***************************************************************************
+    /// \returns a pointer of type T and asserts if has_value() is false.
+    //***************************************************************************
+    pointer operator->() ETL_NOEXCEPT_EXPR(ETL_NOT_USING_EXCEPTIONS)
+    {
+      ETL_ASSERT(has_value(), ETL_ERROR(etl::typed_storage_error));
+
+      return &storage.value;
+    }
+
+    //***************************************************************************
+    /// \returns a const pointer of type T and asserts if has_value() is false.
+    //***************************************************************************
+    const_pointer operator->() const ETL_NOEXCEPT_EXPR(ETL_NOT_USING_EXCEPTIONS)
+    {
+      ETL_ASSERT(has_value(), ETL_ERROR(etl::typed_storage_error));
+
+      return &storage.value;
+    }
+
+    //***************************************************************************
+    /// \returns reference of type T and asserts if has_value() is false.
+    //***************************************************************************
+    reference operator*() ETL_NOEXCEPT_EXPR(ETL_NOT_USING_EXCEPTIONS)
+    {
+      return *operator->();
+    }
+
+    //***************************************************************************
+    /// \returns const_reference of type T and asserts if has_value() is false.
+    //***************************************************************************
+    const_reference operator*() const ETL_NOEXCEPT_EXPR(ETL_NOT_USING_EXCEPTIONS)
+    {
+      return *operator->();
+    }
+
+  private:
+
+    typed_storage(etl::typed_storage<T>&) ETL_DELETE;
+    typed_storage& operator=(etl::typed_storage<T>&) ETL_DELETE;
+
+    struct dummy_t
+    {
+    };
+
+    //*******************************
+    union union_type
+    {
+      ETL_CONSTEXPR union_type() ETL_NOEXCEPT
+        : dummy()
+      {
+      }
+
+      ~union_type() ETL_NOEXCEPT {}
+
+      dummy_t    dummy;
+      value_type value;
+    } storage;
+
+    bool valid;
+  };
+
+  //***************************************************************************
+  /// Wrapper class wraps a supplied memory area and lets the user create an
+  /// instance of T in this memory at runtime. This class also erases the
+  /// destructor call of T, i.e. if typed_storage goes out of scope, the
+  /// destructor if the wrapped type will not be called. This can be done
+  /// explicitly by calling destroy().
+  /// \tparam T    Type of element stored in this instance of typed_storage.
+  //***************************************************************************
+  template <typename T>
+  class typed_storage_ext
+  {
+  public:
+
+    typedef T        value_type;
+    typedef T&       reference;
+    typedef const T& const_reference;
+    typedef T*       pointer;
+    typedef const T* const_pointer;
+
+    template <typename U>
+    friend ETL_CONSTEXPR14 void swap(typed_storage_ext<U>& lhs, typed_storage_ext<U>& rhs) ETL_NOEXCEPT;
+
+    //***************************************************************************
+    /// Constructor.
+    //***************************************************************************
+    typed_storage_ext(void* pbuffer_) ETL_NOEXCEPT_EXPR(ETL_NOT_USING_EXCEPTIONS)
+      : pbuffer(reinterpret_cast<T*>(pbuffer_))
+      , valid(false)
+    {
+      ETL_ASSERT(etl::is_aligned(pbuffer_, etl::alignment_of<T>::value), ETL_ERROR(etl::alignment_error));
+    }
+
+#if ETL_USING_CPP11
+    //***************************************************************************
+    /// Constructs the instance of T forwarding the given \p args to its
+    /// constructor.
+    //***************************************************************************
+    template <typename... TArgs>
+    typed_storage_ext(void* pbuffer_, TArgs&&... args) ETL_NOEXCEPT_EXPR(ETL_NOT_USING_EXCEPTIONS)
+      : pbuffer(reinterpret_cast<T*>(pbuffer_))
+      , valid(false)
+    {
+      ETL_ASSERT(etl::is_aligned(pbuffer_, etl::alignment_of<T>::value), ETL_ERROR(etl::alignment_error));
+      create(etl::forward<TArgs>(args)...);
+    }
+
+    //***************************************************************************
+    /// Move constructor.
+    /// Transfers ownership of the buffer from \p other to this.
+    //***************************************************************************
+    typed_storage_ext(typed_storage_ext<T>&& other) ETL_NOEXCEPT_EXPR(ETL_NOT_USING_EXCEPTIONS)
+      : pbuffer(other.pbuffer)
+      , valid(other.valid)
+    {
+      other.pbuffer = ETL_NULLPTR;
+      other.valid   = false;
+    }
+#else
+    //***************************************************************************
+    /// Constructs the instance of T with type T1
+    //***************************************************************************
+    template <typename T1>
+    typed_storage_ext(void* pbuffer_, const T1& t1)
+      : pbuffer(reinterpret_cast<T*>(pbuffer_))
+      , valid(false)
+    {
+      ETL_ASSERT(etl::is_aligned(pbuffer_, etl::alignment_of<T>::value), ETL_ERROR(etl::alignment_error));
+      create(t1);
+    }
+
+    //***************************************************************************
+    /// Constructs the instance of T with types T1, T2
+    //***************************************************************************
+    template <typename T1, typename T2>
+    typed_storage_ext(void* pbuffer_, const T1& t1, const T2& t2)
+      : pbuffer(reinterpret_cast<T*>(pbuffer_))
+      , valid(false)
+    {
+      ETL_ASSERT(etl::is_aligned(pbuffer_, etl::alignment_of<T>::value), ETL_ERROR(etl::alignment_error));
+      create(t1, t2);
+    }
+
+    //***************************************************************************
+    /// Constructs the instance of T with types T1, T2, T3
+    //***************************************************************************
+    template <typename T1, typename T2, typename T3>
+    typed_storage_ext(void* pbuffer_, const T1& t1, const T2& t2, const T3& t3)
+      : pbuffer(reinterpret_cast<T*>(pbuffer_))
+      , valid(false)
+    {
+      ETL_ASSERT(etl::is_aligned(pbuffer_, etl::alignment_of<T>::value), ETL_ERROR(etl::alignment_error));
+      create(t1, t2, t3);
+    }
+
+    //***************************************************************************
+    /// Constructs the instance of T with types T1, T2, T3, T4
+    //***************************************************************************
+    template <typename T1, typename T2, typename T3, typename T4>
+    typed_storage_ext(void* pbuffer_, const T1& t1, const T2& t2, const T3& t3, const T4& t4)
+      : pbuffer(reinterpret_cast<T*>(pbuffer_))
+      , valid(false)
+    {
+      ETL_ASSERT(etl::is_aligned(pbuffer_, etl::alignment_of<T>::value), ETL_ERROR(etl::alignment_error));
+      create(t1, t2, t3, t4);
+    }
+#endif
+
+    //***************************************************************************
+    /// Default destructor which will NOT call the destructor of the object
+    /// which was created by calling create().
+    //***************************************************************************
+    ~typed_storage_ext() ETL_NOEXCEPT
+    {
+      // Intentionally empty.
+    }
+
+    //***************************************************************************
+    /// \returns <b>true</b> if object has been constructed using create().
+    /// \returns <b>false</b> otherwise.
+    //***************************************************************************
+    bool has_value() const ETL_NOEXCEPT
+    {
+      return valid;
+    }
+
+#if ETL_USING_CPP11
+    //***************************************************************************
+    /// Constructs the instance of T forwarding the given \p args to its
+    /// constructor. \returns the instance of T which has been constructed in
+    /// the external buffer.
+    //***************************************************************************
+    template <typename... TArgs>
+    reference create(TArgs&&... args) ETL_NOEXCEPT_EXPR(ETL_NOT_USING_EXCEPTIONS)
+    {
+      ETL_ASSERT(!has_value(), ETL_ERROR(etl::typed_storage_error));
+      pointer p = ::new (pbuffer) value_type(etl::forward<TArgs>(args)...);
+      valid     = true;
+      return *p;
+    }
+#else
+    //***************************************************************************
+    /// Constructs the instance of T with type T1
+    /// \returns the instance of T which has been constructed in the external
+    /// buffer.
+    //***************************************************************************
+    template <typename T1>
+    reference create(const T1& t1)
+    {
+      ETL_ASSERT(!has_value(), ETL_ERROR(etl::typed_storage_error));
+      pointer p = ::new (pbuffer) value_type(t1);
+      valid     = true;
+      return *p;
+    }
+
+    //***************************************************************************
+    /// Constructs the instance of T with types T1, T2
+    /// \returns the instance of T which has been constructed in the external
+    /// buffer.
+    //***************************************************************************
+    template <typename T1, typename T2>
+    reference create(const T1& t1, const T2& t2)
+    {
+      ETL_ASSERT(!has_value(), ETL_ERROR(etl::typed_storage_error));
+      pointer p = ::new (pbuffer) value_type(t1, t2);
+      valid     = true;
+      return *p;
+    }
+
+    //***************************************************************************
+    /// Constructs the instance of T with types T1, T2, T3
+    /// \returns the instance of T which has been constructed in the external
+    /// buffer.
+    //***************************************************************************
+    template <typename T1, typename T2, typename T3>
+    reference create(const T1& t1, const T2& t2, const T3& t3)
+    {
+      ETL_ASSERT(!has_value(), ETL_ERROR(etl::typed_storage_error));
+      pointer p = ::new (pbuffer) value_type(t1, t2, t3);
+      valid     = true;
+      return *p;
+    }
+
+    //***************************************************************************
+    /// Constructs the instance of T with types T1, T2, T3, T4
+    /// \returns the instance of T which has been constructed in the external
+    /// buffer.
+    //***************************************************************************
+    template <typename T1, typename T2, typename T3, typename T4>
+    reference create(const T1& t1, const T2& t2, const T3& t3, const T4& t4)
+    {
+      ETL_ASSERT(!has_value(), ETL_ERROR(etl::typed_storage_error));
+      pointer p = ::new (pbuffer) value_type(t1, t2, t3, t4);
+      valid     = true;
+      return *p;
+    }
+#endif
+
+    //***************************************************************************
+    /// Calls the destructor of the stored object, if created.
+    //***************************************************************************
+    void destroy() ETL_NOEXCEPT
+    {
+      if (has_value())
+      {
+        pbuffer->~T();
+        valid = false;
+      }
+    }
+
+    //***************************************************************************
+    /// \returns a pointer of type T and asserts if has_value() is false.
+    //***************************************************************************
+    pointer operator->() ETL_NOEXCEPT_EXPR(ETL_NOT_USING_EXCEPTIONS)
+    {
+      ETL_ASSERT(has_value(), ETL_ERROR(etl::typed_storage_error));
+
+      return pbuffer;
+    }
+
+    //***************************************************************************
+    /// \returns a const pointer of type T and asserts if has_value() is false.
+    //***************************************************************************
+    const_pointer operator->() const ETL_NOEXCEPT_EXPR(ETL_NOT_USING_EXCEPTIONS)
+    {
+      ETL_ASSERT(has_value(), ETL_ERROR(etl::typed_storage_error));
+
+      return pbuffer;
+    }
+
+    //***************************************************************************
+    /// \returns reference of type T and asserts if has_value() is false.
+    //***************************************************************************
+    reference operator*() ETL_NOEXCEPT_EXPR(ETL_NOT_USING_EXCEPTIONS)
+    {
+      return *operator->();
+    }
+
+    //***************************************************************************
+    /// \returns const_reference of type T and asserts if has_value() is false.
+    //***************************************************************************
+    const_reference operator*() const ETL_NOEXCEPT_EXPR(ETL_NOT_USING_EXCEPTIONS)
+    {
+      return *operator->();
+    }
+
+  private:
+
+    typed_storage_ext(etl::typed_storage_ext<T>&) ETL_DELETE;
+    typed_storage_ext& operator=(etl::typed_storage_ext<T>&) ETL_DELETE;
+
+    pointer pbuffer;
+    bool    valid;
+  };
+
+  //***************************************************************************
+  /// Swap two etl::typed_storage_ext
+  //***************************************************************************
+  template <typename T>
+  ETL_CONSTEXPR14 void swap(etl::typed_storage_ext<T>& lhs, etl::typed_storage_ext<T>& rhs) ETL_NOEXCEPT
+  {
+    using ETL_OR_STD::swap;
+
+    swap(lhs.pbuffer, rhs.pbuffer);
+    swap(lhs.valid, rhs.valid);
+  }
+} // namespace etl
 
 #endif

include/etl/array_view.h

@@ -32,18 +32,18 @@ SOFTWARE.
 #define ETL_ARRAY_VIEW_INCLUDED
 
 #include "platform.h"
-#include "memory.h"
+#include "algorithm.h"
 #include "array.h"
-#include "iterator.h"
 #include "error_handler.h"
 #include "exception.h"
-#include "nullptr.h"
 #include "hash.h"
-#include "algorithm.h"
+#include "iterator.h"
+#include "memory.h"
+#include "nullptr.h"
 #include "type_traits.h"
 
 #if ETL_USING_STL && ETL_USING_CPP11
-#include <array>
+  #include <array>
 #endif
 
 ///\defgroup array array
@@ -93,6 +93,19 @@ namespace etl
     }
   };
 
+  //***************************************************************************
+  /// The exception thrown when the view is empty.
+  //***************************************************************************
+  class array_view_empty : public array_view_exception
+  {
+  public:
+
+    array_view_empty(string_type file_name_, numeric_type line_number_)
+      : array_view_exception(ETL_ERROR_TEXT("array_view:empty", ETL_ARRAY_VIEW_FILE_ID"C"), file_name_, line_number_)
+    {
+    }
+  };
+
   //***************************************************************************
   /// Array view.
   //***************************************************************************
@@ -101,31 +114,31 @@ namespace etl
   {
   public:
 
-    typedef T        value_type;
-    typedef size_t   size_type;
-    typedef const T& const_reference;
-    typedef const T* const_pointer;
-    typedef const T* const_iterator;
+    typedef T                                            value_type;
+    typedef size_t                                       size_type;
+    typedef const T&                                     const_reference;
+    typedef const T*                                     const_pointer;
+    typedef const T*                                     const_iterator;
     typedef ETL_OR_STD::reverse_iterator<const_iterator> const_reverse_iterator;
 
 #if defined(ETL_ARRAY_VIEW_IS_MUTABLE)
-    typedef T* pointer;
-    typedef T& reference;
-    typedef T* iterator;
+    typedef T*                                     pointer;
+    typedef T&                                     reference;
+    typedef T*                                     iterator;
     typedef ETL_OR_STD::reverse_iterator<iterator> reverse_iterator;
 #else
-    typedef const_pointer   pointer;
-    typedef const_reference reference;
-    typedef const_pointer   iterator;
+    typedef const_pointer          pointer;
+    typedef const_reference        reference;
+    typedef const_pointer          iterator;
     typedef const_reverse_iterator reverse_iterator;
 #endif
 
     //*************************************************************************
     /// Default constructor.
     //*************************************************************************
-    ETL_CONSTEXPR array_view()
-      : mbegin(ETL_NULLPTR),
-        mend(ETL_NULLPTR)
+    ETL_CONSTEXPR array_view() ETL_NOEXCEPT
+      : mbegin(ETL_NULLPTR)
+      , mend(ETL_NULLPTR)
     {
     }
 
@@ -133,8 +146,9 @@ namespace etl
     //*************************************************************************
     /// Construct from etl::array.
     //*************************************************************************
-    template <typename U, size_t N, typename = typename etl::enable_if<etl::is_same<etl::remove_cv_t<T>, etl::remove_cv_t<U>>::value, void>::type>
-    ETL_CONSTEXPR array_view(etl::array<U, N>& a) ETL_NOEXCEPT
+    template < typename U, size_t Size,
+               typename = typename etl::enable_if< etl::is_same<etl::remove_cv_t<T>, etl::remove_cv_t<U>>::value, void>::type>
+    ETL_CONSTEXPR array_view(etl::array<U, Size>& a) ETL_NOEXCEPT
       : mbegin(a.data())
       , mend(a.data() + a.size())
     {
@@ -143,8 +157,9 @@ namespace etl
     //*************************************************************************
     /// Construct from etl::array.
     //*************************************************************************
-    template <typename U, size_t N, typename = typename etl::enable_if<etl::is_same<etl::remove_cv_t<T>, etl::remove_cv_t<U>>::value, void>::type>
-    ETL_CONSTEXPR array_view(const etl::array<U, N>& a) ETL_NOEXCEPT
+    template < typename U, size_t Size,
+               typename = typename etl::enable_if< etl::is_same<etl::remove_cv_t<T>, etl::remove_cv_t<U>>::value, void>::type>
+    ETL_CONSTEXPR array_view(const etl::array<U, Size>& a) ETL_NOEXCEPT
       : mbegin(a.data())
       , mend(a.data() + a.size())
     {
@@ -153,8 +168,10 @@ namespace etl
     //*************************************************************************
     /// Construct from etl::array.
     //*************************************************************************
-    template <typename U, size_t N>
-    ETL_CONSTEXPR array_view(etl::array<U, N>& a, typename etl::enable_if<etl::is_same<typename etl::remove_cv<T>::type, typename etl::remove_cv<U>::type>::value, void>::type* = 0) ETL_NOEXCEPT
+    template <typename U, size_t Size>
+    ETL_CONSTEXPR array_view(
+      etl::array<U, Size>& a,
+      typename etl::enable_if< etl::is_same<typename etl::remove_cv<T>::type, typename etl::remove_cv<U>::type>::value, void>::type* = 0) ETL_NOEXCEPT
       : mbegin(a.data())
       , mend(a.data() + a.size())
     {
@@ -163,8 +180,10 @@ namespace etl
     //*************************************************************************
     /// Construct from etl::array.
     //*************************************************************************
-    template <typename U, size_t N>
-    ETL_CONSTEXPR array_view(const etl::array<U, N>& a, typename etl::enable_if<etl::is_same<typename etl::remove_cv<T>::type, typename etl::remove_cv<U>::type>::value, void>::type* = 0) ETL_NOEXCEPT
+    template <typename U, size_t Size>
+    ETL_CONSTEXPR array_view(
+      const etl::array<U, Size>& a,
+      typename etl::enable_if< etl::is_same<typename etl::remove_cv<T>::type, typename etl::remove_cv<U>::type>::value, void>::type* = 0) ETL_NOEXCEPT
       : mbegin(a.data())
       , mend(a.data() + a.size())
     {
@@ -175,8 +194,9 @@ namespace etl
     //*************************************************************************
     /// Construct from std::array.
     //*************************************************************************
-    template <typename U, size_t N, typename = typename etl::enable_if<etl::is_same<etl::remove_cv_t<T>, etl::remove_cv_t<U>>::value, void>::type>
-    ETL_CONSTEXPR array_view(std::array<U, N>& a) ETL_NOEXCEPT
+    template < typename U, size_t Size,
+               typename = typename etl::enable_if< etl::is_same<etl::remove_cv_t<T>, etl::remove_cv_t<U>>::value, void>::type>
+    ETL_CONSTEXPR array_view(std::array<U, Size>& a) ETL_NOEXCEPT
       : mbegin(a.data())
       , mend(a.data() + a.size())
     {
@@ -185,8 +205,9 @@ namespace etl
     //*************************************************************************
     /// Construct from std::array.
     //*************************************************************************
-    template <typename U, size_t N, typename = typename etl::enable_if<etl::is_same<etl::remove_cv_t<T>, etl::remove_cv_t<U>>::value, void>::type>
-    ETL_CONSTEXPR array_view(const std::array<U, N>& a) ETL_NOEXCEPT
+    template < typename U, size_t Size,
+               typename = typename etl::enable_if< etl::is_same<etl::remove_cv_t<T>, etl::remove_cv_t<U>>::value, void>::type>
+    ETL_CONSTEXPR array_view(const std::array<U, Size>& a) ETL_NOEXCEPT
       : mbegin(a.data())
       , mend(a.data() + a.size())
     {
@@ -198,10 +219,12 @@ namespace etl
     /// Construct from a container or other type that supports
     /// data() and size() member functions.
     //*************************************************************************
-    template <typename TContainer, typename = typename etl::enable_if<!etl::is_pointer<etl::remove_reference_t<TContainer>>::value &&
-                                                                      !etl::is_array<etl::remove_reference_t<TContainer>>::value &&
-                                                                      etl::is_same<etl::remove_cv_t<T>, etl::remove_cv_t<typename etl::remove_reference_t<TContainer>::value_type>>::value, void>::type>
-      ETL_CONSTEXPR array_view(TContainer&& a) ETL_NOEXCEPT
+    template < typename TContainer,
+               typename = typename etl::enable_if<
+                 !etl::is_pointer<etl::remove_reference_t<TContainer>>::value && !etl::is_array<etl::remove_reference_t<TContainer>>::value
+                   && etl::is_same<etl::remove_cv_t<T>, etl::remove_cv_t<typename etl::remove_reference_t< TContainer>::value_type>>::value,
+                 void>::type>
+    ETL_CONSTEXPR array_view(TContainer&& a) ETL_NOEXCEPT
       : mbegin(a.data())
       , mend(a.data() + a.size())
     {
@@ -212,9 +235,12 @@ namespace etl
     /// data() and size() member functions.
     //*************************************************************************
     template <typename TContainer>
-    ETL_CONSTEXPR array_view(TContainer& a, typename etl::enable_if<!etl::is_pointer<typename etl::remove_reference<TContainer>::type>::value &&
-                                                                    !etl::is_array<TContainer>::value &&
-                                                                    etl::is_same<typename etl::remove_cv<T>::type, typename etl::remove_cv<typename etl::remove_reference<TContainer>::type::value_type>::type>::value, void>::type* = 0) ETL_NOEXCEPT
+    ETL_CONSTEXPR array_view(TContainer& a,
+                         typename etl::enable_if<
+                           !etl::is_pointer< typename etl::remove_reference<TContainer>::type>::value && !etl::is_array<TContainer>::value
+                             && etl::is_same< typename etl::remove_cv<T>::type,
+                                              typename etl::remove_cv<typename etl::remove_reference< TContainer>::type::value_type>::type>::value,
+                           void>::type* = 0) ETL_NOEXCEPT
       : mbegin(a.data())
       , mend(a.data() + a.size())
     {
@@ -225,9 +251,12 @@ namespace etl
     /// data() and size() member functions.
     //*************************************************************************
     template <typename TContainer>
-    ETL_CONSTEXPR array_view(const TContainer& a, typename etl::enable_if<!etl::is_pointer<typename etl::remove_reference<TContainer>::type>::value &&
-                                                                          !etl::is_array<TContainer>::value &&
-                                                                          etl::is_same<typename etl::remove_cv<T>::type, typename etl::remove_cv<typename etl::remove_reference<TContainer>::type::value_type>::type>::value, void>::type* = 0) ETL_NOEXCEPT
+    ETL_CONSTEXPR array_view(const TContainer& a,
+                         typename etl::enable_if<
+                           !etl::is_pointer< typename etl::remove_reference<TContainer>::type>::value && !etl::is_array<TContainer>::value
+                             && etl::is_same< typename etl::remove_cv<T>::type,
+                                              typename etl::remove_cv<typename etl::remove_reference< TContainer>::type::value_type>::type>::value,
+                           void>::type* = 0) ETL_NOEXCEPT
       : mbegin(a.data())
       , mend(a.data() + a.size())
     {
@@ -238,78 +267,89 @@ namespace etl
     /// Construct from iterators
     //*************************************************************************
     template <typename TIterator>
-    ETL_CONSTEXPR array_view(const TIterator begin_, const TIterator end_)
-      : mbegin(etl::addressof(*begin_)),
-        mend(etl::addressof(*begin_) + etl::distance(begin_, end_))
+    ETL_CONSTEXPR array_view(const TIterator begin_, const TIterator end_) ETL_NOEXCEPT
+      : mbegin(etl::to_address(begin_))
+      , mend(etl::to_address(begin_) + etl::distance(begin_, end_))
+    {
+    }
+
+    //*************************************************************************
+    /// Construct from iterator and size
+    //*************************************************************************
+    template <typename TIterator, typename TSize>
+    ETL_CONSTEXPR array_view(const TIterator begin_, const TSize size_) ETL_NOEXCEPT
+      : mbegin(etl::to_address(begin_))
+      , mend(etl::to_address(begin_) + size_)
     {
     }
 
     //*************************************************************************
     /// Construct from C array
     //*************************************************************************
-    template <typename TIterator,
-              typename TSize>
-    ETL_CONSTEXPR array_view(const TIterator begin_, const TSize size_)
-      : mbegin(etl::addressof(*begin_)),
-        mend(etl::addressof(*begin_) + size_)
-    {
-    }
-
-    //*************************************************************************
-    /// Construct from C array
-    //*************************************************************************
-    template<size_t Array_Size>
-    ETL_CONSTEXPR array_view(T(&begin_)[Array_Size])
-      : mbegin(begin_),
-        mend(begin_ + Array_Size)
+    template <size_t Array_Size>
+    ETL_CONSTEXPR array_view(T (&begin_)[Array_Size]) ETL_NOEXCEPT
+      : mbegin(begin_)
+      , mend(begin_ + Array_Size)
     {
     }
 
     //*************************************************************************
     /// Copy constructor
     //*************************************************************************
-    ETL_CONSTEXPR array_view(const array_view& other)
-      : mbegin(other.mbegin),
-        mend(other.mend)
+    ETL_CONSTEXPR array_view(const array_view& other) ETL_NOEXCEPT
+      : mbegin(other.mbegin)
+      , mend(other.mend)
     {
     }
 
     //*************************************************************************
     /// Returns a reference to the first element.
+    /// If asserts or exceptions are enabled, throws an etl::array_view_empty if
+    /// the view is empty.
     //*************************************************************************
     reference front()
     {
+      ETL_ASSERT_CHECK_EXTRA(!empty(), ETL_ERROR(array_view_empty));
       return *mbegin;
     }
 
     //*************************************************************************
     /// Returns a const reference to the first element.
+    /// If asserts or exceptions are enabled, throws an etl::array_view_empty if
+    /// the view is empty.
     //*************************************************************************
     const_reference front() const
     {
+      ETL_ASSERT_CHECK_EXTRA(!empty(), ETL_ERROR(array_view_empty));
       return *mbegin;
     }
 
     //*************************************************************************
     /// Returns a reference to the last element.
+    /// If asserts or exceptions are enabled, throws an etl::array_view_empty if
+    /// the view is empty.
     //*************************************************************************
     reference back()
     {
+      ETL_ASSERT_CHECK_EXTRA(!empty(), ETL_ERROR(array_view_empty));
       return *(mend - 1);
     }
 
     //*************************************************************************
     /// Returns a const reference to the last element.
+    /// If asserts or exceptions are enabled, throws an etl::array_view_empty if
+    /// the view is empty.
     //*************************************************************************
     const_reference back() const
     {
+      ETL_ASSERT_CHECK_EXTRA(!empty(), ETL_ERROR(array_view_empty));
       return *(mend - 1);
     }
 
     //*************************************************************************
     /// Returns a pointer to the first element of the internal storage.
     //*************************************************************************
-    pointer data()
+    pointer data() ETL_NOEXCEPT
     {
       return mbegin;
     }
@@ -317,7 +357,7 @@ namespace etl
     //*************************************************************************
     /// Returns a const pointer to the first element of the internal storage.
     //*************************************************************************
-    const_pointer data() const
+    const_pointer data() const ETL_NOEXCEPT
     {
       return mbegin;
     }
@@ -325,7 +365,7 @@ namespace etl
     //*************************************************************************
     /// Returns an iterator to the beginning of the array.
     //*************************************************************************
-    iterator begin()
+    iterator begin() ETL_NOEXCEPT
     {
       return mbegin;
     }
@@ -333,7 +373,7 @@ namespace etl
     //*************************************************************************
     /// Returns a const iterator to the beginning of the array.
     //*************************************************************************
-    const_iterator begin() const
+    const_iterator begin() const ETL_NOEXCEPT
     {
       return mbegin;
     }
@@ -341,7 +381,7 @@ namespace etl
     //*************************************************************************
     /// Returns a const iterator to the beginning of the array.
     //*************************************************************************
-    const_iterator cbegin() const
+    const_iterator cbegin() const ETL_NOEXCEPT
     {
       return mbegin;
     }
@@ -349,7 +389,7 @@ namespace etl
     //*************************************************************************
     /// Returns an iterator to the end of the array.
     //*************************************************************************
-    iterator end()
+    iterator end() ETL_NOEXCEPT
     {
       return mend;
     }
@@ -357,7 +397,7 @@ namespace etl
     //*************************************************************************
     /// Returns a const iterator to the end of the array.
     //*************************************************************************
-    const_iterator end() const
+    const_iterator end() const ETL_NOEXCEPT
     {
       return mend;
     }
@@ -365,7 +405,7 @@ namespace etl
     //*************************************************************************
     // Returns a const iterator to the end of the array.
     //*************************************************************************
-    const_iterator cend() const
+    const_iterator cend() const ETL_NOEXCEPT
     {
       return mend;
     }
@@ -373,7 +413,7 @@ namespace etl
     //*************************************************************************
     // Returns an reverse iterator to the reverse beginning of the array.
     //*************************************************************************
-    reverse_iterator rbegin()
+    reverse_iterator rbegin() ETL_NOEXCEPT
     {
       return reverse_iterator(mend);
     }
@@ -381,7 +421,7 @@ namespace etl
     //*************************************************************************
     /// Returns a const reverse iterator to the reverse beginning of the array.
     //*************************************************************************
-    const_reverse_iterator rbegin() const
+    const_reverse_iterator rbegin() const ETL_NOEXCEPT
     {
       return const_reverse_iterator(mend);
     }
@@ -389,7 +429,7 @@ namespace etl
     //*************************************************************************
     /// Returns a const reverse iterator to the reverse beginning of the array.
     //*************************************************************************
-    const_reverse_iterator crbegin() const
+    const_reverse_iterator crbegin() const ETL_NOEXCEPT
     {
       return const_reverse_iterator(mend);
     }
@@ -397,7 +437,7 @@ namespace etl
     //*************************************************************************
     /// Returns a reverse iterator to the end of the array.
     //*************************************************************************
-    reverse_iterator rend()
+    reverse_iterator rend() ETL_NOEXCEPT
     {
       return reverse_iterator(mbegin);
     }
@@ -405,7 +445,7 @@ namespace etl
     //*************************************************************************
     /// Returns a const reverse iterator to the end of the array.
     //*************************************************************************
-    const_reverse_iterator rend() const
+    const_reverse_iterator rend() const ETL_NOEXCEPT
     {
       return const_reverse_iterator(mbegin);
     }
@@ -413,7 +453,7 @@ namespace etl
     //*************************************************************************
     /// Returns a const reverse iterator to the end of the array.
     //*************************************************************************
-    const_reverse_iterator crend() const
+    const_reverse_iterator crend() const ETL_NOEXCEPT
     {
       return const_reverse_iterator(mbegin);
     }
@@ -421,7 +461,7 @@ namespace etl
     //*************************************************************************
     /// Returns <b>true</b> if the array size is zero.
     //*************************************************************************
-    ETL_CONSTEXPR bool empty() const
+    ETL_CONSTEXPR bool empty() const ETL_NOEXCEPT
     {
       return (mbegin == mend);
     }
@@ -429,7 +469,7 @@ namespace etl
     //*************************************************************************
     /// Returns the size of the array.
     //*************************************************************************
-    ETL_CONSTEXPR size_t size() const
+    ETL_CONSTEXPR size_t size() const ETL_NOEXCEPT
     {
       return static_cast<size_t>(mend - mbegin);
     }
@@ -437,7 +477,7 @@ namespace etl
     //*************************************************************************
     /// Returns the maximum possible size of the array.
     //*************************************************************************
-    ETL_CONSTEXPR size_t max_size() const
+    ETL_CONSTEXPR size_t max_size() const ETL_NOEXCEPT
     {
       return size();
     }
@@ -445,7 +485,7 @@ namespace etl
     //*************************************************************************
     /// Assign from a view.
     //*************************************************************************
-    array_view& operator=(const array_view& other)
+    array_view& operator=(const array_view& other) ETL_NOEXCEPT
     {
       mbegin = other.mbegin;
       mend   = other.mend;
@@ -458,36 +498,43 @@ namespace etl
     template <typename TIterator>
     void assign(const TIterator begin_, const TIterator end_)
     {
-      mbegin = etl::addressof(*begin_);
-      mend   = etl::addressof(*begin_) + etl::distance(begin_, end_);
+      mbegin = etl::to_address(begin_);
+      mend   = etl::to_address(begin_) + etl::distance(begin_, end_);
     }
 
     //*************************************************************************
     /// Assign from iterator and size.
     //*************************************************************************
-    template <typename TIterator,
-              typename TSize>
+    template <typename TIterator, typename TSize>
     void assign(const TIterator begin_, const TSize size_)
     {
-      mbegin = etl::addressof(*begin_);
-      mend   = etl::addressof(*begin_) + size_;
+      mbegin = etl::to_address(begin_);
+      mend   = etl::to_address(begin_) + size_;
     }
 
 #if defined(ETL_ARRAY_VIEW_IS_MUTABLE)
     //*************************************************************************
     /// Returns a reference to the indexed value.
+    /// If asserts or exceptions are enabled, throws an etl::array_view_bounds
+    /// if the index is out of bounds.
     //*************************************************************************
-    reference operator[](const size_t i)
+    reference operator[](const size_t i) ETL_NOEXCEPT_EXPR(ETL_NOT_USING_EXCEPTIONS || ETL_NOT_CHECKING_INDEX_OPERATOR)
     {
+      ETL_ASSERT_CHECK_INDEX_OPERATOR(i < size(), ETL_ERROR(array_view_bounds));
+
       return mbegin[i];
     }
 #endif
 
     //*************************************************************************
     /// Returns a const reference to the indexed value.
+    /// If asserts or exceptions are enabled, throws an etl::array_view_bounds
+    /// if the index is out of bounds.
     //*************************************************************************
-    const_reference operator[](const size_t i) const
+    const_reference operator[](const size_t i) const ETL_NOEXCEPT_EXPR(ETL_NOT_USING_EXCEPTIONS || ETL_NOT_CHECKING_INDEX_OPERATOR)
     {
+      ETL_ASSERT_CHECK_INDEX_OPERATOR(i < size(), ETL_ERROR(array_view_bounds));
+
       return mbegin[i];
     }
 
@@ -516,7 +563,7 @@ namespace etl
     //*************************************************************************
     /// Swaps with another array_view.
     //*************************************************************************
-    void swap(array_view& other)
+    void swap(array_view& other) ETL_NOEXCEPT
     {
       using ETL_OR_STD::swap; // Allow ADL
 
@@ -527,23 +574,23 @@ namespace etl
     //*************************************************************************
     /// Shrinks the view by moving its start forward.
     //*************************************************************************
-    void remove_prefix(const size_type n)
+    void remove_prefix(const size_type n) ETL_NOEXCEPT
     {
-		if (n < size())
-			mbegin += n;
-		else
-			mbegin = mend;
+      if (n < size())
+        mbegin += n;
+      else
+        mbegin = mend;
     }
 
     //*************************************************************************
     /// Shrinks the view by moving its end backward.
     //*************************************************************************
-    void remove_suffix(const size_type n)
+    void remove_suffix(const size_type n) ETL_NOEXCEPT
     {
-		if (n < size())
-			mend -= n;
-		else
-			mend = mbegin;
+      if (n < size())
+        mend -= n;
+      else
+        mend = mbegin;
     }
 
     //*************************************************************************
@@ -557,16 +604,15 @@ namespace etl
     //*************************************************************************
     /// Equality for array views.
     //*************************************************************************
-    friend bool operator == (const array_view<T>& lhs, const array_view<T>& rhs)
+    friend bool operator==(const array_view<T>& lhs, const array_view<T>& rhs)
     {
-      return (lhs.size() == rhs.size()) &&
-             etl::equal(lhs.begin(), lhs.end(), rhs.begin());
+      return (lhs.size() == rhs.size()) && etl::equal(lhs.begin(), lhs.end(), rhs.begin());
     }
 
     //*************************************************************************
     /// Inequality for array views.
     //*************************************************************************
-    friend bool operator != (const array_view<T>& lhs, const array_view<T>& rhs)
+    friend bool operator!=(const array_view<T>& lhs, const array_view<T>& rhs)
     {
       return !(lhs == rhs);
     }
@@ -574,7 +620,7 @@ namespace etl
     //*************************************************************************
     /// Less-than for array views.
     //*************************************************************************
-    friend bool operator < (const array_view<T>& lhs, const array_view<T>& rhs)
+    friend bool operator<(const array_view<T>& lhs, const array_view<T>& rhs)
     {
       return etl::lexicographical_compare(lhs.begin(), lhs.end(), rhs.begin(), rhs.end());
     }
@@ -582,7 +628,7 @@ namespace etl
     //*************************************************************************
     /// Greater-than for array views.
     //*************************************************************************
-    friend bool operator > (const array_view<T>& lhs, const array_view<T>& rhs)
+    friend bool operator>(const array_view<T>& lhs, const array_view<T>& rhs)
     {
       return rhs < lhs;
     }
@@ -590,7 +636,7 @@ namespace etl
     //*************************************************************************
     /// Less-than-equal for array views.
     //*************************************************************************
-    friend bool operator <= (const array_view<T>& lhs, const array_view<T>& rhs)
+    friend bool operator<=(const array_view<T>& lhs, const array_view<T>& rhs)
     {
       return !(lhs > rhs);
     }
@@ -598,7 +644,7 @@ namespace etl
     //*************************************************************************
     /// Greater-than-equal for array views.
     //*************************************************************************
-    friend bool operator >= (const array_view<T>& lhs, const array_view<T>& rhs)
+    friend bool operator>=(const array_view<T>& lhs, const array_view<T>& rhs)
     {
       return !(lhs < rhs);
     }
@@ -614,18 +660,14 @@ namespace etl
   //*************************************************************************
 #if ETL_USING_CPP17
   template <typename TArray>
-  array_view(TArray& a) 
-    -> array_view<typename TArray::value_type>;
+  array_view(TArray& a) -> array_view<typename TArray::value_type>;
 
   template <typename TIterator>
-  array_view(const TIterator begin_, const TIterator end_)
-    -> array_view<etl::remove_pointer_t<TIterator>>;
+  array_view(const TIterator begin_, const TIterator end_) -> array_view<etl::remove_pointer_t<TIterator>>;
 
-  template <typename TIterator,
-            typename TSize>
-  array_view(const TIterator begin_, const TSize size_)
-    -> array_view<etl::remove_pointer_t<TIterator>>;
-#endif  
+  template <typename TIterator, typename TSize>
+  array_view(const TIterator begin_, const TSize size_) -> array_view<etl::remove_pointer_t<TIterator>>;
+#endif
 
   //*************************************************************************
   /// Hash function.
@@ -641,13 +683,13 @@ namespace etl
     }
   };
 #endif
-}
+} // namespace etl
 
 //*************************************************************************
 /// Swaps the values.
 //*************************************************************************
 template <typename T>
-void swap(etl::array_view<T>& lhs, etl::array_view<T>& rhs)
+void swap(etl::array_view<T>& lhs, etl::array_view<T>& rhs) ETL_NOEXCEPT
 {
   lhs.swap(rhs);
 }

include/etl/array_wrapper.h

@@ -32,12 +32,12 @@ SOFTWARE.
 #define ETL_ARRAY_WRAPPER_INCLUDED
 
 #include "platform.h"
-#include "iterator.h"
+#include "algorithm.h"
 #include "error_handler.h"
 #include "exception.h"
 #include "hash.h"
+#include "iterator.h"
 #include "parameter_type.h"
-#include "algorithm.h"
 
 ///\defgroup array array
 /// A wrapper for arrays
@@ -75,19 +75,19 @@ namespace etl
   //***************************************************************************
   /// Array wrapper.
   //***************************************************************************
-  template <typename T, size_t SIZE_, T(&ARRAY_)[SIZE_]>
+  template <typename T, size_t SIZE_, T (&ARRAY_)[SIZE_]>
   class array_wrapper
   {
   public:
 
-    typedef T                                     value_type;
-    typedef size_t                                size_type;
-    typedef T&                                    reference;
-    typedef const T&                              const_reference;
-    typedef T*                                    pointer;
-    typedef const T*                              const_pointer;
-    typedef T*                                    iterator;
-    typedef const T*                              const_iterator;
+    typedef T                                            value_type;
+    typedef size_t                                       size_type;
+    typedef T&                                           reference;
+    typedef const T&                                     const_reference;
+    typedef T*                                           pointer;
+    typedef const T*                                     const_pointer;
+    typedef T*                                           iterator;
+    typedef const T*                                     const_iterator;
     typedef ETL_OR_STD::reverse_iterator<iterator>       reverse_iterator;
     typedef ETL_OR_STD::reverse_iterator<const_iterator> const_reverse_iterator;
 
@@ -141,7 +141,7 @@ namespace etl
     //*************************************************************************
     /// Returns a pointer to the first element of the internal storage.
     //*************************************************************************
-    pointer data()
+    pointer data() ETL_NOEXCEPT
     {
       return &ARRAY_[BEGIN];
     }
@@ -149,7 +149,7 @@ namespace etl
     //*************************************************************************
     /// Returns a const pointer to the first element of the internal storage.
     //*************************************************************************
-    ETL_CONSTEXPR const_pointer data() const
+    ETL_CONSTEXPR const_pointer data() const ETL_NOEXCEPT
     {
       return &ARRAY_[BEGIN];
     }
@@ -157,7 +157,7 @@ namespace etl
     //*************************************************************************
     /// Returns an iterator to the beginning of the array.
     //*************************************************************************
-    iterator begin()
+    iterator begin() ETL_NOEXCEPT
     {
       return &ARRAY_[BEGIN];
     }
@@ -165,7 +165,7 @@ namespace etl
     //*************************************************************************
     /// Returns a const iterator to the beginning of the array.
     //*************************************************************************
-    ETL_CONSTEXPR const_iterator begin() const
+    ETL_CONSTEXPR const_iterator begin() const ETL_NOEXCEPT
     {
       return &ARRAY_[BEGIN];
     }
@@ -173,7 +173,7 @@ namespace etl
     //*************************************************************************
     /// Returns a const iterator to the beginning of the array.
     //*************************************************************************
-    ETL_CONSTEXPR const_iterator cbegin() const
+    ETL_CONSTEXPR const_iterator cbegin() const ETL_NOEXCEPT
     {
       return &ARRAY_[BEGIN];
     }
@@ -181,7 +181,7 @@ namespace etl
     //*************************************************************************
     /// Returns an iterator to the end of the array.
     //*************************************************************************
-    iterator end()
+    iterator end() ETL_NOEXCEPT
     {
       return &ARRAY_[END];
     }
@@ -189,7 +189,7 @@ namespace etl
     //*************************************************************************
     /// Returns a const iterator to the end of the array.
     //*************************************************************************
-    ETL_CONSTEXPR const_iterator end() const
+    ETL_CONSTEXPR const_iterator end() const ETL_NOEXCEPT
     {
       return &ARRAY_[END];
     }
@@ -197,7 +197,7 @@ namespace etl
     //*************************************************************************
     // Returns a const iterator to the end of the array.
     //*************************************************************************
-    ETL_CONSTEXPR const_iterator cend() const
+    ETL_CONSTEXPR const_iterator cend() const ETL_NOEXCEPT
     {
       return &ARRAY_[END];
     }
@@ -205,7 +205,7 @@ namespace etl
     //*************************************************************************
     // Returns an reverse iterator to the reverse beginning of the array.
     //*************************************************************************
-    reverse_iterator rbegin()
+    reverse_iterator rbegin() ETL_NOEXCEPT
     {
       return reverse_iterator(&ARRAY_[END]);
     }
@@ -213,7 +213,7 @@ namespace etl
     //*************************************************************************
     /// Returns a const reverse iterator to the reverse beginning of the array.
     //*************************************************************************
-    ETL_CONSTEXPR const_reverse_iterator rbegin() const
+    ETL_CONSTEXPR const_reverse_iterator rbegin() const ETL_NOEXCEPT
     {
       return const_reverse_iterator(&ARRAY_[END]);
     }
@@ -221,7 +221,7 @@ namespace etl
     //*************************************************************************
     /// Returns a const reverse iterator to the reverse beginning of the array.
     //*************************************************************************
-    ETL_CONSTEXPR const_reverse_iterator crbegin() const
+    ETL_CONSTEXPR const_reverse_iterator crbegin() const ETL_NOEXCEPT
     {
       return const_reverse_iterator(&ARRAY_[END]);
     }
@@ -229,7 +229,7 @@ namespace etl
     //*************************************************************************
     /// Returns a reverse iterator to the end of the array.
     //*************************************************************************
-    reverse_iterator rend()
+    reverse_iterator rend() ETL_NOEXCEPT
     {
       return reverse_iterator(&ARRAY_[BEGIN]);
     }
@@ -237,7 +237,7 @@ namespace etl
     //*************************************************************************
     /// Returns a const reverse iterator to the end of the array.
     //*************************************************************************
-    ETL_CONSTEXPR const_reverse_iterator rend() const
+    ETL_CONSTEXPR const_reverse_iterator rend() const ETL_NOEXCEPT
     {
       return const_reverse_iterator(&ARRAY_[BEGIN]);
     }
@@ -245,7 +245,7 @@ namespace etl
     //*************************************************************************
     /// Returns a const reverse iterator to the end of the array.
     //*************************************************************************
-    ETL_CONSTEXPR const_reverse_iterator crend() const
+    ETL_CONSTEXPR const_reverse_iterator crend() const ETL_NOEXCEPT
     {
       return const_reverse_iterator(&ARRAY_[BEGIN]);
     }
@@ -253,7 +253,7 @@ namespace etl
     //*************************************************************************
     /// Returns the size of the array.
     //*************************************************************************
-    ETL_CONSTEXPR size_t size() const
+    ETL_CONSTEXPR size_t size() const ETL_NOEXCEPT
     {
       return SIZE;
     }
@@ -261,25 +261,36 @@ namespace etl
     //*************************************************************************
     /// Returns the maximum possible size of the array.
     //*************************************************************************
-    ETL_CONSTEXPR size_t max_size() const
+    ETL_CONSTEXPR size_t max_size() const ETL_NOEXCEPT
     {
       return MAX_SIZE;
     }
 
     //*************************************************************************
     /// Returns a reference to the indexed value.
+    /// If asserts or exceptions are enabled, throws an
+    /// etl::array_wrapper_bounds if the index is out of bounds.
     //*************************************************************************
-    reference operator[](size_t i)
+    reference operator[](size_t i) ETL_NOEXCEPT_EXPR(ETL_NOT_USING_EXCEPTIONS || ETL_NOT_CHECKING_INDEX_OPERATOR)
     {
+      ETL_ASSERT_CHECK_INDEX_OPERATOR(i < SIZE, ETL_ERROR(etl::array_wrapper_bounds));
       return ARRAY_[i];
     }
 
     //*************************************************************************
     /// Returns a const reference to the indexed value.
+    /// If asserts or exceptions are enabled, throws an
+    /// etl::array_wrapper_bounds if the index is out of bounds.
     //*************************************************************************
-    ETL_CONSTEXPR const_reference operator[](size_t i) const
+    ETL_CONSTEXPR const_reference operator[](size_t i) const ETL_NOEXCEPT_EXPR(ETL_NOT_USING_EXCEPTIONS || ETL_NOT_CHECKING_INDEX_OPERATOR)
     {
+      // Throwing from c++11 constexpr requires special syntax
+#if ETL_USING_CPP11 && ETL_NOT_USING_CPP14 && ETL_USING_EXCEPTIONS && ETL_CHECKING_INDEX_OPERATOR
+      return i < SIZE ? ARRAY_[i] : throw(ETL_ERROR(etl::array_wrapper_bounds));
+#else
+      ETL_ASSERT_CHECK_INDEX_OPERATOR(i < SIZE, ETL_ERROR(etl::array_wrapper_bounds));
       return ARRAY_[i];
+#endif
     }
 
     //*************************************************************************
@@ -311,9 +322,8 @@ namespace etl
     //*************************************************************************
     /// Swaps the contents of arrays.
     //*************************************************************************
-    template <typename U, U(&ARRAYOTHER)[SIZE_]>
-    typename etl::enable_if<etl::is_same<T, U>::value, void>::type
-     swap(etl::array_wrapper<U, SIZE_, ARRAYOTHER>& other)
+    template <typename U, U (&ARRAYOTHER)[SIZE_]>
+    typename etl::enable_if<etl::is_same<T, U>::value, void>::type swap(etl::array_wrapper<U, SIZE_, ARRAYOTHER>& other)
     {
       using ETL_OR_STD::swap; // Allow ADL
 
@@ -327,9 +337,8 @@ namespace etl
   //*************************************************************************
   /// Equality for array wrappers.
   //*************************************************************************
-  template <typename TL, typename TR, size_t SIZEL, size_t SIZER, TL(&ARRAYL)[SIZEL], TR(&ARRAYR)[SIZER]>
-  bool operator == (const etl::array_wrapper<TL, SIZEL, ARRAYL>& lhs,
-                    const etl::array_wrapper<TR, SIZER, ARRAYR>& rhs)
+  template <typename TL, typename TR, size_t SIZEL, size_t SIZER, TL (&ARRAYL)[SIZEL], TR (&ARRAYR)[SIZER]>
+  bool operator==(const etl::array_wrapper<TL, SIZEL, ARRAYL>& lhs, const etl::array_wrapper<TR, SIZER, ARRAYR>& rhs)
   {
     return (SIZEL == SIZER) && etl::equal(lhs.begin(), lhs.end(), rhs.begin());
   }
@@ -337,9 +346,8 @@ namespace etl
   //*************************************************************************
   /// Inequality for array wrapper.
   //*************************************************************************
-  template <typename TL, typename TR, size_t SIZEL, size_t SIZER, TL(&ARRAYL)[SIZEL], TR(&ARRAYR)[SIZER]>
-  bool operator != (const etl::array_wrapper<TL, SIZEL, ARRAYL>& lhs,
-                    const etl::array_wrapper<TR, SIZER, ARRAYR>& rhs)
+  template <typename TL, typename TR, size_t SIZEL, size_t SIZER, TL (&ARRAYL)[SIZEL], TR (&ARRAYR)[SIZER]>
+  bool operator!=(const etl::array_wrapper<TL, SIZEL, ARRAYL>& lhs, const etl::array_wrapper<TR, SIZER, ARRAYR>& rhs)
   {
     return !(lhs == rhs);
   }
@@ -347,9 +355,8 @@ namespace etl
   //*************************************************************************
   /// Less-than for array wrapper.
   //*************************************************************************
-  template <typename TL, typename TR, size_t SIZEL, size_t SIZER, TL(&ARRAYL)[SIZEL], TR(&ARRAYR)[SIZER]>
-  bool operator < (const etl::array_wrapper<TL, SIZEL, ARRAYL>& lhs,
-                   const etl::array_wrapper<TR, SIZER, ARRAYR>& rhs)
+  template <typename TL, typename TR, size_t SIZEL, size_t SIZER, TL (&ARRAYL)[SIZEL], TR (&ARRAYR)[SIZER]>
+  bool operator<(const etl::array_wrapper<TL, SIZEL, ARRAYL>& lhs, const etl::array_wrapper<TR, SIZER, ARRAYR>& rhs)
   {
     return etl::lexicographical_compare(lhs.begin(), lhs.end(), rhs.begin(), rhs.end());
   }
@@ -357,9 +364,8 @@ namespace etl
   //*************************************************************************
   /// Greater-than for array wrapper.
   //*************************************************************************
-  template <typename TL, typename TR, size_t SIZEL, size_t SIZER, TL(&ARRAYL)[SIZEL], TR(&ARRAYR)[SIZER]>
-  bool operator > (const etl::array_wrapper<TL, SIZEL, ARRAYL>& lhs,
-                   const etl::array_wrapper<TR, SIZER, ARRAYR>& rhs)
+  template <typename TL, typename TR, size_t SIZEL, size_t SIZER, TL (&ARRAYL)[SIZEL], TR (&ARRAYR)[SIZER]>
+  bool operator>(const etl::array_wrapper<TL, SIZEL, ARRAYL>& lhs, const etl::array_wrapper<TR, SIZER, ARRAYR>& rhs)
   {
     return rhs < lhs;
   }
@@ -367,9 +373,8 @@ namespace etl
   //*************************************************************************
   /// Less-than-equal for array wrapper.
   //*************************************************************************
-  template <typename TL, typename TR, size_t SIZEL, size_t SIZER, TL(&ARRAYL)[SIZEL], TR(&ARRAYR)[SIZER]>
-  bool operator <= (const etl::array_wrapper<TL, SIZEL, ARRAYL>& lhs,
-                    const etl::array_wrapper<TR, SIZER, ARRAYR>& rhs)
+  template <typename TL, typename TR, size_t SIZEL, size_t SIZER, TL (&ARRAYL)[SIZEL], TR (&ARRAYR)[SIZER]>
+  bool operator<=(const etl::array_wrapper<TL, SIZEL, ARRAYL>& lhs, const etl::array_wrapper<TR, SIZER, ARRAYR>& rhs)
   {
     return !(lhs > rhs);
   }
@@ -377,9 +382,8 @@ namespace etl
   //*************************************************************************
   /// Greater-than-equal for array wrapper.
   //*************************************************************************
-  template <typename TL, typename TR, size_t SIZEL, size_t SIZER, TL(&ARRAYL)[SIZEL], TR(&ARRAYR)[SIZER]>
-  bool operator >= (const etl::array_wrapper<TL, SIZEL, ARRAYL>& lhs,
-                    const etl::array_wrapper<TR, SIZER, ARRAYR>& rhs)
+  template <typename TL, typename TR, size_t SIZEL, size_t SIZER, TL (&ARRAYL)[SIZEL], TR (&ARRAYR)[SIZER]>
+  bool operator>=(const etl::array_wrapper<TL, SIZEL, ARRAYL>& lhs, const etl::array_wrapper<TR, SIZER, ARRAYR>& rhs)
   {
     return !(lhs < rhs);
   }
@@ -388,7 +392,7 @@ namespace etl
   /// Hash function.
   //*************************************************************************
 #if ETL_USING_8BIT_TYPES
-  template <typename T, size_t SIZE, T(&ARRAY)[SIZE]>
+  template <typename T, size_t SIZE, T (&ARRAY)[SIZE]>
   struct hash<etl::array_wrapper<T, SIZE, ARRAY> >
   {
     size_t operator()(const etl::array_wrapper<T, SIZE, ARRAY>& aw) const
@@ -400,19 +404,17 @@ namespace etl
     }
   };
 #endif
-}
+} // namespace etl
 
 //*************************************************************************
 /// Swap.
 //*************************************************************************
-template <typename T, size_t SIZE, T(&ARRAYL)[SIZE], T(&ARRAYR)[SIZE]>
-void swap(etl::array_wrapper<T, SIZE, ARRAYL>& lhs,
-          etl::array_wrapper<T, SIZE, ARRAYR>& rhs)
+template <typename T, size_t SIZE, T (&ARRAYL)[SIZE], T (&ARRAYR)[SIZE]>
+void swap(etl::array_wrapper<T, SIZE, ARRAYL>& lhs, etl::array_wrapper<T, SIZE, ARRAYR>& rhs)
 {
   lhs.swap(rhs);
 }
 
-#define ETL_ARRAY_WRAPPER(arraytype, arrayobject)  etl::array_wrapper<arraytype, ETL_ARRAY_SIZE(arrayobject), arrayobject>
+#define ETL_ARRAY_WRAPPER(arraytype, arrayobject) etl::array_wrapper<arraytype, ETL_ARRAY_SIZE(arrayobject), arrayobject>
 
 #endif
-

include/etl/atomic.h

@@ -32,7 +32,7 @@ SOFTWARE.
 #include "platform.h"
 
 #if ETL_HAS_ATOMIC
-  #if (ETL_USING_CPP11 && (ETL_USING_STL || defined(ETL_IN_UNIT_TEST))) 
+  #if (ETL_USING_CPP11 && (ETL_USING_STL || defined(ETL_IN_UNIT_TEST)))
     #include "atomic/atomic_std.h"
   #elif defined(ETL_COMPILER_ARM5)
     #include "atomic/atomic_arm.h"

include/etl/atomic/atomic_std.h

@@ -30,8 +30,8 @@ SOFTWARE.
 #define ETL_ATOMIC_STD_INCLUDED
 
 #include "../platform.h"
-#include "../nullptr.h"
 #include "../char_traits.h"
+#include "../nullptr.h"
 
 #include <atomic>
 #include <stdint.h>
@@ -55,39 +55,39 @@ 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    = 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>;
 #if ETL_HAS_NATIVE_CHAR8_T
   using atomic_char8_t = std::atomic<char8_t>;
 #endif
 #if ETL_HAS_NATIVE_CHAR16_T
-  using atomic_char16_t       = std::atomic<char16_t>;
+  using atomic_char16_t = std::atomic<char16_t>;
 #endif
 #if ETL_HAS_NATIVE_CHAR32_T
-  using atomic_char32_t       = std::atomic<char32_t>;
+  using atomic_char32_t = std::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 = std::atomic<uint8_t>;
+  using atomic_int8_t  = std::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 = 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>;
 #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 = std::atomic<uint64_t>;
+  using atomic_int64_t  = std::atomic<int64_t>;
 #endif
   using atomic_int_least8_t   = std::atomic<int_least8_t>;
   using atomic_uint_least8_t  = std::atomic<uint_least8_t>;
@@ -99,22 +99,22 @@ namespace etl
   using atomic_int_least64_t  = std::atomic<int_least64_t>;
   using atomic_uint_least64_t = std::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   = 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>;
 #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  = std::atomic<int_fast64_t>;
+  using atomic_uint_fast64_t = std::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  = 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>;
+} // namespace etl
 
 #endif

include/etl/base64.h

@@ -1,13 +1,11 @@
-//*************************************************************************
-///Decode from Base64 from and to pointer/length
-//*************************************************************************///\file
+///\file
 
 /******************************************************************************
 The MIT License(MIT)
 Embedded Template Library.
 https://github.com/ETLCPP/etl
 https://www.etlcpp.com
-Copyright(c) 2023 John Wellbelove
+Copyright(c) 2024 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
@@ -28,23 +26,30 @@ SOFTWARE.
 #ifndef ETL_BASE64_INCLUDED
 #define ETL_BASE64_INCLUDED
 
-#include "etl/platform.h"
-#include "etl/span.h"
-#include "etl/static_assert.h"
-#include "etl/error_handler.h"
-#include "etl/exception.h"
-#include "etl/type_traits.h"
-#include "etl/binary.h"
-#include "etl/algorithm.h"
-#include "etl/integral_limits.h"
-#include "etl/iterator.h"
-#include "etl/string.h"
+#include "platform.h"
+#include "enum_type.h"
+#include "error_handler.h"
+#include "exception.h"
+#include "integral_limits.h"
+#include "static_assert.h"
+#include "type_traits.h"
 
 #include <stdint.h>
 
-#if ETL_USING_STL
-  #include <string>
-#endif
+/**************************************************************************************************************************************************************************
+ * See https://en.wikipedia.org/wiki/Base64
+ *
+ * Encoding	                                                Encoding characters
+ *Separate encoding of lines Decoding non-encoding characters 62nd	63rd	Pad
+ *Separators	Length	                        Checksum RFC 1421 : Base64 for
+ *Privacy - Enhanced Mail(deprecated)   +    /    = mandatory 	CR + LF	    64,
+ *or lower for the last line	No No RFC 2045 : Base64 transfer encoding for MIME
+ *+    /    = mandatory 	CR + LF	    At most 76	No Discarded RFC 2152 : Base64
+ *for UTF - 7                               +    /    No	         No No RFC
+ *3501 : Base64 encoding for IMAP mailbox names           +    ,    No
+ *No No RFC 4648 : base64(standard)[a] +    /    = optional 	 No No RFC 4648 :
+ *base64url(URL - and filename - safe standard)    -    _    = optional   No No
+ **************************************************************************************************************************************************************************/
 
 namespace etl
 {
@@ -62,7 +67,7 @@ namespace etl
   };
 
   //***************************************************************************
-  /// Memory misalignment exception.
+  /// buffer overflow exception.
   //***************************************************************************
   class base64_overflow : public base64_exception
   {
@@ -74,450 +79,134 @@ namespace etl
     }
   };
 
-  //*************************************************************************
-  /// Codec for Base64
-  //*************************************************************************
+  //***************************************************************************
+  /// Illegal character exception.
+  //***************************************************************************
+  class base64_invalid_data : public base64_exception
+  {
+  public:
+
+    base64_invalid_data(string_type file_name_, numeric_type line_number_)
+      : base64_exception(ETL_ERROR_TEXT("base64:invalid data", ETL_BASE64_FILE_ID"B"), file_name_, line_number_)
+    {
+    }
+  };
+
+  //***************************************************************************
+  /// Invalid decode input length exception.
+  //***************************************************************************
+  class base64_invalid_decode_input_length : public base64_exception
+  {
+  public:
+
+    base64_invalid_decode_input_length(string_type file_name_, numeric_type line_number_)
+      : base64_exception(ETL_ERROR_TEXT("base64:invalid decode input length", ETL_BASE64_FILE_ID"C"), file_name_, line_number_)
+    {
+    }
+  };
+
+  //***************************************************************************
+  /// Common Base64 definitions
+  //***************************************************************************
   class base64
   {
   public:
 
-    //*************************************************************************
-    /// Encode to Base64 from and to pointer/length
-    //*************************************************************************
-    template <typename T>
-    ETL_CONSTEXPR14
-    static 
-    typename etl::enable_if<etl::is_integral<T>::value && (etl::integral_limits<T>::bits == 8U), size_t>::type 
-      encode(const T* input, size_t input_length, char* output, size_t output_length)
+    struct Encoding
     {
-      if (input_length == 0U)
+      enum enum_type
       {
-        return 0;
-      }
+        // RFC_1421, // Not implemented
+        // RFC_2045, // Not implemented
+        RFC_2152,
+        RFC_3501,
+        RFC_4648,
+        RFC_4648_PADDING,
+        RFC_4648_URL,
+        RFC_4648_URL_PADDING,
+      };
 
-      // Figure out if the output buffer is large enough.
-      size_t required_output_length = encode_size(input_length);
-
-      ETL_ASSERT_OR_RETURN_VALUE(output_length >= required_output_length, ETL_ERROR(base64_overflow), 0U);
-
-      const T* p_in     = input;
-      const T* p_in_end = input + input_length;
-
-      char* p_out     = output;
-      char* p_out_end = output + required_output_length;
-
-      int next_sextet = First_Sextet;
-
-      // Step through the input buffer, creating the output sextets.
-      while (p_in != p_in_end)
-      {
-        T c = *p_in;
-        char  index = 0;
-
-        switch (next_sextet)
-        {
-          //**************************
-          case First_Sextet:
-          {
-            index = static_cast<char>((*p_in & b11111100) >> 2);
-            next_sextet = Second_Sextet;
-            break;
-          }
-
-          //**************************
-          case Second_Sextet:
-          {
-            index = static_cast<char>((c & b00000011) << 4);
-            ++p_in;
-
-            // Next byte valid?
-            if (p_in != p_in_end)
-            {
-              index = index | ((*p_in & b11110000) >> 4);
-            }
-            next_sextet = Third_Sextet;
-            break;
-          }
-
-          //**************************
-          case Third_Sextet:
-          {
-            index = (c & b00001111) << 2;
-            ++p_in;
-
-            // Next byte valid?
-            if (p_in != p_in_end)
-            {
-              index = index | static_cast<char>((*p_in & b11000000) >> 6);
-            }
-            next_sextet = Fourth_Sextet;
-            break;
-          }
-
-          //**************************
-          case Fourth_Sextet:
-          {
-            index = static_cast<char>(c & b00111111);
-            ++p_in;
-            next_sextet = First_Sextet;
-            break;
-          }
-
-          //**************************
-          default:
-          {
-            // Should never get here.
-            assert(false);
-            break;
-          }
-        }
-
-        *p_out = get_sextet_from_index(index);
-        ++p_out;
-      }
-
-      // Pad out the end of the output buffer.
-      while (p_out != p_out_end)
-      {
-        *p_out++ = padding();
-      }
-
-      return static_cast<size_t>(etl::distance(output, p_out));
-    }
-
-    //*************************************************************************
-    /// Encode to Base64 from and to pointer/pointer
-    //*************************************************************************
-    template <typename T>
-    ETL_CONSTEXPR14
-      static
-      typename etl::enable_if<etl::is_integral<T>::value && (etl::integral_limits<T>::bits == 8U), size_t>::type
-      encode(const T* input_begin, const T* input_end, char* output_begin, char* output_end)
-    {
-      return encode(input_begin, static_cast<size_t>(etl::distance(input_begin, input_end)),
-        output_begin, static_cast<size_t>(etl::distance(output_begin, output_end)));
-    }
-
-    //*************************************************************************
-    /// Encode to Base64 from and to span/span
-    //*************************************************************************
-    template <typename T, size_t Length1, size_t Length2>
-    ETL_CONSTEXPR14
-    static
-    typename etl::enable_if<etl::is_integral<T>::value && (etl::integral_limits<T>::bits == 8U), size_t>::type
-      encode(const etl::span<const T, Length1>& input_span,
-             const etl::span<char, Length2>&    output_span)
-    {
-      return encode(input_span.begin(),  input_span.size(),
-                    output_span.begin(), output_span.size());
-    }
-
-    //*************************************************************************
-    /// Encode to Base64 from pointer/length to etl::istring
-    //*************************************************************************
-    template <typename T>
-    ETL_CONSTEXPR14
-    static
-    typename etl::enable_if<etl::is_integral<T>::value && (etl::integral_limits<T>::bits == 8U), size_t>::type
-      encode(const T* input_begin, size_t input_length,
-             etl::istring& output)
-    {
-      output.resize(etl::base64::encode_size(input_length));
-
-      return encode(input_begin,   input_length,
-                    output.data(), output.size());
-    }
-
-    //*************************************************************************
-    /// Encode to Base64 from pointer/pointer to etl::istring
-    //*************************************************************************
-    template <typename T>
-    ETL_CONSTEXPR14
-    static
-    typename etl::enable_if<etl::is_integral<T>::value && (etl::integral_limits<T>::bits == 8U), size_t>::type
-      encode(const T* input_begin, const T* input_end,
-             etl::istring& output)
-    {
-      output.resize(etl::base64::encode_size(etl::distance(input_begin, input_end)));
-
-      return encode(input_begin,   static_cast<size_t>(etl::distance(input_begin, input_end)),
-                    output.data(), output.size());
-    }
-
-    //*************************************************************************
-    /// Encode to Base64 from span to etl::istring
-    //*************************************************************************
-    template <typename T, size_t Length1>
-    ETL_CONSTEXPR14
-    static
-    typename etl::enable_if<etl::is_integral<T>::value && (etl::integral_limits<T>::bits == 8U), size_t>::type
-      encode(const etl::span<const T, Length1>& input_span,
-             etl::istring& output)
-    {
-      output.resize(etl::base64::encode_size(Length1));
-
-      return encode(input_span.begin(), input_span.size(),
-                    output.data(),      output.size());
-    }
-
-    //*************************************************************************
-    /// Calculates the buffer size required to encode to Base64
-    //*************************************************************************
-    ETL_NODISCARD
-    ETL_CONSTEXPR14
-    static
-    size_t encode_size(size_t input_length)
-    {
-      size_t required_output_length = (input_length * 8U) / 6U;
-
-      if ((input_length % 3U) != 0U)
-      {
-        while ((required_output_length % 4U) != 0)
-        {
-          ++required_output_length;
-        }
-      }
-
-      return required_output_length;
-    }
-
-    //*************************************************************************
-    /// Decode from Base64 from and to pointer/length
-    //*************************************************************************
-    template <typename T>
-    ETL_CONSTEXPR14
-    static
-    typename etl::enable_if<etl::is_integral<T>::value && (etl::integral_limits<T>::bits == 8U), size_t>::type 
-      decode(const char* input, size_t input_length, T* output, size_t output_length)
-    {
-      if (input_length == 0)
-      {
-        return 0;
-      }
-
-      // Figure out if the output buffer is large enough.
-      size_t required_output_length = etl::base64::decode_size(input, input_length);
-
-      ETL_ASSERT_OR_RETURN_VALUE(output_length >= required_output_length, ETL_ERROR(base64_overflow), 0U);
-
-      const char* p_in     = input;
-      const char* p_in_end = input + input_length;
-
-      T* p_out = output;
-
-      T c = 0;
-      int next_sextet = First_Sextet;
-
-      // Step through the input buffer, creating the output binary.
-      while (p_in != p_in_end)
-      {
-        char sextet = *p_in++; // Get the sextet as a T.
-
-        if (sextet == padding())
-        {
-          break;
-        }
-
-        char index = get_index_from_sextet(sextet);
-
-        switch (next_sextet)
-        {
-          //**************************
-          case First_Sextet:
-          {
-            c = (index & b00111111) << 2;
-            next_sextet = Second_Sextet;
-            break;
-          }
-
-          //**************************
-          case Second_Sextet:
-          {
-            c |= (index & b00110000) >> 4;
-            *p_out++ = static_cast<T>(c);
-            c = (index & b00001111) << 4;
-            next_sextet = Third_Sextet;
-            break;
-          }
-
-          //**************************
-          case Third_Sextet:
-          {
-            c |= (index & b00111100) >> 2;
-            *p_out++ = static_cast<T>(c);
-            c = (index & b00000011) << 6;
-            next_sextet = Fourth_Sextet;
-            break;
-          }
-
-          //**************************
-          case Fourth_Sextet:
-          {
-            c |= (index & b00111111);
-            *p_out++ = static_cast<T>(c);
-            next_sextet = First_Sextet;
-            break;
-          }
-
-          //**************************
-          default:
-          {
-            // Should never get here.
-            assert(false);
-            break;
-          }
-        }
-      }
-
-      return static_cast<size_t>(etl::distance(output, p_out));
-    }
-
-    //*************************************************************************
-    /// Decode from Base64 from and to pointer/pointer
-    //*************************************************************************
-    template <typename T>
-    ETL_CONSTEXPR14
-    static
-    typename etl::enable_if<etl::is_integral<T>::value && (etl::integral_limits<T>::bits == 8U), size_t>::type
-      decode(const char* input_begin, const char* input_end, T* output_begin, T* output_end)
-    {
-      return decode(input_begin,  static_cast<size_t>(etl::distance(input_begin,  input_end)),
-                    output_begin, static_cast<size_t>(etl::distance(output_begin, output_end)));
-    }
-
-    //*************************************************************************
-    /// Decode from Base64 from and to span/span
-    //*************************************************************************
-    template <typename T, size_t Length1, size_t Length2>
-    ETL_CONSTEXPR14
-      static
-      typename etl::enable_if<etl::is_integral<T>::value && (etl::integral_limits<T>::bits == 8U), size_t>::type
-      decode(const etl::span<const char, Length1>& input_span,
-      const etl::span<T, Length2>& output_span)
-    {
-      return decode(input_span.begin(), input_span.size(),
-        output_span.begin(), output_span.size());
-    }
-
-    //*************************************************************************
-    /// Calculates the buffer size required to decode from Base64
-    //*************************************************************************
-    ETL_NODISCARD
-    ETL_CONSTEXPR14
-    static size_t decode_size(const char* input, size_t input_length)
-    {
-      if (input_length == 0U)
-      {
-        return 0U;
-      }
-
-      // Figure out the minimum output buffer size.
-      size_t length = static_cast<size_t>(etl::distance(input, etl::find(input, input + input_length, padding())) - 1);
-      size_t required_output_length = length - (length / 4U);
-
-      return required_output_length;
-    }
-
-  private:
-
-    //*************************************************************************
-    /// Sextet index id.
-    enum
-    {
-      First_Sextet,
-      Second_Sextet,
-      Third_Sextet,
-      Fourth_Sextet
+      ETL_DECLARE_ENUM_TYPE(Encoding, int)
+      // ETL_ENUM_TYPE(RFC_1421, "RFC_1421") // Not implemented
+      // ETL_ENUM_TYPE(RFC_2045, "RFC_2045") // Not implemented
+      ETL_ENUM_TYPE(RFC_2152,             "RFC_2152")
+      ETL_ENUM_TYPE(RFC_3501,             "RFC_3501")
+      ETL_ENUM_TYPE(RFC_4648,             "RFC_4648")
+      ETL_ENUM_TYPE(RFC_4648_PADDING,     "RFC_4648_PADDING")
+      ETL_ENUM_TYPE(RFC_4648_URL,         "RFC_4648_URL")
+      ETL_ENUM_TYPE(RFC_4648_URL_PADDING, "RFC_4648_URL_PADDING")
+      ETL_END_ENUM_TYPE
     };
 
-    // Sextets
-    // 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H',
-    // 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P',
-    // 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X',
-    // 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f',
-    // 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n',
-    // 'o', 'p', 'q', 'r', 's', 't', 'u', 'v',
-    // 'w', 'x', 'y', 'z', '0', '1', '2', '3',
-    // '4', '5', '6', '7', '8', '9', '+', '/'
-
-    //*************************************************************************
-    // Translates an index into a sextet
-    //*************************************************************************
-    ETL_CONSTEXPR14 static char get_sextet_from_index(char index)
+    struct Padding
     {
-      if ((index >= 0) && (index < 26))
+      enum enum_type
       {
-        return 'A' + index;
-      }
-      else if ((index >= 26) && (index < 52))
+        No_Padding  = 0,
+        Use_Padding = 1
+      };
+
+      ETL_DECLARE_ENUM_TYPE(Padding, bool)
+      ETL_ENUM_TYPE(No_Padding,  "No_Padding")
+      ETL_ENUM_TYPE(Use_Padding, "Use_Padding")
+      ETL_END_ENUM_TYPE
+    };
+
+    struct Non_Coding_Characters
+    {
+      enum enum_type
       {
-        index -= 26;
-        return 'a' + index;
-      }
-      else if ((index >= 52) && (index < 62))
-      {
-        index -= 52;
-        return '0' + index;
-      }
-      else if (index == 62)
-      {
-        return '+';
-      }
-      else if (index == 63)
-      {
-        return '/';
-      }
-      else
-      {
-        // Should never get here.
-        assert(false);
-        return padding();
-      }
+        Ignore = 0,
+        Reject = 1
+      };
+
+      ETL_DECLARE_ENUM_TYPE(Non_Coding_Characters, bool)
+      ETL_ENUM_TYPE(Ignore, "Ignore")
+      ETL_ENUM_TYPE(Reject, "Reject")
+      ETL_END_ENUM_TYPE
+    };
+
+    enum
+    {
+      Invalid_Data           = etl::integral_limits<int>::max,
+      Min_Encode_Buffer_Size = 4,
+      Min_Decode_Buffer_Size = 3
+    };
+
+  protected:
+
+    ETL_CONSTEXPR14 base64(const char* encoder_table_, bool use_padding_)
+      : encoder_table(encoder_table_)
+      , use_padding(use_padding_)
+    {
     }
 
     //*************************************************************************
-    // Translates a sextet into an index 
+    // Character set for RFC-1421, RFC-2045, RFC-2152 and RFC-4648
     //*************************************************************************
-    ETL_CONSTEXPR14 static char get_index_from_sextet(char sextet)
+    static ETL_CONSTEXPR14 const char* character_set_1()
     {
-      if ((sextet >= 'A') && (sextet <= 'Z'))
-      {
-        return sextet - 'A';
-      }
-      else if ((sextet >= 'a') && (sextet <= 'z'))
-      {
-        return sextet - 'a' + 26;
-      }
-      else if ((sextet >= '0') && (sextet <= '9'))
-      {
-        return sextet - '0' + 52;
-      }
-      else if (sextet == '+')
-      {
-        return 62;
-      }
-      else if (sextet == '/')
-      {
-        return 63;
-      }
-      else
-      {
-        // Should never get here.
-        assert(false);
-        return 0;
-      }
+      return "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
     }
 
     //*************************************************************************
-    /// Gets the padding character
+    // Character set for RFC-4648-URL
     //*************************************************************************
-    ETL_NODISCARD
-    ETL_CONSTEXPR14
-    static char padding()
+    static ETL_CONSTEXPR14 const char* character_set_2()
     {
-      return '=';
+      return "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
     }
+
+    //*************************************************************************
+    // Character set for RFC-3501-URL
+    //*************************************************************************
+    static ETL_CONSTEXPR14 const char* character_set_3()
+    {
+      return "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+,";
+    }
+
+    const char* encoder_table;
+    const bool  use_padding;
   };
-}
-
+} // namespace etl
 #endif

include/etl/base64_decoder.h

@@ -0,0 +1,764 @@
+//*************************************************************************
+/// Decode from Base64 from and to pointer/length
+//*************************************************************************///\file
+
+/******************************************************************************
+The MIT License(MIT)
+Embedded Template Library.
+https://github.com/ETLCPP/etl
+https://www.etlcpp.com
+Copyright(c) 2024 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.
+******************************************************************************/
+
+#ifndef ETL_BASE64_DECODER_INCLUDED
+#define ETL_BASE64_DECODER_INCLUDED
+
+#include "platform.h"
+#include "algorithm.h"
+#include "binary.h"
+#include "delegate.h"
+#include "enum_type.h"
+#include "error_handler.h"
+#include "integral_limits.h"
+#include "iterator.h"
+#include "span.h"
+#include "static_assert.h"
+#include "type_traits.h"
+
+#include "base64.h"
+
+#include <stdint.h>
+
+#if ETL_USING_STL
+  #include <iterator>
+#endif
+
+#define ETL_IS_8_BIT_INTEGRAL(Type) \
+  (etl::is_integral<typename etl::remove_cv<Type>::type>::value && (etl::integral_limits<typename etl::remove_cv<Type>::type>::bits == 8U))
+
+#define ETL_IS_ITERATOR_TYPE_8_BIT_INTEGRAL(Type)                                                            \
+  (etl::is_integral< typename etl::iterator_traits< typename etl::remove_cv<Type>::type>::value_type>::value \
+   && (etl::integral_limits< typename etl::iterator_traits< typename etl::remove_cv<Type>::type>::value_type>::bits == 8U))
+
+namespace etl
+{
+  //*************************************************************************
+  /// Base64 Decoder
+  //*************************************************************************
+  class ibase64_decoder : public base64
+  {
+  public:
+
+    typedef etl::span<const unsigned char>        span_type;
+    typedef etl::delegate<void(const span_type&)> callback_type;
+
+    //*************************************************************************
+    /// Decode to Base64
+    //*************************************************************************
+    template <typename T>
+    ETL_CONSTEXPR14 bool decode(T value)
+    {
+      ETL_STATIC_ASSERT(ETL_IS_8_BIT_INTEGRAL(T), "Input type must be an 8 bit integral");
+
+      push_to_input_buffer(value);
+
+      if (input_buffer_is_full())
+      {
+        if (decode_block())
+        {
+          if (callback.is_valid())
+          {
+            if (output_buffer_is_full())
+            {
+              callback(span());
+              reset_output_buffer();
+            }
+          }
+        }
+
+        reset_input_buffer();
+      }
+
+      return !error();
+    }
+
+    //*************************************************************************
+    /// Decode from Base64
+    //*************************************************************************
+    template <typename TInputIterator>
+    ETL_CONSTEXPR14 bool decode(TInputIterator input_begin, TInputIterator input_end)
+    {
+      ETL_STATIC_ASSERT(ETL_IS_ITERATOR_TYPE_8_BIT_INTEGRAL(TInputIterator), "Input type must be an 8 bit integral");
+
+      while (input_begin != input_end)
+      {
+        if (!decode(*input_begin++))
+        {
+          return false;
+        }
+      }
+
+      return true;
+    }
+
+    //*************************************************************************
+    /// Decode from Base64
+    //*************************************************************************
+    template <typename TInputIterator>
+    ETL_CONSTEXPR14 bool decode(TInputIterator input_begin, size_t input_length)
+    {
+      ETL_STATIC_ASSERT(ETL_IS_ITERATOR_TYPE_8_BIT_INTEGRAL(TInputIterator), "Input type must be an 8 bit integral");
+
+      while (input_length-- != 0)
+      {
+        if (!decode(*input_begin++))
+        {
+          return false;
+        }
+      }
+
+      return true;
+    }
+
+    //*************************************************************************
+    /// Decode from Base64
+    //*************************************************************************
+    template <typename TInputIterator>
+    ETL_CONSTEXPR14 bool decode_final(TInputIterator input_begin, TInputIterator input_end)
+    {
+      return decode(input_begin, input_end) && flush();
+    }
+
+    //*************************************************************************
+    /// Decode from Base64
+    //*************************************************************************
+    template <typename TInputIterator>
+    ETL_CONSTEXPR14 bool decode_final(TInputIterator input_begin, size_t input_length)
+    {
+      return decode(input_begin, input_length) && flush();
+    }
+
+    //*************************************************************************
+    /// Flush any remaining data to the output.
+    //*************************************************************************
+    ETL_CONSTEXPR14 bool flush()
+    {
+      // Encode any remaining input data.
+      bool success = decode_block();
+
+      reset_input_buffer();
+
+      if (success)
+      {
+        if (callback.is_valid())
+        {
+          // Send any remaining data.
+          if (size() != 0)
+          {
+            callback(span());
+          }
+
+          // Indicate this was the final block.
+          callback(span_type());
+
+          reset_output_buffer();
+        }
+      }
+
+      padding_received = false;
+
+      return success;
+    }
+
+    //*************************************************************************
+    /// Reset the encoder.
+    //*************************************************************************
+    ETL_CONSTEXPR14 void restart()
+    {
+      reset_input_buffer();
+      reset_output_buffer();
+      overflow_detected     = false;
+      invalid_data_detected = false;
+      padding_received      = false;
+    }
+
+    //*************************************************************************
+    /// Returns the beginning of the output buffer.
+    //*************************************************************************
+    ETL_NODISCARD ETL_CONSTEXPR14 const unsigned char* begin() const
+    {
+      return p_output_buffer;
+    }
+
+    //*************************************************************************
+    /// This only returns a useful value if a callback has not been set or
+    /// called.
+    //*************************************************************************
+    ETL_NODISCARD ETL_CONSTEXPR14 const unsigned char* end() const
+    {
+      return p_output_buffer + output_buffer_length;
+    }
+
+    //*************************************************************************
+    /// Returns the beginning of the output buffer.
+    //*************************************************************************
+    ETL_NODISCARD ETL_CONSTEXPR14 const unsigned char* cbegin() const
+    {
+      return p_output_buffer;
+    }
+
+    //*************************************************************************
+    /// This only returns a useful value if a callback has not been set or
+    /// called.
+    //*************************************************************************
+    ETL_NODISCARD ETL_CONSTEXPR14 const unsigned char* cend() const
+    {
+      return p_output_buffer + output_buffer_length;
+    }
+
+    //*************************************************************************
+    /// Returns the size of the output buffer.
+    /// This only returns a useful value if a callback has not been set or
+    /// called.
+    //*************************************************************************
+    ETL_NODISCARD ETL_CONSTEXPR14 size_t size() const
+    {
+      return output_buffer_length;
+    }
+
+    //*************************************************************************
+    /// Returns the maximum size of the output buffer.
+    //*************************************************************************
+    ETL_NODISCARD ETL_CONSTEXPR14 size_t buffer_size() const
+    {
+      return output_buffer_max_size;
+    }
+
+    //*************************************************************************
+    /// Get a span of the output data.
+    /// This only returns a useful span if a callback has not been set or
+    /// called.
+    //*************************************************************************
+    ETL_NODISCARD ETL_CONSTEXPR14 span_type span() const
+    {
+      return span_type(begin(), end());
+    }
+
+    //*************************************************************************
+    /// Returns true if the output buffer has overflowed
+    //*************************************************************************
+    ETL_NODISCARD ETL_CONSTEXPR14 bool overflow() const
+    {
+      return overflow_detected;
+    }
+
+    //*************************************************************************
+    /// Returns true if an invalid character was detected.
+    //*************************************************************************
+    ETL_NODISCARD ETL_CONSTEXPR14 bool invalid_data() const
+    {
+      return invalid_data_detected;
+    }
+
+    //*************************************************************************
+    /// Returns true if an error was detected.
+    //*************************************************************************
+    ETL_NODISCARD ETL_CONSTEXPR14 bool error() const
+    {
+      return overflow() || invalid_data();
+    }
+
+  protected:
+
+    //*************************************************************************
+    /// Constructor
+    //*************************************************************************
+    ETL_CONSTEXPR14 ibase64_decoder(const char* encoder_table_, bool use_padding_, unsigned char* p_output_buffer_, size_t ouput_buffer_max_size_,
+                              callback_type callback_)
+      : base64(encoder_table_, use_padding_)
+      , input_buffer()
+      , input_buffer_length(0)
+      , p_output_buffer(p_output_buffer_)
+      , output_buffer_length(0)
+      , output_buffer_max_size(ouput_buffer_max_size_)
+      , callback(callback_)
+      , overflow_detected(false)
+      , invalid_data_detected(false)
+      , padding_received(false)
+    {
+    }
+
+    //*************************************************************************
+    /// Calculates the minimum buffer size required to decode from Base64
+    //*************************************************************************
+    ETL_NODISCARD
+    static ETL_CONSTEXPR14 size_t decoded_size_from_valid_input_length(size_t input_length)
+    {
+      return input_length - (input_length / 4U);
+    }
+
+  private:
+
+    //*************************************************************************
+    // Translates a sextet into an index
+    //*************************************************************************
+    template <typename T>
+    ETL_CONSTEXPR14 uint32_t get_index_from_sextet(T sextet)
+    {
+      const char* encoder_table_end = encoder_table + 64;
+      const char* p_sextet          = etl::find(encoder_table, encoder_table_end, static_cast<char>(sextet));
+
+      if (p_sextet != encoder_table_end)
+      {
+        return static_cast<uint32_t>(etl::distance(encoder_table, p_sextet));
+      }
+      else
+      {
+        invalid_data_detected = true;
+        return 0;
+      }
+    }
+
+    //*************************************************************************
+    /// Gets the padding character
+    //*************************************************************************
+    template <typename T>
+    ETL_NODISCARD
+    static
+      ETL_CONSTEXPR14 T padding()
+    {
+      return static_cast<T>('=');
+    }
+
+    //*************************************************************************
+    /// Decode one block of data.
+    //*************************************************************************
+    ETL_CONSTEXPR14 bool decode_block()
+    {
+      switch (input_buffer_length)
+      {
+        // Only triggered on call to flush().
+        case 2:
+          {
+            uint32_t sextets = (get_index_from_sextet(input_buffer[0]) << 6);
+            sextets          = sextets | (get_index_from_sextet(input_buffer[1]));
+            push_to_output_buffer((sextets >> 4) & 0xFF);
+            break;
+          }
+
+        // Only triggered on call to flush().
+        case 3:
+          {
+            uint32_t sextets = (get_index_from_sextet(input_buffer[0]) << 12);
+            sextets          = sextets | (get_index_from_sextet(input_buffer[1]) << 6);
+            sextets          = sextets | (get_index_from_sextet(input_buffer[2]));
+            push_to_output_buffer((sextets >> 10) & 0xFF);
+            push_to_output_buffer((sextets >> 2) & 0xFF);
+            break;
+          }
+
+        // Only triggered on call to decode().
+        case 4:
+          {
+            // Read in four sextets
+            uint32_t sextets = (get_index_from_sextet(input_buffer[0]) << 18);
+            sextets          = sextets | (get_index_from_sextet(input_buffer[1]) << 12);
+            sextets          = sextets | (get_index_from_sextet(input_buffer[2]) << 6);
+            sextets          = sextets | (get_index_from_sextet(input_buffer[3]));
+
+            // Write out three octets
+            push_to_output_buffer((sextets >> 16) & 0xFF);
+            push_to_output_buffer((sextets >> 8) & 0xFF);
+            push_to_output_buffer((sextets >> 0) & 0xFF);
+            break;
+          }
+
+        default:
+          {
+            break;
+          }
+      }
+
+      ETL_ASSERT(!invalid_data_detected, ETL_ERROR(etl::base64_invalid_data));
+      ETL_ASSERT(!overflow_detected, ETL_ERROR(etl::base64_overflow));
+
+      return (!invalid_data_detected && !overflow_detected);
+    }
+
+    //*************************************************************************
+    // Push to the output buffer.
+    //*************************************************************************
+    ETL_CONSTEXPR14 void push_to_output_buffer(unsigned char c)
+    {
+      if (output_buffer_length < output_buffer_max_size)
+      {
+        p_output_buffer[output_buffer_length++] = c;
+      }
+      else
+      {
+        overflow_detected = true;
+      }
+    }
+
+    //*************************************************************************
+    //
+    //*************************************************************************
+    ETL_CONSTEXPR14 bool output_buffer_is_full() const
+    {
+      return output_buffer_length == output_buffer_max_size;
+    }
+
+    //*************************************************************************
+    //
+    //*************************************************************************
+    ETL_CONSTEXPR14 bool output_buffer_is_empty() const
+    {
+      return output_buffer_length == 0;
+    }
+
+    //*************************************************************************
+    //
+    //*************************************************************************
+    ETL_CONSTEXPR14 void reset_output_buffer()
+    {
+      output_buffer_length = 0;
+    }
+
+    //*************************************************************************
+    // Push to the input buffer.
+    //*************************************************************************
+    template <typename T>
+    ETL_CONSTEXPR14 void push_to_input_buffer(T value)
+    {
+      if (value == padding<T>())
+      {
+        padding_received = true;
+      }
+      else
+      {
+        if (padding_received)
+        {
+          ETL_ASSERT_FAIL(ETL_ERROR(etl::base64_invalid_data));
+          invalid_data_detected = true;
+        }
+        else
+        {
+          input_buffer[input_buffer_length++] = static_cast<char>(value);
+        }
+      }
+    }
+
+    //*************************************************************************
+    //
+    //*************************************************************************
+    ETL_CONSTEXPR14 bool input_buffer_is_full() const
+    {
+      return input_buffer_length == 4U;
+    }
+
+    //*************************************************************************
+    //
+    //*************************************************************************
+    ETL_CONSTEXPR14 void reset_input_buffer()
+    {
+      input_buffer_length = 0;
+    }
+
+    char   input_buffer[4];
+    size_t input_buffer_length;
+
+    unsigned char* p_output_buffer;
+    size_t         output_buffer_length;
+    const size_t   output_buffer_max_size;
+
+    callback_type callback;
+
+    bool overflow_detected;
+    bool invalid_data_detected;
+    bool padding_received;
+  };
+
+  //*************************************************************************
+  /// Base64 RFC-2152 Decoder
+  //*************************************************************************
+  template <size_t Buffer_Size = etl::base64::Min_Decode_Buffer_Size>
+  class base64_rfc2152_decoder : public ibase64_decoder
+  {
+  public:
+
+    ETL_STATIC_ASSERT((Buffer_Size >= etl::base64::Min_Decode_Buffer_Size), "Buffer size must be greater than etl::base64::Min_Decode_Buffer_Size");
+
+    //*************************************************************************
+    /// Base64 RFC-2152 constructor.
+    //*************************************************************************
+    ETL_CONSTEXPR14 base64_rfc2152_decoder()
+      : ibase64_decoder(etl::base64::character_set_1(), etl::base64::Padding::No_Padding, output_buffer, Buffer_Size, callback_type())
+      , output_buffer()
+    {
+    }
+
+    //*************************************************************************
+    /// Base64 RFC-2152 constructor.
+    //*************************************************************************
+    ETL_CONSTEXPR14 base64_rfc2152_decoder(callback_type callback_)
+      : ibase64_decoder(etl::base64::character_set_1(), etl::base64::Padding::No_Padding, output_buffer, Buffer_Size, callback_)
+      , output_buffer()
+    {
+    }
+
+    //*************************************************************************
+    /// Calculate the required output encode buffer size.
+    //*************************************************************************
+    ETL_NODISCARD
+    static
+      ETL_CONSTEXPR14 size_t safe_output_buffer_size(size_t input_length)
+    {
+      return ibase64_decoder::decoded_size_from_valid_input_length(input_length);
+    }
+
+  private:
+
+    /// The internal output buffer.
+    unsigned char output_buffer[Buffer_Size];
+  };
+
+  //*************************************************************************
+  /// Base64 RFC-3501 Decoder
+  //*************************************************************************
+  template <size_t Buffer_Size = etl::base64::Min_Decode_Buffer_Size>
+  class base64_rfc3501_decoder : public ibase64_decoder
+  {
+  public:
+
+    ETL_STATIC_ASSERT((Buffer_Size >= etl::base64::Min_Decode_Buffer_Size), "Buffer size must be greater than etl::base64::Min_Decode_Buffer_Size");
+
+    //*************************************************************************
+    /// Base64 RFC-3501 constructor.
+    //*************************************************************************
+    ETL_CONSTEXPR14 base64_rfc3501_decoder()
+      : ibase64_decoder(etl::base64::character_set_3(), etl::base64::Padding::No_Padding, output_buffer, Buffer_Size, callback_type())
+      , output_buffer()
+    {
+    }
+
+    //*************************************************************************
+    /// Base64 RFC-3501 constructor.
+    //*************************************************************************
+    ETL_CONSTEXPR14 base64_rfc3501_decoder(callback_type callback_)
+      : ibase64_decoder(etl::base64::character_set_3(), etl::base64::Padding::No_Padding, output_buffer, Buffer_Size, callback_)
+      , output_buffer()
+    {
+    }
+
+    //*************************************************************************
+    /// Calculate the required output encode buffer size.
+    //*************************************************************************
+    ETL_NODISCARD
+    static
+      ETL_CONSTEXPR14 size_t safe_output_buffer_size(size_t input_length)
+    {
+      return ibase64_decoder::decoded_size_from_valid_input_length(input_length);
+    }
+
+  private:
+
+    /// The internal output buffer.
+    unsigned char output_buffer[Buffer_Size];
+  };
+
+  //*************************************************************************
+  /// Base64 RFC-4648 Decoder
+  //*************************************************************************
+  template <size_t Buffer_Size = etl::base64::Min_Decode_Buffer_Size>
+  class base64_rfc4648_decoder : public ibase64_decoder
+  {
+  public:
+
+    ETL_STATIC_ASSERT((Buffer_Size >= etl::base64::Min_Decode_Buffer_Size), "Buffer size must be greater than etl::base64::Min_Decode_Buffer_Size");
+
+    //*************************************************************************
+    /// Base64 RFC-4648 constructor.
+    //*************************************************************************
+    ETL_CONSTEXPR14 base64_rfc4648_decoder()
+      : ibase64_decoder(etl::base64::character_set_1(), etl::base64::Padding::No_Padding, output_buffer, Buffer_Size, callback_type())
+      , output_buffer()
+    {
+    }
+
+    //*************************************************************************
+    /// Base64 RFC-4648 constructor.
+    //*************************************************************************
+    ETL_CONSTEXPR14 base64_rfc4648_decoder(callback_type callback_)
+      : ibase64_decoder(etl::base64::character_set_1(), etl::base64::Padding::No_Padding, output_buffer, Buffer_Size, callback_)
+      , output_buffer()
+    {
+    }
+
+    //*************************************************************************
+    /// Calculate the required output encode buffer size.
+    //*************************************************************************
+    ETL_NODISCARD
+    static
+      ETL_CONSTEXPR14 size_t safe_output_buffer_size(size_t input_length)
+    {
+      return ibase64_decoder::decoded_size_from_valid_input_length(input_length);
+    }
+
+  private:
+
+    /// The internal output buffer.
+    unsigned char output_buffer[Buffer_Size];
+  };
+
+  //*************************************************************************
+  /// Base64 RFC-4648-Padding Decoder
+  //*************************************************************************
+  template <size_t Buffer_Size = etl::base64::Min_Decode_Buffer_Size>
+  class base64_rfc4648_padding_decoder : public ibase64_decoder
+  {
+  public:
+
+    ETL_STATIC_ASSERT((Buffer_Size >= etl::base64::Min_Decode_Buffer_Size), "Buffer size must be greater than etl::base64::Min_Decode_Buffer_Size");
+
+    //*************************************************************************
+    /// Base64 RFC-4648-Padding constructor.
+    //*************************************************************************
+    ETL_CONSTEXPR14 base64_rfc4648_padding_decoder()
+      : ibase64_decoder(etl::base64::character_set_1(), etl::base64::Padding::Use_Padding, output_buffer, Buffer_Size, callback_type())
+      , output_buffer()
+    {
+    }
+
+    //*************************************************************************
+    /// Base64 RFC-4648-Padding constructor.
+    //*************************************************************************
+    ETL_CONSTEXPR14 base64_rfc4648_padding_decoder(callback_type callback_)
+      : ibase64_decoder(etl::base64::character_set_1(), etl::base64::Padding::Use_Padding, output_buffer, Buffer_Size, callback_)
+      , output_buffer()
+    {
+    }
+
+    //*************************************************************************
+    /// Calculate the required output encode buffer size.
+    //*************************************************************************
+    ETL_NODISCARD
+    static
+      ETL_CONSTEXPR14 size_t safe_output_buffer_size(size_t input_length)
+    {
+      return ibase64_decoder::decoded_size_from_valid_input_length(input_length);
+    }
+
+  private:
+
+    /// The internal output buffer.
+    unsigned char output_buffer[Buffer_Size];
+  };
+
+  //*************************************************************************
+  /// Base64 RFC-4648-URL Decoder
+  //*************************************************************************
+  template <size_t Buffer_Size = etl::base64::Min_Decode_Buffer_Size>
+  class base64_rfc4648_url_decoder : public ibase64_decoder
+  {
+  public:
+
+    ETL_STATIC_ASSERT((Buffer_Size >= etl::base64::Min_Decode_Buffer_Size), "Buffer size must be greater than etl::base64::Min_Decode_Buffer_Size");
+
+    //*************************************************************************
+    /// Base64 RFC-4648-Padding constructor.
+    //*************************************************************************
+    ETL_CONSTEXPR14 base64_rfc4648_url_decoder()
+      : ibase64_decoder(etl::base64::character_set_2(), etl::base64::Padding::No_Padding, output_buffer, Buffer_Size, callback_type())
+      , output_buffer()
+    {
+    }
+
+    //*************************************************************************
+    /// Base64 RFC-4648-Padding constructor.
+    //*************************************************************************
+    ETL_CONSTEXPR14 base64_rfc4648_url_decoder(callback_type callback_)
+      : ibase64_decoder(etl::base64::character_set_2(), etl::base64::Padding::No_Padding, output_buffer, Buffer_Size, callback_)
+      , output_buffer()
+    {
+    }
+
+    //*************************************************************************
+    /// Calculate the required output encode buffer size.
+    //*************************************************************************
+    ETL_NODISCARD
+    static
+      ETL_CONSTEXPR14 size_t safe_output_buffer_size(size_t input_length)
+    {
+      return ibase64_decoder::decoded_size_from_valid_input_length(input_length);
+    }
+
+  private:
+
+    /// The internal output buffer.
+    unsigned char output_buffer[Buffer_Size];
+  };
+
+  //*************************************************************************
+  /// Base64 RFC-4648-URL-Padding Decoder
+  //*************************************************************************
+  template <size_t Buffer_Size = etl::base64::Min_Decode_Buffer_Size>
+  class base64_rfc4648_url_padding_decoder : public ibase64_decoder
+  {
+  public:
+
+    ETL_STATIC_ASSERT((Buffer_Size >= etl::base64::Min_Decode_Buffer_Size), "Buffer size must be greater than etl::base64::Min_Decode_Buffer_Size");
+
+    //*************************************************************************
+    /// Base64 RFC-4648-Padding constructor.
+    //*************************************************************************
+    ETL_CONSTEXPR14 base64_rfc4648_url_padding_decoder()
+      : ibase64_decoder(etl::base64::character_set_2(), etl::base64::Padding::Use_Padding, output_buffer, Buffer_Size, callback_type())
+      , output_buffer()
+    {
+    }
+
+    //*************************************************************************
+    /// Base64 RFC-4648-Padding constructor.
+    //*************************************************************************
+    ETL_CONSTEXPR14 base64_rfc4648_url_padding_decoder(callback_type callback_)
+      : ibase64_decoder(etl::base64::character_set_2(), etl::base64::Padding::Use_Padding, output_buffer, Buffer_Size, callback_)
+      , output_buffer()
+    {
+    }
+
+    //*************************************************************************
+    /// Calculate the required output encode buffer size.
+    //*************************************************************************
+    ETL_NODISCARD
+    static
+      ETL_CONSTEXPR14 size_t safe_output_buffer_size(size_t input_length)
+    {
+      return ibase64_decoder::decoded_size_from_valid_input_length(input_length);
+    }
+
+  private:
+
+    /// The internal output buffer.
+    unsigned char output_buffer[Buffer_Size];
+  };
+} // namespace etl
+
+#undef ETL_IS_TYPE_8_BIT_INTEGRAL
+#undef ETL_IS_ITERATOR_TYPE_8_BIT_INTEGRAL
+
+#endif

include/etl/base64_encoder.h

@@ -0,0 +1,752 @@
+//*************************************************************************
+/// Decode from Base64 from and to pointer/length
+//*************************************************************************///\file
+
+/******************************************************************************
+The MIT License(MIT)
+Embedded Template Library.
+https://github.com/ETLCPP/etl
+https://www.etlcpp.com
+Copyright(c) 2024 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.
+******************************************************************************/
+
+#ifndef ETL_BASE64_ENCODER_INCLUDED
+#define ETL_BASE64_ENCODER_INCLUDED
+
+#include "platform.h"
+#include "algorithm.h"
+#include "binary.h"
+#include "delegate.h"
+#include "enum_type.h"
+#include "error_handler.h"
+#include "integral_limits.h"
+#include "iterator.h"
+#include "span.h"
+#include "static_assert.h"
+#include "type_traits.h"
+
+#include "base64.h"
+
+#include <stdint.h>
+
+#if ETL_USING_STL
+  #include <iterator>
+#endif
+
+#define ETL_IS_8_BIT_INTEGRAL(Type) \
+  (etl::is_integral<typename etl::remove_cv<Type>::type>::value && (etl::integral_limits<typename etl::remove_cv<Type>::type>::bits == 8U))
+
+#define ETL_IS_ITERATOR_TYPE_8_BIT_INTEGRAL(Type)                                                            \
+  (etl::is_integral< typename etl::iterator_traits< typename etl::remove_cv<Type>::type>::value_type>::value \
+   && (etl::integral_limits< typename etl::iterator_traits< typename etl::remove_cv<Type>::type>::value_type>::bits == 8U))
+
+namespace etl
+{
+  //*************************************************************************
+  /// Base64 Encoder
+  //*************************************************************************
+  class ibase64_encoder : public base64
+  {
+  public:
+
+    typedef etl::span<const char>                 span_type;
+    typedef etl::delegate<void(const span_type&)> callback_type;
+
+    //*************************************************************************
+    /// Encode to Base64
+    //*************************************************************************
+    template <typename T>
+    ETL_CONSTEXPR14 bool encode(T value)
+    {
+      ETL_STATIC_ASSERT(ETL_IS_8_BIT_INTEGRAL(T), "Input type must be an 8 bit integral");
+
+      push_to_input_buffer(value);
+
+      if (input_buffer_is_full())
+      {
+        encode_block();
+        reset_input_buffer();
+
+        if (callback.is_valid())
+        {
+          if (output_buffer_is_full())
+          {
+            callback(span());
+            reset_output_buffer();
+          }
+        }
+      }
+
+      return !error();
+    }
+
+    //*************************************************************************
+    /// Encode to Base64
+    //*************************************************************************
+    template <typename TInputIterator>
+    ETL_CONSTEXPR14 bool encode(TInputIterator input_begin, size_t input_length)
+    {
+      ETL_STATIC_ASSERT(ETL_IS_ITERATOR_TYPE_8_BIT_INTEGRAL(TInputIterator), "Input type must be an 8 bit integral");
+
+      while (input_length-- != 0)
+      {
+        if (!encode(*input_begin++))
+        {
+          return false;
+        }
+      }
+
+      return true;
+    }
+
+    //*************************************************************************
+    /// Encode to Base64
+    //*************************************************************************
+    template <typename TInputIterator>
+    ETL_CONSTEXPR14 bool encode(TInputIterator input_begin, TInputIterator input_end)
+    {
+      ETL_STATIC_ASSERT(ETL_IS_ITERATOR_TYPE_8_BIT_INTEGRAL(TInputIterator), "Input type must be an 8 bit integral");
+
+      while (input_begin != input_end)
+      {
+        if (!encode(*input_begin++))
+        {
+          return false;
+        }
+      }
+
+      return true;
+    }
+
+    //*************************************************************************
+    /// Encode to Base64
+    //*************************************************************************
+    template <typename TInputIterator>
+    ETL_CONSTEXPR14 bool encode_final(TInputIterator input_begin, size_t input_length)
+    {
+      return encode(input_begin, input_length) && flush();
+    }
+
+    //*************************************************************************
+    /// Encode to Base64
+    //*************************************************************************
+    template <typename TInputIterator>
+    ETL_CONSTEXPR14 bool encode_final(TInputIterator input_begin, TInputIterator input_end)
+    {
+      return encode(input_begin, input_end) && flush();
+    }
+
+    //*************************************************************************
+    /// Flush any remaining data to the output.
+    //*************************************************************************
+    ETL_CONSTEXPR14 bool flush()
+    {
+      // Encode any remaining input data.
+      bool success = encode_block();
+
+      reset_input_buffer();
+
+      if (success)
+      {
+        if (callback.is_valid())
+        {
+          // Send any remaining data.
+          if (size() != 0)
+          {
+            callback(span());
+          }
+
+          // Indicate this was the final block.
+          callback(span_type());
+
+          reset_output_buffer();
+        }
+      }
+
+      return success;
+    }
+
+    //*************************************************************************
+    /// Reset the encoder.
+    //*************************************************************************
+    ETL_CONSTEXPR14 void restart()
+    {
+      reset_input_buffer();
+      reset_output_buffer();
+    }
+
+    //*************************************************************************
+    /// Returns the beginning of the output buffer.
+    //*************************************************************************
+    ETL_NODISCARD ETL_CONSTEXPR14 const char* begin() const
+    {
+      return p_output_buffer;
+    }
+
+    //*************************************************************************
+    /// This only returns a useful value if a callback has not been set or
+    /// called.
+    //*************************************************************************
+    ETL_NODISCARD ETL_CONSTEXPR14 const char* end() const
+    {
+      return p_output_buffer + output_buffer_length;
+    }
+
+    //*************************************************************************
+    /// Returns the beginning of the output buffer.
+    //*************************************************************************
+    ETL_NODISCARD ETL_CONSTEXPR14 const char* cbegin() const
+    {
+      return p_output_buffer;
+    }
+
+    //*************************************************************************
+    /// This only returns a useful value if a callback has not been set or
+    /// called.
+    //*************************************************************************
+    ETL_NODISCARD ETL_CONSTEXPR14 const char* cend() const
+    {
+      return p_output_buffer + output_buffer_length;
+    }
+
+    //*************************************************************************
+    /// Returns the size of the output buffer.
+    /// This only returns a useful value if a callback has not been set or
+    /// called.
+    //*************************************************************************
+    ETL_NODISCARD ETL_CONSTEXPR14 size_t size() const
+    {
+      return output_buffer_length;
+    }
+
+    //*************************************************************************
+    /// Returns the maximum size of the output buffer.
+    //*************************************************************************
+    ETL_NODISCARD ETL_CONSTEXPR14 size_t max_size() const
+    {
+      return output_buffer_max_size;
+    }
+
+    //*************************************************************************
+    /// Get a span of the output data.
+    /// This only returns a useful span if a callback has not been set or
+    /// called.
+    //*************************************************************************
+    ETL_NODISCARD ETL_CONSTEXPR14 span_type span() const
+    {
+      return span_type(begin(), end());
+    }
+
+    //*************************************************************************
+    /// Returns true if the output buffer has overflowed
+    //*************************************************************************
+    ETL_NODISCARD ETL_CONSTEXPR14 bool overflow() const
+    {
+      return overflowed;
+    }
+
+    //*************************************************************************
+    /// Returns true if an error was detected.
+    //*************************************************************************
+    ETL_NODISCARD ETL_CONSTEXPR14 bool error() const
+    {
+      return overflow();
+    }
+
+  protected:
+
+    //*************************************************************************
+    /// Constructor
+    //*************************************************************************
+    ETL_CONSTEXPR14 ibase64_encoder(const char* encoder_table_, bool use_padding_, char* p_output_buffer_, size_t ouput_buffer_max_size_,
+                              callback_type callback_)
+      : base64(encoder_table_, use_padding_)
+      , input_buffer()
+      , input_buffer_length(0)
+      , p_output_buffer(p_output_buffer_)
+      , output_buffer_length(0)
+      , output_buffer_max_size(ouput_buffer_max_size_)
+      , callback(callback_)
+      , overflowed(false)
+    {
+    }
+
+    //*************************************************************************
+    /// Encode one block of data.
+    //*************************************************************************
+    ETL_CONSTEXPR14 bool encode_block()
+    {
+      switch (input_buffer_length)
+      {
+        // Only triggered on call to flush().
+        case 1:
+          {
+            uint32_t octets = input_buffer[0];
+            octets          = octets << 4; // Adjust one octet (8 bits) for two sextets
+                                           // worth of data (12 bits)
+
+            // Write out two sextets + optional padding.
+            push_to_output_buffer(encoder_table[(octets >> 6) & 0x3F]);
+            push_to_output_buffer(encoder_table[(octets >> 0) & 0x3F]);
+
+            if (use_padding)
+            {
+              push_to_output_buffer('=');
+              push_to_output_buffer('=');
+            }
+            break;
+          }
+
+        // Only triggered on call to flush().
+        case 2:
+          {
+            uint32_t octets = (static_cast<uint32_t>(input_buffer[0]) << 8) | input_buffer[1];
+            octets <<= 2; // Adjust two octets (16 bits) for three sextets worth
+                          // of data (18 bits)
+
+            // Write out three sextets + optional padding.
+            push_to_output_buffer(encoder_table[(octets >> 12) & 0x3F]);
+            push_to_output_buffer(encoder_table[(octets >> 6) & 0x3F]);
+            push_to_output_buffer(encoder_table[(octets >> 0) & 0x3F]);
+
+            if (use_padding)
+            {
+              push_to_output_buffer('=');
+            }
+            break;
+          }
+
+        // Only triggered on call to encode().
+        case 3:
+          {
+            uint32_t octets = (static_cast<uint32_t>(input_buffer[0]) << 16) | (static_cast<uint32_t>(input_buffer[1]) << 8) | input_buffer[2];
+
+            // Write out four sextets
+            push_to_output_buffer(encoder_table[(octets >> 18) & 0x3F]);
+            push_to_output_buffer(encoder_table[(octets >> 12) & 0x3F]);
+            push_to_output_buffer(encoder_table[(octets >> 6) & 0x3F]);
+            push_to_output_buffer(encoder_table[(octets >> 0) & 0x3F]);
+            break;
+          }
+
+        default:
+          {
+            break;
+          }
+      }
+
+      ETL_ASSERT(!overflowed, ETL_ERROR(etl::base64_overflow));
+
+      return !overflowed;
+    }
+
+    //*************************************************************************
+    /// Calculates the minimum buffer size required to encode to Base64
+    //*************************************************************************
+    ETL_NODISCARD
+    static
+      ETL_CONSTEXPR14 size_t encoded_size(size_t input_length, bool use_padding)
+    {
+      size_t required_output_length = 0;
+
+      if (input_length == 0U)
+      {
+        return 0U;
+      }
+
+      if (use_padding)
+      {
+        required_output_length = (input_length * 4U) / 3U;
+
+        while ((required_output_length % 4U) != 0)
+        {
+          ++required_output_length;
+        }
+      }
+      else
+      {
+        required_output_length = input_length + (((input_length - 1U) / 3U) + 1U);
+      }
+
+      while (required_output_length % 4)
+      {
+        ++required_output_length;
+      }
+
+      return required_output_length;
+    }
+
+  private:
+
+    //*************************************************************************
+    // Push to the output buffer.
+    //*************************************************************************
+    ETL_CONSTEXPR14 void push_to_output_buffer(char c)
+    {
+      if (output_buffer_length < output_buffer_max_size)
+      {
+        p_output_buffer[output_buffer_length++] = c;
+      }
+      else
+      {
+        overflowed = true;
+      }
+    }
+
+    //*************************************************************************
+    //
+    //*************************************************************************
+    ETL_CONSTEXPR14 bool output_buffer_is_full() const
+    {
+      return output_buffer_length == output_buffer_max_size;
+    }
+
+    //*************************************************************************
+    //
+    //*************************************************************************
+    ETL_CONSTEXPR14 bool output_buffer_is_empty() const
+    {
+      return output_buffer_length == 0;
+    }
+
+    //*************************************************************************
+    //
+    //*************************************************************************
+    ETL_CONSTEXPR14 void reset_output_buffer()
+    {
+      output_buffer_length = 0;
+    }
+
+    //*************************************************************************
+    // Push to the input buffer.
+    //*************************************************************************
+    template <typename T>
+    ETL_CONSTEXPR14 void push_to_input_buffer(T value)
+    {
+      input_buffer[input_buffer_length++] = static_cast<uint8_t>(value);
+    }
+
+    //*************************************************************************
+    //
+    //*************************************************************************
+    ETL_CONSTEXPR14 bool input_buffer_is_full() const
+    {
+      return input_buffer_length == 3U;
+    }
+
+    //*************************************************************************
+    //
+    //*************************************************************************
+    ETL_CONSTEXPR14 void reset_input_buffer()
+    {
+      input_buffer_length = 0;
+    }
+
+    uint8_t input_buffer[3];
+    size_t  input_buffer_length;
+
+    char*        p_output_buffer;
+    size_t       output_buffer_length;
+    const size_t output_buffer_max_size;
+
+    callback_type callback;
+
+    bool overflowed;
+  };
+
+  //*************************************************************************
+  /// Base64 RFC-2152 Encoder
+  //*************************************************************************
+  template <size_t Buffer_Size = etl::base64::Min_Encode_Buffer_Size>
+  class base64_rfc2152_encoder : public ibase64_encoder
+  {
+  public:
+
+    ETL_STATIC_ASSERT((Buffer_Size >= etl::base64::Min_Encode_Buffer_Size), "Buffer size must be greater than etl::base64::Min_Encode_Buffer_Size");
+    ETL_STATIC_ASSERT(((Buffer_Size % etl::base64::Min_Encode_Buffer_Size) == 0),
+                      "Buffer size must be a multiple of etl::base64::Min_Encode_Buffer_Size");
+
+    //*************************************************************************
+    /// Base64 RFC-2152 constructor.
+    //*************************************************************************
+    ETL_CONSTEXPR14 base64_rfc2152_encoder()
+      : ibase64_encoder(etl::base64::character_set_1(), etl::base64::Padding::No_Padding, output_buffer, Buffer_Size, callback_type())
+      , output_buffer()
+    {
+    }
+
+    //*************************************************************************
+    /// Base64 RFC-2152 constructor.
+    //*************************************************************************
+    ETL_CONSTEXPR14 base64_rfc2152_encoder(callback_type callback_)
+      : ibase64_encoder(etl::base64::character_set_1(), etl::base64::Padding::No_Padding, output_buffer, Buffer_Size, callback_)
+      , output_buffer()
+    {
+    }
+
+    //*************************************************************************
+    /// Calculate the required output encode buffer size.
+    //*************************************************************************
+    ETL_NODISCARD
+    static
+      ETL_CONSTEXPR14 size_t safe_output_buffer_size(size_t input_length)
+    {
+      return ibase64_encoder::encoded_size(input_length, etl::base64::Padding::No_Padding);
+    }
+
+  private:
+
+    /// The internal output buffer.
+    char output_buffer[Buffer_Size];
+  };
+
+  //*************************************************************************
+  /// Base64 RFC-3501 Encoder
+  //*************************************************************************
+  template <size_t Buffer_Size = etl::base64::Min_Encode_Buffer_Size>
+  class base64_rfc3501_encoder : public ibase64_encoder
+  {
+  public:
+
+    ETL_STATIC_ASSERT((Buffer_Size >= etl::base64::Min_Encode_Buffer_Size), "Buffer size must be greater than etl::base64::Min_Encode_Buffer_Size");
+    ETL_STATIC_ASSERT(((Buffer_Size % etl::base64::Min_Encode_Buffer_Size) == 0),
+                      "Buffer size must be a multiple of etl::base64::Min_Encode_Buffer_Size");
+
+    //*************************************************************************
+    /// Base64 RFC-3501 constructor.
+    //*************************************************************************
+    ETL_CONSTEXPR14 base64_rfc3501_encoder()
+      : ibase64_encoder(etl::base64::character_set_3(), etl::base64::Padding::No_Padding, output_buffer, Buffer_Size, callback_type())
+      , output_buffer()
+    {
+    }
+
+    //*************************************************************************
+    /// Base64 RFC-3501 constructor.
+    //*************************************************************************
+    ETL_CONSTEXPR14 base64_rfc3501_encoder(callback_type callback_)
+      : ibase64_encoder(etl::base64::character_set_3(), etl::base64::Padding::No_Padding, output_buffer, Buffer_Size, callback_)
+      , output_buffer()
+    {
+    }
+
+    //*************************************************************************
+    /// Calculate the required output encode buffer size.
+    //*************************************************************************
+    ETL_NODISCARD
+    static
+      ETL_CONSTEXPR14 size_t safe_output_buffer_size(size_t input_length)
+    {
+      return ibase64_encoder::encoded_size(input_length, etl::base64::Padding::No_Padding);
+    }
+
+  private:
+
+    /// The internal output buffer.
+    char output_buffer[Buffer_Size];
+  };
+
+  //*************************************************************************
+  /// Base64 RFC-4648 Encoder
+  //*************************************************************************
+  template <size_t Buffer_Size = etl::base64::Min_Encode_Buffer_Size>
+  class base64_rfc4648_encoder : public ibase64_encoder
+  {
+  public:
+
+    ETL_STATIC_ASSERT((Buffer_Size >= etl::base64::Min_Encode_Buffer_Size), "Buffer size must be greater than etl::base64::Min_Encode_Buffer_Size");
+    ETL_STATIC_ASSERT(((Buffer_Size % etl::base64::Min_Encode_Buffer_Size) == 0),
+                      "Buffer size must be a multiple of etl::base64::Min_Encode_Buffer_Size");
+
+    //*************************************************************************
+    /// Base64 RFC-4648 constructor.
+    //*************************************************************************
+    ETL_CONSTEXPR14 base64_rfc4648_encoder()
+      : ibase64_encoder(etl::base64::character_set_1(), etl::base64::Padding::No_Padding, output_buffer, Buffer_Size, callback_type())
+      , output_buffer()
+    {
+    }
+
+    //*************************************************************************
+    /// Base64 RFC-4648 constructor.
+    //*************************************************************************
+    ETL_CONSTEXPR14 base64_rfc4648_encoder(callback_type callback_)
+      : ibase64_encoder(etl::base64::character_set_1(), etl::base64::Padding::No_Padding, output_buffer, Buffer_Size, callback_)
+      , output_buffer()
+    {
+    }
+
+    //*************************************************************************
+    /// Calculate the required output encode buffer size.
+    //*************************************************************************
+    ETL_NODISCARD
+    static
+      ETL_CONSTEXPR14 size_t safe_output_buffer_size(size_t input_length)
+    {
+      return ibase64_encoder::encoded_size(input_length, etl::base64::Padding::No_Padding);
+    }
+
+  private:
+
+    /// The internal output buffer.
+    char output_buffer[Buffer_Size];
+  };
+
+  //*************************************************************************
+  /// Base64 RFC-4648-Padding Encoder
+  //*************************************************************************
+  template <size_t Buffer_Size = etl::base64::Min_Encode_Buffer_Size>
+  class base64_rfc4648_padding_encoder : public ibase64_encoder
+  {
+  public:
+
+    ETL_STATIC_ASSERT((Buffer_Size >= etl::base64::Min_Encode_Buffer_Size), "Buffer size must be greater than etl::base64::Min_Encode_Buffer_Size");
+    ETL_STATIC_ASSERT(((Buffer_Size % etl::base64::Min_Encode_Buffer_Size) == 0),
+                      "Buffer size must be a multiple of etl::base64::Min_Encode_Buffer_Size");
+
+    //*************************************************************************
+    /// Base64 RFC-4648-Padding constructor.
+    //*************************************************************************
+    ETL_CONSTEXPR14 base64_rfc4648_padding_encoder()
+      : ibase64_encoder(etl::base64::character_set_1(), etl::base64::Padding::Use_Padding, output_buffer, Buffer_Size, callback_type())
+      , output_buffer()
+    {
+    }
+
+    //*************************************************************************
+    /// Base64 RFC-4648-Padding constructor.
+    //*************************************************************************
+    ETL_CONSTEXPR14 base64_rfc4648_padding_encoder(callback_type callback_)
+      : ibase64_encoder(etl::base64::character_set_1(), etl::base64::Padding::Use_Padding, output_buffer, Buffer_Size, callback_)
+      , output_buffer()
+    {
+    }
+
+    //*************************************************************************
+    /// Calculate the required output encode buffer size.
+    //*************************************************************************
+    ETL_NODISCARD
+    static
+      ETL_CONSTEXPR14 size_t safe_output_buffer_size(size_t input_length)
+    {
+      return ibase64_encoder::encoded_size(input_length, etl::base64::Padding::Use_Padding);
+    }
+
+  private:
+
+    /// The internal output buffer.
+    char output_buffer[Buffer_Size];
+  };
+
+  //*************************************************************************
+  /// Base64 RFC-4648-URL Encoder
+  //*************************************************************************
+  template <size_t Buffer_Size = etl::base64::Min_Encode_Buffer_Size>
+  class base64_rfc4648_url_encoder : public ibase64_encoder
+  {
+  public:
+
+    ETL_STATIC_ASSERT((Buffer_Size >= etl::base64::Min_Encode_Buffer_Size), "Buffer size must be greater than etl::base64::Min_Encode_Buffer_Size");
+    ETL_STATIC_ASSERT(((Buffer_Size % etl::base64::Min_Encode_Buffer_Size) == 0),
+                      "Buffer size must be a multiple of etl::base64::Min_Encode_Buffer_Size");
+
+    //*************************************************************************
+    /// Base64 RFC-4648-URL constructor.
+    //*************************************************************************
+    ETL_CONSTEXPR14 base64_rfc4648_url_encoder()
+      : ibase64_encoder(etl::base64::character_set_2(), etl::base64::Padding::No_Padding, output_buffer, Buffer_Size, callback_type())
+      , output_buffer()
+    {
+    }
+
+    //*************************************************************************
+    /// Base64 RFC-4648-URL constructor.
+    //*************************************************************************
+    ETL_CONSTEXPR14 base64_rfc4648_url_encoder(callback_type callback_)
+      : ibase64_encoder(etl::base64::character_set_2(), etl::base64::Padding::No_Padding, output_buffer, Buffer_Size, callback_)
+      , output_buffer()
+    {
+    }
+
+    //*************************************************************************
+    /// Calculate the required output encode buffer size.
+    //*************************************************************************
+    ETL_NODISCARD
+    static
+      ETL_CONSTEXPR14 size_t safe_output_buffer_size(size_t input_length)
+    {
+      return ibase64_encoder::encoded_size(input_length, etl::base64::Padding::No_Padding);
+    }
+
+  private:
+
+    /// The internal output buffer.
+    char output_buffer[Buffer_Size];
+  };
+
+  //*************************************************************************
+  /// Base64 RFC-4648-URL_Padding Encoder
+  //*************************************************************************
+  template <size_t Buffer_Size = etl::base64::Min_Encode_Buffer_Size>
+  class base64_rfc4648_url_padding_encoder : public ibase64_encoder
+  {
+  public:
+
+    ETL_STATIC_ASSERT((Buffer_Size >= etl::base64::Min_Encode_Buffer_Size), "Buffer size must be greater than etl::base64::Min_Encode_Buffer_Size");
+    ETL_STATIC_ASSERT(((Buffer_Size % etl::base64::Min_Encode_Buffer_Size) == 0),
+                      "Buffer size must be a multiple of etl::base64::Min_Encode_Buffer_Size");
+
+    //*************************************************************************
+    /// Base64 RFC-4648-URL constructor.
+    //*************************************************************************
+    ETL_CONSTEXPR14 base64_rfc4648_url_padding_encoder()
+      : ibase64_encoder(etl::base64::character_set_2(), etl::base64::Padding::Use_Padding, output_buffer, Buffer_Size, callback_type())
+      , output_buffer()
+    {
+    }
+
+    //*************************************************************************
+    /// Base64 RFC-4648-URL constructor.
+    //*************************************************************************
+    ETL_CONSTEXPR14 base64_rfc4648_url_padding_encoder(callback_type callback_)
+      : ibase64_encoder(etl::base64::character_set_2(), etl::base64::Padding::Use_Padding, output_buffer, Buffer_Size, callback_)
+      , output_buffer()
+    {
+    }
+
+    //*************************************************************************
+    /// Calculate the required output encode buffer size.
+    //*************************************************************************
+    ETL_NODISCARD
+    static
+      ETL_CONSTEXPR14 size_t safe_output_buffer_size(size_t input_length)
+    {
+      return ibase64_encoder::encoded_size(input_length, etl::base64::Padding::Use_Padding);
+    }
+
+  private:
+
+    /// The internal output buffer.
+    char output_buffer[Buffer_Size];
+  };
+} // namespace etl
+
+#undef ETL_IS_TYPE_8_BIT_INTEGRAL
+#undef ETL_IS_ITERATOR_TYPE_8_BIT_INTEGRAL
+
+#endif